fix edge cases

.dockerignore

@@ -1,11 +0,0 @@
-**/node_modules
-**/.angular
-**/dist
-.astro/
-.forgejo/
-.idea/
-.vscode/
-test/
-.gitignore
-Dockerfile
-.dockerignore

.forgejo/workflows/deploy-hot.yml

@@ -1,44 +0,0 @@
-name: Build and Deploy hot PRs
-
-on:
-  pull_request_target:
-    types: [labeled]
-
-# Allow one concurrent deployment
-concurrency:
-  group: "warm-pages"
-  cancel-in-progress: false
-
-jobs:
-  build:
-    if: ${{ github.event.label.name == 'serve-hot' }}
-    runs-on: docker
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.pull_request.head.sha }}      
-      - uses: pnpm/action-setup@v4
-        with:
-          version: 9.12.2
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-
-      - name: Install Dependencies
-        run: pnpm install
-
-      - name: Build
-        run: pnpm build
-
-      - name: Deploy
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.SSH_PRIVATE_KEY }}
-        run: |
-          eval $(ssh-agent -s)
-          echo "$SSH_PRIVATE_KEY" | ssh-add -
-          apt update && apt install -y rsync
-          mkdir -p ~/.ssh
-          ssh-keyscan matrix.toplap.org > ~/.ssh/known_hosts
-          rsync -atv --delete --delete-after --progress \
-            ./website/dist/ \
-            strudel@matrix.toplap.org:/home/strudel/deploy/pr-${{ github.event.pull_request.number }}.hot.strudel.cc

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

@@ -1,4 +1,4 @@
-name: Build and Deploy to warm (strudel.cc)
+name: Build and Deploy to beta (warm.strudel.cc)
 
 on:
   push:
@@ -37,4 +37,4 @@ jobs:
           apt update && apt install -y rsync
           mkdir ~/.ssh
           ssh-keyscan matrix.toplap.org  > ~/.ssh/known_hosts
-          rsync -atv --delete --delete-after --progress ./website/dist/ strudel@matrix.toplap.org:/home/strudel/deploy/strudel.cc
+          rsync -atv --delete --delete-after --progress ./website/dist/ strudel@matrix.toplap.org:/home/strudel/deploy/warm.strudel.cc

.forgejo/workflows/deploy.yml

@@ -1,4 +1,4 @@
-name: Build and Deploy to cold (cold.strudel.cc)
+name: Build and Deploy to live (strudel.cc)
 
 on: [workflow_dispatch]
 
@@ -34,4 +34,4 @@ jobs:
           apt update && apt install -y rsync
           mkdir ~/.ssh
           ssh-keyscan matrix.toplap.org  > ~/.ssh/known_hosts
-          rsync -atv --delete --delete-after --progress ./website/dist/ strudel@matrix.toplap.org:/home/strudel/deploy/cold.strudel.cc
+          rsync -atv --delete --delete-after --progress ./website/dist/ strudel@matrix.toplap.org:/home/strudel/deploy/strudel.cc

CONTRIBUTING.md

@@ -52,17 +52,7 @@ Strudel is a project handmade by humans, with thought and nuance.
 
 If you have used LLMs (so called 'AI'), please detail that in the pull request. We are still developing our response to the onslaught of LLM technology, but for practical and legal reasons are currently not accepting wholly LLM-generated code. We are also not accepting PRs that add LLM features to strudel itself.
 
-There are #llm-chat and #llm-share channels on [our discord](https://discord.com/invite/HGEdXmRkzT). Please do not discuss or share LLM-related things outside of those channels.
-
-## Creating and sharing a new project using strudel
-
-Strudel is free/open source software, and we are also happy to see people making use of it within the following terms. 
-
-Please don't use 'strudel' in the name of your project, so people don't assume it's official strudel project. (If you'd like it to be an official strudel project, please check in with the community, e.g. on [the discord](https://discord.com/invite/HGEdXmRkzT).) 
-
-Please respect our AGPL license, which e.g. requires you to share/link to the source code of strudel, any modifications you've made to it, and the source code for the rest of your project if it integrates with strudel. You are also required to maintain Strudel's copyright notices in the source code, and include Strudel's copyright notice in your user interface. This is an ad-hoc summary - please [refer to the license](https://codeberg.org/uzu/strudel/src/branch/main/LICENSE) for full details.
-
-You are also encouraged to connect with the community and understand our aims and values.
+There are #llm-chat and #llm-share channels on our discord. Please do not discuss or share LLM-related things outside of those channels.
 
 ## Report a Bug
 

examples/codemirror-repl/main.js

@@ -29,7 +29,6 @@ const editor = new StrudelMirror({
       import('@strudel/core'),
       import('@strudel/draw'),
       import('@strudel/mini'),
-      import('@strudel/edo'),
       import('@strudel/tonal'),
       import('@strudel/webaudio'),
     );

examples/codemirror-repl/package.json

@@ -15,7 +15,6 @@
     "@strudel/codemirror": "workspace:*",
     "@strudel/core": "workspace:*",
     "@strudel/draw": "workspace:*",
-    "@strudel/edo": "workspace:*",
     "@strudel/mini": "workspace:*",
     "@strudel/soundfonts": "workspace:*",
     "@strudel/tonal": "workspace:*",

index.mjs

@@ -4,7 +4,6 @@ export * from './packages/core/index.mjs';
 export * from './packages/csound/index.mjs';
 export * from './packages/desktopbridge/index.mjs';
 export * from './packages/draw/index.mjs';
-export * from './packages/edo/index.mjs';
 export * from './packages/embed/index.mjs';
 export * from './packages/hydra/index.mjs';
 export * from './packages/midi/index.mjs';

package.json

@@ -48,7 +48,6 @@
   "homepage": "https://strudel.cc",
   "dependencies": {
     "@strudel/core": "workspace:*",
-    "@strudel/edo": "workspace:*",
     "@strudel/mini": "workspace:*",
     "@strudel/tonal": "workspace:*",
     "@strudel/transpiler": "workspace:*",

packages/codemirror/block_utilities.mjs

@@ -1,51 +0,0 @@
-// Block-based evaluation utilities
-
-export function getBlockRegions(code) {
-  const chars = code.split('');
-  let i = 0,
-    blanks = [],
-    blockStart = 0,
-    regions = [];
-  while (i < chars.length) {
-    const isBlank = chars[i] === '\n';
-    if (isBlank) {
-      blanks.push(i);
-    } else if (chars[i].trim() !== '') {
-      if (blanks.length > 1) {
-        regions.push([blockStart, blanks[0]]);
-        blockStart = i;
-      }
-      blanks = [];
-    }
-    i++;
-  }
-  regions.push([blockStart, blanks.length ? blanks[0] : i]);
-  return regions;
-}
-
-export function getBlockAt(code, cursor) {
-  const regions = getBlockRegions(code);
-  for (const [start, end] of regions) {
-    if (cursor >= start && cursor <= end) {
-      return [start, end];
-    }
-  }
-  return null;
-}
-
-export const evalBlock = (strudelMirror) => {
-  const { state } = strudelMirror.editor;
-  const code = state.doc.toString();
-  const cursor = state.selection.main.head;
-  const range = getBlockAt(code, cursor);
-  if (range) {
-    const [a, b] = range;
-    const block = code.slice(a, b);
-    if (block) {
-      // Flash the block being evaluated
-      strudelMirror.flash(200, { from: a, to: b });
-      strudelMirror.repl.evaluateBlock(block, true, { range });
-    }
-  }
-  return true;
-};

packages/codemirror/codemirror.mjs

@@ -13,18 +13,23 @@ import {
 } from '@codemirror/view';
 import { persistentAtom } from '@nanostores/persistent';
 import { logger, registerControl, repl } from '@strudel/core';
-import { cleanupDraw, cleanupDrawContext, Drawer } from '@strudel/draw';
+import { cleanupDraw, Drawer } from '@strudel/draw';
+
 import { isAutoCompletionEnabled } from './autocomplete.mjs';
 import { basicSetup } from './basicSetup.mjs';
-import { evalBlock } from './block_utilities.mjs';
 import { flash, isFlashEnabled } from './flash.mjs';
 import { highlightMiniLocations, isPatternHighlightingEnabled, updateMiniLocations } from './highlight.mjs';
 import { keybindings } from './keybindings.mjs';
-import { jumpToCharacter } from './labelJump.mjs';
-import { getSliderWidgets, sliderPlugin, updateSliderWidgets } from './slider.mjs';
+import { sliderPlugin, updateSliderWidgets } from './slider.mjs';
 import { activateTheme, initTheme, theme } from './themes.mjs';
 import { isTooltipEnabled } from './tooltip.mjs';
-import { getActiveWidgets, updateWidgets, widgetPlugin } from './widget.mjs';
+import { updateWidgets, widgetPlugin } from './widget.mjs';
+import {
+  deleteAllInlineBeforeCharacter,
+  InsertCharBeforeChar,
+  jumpToCharacter,
+  jumpToNextCharacter,
+} from './labelJump.mjs';
 
 export { toggleBlockComment, toggleBlockCommentByLine, toggleComment, toggleLineComment } from '@codemirror/commands';
 
@@ -64,7 +69,6 @@ export const defaultSettings = {
   isLineWrappingEnabled: false,
   isTabIndentationEnabled: false,
   isMultiCursorEnabled: false,
-  isBlockBasedEvalEnabled: false,
   theme: 'strudelTheme',
   fontFamily: 'monospace',
   fontSize: 18,
@@ -75,8 +79,12 @@ export const codemirrorSettings = persistentAtom('codemirror-settings', defaultS
   decode: JSON.parse,
 });
 
+const ANON_LABEL = '$';
+const SOLO_LABEL = 'S';
+const MUTE_LABEL = '_';
+
 // https://codemirror.net/docs/guide/
-export function initEditor({ initialCode = '', onChange, onEvaluate, onStop, root, mondo, strudelMirror }) {
+export function initEditor({ initialCode = '', onChange, onEvaluate, onStop, root, mondo }) {
   const settings = codemirrorSettings.get();
   const initialSettings = Object.keys(compartments).map((key) =>
     compartments[key].of(extensions[key](parseBooleans(settings[key]))),
@@ -106,26 +114,11 @@ export function initEditor({ initialCode = '', onChange, onEvaluate, onStop, roo
         keymap.of([
           {
             key: 'Ctrl-Enter',
-            run: () => {
-              // issue with referencing settings, this works more reliably
-              if (strudelMirror?.isBlockBasedEvalEnabled) {
-                evalBlock(strudelMirror);
-                return true;
-              } else {
-                return onEvaluate?.();
-              }
-            },
+            run: () => onEvaluate?.(),
           },
           {
             key: 'Alt-Enter',
-            run: () => {
-              if (strudelMirror?.isBlockBasedEvalEnabled) {
-                evalBlock(strudelMirror);
-                return true;
-              } else {
-                return onEvaluate?.();
-              }
-            },
+            run: () => onEvaluate?.(),
           },
           {
             key: 'Ctrl-.',
@@ -138,12 +131,75 @@ export function initEditor({ initialCode = '', onChange, onEvaluate, onStop, roo
           },
           {
             key: 'Alt-w',
-            run: (view) => jumpToCharacter(view, '$', 1),
+            run: (view) => jumpToNextCharacter(view, ANON_LABEL, 1),
           },
           {
             key: 'Alt-q',
-            run: (view) => jumpToCharacter(view, '$', -1),
+            run: (view) => {
+              return jumpToNextCharacter(view, ANON_LABEL, -1);
+            },
           },
+          // clear all muted
+          {
+            key: `Alt-Ctrl-0`,
+            run: (view) => {
+              return deleteAllInlineBeforeCharacter(view, MUTE_LABEL + ANON_LABEL);
+            },
+          },
+          // clear all solod
+          {
+            key: `Alt-Shift-0`,
+            run: (view) => {
+              return deleteAllInlineBeforeCharacter(view, SOLO_LABEL + ANON_LABEL);
+            },
+          },
+          // clear all solo and mute
+          {
+            key: `Ctrl-Shift-0`,
+            run: (view) => {
+              return deleteAllInlineBeforeCharacter(view, ANON_LABEL);
+            },
+          },
+          ...Array.from({ length: 9 }).map((_, i) => {
+            let num = i + 1;
+            return {
+              key: `Alt-${num}`,
+              run: (view) => {
+                return jumpToCharacter(view, ANON_LABEL, i);
+              },
+            };
+          }),
+          // handle solo toggles 1-9
+          ...Array.from({ length: 9 }).map((_, i) => {
+            let num = i + 1;
+            return {
+              key: `Alt-Shift-${num}`,
+              run: (view) => {
+                return InsertCharBeforeChar(view, ANON_LABEL, SOLO_LABEL, i);
+              },
+            };
+          }),
+          // handle mute toggles 1-9
+          ...Array.from({ length: 9 }).map((_, i) => {
+            let num = i + 1;
+            return {
+              key: `Alt-Ctrl-${num}`,
+              run: (view) => {
+                return InsertCharBeforeChar(view, ANON_LABEL, MUTE_LABEL, i);
+              },
+            };
+          }),
+          // Handle clearing mutes and solos 1-9
+          ...Array.from({ length: 9 }).map((_, i) => {
+            let num = i + 1;
+            return {
+              key: `Ctrl-Shift-${num}`,
+              run: (view) => {
+                return InsertCharBeforeChar(view, ANON_LABEL,'', i);
+              },
+            };
+          }),
+
           /* {
             key: 'Ctrl-Shift-.',
             run: () => (onPanic ? onPanic() : onStop?.()),
@@ -187,7 +243,6 @@ export class StrudelMirror {
     this.onDraw = onDraw || this.draw;
     this.id = id || s4();
     this.solo = solo;
-    this.isBlockBasedEvalEnabled = false; // Will be updated via updateSettings()
 
     this.drawer = new Drawer((haps, time, _, painters) => {
       const currentFrame = haps.filter((hap) => hap.isActive(time));
@@ -218,28 +273,20 @@ export class StrudelMirror {
           cleanupDraw(true, id);
         }
       },
-      beforeEval: async ({ blockBased } = {}) => {
-        // Only clean up all drawings for full evaluation
-        // Block-based eval should preserve animations (like .scope()) from other blocks
-        if (!blockBased) {
-          cleanupDraw(true, id);
-        }
+      beforeEval: async () => {
+        cleanupDraw(true, id);
         await this.prebaked;
         await replOptions?.beforeEval?.();
       },
       afterEval: (options) => {
         // remember for when highlighting is toggled on
-        this.miniLocations = options.meta?.miniLocations || [];
-        this.widgets = options.meta?.widgets || [];
-
+        this.miniLocations = options.meta?.miniLocations;
+        this.widgets = options.meta?.widgets;
         const sliders = this.widgets.filter((w) => w.type === 'slider');
+        updateSliderWidgets(this.editor, sliders);
         const widgets = this.widgets.filter((w) => w.type !== 'slider');
-        // range-aware update for block-based evaluation
-        const range = options.range && options.range.length >= 2 ? options.range : null;
-
-        updateSliderWidgets(this.editor, sliders, range);
-        updateWidgets(this.editor, widgets, range);
-        updateMiniLocations(this.editor, this.miniLocations, range);
+        updateWidgets(this.editor, widgets);
+        updateMiniLocations(this.editor, this.miniLocations);
         replOptions?.afterEval?.(options);
         // if no painters are set (.onPaint was not called), then we only need
         // the present moment (for highlighting)
@@ -247,14 +294,8 @@ export class StrudelMirror {
         this.drawer.setDrawTime(drawTime);
         // invalidate drawer after we've set the appropriate drawTime
         this.drawer.invalidate(this.repl.scheduler);
-
-        // Clean up draw context if a non-inline widget was removed
-        if (options.widgetRemoved) {
-          cleanupDrawContext(id);
-        }
       },
     });
-    this.cleanupDrawContext = () => cleanupDrawContext(id);
     this.editor = initEditor({
       root,
       initialCode,
@@ -267,9 +308,7 @@ export class StrudelMirror {
       onEvaluate: () => this.evaluate(),
       onStop: () => this.stop(),
       mondo: replOptions.mondo,
-      strudelMirror: this,
     });
-
     const cmEditor = this.root.querySelector('.cm-editor');
     if (cmEditor) {
       this.root.style.display = 'block';
@@ -293,9 +332,6 @@ export class StrudelMirror {
     // Handle global evaluation requests (e.g., from Vim :w)
     this.onEvaluateRequest = (e) => {
       try {
-        if (e.detail.view !== this.editor) {
-          return; // ignore events from other editors
-        }
         // Evaluate current editor on repl-evaluate
         logger('[repl] evaluate via event');
         this.evaluate();
@@ -310,9 +346,6 @@ export class StrudelMirror {
     // Toggle comments requested from Vim (gc)
     this.onToggleComment = (e) => {
       try {
-        if (e.detail.view !== this.editor) {
-          return; // ignore events from other editors
-        }
         // Honor selections; toggleLineComment handles both selections and
         // single line
         toggleLineComment(this.editor);
@@ -345,17 +378,13 @@ export class StrudelMirror {
     this.flash();
     await this.repl.evaluate(this.code, autostart);
   }
-
   async stop() {
-    this.repl.stop();
+    this.repl.scheduler.stop();
   }
 
   // Listen for global stop requests (e.g., from Vim :q)
   onStopRequest = (e) => {
     try {
-      if (e.detail.view !== this.editor) {
-        return; // ignore events from other editors
-      }
       this.stop();
       e?.cancelable && e.preventDefault?.();
     } catch (err) {
@@ -369,8 +398,8 @@ export class StrudelMirror {
       this.evaluate();
     }
   }
-  flash(ms, range) {
-    flash(this.editor, ms, range);
+  flash(ms) {
+    flash(this.editor, ms);
   }
   highlight(haps, time) {
     highlightMiniLocations(this.editor, time, haps);
@@ -402,10 +431,6 @@ export class StrudelMirror {
   setLineWrappingEnabled(enabled) {
     this.reconfigureExtension('isLineWrappingEnabled', enabled);
   }
-
-  setBlockBasedEvalEnabled(enabled) {
-    this.reconfigureExtension('isBlockBasedEvalEnabled', enabled);
-  }
   setBracketMatchingEnabled(enabled) {
     this.reconfigureExtension('isBracketMatchingEnabled', enabled);
   }
@@ -427,10 +452,6 @@ export class StrudelMirror {
     for (let key in extensions) {
       this.reconfigureExtension(key, settings[key]);
     }
-    // Update block-based eval setting on the instance
-    if (settings.isBlockBasedEvalEnabled !== undefined) {
-      this.isBlockBasedEvalEnabled = parseBooleans(settings.isBlockBasedEvalEnabled);
-    }
     const updated = { ...codemirrorSettings.get(), ...settings };
     codemirrorSettings.set(updated);
   }
@@ -444,25 +465,13 @@ export class StrudelMirror {
       this.setFontSize(value);
     }
   }
-  replaceCode(code, from, to) {
-    const changes = { from, to, insert: code };
-    this.editor.dispatch({ changes });
-  }
-  insertCode(code, position) {
-    this.replaceCode(code, position, position);
-  }
   setCode(code) {
-    this.replaceCode(code, 0, this.editor.state.doc.length);
-  }
-  // used for debugging but could serve other purposes
-  getActiveWidgets() {
-    return getActiveWidgets(this.editor);
-  }
-  getSliderWidgets() {
-    return getSliderWidgets(this.editor);
-  }
-  getMiniLocations() {
-    return this.miniLocations;
+    const changes = {
+      from: 0,
+      to: this.editor.state.doc.length,
+      insert: code,
+    };
+    this.editor.dispatch({ changes });
   }
   clear() {
     this.onStartRepl && document.removeEventListener('start-repl', this.onStartRepl);

packages/codemirror/flash.mjs

@@ -14,8 +14,7 @@ export const flashField = StateField.define({
             const mark = Decoration.mark({
               attributes: { style: `background-color: rgba(255,255,255, .4); filter: invert(10%)` },
             });
-            const range = e.value.range || { from: 0, to: tr.newDoc.length };
-            flash = Decoration.set([mark.range(range.from, range.to)]);
+            flash = Decoration.set([mark.range(0, tr.newDoc.length)]);
           } else {
             flash = Decoration.set([]);
           }
@@ -30,9 +29,8 @@ export const flashField = StateField.define({
   provide: (f) => EditorView.decorations.from(f),
 });
 
-export const flash = (view, ms = 200, range) => {
-  const flashData = range ? { range } : true;
-  view.dispatch({ effects: setFlash.of(flashData) });
+export const flash = (view, ms = 200) => {
+  view.dispatch({ effects: setFlash.of(true) });
   setTimeout(() => {
     view.dispatch({ effects: setFlash.of(false) });
   }, ms);

packages/codemirror/highlight.mjs

@@ -3,9 +3,8 @@ import { Decoration, EditorView } from '@codemirror/view';
 
 export const setMiniLocations = StateEffect.define();
 export const showMiniLocations = StateEffect.define();
-export const displayMiniLocations = StateEffect.define();
-export const updateMiniLocations = (view, locations, range = null) => {
-  view.dispatch({ effects: setMiniLocations.of({ locations, range }) });
+export const updateMiniLocations = (view, locations) => {
+  view.dispatch({ effects: setMiniLocations.of(locations) });
 };
 export const highlightMiniLocations = (view, atTime, haps) => {
   view.dispatch({ effects: showMiniLocations.of({ atTime, haps }) });
@@ -22,54 +21,23 @@ const miniLocations = StateField.define({
 
     for (let e of tr.effects) {
       if (e.is(setMiniLocations)) {
-        //block-based eval case
-        if (e.value.range) {
-          const stateMiniLocations = getMiniLocationsFromDecorations(locations);
-
-          const normalized = e.value.locations
-            .filter(([from]) => from < tr.newDoc.length)
-            .map(([from, to]) => [from, Math.min(to, tr.newDoc.length)]);
-
-          const newIds = new Set(normalized.map((r) => r.join(':')));
-
-          const marks = normalized.map((range) => {
-            const id = range.join(':');
-            return Decoration.mark({
-              id,
-              // this green is only to verify that the decoration moves when the document is edited
-              // it will be removed later, so the mark is not visible by default
-              attributes: { style: `background-color: #00CA2880` },
-            }).range(...range); // -> Decoration
-          });
-
-          const previousMarks = stateMiniLocations
-            .filter(({ id }) => !newIds.has(id))
-            .map(({ from, to, id }) =>
+        // this is called on eval, with the mini locations obtained from the transpiler
+        // codemirror will automatically remap the marks when the document is edited
+        // create a mark for each mini location, adding the range to the spec to find it later
+        const marks = e.value
+          .filter(([from]) => from < tr.newDoc.length)
+          .map(([from, to]) => [from, Math.min(to, tr.newDoc.length)])
+          .map(
+            (range) =>
               Decoration.mark({
-                id,
+                id: range.join(':'),
+                // this green is only to verify that the decoration moves when the document is edited
+                // it will be removed later, so the mark is not visible by default
                 attributes: { style: `background-color: #00CA2880` },
-              }).range(from, to),
-            );
+              }).range(...range), // -> Decoration
+          );
 
-          locations = Decoration.set(previousMarks.concat(marks), true); // -> DecorationSet === RangeSet<Decoration>
-        } else {
-          // this is called on eval, with the mini locations obtained from the transpiler
-          // codemirror will automatically remap the marks when the document is edited
-          // create a mark for each mini location, adding the range to the spec to find it later
-          const marks = e.value.locations
-            .filter(([from]) => from < tr.newDoc.length)
-            .map(([from, to]) => [from, Math.min(to, tr.newDoc.length)])
-            .map(
-              (range) =>
-                Decoration.mark({
-                  id: range.join(':'),
-                  // this green is only to verify that the decoration moves when the document is edited
-                  // it will be removed later, so the mark is not visible by default
-                  attributes: { style: `background-color: #00CA2880` },
-                }).range(...range), // -> Decoration
-            );
-          locations = Decoration.set(marks, true); // -> DecorationSet === RangeSet<Decoration>
-        }
+        locations = Decoration.set(marks, true); // -> DecorationSet === RangeSet<Decoration>
       }
     }
 
@@ -107,83 +75,12 @@ const visibleMiniLocations = StateField.define({
   },
 });
 
-const displayMiniLocationsState = StateField.define({
-  create() {
-    return true; // default to showing miniLocations
-  },
-  update(display, tr) {
-    for (let e of tr.effects) {
-      if (e.is(displayMiniLocations)) {
-        display = e.value;
-      }
-    }
-    return display;
-  },
-});
-
 // // Derive the set of decorations from the miniLocations and visibleLocations
-const miniLocationHighlights = EditorView.decorations.compute(
-  [miniLocations, visibleMiniLocations, displayMiniLocationsState],
-  (state) => {
-    // Check if miniLocations display is disabled
-    const shouldDisplay = state.field(displayMiniLocationsState);
-    if (!shouldDisplay) {
-      return Decoration.none; // Return empty decorations if display is disabled
-    }
+const miniLocationHighlights = EditorView.decorations.compute([miniLocations, visibleMiniLocations], (state) => {
+  const iterator = state.field(miniLocations).iter();
+  const { haps } = state.field(visibleMiniLocations);
+  const builder = new RangeSetBuilder();
 
-    const iterator = state.field(miniLocations).iter();
-    const { haps } = state.field(visibleMiniLocations);
-    const builder = new RangeSetBuilder();
-
-    while (iterator.value) {
-      const {
-        from,
-        to,
-        value: {
-          spec: { id },
-        },
-      } = iterator;
-
-      if (haps.has(id)) {
-        const hap = haps.get(id);
-        const color = hap.value?.color ?? 'var(--foreground)';
-        const style = hap.value?.markcss || `outline: solid 2px ${color}`;
-        // Get explicit channels for color values
-        /* 
-    const swatch = document.createElement('div');
-    swatch.style.color = color;
-    document.body.appendChild(swatch);
-    let channels = getComputedStyle(swatch)
-      .color.match(/^rgba?\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})(?:,\s*(\d*(?:\.\d+)?))?\)$/)
-      .slice(1)
-      .map((c) => parseFloat(c || 1));
-    document.body.removeChild(swatch);
-
-    // Get percentage of event
-    const percent = 1 - (atTime - hap.whole.begin) / hap.whole.duration;
-    channels[3] *= percent;
-    */
-
-        builder.add(
-          from,
-          to,
-          Decoration.mark({
-            // attributes: { style: `outline: solid 2px rgba(${channels.join(', ')})` },
-            attributes: { style },
-          }),
-        );
-      }
-
-      iterator.next();
-    }
-
-    return builder.finish();
-  },
-);
-
-const getMiniLocationsFromDecorations = (decorations) => {
-  const iterator = decorations.iter();
-  const miniLocationsArray = [];
   while (iterator.value) {
     const {
       from,
@@ -192,48 +89,50 @@ const getMiniLocationsFromDecorations = (decorations) => {
         spec: { id },
       },
     } = iterator;
-    miniLocationsArray.push({
-      from,
-      to,
-      id,
-    });
+
+    if (haps.has(id)) {
+      const hap = haps.get(id);
+      const color = hap.value?.color ?? 'var(--foreground)';
+      const style = hap.value?.markcss || `outline: solid 2px ${color}`;
+      // Get explicit channels for color values
+      /* 
+      const swatch = document.createElement('div');
+      swatch.style.color = color;
+      document.body.appendChild(swatch);
+      let channels = getComputedStyle(swatch)
+        .color.match(/^rgba?\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})(?:,\s*(\d*(?:\.\d+)?))?\)$/)
+        .slice(1)
+        .map((c) => parseFloat(c || 1));
+      document.body.removeChild(swatch);
+
+      // Get percentage of event
+      const percent = 1 - (atTime - hap.whole.begin) / hap.whole.duration;
+      channels[3] *= percent;
+      */
+
+      builder.add(
+        from,
+        to,
+        Decoration.mark({
+          // attributes: { style: `outline: solid 2px rgba(${channels.join(', ')})` },
+          attributes: { style },
+        }),
+      );
+    }
+
     iterator.next();
   }
-  return miniLocationsArray;
-};
 
-export const getMiniLocations = (state) => {
-  const decorations = state.field(miniLocations);
-  return getMiniLocationsFromDecorations(decorations);
-};
+  return builder.finish();
+});
 
-export const getActiveMiniLocations = (state) => {
-  const miniLocations = getMiniLocations(state);
-  const { haps } = state.field(visibleMiniLocations);
-
-  const activeMiniLocations = miniLocations.filter((location) => haps.has(location.id));
-  return activeMiniLocations;
-};
-
-export const highlightExtension = [
-  miniLocations,
-  visibleMiniLocations,
-  displayMiniLocationsState,
-  miniLocationHighlights,
-];
+export const highlightExtension = [miniLocations, visibleMiniLocations, miniLocationHighlights];
 
 export const isPatternHighlightingEnabled = (on, config) => {
-  // NOTE:
-  // Modified this function to always return the highlightExtension, and instead just toggle whether or not the miniLocations are displayed.
-  // This is because block based evaluation only updates regions of miniLocations, and those updates need to be kept track of constantly.
-  // The setTimeout was also removed because it conflicted with the range-specific updates required by
-  // block based evaluation.
-  // Not sure if this is the best approach, but for block based eval I can't think of a better way to do it.
-
-  if (config) {
-    // Toggle the display state for miniLocations
-    config.editor.dispatch({ effects: displayMiniLocations.of(on) });
-  }
-
-  return Prec.highest(highlightExtension);
+  on &&
+    config &&
+    setTimeout(() => {
+      updateMiniLocations(config.editor, config.miniLocations);
+    }, 100);
+  return on ? Prec.highest(highlightExtension) : [];
 };

packages/codemirror/index.mjs

@@ -5,4 +5,3 @@ export * from './slider.mjs';
 export * from './themes.mjs';
 export * from './widget.mjs';
 export { Vim } from './keybindings.mjs';
-export * from './basicSetup.mjs';

packages/codemirror/keybindings.mjs

@@ -6,7 +6,6 @@ import { emacs } from '@replit/codemirror-emacs';
 import { vim, Vim } from '@replit/codemirror-vim';
 // import { vim } from './vim_test.mjs';
 import { vscodeKeymap } from '@replit/codemirror-vscode-keymap';
-import { helix, commands } from 'codemirror-helix';
 import { logger } from '@strudel/core';
 
 const vscodePlugin = ViewPlugin.fromClass(
@@ -21,70 +20,6 @@ const vscodePlugin = ViewPlugin.fromClass(
 );
 const vscodeExtension = (options) => [vscodePlugin].concat(options ?? []);
 
-function replEval(view) {
-  try {
-    // Dispatch a dedicated evaluate event first
-    let handled = false;
-    try {
-      const ev = new CustomEvent('repl-evaluate', { detail: { source: 'vim', view }, cancelable: true });
-      handled = document.dispatchEvent(ev) === false; // false means preventDefault was called
-    } catch (e) {
-      console.error('Error dispatching repl-evaluate event', e);
-    }
-    if (handled) {
-      return;
-    }
-    // Try Ctrl+Enter first if not handled by custom event
-    const ctrlEnter = new KeyboardEvent('keydown', {
-      key: 'Enter',
-      code: 'Enter',
-      ctrlKey: true,
-      bubbles: true,
-      cancelable: true,
-    });
-    view?.dom?.dispatchEvent?.(ctrlEnter);
-    // If not handled (no handler called preventDefault), try Alt+Enter as
-    // fallback
-    if (!ctrlEnter.defaultPrevented) {
-      const altEnter = new KeyboardEvent('keydown', {
-        key: 'Enter',
-        code: 'Enter',
-        altKey: true,
-        bubbles: true,
-        cancelable: true,
-      });
-      view?.dom?.dispatchEvent?.(altEnter);
-    }
-  } catch (e) {
-    console.error('Error dispatching repl evaluation event', e);
-  }
-}
-
-function replStop(view) {
-  try {
-    // First try dispatching our custom stop event, then fallback to Alt+.
-    let handled = false;
-    try {
-      const ev = new CustomEvent('repl-stop', { detail: { source: 'vim', view }, cancelable: true });
-      handled = document.dispatchEvent(ev) === false;
-    } catch (e) {
-      console.error('Error dispatching repl-stop event', e);
-    }
-    if (!handled) {
-      const altDot = new KeyboardEvent('keydown', {
-        key: '.',
-        code: 'Period',
-        altKey: true,
-        bubbles: true,
-        cancelable: true,
-      });
-      view?.dom?.dispatchEvent?.(altDot);
-    }
-  } catch (e) {
-    console.error('Error dispatching repl stop event', e);
-  }
-}
-
 // Map Vim :w to trigger the same action as evaluation. We dispatch a custom
 // event 'repl-evaluate' that the editor listens for, and also simulate
 // Ctrl+Enter/Alt+Enter as a fallback. We log to the Strudel logger so it
@@ -96,7 +31,7 @@ try {
     // internal actions and works with current selections/visual mode.
     try {
       Vim.defineAction('strudelToggleComment', (cm) => {
-        const view = cm.cm6;
+        const view = cm?.view || cm;
         try {
           const ev = new CustomEvent('repl-toggle-comment', { detail: { source: 'vim', view }, cancelable: true });
           document.dispatchEvent(ev);
@@ -112,23 +47,74 @@ try {
 
     // :q to pause/stop
     Vim.defineEx('quit', 'q', (cm) => {
-      const view = cm.cm6;
-      logger('[vim] :q — stopping repl');
-      replStop(view);
+      try {
+        const view = cm?.view || cm;
+        // First try dispatching our custom stop event, then fallback to Alt+.
+        let handled = false;
+        try {
+          const ev = new CustomEvent('repl-stop', { detail: { source: 'vim', view }, cancelable: true });
+          handled = document.dispatchEvent(ev) === false;
+        } catch (e) {
+          console.error('Error dispatching repl-stop event', e);
+        }
+        if (!handled) {
+          const altDot = new KeyboardEvent('keydown', {
+            key: '.',
+            code: 'Period',
+            altKey: true,
+            bubbles: true,
+            cancelable: true,
+          });
+          view?.dom?.dispatchEvent?.(altDot);
+        }
+      } catch (e) {
+        console.error('Error dispatching :q stop event', e);
+      }
     });
 
     // :w to evaluate
     Vim.defineEx('write', 'w', (cm) => {
-      const view = cm.cm6;
+      const view = cm?.view || cm; // CM6 Vim passes either an object with view or the view itself
       try {
-        view.focus?.();
+        view?.focus?.();
         // Let the app know this came from Vim :w
         try {
           logger('[vim] :w — evaluating code');
         } catch (e) {
           console.error('Error logging Vim :w evaluation', e);
         }
-        replEval(view);
+        // Dispatch a dedicated evaluate event first
+        let handled = false;
+        try {
+          const ev = new CustomEvent('repl-evaluate', { detail: { source: 'vim', view }, cancelable: true });
+          handled = document.dispatchEvent(ev) === false; // false means preventDefault was called
+        } catch (e) {
+          console.error('Error dispatching repl-evaluate event', e);
+        }
+        if (handled) {
+          return;
+        }
+        // Try Ctrl+Enter first if not handled by custom event
+        const ctrlEnter = new KeyboardEvent('keydown', {
+          key: 'Enter',
+          code: 'Enter',
+          ctrlKey: true,
+          bubbles: true,
+          cancelable: true,
+        });
+        view?.dom?.dispatchEvent?.(ctrlEnter);
+        // If not handled (no handler called preventDefault), try Alt+Enter as
+        // fallback
+        if (!ctrlEnter.defaultPrevented) {
+          const altEnter = new KeyboardEvent('keydown', {
+            key: 'Enter',
+            code: 'Enter',
+            altKey: true,
+            bubbles: true,
+            cancelable: true,
+          });
+          view?.dom?.dispatchEvent?.(altEnter);
+        }
       } catch (e) {
         console.error('Error dispatching :w evaluation event', e);
       }
@@ -138,49 +124,11 @@ try {
   console.error('Vim ex command setup failed (defineEx missing or Vim unavailable)', e);
 }
 
-// Map Helix :w to trigger the same action as evaluation. We dispatch a custom
-// event 'repl-evaluate' that the editor listens for, and also simulate
-// Ctrl+Enter/Alt+Enter as a fallback. We log to the Strudel logger so it
-// appears in the Console panel.
-const helixCommands = commands.of([
-  {
-    // :w to evaluate
-    name: 'write',
-    aliases: ['w'],
-    help: 'Repl-eval',
-    handler(view, args) {
-      try {
-        view?.focus?.(); // Let the app know this came from Helix :w
-        logger('[helix] :w — evaluating code');
-        replEval(view);
-      } catch (e) {
-        console.error('Error dispatching helix :w evaluation event', e);
-      }
-    },
-  },
-  {
-    // :q to pause/stop
-    name: 'quit',
-    aliases: ['q'],
-    help: 'Repl-stop',
-    handler(view, args) {
-      try {
-        view?.focus?.(); // Let the app know this came from Helix :q
-        logger('[helix] :q — stopping repl');
-        replStop(view);
-      } catch (e) {
-        console.error('Error dispatching helix :q stop event', e);
-      }
-    },
-  },
-]);
-
 const keymaps = {
   vim,
   emacs,
   codemirror: () => keymap.of(defaultKeymap),
   vscode: vscodeExtension,
-  helix: () => [helix(), helixCommands],
 };
 
 export { Vim } from '@replit/codemirror-vim';

packages/codemirror/labelJump.mjs

@@ -1,18 +1,54 @@
 import { EditorSelection } from '@codemirror/state';
 import { SearchCursor } from '@codemirror/search';
+import { EditorView } from '@codemirror/view';
+import { syntaxTree } from '@codemirror/language';
 
-export function jumpToCharacter(view, character, direction = 1) {
+/**
+ * gets all of the positions of a character in a document, excluding commented out lines
+ * @param { EditorState} state 
+ * @param {String} character 
+ * @returns {number[]}
+ */
+function getCharacterPositions(state, character) {
+  const cursor = new SearchCursor(state.doc, character);
+ 
+  const characterPositions = [];
+  while (!cursor.next().done) {
+
+    const linestartpos = state.doc.lineAt(cursor.value.to).from
+    if (!isLineCommentedOut(state, linestartpos)) {
+
+      characterPositions.push(cursor.value.to);
+    }
+  }
+  return characterPositions;
+}
+
+function isLineCommentedOut(state, pos) {
+
+  const line = state.doc.lineAt(pos);
+  // remove white space
+  pos = line.from + line.text.search(/\S/)
+
+  const tree = syntaxTree(state);
+  const node = tree.resolveInner(pos, 1)
+  return node.name.includes("Comment")
+}
+
+/**
+ * jump to the next character in a document
+ * @param {EditorView} view 
+ * @param {String} character 
+ * @param {number} direction 0 or 1
+ * @returns {boolean}
+ */
+export function jumpToNextCharacter(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);
-  }
+  const characterPositions = getCharacterPositions(state, character);
   if (!characterPositions.length) {
-    return false;
+    return true;
   }
   if (direction > 0) {
     jumpPos = characterPositions.find((x) => x > pos + 1) ?? characterPositions.at(0); // Loop back around for convenience
@@ -21,11 +57,97 @@ export function jumpToCharacter(view, character, direction = 1) {
   }
 
   if (jumpPos == null) {
-    return false;
+    return true;
   }
+  const selection = EditorSelection.cursor(jumpPos - 1);
   dispatch({
-    selection: EditorSelection.cursor(jumpPos - 1),
-    scrollIntoView: true,
+    selection,
+    effects: EditorView.scrollIntoView(
+      selection.head,
+      { y: "start" }
+    )
   });
   return true;
 }
+/**
+ * 
+ * @param {EditorView} view 
+ * @param {String} character 
+ * @param {number} index the instance of the character  
+ * @returns 
+ */
+export function jumpToCharacter(view, character, index) {
+  const { state, dispatch } = view;
+  const characterPositions = getCharacterPositions(state, character);
+  const pos = characterPositions.at(index) ?? characterPositions.at(-1);
+  if (pos == null) {
+    return true;
+  }
+
+  const selection = EditorSelection.cursor(pos - 1);
+  dispatch({
+    selection,
+    effects: EditorView.scrollIntoView(
+      selection.head,
+      { y: "start" }
+    )
+  });
+  return true;
+}
+/**
+ * 
+ * @param {EditorView} view 
+ * @param {String} character 
+ * @returns {true}
+ */
+export function deleteAllInlineBeforeCharacter(view, character) {
+  const { state, dispatch } = view;
+  const characterPositions = getCharacterPositions(state, character);
+
+  const changes = [];
+  characterPositions.forEach((pos) => {
+    const line = state.doc.lineAt(pos);
+    if (state.doc.sliceString(line.from, line.from + 2) === COMMENT_STRING) {
+      return;
+    }
+    changes.push({
+      from: line.from,
+      to: pos - 1,
+      insert: '',
+    });
+  });
+  dispatch({ changes });
+  return true;
+}
+
+/**
+ * 
+ * @param {EditorView} view 
+ * @param {String} character 
+ * @param {String} character2 
+ * @param {number} index 
+ * @returns 
+ */
+export function InsertCharBeforeChar(view, character, character2, index) {
+  const { state, dispatch } = view;
+
+  const changes = [];
+  const characterPositions = getCharacterPositions(state, character);
+  const labelpos = characterPositions.at(index) ?? characterPositions.at(-1);
+  const line = state.doc.lineAt(labelpos);
+
+  //delete preceeding characters
+  changes.push({
+    from: line.from,
+    to: labelpos - 1,
+    insert: '',
+  });
+
+  changes.push({
+    insert: character2,
+    from: line.from,
+  });
+
+  dispatch({ changes });
+  return true;
+}

packages/codemirror/package.json

@@ -32,19 +32,18 @@
   },
   "homepage": "https://codeberg.org/uzu/strudel#readme",
   "dependencies": {
-    "@codemirror/autocomplete": "catalog:",
-    "@codemirror/commands": "catalog:",
-    "@codemirror/lang-javascript": "catalog:",
-    "@codemirror/language": "catalog:",
-    "@codemirror/search": "catalog:",
-    "@codemirror/state": "catalog:",
-    "@codemirror/view": "catalog:",
+    "@codemirror/autocomplete": "^6.18.4",
+    "@codemirror/commands": "^6.8.0",
+    "@codemirror/lang-javascript": "^6.2.2",
+    "@codemirror/language": "^6.10.8",
+    "@codemirror/search": "^6.5.8",
+    "@codemirror/state": "^6.5.1",
+    "@codemirror/view": "^6.36.2",
     "@lezer/highlight": "^1.2.1",
     "@nanostores/persistent": "^0.10.2",
     "@replit/codemirror-emacs": "^6.1.0",
     "@replit/codemirror-vim": "^6.3.0",
     "@replit/codemirror-vscode-keymap": "^6.0.2",
-    "codemirror-helix": "^0.5.0",
     "@strudel/core": "workspace:*",
     "@strudel/draw": "workspace:*",
     "@strudel/tonal": "workspace:*",

packages/codemirror/slider.mjs

@@ -2,11 +2,11 @@ import { ref, pure } from '@strudel/core';
 import { WidgetType, ViewPlugin, Decoration } from '@codemirror/view';
 import { StateEffect } from '@codemirror/state';
 
-// Global state storage for all widget types
 export let sliderValues = {};
+const getSliderID = (from) => `slider_${from}`;
 
 export class SliderWidget extends WidgetType {
-  constructor(value, min, max, from, to, step, view, id) {
+  constructor(value, min, max, from, to, step, view) {
     super();
     this.value = value;
     this.min = min;
@@ -16,21 +16,10 @@ export class SliderWidget extends WidgetType {
     this.to = to;
     this.step = step;
     this.view = view;
-    this.id = id || `${from}:${to}`; // Range-based ID for stability
   }
 
-  eq(other) {
-    if (!(other instanceof SliderWidget)) {
-      return false;
-    }
-    return (
-      this.id === other.id &&
-      this.from === other.from &&
-      this.to === other.to &&
-      this.value === other.value &&
-      this.min === other.min &&
-      this.max === other.max
-    );
+  eq() {
+    return false;
   }
 
   toDOM() {
@@ -49,7 +38,6 @@ export class SliderWidget extends WidgetType {
     slider.from = this.from;
     slider.originalFrom = this.originalFrom;
     slider.to = this.to;
-    slider.id = this.id; // Store range-based ID in DOM element
     slider.style = 'width:64px;margin-right:4px;transform:translateY(4px)';
     this.slider = slider;
     slider.addEventListener('input', (e) => {
@@ -61,7 +49,7 @@ export class SliderWidget extends WidgetType {
       slider.originalValue = insert;
       slider.value = insert;
       this.view.dispatch({ changes: change });
-      const id = slider.id; // Use range-based ID
+      const id = getSliderID(slider.originalFrom); // matches id generated in transpiler
       window.postMessage({ type: 'cm-slider', value: Number(next), id });
     });
     return wrap;
@@ -74,60 +62,19 @@ export class SliderWidget extends WidgetType {
 
 export const setSliderWidgets = StateEffect.define();
 
-export const setSliderWidgetsInRange = StateEffect.define();
-
-export const updateSliderWidgets = (view, widgets, range = null) => {
-  if (range) {
-    // range argument passed for block-based evaluation
-    view.dispatch({ effects: setSliderWidgetsInRange.of({ widgets, range }) });
-  } else {
-    view.dispatch({ effects: setSliderWidgets.of(widgets) });
-  }
+export const updateSliderWidgets = (view, widgets) => {
+  view.dispatch({ effects: setSliderWidgets.of(widgets) });
 };
 
 function getSliders(widgetConfigs, view) {
-  return (
-    widgetConfigs
-      .filter((w) => w.type === 'slider')
-      // Deduplicate sliders that might appear multiple times (e.g., during paste operations)
-      .filter((slider, index, self) => index === self.findIndex((s) => s.from === slider.from && s.to === slider.to))
-      .sort((a, b) => a.from - b.from)
-      .map(({ from, to, value, min, max, step, id }) => {
-        return Decoration.widget({
-          widget: new SliderWidget(value, min, max, from, to, step, view, id),
-          side: 0,
-        }).range(from /* , to */);
-      })
-  );
-}
-
-export function getSliderWidgets(view) {
-  if (!view || !view.state) {
-    return [];
-  }
-
-  const sliderPluginInstance = view.plugin(sliderPlugin);
-  if (!sliderPluginInstance || !sliderPluginInstance.decorations) {
-    return [];
-  }
-
-  const sliderWidgets = [];
-
-  sliderPluginInstance.decorations.between(0, view.state.doc.length, (from, to, decoration) => {
-    if (decoration.widget instanceof SliderWidget) {
-      sliderWidgets.push({
-        type: 'slider',
-        from: decoration.widget.from,
-        to: decoration.widget.to,
-        value: decoration.widget.value,
-        min: decoration.widget.min,
-        max: decoration.widget.max,
-        step: decoration.widget.step,
-      });
-    }
-  });
-
-  return sliderWidgets;
+  return widgetConfigs
+    .filter((w) => w.type === 'slider')
+    .map(({ from, to, value, min, max, step }) => {
+      return Decoration.widget({
+        widget: new SliderWidget(value, min, max, from, to, step, view),
+        side: 0,
+      }).range(from /* , to */);
+    });
 }
 
 export const sliderPlugin = ViewPlugin.fromClass(
@@ -154,42 +101,7 @@ export const sliderPlugin = ViewPlugin.fromClass(
           }
         }
         for (let e of tr.effects) {
-          if (e.is(setSliderWidgetsInRange)) {
-            // Block-aware slider update logic
-            const { widgets, range } = e.value;
-            const [rangeStart, rangeEnd] = range;
-
-            // Get existing slider widgets that should be preserved
-            const existingSliders = [];
-            this.decorations.between(0, update.view.state.doc.length, (from, to, decoration) => {
-              if (decoration.widget instanceof SliderWidget) {
-                // Preserve sliders outside the evaluation range
-                // Use strict > for rangeEnd because when code is deleted, slider positions
-                // map to the deletion boundary (rangeEnd), and those should be removed, not preserved
-                if (from < rangeStart || from > rangeEnd) {
-                  existingSliders.push({
-                    from,
-                    to,
-                    value: decoration.widget.value,
-                    min: decoration.widget.min,
-                    max: decoration.widget.max,
-                    step: decoration.widget.step,
-                    id: decoration.widget.id || `${from}:${to}`,
-                    type: 'slider',
-                  });
-                }
-              }
-            });
-
-            // Merge preserved sliders with new widgets
-            const mergedWidgets = [...existingSliders, ...widgets]
-              .filter(
-                (slider, index, self) => index === self.findIndex((s) => s.type === 'slider' && s.id === slider.id),
-              )
-              .sort((a, b) => a.from - b.from);
-
-            this.decorations = Decoration.set(getSliders(mergedWidgets, update.view));
-          } else if (e.is(setSliderWidgets)) {
+          if (e.is(setSliderWidgets)) {
             this.decorations = Decoration.set(getSliders(e.value, update.view));
           }
         }
@@ -220,7 +132,6 @@ export let sliderWithID = (id, value, min, max) => {
   sliderValues[id] = value; // sync state at eval time (code -> state)
   return ref(() => sliderValues[id]); // use state at query time
 };
-
 // update state when sliders are moved
 if (typeof window !== 'undefined') {
   window.addEventListener('message', (e) => {
@@ -229,7 +140,7 @@ if (typeof window !== 'undefined') {
         // update state when slider is moved
         sliderValues[e.data.id] = e.data.value;
       } else {
-        console.error(`slider with id "${e.data.id}" is not registered. Only ${Object.keys(sliderValues)}`);
+        console.warn(`slider with id "${e.data.id}" is not registered. Only ${Object.keys(sliderValues)}`);
       }
     }
   });

packages/codemirror/widget.mjs

@@ -1,111 +1,55 @@
 import { StateEffect, StateField } from '@codemirror/state';
-import { Decoration, EditorView, WidgetType, ViewPlugin } from '@codemirror/view';
+import { Decoration, EditorView, WidgetType } from '@codemirror/view';
 import { getWidgetID, registerWidgetType } from '@strudel/transpiler';
 import { Pattern } from '@strudel/core';
 
-export const setWidgets = StateEffect.define();
+export const addWidget = StateEffect.define({
+  map: ({ from, to }, change) => {
+    return { from: change.mapPos(from), to: change.mapPos(to) };
+  },
+});
 
-export const setWidgetsInRange = StateEffect.define();
-
-export const updateWidgets = (view, widgets, range = null) => {
-  if (range) {
-    // range argument passed for block-based evaluation
-    view.dispatch({ effects: setWidgetsInRange.of({ widgets, range }) });
-  } else {
-    view.dispatch({ effects: setWidgets.of(widgets) });
-  }
+export const updateWidgets = (view, widgets) => {
+  view.dispatch({ effects: addWidget.of(widgets) });
 };
 
-function getWidgets(widgetConfigs, view) {
-  const filtered = widgetConfigs
-    // Filter to widget configs only (exclude sliders)
-    .filter((w) => w && w.type && w.type !== 'slider')
-    // Deduplicate widgets by ID, matching slider behavior for stable widget identity
-    .filter((widget, index, self) => index === self.findIndex((w) => w.type === widget.type && w.id === widget.id));
-
-  // Filter out widgets whose range is encompassed by another widget
-  // const nonEncompassed = filterEncompassedWidgets(filtered);
-
-  return filtered
-    .sort((a, b) => (a.to || 0) - (b.to || 0))
-    .map((widgetConfig) => {
-      try {
+function getWidgets(widgetConfigs) {
+  return (
+    widgetConfigs
+      // codemirror throws an error if we don't sort
+      .sort((a, b) => a.to - b.to)
+      .map((widgetConfig) => {
         return Decoration.widget({
-          widget: new BlockWidget(widgetConfig, view),
+          widget: new BlockWidget(widgetConfig),
           side: 0,
-        }).range(widgetConfig.to || widgetConfig.from || 0);
-      } catch (error) {
-        console.error('error creating widget', error);
-        return null;
-      }
-    })
-    .filter(Boolean); // Remove any null results from failed creations
+          block: true,
+        }).range(widgetConfig.to);
+      })
+  );
 }
 
-export const widgetPlugin = ViewPlugin.fromClass(
-  class {
-    decorations; //: DecorationSet
-
-    constructor(view /* : EditorView */) {
-      this.decorations = Decoration.set([]);
-    }
-
-    update(update /* : ViewUpdate */) {
-      update.transactions.forEach((tr) => {
-        if (tr.docChanged) {
-          this.decorations = this.decorations.map(tr.changes);
-          const iterator = this.decorations.iter();
-          // Apply changes to iterator.from and iterator.to if docChanged
-          while (iterator.value) {
-            // when the widgets are moved, we need to tell the dom node the current position
-            // this is important because the widget functions have to work with the dom node
-            if (iterator.value?.widget instanceof BlockWidget) {
-              iterator.value.widget.from = iterator.from;
-              iterator.value.widget.to = iterator.to;
-            }
-            iterator.next();
-          }
-        }
-        for (let e of tr.effects) {
-          if (e.is(setWidgetsInRange)) {
-            // Block-aware widget update logic
-            const { widgets, range } = e.value;
-            const [rangeStart, rangeEnd] = range;
-
-            // Get existing widget widgets that should be preserved
-            const existingWidgets = [];
-            this.decorations.between(0, update.view.state.doc.length, (from, to, decoration) => {
-              if (decoration.widget instanceof BlockWidget) {
-                // Preserve widgets outside the evaluation range
-                // Use strict > for rangeEnd because when code is deleted, widget positions
-                // map to the deletion boundary (rangeEnd), and those should be removed, not preserved
-                if (from < rangeStart || from > rangeEnd) {
-                  existingWidgets.push({
-                    from: decoration.widget.from,
-                    to: decoration.widget.to,
-                    type: decoration.widget.type,
-                    index: decoration.widget.index,
-                    id: decoration.widget.id,
-                  });
-                }
-              }
+const widgetField = StateField.define(
+  /* <DecorationSet> */ {
+    create() {
+      return Decoration.none;
+    },
+    update(widgets, tr) {
+      widgets = widgets.map(tr.changes);
+      for (let e of tr.effects) {
+        if (e.is(addWidget)) {
+          try {
+            widgets = widgets.update({
+              filter: () => false,
+              add: getWidgets(e.value),
             });
-
-            // Merge preserved widgets with new widgets, deduplicating by ID
-            const mergedWidgets = [...existingWidgets, ...widgets].filter(
-              (widget, index, self) => index === self.findIndex((w) => w.type === widget.type && w.id === widget.id),
-            );
-
-            this.decorations = Decoration.set(getWidgets(mergedWidgets, update.view));
-          } else if (e.is(setWidgets)) {
-            this.decorations = Decoration.set(getWidgets(e.value, update.view));
+          } catch (error) {
+            console.log('err', error);
           }
         }
-      });
-    }
-  },
-  {
-    decorations: (v) => v.decorations,
+      }
+      return widgets;
+    },
+    provide: (f) => EditorView.decorations.from(f),
   },
 );
 
@@ -116,116 +60,24 @@ export function setWidget(id, el) {
 }
 
 export class BlockWidget extends WidgetType {
-  constructor(widgetConfig, view) {
+  constructor(widgetConfig) {
     super();
-
-    // Graceful handling of invalid configs like sliders
-    if (!widgetConfig || typeof widgetConfig !== 'object') {
-      widgetConfig = { type: 'unknown', from: 0, to: 0 };
-    }
-
-    this.from = widgetConfig.from || 0;
-    this.originalFrom = widgetConfig.from || 0;
-    this.to = widgetConfig.to || this.from;
-    this.originalTo = widgetConfig.to || this.from;
-    this.type = widgetConfig.type || 'unknown';
-    this.index = widgetConfig.index || 0;
-    this.view = view;
-
-    // Use range-based ID for stability, similar to sliders
-    this.id = widgetConfig.id || getWidgetID?.(widgetConfig);
     this.widgetConfig = widgetConfig;
   }
-
-  eq(other) {
-    if (!(other instanceof BlockWidget)) {
-      return false;
-    }
-    return (
-      this.id === other.id &&
-      this.from === other.from &&
-      this.to === other.to &&
-      this.type === other.type &&
-      this.index === other.index
-    );
+  eq() {
+    return true;
   }
-
   toDOM() {
-    let wrap = document.createElement('span');
-    wrap.setAttribute('aria-hidden', 'true');
-    wrap.className = 'cm-widget-container';
-
-    let el = widgetElements[this.id];
-    if (el) {
-      // Ensure the element has the correct ID
-      el.id = this.id;
-      wrap.appendChild(el);
-    } else {
-      // Create a placeholder element if the widget element doesn't exist
-      // This prevents CodeMirror errors when widget is missing
-      const placeholder = document.createElement('span');
-      placeholder.setAttribute('aria-hidden', 'true');
-      placeholder.className = 'cm-widget-placeholder';
-      placeholder.style.cssText = 'display: none;'; // Hide placeholder
-      placeholder.id = this.id;
-      wrap.appendChild(placeholder);
-    }
-
-    return wrap;
+    const id = getWidgetID(this.widgetConfig);
+    const el = widgetElements[id];
+    return el;
   }
-
   ignoreEvent(e) {
     return true;
   }
 }
 
-export function getActiveWidgets(view) {
-  if (!view || !view.state) {
-    return [];
-  }
-
-  const widgetPluginInstance = view.plugin(widgetPlugin);
-  if (!widgetPluginInstance || !widgetPluginInstance.decorations) {
-    return [];
-  }
-
-  const widgets = [];
-
-  widgetPluginInstance.decorations.between(0, view.state.doc.length, (from, to, decoration) => {
-    if (decoration.widget instanceof BlockWidget) {
-      widgets.push({
-        type: decoration.widget.type,
-        from: decoration.widget.from,
-        to: decoration.widget.to,
-        index: decoration.widget.index,
-        id: decoration.widget.id,
-      });
-    }
-  });
-
-  return widgets;
-}
-
-export function getAllWidgetIds(view) {
-  if (!view || !view.state) {
-    return [];
-  }
-
-  const widgetPluginInstance = view.plugin(widgetPlugin);
-  if (!widgetPluginInstance || !widgetPluginInstance.decorations) {
-    return [];
-  }
-
-  const widgetIds = [];
-
-  widgetPluginInstance.decorations.between(0, view.state.doc.length, (from, to, decoration) => {
-    if (decoration.widget instanceof BlockWidget) {
-      widgetIds.push(decoration.widget.id);
-    }
-  });
-
-  return widgetIds;
-}
+export const widgetPlugin = [widgetField];
 
 // widget implementer API to create a new widget type
 export function registerWidget(type, fn) {

packages/core/evaluate.mjs

@@ -5,34 +5,6 @@ This program is free software: you can redistribute it and/or modify it under th
 */
 
 export const strudelScope = {};
-// Make strudelScope available globally so transpiled code can access it
-globalThis.strudelScope = strudelScope;
-
-// Track user-defined keys (from block-based eval) so we can clear them without removing strudel functions
-export const userDefinedKeys = new Set();
-globalThis.userDefinedKeys = userDefinedKeys;
-
-/**
- * Clears all user-defined variables and functions from the scope.
- * This removes variables created during block-based evaluation.
- * @name clearScope
- * @example
- * // After defining variables in blocks:
- * // let myVar = 5
- * // function myFunc() { return 10; }
- * clearScope() // removes myVar and myFunc from scope
- */
-export const clearScope = () => {
-  for (const key of userDefinedKeys) {
-    delete strudelScope[key];
-    delete globalThis[key];
-  }
-  userDefinedKeys.clear();
-  // Return silence if available (for use in pattern expressions), otherwise undefined
-  return globalThis.silence;
-};
-// Make clearScope available globally
-globalThis.clearScope = clearScope;
 
 export const evalScope = async (...args) => {
   const results = await Promise.allSettled(args);

packages/core/pattern.mjs

@@ -818,6 +818,7 @@ export class Pattern {
    * @name layer
    * @tags combiners
    * @memberof Pattern
+   * @synonyms apply
    * @returns Pattern
    * @example
    * "<0 2 4 6 ~ 4 ~ 2 0!3 ~!5>*8"
@@ -1056,55 +1057,7 @@ function _composeOp(a, b, func) {
 
 // pattern composers
 const COMPOSERS = {
-  /**
-   * When called on a pattern `a`, with a input pattern `b` (`a.set(b)`),
-   * combines `a` and `b` such that anything defined in `b`
-   * and anything defined in `a` that is *not* defined in `b`
-   * will be in the resulting pattern.
-   *
-   * The structure is maintained from `a`,
-   * because the default pattern alignment is `in`,
-   * see the section on `Pattern Alignment`
-   * in the technical manual in the docs
-   *
-   * This is the inverse of `keep`
-   *
-   * See examples below
-   * @name set
-   * @param {Pattern} pat
-   * @returns {Pattern}
-   * @memberof Pattern
-   * @tags internal, combiners
-   * @example
-   * // because input pattern has `s` set,
-   * // it overrides the "sine" declared earlier
-   * note("c a f e").s("sine").set(s("triangle"))
-   */
   set: [(a, b) => b],
-  /**
-   * When called on a pattern `a`, with a input pattern `b` (`a.keep(b)`),
-   * combines `a` and `b` such that anything defined in `a`,
-   * and anything defined in `b` that is *not* defined in `a`
-   * will be in the resulting pattern
-   *
-   * The structure is maintained from `a`,
-   * because the default pattern alignment is `in`,
-   * see the section on `Pattern Alignment`
-   * in the technical manual in the docs
-   *
-   * This is the inverse of `set`
-   *
-   * See examples below
-   * @name keep
-   * @param {Pattern} pat
-   * @memberof Pattern
-   * @returns {Pattern}
-   * @tags internal, combiners
-   * @example
-   * // notes, already defined, will stay "c a f e",
-   * // while "s", not defined, will be set to "piano"
-   * note("c a f e").keep(note("e f a c").s("piano"))
-   */
   keep: [(a) => a],
   keepif: [(a, b) => (b ? a : undefined)],
 
@@ -1158,6 +1111,7 @@ const COMPOSERS = {
   div: [numeralArgs((a, b) => a / b)],
   mod: [numeralArgs(_mod)],
   pow: [numeralArgs(Math.pow)],
+  log2: [numeralArgs(Math.log2)],
   band: [numeralArgs((a, b) => a & b)],
   bor: [numeralArgs((a, b) => a | b)],
   bxor: [numeralArgs((a, b) => a ^ b)],
@@ -1311,7 +1265,6 @@ const ALIGNMENT_KEYS = ALIGNMENTS.map((how) => how.toLowerCase());
  * 'add.mix', 'set.squeeze', etc.
  *
  * @param {string} method Default join method to use. Options: 'in', 'out', 'mix', 'squeeze', 'squeezeout', 'reset', 'restart', 'poly'
- * @tags combiners
  * @example
  * setDefaultJoin('mix') // also try 'in', 'out', 'squeeze', etc.
  * s("saw").vel("1 0.5").note("F A C E").delay("0 0.2 0.3")
@@ -1611,10 +1564,10 @@ export function arrange(...sections) {
  * @tags combiners
  * @return {Pattern}
  * @example
-seqPLoop(
-  [0, 2, "bd(3,8)"],
-  [1, 3, "cp(3,8)"]
-).sound()
+seqPLoop([0, 2, "bd(3,8)"],
+         [1, 3, "cp(3,8)"]
+        )
+  .sound()
  */
 export function seqPLoop(...parts) {
   let total = Fraction(0);
@@ -1657,7 +1610,7 @@ export function sequence(...pats) {
 
 /** Like **cat**, but the items are crammed into one cycle.
  * @tags combiners
- * @synonyms fastcat
+ * @synonyms seq, fastcat
  * @example
  * seq("e5", "b4", ["d5", "c5"]).note()
  * // "e5 b4 [d5 c5]".note()
@@ -1741,12 +1694,6 @@ export const func = curry((a, b) => reify(b).func(a));
  *
  */
 export function register(name, func, patternify = true, preserveSteps = false, join = (x) => x.innerJoin()) {
-  if (isPattern(name)) {
-    throw new Error(
-      'Name argument for register is a pattern, try using single quotes (\'name\') instead of double quotes ("name")',
-    );
-  }
-
   if (Array.isArray(name)) {
     const result = {};
     for (const name_item of name) {
@@ -1869,8 +1816,6 @@ export const floor = register('floor', function (pat) {
   return pat.asNumber().fmap((v) => Math.floor(v));
 });
 
-export const log2 = register('log2', (pat) => pat.asNumber().fmap((v) => Math.log2(v)));
-
 /**
  * Assumes a numerical pattern. Returns a new pattern with all values set to
  * their mathematical ceiling. E.g. `3.2` replaced with `4`, and `-4.2`
@@ -2192,12 +2137,13 @@ export const { firstOf, every } = register(['firstOf', 'every'], function (n, fu
 });
 
 /**
- * Applies the given function to the pattern. Like layer, but with a single function:
- * @tags combiners
+ * Like layer, but with a single function:
+ * @tags temporal
  * @name apply
  * @example
  * "<c3 eb3 g3>".scale('C minor').apply(scaleTranspose("0,2,4")).note()
  */
+// TODO: remove or dedupe with layer?
 export const apply = register('apply', function (func, pat) {
   return func(pat);
 });
@@ -2552,23 +2498,9 @@ export const { juxBy, juxby } = register(['juxBy', 'juxby'], function (by, func,
   return stack(left, right).setSteps(__steps ? lcm(left._steps, right._steps) : undefined);
 });
 
-/**
- * Like juxBy, except it flips the ears each cycle.
- * @name juxFlipBy
- * @synonyms juxflipby, fluxBy, fluxby
- * @example
- * s("bd lt [~ ht] mt cp ~ bd hh").juxFlipBy(".8", rev)
- */
-export const { juxFlipBy, juxflipby, fluxBy, fluxby } = register(
-  ['juxFlipBy', 'juxflipby', 'fluxBy', 'fluxby'],
-  function (by, func, pat) {
-    return pat.juxBy(slowcat(by, -by), func);
-  },
-);
-
 /**
  * The jux function creates strange stereo effects, by applying a function to a pattern, but only in the right-hand channel.
- * @tags temporal, superdough
+ * @tags temporal
  * @example
  * s("bd lt [~ ht] mt cp ~ bd hh").jux(rev)
  * @example
@@ -2580,24 +2512,9 @@ export const jux = register('jux', function (func, pat) {
   return pat._juxBy(1, func, pat);
 });
 
-/**
- * Like jux, but flips the ears each cycle.
- * @name juxFlip
- * @synonyms juxflip, flux
- * @example
- * s("bd lt [~ ht] mt cp ~ bd hh").juxFlip(rev)
- * @example
- * s("bd lt [~ ht] mt cp ~ bd hh").juxFlip(press)
- * @example
- * s("bd lt [~ ht] mt cp ~ bd hh").juxFlip(iter(4))
- */
-export const { juxFlip, flux } = register(['juxFlip', 'juxflip', 'flux'], function (func, pat) {
-  return pat._juxFlipBy(1, func, pat);
-});
-
 /**
  * Superimpose and offset multiple times, applying the given function each time.
- * @tags temporal, functional
+ * @tags temporal
  * @name echoWith
  * @synonyms echowith, stutWith, stutwith
  * @param {number} times how many times to repeat
@@ -2771,7 +2688,7 @@ export const { repeatCycles } = register(
 
 /**
  * Divides a pattern into a given number of parts, then cycles through those parts in turn, applying the given function to each part in turn (one part per cycle).
- * @tags temporal, functional
+ * @tags temporal
  * @name chunk
  * @synonyms slowChunk, slowchunk
  * @memberof Pattern
@@ -2935,7 +2852,7 @@ Pattern.prototype.tag = function (tag) {
 /**
  * Filters haps using the given function
  * @name filter
- * @tags temporal, functional
+ * @tags temporal
  * @param {Function} test function to test Hap
  * @example
  * s("hh!7 oh").filter(hap => hap.value.s === 'hh')
@@ -2945,7 +2862,7 @@ export const filter = register('filter', (test, pat) => pat.withHaps((haps) => h
 /**
  * Filters haps by their begin time
  * @name filterWhen
- * @tags temporal, functional
+ * @tags temporal
  * @param {Function} test function to test Hap.whole.begin
  * @example
  * oneCycle: s("bd*4").filterWhen((t) => t < 1)
@@ -2955,7 +2872,7 @@ export const filterWhen = register('filterWhen', (test, pat) => pat.filter((h) =
 /**
  * Use within to apply a function to only a part of a pattern.
  * @name within
- * @tags temporal, functional
+ * @tags temporal
  * @param {number} start start within cycle (0 - 1)
  * @param {number} end end within cycle (0 - 1). Must be > start
  * @param {Function} func function to be applied to the sub-pattern
@@ -3030,7 +2947,7 @@ export function _match(span, hap_p) {
  * *Experimental*
  *
  * Speeds a pattern up or down, to fit to the given number of steps per cycle.
- * @tags stepwise
+ * @tags temporal
  * @example
  * sound("bd sd cp").pace(4)
  * // The same as sound("{bd sd cp}%4") or sound("<bd sd cp>*4")
@@ -3072,7 +2989,7 @@ export function _polymeterListSteps(steps, ...args) {
  * *Experimental*
  *
  * Aligns the steps of the patterns, creating polymeters. The patterns are repeated until they all fit the cycle. For example, in the below the first pattern is repeated twice, and the second is repeated three times, to fit the lowest common multiple of six steps.
- * @tags stepwise
+ * @tags temporal
  * @synonyms pm
  * @example
  * // The same as note("{c eb g, c2 g2}%6")
@@ -3105,7 +3022,7 @@ export function polymeter(...args) {
  * The steps can either be inferred from the pattern, or provided as a [length, pattern] pair.
  * Has the alias `timecat`.
  * @name stepcat
- * @tags stepwise
+ * @tags combiners
  * @synonyms timeCat, timecat
  * @return {Pattern}
  * @example
@@ -3163,7 +3080,7 @@ export function stepcat(...timepats) {
  * Concatenates patterns stepwise, according to an inferred 'steps per cycle'.
  * Similar to `stepcat`, but if an argument is a list, the whole pattern will alternate between the elements in the list.
  *
- * @tags stepwise
+ * @tags combiners
  * @return {Pattern}
  * @example
  * stepalt(["bd cp", "mt"], "bd").sound()
@@ -3190,7 +3107,7 @@ export function stepalt(...groups) {
  *
  * Takes the given number of steps from a pattern (dropping the rest).
  * A positive number will take steps from the start of a pattern, and a negative number from the end.
- * @tags stepwise
+ * @tags temporal
  * @return {Pattern}
  * @example
  * "bd cp ht mt".take("2").sound()
@@ -3235,7 +3152,7 @@ export const take = stepRegister('take', function (i, pat) {
  *
  * Drops the given number of steps from a pattern.
  * A positive number will drop steps from the start of a pattern, and a negative number from the end.
- * @tags stepwise
+ * @tags temporal
  * @return {Pattern}
  * @example
  * "tha dhi thom nam".drop("1").sound().bank("mridangam")
@@ -3264,7 +3181,7 @@ export const drop = stepRegister('drop', function (i, pat) {
  * `extend` is similar to `fast` in that it increases its density, but it also increases the step count
  * accordingly. So `stepcat("a b".extend(2), "c d")` would be the same as `"a b a b c d"`, whereas
  * `stepcat("a b".fast(2), "c d")` would be the same as `"[a b] [a b] c d"`.
- * @tags stepwise
+ * @tags temporal
  * @example
  * stepcat(
  *   sound("bd bd - cp").extend(2),
@@ -3283,7 +3200,7 @@ export const extend = stepRegister('extend', function (factor, pat) {
  * `stepcat("a b".fast(2), "c d")` would be the same as `"[a b] [a b] c d"`.
  *
  * TODO: find out how this function differs from extend
- * @tags stepwise
+ * @tags temporal
  * @example
  * stepcat(
  *   sound("bd bd - cp").replicate(2),
@@ -3298,7 +3215,7 @@ export const replicate = stepRegister('replicate', function (factor, pat) {
  * *Experimental*
  *
  * Expands the step size of the pattern by the given factor.
- * @tags stepwise
+ * @tags temporal
  * @example
  * sound("tha dhi thom nam").bank("mridangam").expand("3 2 1 1 2 3").pace(8)
  */
@@ -3310,7 +3227,7 @@ export const expand = stepRegister('expand', function (factor, pat) {
  * *Experimental*
  *
  * Contracts the step size of the pattern by the given factor. See also `expand`.
- * @tags stepwise
+ * @tags temporal
  * @example
  * sound("tha dhi thom nam").bank("mridangam").contract("3 2 1 1 2 3").pace(8)
  */
@@ -3359,18 +3276,13 @@ Pattern.prototype.shrinklist = function (amount) {
 
 export const shrinklist = (amount, pat) => pat.shrinklist(amount);
 
-Pattern.prototype.growlist = function (amount) {
-  return this.shrinklist(amount).reverse();
-};
-export const growlist = (amount, pat) => pat.growlist(amount);
-
 /**
  * *Experimental*
  *
  * Progressively shrinks the pattern by 'n' steps until there's nothing left, or if a second value is given (using mininotation list syntax with `:`),
  * that number of times.
  * A positive number will progressively drop steps from the start of a pattern, and a negative number from the end.
- * @tags stepwise
+ * @tags temporal
  * @return {Pattern}
  * @example
  * "tha dhi thom nam".shrink("1").sound()
@@ -3410,7 +3322,7 @@ export const shrink = register(
  * Progressively grows the pattern by 'n' steps until the full pattern is played, or if a second value is given (using mininotation list syntax with `:`),
  * that number of times.
  * A positive number will progressively grow steps from the start of a pattern, and a negative number from the end.
- * @tags stepwise
+ * @tags temporal
  * @return {Pattern}
  * @example
  * "tha dhi thom nam".grow("1").sound()
@@ -3451,7 +3363,7 @@ export const grow = register(
  * on successive repetitions. The patterns are added together stepwise, with all repetitions taking place over a single cycle. Using `pace` to set the 
  * number of steps per cycle is therefore usually recommended.
  *
- * @tags stepwise
+ * @tags combiners
  * @return {Pattern}
  * @example
  * "[c g]".tour("e f", "e f g", "g f e c").note()
@@ -3478,7 +3390,7 @@ Pattern.prototype.tour = function (...many) {
  * 'zips' together the steps of the provided patterns. This can create a long repetition, taking place over a single, dense cycle. 
  * Using `pace` to set the number of steps per cycle is therefore usually recommended.
  * 
- * @tags stepwise
+ * @tags combiners
  * @returns {Pattern}
  * @example
  * zip("e f", "e f g", "g [f e] a f4 c").note()
@@ -3530,7 +3442,7 @@ Pattern.prototype.steps = Pattern.prototype.pace;
  * Cuts each sample into the given number of parts, allowing you to explore a technique known as 'granular synthesis'.
  * It turns a pattern of samples into a pattern of parts of samples.
  * @name chop
- * @tags samples
+ * @tags temporal
  * @memberof Pattern
  * @returns Pattern
  * @example
@@ -3561,7 +3473,7 @@ export const chop = register('chop', function (n, pat) {
 /**
  * Cuts each sample into the given number of parts, triggering progressive portions of each sample at each loop.
  * @name striate
- * @tags samples
+ * @tags temporal
  * @memberof Pattern
  * @returns Pattern
  * @example
@@ -3580,13 +3492,14 @@ export const striate = register('striate', function (n, pat) {
 /**
  * Makes the sample fit the given number of cycles by changing the speed.
  * @name loopAt
- * @tags samples, pitch
+ * @tags temporal
  * @memberof Pattern
  * @returns Pattern
  * @example
  * samples({ rhodes: 'https://cdn.freesound.org/previews/132/132051_316502-lq.mp3' })
  * s("rhodes").loopAt(2)
  */
+// TODO - global cps clock
 const _loopAt = function (factor, pat, cps = 0.5) {
   return pat
     .speed((1 / factor) * cps)
@@ -3594,16 +3507,11 @@ const _loopAt = function (factor, pat, cps = 0.5) {
     .slow(factor);
 };
 
-export const { loopAt, loopat } = register(['loopAt', 'loopat'], function (factor, pat) {
-  const steps = pat._steps ? pat._steps.div(factor) : undefined;
-  return new Pattern((state) => _loopAt(factor, pat, state.controls._cps).query(state), steps);
-});
-
 /**
  * Chops samples into the given number of slices, triggering those slices with a given pattern of slice numbers.
  * Instead of a number, it also accepts a list of numbers from 0 to 1 to slice at specific points.
  * @name slice
- * @tags samples
+ * @tags temporal
  * @memberof Pattern
  * @returns Pattern
  * @example
@@ -3657,7 +3565,7 @@ Pattern.prototype.onTriggerTime = function (func) {
 /**
  * Works the same as slice, but changes the playback speed of each slice to match the duration of its step.
  * @name splice
- * @tags samples, pitch
+ * @tags temporal
  * @example
  * samples('github:tidalcycles/dirt-samples')
  * s("breaks165")
@@ -3686,11 +3594,16 @@ export const splice = register(
   false, // turns off auto-patternification
 );
 
+export const { loopAt, loopat } = register(['loopAt', 'loopat'], function (factor, pat) {
+  const steps = pat._steps ? pat._steps.div(factor) : undefined;
+  return new Pattern((state) => _loopAt(factor, pat, state.controls._cps).query(state), steps);
+});
+
 /**
  * Makes the sample fit its event duration. Good for rhythmical loops like drum breaks.
  * Similar to `loopAt`.
  * @name fit
- * @tags samples, pitch
+ * @tags temporal
  * @example
  * samples({ rhodes: 'https://cdn.freesound.org/previews/132/132051_316502-lq.mp3' })
  * s("rhodes/2").fit()
@@ -3712,16 +3625,18 @@ export const fit = register('fit', (pat) =>
 
 /**
  * Makes the sample fit the given number of cycles and cps value, by
- * changing the speed. deprecated: use loopAt or fit instead, together with setCps / setCpm.
+ * changing the speed. Please note that at some point cps will be
+ * given by a global clock and this function will be
+ * deprecated/removed.
  * @name loopAtCps
- * @tags samples, pitch
+ * @tags temporal
  * @memberof Pattern
- * @deprecated
  * @returns Pattern
  * @example
  * samples({ rhodes: 'https://cdn.freesound.org/previews/132/132051_316502-lq.mp3' })
  * s("rhodes").loopAtCps(4,1.5).cps(1.5)
  */
+// TODO - global cps clock
 export const { loopAtCps, loopatcps } = register(['loopAtCps', 'loopatcps'], function (factor, cps, pat) {
   return _loopAt(factor, pat, cps);
 });
@@ -3743,7 +3658,7 @@ let fadeGain = (p) => (p < 0.5 ? 1 : 1 - (p - 0.5) / 0.5);
  * - 1 = (no left, full right)
  *
  * @name xfade
- * @tags amplitude
+ * @tags combiners
  * @example
  * xfade(s("bd*2"), "<0 .25 .5 .75 1>", s("hh*8"))
  */
@@ -3869,7 +3784,7 @@ const _distortWithAlg = function (name) {
  * Soft-clipping distortion
  *
  * @name soft
- * @tags distortion, superdough
+ * @tags fx
  * @param {number | Pattern} distortion amount of distortion to apply
  * @param {number | Pattern} volume linear postgain of the distortion
  *
@@ -3880,7 +3795,7 @@ export const soft = _distortWithAlg('soft');
  * Hard-clipping distortion
  *
  * @name hard
- * @tags distortion, superdough
+ * @tags fx
  * @param {number | Pattern} distortion amount of distortion to apply
  * @param {number | Pattern} volume linear postgain of the distortion
  *
@@ -3891,7 +3806,7 @@ export const hard = _distortWithAlg('hard');
  * Cubic polynomial distortion
  *
  * @name cubic
- * @tags distortion, superdough
+ * @tags fx
  * @param {number | Pattern} distortion amount of distortion to apply
  * @param {number | Pattern} volume linear postgain of the distortion
  *
@@ -3902,7 +3817,7 @@ export const cubic = _distortWithAlg('cubic');
  * Diode-emulating distortion
  *
  * @name diode
- * @tags distortion, superdough
+ * @tags fx
  * @param {number | Pattern} distortion amount of distortion to apply
  * @param {number | Pattern} volume linear postgain of the distortion
  *
@@ -3913,7 +3828,7 @@ export const diode = _distortWithAlg('diode');
  * Asymmetrical diode distortion
  *
  * @name asym
- * @tags distortion, superdough
+ * @tags fx
  * @param {number | Pattern} distortion amount of distortion to apply
  * @param {number | Pattern} volume linear postgain of the distortion
  *
@@ -3924,7 +3839,7 @@ export const asym = _distortWithAlg('asym');
  * Wavefolding distortion
  *
  * @name fold
- * @tags distortion, superdough
+ * @tags fx
  * @param {number | Pattern} distortion amount of distortion to apply
  * @param {number | Pattern} volume linear postgain of the distortion
  *
@@ -3935,7 +3850,7 @@ export const fold = _distortWithAlg('fold');
  * Wavefolding distortion composed with sinusoid
  *
  * @name sinefold
- * @tags distortion, superdough
+ * @tags fx
  * @param {number | Pattern} distortion amount of distortion to apply
  * @param {number | Pattern} volume linear postgain of the distortion
  *
@@ -3946,7 +3861,7 @@ export const sinefold = _distortWithAlg('sinefold');
  * Distortion via Chebyshev polynomials
  *
  * @name chebyshev
- * @tags distortion, superdough
+ * @tags fx
  * @param {number | Pattern} distortion amount of distortion to apply
  * @param {number | Pattern} volume linear postgain of the distortion
  *
@@ -3980,7 +3895,7 @@ const _ensureListPattern = (list) => {
  * Can also be used to create a new synth via `s('user').partials(...)`
  *
  * @name partials
- * @tags superdough
+ * @tags fx, superdough
  * @param {number[] | Pattern} magnitudes List of [0, 1] magnitudes for partials. 0th entry is the fundamental harmonic (i.e. DC offset is skipped)
  * @example
  * s("user").seg(16).n(irand(8)).scale("A:major")
@@ -4002,7 +3917,7 @@ export const partials = (list) => {
  * Rotates the harmonics of one of the core synths ('sine', 'tri', 'saw', 'user', ..) by a list of phases
  *
  * @name phases
- * @tags superdough
+ * @tags fx, superdough
  * @param {number[] | Pattern} phases List of [0, 1) phases for partials. 0th entry is the fundamental phase (i.e. DC offset is skipped)
  * @example
  * // Phase cancellation
@@ -4024,7 +3939,7 @@ export const phases = (list) => {
  * calls and/or in a single .FX(fx1, fx2, ..) call. The fx1, .. are _patterns_ which
  * establish the controls of the given effect. See examples.
  * @name FX
- * @tags superdough
+ * @tags fx, superdough
  * @memberof Pattern
  * @returns Pattern
  * @example
@@ -4075,7 +3990,7 @@ const _asArrayPattern = (pats) => {
  *     by wrapping them inside a function in K (see example).
  *
  * @name K
- * @tags generators, superdough
+ * @tags generators, fx, superdough
  * @param {KabelsalatExpression | Function} expr Kabelsalat graph definition
  * @memberof Pattern
  * @returns Pattern
@@ -4132,59 +4047,3 @@ Pattern.prototype.worklet = function (src, ...inputs) {
 };
 
 export const worklet = (...args) => pure({}).worklet(...args);
-
-/**
- * Creates a pattern of numbers in base b from a number or pattern of numbers
- * limited to d digits long from the right
- *
- * @name base
- * @tags generators
- * @param {number} n - number to convert (can be a pattern or array)
- * @param {number} b - base to convert to (defaults to 10) (can be a pattern)
- * @param {number} d - max number of digits to produce for each n (defaults to 0 for all) (can be a pattern)
- * @example
- * $: note(base("7175 543", 10, 3)).scale("c:major").s("saw")
- * // $: note("1 7 5 5 4 3").scale("c:major").s("saw")
- */
-export const base = (n, b = 10, d = 0) => {
-  if (Array.isArray(n)) {
-    n = sequence(n);
-  }
-  n = reify(n);
-  b = reify(b);
-  d = reify(d);
-
-  return d
-    .withValue((e) => {
-      return b
-        .withValue((c) => {
-          return n
-            .withValue((v) => {
-              let digits = [];
-              let value = v;
-              while (value > 0) {
-                digits.unshift(value % c);
-                value = Math.floor(value / c);
-              }
-              if (e) {
-                const l = digits.length;
-                if (l > e) {
-                  digits = digits.slice(-1 * e);
-                }
-                /* 
-          if (l < e){
-            for (let i = l; i < e; i++) {
-              digits.unshift("~");//0); //Would like to be padding this but ~- doesn't work
-            }
-            console.log("digits", digits);
-          }
-          */
-              }
-              return sequence(digits);
-            })
-            .squeezeJoin();
-        })
-        .squeezeJoin();
-    })
-    .squeezeJoin();
-};

packages/core/pick.mjs

@@ -71,32 +71,29 @@ 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 or names
- * @param {function[] | object} lookup the array or lookup object of functions from which to pull
+ * @param {Pattern} lookup a pattern of indices
+ * @param {function[]} funcs the array of functions from which to pull
  * @returns {Pattern}
  * @example
  * 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)])
- * @example
- * note("<c2 d2>(3,8)").s("square")
- * .pickF("<jr l> f", { jr:jux(rev), f:fast(2), l:x=>x.lpf(800) })
+ *     .pickF("<0 2> 1", [jux(rev),fast(2),x=>x.lpf(800)])
  */
-export const pickF = register('pickF', function (pickPattern, lookup, pat) {
-  return pat.apply(pick(lookup, pickPattern));
+export const pickF = register('pickF', function (lookup, funcs, pat) {
+  return pat.apply(pick(lookup, funcs));
 });
 
 /** * 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 or names
- * @param {function[] | object} lookup the array or lookup object of functions from which to pull
+ * @param {Pattern} lookup a pattern of indices
+ * @param {function[]} funcs the array of functions from which to pull
  * @returns {Pattern}
  */
-export const pickmodF = register('pickmodF', function (pickPattern, lookup, pat) {
-  return pat.apply(pickmod(lookup, pickPattern));
+export const pickmodF = register('pickmodF', function (lookup, funcs, pat) {
+  return pat.apply(pickmod(lookup, funcs));
 });
 
 /** * Similar to `pick`, but it applies an outerJoin instead of an innerJoin.
@@ -170,22 +167,20 @@ 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
- * @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)
- */
+   * 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
+   * "<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)
+   */
 export const { inhabit, pickSqueeze } = register(['inhabit', 'pickSqueeze'], function (lookup, pat) {
   return _pick(lookup, pat, false).squeezeJoin();
 });

packages/core/repl.mjs

@@ -38,7 +38,6 @@ export function repl({
     pattern: undefined,
     miniLocations: [],
     widgets: [],
-    sliders: [],
     pending: false,
     started: false,
   };
@@ -80,132 +79,11 @@ export function repl({
   let allTransform;
   let eachTransform;
 
-  // Block-based evaluation state
-  let codeBlocks = {};
-  let lastActiveVisualizerLabel = null;
-  // Track which patterns belong to which blocks: { blockRange: [patternKeys] }
-  let blockPatterns = new Map();
-
-  // Helper function to collect properties from all code blocks (handles both labeled and anonymous blocks)
-  function collectFromBlocks(property) {
-    return Object.entries(codeBlocks).flatMap(([key, block]) => {
-      if (key === '$') {
-        // Anonymous blocks are stored as an array of block objects
-        return Array.isArray(block) ? block.flatMap((b) => b[property] || []) : [];
-      }
-      // Labeled blocks are stored as single block objects
-      return block[property] || [];
-    });
-  }
-
-  // Helper function to process a single labeled block
-  function processLabeledBlock(labels, i, code, options, meta) {
-    const label = labels[i];
-    const nextLabel = labels[i + 1] || { index: code.length, end: code.length };
-
-    const labelCode = code.slice(label.index, nextLabel.index);
-    const labelRange = [label.index + options.range[0], label.end + options.range[0]];
-
-    // Calculate the full block range (from label start to next label start)
-    const blockStart = label.index + options.range[0];
-    const blockEnd = nextLabel.index + options.range[0];
-
-    const blockWidgets = (meta?.widgets || []).filter((widget) => {
-      const widgetPos = widget.from ?? widget.index ?? 0;
-      return widgetPos >= blockStart && widgetPos < blockEnd;
-    });
-
-    const blockSliders = (meta?.sliders || []).filter((slider) => {
-      const sliderPos = slider.from ?? slider.index ?? 0;
-      return sliderPos >= blockStart && sliderPos < blockEnd;
-    });
-
-    const blockMiniLocations = (meta?.miniLocations || []).filter((loc) => {
-      // const locStart = loc.start ?? loc.from ?? 0;
-      // mini locations can be either [start, end] arrays or objects with start/from
-      const locStart = Array.isArray(loc) ? loc[0] : (loc.start ?? loc.from ?? 0);
-      return locStart >= blockStart && locStart < blockEnd;
-    });
-
-    handleSingleLabelBlock(
-      label,
-      labelCode,
-      { ...options, range: labelRange },
-      { widgets: blockWidgets, sliders: blockSliders, miniLocations: blockMiniLocations },
-    );
-  }
-
-  // helper
-  function cleanupConflictingRanges(codeBlocks, currentKey, newRange) {
-    for (const [existingKey, existingBlock] of Object.entries(codeBlocks)) {
-      if (existingKey === currentKey) continue;
-      if (!existingBlock.range) continue;
-
-      const [existingStart, existingEnd] = existingBlock.range;
-      const [newStart, newEnd] = newRange;
-
-      // If ranges overlap (not just touch), remove the stale block
-      if (!(newEnd <= existingStart || newStart >= existingEnd)) {
-        delete codeBlocks[existingKey];
-      }
-    }
-  }
-
-  // helper
-  function handleSingleLabelBlock(label, code, options, meta) {
-    // Detect if this block contains a non-inline widget
-    // The activeVisualizer is now provided by the transpiler for all labels
-    const activeVisualizer = label.activeVisualizer || null;
-
-    if (activeVisualizer !== null) {
-      lastActiveVisualizerLabel = label.name;
-    }
-
-    // Store the entire code block under the label name
-    codeBlocks[label.name] = {
-      code: code,
-      range: options.range,
-      labels: [label.name],
-      miniLocations: meta?.miniLocations || [],
-      widgets: meta?.widgets || [],
-      sliders: meta?.sliders || [],
-      activeVisualizer: activeVisualizer, // Store the widget type if present, null otherwise
-    };
-
-    // Clean up any blocks with conflicting ranges (including declaration blocks)
-    cleanupConflictingRanges(codeBlocks, label.name, options.range);
-  }
-
-  // helper
-  // These blocks return silence but may contain mini notation strings that need highlighting
-  function handleDeclarationBlock(code, options, meta) {
-    const range = options.range || [];
-    if (range.length < 2) return;
-
-    const blockKey = `_decl:${range[0]}:${range[1]}`;
-
-    codeBlocks[blockKey] = {
-      code: code,
-      range: range,
-      labels: [],
-      miniLocations: meta?.miniLocations || [],
-      widgets: meta?.widgets || [],
-      sliders: meta?.sliders || [],
-      activeVisualizer: null,
-    };
-
-    // Clean up any overlapping declaration blocks
-    cleanupConflictingRanges(codeBlocks, blockKey, range);
-  }
-
   const hush = function () {
     pPatterns = {};
     anonymousIndex = 0;
     allTransform = undefined;
     eachTransform = undefined;
-    codeBlocks = {};
-    blockPatterns.clear();
-    lastActiveVisualizerLabel = null; // Reset 'all' visualizer tracking
     return silence;
   };
 
@@ -225,60 +103,7 @@ export function repl({
   };
   setTime(() => scheduler.now()); // TODO: refactor?
 
-  // Helper function to apply pattern transformations (solo, each, all)
-  // this should be abstracted more
-  function applyPatternTransforms(pattern) {
-    const allPatterns = Object.values(pPatterns);
-
-    if (allPatterns.length) {
-      let patterns = [];
-      let soloActive = false;
-      for (const [key, value] of Object.entries(pPatterns)) {
-        // handle soloed patterns ex: S$: s("bd!4")
-        const isSolod = key.length > 1 && key.startsWith('S');
-        if (isSolod && soloActive === false) {
-          // first time we see a soloed pattern, clear existing patterns
-          patterns = [];
-          soloActive = true;
-        }
-        if (!soloActive || (soloActive && isSolod)) {
-          const valWithState = value.withState((state) => state.setControls({ id: key }));
-          patterns.push(valWithState);
-        }
-      }
-      if (eachTransform) {
-        // Explicit lambda so only element (not index and array) are passed
-        patterns = patterns.map((x) => eachTransform(x));
-      }
-      pattern = stack(...patterns);
-    } else if (eachTransform) {
-      pattern = eachTransform(pattern);
-    }
-    if (allTransforms.length) {
-      for (const transform of allTransforms) {
-        pattern = transform(pattern);
-      }
-    }
-
-    if (!isPattern(pattern)) {
-      pattern = silence;
-    }
-
-    return pattern;
-  }
-
-  const stop = () => {
-    codeBlocks = {};
-    blockPatterns.clear();
-    pPatterns = {};
-    lastActiveVisualizerLabel = null; // Reset 'all' visualizer tracking
-    updateState({
-      miniLocations: [],
-      widgets: [],
-      sliders: [],
-    });
-    scheduler.stop();
-  };
+  const stop = () => scheduler.stop();
   const start = () => scheduler.start();
   const pause = () => scheduler.pause();
   const toggle = () => scheduler.toggle();
@@ -307,12 +132,8 @@ export function repl({
 
   let allTransforms = [];
   /**
-   * Applies a function to all the running patterns. Note that the patterns are grouped together into a single `stack` before the function is applied. This is probably what you want, but see `each` for
+   * 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.
-   *
-   * **Note:** Patterns must be labeled (e.g. with `$:`) to be picked up by `all`. An unlabeled
-   * pattern such as `note("c4")` is not registered and will produce no audio when `all` is present.
-   * Use `$: note("c4")` instead.
    * ```
    * $: sound("bd - cp sd")
    * $: sound("hh*8")
@@ -332,9 +153,6 @@ export function repl({
   };
   /** 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.
    *
-   * **Note:** Patterns must be labeled (e.g. with `$:`) to be picked up by `each`. An unlabeled
-   * pattern such as `note("c4")` is not registered and will produce no audio when `each` is present.
-   * Use `$: note("c4")` instead.
    * ```
    * $: sound("bd - cp sd")
    * $: sound("hh*8")
@@ -399,7 +217,7 @@ export function repl({
     });
   };
 
-  const evaluate = async (code, autostart = true) => {
+  const evaluate = async (code, autostart = true, shouldHush = true) => {
     if (!code) {
       throw new Error('no code to evaluate');
     }
@@ -407,146 +225,59 @@ export function repl({
       updateState({ code, pending: true });
       await injectPatternMethods();
       setTime(() => scheduler.now()); // TODO: refactor?
-      await beforeEval?.({ code, blockBased: false });
+      await beforeEval?.({ code });
       allTransforms = []; // reset all transforms
-
-      codeBlocks = {};
-      hush();
+      shouldHush && hush();
 
       if (mondo) {
         code = `mondolang\`${code}\``;
       }
-
       let { pattern, meta } = await _evaluate(code, transpiler, transpilerOptions);
-
-      pattern = applyPatternTransforms(pattern);
-
-      logger(`[eval] code updated`);
-      pattern = await setPattern(pattern, autostart);
-      updateState({
-        miniLocations: meta?.miniLocations || [],
-        widgets: meta?.widgets || [],
-        sliders: meta?.sliders || [],
-        activeCode: code,
-        pattern,
-        evalError: undefined,
-        schedulerError: undefined,
-        pending: false,
-      });
-
-      afterEval?.({ code, pattern, meta, range: undefined, widgetRemoved: false });
-      return pattern;
-    } catch (err) {
-      logger(`[eval] error: ${err.message}`, 'error');
-      console.error(err);
-      updateState({ evalError: err, pending: false });
-      onEvalError?.(err);
-    }
-  };
-
-  const evaluateBlock = async (code, autostart = true, options = {}) => {
-    if (!code) {
-      throw new Error('no code to evaluate');
-    }
-    try {
-      updateState({ code, pending: true });
-      await injectPatternMethods();
-      setTime(() => scheduler.now()); // TODO: refactor?
-      await beforeEval?.({ code, blockBased: true });
-      allTransforms = []; // reset all transforms
-
-      const transpilerOptionsWithBlock = {
-        ...transpilerOptions,
-        blockBased: true,
-        range: options.range || [],
-      };
-
-      if (mondo) {
-        code = `mondolang\`${code}\``;
-      }
-
-      let { pattern, meta } = await _evaluate(code, transpiler, transpilerOptionsWithBlock);
-
-      // Track activeVisualizer cleanup: check if any block's visualizer was removed
-      let widgetRemoved = false;
-
-      const labels = meta.labels || [];
-
-      // Check for anonymous labels (labels starting with '$')
-      const hasAnonymousLabel = labels.some((label) => label.name.startsWith('$'));
-
-      // Store code blocks in dictionary using labels as keys
-      if (hasAnonymousLabel) {
-        // variable/function declarations that don't return patterns are allowed,
-        // but anonymous pattern blocks pose an issue for block-based evaluation
-        // if an anonymous pattern is evaluated multiple times it will just stack and get louder and louder
-
-        // it's very common for users to write code prefixed with '$'
-        // but to modify and override existing patterns, the patterns must be labeled,
-        // otherwise we'll have no idea of which pattern is being overridden
-
-        // (we probably need to update the docs on this)
-        // we could easily enable it, but it would confuse a lot of people
-
-        throw new Error(
-          'anonymous labels disabled for block based evaluation (see https://strudel.cc/blog/#label-notation)',
-        );
-      } else if (labels.length > 0) {
-        for (let i = 0; i < labels.length; i++) {
-          // processing transpiler output instead of code is simply to avoid
-          // extra regex in detecting whether or not an inline widget has been commented out
-          processLabeledBlock(labels, i, meta.output, options, meta);
-        }
-      } else {
-        // Declaration block (variable/function that returns silence)
-        // Store it so its miniLocations are preserved for highlighting patterns stored in variables
-        handleDeclarationBlock(code, options, meta);
-      }
-
-      meta.miniLocations = collectFromBlocks('miniLocations');
-      meta.widgets = collectFromBlocks('widgets');
-      meta.sliders = collectFromBlocks('sliders');
-
-      // Track activeVisualizer cleanup: check if any block's visualizer was removed
-      const blocksToUpdate = labels.map((label) => label.name);
-
-      // this is the hackiest bit
-      for (const [key, block] of Object.entries(codeBlocks)) {
-        if (blocksToUpdate.includes(key)) {
-          // This block was just updated
-          if (block.activeVisualizer !== null) {
-            // Block now has a visualizer, update tracking
-            lastActiveVisualizerLabel = key;
-          } else if (lastActiveVisualizerLabel === key) {
-            // This block lost its visualizer, trigger cleanup
-            widgetRemoved = true;
-            lastActiveVisualizerLabel = null;
+      if (Object.keys(pPatterns).length) {
+        let patterns = [];
+        let soloActive = false;
+        for (const [key, value] of Object.entries(pPatterns)) {
+          // handle soloed patterns ex: S$: s("bd!4")
+          const isSolod = key.length > 1 && key.startsWith('S');
+          if (isSolod && soloActive === false) {
+            // first time we see a soloed pattern, clear existing patterns
+            patterns = [];
+            soloActive = true;
+          }
+          if (!soloActive || (soloActive && isSolod)) {
+            const valWithState = value.withState((state) => state.setControls({ id: key }));
+            patterns.push(valWithState);
           }
         }
+        if (eachTransform) {
+          // Explicit lambda so only element (not index and array) are passed
+          patterns = patterns.map((x) => eachTransform(x));
+        }
+        pattern = stack(...patterns);
+      } else if (eachTransform) {
+        pattern = eachTransform(pattern);
+      }
+      if (allTransforms.length) {
+        for (const transform of allTransforms) {
+          pattern = transform(pattern);
+        }
       }
 
-      pPatterns = Object.fromEntries(
-        Object.entries(pPatterns).filter(([key]) => {
-          return Object.keys(codeBlocks).includes(key);
-        }),
-      );
-
-      pattern = applyPatternTransforms(pattern);
-
+      if (!isPattern(pattern)) {
+        pattern = silence;
+      }
       logger(`[eval] code updated`);
       pattern = await setPattern(pattern, autostart);
       updateState({
         miniLocations: meta?.miniLocations || [],
         widgets: meta?.widgets || [],
-        sliders: meta?.sliders || [],
         activeCode: code,
         pattern,
         evalError: undefined,
         schedulerError: undefined,
         pending: false,
       });
-
-      afterEval?.({ code, pattern, meta, range: options.range, widgetRemoved });
+      afterEval?.({ code, pattern, meta });
       return pattern;
     } catch (err) {
       logger(`[eval] error: ${err.message}`, 'error');
@@ -555,9 +286,8 @@ export function repl({
       onEvalError?.(err);
     }
   };
-
   const setCode = (code) => updateState({ code });
-  return { scheduler, evaluate, evaluateBlock, start, stop, pause, setCps, setPattern, setCode, toggle, state };
+  return { scheduler, evaluate, start, stop, pause, setCps, setPattern, setCode, toggle, state };
 }
 
 export const getTrigger =

packages/core/signal.mjs

@@ -316,7 +316,7 @@ export const run = (n) => saw.range(0, n).round().segment(n);
  * // "hh".s().struct("1 0 1")
  */
 export const binary = (n) => {
-  const nBits = reify(n).log2().floor().add(1);
+  const nBits = reify(n).log2(0).floor().add(1);
   return binaryN(n, nBits);
 };
 
@@ -348,7 +348,7 @@ export const binaryN = (n, nBits = 16) => {
  *   .partials(binaryL(irand(4096).add(1)))
  */
 export const binaryL = (n) => {
-  const nBits = reify(n).log2().floor().add(1);
+  const nBits = reify(n).log2(0).floor().add(1);
   return binaryNL(n, nBits);
 };
 
@@ -389,9 +389,7 @@ export const randL = (n) => {
 export const randrun = (n) => {
   return signal((t, controls) => {
     // Without adding 0.5, the first cycle is always 0,1,2,3,...
-    let rands = getRandsAtTime(t.floor().add(0.5), n, controls.randSeed);
-    // Support n = 1
-    if (!Array.isArray(rands)) rands = [rands];
+    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]))

packages/core/test/signal.test.mjs

@@ -9,7 +9,7 @@ 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, note } from '../index.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));
@@ -59,9 +59,3 @@ describe('perx', () => {
     );
   });
 });
-
-describe('shuffle', () => {
-  it('returns original pattern if input is 1', () => {
-    expect(note('c d e f').sound('piano').shuffle(1).firstCycle()).toEqual(note('c d e f').sound('piano').firstCycle());
-  });
-});

packages/core/util.mjs

@@ -339,13 +339,8 @@ export function uniqsortr(a) {
 
 export function unicodeToBase64(text) {
   const utf8Bytes = new TextEncoder().encode(text);
-  let binaryString = '';
-  const chunkSize = 0x8000;
-  for (let i = 0; i < utf8Bytes.length; i += chunkSize) {
-    const chunk = utf8Bytes.subarray(i, i + chunkSize);
-    binaryString += String.fromCharCode.apply(null, chunk);
-  }
-  return btoa(binaryString);
+  const base64String = btoa(String.fromCharCode(...utf8Bytes));
+  return base64String;
 }
 
 export function base64ToUnicode(base64String) {

packages/draw/draw.mjs

@@ -78,16 +78,6 @@ export const cleanupDraw = (clearScreen = true, id) => {
   stopAllAnimations(id);
 };
 
-export const cleanupDrawContext = (replID) => {
-  const ctx = getDrawContext();
-  ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
-
-  // clear the big canvas context, ignore inline widgets
-  Object.keys(animationFrames).forEach(
-    (id) => (!replID || id.startsWith(replID)) && !id.startsWith('_') && stopAnimationFrame(id),
-  );
-};
-
 Pattern.prototype.onPaint = function (painter) {
   return this.withState((state) => {
     if (!state.controls.painters) {

packages/draw/pitchwheel.mjs

@@ -54,42 +54,11 @@ export function pitchwheel({
   }
 
   if (edo) {
-    edo = haps.length >= 1 && haps[0].value && haps[0].value.edo ? haps[0].value.edo : edo;
-    root = haps.length >= 1 && haps[0].value && haps[0].value.root ? haps[0].value.root : root;
-    const degreeIndexes =
-      haps.length >= 1 && haps[0].value && haps[0].value.degreeIndexes ? haps[0].value.degreeIndexes : null;
-    const intLabels = haps.length >= 1 && haps[0].value && haps[0].value.intLabels ? haps[0].value.intLabels : null;
-    ctx.font = '20px sans-serif';
-    const label = `${edo} EDO`;
-    // Draw EDO label:
-    ctx.fillText(label, centerX + radius - ctx.measureText(label).width + 15, centerY + radius);
     Array.from({ length: edo }, (_, i) => {
       const angle = freq2angle(root * Math.pow(2, i / edo), root);
-
       const [x, y] = circlePos(centerX, centerY, radius, angle);
       ctx.beginPath();
-      // Draw interval label for degree i when it exists:
-      if (degreeIndexes === null || degreeIndexes.includes(i)) {
-        ctx.globalAlpha = 1;
-        ctx.arc(x, y, hapRadius, 0, 2 * Math.PI);
-        if (intLabels !== null) {
-          const degree = degreeIndexes.indexOf(i);
-          if (intLabels[degree]) {
-            if (angle < 0.32 && angle > 0.125) {
-              ctx.fillText(intLabels[degree], x - 34, y);
-            } else {
-              if (angle < 0.1 && angle > -1.125) {
-                ctx.fillText(intLabels[degree], x - 7, y - 12);
-              } else {
-                ctx.fillText(intLabels[degree], x + 9, y);
-              }
-            }
-          }
-        }
-      } else {
-        ctx.globalAlpha = 0.15;
-        ctx.arc(x, y, hapRadius, 0, 2 * Math.PI);
-      }
+      ctx.arc(x, y, hapRadius, 0, 2 * Math.PI);
       ctx.fill();
     });
     ctx.stroke();

packages/edo/README.md

@@ -1,41 +0,0 @@
-# @strudel/edo
-
-This package adds EDO scale functions to strudel Patterns.
-
-## Install
-
-```sh
-npm i @strudel/edo --save
-```
-
-## Example
-
-```js
-import { n } from '@strudel/core';
-import '@strudel/edo';
-
-// E.g. edoScale for Gorgo-6 scale, 16 EDO, LLsLLLs
-// base note C3, large step size 3, small step size 1:
-// C3:LLsLLL:3:1
-const [baseNote, sequence, largeStep, smallStep] = ['C3', 'LLsLLL', 3, 1]
-const pattern = n("0 2 4 6 4 2").edoScale([baseNote, sequence, largeStep, smallStep]);
-
-const events = pattern.firstCycle().map((e) => e.show());
-console.log(events);
-```
-
-yields:
-```
-[
-    "[ 0/1 → 1/1 |
-      {
-        \"degree\":1,
-        \"degreeIndexes\":[0,3,6,7,10,13],
-        \"intLabels\":[null,\"S2\",\"d4\",\"N4\",\"s6\",\"s7\",\"P8\"],
-        \"root\":\"130.8128\",
-        \"freq\":130.813,
-        \"edo\":16
-      }
-    ]"
-]
-```

packages/edo/edo.mjs

@@ -1,114 +0,0 @@
-/*
-edo.mjs - Equal division of the octave (EDO) scale functions for strudel
-Copyright (C) 2025 Rob McKinnon and Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/edo/edo.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, pure, noteToMidi, isNote, tokenizeNote } from '@strudel/core';
-import { EdoScale } from './edoscale.mjs';
-import { Intervals } from './intervals.mjs';
-import { Pitches } from './pitches.mjs';
-
-const pitchesCache = new Map();
-
-/**
- * Turns numbers into notes in the given EDO scale (zero indexed).
- *
- * An EDO scale definition looks like this:
- *
- * e.g. C:LLsLLLs:2:1 <- this is the C major scale, 12 EDO
- *
- * e.g. C:LLsLLL:3:1 <- this is the Gorgo 6 note scale, 16 EDO
- *
- * An EDO scale, e.g. C:LLsLLLs:2:1, consists of a root note (e.g. C)
- * followed by semicolon (':')
- * and then a [Large/small step notation sequence](https://en.xen.wiki/w/MOS_scale)
- * (e.g. LLsLLLs)
- * followed by semicolon, then the large step size (e.g. 2)
- * followed by semicolon, then the small step size (e.g. 1).
- *
- * The number of divisions of the octave is calculated as the sum
- * of the steps in the EDO scale definition.
- *
- * e.g. C:LLsLLLs:2:1 is 2+2+1+2+2+2+1 = 12 EDO, 7 note scale
- *
- * e.g. C:LLsLLL:3:1 is 3+3+1+3+3+3 = 16 EDO, 6 note scale
- *
- * The root note defaults to octave 3, if no octave number is given.
- *
- * @name edoScale
- * @param {string} scale Definition of EDO scale.
- * @returns Pattern
- * @example
- * n("0 2 4 6 4 2").edoScale("C:LLsLLLs:2:1")
- * @example
- * n("[0,7] 4 [2,7] 4")
- * .edoScale("G2:<LLsLLL LLLLsL>:3:1")
- * .s("piano")._pitchwheel()
- * @example
- * n(rand.range(0,5).segment(6))
- * .edoScale("<G2 C3>:LLsLL:3:1")
- * .s("piano")._pitchwheel()
- */
-export const edoScale = register(
-  'edoScale',
-  function (scaleDefinition, pat) {
-    // console.log(scaleDefinition);
-
-    // if (Array.isArray(scale)) {
-    const key = scaleDefinition.flat().join(':');
-    // }
-    // console.log(scaleDefinition);
-    let pitches;
-    if (pitchesCache.has(key)) {
-      pitches = pitchesCache.get(key);
-    } else {
-      // console.log({ key });
-      const [base_note, sequence, large, small] = scaleDefinition;
-      const root_octave = tokenizeNote(base_note)[2] || 3;
-      // console.log({ root_octave });
-      const scale = new EdoScale(large, small, sequence);
-      const intervals = new Intervals(scale);
-      // console.log({ intervals });
-      pitches = new Pitches(scale, intervals, 440, noteToMidi(base_note), root_octave);
-      pitchesCache.set(key, pitches);
-      // console.log({ base_note: noteToMidi(base_note) });
-      // console.log({ sequence });
-      // console.log({ edivisions: scale.edivisions });
-      // console.log({ intervals });
-      // console.log({ pat });
-      // console.log({ pitches: pitches });
-    }
-    return pat
-      .fmap((value) => {
-        const isObject = typeof value === 'object';
-        const n = isObject ? value.n : value;
-        if (isObject) {
-          delete value.n; // remove n so it won't cause trouble
-        }
-        if (isNote(n)) {
-          // legacy..
-          return pure(n);
-        }
-        const deg = (typeof n === 'string' ? parseInt(n, 10) : Number.isInteger(n) ? n : Math.round(n)) + 1;
-
-        const [oct, degree] = pitches.octdeg(deg);
-        const freq = pitches.octdegfreq(oct, degree);
-        const note = pitches.octdegmidi(oct, degree);
-        const edo = pitches.scale.edivisions;
-        const root = pitches.base_freq;
-        const degreeIndexes = pitches.scale.divisions;
-        const intLabels = pitches.intervals.intLabels;
-        // const color = 'red';
-        value = pure(isObject ? { ...value, degree, degreeIndexes, intLabels, root, freq, edo } : note);
-        // value = pure(isObject ? { ...value, key } : note);
-        // value = pure(isObject ? { ...value, edo } : note);
-        // console.log({ value });
-        return value;
-      })
-      .outerJoin()
-      .withHap((hap) => hap.setContext({ ...hap.context, scaleDefinition }));
-  },
-  true,
-  true, // preserve tactus
-);

packages/edo/edoscale.mjs

@@ -1,213 +0,0 @@
-/*
-edoscale.mjs - EdoScale defines equal division of the octave (EDO) scale in Ls notation
-             - Port of pitfalls/lib/Scale.lua - see <https://github.com/robmckinnon/pitfalls/blob/main/lib/Scale.lua>
-Copyright (C) 2025 Rob McKinnon and Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/edo/edoscale.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 M = 2;
-const L = 1;
-const S = 0;
-const LABELS = ['s', 'L', 'M'];
-
-export class EdoScale {
-  constructor(large, small, sequence, medium) {
-    this.stepbackup = [L, L, S, L, L, L, S, L, L, L, S, L, L, L, S, L];
-    this.large = large;
-    this.medium = medium || large;
-    this.small = small;
-    this.divisions = [];
-    this.edivisions = null;
-    this.sequence = null;
-    this.tonic = 1;
-    this.mode = 1;
-    this.max_steps = 12;
-    this.min_steps = 3;
-    this.setSequence(sequence);
-  }
-
-  hasMedium() {
-    return this.step.some((_, i) => this.step[this.offset(i)] === M);
-  }
-
-  stepSize(i) {
-    return LABELS[this.step[this.offset(i)]];
-  }
-
-  sequence() {
-    return this.step.map((_, i) => this.stepSize(i)).join('');
-  }
-
-  stepValue(i) {
-    const step = this.step[this.offset(i)];
-    return step === L ? this.large : step === M ? this.medium : this.small;
-  }
-
-  offset(i) {
-    if (this.mode === 1) {
-      return i;
-    } else {
-      const offset = (this.mode - 1 + i) % this.length;
-      return offset === 0 ? this.length : offset;
-    }
-  }
-
-  static setMaxSteps(max) {
-    this.max_steps = max;
-  }
-
-  static setMinSteps(min) {
-    this.min_steps = min;
-  }
-
-  setSequence(sequence) {
-    if (this.sequence !== sequence) {
-      this.sequence = sequence;
-      this.length = sequence.length;
-      this.step = [];
-      for (let i = 0; i < sequence.length; i++) {
-        const char = sequence[i];
-        this.step[i] = char === 'L' ? L : char === 'M' ? M : S;
-      }
-      this.updateEdo();
-    } else {
-      return false;
-    }
-  }
-
-  setLarge(l) {
-    if (this.large !== l) {
-      this.large = l;
-      this.updateEdo();
-    } else {
-      return false;
-    }
-  }
-
-  setMedium(m) {
-    if (this.medium !== m) {
-      this.medium = m;
-      this.updateEdo();
-    } else {
-      return false;
-    }
-  }
-
-  setSmall(s) {
-    if (this.small !== s) {
-      this.small = s;
-      this.updateEdo();
-    } else {
-      return false;
-    }
-  }
-
-  setMode(mode) {
-    this.mode = mode;
-  }
-
-  setTonic(tonic) {
-    this.tonic = tonic;
-  }
-
-  changeMode(d) {
-    const orig = this.mode;
-    this.mode = Math.max(1, Math.min(this.mode + d, this.length));
-    return orig !== this.mode;
-  }
-
-  changeTonic(d) {
-    const orig = this.tonic;
-    this.tonic = Math.max(1, Math.min(this.tonic + d, this.edivisions));
-    return orig !== this.tonic;
-  }
-
-  updateEdo() {
-    const orig = this.edivisions;
-    this.edivisions = this.step.reduce((sum, _, i) => {
-      this.divisions[i] = sum;
-      return sum + this.stepValue(i);
-    }, 0);
-    // console.log(this.divisions);
-    const changed = orig !== this.edivisions;
-    if (changed) {
-      this.tonic = Math.max(1, Math.min(this.tonic, this.edivisions));
-    }
-    return changed;
-  }
-
-  changeStep(d, i) {
-    const index = this.offset(i);
-    const orig = this.step[index];
-    this.step[index] = Math.max(S, Math.min(this.step[index] + d, M));
-    this.stepbackup[index] = this.step[index];
-    const changed = orig !== this.step[index];
-    if (changed) {
-      this.updateEdo();
-    }
-    return changed;
-  }
-
-  changeLarge(d) {
-    const orig = this.large;
-    this.setLarge(Math.max(this.small + 1, Math.min(this.large + d, this.large + 1)));
-    const changed = this.large !== orig;
-    if (changed) {
-      if (this.large <= this.medium) {
-        this.setMedium(Math.max(this.small + 1, Math.min(this.large - 1, this.large)));
-      }
-      this.updateEdo();
-    }
-    return changed;
-  }
-
-  changeMedium(d) {
-    const orig = this.medium;
-    this.setMedium(Math.max(this.small + 1, Math.min(this.medium + d, this.large - 1)));
-    const changed = this.medium !== orig;
-    if (changed) {
-      this.updateEdo();
-    }
-    return changed;
-  }
-
-  changeSmall(d) {
-    const orig = this.small;
-    const value = this.small + d;
-
-    if (this.hasMedium()) {
-      this.setSmall(Math.max(1, Math.min(value, this.medium - 1)));
-    } else {
-      this.setSmall(Math.max(1, Math.min(value, this.large - 1)));
-    }
-
-    const changed = this.small !== orig;
-    if (changed) {
-      if (this.small >= this.medium) {
-        this.setMedium(Math.max(this.small + 1, Math.min(this.large)));
-      }
-      this.updateEdo();
-    }
-    return changed;
-  }
-
-  changeLength(d) {
-    const orig = this.length;
-    if (d === 1) {
-      this.length = Math.min(this.length + 1, this.max_steps);
-    } else if (d === -1) {
-      this.length = Math.max(this.length - 1, this.min_steps);
-    }
-
-    const changed = this.length !== orig;
-    if (changed) {
-      this.mode = 1;
-      if (d === 1) {
-        this.step[this.length] = this.stepbackup[this.length] || L;
-      } else if (d === -1 && this.length >= this.min_steps) {
-        this.step.pop();
-      }
-      this.updateEdo();
-    }
-    return changed;
-  }
-}

packages/edo/index.mjs

@@ -1,5 +0,0 @@
-import './edo.mjs';
-
-export * from './edo.mjs';
-
-export const packageName = '@strudel/edo';

packages/edo/intervals.mjs

@@ -1,103 +0,0 @@
-/*
-intervals.mjs - defines Intervals for equal division of the octave (EDO) scale
-              - Port of pitfalls/lib/Intervals.lua - see <https://github.com/robmckinnon/pitfalls/blob/main/lib/Intervals.lua>
-Copyright (C) 2025 Rob McKinnon and Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/edo/intervals.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 ratiointervals from './ratios.mjs';
-
-function ratio(division, edivisions) {
-  return division === 0 ? 1 : Math.pow(2, division / edivisions);
-}
-
-export class Intervals {
-  constructor(scale) {
-    this.scale = scale;
-    this.intLabels = [];
-    this.intNoms = [];
-    this.intRatios = [];
-    this.uniqLabels = [];
-    this.intErrors = [];
-    this.ratios = [];
-
-    const BLANK = '';
-    let division = 0;
-    const labToErr = {};
-    const labToInd = {};
-
-    this.ratios[0] = 1;
-
-    for (let i = 0; i < scale.length; i++) {
-      division += scale.stepValue(i);
-      this.ratios[i + 1] = ratio(division, scale.edivisions);
-
-      if (i < scale.length) {
-        const nearest = ratiointervals.nearestInterval(this.ratios[i + 1]);
-        const closeness = nearest[0];
-        const ratio = nearest[1];
-        const intLabel = ratiointervals.key(ratio);
-        this.intLabels[i + 1] = intLabel;
-        this.intErrors[i + 1] = closeness;
-        this.intNoms[i + 1] = ratio ? ratiointervals.nom(ratio) : 0;
-        this.intRatios[i + 1] = ratio ? `${ratiointervals.nom(ratio)}/${ratiointervals.denom(ratio)}` : '';
-        this.uniqLabels[i + 1] = BLANK;
-
-        if (intLabel && intLabel !== 'P1' && intLabel !== 'P8') {
-          if (!labToErr[intLabel]) {
-            this.uniqLabels[i + 1] = intLabel;
-            labToInd[intLabel] = i + 1;
-            labToErr[intLabel] = closeness;
-          } else if (closeness < labToErr[intLabel]) {
-            this.uniqLabels[labToInd[intLabel]] = BLANK;
-            this.uniqLabels[i + 1] = intLabel;
-            labToInd[intLabel] = i + 1;
-            labToErr[intLabel] = closeness;
-          }
-        }
-      }
-    }
-  }
-
-  ratio(i) {
-    return this.ratios[i];
-  }
-
-  intervalLabel(i) {
-    return this.intLabels[i];
-  }
-
-  intervalNominator(i) {
-    return this.intNoms[i];
-  }
-
-  intervalRatio(i) {
-    return this.intRatios[i];
-  }
-
-  uniqIntervalLabel(i) {
-    return this.uniqLabels[i];
-  }
-
-  intervalError(i) {
-    return this.intErrors[i];
-  }
-
-  nearestDegreeTo(r, threshold) {
-    let min = 1;
-    let degree = null;
-
-    for (const [i, v] of Object.entries(this.ratios)) {
-      const diff = Math.abs((r - v) / r);
-      if (diff < min) {
-        min = diff;
-        degree = parseInt(i, 10);
-      }
-    }
-
-    if (threshold == null) {
-      return degree;
-    } else {
-      return min < threshold ? degree : 1;
-    }
-  }
-}

packages/edo/package.json

@@ -1,42 +0,0 @@
-{
-  "name": "@strudel/edo",
-  "version": "0.1.0",
-  "description": "Equal division of the octave (EDO) scale functions for strudel",
-  "main": "index.mjs",
-  "publishConfig": {
-    "main": "dist/index.mjs"
-  },
-  "scripts": {
-    "build": "vite build",
-    "test": "vitest run",
-    "prepublishOnly": "npm run build"
-  },
-  "type": "module",
-  "repository": {
-    "type": "git",
-    "url": "git+https://codeberg.org/uzu/strudel.git"
-  },
-  "keywords": [
-    "tidalcycles",
-    "strudel",
-    "pattern",
-    "livecoding",
-    "algorave"
-  ],
-  "author": "Rob McKinnon <rob@movingflow>",
-  "license": "AGPL-3.0-or-later",
-  "bugs": {
-    "url": "https://codeberg.org/uzu/strudel/issues"
-  },
-  "homepage": "https://codeberg.org/uzu/strudel#readme",
-  "dependencies": {
-    "@strudel/core": "workspace:*",
-    "@tonaljs/tonal": "^4.10.0",
-    "chord-voicings": "^0.0.1",
-    "webmidi": "^3.1.12"
-  },
-  "devDependencies": {
-    "vite": "^6.0.11",
-    "vitest": "^3.0.4"
-  }
-}

packages/edo/pitches.mjs

@@ -1,98 +0,0 @@
-/*
-pitches.mjs - defines Pitches for equal division of the octave (EDO) scale
-            - Port of pitfalls/lib/Pitches.lua - see <https://github.com/robmckinnon/pitfalls/blob/main/lib/Pitches.lua>
-Copyright (C) 2025 Rob McKinnon and Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/edo/pitches.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/>.
-*/
-
-function ratio(division, edivisions) {
-  return division === 0 ? 1 : Math.pow(2, division / edivisions);
-}
-
-// This function gets frequency based on index, edo, octave, and base frequency
-function get_freq(base_freq, edo, index, oct, base_octave) {
-  let f = base_freq * ratio(index - 1, edo);
-  if (oct < base_octave) {
-    f /= Math.pow(2, base_octave - oct);
-  } else if (oct > base_octave) {
-    f *= Math.pow(2, oct - base_octave);
-  }
-  return f;
-}
-
-// Convert MIDI number to Hz using a given tuning multiplier
-function midi_to_hz(n, tuning) {
-  return tuning * Math.pow(2, (n - 69) / 12.0);
-}
-
-const denom = Math.log(2);
-function hz_to_midi(freq, tuning) {
-  return 12.0 * (Math.log(freq / tuning) / denom) + 69;
-}
-
-export class Pitches {
-  constructor(scale, intervals, tuning, midi_start, root_octave) {
-    this.scale = scale;
-    this.intervals = intervals;
-    this.base_freq = midi_to_hz(midi_start, tuning);
-    this.root_octave = root_octave;
-    this.freqs = {};
-    this.midis = {};
-    this.degrees = {};
-    this.octdegfreqs = {};
-    this.octdegmidis = {};
-    let index = 0;
-    let f = null;
-
-    for (let oct = 0; oct <= 8; oct++) {
-      this.octdegfreqs[oct] = {};
-      this.octdegmidis[oct] = {};
-      f = get_freq(this.base_freq, scale.edivisions, scale.tonic, oct, this.root_octave);
-      for (let deg = 0; deg < scale.length; deg++) {
-        index = index + 1;
-        this.freqs[index] = parseFloat((f * intervals.ratio(deg)).toFixed(3));
-        this.midis[index] = parseFloat(hz_to_midi(f * intervals.ratio(deg), tuning).toFixed(4));
-        this.degrees[index] = deg;
-        this.octdegfreqs[oct][deg + 1] = this.freqs[index];
-        this.octdegmidis[oct][deg + 1] = this.midis[index];
-      }
-    }
-    this.base_freq = parseFloat(this.base_freq).toFixed(4);
-  }
-
-  base_freq() {
-    return this.base_freq;
-  }
-
-  degree(index) {
-    return this.degrees[index];
-  }
-
-  freq(index) {
-    return this.freqs[index];
-  }
-
-  octdeg(deg) {
-    const higherOcatve = deg > this.scale.length;
-    const octave = this.root_octave + (higherOcatve ? Math.floor((deg - 1) / this.scale.length) : 0);
-    const degree = higherOcatve ? (deg % this.scale.length === 0 ? this.scale.length : deg % this.scale.length) : deg;
-    // console.log([octave, degree]);
-    return [octave, degree];
-  }
-
-  octdegfreq(oct, deg) {
-    if (this.octdegfreqs[oct]) {
-      return this.octdegfreqs[oct][deg];
-    } else {
-      return null;
-    }
-  }
-
-  octdegmidi(oct, deg) {
-    if (this.octdegmidis[oct]) {
-      return this.octdegmidis[oct][deg];
-    } else {
-      return null;
-    }
-  }
-}

packages/edo/ratios.mjs

@@ -1,95 +0,0 @@
-/*
-ratios.mjs - lists whole number ratios for pitch intervals
-           - Port of pitfalls/lib/ratios.lua - see <https://github.com/robmckinnon/pitfalls/blob/main/lib/ratios.lua>
-Copyright (C) 2025 Rob McKinnon and Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/edo/ratios.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 ratiointervals = {};
-
-// FJS Calculators - https://misotanni.github.io/fjs/en/calc.html
-// List of pitch intervals - https://en.wikipedia.org/wiki/List_of_pitch_intervals
-// Gallery of just intervals - https://en.xen.wiki/w/Gallery_of_just_intervals
-// Two letter codes changed to make different interval labels more unique.
-ratiointervals.list = new Map([
-  [1, ['P1', 'P1', 'P1', 1, 1]], // unison P1
-  [16 / 15, ['m2', 'm2', 'm2_5', 16, 15]], // minor second m2
-  [15 / 14, ['A1', 'A1', 'A1^5_7', 15, 14]], // augmented unison
-  [13 / 12, ['t2', 'm2', 'm2^13', 13, 12]], // tridecimal neutral second
-  [12 / 11, ['N2', 'M2', 'M2_11', 12, 11]], // undecimal neutral second
-  [11 / 10, ['n2', 'm2', 'm2^11_5', 11, 10]], // undecimal submajor second
-  [10 / 9, ['T2', 'M2', 'M2^5', 10, 9]], // classic (whole) tone
-  [9 / 8, ['M2', 'M2', 'M2', 9, 8]], // major second M2
-  [8 / 7, ['S2', 'M2', 'M2_7', 8, 7]], // septimal major second
-  [7 / 6, ['s3', 'm3', 'm3^7', 7, 6]], // septimal minor third
-  [19 / 16, ['o3', 'm3', 'm3^19', 19, 16]], // otonal minor third
-  [6 / 5, ['m3', 'm3', 'm3_5', 6, 5]], // minor third m3
-  [17 / 14, ['t3', 'm3', 'm3^17_7', 17, 14]], // septendecimal supraminor third
-  [11 / 9, ['n3', 'm3', 'm3^11', 11, 9]], // undecimal neutral third
-  [5 / 4, ['M3', 'M3', 'M3^5', 5, 4]], // major third M3
-  [9 / 7, ['S3', 'M3', 'M3_7', 9, 7]], // septimal major third SM3
-  [13 / 10, ['d4', 'd4', 'd4^13_5', 13, 10]], // Barbados third
-  [4 / 3, ['P4', 'P4', 'P4', 4, 3]], // perfect fourth P4
-  [19 / 14, ['N4', 'P4', 'P4^19_7', 19, 14]], // undevicesimal wide fourth
-  [11 / 8, ['n4', 'P4', 'P4^11', 11, 8]], // super-fourth
-  [25 / 18, ['a4', 'A4', 'A4^5,5', 25, 18]], // classic augmented fourth
-  [7 / 5, ['sT', 'd5', 'd5^7_5', 7, 5]], // lesser septimal tritone
-  [45 / 32, ['A4', 'A4', 'A4^5', 45, 32]], // just augmented fourth
-  [17 / 12, ['d5', 'd5', 'd5^17', 17, 12]], // larger septendecimal tritone
-  [10 / 7, ['ST', 'A4', 'A4^5_7', 10, 7]], // greater septimal tritone
-  [13 / 9, ['t5', 'd5', 'd5^13', 13, 9]], // tridecimal diminished fifth
-  [3 / 2, ['P5', 'P5', 'P5', 3, 2]], // perfect fifth P5
-  [14 / 9, ['s6', 'M6', 'm6^7', 14, 9]], // subminor sixth or septimal sixth
-  [25 / 16, ['a5', 'A5', 'A5^5,5', 25, 16]], // classic augmented fifth
-  [11 / 7, ['A5', 'P5', 'P5^11_7', 11, 7]], // undecimal minor sixth
-  [8 / 5, ['m6', 'm6', 'm6_5', 8, 5]], // minor sixth m6
-  [13 / 8, ['N6', 'm6', 'm6^13', 13, 8]], // tridecimal neutral sixth
-  [18 / 11, ['n6', 'M6', 'M6_11', 18, 11]], // undecimal neutral sixth
-  [5 / 3, ['M6', 'M6', 'M6^5', 5, 3]], // just major sixth M6
-  [128 / 75, ['d7', 'd7', 'd7_5,5', 128, 75]], // diminished seventh
-  [17 / 10, ['T6', 'd7', 'd7^17_5', 17, 10]], // septendecimal diminished seventh
-  [12 / 7, ['S6', 'M6', 'M6_7', 12, 7]], // septimal major sixth
-  [7 / 4, ['s7', 'm7', 'm7^7', 7, 4]], // septimal minor seventh
-  [16 / 9, ['m7', 'm7', 'm7', 16, 9]], // lesser minor seventh
-  [9 / 5, ['g7', 'm7', 'm7_5', 9, 5]], // greater just minor seventh
-  [11 / 6, ['n7', 'm7', 'm7^11', 11, 6]], // undecimal neutral seventh
-  [13 / 7, ['N7', 'm7', 'm7^13_7', 13, 7]], // tridecimal neutral seventh
-  [15 / 8, ['M7', 'M7', 'M7^5', 15, 8]], // major seventh
-  [17 / 9, ['T7', 'd8', 'd8^17', 17, 9]], // large septendecimal major seventh
-  [19 / 10, ['d8', 'd8', 'd8^19_5', 19, 10]], // large undevicesimal major seventh
-  [2, ['P8', 'P8', 'P8', 2, 1]], // octave P8
-]);
-
-ratiointervals.key = function (ratio) {
-  return ratio == null ? '' : ratiointervals.list.get(ratio)?.[0] || '';
-};
-
-ratiointervals.label = function (ratio) {
-  return ratio == null ? '' : ratiointervals.list.get(ratio)?.[1] || '';
-};
-
-ratiointervals.fjs = function (ratio) {
-  return ratio == null ? '' : ratiointervals.list.get(ratio)?.[2] || '';
-};
-
-ratiointervals.nom = function (ratio) {
-  return ratio == null ? null : ratiointervals.list.get(ratio)?.[3] || null;
-};
-
-ratiointervals.denom = function (ratio) {
-  return ratio == null ? null : ratiointervals.list.get(ratio)?.[4] || null;
-};
-
-ratiointervals.nearestInterval = function (v) {
-  let min = 1;
-  let match = null;
-  for (const [ratio, _labels] of ratiointervals.list) {
-    const diff = Math.abs((ratio - v) / ratio);
-    if (diff < min) {
-      min = diff;
-      match = ratio;
-    }
-  }
-  return min < 0.01 ? [min, match] : [null, null];
-};
-
-export default ratiointervals;

packages/edo/test/edo.test.mjs

@@ -1,34 +0,0 @@
-/*
-edo.test.mjs - tests of edo.mjs
-Copyright (C) 2025 Rob McKinnon and Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/tonal/test/tonal.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 '../edo.mjs';
-import { n } from '@strudel/core';
-import { describe, it, expect } from 'vitest';
-
-describe('edoScale', () => {
-  it('Should run tonal functions ', () => {
-    // base note A3 = 220Hz
-    let baseNote = 'A3';
-    let root = 220;
-    let freq = 220;
-    let pattern = n('0').edoScale([baseNote, 'LLsLLLs', 2, 1]);
-    let cycle = pattern.firstCycleValues[0];
-    expect(cycle.freq).toEqual(freq);
-    expect(cycle.edo).toEqual(12);
-    expect(cycle.degree).toEqual(1);
-    expect(parseFloat(cycle.root).toFixed(0)).toEqual(root.toFixed(0));
-
-    // base note A4 = 440Hz
-    baseNote = 'A4';
-    root = 440;
-    freq = 880;
-    pattern = n('7').edoScale([baseNote, 'LLsLLLs', 2, 1]);
-    cycle = pattern.firstCycleValues[0];
-    expect(cycle.freq).toEqual(freq);
-    expect(cycle.edo).toEqual(12);
-    expect(cycle.degree).toEqual(1);
-    expect(parseFloat(cycle.root).toFixed(0)).toEqual(root.toFixed(0));
-  });
-});

packages/edo/test/edoscale.test.mjs

@@ -1,21 +0,0 @@
-/*
-edoscale.test.mjs - tests of EdoScale from edoscale.mjs
-Copyright (C) 2025 Rob McKinnon and Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/edo/test/edoscale.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 '../edoscale.mjs'; // need to import this to add prototypes
-import { EdoScale } from '../edoscale.mjs';
-import { describe, it, expect } from 'vitest';
-
-describe('EdoScale', () => {
-  it('updates edivisions', () => {
-    let scale = new EdoScale(2, 1, ['L', 'L', 's', 'L', 'L', 'L', 's']);
-    expect(scale.stepSize(0)).toEqual('L');
-    expect(scale.stepValue(0)).toEqual(2);
-
-    expect(scale.stepSize(2)).toEqual('s');
-    expect(scale.stepValue(2)).toEqual(1);
-
-    expect(scale.edivisions).toEqual(12);
-  });
-});

packages/edo/test/ratios.test.mjs

@@ -1,18 +0,0 @@
-/*
-ratios.test.mjs - tests of ratios.mjs
-Copyright (C) 2025 Rob McKinnon and Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/edo/test/ratios.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 ratiointervals from '../ratios.mjs';
-import { describe, it, expect } from 'vitest';
-
-describe('ratiointervals', () => {
-  it('updates edivisions', () => {
-    let ratio = 9 / 7;
-    expect(ratiointervals.key(ratio)).toEqual('S3');
-    expect(ratiointervals.label(ratio)).toEqual('M3');
-    expect(ratiointervals.fjs(ratio)).toEqual('M3_7');
-    expect(ratiointervals.nom(ratio)).toEqual(9);
-    expect(ratiointervals.denom(ratio)).toEqual(7);
-  });
-});

packages/edo/vite.config.js

@@ -1,19 +0,0 @@
-import { defineConfig } from 'vite';
-import { dependencies } from './package.json';
-import { resolve } from 'path';
-
-// https://vitejs.dev/config/
-export default defineConfig({
-  plugins: [],
-  build: {
-    lib: {
-      entry: resolve(__dirname, 'index.mjs'),
-      formats: ['es'],
-      fileName: (ext) => ({ es: 'index.mjs' })[ext],
-    },
-    rollupOptions: {
-      external: [...Object.keys(dependencies)],
-    },
-    target: 'esnext',
-  },
-});

packages/midi/input.mjs

@@ -1,193 +0,0 @@
-/*
-input.mjs - MIDI input wrapper
-Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/midi/midi.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 { WebMidi } from 'webmidi';
-import { logger, ref } from '@strudel/core';
-import { getDevice } from './util.mjs';
-
-/**
- * MIDI input device wrapper that manages connection and reconnection, tracks
- * persisted CC states, etc. These instances are long-lived and are maintained as singletons
- * (keyed globally by input string/number).
- */
-export class MidiInput {
-  /**
-   *
-   * @param {string | number} input MIDI device name or index defaulting to 0
-   */
-  constructor(input) {
-    this.input = input;
-    this.stateKey = typeof input === 'string' ? input : undefined; // Saved state is not tracked for numeric index inputs
-
-    this._refs = {};
-    this._refsByChan = {};
-
-    this._loadAllStates();
-
-    this.initialDevice = this._startDeviceListener();
-  }
-
-  /**
-   * Implementation for the cc() factory function tied to this specific input.
-   * @param {number} cc MIDI CC number
-   * @param {number | undefined} chan MIDI channel (1-16) or undefined for all channels
-   */
-  createCC(cc, chan) {
-    const lookupMap = chan === undefined ? this._refs : this._refsByChan[chan];
-    if (!(cc in lookupMap)) {
-      const initialState = this._loadState(chan);
-      lookupMap[cc] = initialState[cc] || 0;
-    }
-
-    return ref(() => lookupMap[cc]);
-  }
-
-  _startDeviceListener() {
-    const initialDevice = getDevice(this.input, WebMidi.inputs);
-
-    // Background connection loop
-    (async () => {
-      const midiListener = this._onMidiMessage.bind(this);
-      let device = initialDevice;
-
-      while (true) {
-        if (!device) {
-          device = await this._waitForDevice();
-        }
-
-        // Wait a bit for device to be ready to receive last state
-        await new Promise((resolve) => setTimeout(resolve, 2000));
-
-        try {
-          // Still continue if sending did not work
-          this._sendAllStates(device);
-        } catch (err) {
-          console.error('midiin: failed to send last state on connect:', device.name, err);
-        }
-
-        // Listen for incoming MIDI messages and for disconnection
-        device.addListener('midimessage', midiListener);
-
-        await this._waitForDeviceDisconnect(device);
-
-        device.removeListener('midimessage', midiListener);
-        device = null; // Clear var to trigger wait for connection
-      }
-    })();
-
-    return initialDevice;
-  }
-
-  // Returns a promise that resolves when the specified device is connected
-  _waitForDevice() {
-    return new Promise((resolve) => {
-      const connListener = () => {
-        const device = getDevice(this.input, WebMidi.inputs);
-        if (device) {
-          logger(`[midi] device reconnected: ${device.name}`);
-
-          WebMidi.removeListener('connected', connListener);
-          resolve(device);
-        }
-      };
-
-      WebMidi.addListener('connected', connListener);
-    });
-  }
-
-  // Returns a promise that resolves when the specified device is disconnected
-  _waitForDeviceDisconnect(device) {
-    return new Promise((resolve) => {
-      const disconnListener = (e) => {
-        if (e.port.name === device.name) {
-          logger(`[midi] device disconnected: ${device.name}`);
-
-          WebMidi.removeListener('disconnected', disconnListener);
-          resolve();
-        }
-      };
-
-      WebMidi.addListener('disconnected', disconnListener);
-    });
-  }
-
-  _onMidiMessage(e) {
-    const ccNum = e.dataBytes[0];
-    const v = e.dataBytes[1];
-    const chan = e.message.channel;
-    const scaled = v / 127;
-
-    this._refs[ccNum] = scaled;
-    this._refsByChan[chan] ??= {};
-    this._refsByChan[chan][ccNum] = scaled;
-
-    this._saveState(undefined, ccNum, scaled);
-    this._saveState(chan, ccNum, scaled);
-  }
-
-  _loadAllStates() {
-    Object.assign(this._refs, this._loadState(undefined));
-
-    for (let chan = 1; chan <= 16; chan++) {
-      this._refsByChan[chan] ??= {};
-      Object.assign(this._refsByChan[chan], this._loadState(chan));
-    }
-  }
-
-  _loadState(chan) {
-    if (!this.stateKey) {
-      return {};
-    }
-
-    const initialDataRaw = localStorage.getItem(
-      `strudel-midin-${this.stateKey}-chan${chan !== undefined ? chan : 'all'}`,
-    );
-    if (!initialDataRaw) {
-      return {};
-    }
-
-    try {
-      return JSON.parse(initialDataRaw);
-    } catch (err) {
-      console.warn(
-        `Failed to parse MIDI state from localStorage for input "${this.stateKey}" and channel "${chan}"`,
-        initialDataRaw,
-        err,
-      );
-      return {};
-    }
-  }
-
-  _saveState(chan, cc, value) {
-    if (!this.stateKey) {
-      return;
-    }
-
-    const state = this._loadState(chan);
-    state[cc] = value;
-    localStorage.setItem(
-      `strudel-midin-${this.stateKey}-chan${chan !== undefined ? chan : 'all'}`,
-      JSON.stringify(state),
-    );
-  }
-
-  // Send CC values back to device to restore encoders and motorized sliders
-  _sendAllStates(device) {
-    const output = WebMidi.outputs.find((o) => o.name === device.name);
-    if (!output) {
-      return;
-    }
-
-    for (const [chan, refs] of Object.entries(this._refsByChan)) {
-      const channel = Number(chan);
-      for (const [cc, value] of Object.entries(refs)) {
-        const ccn = Number(cc);
-        const scaled = Math.round(value * 127);
-        output.sendControlChange(ccn, scaled, channel);
-      }
-    }
-  }
-}

packages/midi/midi.mjs

@@ -23,8 +23,6 @@ import { noteToMidi, getControlName } from '@strudel/core';
 import { Note } from 'webmidi';
 import { getAudioContext } from '@strudel/webaudio';
 import { scheduleAtTime } from '../superdough/helpers.mjs';
-import { getMidiDeviceNamesString, getDevice } from './util.mjs';
-import { MidiInput } from './input.mjs';
 
 // if you use WebMidi from outside of this package, make sure to import that instance:
 export const { WebMidi } = _WebMidi;
@@ -33,6 +31,10 @@ function supportsMidi() {
   return typeof navigator.requestMIDIAccess === 'function';
 }
 
+function getMidiDeviceNamesString(devices) {
+  return devices.map((o) => `'${o.name}'`).join(' | ');
+}
+
 export function enableWebMidi(options = {}) {
   const { onReady, onConnected, onDisconnected, onEnabled } = options;
   if (WebMidi.enabled) {
@@ -70,6 +72,29 @@ export function enableWebMidi(options = {}) {
   });
 }
 
+function getDevice(indexOrName, devices) {
+  if (!devices.length) {
+    throw new Error(`🔌 No MIDI devices found. Connect a device or enable IAC Driver.`);
+  }
+  if (typeof indexOrName === 'number') {
+    return devices[indexOrName];
+  }
+  const byName = (name) => devices.find((output) => output.name.includes(name));
+  if (typeof indexOrName === 'string') {
+    return byName(indexOrName);
+  }
+  // attempt to default to first IAC device if none is specified
+  const IACOutput = byName('IAC');
+  const device = IACOutput ?? devices[0];
+  if (!device) {
+    throw new Error(
+      `🔌 MIDI device '${device ? device : ''}' not found. Use one of ${getMidiDeviceNamesString(devices)}`,
+    );
+  }
+
+  return IACOutput ?? devices[0];
+}
+
 // send start/stop messages to outputs when repl starts/stops
 if (typeof window !== 'undefined') {
   window.addEventListener('message', (e) => {
@@ -113,7 +138,7 @@ function githubPath(base, subpath = '') {
 
 /**
  * configures the default midimap, which is used when no "midimap" port is set
- * @tags external_io, midi
+ * @tags external_io
  * @example
  * defaultmidimap({ lpf: 74 })
  * $: note("c a f e").midi();
@@ -127,7 +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
+ * @tags external_io
  * @example
  * midimaps({ mymap: { lpf: 74 } })
  * $: note("c a f e")
@@ -470,9 +495,9 @@ Pattern.prototype.midi = function (midiport, options = {}) {
 };
 
 /**
- * Initialize a midi input device
+ * Initialize a midi device
  */
-async function _initializeInput(input) {
+async function _initialize(input) {
   if (isPattern(input)) {
     throw new Error(
       `[midi] Midi input cannot be a pattern. Make sure to pass device name with single quotes. Example: midin('${
@@ -480,38 +505,31 @@ async function _initializeInput(input) {
       }')`,
     );
   }
-
   const initial = await enableWebMidi(); // only returns on first init
-
-  const instance = midiInputs[input] || new MidiInput(input);
-  midiInputs[input] = instance;
-
-  if (initial) {
-    const device = instance.initialDevice;
-
-    const otherInputs = WebMidi.inputs.filter((o) => o.name !== device.name);
-    logger(
-      device
-        ? `[midi] Midi enabled! Using "${device.name}". ${
-            otherInputs?.length ? `Also available: ${getMidiDeviceNamesString(otherInputs)}` : ''
-          }`
-        : `[midi] Midi enabled! Waiting for device "${input}"... Currently connected devices: ${getMidiDeviceNamesString(WebMidi.inputs)}`,
+  const device = getDevice(input, WebMidi.inputs);
+  if (!device) {
+    throw new Error(
+      `[midi] Midi device "${input}" not found.. connected devices: ${getMidiDeviceNamesString(WebMidi.inputs)}`,
     );
   }
-
-  return instance;
+  if (initial) {
+    const otherInputs = WebMidi.inputs.filter((o) => o.name !== device.name);
+    logger(
+      `[midi] Midi enabled! Using "${device.name}". ${
+        otherInputs?.length ? `Also available: ${getMidiDeviceNamesString(otherInputs)}` : ''
+      }`,
+    );
+  }
+  return device;
 }
 
-// MIDI input wrappers, by specified input string/index
-const midiInputs = {};
-
 /**
  * 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
+ * @tags external_io
  * @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)
@@ -525,10 +543,31 @@ const midiInputs = {};
  * 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 instance = await _initializeInput(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);
+  };
 
-  return instance.createCC.bind(instance);
+  listeners[input] && device.removeListener('midimessage', listeners[input]);
+  listeners[input] = (e) => {
+    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;
 }
 
 /**
@@ -537,11 +576,8 @@ export async function midin(input) {
  * The note length is fixed as Superdough is not currently set up for undetermined
  * note durations
  *
- * The 'midichan' control value contains the number of the channel the note is coming from
- * so it could be filtered or manipulated further in the chain.
- *
  * @name midikeys
- * @tags external_io, midi
+ * @tags external_io
  * @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,
@@ -555,10 +591,6 @@ export async function midin(input) {
  *   .s("saw")
  *   .add(note(rand.mul(0.3)))
  *   .lpf(1000).lpe(2).room(0.5)
- * @example
- * // discard all notes not coming out from midi channel 2
- * const kb = await midikeys('Arturia KeyStep 32')
- * kb().filterValues(v=>v.midichan==2).s("tri")
  */
 const kHaps = {};
 const kListeners = {};
@@ -590,16 +622,7 @@ function _triggerKeyboard(input, cps, now, latencyCycles) {
   return true;
 }
 export async function midikeys(input) {
-  const instance = await _initializeInput(input);
-
-  // TODO: support unpluggable device usage
-  const device = instance.initialDevice;
-  if (!device) {
-    throw new Error(
-      `[midi] Midi device "${input}" not found.. connected devices: ${getMidiDeviceNamesString(WebMidi.inputs)}`,
-    );
-  }
-
+  const device = await _initialize(input);
   if (!kHaps[input]) {
     kHaps[input] = [];
   }
@@ -640,7 +663,7 @@ export async function midikeys(input) {
       */
       return;
     } else {
-      value = { ...value, note: Math.round(note), velocity: velocity / 127, midichan: message.channel };
+      value = { ...value, note: Math.round(note), velocity: velocity / 127 };
     }
     kHaps[input].push(new Hap(span, span, value, {}));
     if (!noteoff && triggerAvailable) {

packages/midi/util.mjs

@@ -1,44 +0,0 @@
-/*
-util.mjs - MIDI utility functions
-Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/midi/midi.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 { Input, Output } from 'webmidi';
-
-/**
- * Get a string listing device names for error messages.
- * @param {Input[] | Output[]} devices
- * @returns {string}
- */
-export function getMidiDeviceNamesString(devices) {
-  return devices.map((o) => `'${o.name}'`).join(' | ');
-}
-
-/**
- * Look up a device by index or name. Otherwise return a default device, or fail if none are connected.
- *
- * @param {string | number} indexOrName
- * @param {Input[] | Output[]} devices
- * @returns {Input | Output | undefined}
- */
-export function getDevice(indexOrName, devices) {
-  if (typeof indexOrName === 'number') {
-    return devices[indexOrName];
-  }
-  const byName = (name) => devices.find((output) => output.name.includes(name));
-  if (typeof indexOrName === 'string') {
-    return byName(indexOrName);
-  }
-  // attempt to default to first IAC device if none is specified
-  const IACOutput = byName('IAC');
-  const device = IACOutput ?? devices[0];
-  if (!device) {
-    if (!devices.length) {
-      throw new Error(`🔌 No MIDI devices found. Connect a device or enable IAC Driver.`);
-    }
-    throw new Error(`🔌 Default MIDI device not found. Use one of ${getMidiDeviceNamesString(devices)}`);
-  }
-
-  return device;
-}

packages/mqtt/mqtt.mjs

@@ -4,7 +4,7 @@ Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/
 This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
-import { Pattern, isPattern, createParams } from '@strudel/core';
+import { Pattern, isPattern } from '@strudel/core';
 import Paho from 'paho-mqtt';
 
 const connections = {};
@@ -61,6 +61,7 @@ Pattern.prototype.mqtt = function (
     const props = {
       onSuccess: onConnect,
       onFailure: onFailure,
+      useSSL: true,
     };
 
     if (username) {
@@ -118,12 +119,3 @@ Pattern.prototype.mqtt = function (
     return hap.setContext({ ...hap.context, onTrigger, dominantTrigger: true });
   });
 };
-
-// This adds the 'move' and 'motor' commands to strudel
-export const { move, motor } = createParams('move', 'motor');
-window.move = move;
-window.motor = motor;
-// This adds the 'robot' command
-Pattern.prototype.robot = function (robot_id, address = 'ws://192.168.8.248:9001/mqtt') {
-  return this.mqtt(undefined, undefined, '/move/' + robot_id, address);
-};

packages/osc/osc.mjs

@@ -42,7 +42,7 @@ export function parseControlsFromHap(hap, cps) {
     if (isNote(controls.note)) {
       controls.midinote = noteToMidi(controls.note, controls.octave || 3);
     } else {
-      controls.midinote = parseNumeral(controls.note);
+      controls.note = parseNumeral(controls.note);
     }
   }
   controls.bank && (controls.s = controls.bank + controls.s);

packages/repl/package.json

@@ -36,7 +36,6 @@
     "@strudel/codemirror": "workspace:*",
     "@strudel/core": "workspace:*",
     "@strudel/draw": "workspace:*",
-    "@strudel/edo": "workspace:*",
     "@strudel/hydra": "workspace:*",
     "@strudel/midi": "workspace:*",
     "@strudel/mini": "workspace:*",

packages/repl/prebake.mjs

@@ -8,7 +8,6 @@ export async function prebake() {
     core,
     import('@strudel/draw'),
     import('@strudel/mini'),
-    import('@strudel/edo'),
     import('@strudel/tonal'),
     import('@strudel/webaudio'),
     import('@strudel/codemirror'),

packages/superdough/sampler.mjs

@@ -1,5 +1,5 @@
 import { getBaseURL, getCommonSampleInfo } from './util.mjs';
-import { registerSound, registerWaveTable, soundMap } from './index.mjs';
+import { registerSound, registerWaveTable } from './index.mjs';
 import { getAudioContext } from './audioContext.mjs';
 import {
   getADSRValues,
@@ -30,29 +30,6 @@ function humanFileSize(bytes, si) {
   return bytes.toFixed(1) + ' ' + units[u];
 }
 
-/**
- * Returns the duration, in seconds, of the given sample.
- * Has optional param `n` (for instance, the `2` in `s("casio:2")`)
- *
- * Note: `must` be called with await, otherwise you'll get a pending Promise object.
- *
- * @name getDuration,getDur
- * @tag samples
- * @param {string} sampleName
- * @param {number} (optional) n
- *
- * @example
- * // Set a patterns cycle length to exactly the length of the sample
- * samples('github:tidalcycles/dirt-samples')
- * let k = await getDuration('sax')
- * s("sax").cps(1/k)
- */
-export const getDuration = (s, n = 0) => {
-  return getSampleBufferSource({ s, n }, soundMap.get(s)[s].data.samples).then((x) => x.bufferDuration);
-};
-
-export const getDur = getDuration;
-
 export function getSampleInfo(hapValue, bank) {
   const { speed = 1.0 } = hapValue;
   const { transpose, url, index, midi, label } = getCommonSampleInfo(hapValue, bank);

packages/superdough/superdough.mjs

@@ -25,7 +25,7 @@ import {
 import { map } from 'nanostores';
 import { logger } from './logger.mjs';
 import { connectLFO, connectEnvelope, connectBusModulator } from './modulators.mjs';
-import { getSampleBufferSource, loadBuffer } from './sampler.mjs';
+import { loadBuffer } from './sampler.mjs';
 import { getAudioContext } from './audioContext.mjs';
 import { SuperdoughAudioController } from './superdoughoutput.mjs';
 import { resetSeenKeys } from './wavetable.mjs';
@@ -40,7 +40,7 @@ export let maxPolyphony = DEFAULT_MAX_POLYPHONY;
  * start to die out in first-in-first-out order once the max polyphony has been hit
  *
  * @name setMaxPolyphony
- * @tags superdough
+ * @tags fx, superdough
  * @param {number} Max polyphony. Defaults to 128
  * @example
  * setMaxPolyphony(4)
@@ -74,7 +74,7 @@ export function applyGainCurve(val) {
  * quadratic, exponential, etc. rather than linear
  *
  * @name setGainCurve
- * @tags amplitude, superdough
+ * @tags fx, superdough
  * @param {Function} function to apply to all gain values
  * @example
  * setGainCurve((x) => x * x) // quadratic gain

packages/superdough/synth.mjs

@@ -485,10 +485,8 @@ export function waveformN(partials, phases, type) {
     if (phase !== 0) {
       const c = Math.cos(PI2 * phase);
       const s = Math.sin(PI2 * phase);
-      const R0 = R;
-      const I0 = I;
-      R = c * R0 - s * I0;
-      I = s * R0 + c * I0;
+      R = c * R - s * I;
+      I = s * R + c * I;
     }
     real[n + 1] = R;
     imag[n + 1] = I;

packages/superdough/wavetable.mjs

@@ -186,7 +186,7 @@ export function registerWaveTable(key, tables, params) {
  * Loads a collection of wavetables to use with `s`
  *
  * @name tables
- * @tags wavetable
+ * @tags fx
  */
 export const tables = async (url, frameLen, json, options = {}) => {
   if (json !== undefined) return _processTables(json, url, frameLen);

packages/superdough/worklets.mjs

@@ -214,7 +214,7 @@ class CoarseProcessor extends AudioWorkletProcessor {
     coarse = Math.max(1, coarse);
     for (let n = 0; n < blockSize; n++) {
       for (let i = 0; i < input.length; i++) {
-        output[i][n] = n % coarse < 1 ? input[i][n] : output[i][n - 1];
+        output[i][n] = n % coarse === 0 ? input[i][n] : output[i][n - 1];
       }
     }
     return true;

packages/tonal/tonal.mjs

@@ -100,7 +100,7 @@ function scaleOffset(scale, offset, note) {
  * - 5P = perfect fifth
  * - 5d = diminished fifth
  *
- * @tags tonal
+ * @tags music_theory
  * @param {string | number} amount Either number of semitones or interval string.
  * @returns Pattern
  * @memberof Pattern
@@ -155,7 +155,7 @@ export const { transpose, trans } = register(['transpose', 'trans'], function tr
  *
  * @memberof Pattern
  * @name scaleTranspose
- * @tags tonal
+ * @tags music_theory
  * @param {offset} offset number of steps inside the scale
  * @returns Pattern
  * @synonyms scaleTrans, strans
@@ -246,7 +246,7 @@ function _getNearestScaleNote(scaleName, note, preferHigher = true) {
  * The root note defaults to octave 3, if no octave number is given.
  *
  * @name scale
- * @tags tonal
+ * @tags music_theory
  * @param {string} scale Name of scale
  * @returns Pattern
  * @example

packages/tonal/voicings.mjs

@@ -90,7 +90,7 @@ export const setVoicingRange = (name, range) => addVoicings(name, voicingRegistr
  * Adds a new custom voicing dictionary.
  *
  * @name addVoicings
- * @tags tonal
+ * @tags music_theory
  * @memberof Pattern
  * @param {string} name identifier for the voicing dictionary
  * @param {Object} dictionary maps chord symbol to possible voicings
@@ -134,7 +134,7 @@ const getVoicing = (chord, dictionaryName, lastVoicing) => {
  * Uses [chord-voicings package](https://github.com/felixroos/chord-voicings#chord-voicings).
  *
  * @name voicings
- * @tags tonal
+ * @tags music_theory
  * @memberof Pattern
  * @param {string} dictionary which voicing dictionary to use.
  * @returns Pattern
@@ -159,7 +159,7 @@ export const voicings = register('voicings', function (dictionary, pat) {
  * Maps the chords of the incoming pattern to root notes in the given octave.
  *
  * @name rootNotes
- * @tags tonal
+ * @tags music_theory
  * @memberof Pattern
  * @param {octave} octave octave to use
  * @returns Pattern
@@ -192,7 +192,7 @@ export const rootNotes = register('rootNotes', function (octave, pat) {
  * If you pass a pattern of strings to voicing, they will be interpreted as chords.
  *
  * @name voicing
- * @tags tonal
+ * @tags music_theory
  * @returns Pattern
  * @example
  * n("0 1 2 3").chord("<C Am F G>").voicing()

packages/transpiler/README.md

@@ -1,31 +1,10 @@
 # @strudel/transpiler
 
-This package contains a JS code transpiler with a plugin system that can be used to transform the code.
-
-A plugin can be registered via a `registerTranspilerPlugin` call :
-
-```js
-registerTranspilerPlugin({
-  walk: (context) => ({
-    enter: function(node, parent, prop, index) {},
-    leave: function(node, parent, prop, index) {}
-  })
-})
-```
-
-where the enter/leave functions (both optional) follow the `estree-walker` walk API.
-
-4 plugins are currently hosted inside `@strudel/transpiler`
-
-- mini: add locations of mini notation strings (double quoted or backticked) for highlighting
-- widgets: add handling of sliders & draw widgets
-- sample: make it possible to call a sample without await
-- kabelsalat: transform the code to handle the `K(..)` kabelsalat notation
-
-it also
+This package contains a JS code transpiler with the following features:
 
+- add locations of mini notation strings (double quoted or backticked) for highlighting
+- converts pseudo note variables to note strings
 - adds return statement to the last expression
-- handles label capturing for block-based eval
 
 ## Install
 

packages/transpiler/index.mjs

@@ -1,17 +1,5 @@
-/*
-index.mjs - <short description TODO>
-Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/superdough/superdough.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 { evaluate as _evaluate } from '@strudel/core';
 import { transpiler } from './transpiler.mjs';
-
 export * from './transpiler.mjs';
 
-import './plugin-kabelsalat.mjs';
-import './plugin-mini.mjs';
-import './plugin-sample.mjs';
-import './plugin-widgets.mjs';
-
-export { registerWidgetType, getWidgetID } from './plugin-widgets.mjs';
-export const evaluate = (code, transpilerOptions) => _evaluate(code, transpiler, transpilerOptions);
+export const evaluate = (code) => _evaluate(code, transpiler);

packages/transpiler/plugin-kabelsalat.mjs

@@ -1,235 +0,0 @@
-/*
-plugin-kabelsalat.mjs - <short description TODO>
-Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/superdough/superdough.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 { walk } from 'estree-walker';
-import escodegen from 'escodegen';
-import { getLanguages, registerTranspilerPlugin } from './transpiler.mjs';
-
-export function genExprSource(expr) {
-  return escodegen.generate(expr, { format: { semicolons: false } });
-}
-
-function isStrudelPatternWrap(node) {
-  if (node.type !== 'CallExpression') {
-    return false;
-  }
-  const callee = node.callee;
-  if (callee.type === 'Identifier') {
-    return callee.name === 'S';
-  }
-  if (callee.type === 'MemberExpression' && !callee.computed) {
-    return callee.property?.name === 'S';
-  }
-  return false;
-}
-
-// Used to identify transpiled `m(...)` calls for proper conversion
-// to, say, kabelsalat placeholders
-function isMiniCall(node) {
-  if (node.type !== 'CallExpression') {
-    return false;
-  }
-  const callee = node.callee;
-  if (callee.type !== 'Identifier') {
-    return false;
-  }
-  if (callee.name !== getMinilangName()) {
-    return false;
-  }
-  const firstArg = node.arguments?.[0];
-  return firstArg?.type === 'Literal' && typeof firstArg.value === 'string';
-}
-
-function getMinilangName() {
-  const minilang = getLanguages().get('minilang');
-  return minilang?.name || 'm';
-}
-
-function replaceNode(node, replacement, parents, currentRoot) {
-  const info = parents.get(node);
-  if (!info || !info.parent) {
-    return replacement;
-  }
-
-  const { parent, prop, index } = info;
-  if (Array.isArray(parent[prop])) {
-    parent[prop][index] = replacement;
-  } else {
-    parent[prop] = replacement;
-  }
-  parents.set(replacement, { parent, prop, index });
-  return currentRoot;
-}
-
-// If `start` is available, we use it. If it's already been transpiled
-// to `m(...)`, use the provided offset
-function getPatternNodeOrder(node) {
-  if (typeof node.start === 'number') {
-    return node.start;
-  }
-  if (isMiniCall(node)) {
-    const offsetArg = node.arguments?.[1];
-    if (offsetArg?.type === 'Literal' && typeof offsetArg.value === 'number') {
-      return offsetArg.value;
-    }
-  }
-  return 0;
-}
-
-function placeholderAst(index) {
-  return {
-    type: 'MemberExpression',
-    object: { type: 'Identifier', name: 'pat' },
-    property: { type: 'Literal', value: index },
-    computed: true,
-    optional: false,
-  };
-}
-
-function getStrudelPatternExpr(node) {
-  if (isStrudelPatternWrap(node)) {
-    const arg = node.arguments?.[0];
-    if (!arg) {
-      throw new Error('S(...) requires an argument');
-    }
-    return arg;
-  }
-  if (isMiniCall(node)) {
-    return node;
-  }
-  return null;
-}
-
-function cloneNode(node) {
-  return JSON.parse(JSON.stringify(node));
-}
-
-export function extractPatternPlaceholders(expr) {
-  const templateExpr = cloneNode(expr);
-  const parents = new Map();
-  const targets = [];
-
-  walk(templateExpr, {
-    enter(node, parent, prop, index) {
-      parents.set(node, { parent, prop, index });
-      const patternExpr = getStrudelPatternExpr(node);
-      if (patternExpr) {
-        targets.push({ node, patternExpr });
-        this.skip();
-      }
-    },
-  });
-
-  if (!targets.length) {
-    return { template: genExprSource(templateExpr), patternExprs: [] };
-  }
-
-  targets.sort((a, b) => getPatternNodeOrder(a.node) - getPatternNodeOrder(b.node));
-
-  const patternExprs = targets.map(({ patternExpr }) => cloneNode(patternExpr));
-
-  let currentExpr = templateExpr;
-  targets.forEach(({ node }, index) => {
-    currentExpr = replaceNode(node, placeholderAst(index), parents, currentExpr);
-  });
-
-  const template = genExprSource(currentExpr);
-  return { template, patternExprs };
-}
-
-const transpilerPlugin = {
-  walk: (context) => ({
-    leave: function (node, parent, prop, index) {
-      if (!isKabelCall(node)) return;
-      let [expr, ...rest] = node.arguments;
-      if (!expr) throw new Error('K(...) requires an expression');
-      if (shouldCallKabelExpression(expr)) {
-        expr = {
-          type: 'CallExpression',
-          callee: expr,
-          arguments: [],
-          optional: false,
-        };
-      }
-      const language = 'kabelsalat';
-      const { template, patternExprs } = extractPatternPlaceholders(expr);
-      if (patternExprs.length) {
-        const workletArgs = [
-          /*{ type: 'Literal', value: language },*/
-          { type: 'Literal', value: template },
-          ...patternExprs,
-          ...rest,
-        ];
-        let callee = node.callee;
-        if (callee.type === 'ChainExpression') callee = callee.expression;
-        if (callee.type === 'MemberExpression') {
-          return this.replace({
-            type: 'CallExpression',
-            callee: workletMemberAst(callee.object),
-            arguments: workletArgs,
-            optional: false,
-          });
-        }
-        return this.replace({
-          type: 'CallExpression',
-          callee: { type: 'Identifier', name: 'worklet' },
-          arguments: workletArgs,
-          optional: false,
-        });
-      }
-
-      const kabelSrc = genExprSource(expr);
-      const workletArgs = [/*{ type: 'Literal', value: language },*/ { type: 'Literal', value: kabelSrc }, ...rest];
-
-      let callee = node.callee;
-      if (callee.type === 'ChainExpression') callee = callee.expression;
-      if (callee.type === 'MemberExpression') {
-        return this.replace({
-          type: 'CallExpression',
-          callee: workletMemberAst(callee.object),
-          arguments: workletArgs,
-          optional: false,
-        });
-      }
-      return this.replace({
-        type: 'CallExpression',
-        callee: { type: 'Identifier', name: 'worklet' },
-        arguments: workletArgs,
-        optional: false,
-      });
-    },
-  }),
-};
-
-registerTranspilerPlugin(transpilerPlugin);
-
-function isKabelCall(node) {
-  if (node.type !== 'CallExpression') return false;
-  let callee = node.callee;
-  if (callee.type === 'ChainExpression') callee = callee.expression;
-  if (callee.type === 'MemberExpression') return !callee.computed && callee.property?.name === 'K';
-  return callee.type === 'Identifier' && callee.name === 'K';
-}
-
-function shouldCallKabelExpression(expr) {
-  if (expr.type !== 'ArrowFunctionExpression' && expr.type !== 'FunctionExpression') {
-    return false;
-  }
-  if (expr.params.length) {
-    return false;
-  }
-  return expr.body?.type === 'BlockStatement';
-}
-
-function workletMemberAst(objectExpr) {
-  return {
-    type: 'MemberExpression',
-    object: objectExpr,
-    property: { type: 'Identifier', name: 'worklet' },
-    computed: false,
-    optional: false,
-  };
-}

packages/transpiler/plugin-mini.mjs

@@ -1,200 +0,0 @@
-/*
-plugin-mini.mjs - <short description TODO>
-Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/superdough/superdough.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 { getLeafLocations } from '@strudel/mini';
-import { getLanguages, registerTranspilerPlugin } from './transpiler.mjs';
-
-const languageLiteral = {
-  walk: (context) => ({
-    enter: function (node, parent, prop, index) {
-      if (!isLanguageLiteral(node)) return;
-      context.miniLocations ??= [];
-      const { options, miniLocations } = context;
-      const { emitMiniLocations } = options;
-      const { name } = node.tag;
-      const language = getLanguages().get(name);
-      const code = node.quasi.quasis[0].value.raw;
-      const offset = node.quasi.start + 1;
-      if (emitMiniLocations) {
-        const locs = language.getLocations(code, offset);
-        miniLocations.push(...locs);
-      }
-      this.skip();
-      return this.replace(languageWithLocation(name, code, offset));
-    },
-  }),
-};
-
-const tidal = {
-  walk: (context) => ({
-    enter: function (node, parent, prop, index) {
-      if (!isTemplateLiteral(node, 'tidal')) return;
-      context.miniLocations ??= [];
-      const { options, miniLocations } = context;
-      const { emitMiniLocations } = options;
-      const raw = node.quasi.quasis[0].value.raw;
-      const offset = node.quasi.start + 1;
-      if (emitMiniLocations) {
-        const stringLocs = collectHaskellMiniLocations(raw, offset);
-        miniLocations.push(...stringLocs);
-      }
-      this.skip();
-      return this.replace(tidalWithLocation(raw, offset));
-    },
-  }),
-};
-
-const backtick = {
-  walk: (context) => ({
-    enter: function (node, parent, prop, index) {
-      if (!isBackTickString(node, parent)) return;
-      context.miniLocations ??= [];
-      const { options, input, miniDisableRanges, miniLocations } = context;
-      const { emitMiniLocations } = options;
-      if (isMiniDisabled(node.start, miniDisableRanges)) {
-        return;
-      }
-      const { quasis } = node;
-      const { raw } = quasis[0].value;
-      this.skip();
-      emitMiniLocations && collectMiniLocations(raw, node, miniLocations, input);
-      return this.replace(miniWithLocation(raw, node));
-    },
-  }),
-};
-
-const doublequotes = {
-  walk: (context) => ({
-    enter: function (node, parent, prop, index) {
-      if (!isStringWithDoubleQuotes(node)) return;
-      context.miniLocations ??= [];
-      const { options, input, miniDisableRanges, miniLocations } = context;
-      const { emitMiniLocations } = options;
-      if (isMiniDisabled(node.start, miniDisableRanges)) {
-        return;
-      }
-      const { value } = node;
-      this.skip();
-      emitMiniLocations && collectMiniLocations(value, node, miniLocations, input);
-      return this.replace(miniWithLocation(value, node));
-    },
-  }),
-};
-
-function isLanguageLiteral(node) {
-  return node.type === 'TaggedTemplateExpression' && getLanguages().has(node.tag.name);
-}
-
-function languageWithLocation(name, value, offset) {
-  return {
-    type: 'CallExpression',
-    callee: {
-      type: 'Identifier',
-      name: name,
-    },
-    arguments: [
-      { type: 'Literal', value },
-      { type: 'Literal', value: offset },
-    ],
-    optional: false,
-  };
-}
-
-function collectHaskellMiniLocations(haskellCode, offset) {
-  return haskellCode
-    .split('')
-    .reduce((acc, char, i) => {
-      if (char !== '"') {
-        return acc;
-      }
-      if (!acc.length || acc[acc.length - 1].length > 1) {
-        acc.push([i + 1]);
-      } else {
-        acc[acc.length - 1].push(i);
-      }
-      return acc;
-    }, [])
-    .map(([start, end]) => {
-      const miniString = haskellCode.slice(start, end);
-      return getLeafLocations(`"${miniString}"`, offset + start - 1);
-    })
-    .flat();
-}
-
-function isTemplateLiteral(node, value) {
-  return node.type === 'TaggedTemplateExpression' && node.tag.name === value;
-}
-
-function tidalWithLocation(value, offset) {
-  return {
-    type: 'CallExpression',
-    callee: {
-      type: 'Identifier',
-      name: 'tidal',
-    },
-    arguments: [
-      { type: 'Literal', value },
-      { type: 'Literal', value: offset },
-    ],
-    optional: false,
-  };
-}
-
-function isBackTickString(node, parent) {
-  return node.type === 'TemplateLiteral' && parent.type !== 'TaggedTemplateExpression';
-}
-
-function isMiniDisabled(offset, miniDisableRanges) {
-  for (const [start, end] of miniDisableRanges) {
-    if (offset >= start && offset < end) {
-      return true;
-    }
-  }
-  return false;
-}
-
-function miniWithLocation(value, node) {
-  const { start: fromOffset } = node;
-
-  const minilang = getLanguages().get('minilang');
-  let name = 'm';
-  if (minilang && minilang.name) {
-    name = minilang.name; // name is expected to be exported from the package of the minilang
-  }
-
-  return {
-    type: 'CallExpression',
-    callee: {
-      type: 'Identifier',
-      name,
-    },
-    arguments: [
-      { type: 'Literal', value },
-      { type: 'Literal', value: fromOffset },
-    ],
-    optional: false,
-  };
-}
-
-const collectMiniLocations = (value, node, miniLocations, input) => {
-  const minilang = getLanguages().get('minilang');
-  if (minilang) {
-    const code = `[${value}]`;
-    const locs = minilang.getLocations(code, node.start);
-    miniLocations.push(...locs);
-  } else {
-    const leafLocs = getLeafLocations(`"${value}"`, node.start, input);
-    miniLocations.push(...leafLocs);
-  }
-};
-
-function isStringWithDoubleQuotes(node, locations, code) {
-  if (node.type !== 'Literal') {
-    return false;
-  }
-  return node.raw[0] === '"';
-}
-
-registerTranspilerPlugin([languageLiteral, tidal, backtick, doublequotes]);

packages/transpiler/plugin-sample.mjs

@@ -1,29 +0,0 @@
-/*
-plugin-sample.mjs - <short description TODO>
-Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/superdough/superdough.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 { registerTranspilerPlugin } from './transpiler.mjs';
-
-export function withAwait(node) {
-  return {
-    type: 'AwaitExpression',
-    argument: node,
-  };
-}
-
-const bareSample = {
-  walk: (context) => ({
-    enter: function (node, parent, prop, index) {
-      if (!isBareSamplesCall(node, parent)) return;
-      this.replace(withAwait(node));
-    },
-  }),
-};
-
-function isBareSamplesCall(node, parent) {
-  return node.type === 'CallExpression' && node.callee.name === 'samples' && parent.type !== 'AwaitExpression';
-}
-
-registerTranspilerPlugin(bareSample);

packages/transpiler/plugin-widgets.mjs

@@ -1,128 +0,0 @@
-/*
-plugin-widgets.mjs - <short description TODO>
-Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/superdough/superdough.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 { registerTranspilerPlugin } from './transpiler.mjs';
-
-let widgetMethods = [];
-export function registerWidgetType(type) {
-  widgetMethods.push(type);
-}
-
-const widgetTranspilerPlugin = {
-  walk: (context) => ({
-    enter: function (node, parent, prop, index) {
-      if (!isWidgetMethod(node)) return;
-      context.widgets ??= [];
-      const { widgets, options } = context;
-      const { emitWidgets } = options;
-      const type = node.callee.property.name;
-      const idx = widgets.filter((w) => w.type === type).length;
-      const widgetConfig = {
-        from: node.start,
-        to: node.end,
-        index: idx,
-        type,
-        id: options.id,
-      };
-      emitWidgets && widgets.push(widgetConfig);
-      return this.replace(widgetWithLocation(node, widgetConfig));
-    },
-  }),
-};
-
-const sliderTranspilerPlugin = {
-  walk: (context) => ({
-    enter: function (node, parent, prop, index) {
-      if (!isSliderFunction(node)) return;
-      context.widgets ??= [];
-      context.sliders ??= [];
-      const { options, widgets, sliders, nodeOffset } = context;
-      const { emitWidgets } = options;
-      const from = node.arguments[0].start + nodeOffset;
-      const to = node.arguments[0].end + nodeOffset;
-      const id = `${from}:${to}`; // Range-based ID for stability
-      const sliderConfig = {
-        from,
-        to,
-        id,
-        value: node.arguments[0].raw, // don't use value!
-        min: node.arguments[1]?.value ?? 0,
-        max: node.arguments[2]?.value ?? 1,
-        step: node.arguments[3]?.value,
-        type: 'slider',
-      };
-      emitWidgets && widgets.push(sliderConfig);
-      sliders.push(sliderConfig);
-      return this.replace(sliderWithLocation(node, nodeOffset));
-    },
-  }),
-};
-
-export const widgetTranspilerPlugins = [sliderTranspilerPlugin, widgetTranspilerPlugin];
-
-// these functions are connected to @strudel/codemirror -> slider.mjs
-// maybe someday there will be pluggable transpiler functions, then move this there
-function isSliderFunction(node) {
-  return node.type === 'CallExpression' && node.callee.name === 'slider';
-}
-
-function isWidgetMethod(node) {
-  return node.type === 'CallExpression' && widgetMethods.includes(node.callee.property?.name);
-}
-
-function sliderWithLocation(node, nodeOffset = 0) {
-  // Apply nodeOffset for block-based evaluation to generate correct range
-  const from = node.arguments[0].start + nodeOffset;
-  const to = node.arguments[0].end + nodeOffset;
-
-  // Use range-based ID for stability during block evaluation
-  const id = `${from}:${to}`;
-
-  // add loc as identifier to first argument
-  // the sliderWithID function is assumed to be sliderWithID(id, value, min?, max?)
-  node.arguments.unshift({
-    type: 'Literal',
-    value: id,
-    raw: id,
-  });
-  node.callee.name = 'sliderWithID';
-  return node;
-}
-
-export function getWidgetID(widgetConfig) {
-  // the widget id is used as id for the dom element + as key for eventual resources
-  // for example, for each scope widget, a new analyser + buffer (large) is created
-  // Update: use range-based ID generation for better stability during block evaluation
-  // When we have both from and to, use them together for stability
-  // Otherwise fall back to position-based ID for backward compatibility
-  let uniqueIdentifier;
-  if (widgetConfig.from !== undefined && widgetConfig.to !== undefined) {
-    // Use range for more stable identification
-    uniqueIdentifier = `${widgetConfig.from}-${widgetConfig.to}`;
-  } else {
-    // Fallback to single position (for backward compatibility)
-    uniqueIdentifier = widgetConfig.to || widgetConfig.from || 0;
-  }
-  const baseId = `${widgetConfig.id || ''}_widget_${widgetConfig.type}`;
-  return `${baseId}_${widgetConfig.index}_${uniqueIdentifier}`;
-}
-
-function widgetWithLocation(node, widgetConfig) {
-  const id = getWidgetID(widgetConfig);
-  // Store the unique ID back into the config so it's available for widget management
-  // This is critical for block-based evaluation to match existing widgets with new ones
-  widgetConfig.id = id;
-  // add loc as identifier to first argument
-  // the sliderWithID function is assumed to be sliderWithID(id, value, min?, max?)
-  node.arguments.unshift({
-    type: 'Literal',
-    value: id,
-    raw: id,
-  });
-  return node;
-}
-
-registerTranspilerPlugin(widgetTranspilerPlugins);

packages/transpiler/test/transpiler.test.mjs

@@ -5,7 +5,7 @@ This program is free software: you can redistribute it and/or modify it under th
 */
 
 import { describe, it, expect } from 'vitest';
-import { transpiler } from '../index.mjs';
+import { transpiler } from '../transpiler.mjs';
 
 const simple = { wrapAsync: false, addReturn: false, simpleLocs: true };
 

packages/transpiler/transpiler.mjs

@@ -1,12 +1,13 @@
-/*
-transpiler.mjs - <short description TODO>
-Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/superdough/superdough.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 { getLeafLocations } from '@strudel/mini';
 import { parse } from 'acorn';
 import escodegen from 'escodegen';
 import { walk } from 'estree-walker';
 
+let widgetMethods = [];
+export function registerWidgetType(type) {
+  widgetMethods.push(type);
+}
+
 let languages = new Map();
 // config = { getLocations: (code: string, offset?: number) => number[][] }
 // see mondough.mjs for example use
@@ -16,31 +17,9 @@ let languages = new Map();
 export function registerLanguage(type, config) {
   languages.set(type, config);
 }
-export function getLanguages() {
-  return languages;
-}
-
-const plugins = [];
-
-export function registerTranspilerPlugin(plugin) {
-  plugins.push(plugin);
-}
-export function getPlugins() {
-  return plugins.flat(Infinity);
-}
 
 export function transpiler(input, options = {}) {
-  options = {
-    wrapAsync: false,
-    addReturn: true,
-    emitMiniLocations: true,
-    emitWidgets: true,
-    blockBased: false,
-    range: [],
-    ...options,
-  };
-
-  const { wrapAsync, addReturn, emitMiniLocations, emitWidgets, blockBased, range } = options;
+  const { wrapAsync = false, addReturn = true, emitMiniLocations = true, emitWidgets = true } = options;
 
   const comments = [];
   let ast = parse(input, {
@@ -50,103 +29,169 @@ export function transpiler(input, options = {}) {
     onComment: comments,
   });
 
-  let miniDisableRanges = findMiniDisableRanges(comments, input.length);
-
-  // Position offset for block-based evaluation
-  let nodeOffset = range && range.length > 0 ? range[0] : 0;
-
-  // Track declarations to add to strudelScope for block-based eval
-  let scopeDeclarations = [];
-
-  let labels = [];
-
-  const context = { options, input, nodeOffset, miniDisableRanges, labels };
-  const plugins = getPlugins().map((plugin) => plugin.walk?.(context));
+  const miniDisableRanges = findMiniDisableRanges(comments, input.length);
+  let miniLocations = [];
+  const collectMiniLocations = (value, node) => {
+    const minilang = languages.get('minilang');
+    if (minilang) {
+      const code = `[${value}]`;
+      const locs = minilang.getLocations(code, node.start);
+      miniLocations = miniLocations.concat(locs);
+    } else {
+      const leafLocs = getLeafLocations(`"${value}"`, node.start, input);
+      miniLocations = miniLocations.concat(leafLocs);
+    }
+  };
+  let widgets = [];
 
   walk(ast, {
-    enter(node, parent, prop, index) {
-      // Apply position offset for block-based evaluation
-      if (blockBased && node.start !== undefined) {
-        node.start = node.start + nodeOffset;
-        node.end = node.end + nodeOffset;
-      }
-      // Collect variable and function declarations for strudelScope (block-based eval)
-      if (blockBased && parent?.type === 'Program') {
-        if (node.type === 'VariableDeclaration') {
-          for (const declarator of node.declarations) {
-            if (declarator.id?.name) {
-              scopeDeclarations.push(declarator.id.name);
-            }
-          }
-        } else if (node.type === 'FunctionDeclaration' && node.id?.name) {
-          scopeDeclarations.push(node.id.name);
+    enter(node, parent /* , prop, index */) {
+      if (isLanguageLiteral(node)) {
+        const { name } = node.tag;
+        const language = languages.get(name);
+        const code = node.quasi.quasis[0].value.raw;
+        const offset = node.quasi.start + 1;
+        if (emitMiniLocations) {
+          const locs = language.getLocations(code, offset);
+          miniLocations = miniLocations.concat(locs);
         }
+        this.skip();
+        return this.replace(languageWithLocation(name, code, offset));
       }
-
-      for (const plugin of plugins) {
-        if (!plugin?.enter?.call(this, node, parent, prop, index)) continue;
-        return;
+      if (isTemplateLiteral(node, 'tidal')) {
+        const raw = node.quasi.quasis[0].value.raw;
+        const offset = node.quasi.start + 1;
+        if (emitMiniLocations) {
+          const stringLocs = collectHaskellMiniLocations(raw, offset);
+          miniLocations = miniLocations.concat(stringLocs);
+        }
+        this.skip();
+        return this.replace(tidalWithLocation(raw, offset));
       }
-
-      if (isLabelStatement(node)) {
-        // Collect label info for block-based evaluation
-        // Store positions WITHOUT offset so repl can slice the transpiler output correctly
-        if (blockBased) {
-          labels.push({
-            name: node.label.name,
-            index: node.start - nodeOffset,
-            end: node.label.end - nodeOffset,
-            fullMatch: input.slice(node.start - nodeOffset, node.label.end - nodeOffset),
-            activeVisualizer: findVisualizerInSubtree(node.body),
+      if (isBackTickString(node, parent)) {
+        if (isMiniDisabled(node.start, miniDisableRanges)) {
+          return;
+        }
+        const { quasis } = node;
+        const { raw } = quasis[0].value;
+        this.skip();
+        emitMiniLocations && collectMiniLocations(raw, node);
+        return this.replace(miniWithLocation(raw, node));
+      }
+      if (isStringWithDoubleQuotes(node)) {
+        if (isMiniDisabled(node.start, miniDisableRanges)) {
+          return;
+        }
+        const { value } = node;
+        this.skip();
+        emitMiniLocations && collectMiniLocations(value, node);
+        return this.replace(miniWithLocation(value, node));
+      }
+      if (isSliderFunction(node)) {
+        emitWidgets &&
+          widgets.push({
+            from: node.arguments[0].start,
+            to: node.arguments[0].end,
+            value: node.arguments[0].raw, // don't use value!
+            min: node.arguments[1]?.value ?? 0,
+            max: node.arguments[2]?.value ?? 1,
+            step: node.arguments[3]?.value,
+            type: 'slider',
           });
-        }
-        return this.replace(labelToP(node));
+        return this.replace(sliderWithLocation(node));
       }
-      // Detect all() calls as special labels for block management
-      // Store positions WITHOUT offset so repl can slice the transpiler output correctly
-      if (blockBased && isAllCall(node)) {
-        labels.push({
-          name: 'all',
-          index: node.start - nodeOffset,
-          end: node.end - nodeOffset,
-          fullMatch: input.slice(node.start - nodeOffset, node.end - nodeOffset),
-          activeVisualizer: node.arguments[0] ? findVisualizerInSubtree(node.arguments[0]) : null,
-        });
+      if (isWidgetMethod(node)) {
+        const type = node.callee.property.name;
+        const index = widgets.filter((w) => w.type === type).length;
+        const widgetConfig = {
+          to: node.end,
+          index,
+          type,
+          id: options.id,
+        };
+        emitWidgets && widgets.push(widgetConfig);
+        return this.replace(widgetWithLocation(node, widgetConfig));
+      }
+      if (isBareSamplesCall(node, parent)) {
+        return this.replace(withAwait(node));
+      }
+      if (isLabelStatement(node)) {
+        return this.replace(labelToP(node));
       }
     },
 
     leave(node, parent, prop, index) {
-      for (const plugin of plugins) {
-        if (!plugin?.leave?.call(this, node, parent, prop, index)) continue;
-        return;
+      if (!isKabelCall(node)) return;
+
+      let [expr, ...rest] = node.arguments;
+      if (!expr) throw new Error('K(...) requires an expression');
+
+      if (shouldCallKabelExpression(expr)) {
+        expr = {
+          type: 'CallExpression',
+          callee: expr,
+          arguments: [],
+          optional: false,
+        };
       }
+
+      const { template, patternExprs } = extractPatternPlaceholders(expr);
+      if (patternExprs.length) {
+        const workletArgs = [{ type: 'Literal', value: template }, ...patternExprs, ...rest];
+
+        let callee = node.callee;
+        if (callee.type === 'ChainExpression') callee = callee.expression;
+        if (callee.type === 'MemberExpression') {
+          return this.replace({
+            type: 'CallExpression',
+            callee: workletMemberAst(callee.object),
+            arguments: workletArgs,
+            optional: false,
+          });
+        }
+        return this.replace({
+          type: 'CallExpression',
+          callee: { type: 'Identifier', name: 'worklet' },
+          arguments: workletArgs,
+          optional: false,
+        });
+      }
+
+      const kabelSrc = genExprSource(expr);
+      const workletArgs = [{ type: 'Literal', value: kabelSrc }, ...rest];
+
+      let callee = node.callee;
+      if (callee.type === 'ChainExpression') callee = callee.expression;
+      if (callee.type === 'MemberExpression') {
+        return this.replace({
+          type: 'CallExpression',
+          callee: workletMemberAst(callee.object),
+          arguments: workletArgs,
+          optional: false,
+        });
+      }
+      return this.replace({
+        type: 'CallExpression',
+        callee: { type: 'Identifier', name: 'worklet' },
+        arguments: workletArgs,
+        optional: false,
+      });
     },
   });
 
   let { body } = ast;
 
-  const silenceExpression = {
-    type: 'ExpressionStatement',
-    expression: {
-      type: 'Identifier',
-      name: 'silence',
-    },
-  };
-
   if (!body.length) {
     console.warn('empty body -> fallback to silence');
-    body.push(silenceExpression);
+    body.push({
+      type: 'ExpressionStatement',
+      expression: {
+        type: 'Identifier',
+        name: 'silence',
+      },
+    });
   } else if (!body?.[body.length - 1]?.expression) {
-    // Last statement is not an expression (e.g., VariableDeclaration, FunctionDeclaration)
-    body.push(silenceExpression);
-  }
-
-  // For block-based eval, add scope assignments before the return statement
-  // This allows variables/functions defined in one block to be used in other blocks
-  if (blockBased && scopeDeclarations.length > 0) {
-    const scopeAssignments = scopeDeclarations.flatMap((name) => createScopeAssignment(name));
-    // Insert scope assignments before the last statement (which will become the return)
-    body.splice(body.length - 1, 0, ...scopeAssignments);
+    throw new Error('unexpected ast format without body expression');
   }
 
   // add return to last statement
@@ -164,15 +209,256 @@ export function transpiler(input, options = {}) {
   if (!emitMiniLocations) {
     return { output };
   }
-
-  let pluginContext;
-  ({ options, input, miniDisableRanges, nodeOffset, ...pluginContext } = context);
-
-  return { output, ...pluginContext };
+  return { output, miniLocations, widgets };
 }
 
-function isAllCall(node) {
-  return node.type === 'CallExpression' && node.callee.name === 'all';
+function isKabelCall(node) {
+  if (node.type !== 'CallExpression') return false;
+  let callee = node.callee;
+  if (callee.type === 'ChainExpression') callee = callee.expression;
+  if (callee.type === 'MemberExpression') return !callee.computed && callee.property?.name === 'K';
+  return callee.type === 'Identifier' && callee.name === 'K';
+}
+
+function shouldCallKabelExpression(expr) {
+  if (expr.type !== 'ArrowFunctionExpression' && expr.type !== 'FunctionExpression') {
+    return false;
+  }
+  if (expr.params.length) {
+    return false;
+  }
+  return expr.body?.type === 'BlockStatement';
+}
+
+function genExprSource(expr) {
+  return escodegen.generate(expr, { format: { semicolons: false } });
+}
+
+function extractPatternPlaceholders(expr) {
+  const templateExpr = cloneNode(expr);
+  const parents = new Map();
+  const targets = [];
+
+  walk(templateExpr, {
+    enter(node, parent, prop, index) {
+      parents.set(node, { parent, prop, index });
+      const patternExpr = getStrudelPatternExpr(node);
+      if (patternExpr) {
+        targets.push({ node, patternExpr });
+        this.skip();
+      }
+    },
+  });
+
+  if (!targets.length) {
+    return { template: genExprSource(templateExpr), patternExprs: [] };
+  }
+
+  targets.sort((a, b) => getPatternNodeOrder(a.node) - getPatternNodeOrder(b.node));
+
+  const patternExprs = targets.map(({ patternExpr }) => cloneNode(patternExpr));
+
+  let currentExpr = templateExpr;
+  targets.forEach(({ node }, index) => {
+    currentExpr = replaceNode(node, placeholderAst(index), parents, currentExpr);
+  });
+
+  const template = genExprSource(currentExpr);
+  return { template, patternExprs };
+}
+
+function getStrudelPatternExpr(node) {
+  if (isStrudelPatternWrap(node)) {
+    const arg = node.arguments?.[0];
+    if (!arg) {
+      throw new Error('S(...) requires an argument');
+    }
+    return arg;
+  }
+  if (isMiniCall(node)) {
+    return node;
+  }
+  return null;
+}
+
+function isStrudelPatternWrap(node) {
+  if (node.type !== 'CallExpression') {
+    return false;
+  }
+  const callee = node.callee;
+  if (callee.type === 'Identifier') {
+    return callee.name === 'S';
+  }
+  if (callee.type === 'MemberExpression' && !callee.computed) {
+    return callee.property?.name === 'S';
+  }
+  return false;
+}
+
+function getMinilangName() {
+  const minilang = languages.get('minilang');
+  return minilang?.name || 'm';
+}
+
+// Used to identify transpiled `m(...)` calls for proper conversion
+// to, say, kabelsalat placeholders
+function isMiniCall(node) {
+  if (node.type !== 'CallExpression') {
+    return false;
+  }
+  const callee = node.callee;
+  if (callee.type !== 'Identifier') {
+    return false;
+  }
+  if (callee.name !== getMinilangName()) {
+    return false;
+  }
+  const firstArg = node.arguments?.[0];
+  return firstArg?.type === 'Literal' && typeof firstArg.value === 'string';
+}
+
+// If `start` is available, we use it. If it's already been transpiled
+// to `m(...)`, use the provided offset
+function getPatternNodeOrder(node) {
+  if (typeof node.start === 'number') {
+    return node.start;
+  }
+  if (isMiniCall(node)) {
+    const offsetArg = node.arguments?.[1];
+    if (offsetArg?.type === 'Literal' && typeof offsetArg.value === 'number') {
+      return offsetArg.value;
+    }
+  }
+  return 0;
+}
+
+function placeholderAst(index) {
+  return {
+    type: 'MemberExpression',
+    object: { type: 'Identifier', name: 'pat' },
+    property: { type: 'Literal', value: index },
+    computed: true,
+    optional: false,
+  };
+}
+
+function replaceNode(node, replacement, parents, currentRoot) {
+  const info = parents.get(node);
+  if (!info || !info.parent) {
+    return replacement;
+  }
+
+  const { parent, prop, index } = info;
+  if (Array.isArray(parent[prop])) {
+    parent[prop][index] = replacement;
+  } else {
+    parent[prop] = replacement;
+  }
+  parents.set(replacement, { parent, prop, index });
+  return currentRoot;
+}
+
+function cloneNode(node) {
+  return JSON.parse(JSON.stringify(node));
+}
+
+function workletMemberAst(objectExpr) {
+  return {
+    type: 'MemberExpression',
+    object: objectExpr,
+    property: { type: 'Identifier', name: 'worklet' },
+    computed: false,
+    optional: false,
+  };
+}
+
+function isStringWithDoubleQuotes(node, locations, code) {
+  if (node.type !== 'Literal') {
+    return false;
+  }
+  return node.raw[0] === '"';
+}
+
+function isBackTickString(node, parent) {
+  return node.type === 'TemplateLiteral' && parent.type !== 'TaggedTemplateExpression';
+}
+
+function miniWithLocation(value, node) {
+  const { start: fromOffset } = node;
+
+  const minilang = languages.get('minilang');
+  let name = 'm';
+  if (minilang && minilang.name) {
+    name = minilang.name; // name is expected to be exported from the package of the minilang
+  }
+
+  return {
+    type: 'CallExpression',
+    callee: {
+      type: 'Identifier',
+      name,
+    },
+    arguments: [
+      { type: 'Literal', value },
+      { type: 'Literal', value: fromOffset },
+    ],
+    optional: false,
+  };
+}
+
+// these functions are connected to @strudel/codemirror -> slider.mjs
+// maybe someday there will be pluggable transpiler functions, then move this there
+function isSliderFunction(node) {
+  return node.type === 'CallExpression' && node.callee.name === 'slider';
+}
+
+function isWidgetMethod(node) {
+  return node.type === 'CallExpression' && widgetMethods.includes(node.callee.property?.name);
+}
+
+function sliderWithLocation(node) {
+  const id = 'slider_' + node.arguments[0].start; // use loc of first arg for id
+  // add loc as identifier to first argument
+  // the sliderWithID function is assumed to be sliderWithID(id, value, min?, max?)
+  node.arguments.unshift({
+    type: 'Literal',
+    value: id,
+    raw: id,
+  });
+  node.callee.name = 'sliderWithID';
+  return node;
+}
+
+export function getWidgetID(widgetConfig) {
+  // the widget id is used as id for the dom element + as key for eventual resources
+  // for example, for each scope widget, a new analyser + buffer (large) is created
+  // that means, if we use the index index of line position as id, less garbage is generated
+  // return `widget_${widgetConfig.to}`; // more gargabe
+  //return `widget_${widgetConfig.index}_${widgetConfig.to}`; // also more garbage
+  return `${widgetConfig.id || ''}_widget_${widgetConfig.type}_${widgetConfig.index}`; // less garbage
+}
+
+function widgetWithLocation(node, widgetConfig) {
+  const id = getWidgetID(widgetConfig);
+  // add loc as identifier to first argument
+  // the sliderWithID function is assumed to be sliderWithID(id, value, min?, max?)
+  node.arguments.unshift({
+    type: 'Literal',
+    value: id,
+    raw: id,
+  });
+  return node;
+}
+
+function isBareSamplesCall(node, parent) {
+  return node.type === 'CallExpression' && node.callee.name === 'samples' && parent.type !== 'AwaitExpression';
+}
+
+function withAwait(node) {
+  return {
+    type: 'AwaitExpression',
+    argument: node,
+  };
 }
 
 function isLabelStatement(node) {
@@ -205,126 +491,67 @@ function labelToP(node) {
   };
 }
 
-// List of non-inline widgets that need cleanup
-// These are Pattern.prototype methods that create persistent visualizations
-// (should be repalced by a function call producing an actual list of registered widgets)
-const nonInlineWidgets = ['punchcard', 'spiral', 'scope', 'pitchwheel', 'spectrum', 'pianoroll', 'wordfall'];
-
-function isVisualizerCall(node) {
-  if (
-    node.type === 'CallExpression' &&
-    node.callee.type === 'MemberExpression' &&
-    nonInlineWidgets.includes(node.callee.property?.name)
-  ) {
-    return node.callee.property.name;
-  }
-  return null;
+function isLanguageLiteral(node) {
+  return node.type === 'TaggedTemplateExpression' && languages.has(node.tag.name);
 }
 
-function findVisualizerInSubtree(node) {
-  if (!node || typeof node !== 'object') return null;
+// tidal highlighting
+// this feels kind of stupid, when we also know the location inside the string op (tidal.mjs)
+// but maybe it's the only way
 
-  // Check if this node is a visualizer call
-  const viz = isVisualizerCall(node);
-  if (viz) return viz;
+function isTemplateLiteral(node, value) {
+  return node.type === 'TaggedTemplateExpression' && node.tag.name === value;
+}
 
-  // Recursively search children
-  for (const key of Object.keys(node)) {
-    if (key === 'parent') continue; // Skip parent references to avoid cycles
-    const child = node[key];
-    if (Array.isArray(child)) {
-      for (const item of child) {
-        const found = findVisualizerInSubtree(item);
-        if (found) return found;
+function collectHaskellMiniLocations(haskellCode, offset) {
+  return haskellCode
+    .split('')
+    .reduce((acc, char, i) => {
+      if (char !== '"') {
+        return acc;
       }
-    } else if (child && typeof child === 'object' && child.type) {
-      const found = findVisualizerInSubtree(child);
-      if (found) return found;
-    }
-  }
-  return null;
+      if (!acc.length || acc[acc.length - 1].length > 1) {
+        acc.push([i + 1]);
+      } else {
+        acc[acc.length - 1].push(i);
+      }
+      return acc;
+    }, [])
+    .map(([start, end]) => {
+      const miniString = haskellCode.slice(start, end);
+      return getLeafLocations(`"${miniString}"`, offset + start - 1);
+    })
+    .flat();
 }
 
-// Creates AST nodes for: userDefinedKeys.add('name'); strudelScope.name = name; globalThis.name = name;
-// Used in block-based evaluation to persist variables/functions across blocks
-// We add to both strudelScope (for internal lookups) and globalThis (for direct access)
-// We also track the key in userDefinedKeys so clearScope() can remove it later
-function createScopeAssignment(name) {
-  return [
-    // userDefinedKeys.add('name');
-    {
-      type: 'ExpressionStatement',
-      expression: {
-        type: 'CallExpression',
-        callee: {
-          type: 'MemberExpression',
-          object: {
-            type: 'Identifier',
-            name: 'userDefinedKeys',
-          },
-          property: {
-            type: 'Identifier',
-            name: 'add',
-          },
-          computed: false,
-        },
-        arguments: [
-          {
-            type: 'Literal',
-            value: name,
-          },
-        ],
-      },
+function tidalWithLocation(value, offset) {
+  return {
+    type: 'CallExpression',
+    callee: {
+      type: 'Identifier',
+      name: 'tidal',
     },
-    // strudelScope.name = name;
-    {
-      type: 'ExpressionStatement',
-      expression: {
-        type: 'AssignmentExpression',
-        operator: '=',
-        left: {
-          type: 'MemberExpression',
-          object: {
-            type: 'Identifier',
-            name: 'strudelScope',
-          },
-          property: {
-            type: 'Identifier',
-            name: name,
-          },
-          computed: false,
-        },
-        right: {
-          type: 'Identifier',
-          name: name,
-        },
-      },
+    arguments: [
+      { type: 'Literal', value },
+      { type: 'Literal', value: offset },
+    ],
+    optional: false,
+  };
+}
+
+function languageWithLocation(name, value, offset) {
+  return {
+    type: 'CallExpression',
+    callee: {
+      type: 'Identifier',
+      name: name,
     },
-    // globalThis.name = name;
-    {
-      type: 'ExpressionStatement',
-      expression: {
-        type: 'AssignmentExpression',
-        operator: '=',
-        left: {
-          type: 'MemberExpression',
-          object: {
-            type: 'Identifier',
-            name: 'globalThis',
-          },
-          property: {
-            type: 'Identifier',
-            name: name,
-          },
-          computed: false,
-        },
-        right: {
-          type: 'Identifier',
-          name: name,
-        },
-      },
-    },
-  ];
+    arguments: [
+      { type: 'Literal', value },
+      { type: 'Literal', value: offset },
+    ],
+    optional: false,
+  };
 }
 
 function findMiniDisableRanges(comments, codeEnd) {
@@ -346,3 +573,12 @@ function findMiniDisableRanges(comments, codeEnd) {
   }
   return ranges;
 }
+
+function isMiniDisabled(offset, miniDisableRanges) {
+  for (const [start, end] of miniDisableRanges) {
+    if (offset >= start && offset < end) {
+      return true;
+    }
+  }
+  return false;
+}

packages/web/package.json

@@ -34,7 +34,6 @@
   "homepage": "https://codeberg.org/uzu/strudel#readme",
   "dependencies": {
     "@strudel/core": "workspace:*",
-    "@strudel/edo": "workspace:*",
     "@strudel/mini": "workspace:*",
     "@strudel/tonal": "workspace:*",
     "@strudel/transpiler": "workspace:*",

packages/web/web.mjs

@@ -3,7 +3,6 @@ export * from '@strudel/webaudio';
 //export * from '@strudel/soundfonts';
 export * from '@strudel/transpiler';
 export * from '@strudel/mini';
-export * from '@strudel/edo';
 export * from '@strudel/tonal';
 export * from '@strudel/webaudio';
 import { Pattern, evalScope, setTime } from '@strudel/core';
@@ -18,7 +17,6 @@ export async function defaultPrebake() {
     evalScope,
     import('@strudel/core'),
     import('@strudel/mini'),
-    import('@strudel/edo'),
     import('@strudel/tonal'),
     import('@strudel/webaudio'),
     { hush, evaluate },

packages/xen/tune.mjs

@@ -7,51 +7,14 @@ This program is free software: you can redistribute it and/or modify it under th
 import Tune from './tunejs.js';
 import { register } from '@strudel/core';
 
-/**
- * Assumes pattern contains numerical scale degrees on the `i` control (see examples below). Accepts a scale name or list of frequencies (see all available names at the link on the reference). Returns a new pattern with all values mapped to a frequency ratio. Similar to `xen`.
- * @name tune
- * @returns Pattern
- * @memberof Pattern
- * @param {(string | number[] )} scale
- * @example
- * i("0 1 2 3 4 5").tune("hexany15").mul("220").freq()
- * @example
- * // You can set your root to be a
- * // particular note with getFreq:
- * i("4 8 9 10 - - 5 7 9 11 - -").tune("tranh3")
- *   .mul(getFreq('c3'))
- *   .freq().clip(.5).room(1)
- * @example
- * // You can also give tune a list of
- * // frequencies to use as the scale:
- * i("0 1 2 3 4").tune([
- *   261.6255653006,
- *   302.72962012827,
- *   350.29154279212,
- *   405.32593044476,
- *   469.00678383895,
- *   523.2511306012
- * ]).mul(220).freq();
- *
- * @tags tonal
- */
-
-// Tune.scale seems to be in ratio format
 export const tune = register('tune', (scale, pat) => {
   const tune = new Tune();
   if (!tune.isValidScale(scale)) {
     throw new Error('not a valid tune.js scale name: "' + scale + '". See http://abbernie.github.io/tune/scales.html');
   }
   tune.loadScale(scale);
-  // if the tonic is a frequency, why are we putting in "1"
   tune.tonicize(1);
   return pat.withHap((hap) => {
-    if (typeof hap.value !== 'object') {
-      throw new Error(`Expected hap to have control 'i' set, but received ${hap.value.i}, try wrapping input in i()`);
-    }
-    // const { i, ...otherValues } = hap.value;
-    // hap.value = { ...otherValues, freq: tune.note(i)}
-    // return hap
-    return hap.withValue(() => tune.note(hap.value.i));
+    return hap.withValue(() => tune.note(hap.value));
   });
 });

packages/xen/tunejs.js

@@ -78,21 +78,14 @@ Tune.prototype.frequency = function(stepIn, octaveIn) {
 	}
 	
 	// which scale degree (0 - scale length) is our input
-	// 60 % 12 = 0
 	var scaleDegree = stepIn % this.scale.length
 
-	// what's this doing
-	// 0 scaleDegree = 12
-	// seems to simply be for a negative result from above, maybe another way to do it, but ok for now
 	while (scaleDegree < 0) {
 		scaleDegree += this.scale.length
 	}
 	
-	// tonic is currently always 1
-	// so this is 1*scale[scaledegree]
 	var freq = this.tonic*this.scale[scaleDegree]
 	
-	// map it to octave
 	freq = freq*(Math.pow(2,octave))
 	
 	// truncate irrational numbers
@@ -144,13 +137,10 @@ Tune.prototype.MIDI = function(stepIn,octaveIn) {
 }
 
 /* Load a new scale */
-// sets .scale to ratios
 
 Tune.prototype.loadScale = function(scale){
 
 	/* load the scale */
-	let name
-	if (typeof scale === 'string') name = scale;
 	var freqs = isArrayOfNumbers(scale) ? scale : TuningList[scale].frequencies
 	this.scale = []
 	for (var i=0;i<freqs.length-1;i++) {
@@ -158,10 +148,10 @@ Tune.prototype.loadScale = function(scale){
 	}
 
 	/* visualize in console */
-	// console.log(" ");
-	// console.log("LOADED "+name);
-	// console.log(TuningList[name].description);
-	// console.log(this.scale);
+/* 	console.log(" ");
+	console.log("LOADED "+name);
+	console.log(TuningList[name].description);
+	console.log(this.scale); */
 	var vis = [];
 	for (var i=0;i<100;i++) {
 		vis[i] = " ";

packages/xen/xen.mjs

@@ -4,10 +4,8 @@ Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/
 This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
-import { register, _mod, parseNumeral, removeUndefineds } from '@strudel/core';
-import Tune from './tunejs.js';
+import { register, _mod, parseNumeral } from '@strudel/core';
 
-// returns a list of frequency ratios for given edo scale
 export function edo(name) {
   if (!/^[1-9]+[0-9]*edo$/.test(name)) {
     throw new Error('not an edo scale: "' + name + '"');
@@ -20,33 +18,23 @@ const presets = {
   '12ji': [1 / 1, 16 / 15, 9 / 8, 6 / 5, 5 / 4, 4 / 3, 45 / 32, 3 / 2, 8 / 5, 5 / 3, 16 / 9, 15 / 8],
 };
 
-// Given a base frequency such as 220 and an edo scale, returns
-// an array of frequencies representing the given edo scale in that base
-function _withBase(freq, scale) {
+function withBase(freq, scale) {
   return scale.map((r) => r * freq);
 }
 
 const defaultBase = 220;
 
-const isEdo = (scale) => /^[1-9]+[0-9]*edo$/.test(scale);
-
-// Assumes a base of 220. Returns a filtered scale based on 'indices'
-// NOTE: indices functionality is unused
 function getXenScale(scale, indices) {
-  let tune = new Tune();
   if (typeof scale === 'string') {
-    if (isEdo(scale)) {
+    if (/^[1-9]+[0-9]*edo$/.test(scale)) {
       scale = edo(scale);
     } else if (presets[scale]) {
       scale = presets[scale];
-    } else if (tune.isValidScale(scale)) {
-      tune.loadScale(scale);
-      scale = tune.scale;
     } else {
       throw new Error('unknown scale name: "' + scale + '"');
     }
   }
-  scale = _withBase(defaultBase, scale);
+  scale = withBase(defaultBase, scale);
   if (!indices) {
     return scale;
   }
@@ -59,172 +47,16 @@ function xenOffset(xenScale, offset, index = 0) {
   return xenScale[i] * Math.pow(2, oct);
 }
 
-const trimFreq = (freq) => parseFloat(freq.toPrecision(10));
-
-// accepts a scale name such as 31edo, and a pattern
-// pattern expected to follow format such that a value can be mapped
-// to an edostep within the scale. Returns the pattern with
-// values mapped to the frequencies associated with the given edosteps
 // scaleNameOrRatios: string || number[], steps?: number
-
-/**
- * Assumes a numerical pattern of scale steps, and a scale. Scales accepted are all preset scale names of `tune`, arbitrary edos such as 31edo, or an array of frequency ratios. Assumes scales repeat at octave (2/1). Returns a new pattern with all values mapped to their associated frequency, assuming a base frequency of 220hz.
- *
- * @name xen
- * @returns Pattern
- * @memberof Pattern
- * @param {(string | number[] )} scaleNameOrRatios
- * @tags tonal
- * @example
- * // A minor triad in 31edo:
- * i("0 8 18").xen("31edo").piano()
- * @example
- * // You can also use xen with frequency ratios.
- * // This is equivalent to the above:
- * i("0 1 2").xen([
- *   Math.pow(2, 0/31),
- *   Math.pow(2, 8/31),
- *   Math.pow(2, 18/31),
- * ]).piano()
- * @example
- * // xen also supports all scale names that
- * // tune does:
- * i("0 1 2 3 4 5").xen("hexany15")
- * // equiv to:
- * // "0 1 2 3 4 5".tune("hexany15").mul("220").freq()
- * @example
- * i("0 1 2 3 4 5 6 7").xen("<5edo 10edo 15edo hexany15>")
- */
-
 export const xen = register('xen', function (scaleNameOrRatios, pat) {
-  return pat.withHaps((haps) => {
-    haps = haps.map((hap) => {
-      let hVal = hap.value;
-      const isObject = typeof hVal === 'object';
-      if (!isObject) {
-        throw new Error(`Expected hap to have control 'i' set, but received ${hap.value.i}, try wrapping input in i()`);
-      }
-      const { i, ...otherValues } = hVal;
-      const scale = getXenScale(scaleNameOrRatios);
-      let freq = xenOffset(scale, parseNumeral(hVal.i));
-      // 10 is somewhat arbitrary
-      freq = trimFreq(freq);
-      hap.value = { ...otherValues, freq };
-      return isEdo(scaleNameOrRatios)
-        ? hap.setContext({ ...hap.context, edoSize: scaleNameOrRatios.match(/^([1-9]+[0-9]*)edo$/)[1] })
-        : hap;
-    });
-    return removeUndefineds(haps);
+  return pat.withHap((hap) => {
+    const scale = getXenScale(scaleNameOrRatios);
+    const frequency = xenOffset(scale, parseNumeral(hap.value));
+    return hap.withValue(() => frequency);
   });
 });
 
-/**
- * Assumes pattern of frequencies tuned to some `base` frequency, such as the output of `xen`
- * Because `xen` defaults to `220Hz`, so will `withBase`.
- * but you can specify a different original base with the standard optional array syntax '`:`'
- * @name withBase
- * @param {number} base
- * @param {number} (optional) originalBase
- * @tags tonal
- *
- * @example
- * i("[0 1 2 3] [3 4] [4 3 2 1]").xen("hexany23").withBase("<220 [300 200]>")
- * @example
- * mini([1 / 1, 16 / 15, 9 / 8, 6 / 5, 5 / 4].join(' ')).withBase("220:1")
- * // mini([1 / 1, 16 / 15, 9 / 8, 6 / 5, 5 / 4].join(' ')).mul(220).freq()
- *
- * @returns Pattern
- */
-export const withBase = register('withBase', (b, pat) => {
-  let base;
-  let originalBase = 220;
-  if (Array.isArray(b)) {
-    base = b[0];
-    originalBase = b[1];
-  } else {
-    base = b;
-  }
-  return pat.withHaps((haps) => {
-    haps = haps.map((hap) => {
-      let hVal = hap.value;
-      const isObject = typeof hVal === 'object';
-      let freq = isObject ? hVal.freq : hVal;
-      if (!freq) return hap;
-      freq = (freq * base) / originalBase;
-      hap.value = isObject ? { ...hap.value, freq } : { freq };
-      return hap;
-    });
-    return removeUndefineds(haps);
-  });
-});
-
-/**
- * Frequency transpose. Assumes pattern either has `freq` set, or has values that can be interpreted as frequencies
- * amt has optional `edoSize` param, defaults to 12.
- * If haps have edoSize param set, such as from the output of `xen("31edo")`,
- * `ftrans` will fallback to that instead of 12 as the default.
- *
- * Transposes the frequency by `amt` edoSteps
- * @name ftranspose
- * @synonyms ftrans, fTrans, ftranspose, fTranspose
- * @tags tonal
- * @param {number} amt
- * @param {number} edoSize (optional)
- * @returns {Pattern}
- *
- * @example
- * i("0 1 2").xen("12edo").ftrans("7")
- * // n("0 1 2").scale("A:chromatic").trans("7")
- * @example
- * i("0 8 18").xen("31edo").ftrans("<8 -8>")
- * @example
- * // to transpose by steps of an edo, use "step:edo" :
- * i("0 7 8 18").xen("31edo").ftrans("<0 1:31 1:12>")
- * @example
- * // it can also work with frequency values directly
- * freq("200 300 400").ftrans("<0 7:31 7>")
- */
-
-/* f = frequency (Hz)
-  n = edo (steps per octave)
-  x = number of steps
-  if 0\n = f, then x\n = f * 2^(x/n)
-  example: 5edo, 0\5 = 220 Hz, then 2\5 = 220*2^(2/5) = 290.29 Hz */
-
-export const { ftrans, fTrans, ftranspose, fTranspose } = register(
-  ['ftrans', 'fTrans', 'ftranspose', 'fTranspose'],
-  (amt, pat) => {
-    let edoSize;
-    let numSteps;
-    if (Array.isArray(amt)) {
-      edoSize = amt[1];
-      numSteps = amt[0];
-    } else {
-      numSteps = amt;
-    }
-    return pat.withHaps((haps) => {
-      haps = haps.map((hap) => {
-        let hVal = hap.value;
-        const isObject = typeof hVal === 'object';
-        hVal = isObject ? hVal : { freq: hVal };
-        let { freq, ...otherValues } = hVal;
-        if (edoSize == undefined && hap.context.edoSize != undefined) {
-          edoSize = hap.context.edoSize;
-        } else if (edoSize == undefined) {
-          edoSize = 12;
-        }
-        freq = freq * Math.pow(2, numSteps / edoSize);
-        freq = trimFreq(freq);
-        hap.value = isObject ? { ...otherValues, freq } : freq;
-        return hap.setContext({ ...hap.context, edoSize });
-      });
-      return removeUndefineds(haps);
-    });
-  },
-);
-
-// not sure there's a point to having this and the above, seems like a proto version of the above.
-const tuning = register('tuning', function (ratios, pat) {
+export const tuning = register('tuning', function (ratios, pat) {
   return pat.withHap((hap) => {
     const frequency = xenOffset(ratios, parseNumeral(hap.value));
     return hap.withValue(() => frequency);

pnpm-lock.yaml

@@ -4,30 +4,6 @@ settings:
   autoInstallPeers: true
   excludeLinksFromLockfile: false
 
-catalogs:
-  default:
-    '@codemirror/autocomplete':
-      specifier: ^6.18.4
-      version: 6.18.4
-    '@codemirror/commands':
-      specifier: ^6.8.0
-      version: 6.8.0
-    '@codemirror/lang-javascript':
-      specifier: ^6.2.2
-      version: 6.2.2
-    '@codemirror/language':
-      specifier: ^6.10.8
-      version: 6.10.8
-    '@codemirror/search':
-      specifier: ^6.5.8
-      version: 6.5.8
-    '@codemirror/state':
-      specifier: ^6.5.1
-      version: 6.5.1
-    '@codemirror/view':
-      specifier: ^6.36.2
-      version: 6.36.2
-
 importers:
 
   .:
@@ -35,9 +11,6 @@ importers:
       '@strudel/core':
         specifier: workspace:*
         version: link:packages/core
-      '@strudel/edo':
-        specifier: workspace:*
-        version: link:packages/edo
       '@strudel/mini':
         specifier: workspace:*
         version: link:packages/mini
@@ -120,9 +93,6 @@ importers:
       '@strudel/draw':
         specifier: workspace:*
         version: link:../../packages/draw
-      '@strudel/edo':
-        specifier: workspace:*
-        version: link:../../packages/edo
       '@strudel/mini':
         specifier: workspace:*
         version: link:../../packages/mini
@@ -201,25 +171,25 @@ importers:
   packages/codemirror:
     dependencies:
       '@codemirror/autocomplete':
-        specifier: 'catalog:'
+        specifier: ^6.18.4
         version: 6.18.4
       '@codemirror/commands':
-        specifier: 'catalog:'
+        specifier: ^6.8.0
         version: 6.8.0
       '@codemirror/lang-javascript':
-        specifier: 'catalog:'
+        specifier: ^6.2.2
         version: 6.2.2
       '@codemirror/language':
-        specifier: 'catalog:'
+        specifier: ^6.10.8
         version: 6.10.8
       '@codemirror/search':
-        specifier: 'catalog:'
+        specifier: ^6.5.8
         version: 6.5.8
       '@codemirror/state':
-        specifier: 'catalog:'
+        specifier: ^6.5.1
         version: 6.5.1
       '@codemirror/view':
-        specifier: 'catalog:'
+        specifier: ^6.36.2
         version: 6.36.2
       '@lezer/highlight':
         specifier: ^1.2.1
@@ -251,9 +221,6 @@ importers:
       '@tonaljs/tonal':
         specifier: ^4.10.0
         version: 4.10.0
-      codemirror-helix:
-        specifier: ^0.5.0
-        version: 0.5.0(@codemirror/commands@6.8.0)(@codemirror/language@6.10.8)(@codemirror/search@6.5.8)(@codemirror/state@6.5.1)(@codemirror/view@6.36.2)
       nanostores:
         specifier: ^0.11.3
         version: 0.11.3
@@ -313,28 +280,6 @@ importers:
         specifier: ^6.0.11
         version: 6.0.11(@types/node@22.10.10)(jiti@2.4.2)(lightningcss@1.29.1)(terser@5.37.0)(yaml@2.7.0)
 
-  packages/edo:
-    dependencies:
-      '@strudel/core':
-        specifier: workspace:*
-        version: link:../core
-      '@tonaljs/tonal':
-        specifier: ^4.10.0
-        version: 4.10.0
-      chord-voicings:
-        specifier: ^0.0.1
-        version: 0.0.1
-      webmidi:
-        specifier: ^3.1.12
-        version: 3.1.12
-    devDependencies:
-      vite:
-        specifier: ^6.0.11
-        version: 6.0.11(@types/node@22.10.10)(jiti@2.4.2)(lightningcss@1.29.1)(terser@5.37.0)(yaml@2.7.0)
-      vitest:
-        specifier: ^3.0.4
-        version: 3.0.4(@types/debug@4.1.12)(@types/node@22.10.10)(@vitest/ui@3.0.4)(jiti@2.4.2)(lightningcss@1.29.1)(terser@5.37.0)(yaml@2.7.0)
-
   packages/embed: {}
 
   packages/gamepad:
@@ -501,9 +446,6 @@ importers:
       '@strudel/draw':
         specifier: workspace:*
         version: link:../draw
-      '@strudel/edo':
-        specifier: workspace:*
-        version: link:../edo
       '@strudel/hydra':
         specifier: workspace:*
         version: link:../hydra
@@ -679,9 +621,6 @@ importers:
       '@strudel/core':
         specifier: workspace:*
         version: link:../core
-      '@strudel/edo':
-        specifier: workspace:*
-        version: link:../edo
       '@strudel/mini':
         specifier: workspace:*
         version: link:../mini
@@ -763,21 +702,6 @@ importers:
       '@astrojs/tailwind':
         specifier: ^5.1.5
         version: 5.1.5(astro@5.1.9(@types/node@22.10.10)(jiti@2.4.2)(lightningcss@1.29.1)(rollup@2.79.2)(terser@5.37.0)(typescript@5.7.3)(yaml@2.7.0))(tailwindcss@3.4.17)
-      '@codemirror/commands':
-        specifier: 'catalog:'
-        version: 6.8.0
-      '@codemirror/lang-javascript':
-        specifier: 'catalog:'
-        version: 6.2.2
-      '@codemirror/language':
-        specifier: 'catalog:'
-        version: 6.10.8
-      '@codemirror/state':
-        specifier: 'catalog:'
-        version: 6.5.1
-      '@codemirror/view':
-        specifier: 'catalog:'
-        version: 6.36.2
       '@docsearch/css':
         specifier: ^3.8.3
         version: 3.8.3
@@ -811,9 +735,6 @@ importers:
       '@strudel/draw':
         specifier: workspace:*
         version: link:../packages/draw
-      '@strudel/edo':
-        specifier: workspace:*
-        version: link:../packages/edo
       '@strudel/gamepad':
         specifier: workspace:*
         version: link:../packages/gamepad
@@ -3630,15 +3551,6 @@ packages:
     resolution: {integrity: sha512-FMabTRlc5t5zjdenF6mS0MBeFZm0XqHqeOkcskKFb/LYCcRQ5fVgLOHVc4Lq9CqABd9zhjwPjMBCJvMCziSVtA==}
     engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
-  codemirror-helix@0.5.0:
-    resolution: {integrity: sha512-hI56hf9VGz53H1YvL6H1GC7HtP6te8vX+MsIHaE9J7Q3PQ6KFapKtIRg6lqSH898ikHWpMCPu42r6HJN0IfVLA==}
-    peerDependencies:
-      '@codemirror/commands': ^6.0.0
-      '@codemirror/language': ^6.0.0
-      '@codemirror/search': ^6.0.0
-      '@codemirror/state': ^6.0.0
-      '@codemirror/view': ^6.0.0
-
   collapse-white-space@2.1.0:
     resolution: {integrity: sha512-loKTxY1zCOuG4j9f6EPnuyyYkf58RnhhWTvRoZEokgB+WbdXehfjFviyOVYkqzEWz1Q5kRiZdBYS5SwxbQYwzw==}
 
@@ -11368,14 +11280,6 @@ snapshots:
 
   cmd-shim@6.0.3: {}
 
-  codemirror-helix@0.5.0(@codemirror/commands@6.8.0)(@codemirror/language@6.10.8)(@codemirror/search@6.5.8)(@codemirror/state@6.5.1)(@codemirror/view@6.36.2):
-    dependencies:
-      '@codemirror/commands': 6.8.0
-      '@codemirror/language': 6.10.8
-      '@codemirror/search': 6.5.8
-      '@codemirror/state': 6.5.1
-      '@codemirror/view': 6.36.2
-
   collapse-white-space@2.1.0: {}
 
   color-convert@2.0.1:

pnpm-workspace.yaml

@@ -10,12 +10,3 @@ onlyBuiltDependencies:
   - sharp
   - tree-sitter
   - tree-sitter-haskell
-
-catalog:
-  "@codemirror/commands": "^6.8.0"
-  "@codemirror/language": "^6.10.8"
-  "@codemirror/lang-javascript": "^6.2.2"
-  "@codemirror/state": "^6.5.1"
-  "@codemirror/view": "^6.36.2"
-  "@codemirror/autocomplete": "^6.18.4"
-  "@codemirror/search": "^6.5.8"

test/examples.test.mjs

@@ -20,7 +20,6 @@ const skippedExamples = [
   'accelerationX',
   'defaultmidimap',
   'midimaps',
-  'clearScope',
   'bmod',
 ];
 

test/runtime.mjs

@@ -13,7 +13,6 @@ import { mini, m } from '@strudel/mini/mini.mjs';
 // import euclid from '@strudel/core/euclid.mjs';
 //import '@strudel/midi/midi.mjs';
 import * as tonalHelpers from '@strudel/tonal';
-import * as edoHelpers from '@strudel/edo';
 import '@strudel/xen/xen.mjs';
 // import '@strudel/xen/tune.mjs';
 // import '@strudel/core/euclid.mjs';
@@ -127,7 +126,6 @@ const loadSoundfont = () => {};
 const loadCsound = () => {};
 const loadCSound = () => {};
 const loadcsound = () => {};
-const getDuration = () => {};
 
 const midin = () => {
   return (ccNum) => strudel.ref(() => 0); // returns ref with default value 0
@@ -146,7 +144,6 @@ evalScope(
   toneHelpersMocked,
   uiHelpersMocked,
   webaudio,
-  edoHelpers,
   tonalHelpers,
   gamepadHelpers,
   /*
@@ -171,7 +168,6 @@ evalScope(
     loadCSound,
     loadCsound,
     loadcsound,
-    getDuration,
     setcps: id,
     setcpm: id,
     Clock: {}, // whatever

website/astro.config.mjs

@@ -10,11 +10,8 @@ import bundleAudioWorkletPlugin from 'vite-plugin-bundle-audioworklet';
 import tailwind from '@astrojs/tailwind';
 import AstroPWA from '@vite-pwa/astro';
 
-import process from 'node:process';
-
-const site = process.env.SITE_URL || `https://strudel.cc/`; // root url without a path
-const base = process.env.BASE_PATH || ''; // base path of the strudel site
-
+const site = process.env.STRUDEL_SITE || `https://strudel.cc/`; // root url without a path
+const base = process.env.STRUDEL_BASE || '/'; // base path of the strudel site
 const baseNoTrailing = base.endsWith('/') ? base.slice(0, -1) : base;
 
 // this rehype plugin fixes relative links
@@ -78,7 +75,6 @@ export default defineConfig({
             urlPattern: ({ url }) =>
               [
                 /^https:\/\/raw\.githubusercontent\.com\/.*/i,
-                /^https:\/\/strudel\.b-cdn\.net\/.*/i,
                 /^https:\/\/freesound\.org\/.*/i,
                 /^https:\/\/cdn\.freesound\.org\/.*/i,
                 /^https:\/\/shabda\.ndre\.gr\/.*/i,

website/package.json

@@ -17,11 +17,6 @@
     "@astrojs/react": "^4.1.6",
     "@astrojs/rss": "^4.0.11",
     "@astrojs/tailwind": "^5.1.5",
-    "@codemirror/commands": "catalog:",
-    "@codemirror/language": "catalog:",
-    "@codemirror/lang-javascript": "catalog:",
-    "@codemirror/state": "catalog:",
-    "@codemirror/view": "catalog:",
     "@docsearch/css": "^3.8.3",
     "@docsearch/react": "^3.8.3",
     "@headlessui/react": "^2.2.0",
@@ -33,7 +28,6 @@
     "@strudel/csound": "workspace:*",
     "@strudel/desktopbridge": "workspace:*",
     "@strudel/draw": "workspace:*",
-    "@strudel/edo": "workspace:*",
     "@strudel/gamepad": "workspace:*",
     "@strudel/hydra": "workspace:*",
     "@strudel/midi": "workspace:*",

website/src/config.ts

@@ -98,14 +98,13 @@ export const SIDEBAR: Sidebar = {
       { text: 'Random Modifiers', link: 'learn/random-modifiers' },
       { text: 'Conditional Modifiers', link: 'learn/conditional-modifiers' },
       { text: 'Accumulation', link: 'learn/accumulation' },
-      { text: 'LFOs', link: 'learn/lfo' },
       { text: 'Tonal Functions', link: 'learn/tonal' },
       { text: 'Stepwise Functions', link: 'learn/stepwise' },
     ],
     Understand: [
       { text: 'Coding syntax', link: 'learn/code' },
       { text: 'Pitch', link: 'understand/pitch' },
-      { text: 'Xenharmonic Functions', link: 'learn/xen' },
+      { text: 'Xen Harmonic Functions', link: 'learn/xen' },
       { text: 'Cycles', link: 'understand/cycles' },
       { text: 'Voicings', link: 'understand/voicings' },
       { text: 'Pattern Alignment', link: 'technical-manual/alignment' },

website/src/pages/learn/faq.mdx

@@ -52,15 +52,6 @@ There are multiple ways to load your sample collection. Some methods are good fo
 - Serve a folder of samples locally using the [strudel 'sampler' commandline tool](https://strudel.cc/learn/samples/#from-disk-via-strudelsampler). This can be most reliable method, but requires [nodejs](https://nodejs.org) to be installed.
 - Host your sound library online on the web and [load them from an URL](/learn/samples/#loading-custom-samples)
 
-## Can I create a new project based on Strudel?
-
-Strudel is free/open source software, and we are always happy to see people making use of it within the following terms:
-
-- Please don't use 'strudel' in the name of your project (e.g. strudel2000, foo-strudel), so people don't assume it's official strudel project. (If you'd like it to be an official strudel project, please check in with the community, e.g. on the [discord chat](https://discord.com/invite/HGEdXmRkzT).)
-- Please respect our AGPL license, which e.g. requires you to share/link to the source code of strudel, any modifications you've made to it, and the source code for the rest of your project if it integrates with strudel. You are also required to maintain Strudel's copyright notices in the source code, and include Strudel's copyright notice in your user interface. This is an ad-hoc summary - please [refer to the license](https://codeberg.org/uzu/strudel/src/branch/main/LICENSE) for full details.
-
-You are also encouraged to connect with [the community](https://discord.com/invite/HGEdXmRkzT) to understand our aims and values.
-
 ## Can I use Strudel with AI/LLM tools?
 
 You are free to do what you like with Strudel, within the terms of the free/open source AGPLv3 license.

website/src/pages/learn/lfo.mdx

@@ -1,301 +0,0 @@
----
-title: Low-frequency oscillators (LFO)
-layout: ../../layouts/MainLayout.astro
----
-
-import { MiniRepl } from '../../docs/MiniRepl';
-import { JsDoc } from '../../docs/JsDoc';
-
-# Low frequency oscillators (LFO)
-
-A low frequency oscillator (or short LFO) is a common way on synthesizers to continuously modulate various signals.
-
-This documentation is an interactive version of glossing's tutorial https://www.youtube.com/watch?v=11frBA9L638
-
-## Signals vs LFOs
-
-In Strudel, there are two ways to modulate:
-
-1. [signals](/learn/signals/) for pattern-level modulation
-2. `lfo` (this page) for audio-level modulation
-
-## Applying an LFO
-
-Here, the LFO will change the frequency of the `saw`. Put a comment like this `//.lfo()` to see and hear how it changes, and remove the comment again.
-
-<MiniRepl
-  client:idle
-  tune={`
-s("saw").lfo() 
-  .lpf(800)
-  ._spectrum({height: 300, width: 800})`}
-/>
-
-By default, the LFO will modulate the control parameter which is right before `.lfo()`:
-
-<MiniRepl
-  client:idle
-  tune={`
-s("saw")
-  .lpf(800).lfo() 
-  ._spectrum({height: 300, width: 800})`}
-/>
-
-Here, the LFO will modulate the low pass filter `.lpf`.
-
-## Moving away from the default
-
-The following sections explain how pass parameters to `.lfo`. Similar to `._spectrum` above, almost all the configuration of `lfo` lives inside a json object, starting with `{` and ending with `}`.
-All the parameters (except `id`) are written as `key: value` inside and separated by `,`.
-
-The reference refers to them as `config.key`, i.e. for the following one as `config.control` but you use them like below.
-
-## Control
-
-`control` determines which parameter will be modulated. This allows you to place your `lfo` at different places,
-not necessarily immediately after the controlled parameter.
-
-Here, we place `lfo` after the `s`, but it modulates the low pass filter.
-
-<MiniRepl
-  client:idle
-  tune={`
-s("saw")
-  .lfo({control:'lpf'})
-  .lpf(800)
-  ._spectrum({height: 300, width: 800})`}
-/>
-You can even influence parameters which are always present, even if you haven't explicitly written them, like `gain`.
-
-<MiniRepl
-  client:idle
-  tune={`
-s("saw")
-  .lfo({control:'gain'})
-  .lpf(800)
-  ._spectrum({height: 300, width: 800})`}
-/>
-
-`control` has an alias `c`.
-
-## Rate
-
-`rate` determines how often the `lfo` oscillates per second:
-
-<MiniRepl
-  client:idle
-  tune={`
- s("saw")
-  .lfo({c:'gain', rate:"<2 4>"})
-  .lpf(800)
-  ._spectrum({height: 300, width: 800})`}
-/>
-The alias of `rate` is `r`.{' '}
-
-## Sync
-
-Instead of controlling the frequency with `rate` by setting a frequency in Hz, you can use `sync`
-to snychronize your lfo with your other patterns.
-
-`sync` expresses this frequency as "times per cycle"
-
-Try removing the `sync: "<2 4 8 0.5 >"` from the pattern and notice that there is something not in sync.
-
-<MiniRepl
-  client:idle
-  tune={`
-$: s("bd*4").bank("TR909").postgain(0.5)
-$: s("saw")
-  .lpf(800)
-  .lfo({sync: "<2 4 8 0.5 >"})
-  ._spectrum({height: 300, width: 800})`}
-/>
-
-You can put patterns into the parameters of `lfo` if you want them to change over time, as seen above.
-
-## Relative Depth
-
-`.depth` is relative depth, a value of 1 (the default) means that
-the value goes above and below by half of the value which is being modulated
-
-E.g. for depth `1`, it modulates the frequency to oscillate between 32 = (64/2) and 96 (= 64 + 64/2).
-
-<MiniRepl
-  client:idle
-  tune={`
-s("saw").freq(64)
-  .lfo({r: 2, depth: "<1 2 3>"})
-  .lpf(800)
-  ._spectrum({height: 300, width: 800})`}
-/>
-The `freq` is not needed here, as this is the default frequency, it's just for instructive purposes.
-
-The aliases of `depth` are `dr` and `dep`.
-
-## Absolute Depth
-
-`depthabs` controls the absolute modulation depth. For example you can modulate
-the low pass filter by exactly 250 Hz up and below:
-
-<MiniRepl
-  client:idle
-  tune={`
-s("saw")
-  .lpf(800)
-  .lfo({r: 2, depthabs: "250"})`}
-/>
-
-The alias of `depthabs` is `da`.
-
-## DC offset
-
-If you don't want to go up or down by the same amount with your modulation, then you can shift the center of the modulation with `dcoffset`.
-The default value is -0.5, which is the middle point between:
-"dcoffset = 0: All modulations increase the control parameter (or keep it constant)"
-"dcoffset = -1: All modulations decrease the control parameter (or keep it constant)"
-
-Other values will work as well.
-
-<MiniRepl
-  client:idle
-  tune={`
-s("saw")
-  .lpf(600)
-  .lfo({r: 2, da: "200", dcoffset: "<-0.5 -1 -0.5 0>"})`}
-/>
-The marvellous alias of `dcoffset` is `dc`.
-
-## Shape
-
-You can change the shape of the modulation with `shape`. The default is `triangle`, but other shapes are available too:
-
-<MiniRepl
-  client:idle
-  tune={`
-s("saw")
-  .lpf(800)
-  .lfo({r: 2, shape: "<triangle sine ramp saw square>"}) `}
-/>
-You can add `._spectrum()` to see the shape of the modulations in the spectrum.
-
-You can also get these shapes by using numbers:
-
-| Shape    | number |
-| -------- | ------ |
-| triangle | 0      |
-| sine     | 1      |
-| ramp     | 2      |
-| saw      | 3      |
-| square   | 4      |
-
-this way, you can use a function like `irand` to generate numbers:
-
-<MiniRepl
-  client:idle
-  tune={`
-s("saw")
-  .lpf(800)
-  .lfo({r: 2, shape: irand(4)}) `}
-/>
-
-The alias of `shape` is `sh`.
-
-## Skewing some shapes
-
-You can influence some of the shapes (`triangle` and `square`) in more detail.
-
-The default skew is 0.5, it does different things for these two.
-
-For `triangle`, it skews the top of the triangle to the left or right,
-where 0 makes it look like `saw` and 1 makes it look like `ramp`.
-
-For `square`, the skew influences the pulse width (see reference for `pulse` and `.pw`):
-
-<MiniRepl
-  client:idle
-  tune={`
-s("saw")
-  .lpf(800)
-  .lfo({r: 2, sh: "<triangle square>/5", 
-    skew: "<0 0.25 0.5 0.75 1>"}) `}
-/>
-The alias of `skew` is `sk`.{' '}
-
-## Curve
-
-You can change the curves of your lfo and can make it more intense.
-The default value is 1. Writing numbers greater than one can make it more intense,
-numbers between 0 and 1 will make it less intense.
-This will raise the lfo to the power of curve, so larger numbers (such as 10) can have very unexpected results.
-
-<MiniRepl
-  client:idle
-  tune={`
-s("saw")
-  .lpf(800)
-  .lfo({r: 2, sh: "<triangle>", curve: "<1.3 1 0.75 1>"}) `}
-/>
-## Referencing your lfos with id
-
-All the lfos are numbered from the first starting with 0, the second having an `id` of 1 and so on.
-
-You can refer to this in a later call if you want to modify a specific `lfo`.
-
-The `id` is outside of the config json (which is different from the other parameters of `lfo()`
-
-Try out how the sound changes when you replace the 0 with a 1.
-
-<MiniRepl
-  client:idle
-  tune={`
-s("saw").lfo().lpf(800)
-.lfo({s: "<4 8 0.5>"})
-.sometimes(x => x.lfo({dr: "4"},0))`}
-/>
-
-You can also name your lfos and refer to them by name, using the `id` parameter
-
-<MiniRepl
-  client:idle
-  tune={`
-s("saw").lfo({}, "lfo_freq_saw").lpf(800)
-.lfo({s: "<4 8 0.5>"}, "lfo_lpf")
-.sometimes(x => x.lfo({dr: "4"},"<lfo_lpf lfo_freq_saw>"))`}
-/>
-
-## FX index
-
-If you are using `FX()` to reorder your effects, you dont need to write your lfos inside the `FX`,
-but instead can refer to them by their FX index (starting with 0)
-
-<MiniRepl
-  client:idle
-  tune={`
-s("saw").FX(
-  distort(3),
-  gain(0.3), // this has the fx index 1
-  lpf(400)
-).lfo({s: 16, dr:2, c:"gain", fxi: 1})`}
-/>
-
-## Modulating other LFOs with Sub-control
-
-LFOs can modulate other lfos and will modulate their frequency (given by `r` or `s`):
-
-<MiniRepl
-  client:idle
-  tune={`
-s("saw").lpf(400).gain(0.8)
-  .lfo({s: 16, dr:2, c:"gain"})
-  .lfo({s: 0.3, dc:-1, dr: 0.8})`}
-/>
-To modulate other parameters of the first lfo (like `skew`, `depth` and so on), we can specify this with `subControl`or
-its alias `sc`
-
-<MiniRepl
-  client:idle
-  tune={`
-s("saw").lpf(400).gain(0.8)
-  .lfo({s: 4, dr:2, c:"gain"})
-.lfo({s: 0.3, sc: "skew"})`}
-/>

website/src/pages/learn/xen.mdx

@@ -1,26 +1,22 @@
 ---
-title: Xenharmonic Functions
+title: Xen Harmonic Functions
 layout: ../../layouts/MainLayout.astro
 ---
 
 import { MiniRepl } from '../../docs/MiniRepl';
 import { JsDoc } from '../../docs/JsDoc';
 
-# Xenharmonic Functions (experimental)
-
-{/* TODO expand explanation of xenharmony */}
+# Xen Harmonic Functions
 
 These functions allow the use of scales other than your typical chromatic 12 based ones.
 
 ### tune(scale)
 
-{/* TODO (maybe): combine jsdoc things in tune.mjs with here */}
-
 <JsDoc client:idle name="tune" h={0} />
 
 Here's an example of how to configure a basic hexany scale:
 
-<MiniRepl client:idle tune={`i("0 1 2 3 4 5").tune("hexany15").mul("220").freq()`} />
+<MiniRepl client:idle tune={`"0 1 2 3 4 5".tune("hexany15").mul("220").freq()`} />
 
 Try other scales like `hexany1`, `iraq`, `gumbeng`, `gunkali`, or `tranh3`
 
@@ -30,7 +26,7 @@ You can set your root to be a particular note with `getFreq`
 
 <MiniRepl
   client:idle
-  tune={`i("4 8 9 10 - - 5 7 9 11 - -").tune("tranh3")
+  tune={`"4 8 9 10 - - 5 7 9 11 - -".tune("tranh3")
     .mul(getFreq('c3'))
     .freq().clip(.5).room(1)`}
 />
@@ -39,7 +35,7 @@ Some tunings become more pronounced with a longer reverb decay:
 
 <MiniRepl
   client:idle
-  tune={`i("<[5 6 8 10] - [5 7 9 12] -> -").tune("gumbeng")
+  tune={`"<[5 6 8 10] - [5 7 9 12] -> -".tune("gumbeng")
   .mul(getFreq('c3'))
   .freq().clip(.8).room("3:10").rdim(10000).rfade(5)`}
 />
@@ -48,7 +44,7 @@ Additionally, you can combo this with `fmap` so that the base note changes:
 
 <MiniRepl
   client:idle
-  tune={`i("9 11 12 10 - - -").tune("gunkali")
+  tune={`"9 11 12 10 - - -".tune("gunkali")
   .mul("<c3 c3 a3 d#3>".fmap(getFreq))
   .freq().legato("2 .7").room("1:15").rdim(8500).rlp(14000).rfade(8)`}
 />
@@ -57,7 +53,8 @@ Combining this with various polyrhythm tricks can become very evocative:
 
 <MiniRepl
   client:idle
-  tune={`i("<[0 3 1 -] [-1 4 2 8]> ~ ~,<-4 -5>".add(4))
+  tune={`"<[0 3 1 -] [-1 4 2 8]> ~ ~,<-4 -5>"
+  .transpose(4)
   .tune("iraq")
   .mul("<c3 d3 c#3>".fmap(getFreq))
   .freq().clip(.5).room(1).rfade(9)`}
@@ -70,7 +67,7 @@ Take the `sanza` tuning:
 
 <MiniRepl
   client:idle
-  tune={`i("4 5 6 7 8 9").tune("sanza")
+  tune={`"4 5 6 7 8 9".tune("sanza")
   .mul(getFreq('c3'))
   .freq()`}
 />
@@ -78,15 +75,15 @@ Take the `sanza` tuning:
 Notes 7 and 9 will clash quite a bit if you arp them normally. Many tunings will have this sort of sound, and it can feel distracting on its own.
 See how close they are on the pitch wheel?
 
-<MiniRepl client:idle tune={`i("[7 9]!3").tune("sanza").mul(getFreq('c3')).freq()._pitchwheel()`} />
+<MiniRepl client:idle tune={`"[7 9]!3".tune("sanza").mul(getFreq('c3')).freq()._pitchwheel()`} />
 
 This quality is often due to how the tunings were formed with instruments that were played differently than a piano.
 As such, some tunings are much better strummed, with the subtle clash of the detuned notes actually making the sound much more magical:
 
 <MiniRepl
   client:idle
-  tune={`i("[0 1 2 3 4 5 6]@0.3 -"
-  .add("<2 5 8 1>"))
+  tune={`"[0 1 2 3 4 5 6]@0.3 -"
+  .transpose("<2 5 8 1>")
   .tune("sanza")
   .mul(getFreq('c3')).freq()
   .legato("3").room(1).rfade(5)`}
@@ -96,23 +93,3 @@ Note the legato and reverb effects make sure the sound of the strumming gets to
 tones sound even more alive, too.
 
 The `tranh3` tuning has a similar set of notes, with two clashing. You might trying plugging that in above and see if you find a favorite strumming pattern.
-
-You can also give tune a list of frequencies to use as the scale:
-
-<MiniRepl
-  client:idle
-  tune={`i("0 1 2 3 4").tune([
-    261.6255653006, 
-    302.72962012827, 
-    350.29154279212, 
-    405.32593044476, 
-    469.00678383895, 
-    523.2511306012
-  ]).mul(220).freq();`}
-/>
-
-### xen(scaleOrRatios)
-
-{/* TODO add explanation of EDO to documentation */}
-
-<JsDoc client:idle name="Pattern.xen" h={0} />

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

@@ -1,11 +1,11 @@
 ---
-title: Pattern Alignment
+title: Pattern Aligment
 layout: ../../layouts/MainLayout.astro
 ---
 
 import { MiniRepl } from '../../docs/MiniRepl';
 
-# Pattern Alignment & Combination
+# Pattern Aligment & Combination
 
 One core aspect of Strudel, inherited from Tidal, is the flexible way that patterns can be combined, irrespective of their structure. Its declarative approach means a live coder does not have to think about the details of _how_ this is done, only _what_ is to be done.
 

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

@@ -1,85 +0,0 @@
----
-title: Helix Keybindings
-layout: ../../layouts/MainLayout.astro
----
-
-# Helix Keybindings in the REPL
-
-The Strudel REPL supports [Helix editor](https://helix-editor.com/) keybindings through the `codemirror-helix` extension. Helix is a post-modern modal text editor with a focus on selection-first editing and multiple cursors.
-
-## Enabling Helix Mode
-
-1. Open the Settings panel in the REPL (click the settings icon or use the keyboard shortcut)
-2. Find the "Keybindings" section
-3. Select "Helix" from the available options
-
-## Key Differences from Vim
-
-Helix uses a selection-first approach, which means:
-
-- **Selection → Action** (Helix) vs **Action → Motion** (Vim)
-- For example, to delete a word in Helix: `w` (select word) → `d` (delete)
-- In Vim, it would be: `dw` (delete word)
-
-## Common Helix Commands
-
-### Normal Mode
-
-- `i` — Enter insert mode before selection
-- `a` — Enter insert mode after selection
-- `v` — Enter visual/select mode
-- `w` — Select next word
-- `e` — Select to end of word
-- `b` — Select previous word
-- `x` — Select/extend line
-- `d` — Delete selection
-- `c` — Change selection (delete and enter insert mode)
-- `y` — Yank (copy) selection
-- `p` — Paste after selection
-- `u` — Undo
-- `U` — Redo
-- `/` — Search
-- `n` — Select next search match
-- `N` — Select previous search match
-
-### Movement
-
-- `h, j, k, l` — Move left, down, up, right
-- `gg` — Go to start of document
-- `ge` — Go to end of document
-- `{` / `}` — Move to previous/next paragraph
-- `%` — Match bracket
-
-### Multi-cursor
-
-- `C` — Duplicate cursor to line below
-- `Alt-C` — Duplicate cursor to line above
-- `,` — Remove primary cursor
-- `Alt-,` — Remove all secondary cursors
-
-## Strudel-Specific Features
-
-Currently, Helix mode in Strudel provides standard Helix keybindings. Unlike Vim mode, there are no custom Strudel-specific commands (like `:w` to evaluate) yet.
-
-To evaluate code while in Helix mode, use the standard shortcuts:
-
-- `Ctrl+Enter` or `Alt+Enter` — Evaluate code
-- `Alt+.` — Stop playback
-
-## Resources
-
-- [Helix Documentation](https://docs.helix-editor.com/)
-- [Helix Keymap](https://docs.helix-editor.com/keymap.html)
-- [codemirror-helix on npm](https://www.npmjs.com/package/codemirror-helix)
-- [codemirror-helix on GitLab](https://gitlab.com/_rvidal/codemirror-helix)
-
-## Notes
-
-- The `codemirror-helix` extension is described as an "initial version" and may not implement all Helix features
-- Behavior may differ slightly from the native Helix editor
-- If you encounter issues, you can switch back to other keybinding modes in Settings
-- The keybinding preference is saved in your browser's local storage
-
-## Contributing
-
-If you'd like to add Strudel-specific Helix commands (similar to Vim's `:w` for evaluate), contributions are welcome! See the implementation in `/packages/codemirror/keybindings.mjs` for reference.

website/src/pages/workshop/motors.mdx

@@ -1,117 +0,0 @@
----
-title: Movement with Strudel
-layout: ../../layouts/MainLayout.astro
----
-
-import { MiniRepl } from '@src/docs/MiniRepl';
-import Box from '@components/Box.astro';
-import QA from '@components/QA';
-
-# Controlling motors with Strudel
-
-Strudel is mainly made for making music, but it's possible to pattern other things with it, including motors.
-
-We're going to use a microcontroller for this, called an "[Inventor 2040W](https://shop.pimoroni.com/products/inventor-2040-w)", which is
-a [Pico W](https://shop.pimoroni.com/products/inventor-2040-w?variant=40053063155795) with extra ports added including some for controlling motors.
-
-![image](https://shop.pimoroni.com/cdn/shop/products/Inventor2040_1of3_1500x1500_crop_center.jpg?v=1656927927)
-
-## Technical details
-
-Feel free to gloss over these!
-
-- The Inventor 2040W connects to the internet wirelessly, and it can power from a battery or USB. Hopefully the batteries last!
-- It's running [some code](https://github.com/patternclub/alpacalab/blob/main/course/main.py) that listens for messages using an "Internet of Things" network protocol (called MQTT). When it receives a message, it moves a motor.
-- It connects to a small server (running software called 'mosquitto') on Alex's laptop.
-- Strudel can send these messages instead of triggering sounds - that's how we use it to pattern movement.
-
-## First movement
-
-Let's get a motor running!
-
-1. Note the letter drawn on a label on the back of the microcontroller.
-
-2. Plug a battery into your microcontroller.
-
-3. Plug a motor into 'servo' (not motor) plug numbered 1, with the yellow (lightest) cable closest to the '1', and the brown (darkest) cable outward
-
-4. Run the below to set up some values, changing the `x` in 'robot('x')` to the letter on your microcontroller.
-
-<MiniRepl
-  client:visible
-  tune={`
-   $: move("-60 80").motor("0").robot('x');
-  `}
-/>
-
-<Box>
-
-If you refresh the page, you'll need to change the letter to match your robot again.
-
-If your motor starts moving unexpectedly, someone else might have put your letter in by mistake!
-
-Note that in the above, we start counting motors from '0', so motor 1 on the board is motor 0 in the code.
-
-</Box>
-
-## Patterning movement
-
-Many strudel features for playing with sound patterns will work when
-playing with motor patterns. Try playing with the mininotation in the
-`move` command:
-
-<MiniRepl
-  client:visible
-  tune={`
-$: move("-10 0 10 [20 30]*2").motor("0").slow(2).robot('x')
-  `}
-/>
-
-The move instructions are in the range from -90 to 90.
-
-<box>
-  If your motors stop working at some point, and your code looks right, try pressing the 'reset' button on the
-  microcontroller.
-</box>
-
-It's possible to make smooth movements based on different 'waveforms', for example a smooth sinewave:
-
-<MiniRepl
-  client:visible
-  tune={`
-$: move(sine.range(-30, 30).segment(16)).motor("0").slow(2).robot('x');
-  `}
-/>
-
-The movement is still quite jerky, because the 'segment' command is
-only taking 16 positions from the sinewave. Try increasing it to 32 or 64. It's best not too much higher than that, as the microcontroller
-might get overwhelmed with a backlog of instructions!
-
-<box>
-  Try replacing `sine` with other waveforms: `saw` (sawtooth wave), `tri` (triangular wave) are good, and there is also
-  `rand` (random wave) and `perlin` (a kind of smoothed-out randomness).
-</box>
-
-## Patterning more than one motor
-
-You can pattern the `motor` command separately from the `move` one:
-
-<MiniRepl
-  client:visible
-  tune={`
-$: move("-10 0 10 [20 30]*2").motor("0 1").slow(2).robot('x');
-  `}
-/>
-
-Alternatively, you can pattern two motors in separate patterns. The below sends the same pattern for the first two motors, but with the second one running slower:
-
-<MiniRepl
-  client:visible
-  tune={`
-
-$: move("-10 0 10 [20 30]\*2").motor("0").slow(2).robot('x');
-
-$: move("-10 0 10 [20 30]\*2").motor("1").slow(3).robot('x');
-
-`}
-/>

website/src/repl/Repl.css

@@ -10,50 +10,50 @@
   opacity: 0.5;
 }
 
-.code-container .cm-scroller {
+#code .cm-scroller {
   padding-top: 10px !important;
   height: 100%;
   font-family: inherit;
 }
-.code-container .cm-content {
+#code .cm-content {
   padding-bottom: 50vh;
 }
-.code-container .cm-line > * {
+#code .cm-line > * {
   background: var(--lineBackground);
 }
 
-.code-container .cm-editor {
+#code .cm-editor {
   background-color: transparent !important;
   height: 100%;
   z-index: 11;
 }
 
-.code-container .cm-theme {
+#code .cm-theme {
   width: 100%;
   height: 100%;
 }
 
-.code-container .cm-theme-light {
+#code .cm-theme-light {
   width: 100%;
 }
 
-.code-container .cm-cursorLayer {
+#code .cm-cursorLayer {
   animation-name: inherit !important;
 }
 
-.code-container .cm-cursor {
+#code .cm-cursor {
   border-left: 2px solid currentcolor !important;
 }
 
-.code-container .cm-foldGutter {
+#code .cm-foldGutter {
   display: none !important;
 }
 
-.code-container .cm-focused {
+#code .cm-focused {
   outline: none;
 }
 
-.code-container .cm-matchingBracket {
+#code .cm-matchingBracket {
   text-decoration: underline 0.18rem;
   text-underline-offset: 0.22rem;
 }

website/src/repl/components/Code.jsx

@@ -8,7 +8,8 @@ export function Code(Props) {
 
   return (
     <section
-      className={'code-container text-gray-100 cursor-text pb-0 overflow-auto grow z-10'}
+      className={'text-gray-100 cursor-text pb-0 overflow-auto grow z-10'}
+      id="code"
       ref={(el) => {
         containerRef.current = el;
         if (!editorRef.current) {

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

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

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

@@ -1,50 +1,42 @@
 import { errorLogger } from '@strudel/core';
-import { storePrebakeScript } from '../../../settings.mjs';
-import { confirmDialog } from '@src/repl/util.mjs';
+import { useSettings, storePrebakeScript } from '../../../settings.mjs';
+import { SpecialActionInput } from '../button/action-button';
+import { confirmDialog, SETTING_CHANGE_RELOAD_MSG } from '@src/repl/util.mjs';
 
-async function importScript(script, updateEditor) {
+async function importScript(script) {
   const reader = new FileReader();
   reader.readAsText(script);
 
   reader.onload = () => {
     const text = reader.result;
     storePrebakeScript(text);
-    updateEditor && updateEditor(text);
   };
 
   reader.onerror = () => {
     errorLogger(new Error('failed to import prebake script'), 'importScript');
   };
 }
+export function ImportPrebakeScriptButton() {
+  const settings = useSettings();
 
-export async function exportScript(script) {
-  const blob = new Blob([script], { type: 'application/javascript' });
-  const downloadLink = document.createElement('a');
-  downloadLink.href = window.URL.createObjectURL(blob);
-  const date = new Date().toISOString().split('T')[0];
-  downloadLink.download = `prebake_${date}.strudel`;
-  document.body.appendChild(downloadLink);
-  downloadLink.click();
-  document.body.removeChild(downloadLink);
-}
-
-export function ImportPrebakeScriptButton({ updateEditor }) {
-  const handleChange = async (e) => {
-    const file = e.target.files[0];
-    const confirmed = await confirmDialog('Warning: This will overwrite the current prebake.\nContinue?');
-    if (!confirmed) {
-      return;
-    }
-    try {
-      await importScript(file, updateEditor);
-    } catch (e) {
-      errorLogger(e);
-    }
-  };
   return (
-    <label className="space-x-1 inline-flex items-center cursor-pointer">
-      <input type="file" accept=".strudel,.js" className="sr-only peer" onChange={handleChange} />
-      <span className="inline-flex items-center peer-hover:opacity-50 text-xs max-w-[300px]">import</span>
-    </label>
+    <SpecialActionInput
+      type="file"
+      label="import prebake script"
+      accept=".strudel"
+      onChange={async (e) => {
+        const file = e.target.files[0];
+        const confirmed = await confirmDialog(SETTING_CHANGE_RELOAD_MSG);
+        if (!confirmed) {
+          return;
+        }
+        try {
+          await importScript(file);
+          window.location.reload();
+        } catch (e) {
+          errorLogger(e);
+        }
+      }}
+    />
   );
 }

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

@@ -44,25 +44,6 @@ export function LogoButton({ context, isEmbedded }) {
 
 export function MainPanel({ context, isEmbedded = false, className }) {
   const { isZen, isButtonRowHidden, fontFamily } = useSettings();
-  let loc = window.location;
-  let ver = 'unofficial';
-  let hot = false;
-  let b = loc.hostname.match(/^(.+)\.(strudel)/);
-  if (/(strudel.cc$)/.test(loc.hostname)) {
-    // if there's no text before 'strudel', it's warm, otherwise use the text before strudel
-    ver = b ? b[1] : 'warm';
-  } else {
-    // match both versions of localhost
-    if (/(localhost)|(127.0.0.1)/.test(loc.hostname)) ver = 'dev';
-  }
-  let pr = ver.match(/pr-([0-9]+)/);
-  if (pr) {
-    pr = pr[1];
-    ver = `hot: ${pr}`;
-    hot = true;
-    pr = `https://codeberg.org/uzu/strudel/pulls/${pr}`;
-  }
-
   return (
     <nav
       id="header"
@@ -91,13 +72,6 @@ export function MainPanel({ context, isEmbedded = false, className }) {
               <div className="space-x-2 flex items-baseline">
                 <span className="hidden sm:block">strudel</span>
                 <span className="text-sm font-medium hidden sm:block">REPL</span>
-                {!hot ? (
-                  <span className="text-sm font-medium hidden sm:block">({ver})</span>
-                ) : (
-                  <a className="hover:opacity-50" href={pr} target="_blank">
-                    <span className="text-sm font-medium hidden sm:block">({ver})</span>
-                  </a>
-                )}
               </div>
             )}
           </h1>

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

@@ -4,11 +4,7 @@ import jsdocJson from '../../../../../doc.json';
 import { Textbox } from '@src/repl/components/panel/SettingsTab';
 import { settingsMap, useSettings } from '@src/settings.mjs';
 
-const isValid = ({ name, description, tags = [] }) => {
-  const isSupradoughOnly = tags.includes('supradough') && !tags.includes('superdough');
-  const isSuperdirtOnly = tags.includes('superdirt') && !tags.includes('superdough');
-  return name && !name.startsWith('_') && !!description && !isSupradoughOnly && !isSuperdirtOnly;
-};
+const isValid = ({ name, description }) => name && !name.startsWith('_') && !!description;
 
 const availableFunctions = (() => {
   const seen = new Set(); // avoid repetition
@@ -18,32 +14,36 @@ const availableFunctions = (() => {
     if (seen.has(doc.name)) continue;
 
     // jsdoc also uses "tags" for when you use @something in the comments and it doesn't know what
-    // @something is. We only want data from comments like `@tags superdough` here.
+    // @something is. We only want data from comments like `@tags fx, superdough` here.
     // If nothing is specified, we default to "untagged" for debugging
     doc.tags = doc.tags?.filter((t) => t && typeof t === 'string') || ['untagged'];
+    functions.push(doc);
 
     const synonyms = doc.synonyms || [];
-    let names = [doc.name];
     seen.add(doc.name);
     for (const s of synonyms) {
       if (!s || seen.has(s)) continue;
-      names.push(s);
       seen.add(s);
+      // Swap `doc.name` in for `s` in the list of synonyms
+      const synonymsWithDoc = [doc.name, ...synonyms].filter((x) => x && x !== s);
+      functions.push({
+        ...doc,
+        name: s, // update names for the synonym
+        longname: s,
+        synonyms: synonymsWithDoc,
+        synonyms_text: synonymsWithDoc.join(', '),
+      });
     }
-    doc.allNames = names.join(' ');
-    doc.synonyms = names.slice(1);
-    functions.push(doc);
   }
   return functions.sort((a, b) => /* a.meta.filename.localeCompare(b.meta.filename) +  */ a.name.localeCompare(b.name));
 })();
 
 const tagCounts = {};
-const ignoredTags = ['supradough', 'superdirt'];
 // const tagOptions = { all: `all (${availableFunctions.length})` };
 const tagOptions = { all: `all` };
 for (const doc of availableFunctions) {
   (doc.tags || ['untagged']).forEach((t) => {
-    if (typeof t === 'string' && t && !ignoredTags.includes(t)) {
+    if (typeof t === 'string' && t) {
       tagCounts[t] = (tagCounts[t] || 0) + 1;
       //tagOptions[t] = `${t} (${tagCounts[t]})`;
       tagOptions[t] = t;
@@ -82,7 +82,7 @@ export const Reference = memo(function Reference() {
       }
       const lowerCaseSearch = search.toLowerCase();
       return (
-        (entry.allNames || entry.name).toLowerCase().includes(lowerCaseSearch) ||
+        entry.name.toLowerCase().includes(lowerCaseSearch) ||
         (entry.synonyms?.some((s) => s.toLowerCase().includes(lowerCaseSearch)) ?? false)
       );
     });
@@ -151,7 +151,7 @@ export const Reference = memo(function Reference() {
             <Fragment key={`entry-${entry.name}`}>
               <a
                 className={
-                  'whitespace-nowrap cursor-pointer hover:opacity-50 text-ellipsis block' +
+                  'cursor-pointer hover:opacity-50 text-ellipsis block' +
                   (entry.name === selectedFunction ? 'bg-lineHighlight font-bold' : '')
                 }
                 onClick={() => {
@@ -162,7 +162,7 @@ export const Reference = memo(function Reference() {
                   }
                 }}
               >
-                {entry.name} {entry.synonyms && <small className="opacity-50">{entry.synonyms?.join(', ')}</small>}
+                {entry.name}
               </a>{' '}
             </Fragment>
           ))}
@@ -204,7 +204,7 @@ export const Reference = memo(function Reference() {
                 </h3>
                 {entry.tags && (
                   <span className="ml-2 text-xs text-foreground border border-muted px-1 py-0.5">
-                    {entry.tags.filter((t) => !ignoredTags.includes(t)).join(', ')}
+                    {entry.tags.join(', ')}
                   </span>
                 )}
               </div>

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

@@ -1,16 +1,18 @@
-import { defaultSettings, settingsMap, useSettings, storePrebakeScript, setSettingsTab } from '../../../settings.mjs';
+import { defaultSettings, settingsMap, useSettings } from '../../../settings.mjs';
 import { themes } from '@strudel/codemirror';
-import { PrebakeCodeMirror } from '../../../repl/prebakeCodeMirror.mjs';
 import { confirmAndReloadPage, isUdels } from '../../util.mjs';
 import { ButtonGroup } from './Forms.jsx';
 import { AudioDeviceSelector } from './AudioDeviceSelector.jsx';
 import { AudioEngineTargetSelector } from './AudioEngineTargetSelector.jsx';
 import { confirmDialog } from '../../util.mjs';
 import { DEFAULT_MAX_POLYPHONY, setMaxPolyphony, setMultiChannelOrbits } from '@strudel/webaudio';
-import { ActionButton } from '../button/action-button.jsx';
-import { exportScript, ImportPrebakeScriptButton } from './ImportPrebakeScriptButton.jsx';
-import { useEffect, useRef } from 'react';
-import cx from '@src/cx.mjs';
+import { SpecialActionButton } from '../button/action-button.jsx';
+import { ImportPrebakeScriptButton } from './ImportPrebakeScriptButton.jsx';
+
+function cx(...classes) {
+  // : Array<string | undefined>
+  return classes.filter(Boolean).join(' ');
+}
 
 const inputClass =
   'bg-background text-xs h-8 max-h-8 border border-box rounded-0 text-foreground border-muted placeholder-muted focus:outline-none focus:ring-0 focus:border-foreground';
@@ -121,7 +123,7 @@ const fontFamilyOptions = {
   galactico: 'galactico',
 };
 
-function MainSettingsContent({ started }) {
+export function SettingsTab({ started }) {
   const {
     theme,
     keybindings,
@@ -147,12 +149,12 @@ function MainSettingsContent({ started }) {
     isTabIndentationEnabled,
     isMultiCursorEnabled,
     patternAutoStart,
-    isBlockBasedEvalEnabled,
+    includePrebakeScriptInShare,
   } = useSettings();
   const shouldAlwaysSync = isUdels();
   const canChangeAudioDevice = AudioContext.prototype.setSinkId != null;
   return (
-    <div className="p-4 text-foreground space-y-4 w-full overflow-auto" style={{ fontFamily }}>
+    <div className="p-4 text-foreground space-y-4 w-full" style={{ fontFamily }}>
       {canChangeAudioDevice && (
         <FormItem label="Audio Output Device">
           <AudioDeviceSelector
@@ -230,12 +232,20 @@ function MainSettingsContent({ started }) {
           />
         </FormItem>
       </div>
+      <FormItem label="Prebake">
+        <ImportPrebakeScriptButton />
+        <Checkbox
+          label="Include prebake script in share"
+          onChange={(cbEvent) => settingsMap.setKey('includePrebakeScriptInShare', cbEvent.target.checked)}
+          value={includePrebakeScriptInShare}
+        />
+      </FormItem>
 
       <FormItem label="Keybindings">
         <ButtonGroup
           value={keybindings}
           onChange={(keybindings) => settingsMap.setKey('keybindings', keybindings)}
-          items={{ codemirror: 'Codemirror', vim: 'Vim', emacs: 'Emacs', helix: 'Helix', vscode: 'VSCode' }}
+          items={{ codemirror: 'Codemirror', vim: 'Vim', emacs: 'Emacs', vscode: 'VSCode' }}
         ></ButtonGroup>
       </FormItem>
       <FormItem label="Panel Position">
@@ -296,11 +306,6 @@ function MainSettingsContent({ started }) {
           onChange={(cbEvent) => settingsMap.setKey('isMultiCursorEnabled', cbEvent.target.checked)}
           value={isMultiCursorEnabled}
         />
-        <Checkbox
-          label="Enable Block-based Evaluation (EXPERIMENTAL)"
-          onChange={(cbEvent) => settingsMap.setKey('isBlockBasedEvalEnabled', cbEvent.target.checked)}
-          value={isBlockBasedEvalEnabled}
-        />
         <Checkbox
           label="Enable flashing on evaluation"
           onChange={(cbEvent) => settingsMap.setKey('isFlashEnabled', cbEvent.target.checked)}
@@ -335,7 +340,7 @@ function MainSettingsContent({ started }) {
       </FormItem>
       <FormItem label="Zen Mode">Try clicking the logo in the top left!</FormItem>
       <FormItem label="Reset Settings">
-        <ActionButton
+        <SpecialActionButton
           onClick={() => {
             confirmDialog('Sure?').then((r) => {
               if (r) {
@@ -344,70 +349,10 @@ function MainSettingsContent({ started }) {
               }
             });
           }}
-          className="bg-background p-2 max-w-[300px] hover:opacity-50"
         >
           restore default settings
-        </ActionButton>
+        </SpecialActionButton>
       </FormItem>
     </div>
   );
 }
-
-function PrebakeSettingsContent() {
-  const { fontFamily, includePrebakeScriptInShare, prebakeScript } = useSettings();
-  const editorRef = useRef();
-  useEffect(() => {
-    return () => {
-      editorRef.current?.cleanup();
-    };
-  });
-
-  return (
-    <div className="flex flex-col h-full text-foreground w-full overflow-auto" style={{ fontFamily }}>
-      <div className="flex flex-col grow overflow-hidden h-full bg-background">
-        <section
-          className="pb-0 overflow-auto grow z-10 code-container"
-          ref={(el) => {
-            if (editorRef.current) {
-              return;
-            }
-            editorRef.current = new PrebakeCodeMirror(prebakeScript, (code) => storePrebakeScript(code), el);
-          }}
-        ></section>
-      </div>
-      <div className="flex justify-between items-center border-t border-muted px-4 whitespace-nowrap">
-        <Checkbox
-          label="share with patterns"
-          className="whitespace-nowrap max-w-[200px]"
-          onChange={(cbEvent) => settingsMap.setKey('includePrebakeScriptInShare', cbEvent.target.checked)}
-          value={includePrebakeScriptInShare}
-        />
-        <div className="py-2 flex flex-row items-center space-x-3 ">
-          <ImportPrebakeScriptButton updateEditor={(code) => editorRef?.current.setCode(code)} />
-          <ActionButton onClick={() => exportScript(prebakeScript)}>export</ActionButton>
-          <ActionButton onClick={() => editorRef.current?.savePrebake()}>save</ActionButton>
-        </div>
-      </div>
-    </div>
-  );
-}
-export function SettingsTab({ started }) {
-  const { settingsTab } = useSettings();
-  return (
-    <div className="w-full h-full text-foreground flex flex-col overflow-hidden">
-      <div className="px-2 shrink-0 h-8 space-x-4 flex max-w-full overflow-x-auto border-b border-muted">
-        <ButtonGroup
-          wrap
-          value={settingsTab}
-          onChange={(value) => setSettingsTab(value)}
-          items={{
-            settings: 'settings',
-            prebake: 'prebake',
-          }}
-        ></ButtonGroup>
-      </div>
-      {settingsTab === 'settings' && <MainSettingsContent started={started} />}
-      {settingsTab === 'prebake' && <PrebakeSettingsContent />}
-    </div>
-  );
-}

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

@@ -36,9 +36,8 @@ export function WelcomeTab({ context }) {
         <a href="https://tidalcycles.org/" target="_blank">
           tidalcycles
         </a>
-        , which is a popular live coding language for music, written in Haskell. Strudel is free/open source software,
-        with copyright owned by its [contributors](https://codeberg.org/uzu/strudel/activity/contributors). You can
-        redistribute and/or modify it under the terms of the{' '}
+        , which is a popular live coding language for music, written in Haskell. Strudel is free/open source software:
+        you can redistribute and/or modify it under the terms of the{' '}
         <a href="https://codeberg.org/uzu/strudel/src/branch/main/LICENSE" target="_blank">
           GNU Affero General Public License
         </a>

website/src/repl/prebakeCodeMirror.mjs

@@ -1,115 +0,0 @@
-import { toggleLineComment } from '@codemirror/commands';
-import { javascript, javascriptLanguage } from '@codemirror/lang-javascript';
-import { defaultHighlightStyle, syntaxHighlighting } from '@codemirror/language';
-import { Compartment, EditorState, Prec } from '@codemirror/state';
-import { drawSelection, EditorView, keymap } from '@codemirror/view';
-import { logger } from '@strudel/core';
-import { basicSetup, flash, initTheme, extensions, parseBooleans, codemirrorSettings } from '@strudel/codemirror';
-import { evaluate } from '@strudel/transpiler';
-
-export class PrebakeCodeMirror {
-  constructor(initialCode, storePrebake, container) {
-    const settings = codemirrorSettings.get();
-    this.storePrebake = storePrebake;
-    const compartments = Object.fromEntries(Object.keys(extensions).map((key) => [key, new Compartment()]));
-    const initialSettings = Object.keys(compartments).map((key) =>
-      compartments[key].of(extensions[key](parseBooleans(settings[key]))),
-    );
-    initTheme(settings.theme);
-    let state = EditorState.create({
-      doc: initialCode,
-      extensions: [
-        ...initialSettings,
-        basicSetup,
-        javascript(),
-        javascriptLanguage.data.of({
-          closeBrackets: { brackets: ['(', '[', '{', "'", '"', '<'] },
-          bracketMatching: { brackets: ['(', '[', '{', "'", '"', '<'] },
-        }),
-        syntaxHighlighting(defaultHighlightStyle),
-        EditorView.updateListener.of((v) => {
-          if (v.docChanged) {
-            this.code = v.state.doc.toString();
-          }
-        }),
-        drawSelection({ cursorBlinkRate: 0 }),
-        Prec.highest(
-          keymap.of([
-            {
-              mac: 'Meta-Enter',
-              run: () => {
-                this.savePrebake();
-              },
-            },
-            {
-              key: 'Ctrl-Enter',
-              run: () => {
-                this.savePrebake();
-              },
-            },
-            {
-              key: 'Alt-Enter',
-              run: () => {
-                this.savePrebake();
-              },
-            },
-          ]),
-        ),
-      ],
-    });
-
-    this.code = initialCode;
-    this.view = new EditorView({
-      state,
-      parent: container,
-    });
-
-    const handleSaveEvent = async (e) => {
-      if (e.detail.view !== this.view) {
-        return; // ignore events from other editors
-      }
-      await this.savePrebake();
-      e?.cancelable && e.preventDefault?.();
-    };
-    const handleToggleComment = (e) => {
-      if (e.detail.view !== this.view) {
-        return; // ignore events from other editors
-      }
-      this.toggleComment();
-      e?.cancelable && e.preventDefault?.();
-    };
-
-    document.addEventListener('repl-evaluate', handleSaveEvent);
-    document.addEventListener('repl-toggle-comment', handleToggleComment);
-    this.cleanup = () => {
-      document.removeEventListener('prebake-evaluate', handleSaveEvent);
-      document.removeEventListener('prebake-toggle-comment', handleToggleComment);
-    };
-  }
-
-  async savePrebake() {
-    flash(this.view);
-    this.storePrebake(this.code);
-    evaluate(this.code, { addReturn: false }); // run prebake
-    logger('[prebake] prebake saved');
-  }
-
-  toggleComment() {
-    try {
-      // Honor selections; toggleLineComment handles both selections and
-      // single line
-      toggleLineComment(this.view);
-    } catch (err) {
-      console.error('Error handling repl-toggle-comment event', err);
-    }
-  }
-
-  setCode(code) {
-    const changes = {
-      from: 0,
-      to: this.view.state.doc.length,
-      insert: code,
-    };
-    this.view.dispatch({ changes });
-  }
-}

website/src/repl/useReplContext.jsx

@@ -6,7 +6,7 @@ This program is free software: you can redistribute it and/or modify it under th
 
 import { code2hash, getPerformanceTimeSeconds, logger, silence } from '@strudel/core';
 import { getDrawContext } from '@strudel/draw';
-import { transpiler, evaluate } from '@strudel/transpiler';
+import { evaluate, transpiler } from '@strudel/transpiler';
 import {
   getAudioContextCurrentTime,
   renderPatternAudio,
@@ -71,7 +71,6 @@ export function useReplContext() {
   const defaultOutput = shouldUseWebaudio ? webaudioOutput : superdirtOutput;
   const getTime = shouldUseWebaudio ? getAudioContextCurrentTime : getPerformanceTimeSeconds;
   const init = useCallback(() => {
-    setActivePattern(getViewingPatternData().id);
     const drawTime = [-2, 2];
     const drawContext = getDrawContext();
     const editor = new StrudelMirror({
@@ -87,12 +86,12 @@ export function useReplContext() {
       pattern: silence,
       drawTime,
       drawContext,
-      prebake: async () => {
-        await Promise.all([modulesLoading, presets]);
-        if (prebakeScript) {
-          return evaluate(prebakeScript, { addReturn: false });
-        }
-      },
+      prebake: async () =>
+        Promise.all([modulesLoading, presets]).then(() => {
+          if (prebakeScript?.length) {
+            return evaluate(prebakeScript ?? '');
+          }
+        }),
       onUpdateState: (state) => {
         setReplState({ ...state });
       },
@@ -107,24 +106,17 @@ export function useReplContext() {
         //post to iframe parent (like Udels) if it exists...
         window.parent?.postMessage(code);
 
-        // Get the full buffer content from the editor instead of just the evaluated block
-        const fullBufferCode = editorRef.current?.code || code;
-        setLatestCode(fullBufferCode);
-
-        try {
-          window.location.hash = '#' + code2hash(fullBufferCode);
-        } catch (e) {
-          console.warn('[useReplContext] Failed to update hash:', e.message);
-        }
-        setDocumentTitle(fullBufferCode);
+        setLatestCode(code);
+        window.location.hash = '#' + code2hash(code);
+        setDocumentTitle(code);
         const viewingPatternData = getViewingPatternData();
-        setVersionDefaultsFrom(fullBufferCode);
-        const data = { ...viewingPatternData, code: fullBufferCode };
+        setVersionDefaultsFrom(code);
+        const data = { ...viewingPatternData, code };
         let id = data.id;
         const isExamplePattern = viewingPatternData.collection !== userPattern.collection;
 
         if (isExamplePattern) {
-          const codeHasChanged = fullBufferCode !== viewingPatternData.code;
+          const codeHasChanged = code !== viewingPatternData.code;
           if (codeHasChanged) {
             // fork example
             const newPattern = userPattern.duplicate(data);
@@ -176,8 +168,9 @@ export function useReplContext() {
   useEffect(() => {
     let editorSettings = {};
     Object.keys(defaultSettings).forEach((key) => {
-      // Don't use hasOwnProperty - nanostore uses proxies so values may not be own properties
-      editorSettings[key] = _settings[key];
+      if (Object.prototype.hasOwnProperty.call(_settings, key)) {
+        editorSettings[key] = _settings[key];
+      }
     });
     editorRef.current?.updateSettings(editorSettings);
   }, [_settings]);

website/src/repl/util.mjs

@@ -70,7 +70,6 @@ export function loadModules() {
   let modules = [
     import('@strudel/core'),
     import('@strudel/draw'),
-    import('@strudel/edo'),
     import('@strudel/tonal'),
     import('@strudel/mini'),
     import('@strudel/xen'),
@@ -109,7 +108,6 @@ export function confirmDialog(msg) {
   });
 }
 export const SETTING_CHANGE_RELOAD_MSG = 'Changing this setting requires the window to reload itself. OK?';
-
 export function confirmAndReloadPage(onSuccess) {
   confirmDialog(SETTING_CHANGE_RELOAD_MSG).then((r) => {
     if (r == true) {

website/src/settings.mjs

@@ -18,20 +18,6 @@ export const soundFilterType = {
   ALL: 'all',
 };
 
-const initialPrebakeScript = `// Prebake script
-//
-// This is code that is loaded before your pattern is run.
-// You can use it to define custom functions to use in any pattern.
-// 
-// This is an initial example script. You can edit it to add 
-// your own funtions.
-//
-// To use a script shared by some other user you can use
-// the import-button or paste the script in this editor.
-
-const ratchet = register('ratchet', (pat) => pat.sometimes(ply(2)))
-`;
-
 export const defaultSettings = {
   activeFooter: 'intro',
   keybindings: 'codemirror',
@@ -47,7 +33,6 @@ export const defaultSettings = {
   isPatternHighlightingEnabled: true,
   isTabIndentationEnabled: false,
   isMultiCursorEnabled: false,
-  isBlockBasedEvalEnabled: false,
   theme: 'strudelTheme',
   fontFamily: 'monospace',
   fontSize: 18,
@@ -61,14 +46,13 @@ export const defaultSettings = {
   isPanelPinned: false,
   isPanelOpen: true,
   userPatterns: '{}',
-  prebakeScript: initialPrebakeScript,
+  prebakeScript: '',
   audioEngineTarget: audioEngineTargets.webaudio,
   isButtonRowHidden: false,
   isCSSAnimationDisabled: false,
   maxPolyphony: 128,
   multiChannelOrbits: false,
   includePrebakeScriptInShare: true,
-  settingsTab: 'settings',
 };
 
 let search = null;
@@ -105,7 +89,6 @@ export const $settings = computed(settingsMap, (state) => {
     isSyncEnabled: isUdels() ? true : parseBoolean(state.isSyncEnabled),
     isTabIndentationEnabled: parseBoolean(state.isTabIndentationEnabled),
     isMultiCursorEnabled: parseBoolean(state.isMultiCursorEnabled),
-    isBlockBasedEvalEnabled: parseBoolean(state.isBlockBasedEvalEnabled),
     fontSize: Number(state.fontSize),
     panelPosition: state.activeFooter !== '' && !isUdels() ? state.panelPosition : 'bottom', // <-- keep this 'bottom' where it is!
     isPanelPinned: parseBoolean(state.isPanelPinned),
@@ -130,7 +113,6 @@ export function useSettings() {
 export const setActiveFooter = (tab) => settingsMap.setKey('activeFooter', tab);
 export const setPanelPinned = (bool) => settingsMap.setKey('isPanelPinned', bool);
 export const setIsPanelOpened = (bool) => settingsMap.setKey('isPanelOpen', bool);
-export const setSettingsTab = (tab) => settingsMap.setKey('settingsTab', tab);
 
 export const storePrebakeScript = (script) => settingsMap.setKey('prebakeScript', script);
 

website/src/user_pattern_utils.mjs

@@ -207,10 +207,9 @@ export async function exportPatterns() {
   const userPatterns = userPattern.getAll();
   const blob = new Blob([JSON.stringify(userPatterns)], { type: 'application/json' });
   const downloadLink = document.createElement('a');
-  const prefix = window.location.hostname.split('.').join('_');
   downloadLink.href = window.URL.createObjectURL(blob);
   const date = new Date().toISOString().split('T')[0];
-  downloadLink.download = `${prefix}_patterns_${date}.json`;
+  downloadLink.download = `strudel_patterns_${date}.json`;
   document.body.appendChild(downloadLink);
   downloadLink.click();
   document.body.removeChild(downloadLink);