Merge branch 'main' into busparts

This reverts commit 55839e7ee8.

packages/codemirror/codemirror.mjs

@@ -1,30 +1,31 @@
 import { closeBrackets } from '@codemirror/autocomplete';
-export { toggleComment, toggleBlockComment, toggleLineComment, toggleBlockCommentByLine } from '@codemirror/commands';
+import { indentWithTab, toggleLineComment } from '@codemirror/commands';
-// import { search, highlightSelectionMatches } from '@codemirror/search';
-import { indentWithTab } from '@codemirror/commands';
 import { javascript, javascriptLanguage } from '@codemirror/lang-javascript';
-import { defaultHighlightStyle, syntaxHighlighting, bracketMatching } from '@codemirror/language';
+import { bracketMatching, defaultHighlightStyle, syntaxHighlighting } from '@codemirror/language';
 import { Compartment, EditorState, Prec } from '@codemirror/state';
 import {
+  drawSelection,
   EditorView,
-  highlightActiveLineGutter,
   highlightActiveLine,
+  highlightActiveLineGutter,
   keymap,
   lineNumbers,
-  drawSelection,
 } from '@codemirror/view';
-import { repl, registerControl } from '@strudel/core';
+import { persistentAtom } from '@nanostores/persistent';
-import { Drawer, cleanupDraw } from '@strudel/draw';
+import { logger, registerControl, repl } from '@strudel/core';
+import { cleanupDraw, Drawer } from '@strudel/draw';
+
 import { isAutoCompletionEnabled } from './autocomplete.mjs';
-import { isTooltipEnabled } from './tooltip.mjs';
+import { basicSetup } from './basicSetup.mjs';
 import { flash, isFlashEnabled } from './flash.mjs';
 import { highlightMiniLocations, isPatternHighlightingEnabled, updateMiniLocations } from './highlight.mjs';
 import { keybindings } from './keybindings.mjs';
-import { initTheme, activateTheme, theme } from './themes.mjs';
 import { sliderPlugin, updateSliderWidgets } from './slider.mjs';
-import { widgetPlugin, updateWidgets } from './widget.mjs';
+import { activateTheme, initTheme, theme } from './themes.mjs';
-import { persistentAtom } from '@nanostores/persistent';
+import { isTooltipEnabled } from './tooltip.mjs';
-import { basicSetup } from './basicSetup.mjs';
+import { updateWidgets, widgetPlugin } from './widget.mjs';
+
+export { toggleBlockComment, toggleBlockCommentByLine, toggleComment, toggleLineComment } from '@codemirror/commands';
 
 const extensions = {
   isLineWrappingEnabled: (on) => (on ? EditorView.lineWrapping : []),
@@ -94,8 +95,8 @@ export function initEditor({ initialCode = '', onChange, onEvaluate, onStop, roo
       }),
       sliderPlugin,
       widgetPlugin,
-      // indentOnInput(), // works without. already brought with javascript extension?
+      // indentOnInput(), // works without. already brought with javascript
-      // bracketMatching(), // does not do anything
+      // extension? bracketMatching(), // does not do anything
       syntaxHighlighting(defaultHighlightStyle),
       EditorView.updateListener.of((v) => onChange(v)),
       drawSelection({ cursorBlinkRate: 0 }),
@@ -119,13 +120,13 @@ export function initEditor({ initialCode = '', onChange, onEvaluate, onStop, roo
             run: () => onStop?.(),
           },
           /* {
-          key: 'Ctrl-Shift-.',
+            key: 'Ctrl-Shift-.',
-          run: () => (onPanic ? onPanic() : onStop?.()),
+            run: () => (onPanic ? onPanic() : onStop?.()),
-        },
+          },
-        {
+          {
-          key: 'Ctrl-Shift-Enter',
+            key: 'Ctrl-Shift-Enter',
-          run: () => (onReEvaluate ? onReEvaluate() : onEvaluate?.()),
+            run: () => (onReEvaluate ? onReEvaluate() : onEvaluate?.()),
-        }, */
+          }, */
         ]),
       ),
     ],
@@ -206,7 +207,8 @@ export class StrudelMirror {
         updateWidgets(this.editor, widgets);
         updateMiniLocations(this.editor, this.miniLocations);
         replOptions?.afterEval?.(options);
-        // if no painters are set (.onPaint was not called), then we only need the present moment (for highlighting)
+        // if no painters are set (.onPaint was not called), then we only need
+        // the present moment (for highlighting)
         const drawTime = options.pattern.getPainters().length ? this.drawTime : [0, 0];
         this.drawer.setDrawTime(drawTime);
         // invalidate drawer after we've set the appropriate drawTime
@@ -245,6 +247,33 @@ export class StrudelMirror {
       }
     };
     document.addEventListener('start-repl', this.onStartRepl);
+
+    // Handle global evaluation requests (e.g., from Vim :w)
+    this.onEvaluateRequest = (e) => {
+      try {
+        // Evaluate current editor on repl-evaluate
+        logger('[repl] evaluate via event');
+        this.evaluate();
+        e?.cancelable && e.preventDefault?.();
+      } catch (err) {
+        console.error('Error handling repl-evaluate event', err);
+      }
+    };
+    document.addEventListener('repl-evaluate', this.onEvaluateRequest);
+    document.addEventListener('repl-stop', this.onStopRequest);
+
+    // Toggle comments requested from Vim (gc)
+    this.onToggleComment = (e) => {
+      try {
+        // Honor selections; toggleLineComment handles both selections and
+        // single line
+        toggleLineComment(this.editor);
+        e?.cancelable && e.preventDefault?.();
+      } catch (err) {
+        console.error('Error handling repl-toggle-comment event', err);
+      }
+    };
+    document.addEventListener('repl-toggle-comment', this.onToggleComment);
   }
   draw(haps, time, painters) {
     painters?.forEach((painter) => painter(this.drawContext, time, haps, this.drawTime));
@@ -271,6 +300,16 @@ export class StrudelMirror {
   async stop() {
     this.repl.scheduler.stop();
   }
+
+  // Listen for global stop requests (e.g., from Vim :q)
+  onStopRequest = (e) => {
+    try {
+      this.stop();
+      e?.cancelable && e.preventDefault?.();
+    } catch (err) {
+      console.error('Error handling repl-stop event', err);
+    }
+  };
   async toggle() {
     if (this.repl.scheduler.started) {
       this.repl.stop();
@@ -346,11 +385,18 @@ export class StrudelMirror {
     }
   }
   setCode(code) {
-    const changes = { from: 0, to: this.editor.state.doc.length, insert: code };
+    const changes = {
+      from: 0,
+      to: this.editor.state.doc.length,
+      insert: code,
+    };
     this.editor.dispatch({ changes });
   }
   clear() {
     this.onStartRepl && document.removeEventListener('start-repl', this.onStartRepl);
+    this.onEvaluateRequest && document.removeEventListener('repl-evaluate', this.onEvaluateRequest);
+    this.onStopRequest && document.removeEventListener('repl-stop', this.onStopRequest);
+    this.onToggleComment && document.removeEventListener('repl-toggle-comment', this.onToggleComment);
   }
   getCursorLocation() {
     return this.editor.state.selection.main.head;

packages/codemirror/keybindings.mjs

@@ -1,11 +1,12 @@
+import { defaultKeymap } from '@codemirror/commands';
 import { Prec } from '@codemirror/state';
 import { keymap, ViewPlugin } from '@codemirror/view';
 // import { searchKeymap } from '@codemirror/search';
 import { emacs } from '@replit/codemirror-emacs';
-import { vim } from '@replit/codemirror-vim';
+import { vim, Vim } from '@replit/codemirror-vim';
 // import { vim } from './vim_test.mjs';
 import { vscodeKeymap } from '@replit/codemirror-vscode-keymap';
-import { defaultKeymap } from '@codemirror/commands';
+import { logger } from '@strudel/core';
 
 const vscodePlugin = ViewPlugin.fromClass(
   class {
@@ -19,6 +20,110 @@ const vscodePlugin = ViewPlugin.fromClass(
 );
 const vscodeExtension = (options) => [vscodePlugin].concat(options ?? []);
 
+// Map Vim :w to trigger the same action as evaluation. We dispatch a custom
+// event 'repl-evaluate' that the editor listens for, and also simulate
+// Ctrl+Enter/Alt+Enter as a fallback. We log to the Strudel logger so it
+// appears in the Console panel.
+try {
+  if (Vim && typeof Vim.defineEx === 'function') {
+    // Map gc to toggle line comments by dispatching a custom event that our
+    // CodeMirror integration listens to. This avoids depending on Vim's
+    // internal actions and works with current selections/visual mode.
+    try {
+      Vim.defineAction('strudelToggleComment', (cm) => {
+        const view = cm?.view || cm;
+        try {
+          const ev = new CustomEvent('repl-toggle-comment', { detail: { source: 'vim', view }, cancelable: true });
+          document.dispatchEvent(ev);
+        } catch (e) {
+          console.error('strudelToggleComment dispatch failed', e);
+        }
+      });
+      Vim.mapCommand('gc', 'action', 'strudelToggleComment', {}, { context: 'normal' });
+      Vim.mapCommand('gc', 'action', 'strudelToggleComment', {}, { context: 'visual' });
+    } catch (e) {
+      console.error('Vim gc mapping failed', e);
+    }
+
+    // :q to pause/stop
+    Vim.defineEx('quit', 'q', (cm) => {
+      try {
+        const view = cm?.view || cm;
+        // First try dispatching our custom stop event, then fallback to Alt+.
+        let handled = false;
+        try {
+          const ev = new CustomEvent('repl-stop', { detail: { source: 'vim', view }, cancelable: true });
+          handled = document.dispatchEvent(ev) === false;
+        } catch (e) {
+          console.error('Error dispatching repl-stop event', e);
+        }
+        if (!handled) {
+          const altDot = new KeyboardEvent('keydown', {
+            key: '.',
+            code: 'Period',
+            altKey: true,
+            bubbles: true,
+            cancelable: true,
+          });
+          view?.dom?.dispatchEvent?.(altDot);
+        }
+      } catch (e) {
+        console.error('Error dispatching :q stop event', e);
+      }
+    });
+
+    // :w to evaluate
+    Vim.defineEx('write', 'w', (cm) => {
+      const view = cm?.view || cm; // CM6 Vim passes either an object with view or the view itself
+      try {
+        view?.focus?.();
+        // Let the app know this came from Vim :w
+        try {
+          logger('[vim] :w — evaluating code');
+        } catch (e) {
+          console.error('Error logging Vim :w evaluation', e);
+        }
+        // Dispatch a dedicated evaluate event first
+        let handled = false;
+        try {
+          const ev = new CustomEvent('repl-evaluate', { detail: { source: 'vim', view }, cancelable: true });
+          handled = document.dispatchEvent(ev) === false; // false means preventDefault was called
+        } catch (e) {
+          console.error('Error dispatching repl-evaluate event', e);
+        }
+        if (handled) {
+          return;
+        }
+        // Try Ctrl+Enter first if not handled by custom event
+        const ctrlEnter = new KeyboardEvent('keydown', {
+          key: 'Enter',
+          code: 'Enter',
+          ctrlKey: true,
+          bubbles: true,
+          cancelable: true,
+        });
+        view?.dom?.dispatchEvent?.(ctrlEnter);
+        // If not handled (no handler called preventDefault), try Alt+Enter as
+        // fallback
+        if (!ctrlEnter.defaultPrevented) {
+          const altEnter = new KeyboardEvent('keydown', {
+            key: 'Enter',
+            code: 'Enter',
+            altKey: true,
+            bubbles: true,
+            cancelable: true,
+          });
+          view?.dom?.dispatchEvent?.(altEnter);
+        }
+      } catch (e) {
+        console.error('Error dispatching :w evaluation event', e);
+      }
+    });
+  }
+} catch (e) {
+  console.error('Vim ex command setup failed (defineEx missing or Vim unavailable)', e);
+}
+
 const keymaps = {
   vim,
   emacs,

packages/core/controls.mjs

@@ -72,6 +72,15 @@ export function registerControl(names, ...aliases) {
   return bag;
 }
 
+// Constructs a superdirt effect bus control
+const bus = register('bus', function (busid, control_name, busval, pat) {
+  return pat[control_name]('c' + busid).withValue((val) => {
+    const newval = { ...val };
+    newval['^' + control_name] = [busid, busval];
+    return newval;
+  });
+});
+
 /**
  * Select a sound / sample by name. When using mininotation, you can also optionally supply 'n' and 'gain' parameters
  * separated by ':'.

packages/core/cyclist.mjs

@@ -58,11 +58,10 @@ export class Cyclist {
 
           // query the pattern for events
           const haps = this.pattern.queryArc(begin, end, { _cps: this.cps, cyclist: 'cyclist' });
-
           haps.forEach((hap) => {
-            if (hap.hasOnset()) {
+            if (hap.hasOnset() || hap.context.processParts) {
               const targetTime =
-                (hap.whole.begin - this.num_cycles_at_cps_change) / this.cps + this.seconds_at_cps_change + latency;
+                (hap.part.begin - this.num_cycles_at_cps_change) / this.cps + this.seconds_at_cps_change + latency;
               const duration = hap.duration / this.cps;
               // the following line is dumb and only here for backwards compatibility
               // see https://codeberg.org/uzu/strudel/pulls/1004

packages/core/euclid.mjs

@@ -35,18 +35,18 @@ const right = function (n, x) {
   return result;
 };
 
-const _bjork = function (n, x) {
+const _bjorklund = function (n, x) {
   const [ons, offs] = n;
-  return Math.min(ons, offs) <= 1 ? [n, x] : _bjork(...(ons > offs ? left(n, x) : right(n, x)));
+  return Math.min(ons, offs) <= 1 ? [n, x] : _bjorklund(...(ons > offs ? left(n, x) : right(n, x)));
 };
 
-export const bjork = function (ons, steps) {
+export const bjorklund = function (ons, steps) {
   const inverted = ons < 0;
   const absOns = Math.abs(ons);
   const offs = steps - absOns;
   const ones = Array(absOns).fill([1]);
   const zeros = Array(offs).fill([0]);
-  const result = _bjork([absOns, offs], [ones, zeros]);
+  const result = _bjorklund([absOns, offs], [ones, zeros]);
   const pattern = flatten(result[1][0]).concat(flatten(result[1][1]));
   return inverted ? pattern.map((x) => 1 - x) : pattern;
 };
@@ -128,7 +128,7 @@ export const bjork = function (ons, steps) {
  */
 
 const _euclidRot = function (pulses, steps, rotation) {
-  const b = bjork(pulses, steps);
+  const b = bjorklund(pulses, steps);
   if (rotation) {
     return rotate(b, -rotation);
   }
@@ -139,7 +139,7 @@ export const euclid = register('euclid', function (pulses, steps, pat) {
   return pat.struct(_euclidRot(pulses, steps, 0));
 });
 
-export const e = register('e', function (euc, pat) {
+export const bjork = register('bjork', function (euc, pat) {
   if (!Array.isArray(euc)) {
     euc = [euc];
   }
@@ -216,6 +216,6 @@ export const euclidLegatoRot = register(['euclidLegatoRot'], function (pulses, s
  * .pan(sine.slow(8))
  */
 export const { euclidish, eish } = register(['euclidish', 'eish'], function (pulses, steps, perc, pat) {
-  const morphed = _morph(bjork(pulses, steps), new Array(pulses).fill(1), perc);
+  const morphed = _morph(bjorklund(pulses, steps), new Array(pulses).fill(1), perc);
   return pat.struct(morphed).setSteps(steps);
 });

packages/core/hap.mjs

@@ -16,7 +16,7 @@ export class Hap {
       then the whole will be returned as None, in which case the given
       value will have been sampled from the point halfway between the
       start and end of the 'part' timespan.
-      The context is to store a list of source code locations causing the event.
+      The context is to store metadata, including a list of source code locations causing the event.
 
       The word 'Event' is more or less a reserved word in javascript, hence this
       class is named called 'Hap'.
@@ -161,6 +161,10 @@ export class Hap {
     return new Hap(this.whole, this.part, this.value, context);
   }
 
+  withContext(f) {
+    return new Hap(this.whole, this.part, this.value, f(this.context));
+  }
+
   ensureObjectValue() {
     /* if (isNote(hap.value)) {
       // supports primitive hap values that look like notes

packages/core/pattern.mjs

@@ -62,7 +62,12 @@ export class Pattern {
     this.__steps = steps === undefined ? undefined : Fraction(steps);
   }
 
+  _processParts() {
+    return this.withHap((hap) => hap.withContext((c) => ({ ...c, processParts: true })));
+  }
+
   setSteps(steps) {
+    // TODO shouldn't this be pure and return a new pattern?
     this._steps = steps;
     return this;
   }
@@ -2574,8 +2579,8 @@ export const { chunkBack, chunkback } = register(
  * @returns Pattern
  * @example
  * "<0 8> 1 2 3 4 5 6 7"
- * .fastChunk(4, x => x.color('red')).slow(2)
  * .scale("C2:major").note()
+ * .fastChunk(4, x => x.color('red')).slow(2)
  */
 export const { fastchunk, fastChunk } = register(
   ['fastchunk', 'fastChunk'],

packages/core/test/euclid.test.js

@@ -1,14 +1,14 @@
-import { bjork } from '../euclid.mjs';
+import { bjorklund } from '../euclid.mjs';
 import { describe, expect, it } from 'vitest';
 import { fastcat } from '../pattern.mjs';
 
-describe('bjork', () => {
+describe('bjorklund', () => {
-  it('should apply bjorklund to ons and steps', () => {
+  it('should apply bjorklundlund to ons and steps', () => {
-    expect(bjork(3, 8)).toStrictEqual([1, 0, 0, 1, 0, 0, 1, 0]);
+    expect(bjorklund(3, 8)).toStrictEqual([1, 0, 0, 1, 0, 0, 1, 0]);
-    expect(bjork(-3, 8)).toStrictEqual([0, 1, 1, 0, 1, 1, 0, 1]);
+    expect(bjorklund(-3, 8)).toStrictEqual([0, 1, 1, 0, 1, 1, 0, 1]);
-    expect(bjork(8, 8)).toStrictEqual([1, 1, 1, 1, 1, 1, 1, 1]);
+    expect(bjorklund(8, 8)).toStrictEqual([1, 1, 1, 1, 1, 1, 1, 1]);
-    expect(bjork(-8, 8)).toStrictEqual([0, 0, 0, 0, 0, 0, 0, 0]);
+    expect(bjorklund(-8, 8)).toStrictEqual([0, 0, 0, 0, 0, 0, 0, 0]);
-    expect(bjork(5, 8)).toStrictEqual([1, 0, 1, 1, 0, 1, 1, 0]);
+    expect(bjorklund(5, 8)).toStrictEqual([1, 0, 1, 1, 0, 1, 1, 0]);
   });
 });
 

packages/core/util.mjs

@@ -7,8 +7,8 @@ This program is free software: you can redistribute it and/or modify it under th
 import { logger } from './logger.mjs';
 
 // returns true if the given string is a note
-export const isNoteWithOctave = (name) => /^[a-gA-G][#bs]*[0-9]$/.test(name);
+export const isNoteWithOctave = (name) => /^[a-gA-G][#bsf]*[0-9]*$/.test(name);
-export const isNote = (name) => /^[a-gA-G][#bsf]*-?[0-9]?$/.test(name);
+export const isNote = (name) => /^[a-gA-G][#bsf]*-?[0-9]*$/.test(name);
 export const tokenizeNote = (note) => {
   if (typeof note !== 'string') {
     return [];
@@ -23,6 +23,10 @@ export const tokenizeNote = (note) => {
 const chromas = { c: 0, d: 2, e: 4, f: 5, g: 7, a: 9, b: 11 };
 const accs = { '#': 1, b: -1, s: 1, f: -1 };
 
+export const getAccidentalsOffset = (accidentals) => {
+  return accidentals?.split('').reduce((o, char) => o + accs[char], 0) || 0;
+};
+
 // turns the given note into its midi number representation
 export const noteToMidi = (note, defaultOctave = 3) => {
   const [pc, acc, oct = defaultOctave] = tokenizeNote(note);
@@ -30,7 +34,7 @@ export const noteToMidi = (note, defaultOctave = 3) => {
     throw new Error('not a note: "' + note + '"');
   }
   const chroma = chromas[pc.toLowerCase()];
-  const offset = acc?.split('').reduce((o, char) => o + accs[char], 0) || 0;
+  const offset = getAccidentalsOffset(acc);
   return (Number(oct) + 1) * 12 + chroma + offset;
 };
 export const midiToFreq = (n) => {

packages/mondo/mondo.mjs

@@ -21,13 +21,14 @@ export class MondoParser {
     close_curly: /^\}/,
     number: /^-?[0-9]*\.?[0-9]+/, // before pipe!
     // TODO: better error handling when "-" is used as rest, e.g "s [- bd]"
-    op: /^[*/:!@%?+-]|^\.{2}/, // * / : ! @ % ? ..
+    op: /^[*/:!@%?+\-&]|^\.{2}/, // * / : ! @ % ? ..
     // dollar: /^\$/,
     pipe: /^#/,
     stack: /^[,$]/,
     or: /^[|]/,
     plain: /^[a-zA-Z0-9-~_^#]+/,
   };
+  op_precedence = [['*', '/', ':', '!', '@', '%', '?', '+', '-', '..'], ['&']];
   // matches next token
   next_token(code, offset = 0) {
     for (let type in this.token_types) {
@@ -150,9 +151,9 @@ export class MondoParser {
     }
     return children;
   }
-  desugar_ops(children) {
+  desugar_ops(children, types) {
     while (true) {
-      let opIndex = children.findIndex((child) => child.type === 'op');
+      let opIndex = children.findIndex((child) => child.type === 'op' && types.includes(child.value));
       if (opIndex === -1) break;
       const op = { type: 'plain', value: children[opIndex].value };
       if (opIndex === children.length - 1) {
@@ -263,8 +264,10 @@ export class MondoParser {
           // the type we've removed before splitting needs to be added back
           children = [{ type: 'plain', value: type }, ...children];
         }
-        children = this.desugar_ops(children);
+        // for each precendence group, call desugar_ops once
-        // children = this.desugar_pipes(children, (children) => this.desugar_dollars(children));
+        this.op_precedence.forEach((ops) => {
+          children = this.desugar_ops(children, ops);
+        });
         children = this.desugar_pipes(children);
         return children;
       }),

packages/mondo/test/mondo.test.mjs

@@ -117,6 +117,7 @@ describe('mondo sugar', () => {
   it('should desugar x:y', () => expect(desguar('x:y')).toEqual('(: y x)'));
   it('should desugar x:y:z', () => expect(desguar('x:y:z')).toEqual('(: z (: y x))'));
   it('should desugar x:y*x', () => expect(desguar('bd:0*2')).toEqual('(* 2 (: 0 bd))'));
+  it('should desugar x&y:z', () => expect(desguar('bd&3:8')).toEqual('(& (: 8 3) bd)'));
   it('should desugar a..b', () => expect(desguar('0..2')).toEqual('(.. 2 0)'));
   /* it('should desugar x $ y', () => expect(desguar('x $ y')).toEqual('(x y)'));
   it('should desugar x $ y z', () => expect(desguar('x $ y z')).toEqual('(x (y z))'));

packages/mondough/mondough.mjs

@@ -11,6 +11,7 @@ import {
   chooseIn,
   degradeBy,
   silence,
+  bjork,
 } from '@strudel/core';
 import { registerLanguage } from '@strudel/transpiler';
 import { MondoRunner } from 'mondolang';
@@ -40,6 +41,7 @@ lib['!'] = replicate;
 lib['@'] = expand;
 lib['%'] = pace;
 lib['?'] = degradeBy; // todo: default 0.5 not working..
+lib['&'] = bjork;
 lib[':'] = tail;
 lib['..'] = range;
 lib['def'] = () => silence;

packages/osc/osc.mjs

@@ -52,6 +52,7 @@ export function parseControlsFromHap(hap, cps) {
   controls.unit === 'c' && controls.speed != null && (controls.speed = controls.speed / cps);
   const channels = controls.channels;
   channels != undefined && (controls.channels = JSON.stringify(channels));
+
   return controls;
 }
 
@@ -63,16 +64,42 @@ export async function oscTrigger(hap, currentTime, cps = 1, targetTime) {
   const keyvals = Object.entries(controls).flat();
   const ts = collator.calculateTimestamp(currentTime, targetTime) * 1000;
   const msg = { address: '/dirt/play', args: keyvals, timestamp: ts };
-
-  if ('oschost' in hap.value) {
-    msg['host'] = hap.value['oschost'];
-  }
-  if ('oscport' in hap.value) {
-    msg['port'] = hap.value['oscport'];
-  }
   ws.send(JSON.stringify(msg));
 }
 
+export async function superdirtTrigger(hap, currentTime, cps = 1, targetTime) {
+  const ws = await connect();
+  const controls = parseControlsFromHap(hap, cps);
+  const ts = collator.calculateTimestamp(currentTime, targetTime) * 1000;
+
+  let oschost = '127.0.0.1';
+  let oscport = 57120;
+  let bushost = oschost;
+  let busport = 57110;
+
+  for (const [k, v] of Object.entries(controls)) {
+    if (k.startsWith('^')) {
+      const bus_idval = v;
+      const msg = JSON.stringify({
+        oschost: bushost,
+        oscport: busport,
+        address: '/c_set',
+        args: bus_idval,
+        timestamp: ts,
+      });
+      // console.log('bus message', msg);
+      ws.send(msg);
+      // So they aren't sent with trigger messages
+      delete controls[k];
+    }
+  }
+
+  if (hap.hasOnset()) {
+    const keyvals = Object.entries(controls).flat();
+    ws.send(JSON.stringify({ oschost, oscport, address: '/dirt/play', args: keyvals, timestamp: ts }));
+  }
+}
+
 /**
  *
  * Sends each hap as an OSC message, which can be picked up by SuperCollider or any other OSC-enabled software.
@@ -83,3 +110,4 @@ export async function oscTrigger(hap, currentTime, cps = 1, targetTime) {
  * @returns Pattern
  */
 export const osc = register('osc', (pat) => pat.onTrigger(oscTrigger));
+export const superdirt = register('superdirt', (pat) => pat._processParts().onTrigger(superdirtTrigger));

packages/osc/server.js

@@ -12,18 +12,13 @@ import { WebSocketServer } from 'ws';
 import osc from 'osc';
 
 const WS_PORT = 8080; // WebSocket server port
-const OSC_REMOTE_IP = '127.0.0.1';
-const OSC_REMOTE_PORT = 57120;
 
 const udpPort = new osc.UDPPort({
   localAddress: '0.0.0.0',
   localPort: 0,
-  remoteAddress: OSC_REMOTE_IP,
-  remotePort: OSC_REMOTE_PORT,
 });
 
 udpPort.open();
-console.log(`[Sending OSC] ${OSC_REMOTE_IP}:${OSC_REMOTE_PORT}`);
 
 udpPort.on('error', (e) => {
   console.log('Error: ', e);
@@ -36,23 +31,24 @@ wss.on('connection', (ws) => {
   console.log('New WebSocket connection');
 
   ws.on('message', (message) => {
-    let osc_host = '127.0.0.1';
+    let oschost = '127.0.0.1';
-    let osc_port = 57120;
+    let oscport = 57120;
 
     try {
       const data = JSON.parse(message);
-      if ('host' in data) {
+      if ('oschost' in data) {
-        osc_host = data['host'];
+        oschost = data['oschost'];
+        delete data['oschost'];
       }
-      if ('port' in data) {
+      if ('oscport' in data) {
-        osc_port = data['port'];
+        oscport = data['oscport'];
+        delete data['oscport'];
       }
       let msg = { address: data['address'], args: data['args'] };
       if ('timestamp' in data) {
         msg = { timeTag: osc.timeTag(0, data['timestamp']), packets: [msg] };
       }
-
+      udpPort.send(msg, oschost, oscport);
-      udpPort.send(msg, osc_host, osc_port);
     } catch (err) {
       console.error('Error parsing message:', err);
     }

packages/superdough/util.mjs

@@ -16,13 +16,17 @@ export const tokenizeNote = (note) => {
 const chromas = { c: 0, d: 2, e: 4, f: 5, g: 7, a: 9, b: 11 };
 const accs = { '#': 1, b: -1, s: 1, f: -1 };
 
+export const getAccidentalsOffset = (accidentals) => {
+  return accidentals?.split('').reduce((o, char) => o + accs[char], 0) || 0;
+};
+
 export const noteToMidi = (note, defaultOctave = 3) => {
   const [pc, acc, oct = defaultOctave] = tokenizeNote(note);
   if (!pc) {
     throw new Error('not a note: "' + note + '"');
   }
   const chroma = chromas[pc.toLowerCase()];
-  const offset = acc?.split('').reduce((o, char) => o + accs[char], 0) || 0;
+  const offset = getAccidentalsOffset(acc);
   return (Number(oct) + 1) * 12 + chroma + offset;
 };
 export const midiToFreq = (n) => {

packages/tonal/test/tonal.test.mjs

@@ -61,13 +61,6 @@ describe('tonal', () => {
           .firstCycleValues.map((h) => h.note),
       ).toEqual(['B2', 'Eb3', 'A2', 'G3', 'F3']);
     });
-    it('produces silence for mixed sharps and flats', () => {
-      expect(
-        n(seq('0b#', '1#b', '2#b#'))
-          .scale('C major')
-          .firstCycleValues.map((h) => h.note),
-      ).toEqual([]);
-    });
     it('snaps notes (upwards) to scale', () => {
       const inputNotes = ['Cb', 'Eb', 'G', 'A#', 'Bb'];
       const expectedNotes = ['B2', 'E3', 'G3', 'B3', 'B3'];

packages/tonal/tonal.mjs

@@ -5,9 +5,8 @@ This program is free software: you can redistribute it and/or modify it under th
 */
 
 import { Note, Interval, Scale } from '@tonaljs/tonal';
-import { register, _mod, silence, logger, pure, isNote } from '@strudel/core';
+import { register, _mod, logger, isNote, noteToMidi, removeUndefineds, getAccidentalsOffset } from '@strudel/core';
 import { stepInNamedScale, nearestNumberIndex } from './tonleiter.mjs';
-import { noteToMidi } from '../core/util.mjs';
 
 const octavesInterval = (octaves) => (octaves <= 0 ? -1 : 1) + octaves * 7 + 'P';
 
@@ -185,17 +184,15 @@ function _convertStepToNumberAndOffset(step) {
     step = String(step);
     // Check to see if the step matches the expected format:
     // - A number (possibly negative)
-    // - Some number of sharps or flats (but not both)
+    // - Some number of sharps or flats
-    const match = /^(-?\d+)(#+|b+)?$/.exec(step);
+    const match = /^(-?\d+)([#bsf]*)$/.exec(step);
 
     if (!match) {
       throw new Error(`invalid scale step "${step}", expected number or integer with optional # b suffixes`);
     }
     asNumber = Number(match[1]);
-    // These decorations will determine the semitone offset based on the number of
+    const accidentals = match[2] || '';
-    // sharps or flats
+    offset = getAccidentalsOffset(accidentals);
-    const decorations = match[2] || '';
-    offset = decorations[0] === '#' ? decorations.length : -decorations.length;
   }
   return [asNumber, offset];
 }
@@ -226,7 +223,7 @@ function _getNearestScaleNote(scaleName, note, preferHigher = true) {
  * Turns numbers into notes in the scale (zero indexed) or quantizes notes to a scale.
  *
  * When describing notes via numbers, note that negative numbers can be used to wrap backwards
- * in the scale as well as sharps or flats (but not both) to produce notes outside of the scale.
+ * in the scale as well as sharps or flats to produce notes outside of the scale.
  *
  * Also sets scale for other scale operations, like {@link Pattern#scaleTranspose}.
  *
@@ -254,7 +251,6 @@ function _getNearestScaleNote(scaleName, note, preferHigher = true) {
  * @example
  * note("C1*16").transpose(irand(36)).scale('Cb2 major').scaleTranspose(3)
  */
-
 export const scale = register(
   'scale',
   function (scale, pat) {
@@ -262,44 +258,47 @@ export const scale = register(
     if (Array.isArray(scale)) {
       scale = scale.flat().join(' ');
     }
-    return (
+    return pat.withHaps((haps) => {
-      pat
+      haps = haps.map((hap) => {
-        .fmap((value) => {
+        let hVal = hap.value;
-          const isObject = typeof value === 'object';
+        const isObject = typeof hVal === 'object';
-          // The case where the note has been defined via `n` or `pure`
+        // If hVal is a pure value, place it on `n` so that we interpret it as a scale degree
-          if (!isObject || (isObject && ('n' in value || 'value' in value))) {
+        hVal = isObject ? hVal : { n: hVal };
-            const step = isObject ? (value.n ?? value.value) : value;
+        const { note, n, value, ...otherValues } = hVal;
-            delete value.n; // remove n so it won't cause trouble
+        const noteOrStep = note ?? n ?? value;
-            if (isNote(step)) {
+        if (noteOrStep === undefined) {
-              // legacy..
+          logger(
-              return pure(step);
+            `[tonal] Invalid value format for 'scale'. Value must contain n, note, or value but received keys [${Object.keys(hVal).join(', ')}]`,
+            'error',
+          );
+          return hap; // pass the value through unchanged
+        }
+        let scaleNote;
+        if (isNote(noteOrStep)) {
+          // Note case (quantize to scale)
+          scaleNote = _getNearestScaleNote(scale, noteOrStep);
+          hap.value = { ...otherValues, note: scaleNote };
+        } else {
+          // Step case (convert to note in scale)
+          try {
+            const [number, offset] = _convertStepToNumberAndOffset(noteOrStep);
+            if (otherValues.anchor) {
+              scaleNote = stepInNamedScale(number, scale, otherValues.anchor);
+            } else {
+              scaleNote = scaleStep(number, scale);
             }
-            try {
+            if (offset != 0) scaleNote = Note.transpose(scaleNote, Interval.fromSemitones(offset));
-              const [number, offset] = _convertStepToNumberAndOffset(step);
+          } catch (err) {
-              let note;
+            logger(`[tonal] ${err.message}`, 'error');
-              if (isObject && value.anchor) {
+            return; // will be removed
-                note = stepInNamedScale(number, scale, value.anchor);
-              } else {
-                note = scaleStep(number, scale);
-              }
-              if (offset != 0) note = Note.transpose(note, Interval.fromSemitones(offset));
-              value = pure(isObject ? { ...value, note } : note);
-            } catch (err) {
-              logger(`[tonal] ${err.message}`, 'error');
-              return silence;
-            }
-            return value;
           }
-          // The case where the note has been defined via `note`
+        }
-          else {
+        hap.value = isObject ? { ...otherValues, note: scaleNote } : scaleNote;
-            const note = _getNearestScaleNote(scale, value.note);
+        // Tag with scale for downsteam scale-aware operations
-            return pure(isObject ? { ...value, note } : note);
+        return hap.setContext({ ...hap.context, scale });
-          }
+      });
-        })
+      return removeUndefineds(haps);
-        .outerJoin()
+    });
-        // legacy:
-        .withHap((hap) => hap.setContext({ ...hap.context, scale }))
-    );
   },
   true,
   true, // preserve step count

test/__snapshots__/examples.test.mjs.snap

@@ -3838,8 +3838,8 @@ exports[`runs examples > example "fast" example index 0 1`] = `
 
 exports[`runs examples > example "fastChunk" example index 0 1`] = `
 [
-  "[ 0/1 → 1/4 | color:red note:0 ]",
+  "[ 0/1 → 1/4 | note:C2 color:red ]",
-  "[ 1/4 → 1/2 | color:red note:1 ]",
+  "[ 1/4 → 1/2 | note:D2 color:red ]",
   "[ 1/2 → 3/4 | note:E2 ]",
   "[ 3/4 → 1/1 | note:F2 ]",
   "[ 1/1 → 5/4 | note:G2 ]",
@@ -3848,8 +3848,8 @@ exports[`runs examples > example "fastChunk" example index 0 1`] = `
   "[ 7/4 → 2/1 | note:C3 ]",
   "[ 2/1 → 9/4 | note:D3 ]",
   "[ 9/4 → 5/2 | note:D2 ]",
-  "[ 5/2 → 11/4 | color:red note:2 ]",
+  "[ 5/2 → 11/4 | note:E2 color:red ]",
-  "[ 11/4 → 3/1 | color:red note:3 ]",
+  "[ 11/4 → 3/1 | note:F2 color:red ]",
   "[ 3/1 → 13/4 | note:G2 ]",
   "[ 13/4 → 7/2 | note:A2 ]",
   "[ 7/2 → 15/4 | note:B2 ]",

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

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

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

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