fix: add flag to reduce dom weight

+ use name instead of longname for linking

.github/workflows/tauri.yml

@@ -0,0 +1,62 @@
+name: Tauri Builder
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+
+jobs:
+  release:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [macos-latest, ubuntu-latest, windows-latest]
+        include:
+          - os: ubuntu-latest
+            rust_target: x86_64-unknown-linux-gnu
+          - os: macos-latest
+            rust_target: x86_64-apple-darwin
+          - os: macos-latest
+            rust_target: aarch64-apple-darwin
+          - os: windows-latest
+            rust_target: x86_64-pc-windows-msvc
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+      - uses: pnpm/action-setup@v2
+        with:
+          version: 8.6.2
+
+      - name: Node.js setup
+        uses: actions/setup-node@v3
+        with:
+          node-version: latest
+          # node-version-file: '.nvmrc'
+
+      - name: Install Rust (Stable)
+        run:
+          curl https://sh.rustup.rs -sSf | sh -s -- -y
+
+      - name: Install dependencies (ubuntu only)
+        if: matrix.platform == 'ubuntu-latest'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libgtk-3-dev webkit2gtk-4.0 libappindicator3-dev librsvg2-dev patchelf
+
+      - name: Install app dependencies from lockfile and build web
+        run: pnpm install
+
+      - name: Build the app
+        uses: tauri-apps/tauri-action@v0
+
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          # tauri-action replaces \_\_VERSION\_\_ with the app version
+          tagName: ${{ github.ref_name }}
+          releaseName: "Strudel v__VERSION__"
+          releaseBody: |
+            See the assets to download this version and install.
+          releaseDraft: true
+          prerelease: false

.gitignore

@@ -39,4 +39,8 @@ server/samples/old
 repl/stats.html
 coverage
 public/icons/apple-splash-*
-dev-dist
+dev-dist
+Dirt-Samples
+tidal-drum-machines
+webaudiofontdata
+src-tauri/target

CONTRIBUTING.md

@@ -31,7 +31,7 @@ Use one of the Communication Channels listed above.
 
 ## Improve the Docs
 
-If you find some weak spots in the [docs](https://strudel.tidalcycles.org/learn/getting-started),
+If you find some weak spots in the [docs](https://strudel.tidalcycles.org/workshop/getting-started/),
 you can edit each file directly on github via the "Edit this page" link located in the right sidebar.
 
 ## Propose a Feature
@@ -123,7 +123,14 @@ To publish all packages that have been changed since the last release, run:
 
 ```sh
 npm login
-npx lerna publish
+
+# this will increment all the versions in package.json files of non private packages to selected versions
+npx lerna version --no-private
+
+# publish all packages inside /packages using pnpm! don't use lerna to publish!!
+pnpm --filter "./packages/**" publish --dry-run
+
+# the last command was only a dry-run, make sure everything looks ok, if yes, run the same command without flag
 ```
 
 To manually publish a single package, increase the version in the `package.json`, then run `pnpm publish`.

README.md

@@ -14,8 +14,8 @@ An experiment in making a [Tidal](https://github.com/tidalcycles/tidal/) using w
 After cloning the project, you can run the REPL locally:
 
 ```bash
-npm run setup
-npm run repl
+pnpm run setup
+pnpm run repl
 ```
 
 ## Using Strudel In Your Project
@@ -24,8 +24,8 @@ There are multiple npm packages you can use to use strudel, or only parts of it,
 
 - [`core`](./packages/core/): tidal pattern engine
 - [`mini`](./packages/mini): mini notation parser + core binding
-- [`eval`](./packages/eval): user code evaluator. syntax sugar + highlighting
-- [`tone`](./packages/tone): bindings for Tone.js instruments and effects
+- [`transpiler`](./packages/transpiler): user code transpiler
+- [`webaudio`](./packages/webaudio): webaudio output
 - [`osc`](./packages/osc): bindings to communicate via OSC
 - [`midi`](./packages/midi): webmidi bindings
 - [`serial`](./packages/serial): webserial bindings

index.mjs

@@ -2,7 +2,6 @@
 export * from './packages/core/index.mjs';
 export * from './packages/csound/index.mjs';
 export * from './packages/embed/index.mjs';
-export * from './packages/eval/index.mjs';
 export * from './packages/midi/index.mjs';
 export * from './packages/mini/index.mjs';
 export * from './packages/osc/index.mjs';
@@ -10,8 +9,6 @@ export * from './packages/react/index.mjs';
 export * from './packages/serial/index.mjs';
 export * from './packages/soundfonts/index.mjs';
 export * from './packages/tonal/index.mjs';
-export * from './packages/tone/index.mjs';
 export * from './packages/transpiler/index.mjs';
 export * from './packages/webaudio/index.mjs';
-export * from './packages/webdirt/index.mjs';
 export * from './packages/xen/index.mjs';

package.json

@@ -18,7 +18,6 @@
     "build": "npm run prebuild && cd website && npm run build",
     "preview": "cd website && npm run preview",
     "osc": "cd packages/osc && npm run server",
-    "deploy": "NODE_DEBUG=gh-pages gh-pages -d out",
     "jsdoc": "jsdoc packages/ -c jsdoc.config.json",
     "jsdoc-json": "jsdoc packages/ --template ./node_modules/jsdoc-json --destination doc.json -c jsdoc.config.json",
     "lint": "eslint . --ext mjs,js --quiet",
@@ -53,22 +52,21 @@
     "@strudel.cycles/webaudio": "workspace:*",
     "@strudel.cycles/xen": "workspace:*",
     "acorn": "^8.8.1",
-    "dependency-tree": "^9.0.0",
-    "vitest": "^0.25.7"
+    "dependency-tree": "^9.0.0"
   },
   "devDependencies": {
-    "@vitest/ui": "^0.25.7",
-    "c8": "^7.12.0",
-    "canvas": "^2.11.0",
-    "eslint": "^8.28.0",
+    "@tauri-apps/cli": "^1.4.0",
+    "@vitest/ui": "^0.28.0",
+    "canvas": "^2.11.2",
+    "eslint": "^8.39.0",
     "eslint-plugin-import": "^2.27.5",
     "events": "^3.3.0",
-    "gh-pages": "^4.0.0",
-    "jsdoc": "^3.6.10",
+    "jsdoc": "^4.0.2",
     "jsdoc-json": "^2.0.2",
-    "jsdoc-to-markdown": "^7.1.1",
-    "lerna": "^4.0.0",
-    "prettier": "^2.8.1",
-    "rollup-plugin-visualizer": "^5.8.1"
+    "jsdoc-to-markdown": "^8.0.0",
+    "lerna": "^6.6.1",
+    "prettier": "^2.8.8",
+    "rollup-plugin-visualizer": "^5.8.1",
+    "vitest": "^0.33.0"
   }
 }

packages/codemirror/README.md

@@ -0,0 +1,3 @@
+# @strudel/codemirror
+
+This package contains helpers and extensions to use codemirror6. See [vite-vanilla-repl-cm6](../core/examples/vite-vanilla-repl-cm6/main.js) as an example of using it.

packages/codemirror/codemirror.mjs

@@ -0,0 +1,113 @@
+import { defaultKeymap } from '@codemirror/commands';
+import { javascript } from '@codemirror/lang-javascript';
+import { defaultHighlightStyle, syntaxHighlighting } from '@codemirror/language';
+import { EditorState } from '@codemirror/state';
+import { EditorView, highlightActiveLineGutter, keymap, lineNumbers } from '@codemirror/view';
+import { Drawer, repl } from '@strudel.cycles/core';
+import { flashField, flash } from './flash.mjs';
+import { highlightExtension, highlightMiniLocations } from './highlight.mjs';
+import { oneDark } from './themes/one-dark';
+
+// https://codemirror.net/docs/guide/
+export function initEditor({ initialCode = '', onChange, onEvaluate, onStop, theme = oneDark, root }) {
+  let state = EditorState.create({
+    doc: initialCode,
+    extensions: [
+      theme,
+      javascript(),
+      lineNumbers(),
+      highlightExtension,
+      highlightActiveLineGutter(),
+      syntaxHighlighting(defaultHighlightStyle),
+      keymap.of(defaultKeymap),
+      flashField,
+      EditorView.updateListener.of((v) => onChange(v)),
+      keymap.of([
+        {
+          key: 'Ctrl-Enter',
+          run: () => onEvaluate(),
+        },
+        {
+          key: 'Ctrl-.',
+          run: () => onStop(),
+        },
+      ]),
+    ],
+  });
+
+  return new EditorView({
+    state,
+    parent: root,
+  });
+}
+
+export class StrudelMirror {
+  constructor(options) {
+    const { root, initialCode = '', onDraw, drawTime = [-2, 2], prebake, ...replOptions } = options;
+    this.code = initialCode;
+
+    this.drawer = new Drawer((haps, time) => {
+      const currentFrame = haps.filter((hap) => time >= hap.whole.begin && time <= hap.endClipped);
+      this.highlight(currentFrame, time);
+      onDraw?.(haps, time, currentFrame);
+    }, drawTime);
+
+    const prebaked = prebake();
+    prebaked.then(async () => {
+      if (!onDraw) {
+        return;
+      }
+      const { scheduler, evaluate } = await this.repl;
+      // draw first frame instantly
+      prebaked.then(async () => {
+        await evaluate(this.code, false);
+        this.drawer.invalidate(scheduler);
+        onDraw?.(this.drawer.visibleHaps, 0, []);
+      });
+    });
+
+    this.repl = repl({
+      ...replOptions,
+      onToggle: async (started) => {
+        replOptions?.onToggle?.(started);
+        const { scheduler } = await this.repl;
+        if (started) {
+          this.drawer.start(scheduler);
+        } else {
+          this.drawer.stop();
+        }
+      },
+      beforeEval: async () => {
+        await prebaked;
+      },
+      afterEval: (options) => {
+        replOptions?.afterEval?.(options);
+        this.drawer.invalidate();
+      },
+    });
+    this.editor = initEditor({
+      root,
+      initialCode,
+      onChange: (v) => {
+        this.code = v.state.doc.toString();
+      },
+      onEvaluate: () => this.evaluate(),
+      onStop: () => this.stop(),
+    });
+  }
+  async evaluate() {
+    const { evaluate } = await this.repl;
+    this.flash();
+    await evaluate(this.code);
+  }
+  async stop() {
+    const { scheduler } = await this.repl;
+    scheduler.stop();
+  }
+  flash(ms) {
+    flash(this.editor, ms);
+  }
+  highlight(haps, time) {
+    highlightMiniLocations(this.editor.view, time, haps);
+  }
+}

packages/codemirror/flash.mjs

@@ -0,0 +1,35 @@
+import { StateEffect, StateField } from '@codemirror/state';
+import { Decoration, EditorView } from '@codemirror/view';
+
+export const setFlash = StateEffect.define();
+export const flashField = StateField.define({
+  create() {
+    return Decoration.none;
+  },
+  update(flash, tr) {
+    try {
+      for (let e of tr.effects) {
+        if (e.is(setFlash)) {
+          if (e.value && tr.newDoc.length > 0) {
+            const mark = Decoration.mark({ attributes: { style: `background-color: #FFCA2880` } });
+            flash = Decoration.set([mark.range(0, tr.newDoc.length)]);
+          } else {
+            flash = Decoration.set([]);
+          }
+        }
+      }
+      return flash;
+    } catch (err) {
+      console.warn('flash error', err);
+      return flash;
+    }
+  },
+  provide: (f) => EditorView.decorations.from(f),
+});
+
+export const flash = (view, ms = 200) => {
+  view.dispatch({ effects: setFlash.of(true) });
+  setTimeout(() => {
+    view.dispatch({ effects: setFlash.of(false) });
+  }, ms);
+};

packages/codemirror/highlight.mjs

@@ -0,0 +1,126 @@
+import { RangeSetBuilder, StateEffect, StateField } from '@codemirror/state';
+import { Decoration, EditorView } from '@codemirror/view';
+
+export const setMiniLocations = StateEffect.define();
+export const showMiniLocations = StateEffect.define();
+export const updateMiniLocations = (view, locations) => {
+  view.dispatch({ effects: setMiniLocations.of(locations) });
+};
+export const highlightMiniLocations = (view, atTime, haps) => {
+  view.dispatch({ effects: showMiniLocations.of({ atTime, haps }) });
+};
+
+const miniLocations = StateField.define({
+  create() {
+    return Decoration.none;
+  },
+  update(locations, tr) {
+    if (tr.docChanged) {
+      locations = locations.map(tr.changes);
+    }
+
+    for (let e of tr.effects) {
+      if (e.is(setMiniLocations)) {
+        // 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: 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>
+      }
+    }
+
+    return locations;
+  },
+});
+
+const visibleMiniLocations = StateField.define({
+  create() {
+    return { atTime: 0, haps: new Map() };
+  },
+  update(visible, tr) {
+    for (let e of tr.effects) {
+      if (e.is(showMiniLocations)) {
+        // this is called every frame to show the locations that are currently active
+        // we can NOT create new marks because the context.locations haven't changed since eval time
+        // this is why we need to find a way to update the existing decorations, showing the ones that have an active range
+        const haps = new Map();
+        for (let hap of e.value.haps) {
+          for (let { start, end } of hap.context.locations) {
+            let id = `${start}:${end}`;
+            if (!haps.has(id) || haps.get(id).whole.begin.lt(hap.whole.begin)) {
+              haps.set(id, hap);
+            }
+          }
+        }
+
+        visible = { atTime: e.value.atTime, haps };
+      }
+    }
+
+    return visible;
+  },
+});
+
+// // Derive the set of decorations from the miniLocations and visibleLocations
+const miniLocationHighlights = EditorView.decorations.compute([miniLocations, visibleMiniLocations], (state) => {
+  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.context.color ?? 'var(--foreground)';
+      // 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: `outline: solid 2px ${color}` },
+        }),
+      );
+    }
+
+    iterator.next();
+  }
+
+  return builder.finish();
+});
+
+export const highlightExtension = [miniLocations, visibleMiniLocations, miniLocationHighlights];

packages/codemirror/index.mjs

@@ -0,0 +1,3 @@
+export * from './codemirror.mjs';
+export * from './highlight.mjs';
+export * from './flash.mjs';

packages/codemirror/package.json

@@ -1,9 +1,8 @@
 {
-  "name": "@strudel.cycles/webdirt",
-  "version": "0.6.0",
-  "description": "WebDirt integration for Strudel",
+  "name": "@strudel/codemirror",
+  "version": "0.8.4",
+  "description": "Codemirror Extensions for Strudel",
   "main": "index.mjs",
-  "type": "module",
   "publishConfig": {
     "main": "dist/index.js",
     "module": "dist/index.mjs"
@@ -12,6 +11,7 @@
     "build": "vite build",
     "prepublishOnly": "npm run build"
   },
+  "type": "module",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/tidalcycles/strudel.git"
@@ -24,18 +24,24 @@
     "algorave"
   ],
   "author": "Felix Roos <flix91@gmail.com>",
+  "contributors": [
+    "Alex McLean <alex@slab.org>"
+  ],
   "license": "AGPL-3.0-or-later",
   "bugs": {
     "url": "https://github.com/tidalcycles/strudel/issues"
   },
   "homepage": "https://github.com/tidalcycles/strudel#readme",
   "dependencies": {
-    "@strudel.cycles/core": "workspace:*",
-    "@strudel.cycles/webaudio": "workspace:*",
-    "WebDirt": "github:dktr0/WebDirt"
+    "@codemirror/commands": "^6.2.4",
+    "@codemirror/lang-javascript": "^6.1.7",
+    "@codemirror/language": "^6.6.0",
+    "@codemirror/state": "^6.2.0",
+    "@codemirror/view": "^6.10.0",
+    "@lezer/highlight": "^1.1.4",
+    "@strudel.cycles/core": "workspace:*"
   },
   "devDependencies": {
-    "vite": "^3.2.2",
-    "vitest": "^0.25.7"
+    "vite": "^4.3.3"
   }
 }

packages/codemirror/themes/one-dark.mjs

@@ -0,0 +1,139 @@
+import { EditorView } from '@codemirror/view';
+import { HighlightStyle, syntaxHighlighting } from '@codemirror/language';
+import { tags as t } from '@lezer/highlight';
+
+// Using https://github.com/one-dark/vscode-one-dark-theme/ as reference for the colors
+
+const chalky = '#e5c07b',
+  coral = '#e06c75',
+  cyan = '#56b6c2',
+  invalid = '#ffffff',
+  ivory = '#abb2bf',
+  stone = '#7d8799', // Brightened compared to original to increase contrast
+  malibu = '#61afef',
+  sage = '#98c379',
+  whiskey = '#d19a66',
+  violet = '#c678dd',
+  darkBackground = '#21252b',
+  highlightBackground = '#2c313a',
+  background = '#282c34',
+  tooltipBackground = '#353a42',
+  selection = '#3E4451',
+  cursor = '#528bff';
+
+/// The colors used in the theme, as CSS color strings.
+export const color = {
+  chalky,
+  coral,
+  cyan,
+  invalid,
+  ivory,
+  stone,
+  malibu,
+  sage,
+  whiskey,
+  violet,
+  darkBackground,
+  highlightBackground,
+  background,
+  tooltipBackground,
+  selection,
+  cursor,
+};
+
+/// The editor theme styles for One Dark.
+export const oneDarkTheme = EditorView.theme(
+  {
+    '&': {
+      color: ivory,
+      backgroundColor: background,
+    },
+
+    '.cm-content': {
+      caretColor: cursor,
+    },
+
+    '.cm-cursor, .cm-dropCursor': { borderLeftColor: cursor },
+    '&.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground, .cm-selectionBackground, .cm-content ::selection':
+      { backgroundColor: selection },
+
+    '.cm-panels': { backgroundColor: darkBackground, color: ivory },
+    '.cm-panels.cm-panels-top': { borderBottom: '2px solid black' },
+    '.cm-panels.cm-panels-bottom': { borderTop: '2px solid black' },
+
+    '.cm-searchMatch': {
+      backgroundColor: '#72a1ff59',
+      outline: '1px solid #457dff',
+    },
+    '.cm-searchMatch.cm-searchMatch-selected': {
+      backgroundColor: '#6199ff2f',
+    },
+
+    '.cm-activeLine': { backgroundColor: '#6699ff0b' },
+    '.cm-selectionMatch': { backgroundColor: '#aafe661a' },
+
+    '&.cm-focused .cm-matchingBracket, &.cm-focused .cm-nonmatchingBracket': {
+      backgroundColor: '#bad0f847',
+    },
+
+    '.cm-gutters': {
+      backgroundColor: background,
+      color: stone,
+      border: 'none',
+    },
+
+    '.cm-activeLineGutter': {
+      backgroundColor: highlightBackground,
+    },
+
+    '.cm-foldPlaceholder': {
+      backgroundColor: 'transparent',
+      border: 'none',
+      color: '#ddd',
+    },
+
+    '.cm-tooltip': {
+      border: 'none',
+      backgroundColor: tooltipBackground,
+    },
+    '.cm-tooltip .cm-tooltip-arrow:before': {
+      borderTopColor: 'transparent',
+      borderBottomColor: 'transparent',
+    },
+    '.cm-tooltip .cm-tooltip-arrow:after': {
+      borderTopColor: tooltipBackground,
+      borderBottomColor: tooltipBackground,
+    },
+    '.cm-tooltip-autocomplete': {
+      '& > ul > li[aria-selected]': {
+        backgroundColor: highlightBackground,
+        color: ivory,
+      },
+    },
+  },
+  { dark: true },
+);
+
+/// The highlighting style for code in the One Dark theme.
+export const oneDarkHighlightStyle = HighlightStyle.define([
+  { tag: t.keyword, color: violet },
+  { tag: [t.name, t.deleted, t.character, t.propertyName, t.macroName], color: coral },
+  { tag: [t.function(t.variableName), t.labelName], color: malibu },
+  { tag: [t.color, t.constant(t.name), t.standard(t.name)], color: whiskey },
+  { tag: [t.definition(t.name), t.separator], color: ivory },
+  { tag: [t.typeName, t.className, t.number, t.changed, t.annotation, t.modifier, t.self, t.namespace], color: chalky },
+  { tag: [t.operator, t.operatorKeyword, t.url, t.escape, t.regexp, t.link, t.special(t.string)], color: cyan },
+  { tag: [t.meta, t.comment], color: stone },
+  { tag: t.strong, fontWeight: 'bold' },
+  { tag: t.emphasis, fontStyle: 'italic' },
+  { tag: t.strikethrough, textDecoration: 'line-through' },
+  { tag: t.link, color: stone, textDecoration: 'underline' },
+  { tag: t.heading, fontWeight: 'bold', color: coral },
+  { tag: [t.atom, t.bool, t.special(t.variableName)], color: whiskey },
+  { tag: [t.processingInstruction, t.string, t.inserted], color: sage },
+  { tag: t.invalid, color: invalid },
+]);
+
+/// Extension to enable the One Dark theme (both the editor theme and
+/// the highlight style).
+export const oneDark = [oneDarkTheme, syntaxHighlighting(oneDarkHighlightStyle)];

packages/core/animate.mjs

@@ -1,4 +1,5 @@
-import { controls, Pattern, getDrawContext, silence, register, pure } from './index.mjs';
+import { Pattern, getDrawContext, silence, register, pure } from './index.mjs';
+import controls from './controls.mjs'; // do not import from index.mjs as it breaks for some reason..
 const { createParams } = controls;
 
 let clearColor = '#22222210';

packages/core/controls.mjs

@@ -4,20 +4,34 @@ Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/st
 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, sequence } from './pattern.mjs';
+import { Pattern, register, sequence } from './pattern.mjs';
+import { zipWith } from './util.mjs';
 
 const controls = {};
 const generic_params = [
   /**
-   * Select a sound / sample by name.
+   * Select a sound / sample by name. When using mininotation, you can also optionally supply 'n' and 'gain' parameters
+   * separated by ':'.
    *
    * @name s
    * @param {string | Pattern} sound The sound / pattern of sounds to pick
+   * @synonyms sound
    * @example
    * s("bd hh")
+   * @example
+   * s("bd:0 bd:1 bd:0:0.3 bd:1:1.4")
    *
    */
-  ['s', 's', 'sound'],
+  [['s', 'n', 'gain'], 'sound'],
+  /**
+   * Define a custom webaudio node to use as a sound source.
+   *
+   * @name source
+   * @param {function} getSource
+   * @synonyms src
+   *
+   */
+  ['source', 'src'],
   /**
    * Selects the given index from the sample map.
    * Numbers too high will wrap around.
@@ -29,7 +43,7 @@ const generic_params = [
    * s("bd sd,hh*3").n("<0 1>")
    */
   // also see https://github.com/tidalcycles/strudel/pull/63
-  ['f', 'n', 'The sample number to choose for a synth or sampleset'],
+  ['n'],
   /**
    * Plays the given note name or midi number. A note name consists of
    *
@@ -49,10 +63,8 @@ const generic_params = [
    * @example
    * note("60 69 65 64")
    */
-  ['f', 'note', 'The note or pitch to play a sound or synth with'],
-  //['s', 'toArg', 'for internal sound routing'],
-  // ["f", "from", "for internal sound routing"),
-  //['f', 'to', 'for internal sound routing'],
+  [['note', 'n']],
+
   /**
    * A pattern of numbers that speed up (or slow down) samples while they play. Currently only supported by osc / superdirt.
    *
@@ -63,7 +75,7 @@ const generic_params = [
    * s("sax").accelerate("<0 1 2 4 8 16>").slow(2).osc()
    *
    */
-  ['f', 'accelerate', 'a pattern of numbers that speed up (or slow down) samples while they play.'],
+  ['accelerate'],
   /**
    * Controls the gain by an exponential amount.
    *
@@ -73,11 +85,7 @@ const generic_params = [
    * s("hh*8").gain(".4!2 1 .4!2 1 .4 1")
    *
    */
-  [
-    'f',
-    'gain',
-    'a pattern of numbers that specify volume. Values less than 1 make the sound quieter. Values greater than 1 make the sound louder. For the linear equivalent, see @amp@.',
-  ],
+  ['gain'],
   /**
    * Like {@link gain}, but linear.
    *
@@ -88,17 +96,18 @@ const generic_params = [
    * s("bd*8").amp(".1*2 .5 .1*2 .5 .1 .5").osc()
    *
    */
-  ['f', 'amp', 'like @gain@, but linear.'],
+  ['amp'],
   /**
    * Amplitude envelope attack time: Specifies how long it takes for the sound to reach its peak value, relative to the onset.
    *
    * @name attack
    * @param {number | Pattern} attack time in seconds.
+   * @synonyms att
    * @example
    * note("c3 e3").attack("<0 .1 .5>")
    *
    */
-  ['f', 'attack'],
+  ['attack', 'att'],
 
   /**
    * Select the sound bank to use. To be used together with `s`. The bank name (+ "_") will be prepended to the value of `s`.
@@ -109,7 +118,7 @@ const generic_params = [
    * s("bd sd").bank('RolandTR909') // = s("RolandTR909_bd RolandTR909_sd")
    *
    */
-  ['f', 'bank', 'selects sound bank to use'],
+  ['bank'],
 
   /**
    * Amplitude envelope decay time: the time it takes after the attack time to reach the sustain level.
@@ -121,52 +130,46 @@ const generic_params = [
    * note("c3 e3").decay("<.1 .2 .3 .4>").sustain(0)
    *
    */
-  ['f', 'decay', ''],
+  ['decay'],
   /**
    * Amplitude envelope sustain level: The level which is reached after attack / decay, being sustained until the offset.
    *
    * @name sustain
    * @param {number | Pattern} gain sustain level between 0 and 1
+   * @synonyms sus
    * @example
    * note("c3 e3").decay(.2).sustain("<0 .1 .4 .6 1>")
    *
    */
-  ['f', 'sustain', ''],
+  ['sustain', 'sus'],
   /**
    * Amplitude envelope release time: The time it takes after the offset to go from sustain level to zero.
    *
    * @name release
    * @param {number | Pattern} time release time in seconds
+   * @synonyms rel
    * @example
    * note("c3 e3 g3 c4").release("<0 .1 .4 .6 1>/2")
    *
    */
-  [
-    'f',
-    'release',
-    'a pattern of numbers to specify the release time (in seconds) of an envelope applied to each sample.',
-  ],
-  [
-    'f',
-    'hold',
-    'a pattern of numbers to specify the hold time (in seconds) of an envelope applied to each sample. Only takes effect if `attack` and `release` are also specified.',
-  ],
+  ['release', 'rel'],
+  ['hold'],
   // TODO: in tidal, it seems to be normalized
   /**
-   * Sets the center frequency of the **b**and-**p**ass **f**ilter.
+   * Sets the center frequency of the **b**and-**p**ass **f**ilter. When using mininotation, you
+   * can also optionally supply the 'bpq' parameter separated by ':'.
    *
    * @name bpf
    * @param {number | Pattern} frequency center frequency
-   * @synonyms bandf
+   * @synonyms bandf, bp
    * @example
    * s("bd sd,hh*3").bpf("<1000 2000 4000 8000>")
    *
    */
-  ['f', 'bpf', ''],
-  ['f', 'bandf', 'A pattern of numbers from 0 to 1. Sets the center frequency of the band-pass filter.'],
+  [['bandf', 'bandq'], 'bpf', 'bp'],
   // TODO: in tidal, it seems to be normalized
   /**
-   * Sets the **b**and-**p**ass **q**-factor (resonance)
+   * Sets the **b**and-**p**ass **q**-factor (resonance).
    *
    * @name bpq
    * @param {number | Pattern} q q factor
@@ -175,8 +178,9 @@ const generic_params = [
    * s("bd sd").bpf(500).bpq("<0 1 2 3>")
    *
    */
-  ['f', 'bpq', ''],
-  ['f', 'bandq', 'a pattern of anumbers from 0 to 1. Sets the q-factor of the band-pass filter.'],
+  // currently an alias of 'bandq' https://github.com/tidalcycles/strudel/issues/496
+  // ['bpq'],
+  ['bandq', 'bpq'],
   /**
    * a pattern of numbers from 0 to 1. Skips the beginning of each sample, e.g. `0.25` to cut off the first quarter from each sample.
    *
@@ -188,11 +192,7 @@ const generic_params = [
    * s("rave").begin("<0 .25 .5 .75>")
    *
    */
-  [
-    'f',
-    'begin',
-    'a pattern of numbers from 0 to 1. Skips the beginning of each sample, e.g. `0.25` to cut off the first quarter from each sample.',
-  ],
+  ['begin'],
   /**
    * The same as .begin, but cuts off the end off each sample.
    *
@@ -203,11 +203,7 @@ const generic_params = [
    * s("bd*2,oh*4").end("<.1 .2 .5 1>")
    *
    */
-  [
-    'f',
-    'end',
-    'the same as `begin`, but cuts the end off samples, shortening them; e.g. `0.75` to cut off the last quarter of each sample.',
-  ],
+  ['end'],
   /**
    * Loops the sample (from `begin` to `end`) the specified number of times.
    * Note that the tempo of the loop is not synced with the cycle tempo.
@@ -218,7 +214,7 @@ const generic_params = [
    * s("bd").loop("<1 2 3 4>").osc()
    *
    */
-  ['f', 'loop', 'loops the sample (from `begin` to `end`) the specified number of times.'],
+  ['loop'],
   // TODO: currently duplicated with "native" legato
   // TODO: superdirt legato will do more: https://youtu.be/dQPmE1WaD1k?t=419
   /**
@@ -226,12 +222,13 @@ const generic_params = [
    *
    * @name legato
    * @param {number | Pattern} duration between 0 and 1, where 1 is the length of the whole hap time
+   * @noAutocomplete
    * @example
    * "c4 eb4 g4 bb4".legato("<0.125 .25 .5 .75 1 2 4>")
    *
    */
-  // ['f', 'legato', 'controls the amount of overlap between two adjacent sounds'],
-  // ['f', 'clhatdecay', ''],
+  // ['legato'],
+  // ['clhatdecay'],
   /**
    * bit crusher effect.
    *
@@ -241,11 +238,7 @@ const generic_params = [
    * s("<bd sd>,hh*3").fast(2).crush("<16 8 7 6 5 4 3 2>")
    *
    */
-  [
-    'f',
-    'crush',
-    'bit crushing, a pattern of numbers from 1 (for drastic reduction in bit-depth) to 16 (for barely no reduction).',
-  ],
+  ['crush'],
   /**
    * fake-resampling for lowering the sample rate. Caution: This effect seems to only work in chromium based browsers
    *
@@ -255,11 +248,7 @@ const generic_params = [
    * s("bd sd,hh*4").coarse("<1 4 8 16 32>")
    *
    */
-  [
-    'f',
-    'coarse',
-    'fake-resampling, a pattern of numbers for lowering the sample rate, i.e. 1 for original 2 for half, 3 for a third and so on.',
-  ],
+  ['coarse'],
 
   /**
    * choose the channel the pattern is sent to in superdirt
@@ -268,7 +257,7 @@ const generic_params = [
    * @param {number | Pattern} channel channel number
    *
    */
-  ['i', 'channel', 'choose the channel the pattern is sent to in superdirt'],
+  ['channel'],
   /**
    * In the style of classic drum-machines, `cut` will stop a playing sample as soon as another samples with in same cutgroup is to be played. An example would be an open hi-hat followed by a closed one, essentially muting the open.
    *
@@ -278,35 +267,39 @@ const generic_params = [
    * s("rd*4").cut(1)
    *
    */
-  [
-    'i',
-    'cut',
-    'In the style of classic drum-machines, `cut` will stop a playing sample as soon as another samples with in same cutgroup is to be played. An example would be an open hi-hat followed by a closed one, essentially muting the open.',
-  ],
+  ['cut'],
   /**
    * Applies the cutoff frequency of the **l**ow-**p**ass **f**ilter.
    *
+   * When using mininotation, you can also optionally add the 'lpq' parameter, separated by ':'.
+   *
    * @name lpf
    * @param {number | Pattern} frequency audible between 0 and 20000
-   * @synonyms cutoff
+   * @synonyms cutoff, ctf, lp
    * @example
    * s("bd sd,hh*3").lpf("<4000 2000 1000 500 200 100>")
+   * @example
+   * s("bd*8").lpf("1000:0 1000:10 1000:20 1000:30")
    *
    */
-  ['f', 'lpf'],
-  ['f', 'cutoff', 'a pattern of numbers from 0 to 1. Applies the cutoff frequency of the low-pass filter.'],
+  [['cutoff', 'resonance'], 'ctf', 'lpf', 'lp'],
   /**
    * Applies the cutoff frequency of the **h**igh-**p**ass **f**ilter.
    *
+   * When using mininotation, you can also optionally add the 'hpq' parameter, separated by ':'.
+   *
    * @name hpf
    * @param {number | Pattern} frequency audible between 0 and 20000
-   * @synonyms hcutoff
+   * @synonyms hp, hcutoff
    * @example
    * s("bd sd,hh*4").hpf("<4000 2000 1000 500 200 100>")
+   * @example
+   * s("bd sd,hh*4").hpf("<2000 2000:25>")
    *
    */
-  ['f', 'hpf', ''],
-  ['f', 'hcutoff', ''],
+  // currently an alias of 'hcutoff' https://github.com/tidalcycles/strudel/issues/496
+  // ['hpf'],
+  [['hcutoff', 'hresonance'], 'hpf', 'hp'],
   /**
    * Controls the **h**igh-**p**ass **q**-value.
    *
@@ -317,8 +310,7 @@ const generic_params = [
    * s("bd sd,hh*4").hpf(2000).hpq("<0 10 20 30>")
    *
    */
-  ['f', 'hresonance', ''],
-  ['f', 'hpq', ''],
+  ['hresonance', 'hpq'],
   /**
    * Controls the **l**ow-**p**ass **q**-value.
    *
@@ -329,8 +321,8 @@ const generic_params = [
    * s("bd sd,hh*4").lpf(2000).lpq("<0 10 20 30>")
    *
    */
-  ['f', 'lpq'],
-  ['f', 'resonance', ''],
+  // currently an alias of 'resonance' https://github.com/tidalcycles/strudel/issues/496
+  ['resonance', 'lpq'],
   /**
    * DJ filter, below 0.5 is low pass filter, above is high pass filter.
    *
@@ -340,40 +332,48 @@ const generic_params = [
    * n("0 3 7 [10,24]").s('superzow').octave(3).djf("<.5 .25 .5 .75>").osc()
    *
    */
-  ['f', 'djf', 'DJ filter, below 0.5 is low pass filter, above is high pass filter.'],
-  // ['f', 'cutoffegint', ''],
+  ['djf'],
+  // ['cutoffegint'],
   // TODO: does not seem to work
   /**
    * Sets the level of the delay signal.
    *
+   * When using mininotation, you can also optionally add the 'delaytime' and 'delayfeedback' parameter,
+   * separated by ':'.
+   *
+   *
    * @name delay
    * @param {number | Pattern} level between 0 and 1
    * @example
    * s("bd").delay("<0 .25 .5 1>")
+   * @example
+   * s("bd bd").delay("0.65:0.25:0.9 0.65:0.125:0.7")
    *
    */
-  ['f', 'delay', 'a pattern of numbers from 0 to 1. Sets the level of the delay signal.'],
+  [['delay', 'delaytime', 'delayfeedback']],
   /**
    * Sets the level of the signal that is fed back into the delay.
    * Caution: Values >= 1 will result in a signal that gets louder and louder! Don't do it
    *
    * @name delayfeedback
    * @param {number | Pattern} feedback between 0 and 1
+   * @synonyms delayfb, dfb
    * @example
    * s("bd").delay(.25).delayfeedback("<.25 .5 .75 1>").slow(2)
    *
    */
-  ['f', 'delayfeedback', 'a pattern of numbers from 0 to 1. Sets the amount of delay feedback.'],
+  ['delayfeedback', 'delayfb', 'dfb'],
   /**
    * Sets the time of the delay effect.
    *
    * @name delaytime
    * @param {number | Pattern} seconds between 0 and Infinity
+   * @synonyms delayt, dt
    * @example
    * s("bd").delay(.25).delaytime("<.125 .25 .5 1>").slow(2)
    *
    */
-  ['f', 'delaytime', 'a pattern of numbers from 0 to 1. Sets the length of the delay.'],
+  ['delaytime', 'delayt', 'dt'],
   /* // TODO: test
    * Specifies whether delaytime is calculated relative to cps.
    *
@@ -383,22 +383,19 @@ const generic_params = [
    * s("sd").delay().lock(1).osc()
    *
    */
-  [
-    'f',
-    'lock',
-    'A pattern of numbers. Specifies whether delaytime is calculated relative to cps. When set to 1, delaytime is a direct multiple of a cycle.',
-  ],
+  ['lock'],
   /**
    * Set detune of oscillators. Works only with some synths, see <a target="_blank" href="https://tidalcycles.org/docs/patternlib/tutorials/synthesizers">tidal doc</a>
    *
    * @name detune
    * @param {number | Pattern} amount between 0 and 1
+   * @synonyms det
    * @superdirtOnly
    * @example
    * n("0 3 7").s('superzow').octave(3).detune("<0 .25 .5 1 2>").osc()
    *
    */
-  ['f', 'detune', ''],
+  ['detune', 'det'],
   /**
    * Set dryness of reverb. See {@link room} and {@link size} for more information about reverb.
    *
@@ -409,11 +406,7 @@ const generic_params = [
    * @superdirtOnly
    *
    */
-  [
-    'f',
-    'dry',
-    'when set to `1` will disable all reverb for this pattern. See `room` and `size` for more information about reverb.',
-  ],
+  ['dry'],
   // TODO: does not seem to do anything
   /*
    * Used when using {@link begin}/{@link end} or {@link chop}/{@link striate} and friends, to change the fade out time of the 'grain' envelope.
@@ -424,17 +417,9 @@ const generic_params = [
    * s("oh*4").end(.1).fadeTime("<0 .2 .4 .8>").osc()
    *
    */
-  [
-    'f',
-    'fadeTime',
-    "Used when using begin/end or chop/striate and friends, to change the fade out time of the 'grain' envelope.",
-  ],
+  ['fadeTime', 'fadeOutTime'],
   // TODO: see above
-  [
-    'f',
-    'fadeInTime',
-    'As with fadeTime, but controls the fade in time of the grain envelope. Not used if the grain begins at position 0 in the sample.',
-  ],
+  ['fadeInTime'],
   /**
    * Set frequency of sound.
    *
@@ -446,15 +431,15 @@ const generic_params = [
    * freq("110".mul.out(".5 1.5 .6 [2 3]")).s("superzow").osc()
    *
    */
-  ['f', 'freq', ''],
+  ['freq'],
   // TODO: https://tidalcycles.org/docs/configuration/MIDIOSC/control-voltage/#gate
-  ['f', 'gate', ''],
-  // ['f', 'hatgrain', ''],
-  // ['f', 'lagogo', ''],
-  // ['f', 'lclap', ''],
-  // ['f', 'lclaves', ''],
-  // ['f', 'lclhat', ''],
-  // ['f', 'lcrash', ''],
+  ['gate', 'gat'],
+  // ['hatgrain'],
+  // ['lagogo'],
+  // ['lclap'],
+  // ['lclaves'],
+  // ['lclhat'],
+  // ['lcrash'],
   // TODO:
   // https://tidalcycles.org/docs/reference/audio_effects/#leslie-1
   // https://tidalcycles.org/docs/reference/audio_effects/#leslie
@@ -468,7 +453,7 @@ const generic_params = [
    * @superdirtOnly
    *
    */
-  ['f', 'leslie', ''],
+  ['leslie'],
   /**
    * Rate of modulation / rotation for leslie effect
    *
@@ -480,7 +465,7 @@ const generic_params = [
    *
    */
   // TODO: the rate seems to "lag" (in the example, 1 will be fast)
-  ['f', 'lrate', ''],
+  ['lrate'],
   /**
    * Physical size of the cabinet in meters. Be careful, it might be slightly larger than your computer. Affects the Doppler amount (pitch warble)
    *
@@ -491,31 +476,28 @@ const generic_params = [
    * @superdirtOnly
    *
    */
-  ['f', 'lsize', ''],
-  // ['f', 'lfo', ''],
-  // ['f', 'lfocutoffint', ''],
-  // ['f', 'lfodelay', ''],
-  // ['f', 'lfoint', ''],
-  // ['f', 'lfopitchint', ''],
-  // ['f', 'lfoshape', ''],
-  // ['f', 'lfosync', ''],
-  // ['f', 'lhitom', ''],
-  // ['f', 'lkick', ''],
-  // ['f', 'llotom', ''],
-  // ['f', 'lophat', ''],
-  // ['f', 'lsnare', ''],
-  ['f', 'degree', ''], // TODO: what is this? not found in tidal doc
-  ['f', 'mtranspose', ''], // TODO: what is this? not found in tidal doc
-  ['f', 'ctranspose', ''], // TODO: what is this? not found in tidal doc
-  ['f', 'harmonic', ''], // TODO: what is this? not found in tidal doc
-  ['f', 'stepsPerOctave', ''], // TODO: what is this? not found in tidal doc
-  ['f', 'octaveR', ''], // TODO: what is this? not found in tidal doc
-  // TODO: why is this needed? what's the difference to late / early?
-  [
-    'f',
-    'nudge',
-    'Nudges events into the future by the specified number of seconds. Negative numbers work up to a point as well (due to internal latency)',
-  ],
+  ['lsize'],
+  // ['lfo'],
+  // ['lfocutoffint'],
+  // ['lfodelay'],
+  // ['lfoint'],
+  // ['lfopitchint'],
+  // ['lfoshape'],
+  // ['lfosync'],
+  // ['lhitom'],
+  // ['lkick'],
+  // ['llotom'],
+  // ['lophat'],
+  // ['lsnare'],
+  ['degree'], // TODO: what is this? not found in tidal doc
+  ['mtranspose'], // TODO: what is this? not found in tidal doc
+  ['ctranspose'], // TODO: what is this? not found in tidal doc
+  ['harmonic'], // TODO: what is this? not found in tidal doc
+  ['stepsPerOctave'], // TODO: what is this? not found in tidal doc
+  ['octaveR'], // TODO: what is this? not found in tidal doc
+  // TODO: why is this needed? what's the difference to late / early? Answer: it's in seconds, and delays the message at
+  // OSC time (so can't be negative, at least not beyond the latency value)
+  ['nudge'],
   // TODO: the following doc is just a guess, it's not documented in tidal doc.
   /**
    * Sets the default octave of a synth.
@@ -526,9 +508,9 @@ const generic_params = [
    * n("0,4,7").s('supersquare').octave("<3 4 5 6>").osc()
    * @superDirtOnly
    */
-  ['i', 'octave', ''],
-  ['f', 'offset', ''], // TODO: what is this? not found in tidal doc
-  // ['f', 'ophatdecay', ''],
+  ['octave'],
+
+  // ['ophatdecay'],
   // TODO: example
   /**
    * An `orbit` is a global parameter context for patterns. Patterns with the same orbit will share the same global effects.
@@ -541,13 +523,9 @@ const generic_params = [
    *   s("~ sd").delay(.5).delaytime(.125).orbit(2)
    * )
    */
-  [
-    'i',
-    'orbit',
-    'a pattern of numbers. An `orbit` is a global parameter context for patterns. Patterns with the same orbit will share hardware output bus offset and global effects, e.g. reverb and delay. The maximum number of orbits is specified in the superdirt startup, numbers higher than maximum will wrap around.',
-  ],
-  ['f', 'overgain', ''], // TODO: what is this? not found in tidal doc
-  ['f', 'overshape', ''], // TODO: what is this? not found in tidal doc
+  ['orbit'],
+  ['overgain'], // TODO: what is this? not found in tidal doc Answer: gain is limited to maximum of 2. This allows you to go over that
+  ['overshape'], // TODO: what is this? not found in tidal doc. Similar to above, but limited to 1
   /**
    * Sets position in stereo.
    *
@@ -557,11 +535,7 @@ const generic_params = [
    * s("[bd hh]*2").pan("<.5 1 .5 0>")
    *
    */
-  [
-    'f',
-    'pan',
-    'a pattern of numbers between 0 and 1, from left to right (assuming stereo), once round a circle (assuming multichannel)',
-  ],
+  ['pan'],
   // TODO: this has no effect (see example)
   /*
    * Controls how much multichannel output is fanned out
@@ -572,11 +546,7 @@ const generic_params = [
    * s("[bd hh]*2").pan("<.5 1 .5 0>").panspan("<0 .5 1>").osc()
    *
    */
-  [
-    'f',
-    'panspan',
-    'a pattern of numbers between -inf and inf, which controls how much multichannel output is fanned out (negative is backwards ordering)',
-  ],
+  ['panspan'],
   // TODO: this has no effect (see example)
   /*
    * Controls how much multichannel output is spread
@@ -587,50 +557,51 @@ const generic_params = [
    * s("[bd hh]*2").pan("<.5 1 .5 0>").pansplay("<0 .5 1>").osc()
    *
    */
-  [
-    'f',
-    'pansplay',
-    'a pattern of numbers between 0.0 and 1.0, which controls the multichannel spread range (multichannel only)',
-  ],
-  [
-    'f',
-    'panwidth',
-    'a pattern of numbers between 0.0 and inf, which controls how much each channel is distributed over neighbours (multichannel only)',
-  ],
-  [
-    'f',
-    'panorient',
-    'a pattern of numbers between -1.0 and 1.0, which controls the relative position of the centre pan in a pair of adjacent speakers (multichannel only)',
-  ],
-  // ['f', 'pitch1', ''],
-  // ['f', 'pitch2', ''],
-  // ['f', 'pitch3', ''],
-  // ['f', 'portamento', ''],
+  ['pansplay'],
+  ['panwidth'],
+  ['panorient'],
+  // ['pitch1'],
+  // ['pitch2'],
+  // ['pitch3'],
+  // ['portamento'],
   // TODO: LFO rate see https://tidalcycles.org/docs/patternlib/tutorials/synthesizers/#supersquare
-  ['f', 'rate', "used in SuperDirt softsynths as a control rate or 'speed'"],
+  ['rate'],
   // TODO: slide param for certain synths
-  ['f', 'slide', ''],
+  ['slide'],
   // TODO: detune? https://tidalcycles.org/docs/patternlib/tutorials/synthesizers/#supersquare
-  ['f', 'semitone', ''],
+  ['semitone'],
   // TODO: dedup with synth param, see https://tidalcycles.org/docs/reference/synthesizers/#superpiano
-  // ['f', 'velocity', ''],
-  ['f', 'voice', ''], // TODO: synth param
+  // ['velocity'],
+  ['voice'], // TODO: synth param
+
+  // voicings // https://github.com/tidalcycles/strudel/issues/506
+  ['chord'], // chord to voice, like C Eb Fm7 G7. the symbols can be defined via addVoicings
+  ['dictionary', 'dict'], // which dictionary to use for the voicings
+  ['anchor'], // the top note to align the voicing to, defaults to c5
+  ['offset'], // how the voicing is offset from the anchored position
+  ['octaves'], // how many octaves are voicing steps spread apart, defaults to 1
+  [['mode', 'anchor']], // below = anchor note will be removed from the voicing, useful for melody harmonization
+
   /**
    * Sets the level of reverb.
    *
+   * When using mininotation, you can also optionally add the 'size' parameter, separated by ':'.
+   *
    * @name room
    * @param {number | Pattern} level between 0 and 1
    * @example
    * s("bd sd").room("<0 .2 .4 .6 .8 1>")
+   * @example
+   * s("bd sd").room("<0.9:1 0.9:4>")
    *
    */
-  ['f', 'room', 'a pattern of numbers from 0 to 1. Sets the level of reverb.'],
+  [['room', 'size']],
   /**
    * Sets the room size of the reverb, see {@link room}.
    *
    * @name roomsize
-   * @synonyms size
    * @param {number | Pattern} size between 0 and 10
+   * @synonyms size, sz
    * @example
    * s("bd sd").room(.8).roomsize("<0 1 2 4 8>")
    *
@@ -638,20 +609,11 @@ const generic_params = [
   // TODO: find out why :
   // s("bd sd").room(.8).roomsize("<0 .2 .4 .6 .8 [1,0]>").osc()
   // .. does not work. Is it because room is only one effect?
-  [
-    'f',
-    'size',
-    'a pattern of numbers from 0 to 1. Sets the perceptual size (reverb time) of the `room` to be used in reverb.',
-  ],
-  [
-    'f',
-    'roomsize',
-    'a pattern of numbers from 0 to 1. Sets the perceptual size (reverb time) of the `room` to be used in reverb.',
-  ],
-  // ['f', 'sagogo', ''],
-  // ['f', 'sclap', ''],
-  // ['f', 'sclaves', ''],
-  // ['f', 'scrash', ''],
+  ['size', 'sz', 'roomsize'],
+  // ['sagogo'],
+  // ['sclap'],
+  // ['sclaves'],
+  // ['scrash'],
   /**
    * Wave shaping distortion. CAUTION: it might get loud
    *
@@ -661,11 +623,7 @@ const generic_params = [
    * s("bd sd,hh*4").shape("<0 .2 .4 .6 .8>")
    *
    */
-  [
-    'f',
-    'shape',
-    'wave shaping distortion, a pattern of numbers from 0 for no distortion up to 1 for loads of distortion.',
-  ],
+  ['shape'],
   /**
    * Changes the speed of sample playback, i.e. a cheap way of changing pitch.
    *
@@ -677,11 +635,7 @@ const generic_params = [
    * speed("1 1.5*2 [2 1.1]").s("piano").clip(1)
    *
    */
-  [
-    'f',
-    'speed',
-    'a pattern of numbers which changes the speed of sample playback, i.e. a cheap way of changing pitch. Negative values will play the sample backwards!',
-  ],
+  ['speed'],
   /**
    * Used in conjunction with {@link speed}, accepts values of "r" (rate, default behavior), "c" (cycles), or "s" (seconds). Using `unit "c"` means `speed` will be interpreted in units of cycles, e.g. `speed "1"` means samples will be stretched to fill a cycle. Using `unit "s"` means the playback speed will be adjusted so that the duration is the number of seconds specified by `speed`.
    *
@@ -692,11 +646,7 @@ const generic_params = [
    * @superdirtOnly
    *
    */
-  [
-    's',
-    'unit',
-    'used in conjunction with `speed`, accepts values of "r" (rate, default behavior), "c" (cycles), or "s" (seconds). Using `unit "c"` means `speed` will be interpreted in units of cycles, e.g. `speed "1"` means samples will be stretched to fill a cycle. Using `unit "s"` means the playback speed will be adjusted so that the duration is the number of seconds specified by `speed`.',
-  ],
+  ['unit'],
   /**
    * Made by Calum Gunn. Reminiscent of some weird mixture of filter, ring-modulator and pitch-shifter. The SuperCollider manual defines Squiz as:
    *
@@ -709,14 +659,14 @@ const generic_params = [
    * @superdirtOnly
    *
    */
-  ['f', 'squiz', ''],
-  ['f', 'stutterdepth', ''], // TODO: what is this? not found in tidal doc
-  ['f', 'stuttertime', ''], // TODO: what is this? not found in tidal doc
-  ['f', 'timescale', ''], // TODO: what is this? not found in tidal doc
-  ['f', 'timescalewin', ''], // TODO: what is this? not found in tidal doc
-  // ['f', 'tomdecay', ''],
-  // ['f', 'vcfegint', ''],
-  // ['f', 'vcoegint', ''],
+  ['squiz'],
+  // ['stutterdepth'], // TODO: what is this? not found in tidal doc
+  // ['stuttertime'], // TODO: what is this? not found in tidal doc
+  // ['timescale'], // TODO: what is this? not found in tidal doc
+  // ['timescalewin'], // TODO: what is this? not found in tidal doc
+  // ['tomdecay'],
+  // ['vcfegint'],
+  // ['vcoegint'],
   // TODO: Use a rest (~) to override the effect <- vowel
   /**
    *
@@ -729,11 +679,7 @@ const generic_params = [
    * .vowel("<a e i <o u>>")
    *
    */
-  [
-    's',
-    'vowel',
-    'formant filter to make things sound like vowels, a pattern of either `a`, `e`, `i`, `o` or `u`. Use a rest (`~`) for no effect.',
-  ],
+  ['vowel'],
   /* // TODO: find out how it works
    * Made by Calum Gunn. Divides an audio stream into tiny segments, using the signal's zero-crossings as segment boundaries, and discards a fraction of them. Takes a number between 1 and 100, denoted the percentage of segments to drop. The SuperCollider manual describes the Waveloss effect this way:
    *
@@ -744,12 +690,12 @@ const generic_params = [
    *
    * @name waveloss
    */
-  ['f', 'waveloss', ''],
+  ['waveloss'],
   // TODO: midi effects?
-  ['f', 'dur', ''],
-  // ['f', 'modwheel', ''],
-  ['f', 'expression', ''],
-  ['f', 'sustainpedal', ''],
+  ['dur'],
+  // ['modwheel'],
+  ['expression'],
+  ['sustainpedal'],
   /* // TODO: doesn't seem to do anything
    *
    * Tremolo Audio DSP effect
@@ -760,97 +706,130 @@ const generic_params = [
    * n("0,4,7").tremolodepth("<0 .3 .6 .9>").osc()
    *
    */
-  // TODO: tremdp alias
-  ['f', 'tremolodepth', "Tremolo Audio DSP effect | params are 'tremolorate' and 'tremolodepth'"],
-  ['f', 'tremolorate', "Tremolo Audio DSP effect | params are 'tremolorate' and 'tremolodepth'"],
+  ['tremolodepth', 'tremdp'],
+  ['tremolorate', 'tremr'],
   // TODO: doesn't seem to do anything
-  ['f', 'phaserdepth', "Phaser Audio DSP effect | params are 'phaserrate' and 'phaserdepth'"],
-  ['f', 'phaserrate', "Phaser Audio DSP effect | params are 'phaserrate' and 'phaserdepth'"],
+  ['phaserdepth', 'phasdp'],
+  ['phaserrate', 'phasr'],
 
-  ['f', 'fshift', 'frequency shifter'],
-  ['f', 'fshiftnote', 'frequency shifter'],
-  ['f', 'fshiftphase', 'frequency shifter'],
+  ['fshift'],
+  ['fshiftnote'],
+  ['fshiftphase'],
 
-  ['f', 'triode', 'tube distortion'],
-  ['f', 'krush', 'shape/bass enhancer'],
-  ['f', 'kcutoff', ''],
-  ['f', 'octer', 'octaver effect'],
-  ['f', 'octersub', 'octaver effect'],
-  ['f', 'octersubsub', 'octaver effect'],
-  ['f', 'ring', 'ring modulation'],
-  ['f', 'ringf', 'ring modulation'],
-  ['f', 'ringdf', 'ring modulation'],
-  ['f', 'distort', 'noisy fuzzy distortion'],
-  ['f', 'freeze', 'Spectral freeze'],
-  ['f', 'xsdelay', ''],
-  ['f', 'tsdelay', ''],
-  ['f', 'real', 'Spectral conform'],
-  ['f', 'imag', ''],
-  ['f', 'enhance', 'Spectral enhance'],
-  ['f', 'partials', ''],
-  ['f', 'comb', 'Spectral comb'],
-  ['f', 'smear', 'Spectral smear'],
-  ['f', 'scram', 'Spectral scramble'],
-  ['f', 'binshift', 'Spectral binshift'],
-  ['f', 'hbrick', 'High pass sort of spectral filter'],
-  ['f', 'lbrick', 'Low pass sort of spectral filter'],
-  ['f', 'midichan', ''],
-  ['f', 'control', ''],
-  ['f', 'ccn', ''],
-  ['f', 'ccv', ''],
-  ['f', 'polyTouch', ''],
-  ['f', 'midibend', ''],
-  ['f', 'miditouch', ''],
-  ['f', 'ctlNum', ''],
-  ['f', 'frameRate', ''],
-  ['f', 'frames', ''],
-  ['f', 'hours', ''],
-  ['s', 'midicmd', ''],
-  ['f', 'minutes', ''],
-  ['f', 'progNum', ''],
-  ['f', 'seconds', ''],
-  ['f', 'songPtr', ''],
-  ['f', 'uid', ''],
-  ['f', 'val', ''],
-  ['f', 'cps', ''],
+  ['triode'],
+  ['krush'],
+  ['kcutoff'],
+  ['octer'],
+  ['octersub'],
+  ['octersubsub'],
+  ['ring'],
+  ['ringf'],
+  ['ringdf'],
+  ['distort'],
+  ['freeze'],
+  ['xsdelay'],
+  ['tsdelay'],
+  ['real'],
+  ['imag'],
+  ['enhance'],
+  ['partials'],
+  ['comb'],
+  ['smear'],
+  ['scram'],
+  ['binshift'],
+  ['hbrick'],
+  ['lbrick'],
+  ['midichan'],
+  ['control'],
+  ['ccn'],
+  ['ccv'],
+  ['polyTouch'],
+  ['midibend'],
+  ['miditouch'],
+  ['ctlNum'],
+  ['frameRate'],
+  ['frames'],
+  ['hours'],
+  ['midicmd'],
+  ['minutes'],
+  ['progNum'],
+  ['seconds'],
+  ['songPtr'],
+  ['uid'],
+  ['val'],
+  ['cps'],
   /**
-   * If set to 1, samples will be cut to the duration of their event.
-   * In tidal, this would be done with legato, which [is about to land in strudel too](https://github.com/tidalcycles/strudel/issues/111)
+   * Multiplies the duration with the given number. Also cuts samples off at the end if they exceed the duration.
+   * In tidal, this would be done with legato, [which has a complicated history in strudel](https://github.com/tidalcycles/strudel/issues/111).
+   * For now, if you're coming from tidal, just think clip = legato.
    *
    * @name clip
-   * @param {number | Pattern} active 1 or 0
+   * @param {number | Pattern} factor >= 0
    * @example
-   * note("c a f e ~").s("piano").clip(1)
+   * note("c a f e").s("piano").clip("<.5 1 2>")
    *
    */
-  ['f', 'clip', ''],
+  ['clip'],
 ];
 
 // TODO: slice / splice https://www.youtube.com/watch?v=hKhPdO0RKDQ&list=PL2lW1zNIIwj3bDkh-Y3LUGDuRcoUigoDs&index=13
 
-const _name = (name, ...pats) => sequence(...pats).withValue((x) => ({ [name]: x }));
+controls.createParam = function (names) {
+  const name = Array.isArray(names) ? names[0] : names;
 
-const _setter = (func, name) =>
-  function (...pats) {
+  var withVal;
+  if (Array.isArray(names)) {
+    withVal = (xs) => {
+      if (Array.isArray(xs)) {
+        const result = {};
+        xs.forEach((x, i) => {
+          if (i < names.length) {
+            result[names[i]] = x;
+          }
+        });
+        return result;
+      } else {
+        return { [name]: xs };
+      }
+    };
+  } else {
+    withVal = (x) => ({ [name]: x });
+  }
+
+  const func = (...pats) => sequence(...pats).withValue(withVal);
+
+  const setter = function (...pats) {
     if (!pats.length) {
-      return this.fmap((value) => ({ [name]: value }));
+      return this.fmap(withVal);
     }
     return this.set(func(...pats));
   };
-
-generic_params.forEach(([type, name, description]) => {
-  controls[name] = (...pats) => _name(name, ...pats);
-  Pattern.prototype[name] = _setter(controls[name], name);
-});
-
-// create custom param
-controls.createParam = (name) => {
-  const func = (...pats) => _name(name, ...pats);
-  Pattern.prototype[name] = _setter(func, name);
-  return (...pats) => _name(name, ...pats);
+  Pattern.prototype[name] = setter;
+  return func;
 };
 
+generic_params.forEach(([names, ...aliases]) => {
+  const name = Array.isArray(names) ? names[0] : names;
+  controls[name] = controls.createParam(names);
+
+  aliases.forEach((alias) => {
+    controls[alias] = controls[name];
+    Pattern.prototype[alias] = Pattern.prototype[name];
+  });
+});
+
 controls.createParams = (...names) =>
   names.reduce((acc, name) => Object.assign(acc, { [name]: controls.createParam(name) }), {});
 
+controls.adsr = register('adsr', (adsr, pat) => {
+  adsr = !Array.isArray(adsr) ? [adsr] : adsr;
+  const [attack, decay, sustain, release] = adsr;
+  return pat.set({ attack, decay, sustain, release });
+});
+controls.ds = register('ds', (ds, pat) => {
+  ds = !Array.isArray(ds) ? [ds] : ds;
+  const [decay, sustain] = ds;
+  return pat.set({ decay, sustain });
+});
+
 export default controls;

packages/core/cyclist.mjs

@@ -74,6 +74,7 @@ export class Cyclist {
   stop() {
     logger('[cyclist] stop');
     this.clock.stop();
+    this.lastEnd = 0;
     this.setStarted(false);
   }
   setPattern(pat, autostart = false) {

packages/core/draw.mjs

@@ -1,6 +1,6 @@
 /*
 draw.mjs - <short description TODO>
-Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/tone/draw.mjs>
+Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/core/draw.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/>.
 */
 
@@ -13,8 +13,16 @@ export const getDrawContext = (id = 'test-canvas') => {
     canvas.id = id;
     canvas.width = window.innerWidth;
     canvas.height = window.innerHeight;
-    canvas.style = 'pointer-events:none;width:100%;height:100%;position:fixed;top:0;left:0;z-index:5';
+    canvas.style = 'pointer-events:none;width:100%;height:100%;position:fixed;top:0;left:0';
     document.body.prepend(canvas);
+    let timeout;
+    window.addEventListener('resize', () => {
+      timeout && clearTimeout(timeout);
+      timeout = setTimeout(() => {
+        canvas.width = window.innerWidth;
+        canvas.height = window.innerHeight;
+      }, 200);
+    });
   }
   return canvas.getContext('2d');
 };
@@ -65,3 +73,97 @@ Pattern.prototype.onPaint = function (onPaint) {
   this.context = { onPaint };
   return this;
 };
+
+// const round = (x) => Math.round(x * 1000) / 1000;
+
+// encapsulates starting and stopping animation frames
+export class Framer {
+  constructor(onFrame, onError) {
+    this.onFrame = onFrame;
+    this.onError = onError;
+  }
+  start() {
+    const self = this;
+    let frame = requestAnimationFrame(function updateHighlights(time) {
+      try {
+        self.onFrame(time);
+      } catch (err) {
+        self.onError(err);
+      }
+      frame = requestAnimationFrame(updateHighlights);
+    });
+    self.cancel = () => {
+      cancelAnimationFrame(frame);
+    };
+  }
+  stop() {
+    if (this.cancel) {
+      this.cancel();
+    }
+  }
+}
+
+// syncs animation frames to a cyclist scheduler
+// see vite-vanilla-repl-cm6 for an example
+export class Drawer {
+  constructor(onDraw, drawTime) {
+    let [lookbehind, lookahead] = drawTime; // e.g. [-2, 2]
+    lookbehind = Math.abs(lookbehind);
+    this.visibleHaps = [];
+    this.lastFrame = null;
+    this.drawTime = drawTime;
+    this.framer = new Framer(
+      () => {
+        if (!this.scheduler) {
+          console.warn('Drawer: no scheduler');
+          return;
+        }
+        // calculate current frame time (think right side of screen for pianoroll)
+        const phase = this.scheduler.now() + lookahead;
+        // first frame just captures the phase
+        if (this.lastFrame === null) {
+          this.lastFrame = phase;
+          return;
+        }
+        // query haps from last frame till now. take last 100ms max
+        const haps = this.scheduler.pattern.queryArc(Math.max(this.lastFrame, phase - 1 / 10), phase);
+        this.lastFrame = phase;
+        this.visibleHaps = (this.visibleHaps || [])
+          // filter out haps that are too far in the past (think left edge of screen for pianoroll)
+          .filter((h) => h.whole.end >= phase - lookbehind - lookahead)
+          // add new haps with onset (think right edge bars scrolling in)
+          .concat(haps.filter((h) => h.hasOnset()));
+        const time = phase - lookahead;
+        onDraw(this.visibleHaps, time, this);
+      },
+      (err) => {
+        console.warn('draw error', err);
+      },
+    );
+  }
+  invalidate(scheduler = this.scheduler) {
+    if (!scheduler) {
+      return;
+    }
+    this.scheduler = scheduler;
+    const t = scheduler.now();
+    let [_, lookahead] = this.drawTime;
+    const [begin, end] = [Math.max(t, 0), t + lookahead + 0.1];
+    // remove all future haps
+    this.visibleHaps = this.visibleHaps.filter((h) => h.whole.begin < t);
+    // query future haps
+    const futureHaps = scheduler.pattern.queryArc(begin, end); // +0.1 = workaround for weird holes in query..
+    // append future haps
+    this.visibleHaps = this.visibleHaps.concat(futureHaps);
+  }
+  start(scheduler) {
+    this.scheduler = scheduler;
+    this.invalidate();
+    this.framer.start();
+  }
+  stop() {
+    if (this.framer) {
+      this.framer.stop();
+    }
+  }
+}

packages/core/evaluate.mjs

@@ -1,6 +1,6 @@
 /*
 evaluate.mjs - <short description TODO>
-Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/eval/evaluate.mjs>
+Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/core/evaluate.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/>.
 */
 
@@ -37,8 +37,12 @@ function safeEval(str, options = {}) {
 }
 
 export const evaluate = async (code, transpiler) => {
+  let meta = {};
   if (transpiler) {
-    code = transpiler(code); // transform syntactically correct js code to semantically usable code
+    // transform syntactically correct js code to semantically usable code
+    const transpiled = transpiler(code);
+    code = transpiled.output;
+    meta = transpiled;
   }
   // if no transpiler is given, we expect a single instruction (!wrapExpression)
   const options = { wrapExpression: !!transpiler };
@@ -48,5 +52,5 @@ export const evaluate = async (code, transpiler) => {
     const message = `got "${typeof evaluated}" instead of pattern`;
     throw new Error(message + (typeof evaluated === 'function' ? ', did you forget to call a function?' : '.'));
   }
-  return { mode: 'javascript', pattern: evaluated };
+  return { mode: 'javascript', pattern: evaluated, meta };
 };

packages/core/examples/vite-vanilla-repl-cm6/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

packages/core/examples/vite-vanilla-repl-cm6/README.md

@@ -0,0 +1,8 @@
+# vite-vanilla-repl-cm6
+
+This folder demonstrates how to set up a strudel repl using vite and vanilla JS + codemirror. Run it using:
+
+```sh
+npm i
+npm run dev
+```

packages/core/examples/vite-vanilla-repl-cm6/index.html

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite Vanilla Strudel REPL</title>
+  </head>
+  <body>
+    <main>
+      <nav>
+        <button id="play">eval</button>
+        <button id="stop">stop</button>
+      </nav>
+      <div class="container">
+        <div id="editor"></div>
+        <div id="output"></div>
+      </div>
+      <canvas id="roll"></canvas>
+    </main>
+    <script type="module" src="./main.js"></script>
+  </body>
+</html>

packages/core/examples/vite-vanilla-repl-cm6/main.js

@@ -0,0 +1,39 @@
+import { StrudelMirror } from '@strudel/codemirror';
+import { funk42 } from './tunes';
+import { drawPianoroll, evalScope, controls } from '@strudel.cycles/core';
+import './style.css';
+import { initAudioOnFirstClick } from '@strudel.cycles/webaudio';
+import { transpiler } from '@strudel.cycles/transpiler';
+import { getAudioContext, webaudioOutput, registerSynthSounds } from '@strudel.cycles/webaudio';
+import { registerSoundfonts } from '@strudel.cycles/soundfonts';
+
+// init canvas
+const canvas = document.getElementById('roll');
+canvas.width = canvas.width * 2;
+canvas.height = canvas.height * 2;
+const drawContext = canvas.getContext('2d');
+const drawTime = [-2, 2]; // time window of drawn haps
+
+const editor = new StrudelMirror({
+  defaultOutput: webaudioOutput,
+  getTime: () => getAudioContext().currentTime,
+  transpiler,
+  root: document.getElementById('editor'),
+  initialCode: funk42,
+  drawTime,
+  onDraw: (haps, time) => drawPianoroll({ haps, time, ctx: drawContext, drawTime, fold: 0 }),
+  prebake: async () => {
+    initAudioOnFirstClick(); // needed to make the browser happy (don't await this here..)
+    const loadModules = evalScope(
+      controls,
+      import('@strudel.cycles/core'),
+      import('@strudel.cycles/mini'),
+      import('@strudel.cycles/tonal'),
+      import('@strudel.cycles/webaudio'),
+    );
+    await Promise.all([loadModules, registerSynthSounds(), registerSoundfonts()]);
+  },
+});
+
+document.getElementById('play').addEventListener('click', () => editor.evaluate());
+document.getElementById('stop').addEventListener('click', () => editor.stop());

packages/core/examples/vite-vanilla-repl-cm6/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "vite-vanilla-repl-cm6",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "devDependencies": {
+    "vite": "^4.3.2"
+  },
+  "dependencies": {
+    "@strudel/codemirror": "workspace:*",
+    "@strudel.cycles/core": "workspace:*",
+    "@strudel.cycles/mini": "workspace:*",
+    "@strudel.cycles/soundfonts": "workspace:*",
+    "@strudel.cycles/tonal": "workspace:*",
+    "@strudel.cycles/transpiler": "workspace:*",
+    "@strudel.cycles/webaudio": "workspace:*"
+  }
+}

packages/core/examples/vite-vanilla-repl-cm6/style.css

@@ -0,0 +1,31 @@
+body,
+html {
+  margin: 0;
+  height: 100%;
+  background: #282c34;
+}
+
+main {
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+}
+
+.container {
+  flex-grow: 1;
+  max-height: 100%;
+  position: relative;
+  overflow: auto;
+}
+
+#editor {
+  overflow: auto;
+}
+
+.cm-editor {
+  height: 100%;
+}
+
+#roll {
+  height: 300px;
+}

packages/core/examples/vite-vanilla-repl-cm6/tunes.mjs

@@ -0,0 +1,112 @@
+export const bumpStreet = `// froos - "22 bump street", licensed with CC BY-NC-SA 4.0
+await samples('github:felixroos/samples/main')
+await samples('https://strudel.tidalcycles.org/tidal-drum-machines.json', 'github:ritchse/tidal-drum-machines/main/machines/')
+
+"<[0,<6 7 9>,13,<17 20 22 26>]!2>/2"
+  // make it 22 edo
+  .fmap(v => Math.pow(2,v/22))
+  // mess with the base frequency
+  .mul("<300 [300@3 200]>/8").freq()
+  .layer(
+    // chords
+    x=>x.div(freq(2)).s("flute").euclidLegato("<3 2>",8)
+      .shape(.4).lpf(sine.range(800,4000).slow(8)),
+    // adlibs
+    x=>x.arp("{0 3 2 [1 3]}%1.5")
+      .s('xylo').mul(freq(2))
+      .delay(.5).delayfeedback(.4).juxBy(.5, rev)
+      .hpf(sine.range(200,3000).slow(8)),
+    // bass
+    x=>x.arp("[0 [2 1?]](5,8)").s('sawtooth').div(freq(4))
+      .lpf(sine.range(400,2000).slow(8)).lpq(8).shape(.4)
+      .off(1/8, x=>x.mul(freq(2)).degradeBy(.5)).gain(.3)
+  ).clip(1).release(.2)
+.stack(
+  // drums
+  s("bd sd:<2 1>, [~ hh]*2, [~ rim]").bank('RolandTR909')
+  .off(1/8, x=>x.speed(2).gain(.4)).sometimes(ply(2)).gain(.8)
+  .mask("<0@4 1@12>/4")
+  .reset("<x@15 [x(3,8) x*[4 8]]>")
+  // wait for it...
+).fast(2/3)
+  //.crush(6) // remove "//" if you dare`;
+
+export const trafficFlam = `// froos - "traffic flam", licensed with CC BY-NC-SA 4.0
+
+await samples('github:felixroos/samples/main')
+await samples('https://strudel.tidalcycles.org/tidal-drum-machines.json', 'github:ritchse/tidal-drum-machines/main/machines/')
+
+addVoicings('hip', {
+  m11: ['2M 3m 4P 7m'],
+  '^7#11': ['3M 4A 5P 7M'],
+}, ['C4', 'C6'])
+
+stack(
+  stack(
+    "<Bbm11 A^7#11>/2".voicings('hip').note()
+    .s("gm_epiano1:2")
+    .arp("[<[0 1 2 3] [3 2 1 0]> ~@5]/2")
+    .release(2).late(.25).lpf(2000),
+    "<Bb1 A1>/2".note().s('gm_acoustic_bass'),
+    n("<0 2 3>(3,8)".off(1/8, add(4)))
+    .scale("<Bb4:minor A4:lydian>/2")
+    .s('gm_electric_guitar_jazz')
+    .decay(sine.range(.05, .2).slow(32)).sustain(0)
+    .delay(.5).lpf(sine.range(100,5000).slow(64))
+    .gain(.7).room(.5).pan(sine.range(0,1).slow(11))
+  ).add(perlin.range(0,.25).note()),
+  stack(
+    s("bd:1(3,8) rim").bank('RolandTR707').slow(2).room("<0 <.1 .6>>")
+    .when("<0@7 1>",x=>x.echoWith(3, .0625, (x,i) => x.speed(1+i*.24))),
+    s("rim*4").end(.05).bank('RolandTR808').speed(.8).room(.2)
+  )
+)
+  .late("[0 .05]*2").late(12)
+
+`;
+
+export const funk42 = `// froos - how to funk in 42 lines of code
+// adapted from "how to funk in two minutes" by marc rebillet https://www.youtube.com/watch?v=3vBwRfQbXkg
+// thanks to peach for the transcription: https://www.youtube.com/watch?v=8eiPXvIgda4
+
+await samples('github:felixroos/samples/main')
+await samples('https://strudel.tidalcycles.org/tidal-drum-machines.json', 'github:ritchse/tidal-drum-machines/main/machines/')
+
+setcps(.5)
+
+let drums = stack(
+  s("bd*2, ~ sd").bank('RolandTR707').room("0 .1"),
+  s("hh*4").begin(.2).release(.02).end(.25).release(.02)
+  .gain(.3).bank('RolandTR707').late(.02).room(.5),
+  //s("shaker_small").struct("[x x*2]*2").speed(".8,.9").release(.02)
+).fast(2)
+
+let wurli = note(\`<
+[[a2,g3,[b3 c4],e4] ~ [g3,c4,e4](3,8)@4 ~@2]!3 
+[[e2,e3,a3,b3,e4]@3 [e2,e3,ab3,b3,e4]@5]>\`)
+  .s("gm_epiano1:5").decay(.2).sustain("<[1 0@7]!3 1>")
+  .gain("<[.8@2 .4@14]!3 .7>").room(.3)
+
+let organ = note("<[~@3 [a3,d4,f#4]@2 [[a3,c4,e4]@2 ~] ~@2]!3 ~>".add(12))
+    .s("gm_percussive_organ:2").gain(.6).lpf(1800).pan(.2).room(.3);
+
+let clav = note(\`<
+[~@3 a2 [g3,[b3 c4],e4]@2 ~ a2 [g3,b3,e4] ~@2 [g3,c4,e4] ~@4]!3
+[~@3 e3 [[a3 b3],c3,e3]@2 ~ e2 [e3,a3]@3 [b3,e3] ~@2 [b3,e3]@2]>\`)
+  .s("gm_clavinet:1").decay("<.25!3 [.25 .4]>").sustain(0)
+  .gain(.7).pan(.8).room(.2);
+
+let bass = note(\`<
+[a1 [~ [g2 a2]] [g1 g#1] [a1 [g2 a2]]] 
+[a1 [~ [g2 a2]] [e3 d3] [c3 [g3 a3]]] 
+[a1 [~ [g2 a2]] [g1 g#1] [a1 [g2 a2]]] 
+[e2@6 e1@5 e1 [[d2 e3] g1]@4]
+>\`).s("gm_electric_bass_pick:1").release(.1)
+
+stack(
+  drums
+  ,wurli
+  ,organ
+  ,clav
+  ,bass
+)`;

packages/core/examples/vite-vanilla-repl/README.md

@@ -6,5 +6,3 @@ This folder demonstrates how to set up a strudel repl using vite and vanilla JS.
 npm i
 npm run dev
 ```
-
-or view it [live on githack](https://rawcdn.githack.com/tidalcycles/strudel/5fb36acb046ead7cd6ad3cd10f532e7f585f536a/packages/core/examples/vite-vanilla-repl/dist/index.html)

packages/core/examples/vite-vanilla-repl/package.json

@@ -10,7 +10,7 @@
     "preview": "vite preview"
   },
   "devDependencies": {
-    "vite": "^3.2.0"
+    "vite": "^4.3.3"
   },
   "dependencies": {
     "@strudel.cycles/core": "workspace:*",

packages/core/hap.mjs

@@ -32,7 +32,11 @@ export class Hap {
   }
 
   get duration() {
-    return this.whole.end.sub(this.whole.begin);
+    return this.whole.end.sub(this.whole.begin).mul(typeof this.value?.clip === 'number' ? this.value?.clip : 1);
+  }
+
+  get endClipped() {
+    return this.whole.begin.add(this.duration);
   }
 
   wholeOrPart() {

packages/core/index.mjs

@@ -18,11 +18,13 @@ export * from './util.mjs';
 export * from './speak.mjs';
 export * from './evaluate.mjs';
 export * from './repl.mjs';
+export * from './cyclist.mjs';
 export * from './logger.mjs';
 export * from './time.mjs';
 export * from './draw.mjs';
 export * from './animate.mjs';
 export * from './pianoroll.mjs';
+export * from './spiral.mjs';
 export * from './ui.mjs';
 export { default as drawLine } from './drawLine.mjs';
 export { default as gist } from './gist.js';

packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel.cycles/core",
-  "version": "0.6.8",
+  "version": "0.8.2",
   "description": "Port of Tidal Cycles to JavaScript",
   "main": "index.mjs",
   "type": "module",
@@ -35,7 +35,7 @@
   },
   "gitHead": "0e26d4e741500f5bae35b023608f062a794905c2",
   "devDependencies": {
-    "vite": "^3.2.2",
-    "vitest": "^0.25.7"
+    "vite": "^4.3.3",
+    "vitest": "^0.33.0"
   }
 }

packages/core/pattern.mjs

@@ -472,15 +472,15 @@ export class Pattern {
   /**
    * Returns a new pattern with the given location information added to the
    * context of every hap.
-   * @param {Number} start
-   * @param {Number} end
+   * @param {Number} start start offset
+   * @param {Number} end end offset
    * @returns Pattern
    * @noAutocomplete
    */
-  withLocation(start, end) {
+  withLoc(start, end) {
     const location = {
-      start: { line: start[0], column: start[1], offset: start[2] },
-      end: { line: end[0], column: end[1], offset: end[2] },
+      start,
+      end,
     };
     return this.withContext((context) => {
       const locations = (context.locations || []).concat([location]);
@@ -488,32 +488,6 @@ export class Pattern {
     });
   }
 
-  withMiniLocation(start, end) {
-    const offset = {
-      start: { line: start[0], column: start[1], offset: start[2] },
-      end: { line: end[0], column: end[1], offset: end[2] },
-    };
-    return this.withContext((context) => {
-      let locations = context.locations || [];
-      locations = locations.map(({ start, end }) => {
-        const colOffset = start.line === 1 ? offset.start.column : 0;
-        return {
-          start: {
-            ...start,
-            line: start.line - 1 + (offset.start.line - 1) + 1,
-            column: start.column - 1 + colOffset,
-          },
-          end: {
-            ...end,
-            line: end.line - 1 + (offset.start.line - 1) + 1,
-            column: end.column - 1 + colOffset,
-          },
-        };
-      });
-      return { ...context, locations };
-    });
-  }
-
   /**
    * Returns a new Pattern, which only returns haps that meet the given test.
    * @param {Function} hap_test - a function which returns false for haps to be removed from the pattern
@@ -809,13 +783,14 @@ export class Pattern {
       hap.setContext({
         ...hap.context,
         onTrigger: (...args) => {
-          if (!dominant && hap.context.onTrigger) {
-            hap.context.onTrigger(...args);
-          }
+          // run previously set trigger, if it exists
+          hap.context.onTrigger?.(...args);
           onTrigger(...args);
         },
-        // we need this to know later if the default trigger should still fire
-        dominantTrigger: dominant,
+        // if dominantTrigger is set to true, the default output (webaudio) will be disabled
+        // when using multiple triggers, you cannot flip this flag to false again!
+        // example: x.csound('CooLSynth').log() as well as x.log().csound('CooLSynth') should work the same
+        dominantTrigger: hap.context.dominantTrigger || dominant,
       }),
     );
   }
@@ -1127,6 +1102,8 @@ function _composeOp(a, b, func) {
 export const polyrhythm = stack;
 export const pr = stack;
 
+export const pm = polymeter;
+
 // methods that create patterns, which are added to patternified Pattern methods
 // TODO: remove? this is only used in old transpiler (shapeshifter)
 Pattern.prototype.factories = {
@@ -1284,6 +1261,20 @@ export function timeCat(...timepats) {
   return stack(...pats);
 }
 
+/**
+ * Allows to arrange multiple patterns together over multiple cycles.
+ * Takes a variable number of arrays with two elements specifying the number of cycles and the pattern to use.
+ *
+ * @return {Pattern}
+ * @example
+ * arrange([4, "<c a f e>(3,8)"],[2, "<g a>(5,8)"]).note()
+ */
+export function arrange(...sections) {
+  const total = sections.reduce((sum, [cycles]) => sum + cycles, 0);
+  sections = sections.map(([cycles, section]) => [cycles, section.fast(cycles)]);
+  return timeCat(...sections).slow(total);
+}
+
 export function fastcat(...pats) {
   return slowcat(...pats)._fast(pats.length);
 }
@@ -1360,11 +1351,6 @@ export function polymeter(...args) {
   return polymeterSteps(0, ...args);
 }
 
-// alias
-export function pm(...args) {
-  polymeter(...args);
-}
-
 export const mask = curry((a, b) => reify(b).mask(a));
 export const struct = curry((a, b) => reify(b).struct(a));
 export const superimpose = curry((a, b) => reify(b).superimpose(...a));
@@ -1415,25 +1401,32 @@ export function register(name, func, patternify = true) {
   const arity = func.length;
   var pfunc; // the patternified function
 
-  pfunc = function (...args) {
-    args = args.map(reify);
-    const pat = args[args.length - 1];
-    if (arity === 1) {
-      return func(pat);
-    }
-    const [left, ...right] = args.slice(0, -1);
-    let mapFn = (...args) => {
-      // make sure to call func with the correct argument count
-      // args.length is expected to be <= arity-1
-      // so we set undefined args explicitly undefined
-      Array(arity - 1)
-        .fill()
-        .map((_, i) => args[i] ?? undefined);
-      return func(...args, pat);
+  if (patternify) {
+    pfunc = function (...args) {
+      args = args.map(reify);
+      const pat = args[args.length - 1];
+      if (arity === 1) {
+        return func(pat);
+      }
+      const [left, ...right] = args.slice(0, -1);
+      let mapFn = (...args) => {
+        // make sure to call func with the correct argument count
+        // args.length is expected to be <= arity-1
+        // so we set undefined args explicitly undefined
+        Array(arity - 1)
+          .fill()
+          .map((_, i) => args[i] ?? undefined);
+        return func(...args, pat);
+      };
+      mapFn = curry(mapFn, null, arity - 1);
+      return right.reduce((acc, p) => acc.appLeft(p), left.fmap(mapFn)).innerJoin();
     };
-    mapFn = curry(mapFn, null, arity - 1);
-    return right.reduce((acc, p) => acc.appLeft(p), left.fmap(mapFn)).innerJoin();
-  };
+  } else {
+    pfunc = function (...args) {
+      args = args.map(reify);
+      return func(...args);
+    };
+  }
 
   Pattern.prototype[name] = function (...args) {
     // For methods that take a single argument (plus 'this'), allow
@@ -1564,6 +1557,24 @@ export const range2 = register('range2', function (min, max, pat) {
   return pat.fromBipolar()._range(min, max);
 });
 
+/**
+ * Allows dividing numbers via list notation using ":".
+ * Returns a new pattern with just numbers.
+ * @name ratio
+ * @memberof Pattern
+ * @returns Pattern
+ * @example
+ * ratio("1, 5:4, 3:2").mul(110).freq().s("piano").slow(2)
+ */
+export const ratio = register('ratio', (pat) =>
+  pat.fmap((v) => {
+    if (!Array.isArray(v)) {
+      return v;
+    }
+    return v.slice(1).reduce((acc, n) => acc / n, v[0]);
+  }),
+);
+
 //////////////////////////////////////////////////////////////////////
 // Structural and temporal transformations
 
@@ -1659,6 +1670,9 @@ export const ply = register('ply', function (factor, pat) {
  * s("<bd sd> hh").fast(2) // s("[<bd sd> hh]*2")
  */
 export const { fast, density } = register(['fast', 'density'], function (factor, pat) {
+  if (factor === 0) {
+    return silence;
+  }
   factor = Fraction(factor);
   const fastQuery = pat.withQueryTime((t) => t.mul(factor));
   return fastQuery.withHapTime((t) => t.div(factor));
@@ -1685,6 +1699,9 @@ export const hurry = register('hurry', function (r, pat) {
  * s("<bd sd> hh").slow(2) // s("[<bd sd> hh]/2")
  */
 export const { slow, sparsity } = register(['slow', 'sparsity'], function (factor, pat) {
+  if (factor === 0) {
+    return silence;
+  }
   return pat._fast(Fraction(1).div(factor));
 });
 
@@ -2011,7 +2028,7 @@ export const jux = register('jux', function (func, pat) {
  * @example
  * "<0 [2 4]>"
  * .echoWith(4, 1/8, (p,n) => p.add(n*2))
- * .scale('C minor').note().legato(.2)
+ * .scale('C minor').note().clip(.2)
  */
 export const { echoWith, echowith, stutWith, stutwith } = register(
   ['echoWith', 'echowith', 'stutWith', 'stutwith'],
@@ -2161,6 +2178,7 @@ export const velocity = register('velocity', function (velocity, pat) {
 /**
  *
  * Multiplies the hap duration with the given factor.
+ * With samples, `clip` might be a better function to use ([more info](https://github.com/tidalcycles/strudel/pull/598))
  * @name legato
  * @memberof Pattern
  * @example
@@ -2223,32 +2241,37 @@ const _loopAt = function (factor, pat, cps = 1) {
     .slow(factor);
 };
 
-/*
+/**
  * 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
  * @memberof Pattern
  * @returns Pattern
  * @example
  * await samples('github:tidalcycles/Dirt-Samples/master')
  * s("breaks165").slice(8, "0 1 <2 2*2> 3 [4 0] 5 6 7".every(3, rev)).slow(1.5)
-const slice = register(
+ * @example
+ * await samples('github:tidalcycles/Dirt-Samples/master')
+ * s("breaks125/2").fit().slice([0,.25,.5,.75], "0 1 1 <2 3>")
+ */
+
+export const slice = register(
   'slice',
   function (npat, ipat, opat) {
     return npat.innerBind((n) =>
-    ipat.outerBind((i) =>
+      ipat.outerBind((i) =>
         opat.outerBind((o) => {
           // If it's not an object, assume it's a string and make it a 's' control parameter
           o = o instanceof Object ? o : { s: o };
-          // Remember we must stay pure and avoid editing the object directly
-          const toAdd = { begin: i / n, end: (i + 1) / n, _slices: n };
-          return pure({ ...toAdd, ...o });
+          const begin = Array.isArray(n) ? n[i] : i / n;
+          const end = Array.isArray(n) ? n[i + 1] : (i + 1) / n;
+          return pure({ begin, end, _slices: n, ...o });
         }),
       ),
     );
   },
   false, // turns off auto-patternification
 );
-*/
 
 /*
  * Works the same as slice, but changes the playback speed of each slice to match the duration of its step.
@@ -2258,7 +2281,9 @@ const slice = register(
  * @example
  * await samples('github:tidalcycles/Dirt-Samples/master')
  * s("breaks165").splice(8,  "0 1 [2 3 0]@2 3 0@2 7").hurry(0.65)
-const splice = register(
+ */
+
+export const splice = register(
   'splice',
   function (npat, ipat, opat) {
     const sliced = slice(npat, ipat, opat);
@@ -2273,13 +2298,28 @@ const splice = register(
     });
   },
   false, // turns off auto-patternification
-  );
-  */
+);
 
-const { loopAt, loopat } = register(['loopAt', 'loopat'], function (factor, pat) {
+// this function will be redefined in repl.mjs to use the correct cps value.
+// It is still here to work in cases where repl.mjs is not used
+
+export const { loopAt, loopat } = register(['loopAt', 'loopat'], function (factor, pat) {
   return _loopAt(factor, pat, 1);
 });
 
+// this function will be redefined in repl.mjs to use the correct cps value.
+// It is still here to work in cases where repl.mjs is not used
+
+export const fit = register('fit', (pat) =>
+  pat.withHap((hap) =>
+    hap.withValue((v) => ({
+      ...v,
+      speed: 1 / hap.whole.duration,
+      unit: 'c',
+    })),
+  ),
+);
+
 /**
  * Makes the sample fit the given number of cycles and cps value, by
  * changing the speed. Please note that at some point cps will be
@@ -2293,6 +2333,6 @@ const { loopAt, loopat } = register(['loopAt', 'loopat'], function (factor, pat)
  * s("rhodes").loopAtCps(4,1.5).cps(1.5)
  */
 // TODO - global cps clock
-const { loopAtCps, loopatcps } = register(['loopAtCps', 'loopatcps'], function (factor, cps, pat) {
+export const { loopAtCps, loopatcps } = register(['loopAtCps', 'loopatcps'], function (factor, cps, pat) {
   return _loopAt(factor, pat, cps);
 });

packages/core/pianoroll.mjs

@@ -1,10 +1,10 @@
 /*
 pianoroll.mjs - <short description TODO>
-Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/tone/pianoroll.mjs>
+Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/core/pianoroll.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 { Pattern, toMidi, getDrawContext, freqToMidi, isNote } from './index.mjs';
+import { Pattern, noteToMidi, getDrawContext, freqToMidi, isNote } from './index.mjs';
 
 const scale = (normalized, min, max) => normalized * (max - min) + min;
 const getValue = (e) => {
@@ -18,7 +18,7 @@ const getValue = (e) => {
   }
   note = note ?? n;
   if (typeof note === 'string') {
-    return toMidi(note);
+    return noteToMidi(note);
   }
   if (typeof note === 'number') {
     return note;
@@ -50,6 +50,7 @@ Pattern.prototype.pianoroll = function ({
   timeframe: timeframeProp,
   fold = 0,
   vertical = 0,
+  labels = 0,
 } = {}) {
   const ctx = getDrawContext();
   const w = ctx.canvas.width;
@@ -82,12 +83,12 @@ Pattern.prototype.pianoroll = function ({
         ctx.fillRect(0, 0, w, h);
       }
       const inFrame = (event) =>
-        (!hideNegative || event.whole.begin >= 0) && event.whole.begin <= t + to && event.whole.end >= t + from;
+        (!hideNegative || event.whole.begin >= 0) && event.whole.begin <= t + to && event.endClipped >= t + from;
       events.filter(inFrame).forEach((event) => {
-        const isActive = event.whole.begin <= t && event.whole.end > t;
+        const isActive = event.whole.begin <= t && event.endClipped > t;
         ctx.fillStyle = event.context?.color || inactive;
         ctx.strokeStyle = event.context?.color || active;
-        ctx.globalAlpha = event.context.velocity ?? 1;
+        ctx.globalAlpha = event.context.velocity ?? event.value?.gain ?? 1;
         const timePx = scale((event.whole.begin - (flipTime ? to : from)) / timeExtent, ...timeRange);
         let durationPx = scale(event.duration / timeExtent, 0, timeAxis);
         const value = getValue(event);
@@ -114,6 +115,14 @@ Pattern.prototype.pianoroll = function ({
           ];
         }
         isActive ? ctx.strokeRect(...coords) : ctx.fillRect(...coords);
+        if (labels) {
+          const label = event.value.note ?? event.value.s + (event.value.n ? `:${event.value.n}` : '');
+          ctx.font = `${barThickness * 0.75}px monospace`;
+          ctx.strokeStyle = 'black';
+          ctx.fillStyle = isActive ? 'white' : 'black';
+          ctx.textBaseline = 'top';
+          ctx.fillText(label, ...coords);
+        }
       });
       ctx.globalAlpha = 1; // reset!
       const playheadPosition = scale(-from / timeExtent, ...timeRange);
@@ -181,6 +190,7 @@ export function pianoroll({
   timeframe: timeframeProp,
   fold = 0,
   vertical = 0,
+  labels = false,
   ctx,
 } = {}) {
   const w = ctx.canvas.width;
@@ -236,11 +246,11 @@ export function pianoroll({
   haps
     // .filter(inFrame)
     .forEach((event) => {
-      const isActive = event.whole.begin <= time && event.whole.end > time;
+      const isActive = event.whole.begin <= time && event.endClipped > time;
       const color = event.value?.color || event.context?.color;
       ctx.fillStyle = color || inactive;
       ctx.strokeStyle = color || active;
-      ctx.globalAlpha = event.context.velocity ?? 1;
+      ctx.globalAlpha = event.context.velocity ?? event.value?.gain ?? 1;
       const timePx = scale((event.whole.begin - (flipTime ? to : from)) / timeExtent, ...timeRange);
       let durationPx = scale(event.duration / timeExtent, 0, timeAxis);
       const value = getValue(event);
@@ -267,6 +277,14 @@ export function pianoroll({
         ];
       }
       isActive ? ctx.strokeRect(...coords) : ctx.fillRect(...coords);
+      if (labels) {
+        const label = event.value.note ?? event.value.s + (event.value.n ? `:${event.value.n}` : '');
+        ctx.font = `${barThickness * 0.75}px monospace`;
+        ctx.strokeStyle = 'black';
+        ctx.fillStyle = isActive ? 'white' : 'black';
+        ctx.textBaseline = 'top';
+        ctx.fillText(label, ...coords);
+      }
     });
   ctx.globalAlpha = 1; // reset!
   const playheadPosition = scale(-from / timeExtent, ...timeRange);
@@ -284,7 +302,7 @@ export function pianoroll({
   return this;
 }
 
-function getOptions(drawTime, options = {}) {
+export function getDrawOptions(drawTime, options = {}) {
   let [lookbehind, lookahead] = drawTime;
   lookbehind = Math.abs(lookbehind);
   const cycles = lookahead + lookbehind;
@@ -293,5 +311,18 @@ function getOptions(drawTime, options = {}) {
 }
 
 Pattern.prototype.punchcard = function (options) {
-  return this.onPaint((ctx, time, haps, drawTime) => pianoroll({ ctx, time, haps, ...getOptions(drawTime, options) }));
+  return this.onPaint((ctx, time, haps, drawTime) =>
+    pianoroll({ ctx, time, haps, ...getDrawOptions(drawTime, options) }),
+  );
 };
+
+/* Pattern.prototype.pianoroll = function (options) {
+  return this.onPaint((ctx, time, haps, drawTime) =>
+    pianoroll({ ctx, time, haps, ...getDrawOptions(drawTime, { fold: 0, ...options }) }),
+  );
+}; */
+
+export function drawPianoroll(options) {
+  const { drawTime, ...rest } = options;
+  pianoroll({ ...getDrawOptions(drawTime), ...rest });
+}

packages/core/repl.mjs

@@ -3,6 +3,7 @@ import { evaluate as _evaluate } from './evaluate.mjs';
 import { logger } from './logger.mjs';
 import { setTime } from './time.mjs';
 import { evalScope } from './evaluate.mjs';
+import { register } from './pattern.mjs';
 
 export function repl({
   interval,
@@ -18,47 +19,26 @@ export function repl({
 }) {
   const scheduler = new Cyclist({
     interval,
-    onTrigger: async (hap, deadline, duration, cps) => {
-      try {
-        if (!hap.context.onTrigger || !hap.context.dominantTrigger) {
-          await defaultOutput(hap, deadline, duration);
-        }
-        if (hap.context.onTrigger) {
-          // call signature of output / onTrigger is different...
-          await hap.context.onTrigger(getTime() + deadline, hap, getTime(), cps);
-        }
-      } catch (err) {
-        logger(`[cyclist] error: ${err.message}`, 'error');
-      }
-    },
+    onTrigger: getTrigger({ defaultOutput, getTime }),
     onError: onSchedulerError,
     getTime,
     onToggle,
   });
+  const setPattern = (pattern, autostart = true) => {
+    pattern = editPattern?.(pattern) || pattern;
+    scheduler.setPattern(pattern, autostart);
+  };
   setTime(() => scheduler.now()); // TODO: refactor?
   const evaluate = async (code, autostart = true) => {
     if (!code) {
       throw new Error('no code to evaluate');
     }
     try {
-      beforeEval?.({ code });
-      scheduler.setCps(1); // reset cps in case the code does not contain a setCps call
-      // problem: when the code does contain a setCps after an awaited promise,
-      // the cps will be 1 until the promise resolves
-      // example:
-      /*
-      await new Promise(resolve => setTimeout(resolve,1000))
-      setCps(.5)
-      note("c a f e")
-      */
-      // to make sure the setCps inside the code is called immediately,
-      // it has to be placed first
-      let { pattern } = await _evaluate(code, transpiler);
-
+      await beforeEval?.({ code });
+      let { pattern, meta } = await _evaluate(code, transpiler);
       logger(`[eval] code updated`);
-      pattern = editPattern?.(pattern) || pattern;
-      scheduler.setPattern(pattern, autostart);
-      afterEval?.({ code, pattern });
+      setPattern(pattern, autostart);
+      afterEval?.({ code, pattern, meta });
       return pattern;
     } catch (err) {
       // console.warn(`[repl] eval error: ${err.message}`);
@@ -70,9 +50,47 @@ export function repl({
   const start = () => scheduler.start();
   const pause = () => scheduler.pause();
   const setCps = (cps) => scheduler.setCps(cps);
+  const setCpm = (cpm) => scheduler.setCps(cpm / 60);
+
+  // the following functions use the cps value, which is why they are defined here..
+  const loopAt = register('loopAt', (cycles, pat) => {
+    return pat.loopAtCps(cycles, scheduler.cps);
+  });
+
+  const fit = register('fit', (pat) =>
+    pat.withHap((hap) =>
+      hap.withValue((v) => ({
+        ...v,
+        speed: scheduler.cps / hap.whole.duration, // overwrite speed completely?
+        unit: 'c',
+      })),
+    ),
+  );
+
   evalScope({
+    loopAt,
+    fit,
     setCps,
     setcps: setCps,
+    setCpm,
+    setcpm: setCpm,
   });
-  return { scheduler, evaluate, start, stop, pause, setCps };
+
+  return { scheduler, evaluate, start, stop, pause, setCps, setPattern };
 }
+
+export const getTrigger =
+  ({ getTime, defaultOutput }) =>
+  async (hap, deadline, duration, cps) => {
+    try {
+      if (!hap.context.onTrigger || !hap.context.dominantTrigger) {
+        await defaultOutput(hap, deadline, duration, cps);
+      }
+      if (hap.context.onTrigger) {
+        // call signature of output / onTrigger is different...
+        await hap.context.onTrigger(getTime() + deadline, hap, getTime(), cps);
+      }
+    } catch (err) {
+      logger(`[cyclist] error: ${err.message}`, 'error');
+    }
+  };

packages/core/signal.mjs

@@ -27,7 +27,7 @@ export const isaw2 = isaw.toBipolar();
  *
  * @return {Pattern}
  * @example
- * "c3 [eb3,g3] g2 [g3,bb3]".legato(saw.slow(4)).note()
+ * "c3 [eb3,g3] g2 [g3,bb3]".note().clip(saw.slow(4))
  * @example
  * saw.range(0,8).segment(8).scale('C major').slow(4).note()
  *
@@ -191,13 +191,6 @@ export const chooseInWith = (pat, xs) => {
  */
 export const choose = (...xs) => chooseWith(rand, xs);
 
-/**
- * Chooses from the given list of values (or patterns of values), according
- * to the pattern that the method is called on. The pattern should be in
- * the range 0 .. 1.
- * @param  {...any} xs
- * @returns {Pattern}
- */
 Pattern.prototype.choose = function (...xs) {
   return chooseWith(this, xs);
 };

packages/core/spiral.mjs

@@ -0,0 +1,118 @@
+import { Pattern } from './index.mjs';
+
+// polar coords -> xy
+function fromPolar(angle, radius, cx, cy) {
+  const radians = ((angle - 90) * Math.PI) / 180;
+  return [cx + Math.cos(radians) * radius, cy + Math.sin(radians) * radius];
+}
+
+const xyOnSpiral = (angle, margin, cx, cy, rotate = 0) => fromPolar((angle + rotate) * 360, margin * angle, cx, cy); // TODO: logSpiral
+
+// draw spiral / segment of spiral
+function spiralSegment(options) {
+  let {
+    ctx,
+    from = 0,
+    to = 3,
+    margin = 50,
+    cx = 100,
+    cy = 100,
+    rotate = 0,
+    thickness = margin / 2,
+    color = '#0000ff30',
+    cap = 'round',
+    stretch = 1,
+    fromOpacity = 1,
+    toOpacity = 1,
+  } = options;
+  from *= stretch;
+  to *= stretch;
+  rotate *= stretch;
+  ctx.lineWidth = thickness;
+  ctx.lineCap = cap;
+  ctx.strokeStyle = color;
+  ctx.globalAlpha = fromOpacity;
+
+  ctx.beginPath();
+  let [sx, sy] = xyOnSpiral(from, margin, cx, cy, rotate);
+  ctx.moveTo(sx, sy);
+
+  const increment = 1 / 60;
+  let angle = from;
+  while (angle <= to) {
+    const [x, y] = xyOnSpiral(angle, margin, cx, cy, rotate);
+    //ctx.lineWidth = angle*thickness;
+    ctx.globalAlpha = ((angle - from) / (to - from)) * toOpacity;
+    ctx.lineTo(x, y);
+    angle += increment;
+  }
+  ctx.stroke();
+}
+
+Pattern.prototype.spiral = function (options = {}) {
+  const {
+    stretch = 1,
+    size = 80,
+    thickness = size / 2,
+    cap = 'butt', // round butt squar,
+    inset = 3, // start angl,
+    playheadColor = '#ffffff90',
+    playheadLength = 0.02,
+    playheadThickness = thickness,
+    padding = 0,
+    steady = 1,
+    inactiveColor = '#ffffff20',
+    colorizeInactive = 0,
+    fade = true,
+    // logSpiral = true,
+  } = options;
+
+  function spiral({ ctx, time, haps, drawTime }) {
+    const [w, h] = [ctx.canvas.width, ctx.canvas.height];
+    ctx.clearRect(0, 0, w * 2, h * 2);
+    const [cx, cy] = [w / 2, h / 2];
+    const settings = {
+      margin: size / stretch,
+      cx,
+      cy,
+      stretch,
+      cap,
+      thickness,
+    };
+
+    const playhead = {
+      ...settings,
+      thickness: playheadThickness,
+      from: inset - playheadLength,
+      to: inset,
+      color: playheadColor,
+    };
+
+    const [min] = drawTime;
+    const rotate = steady * time;
+    haps.forEach((hap) => {
+      const isActive = hap.whole.begin <= time && hap.endClipped > time;
+      const from = hap.whole.begin - time + inset;
+      const to = hap.endClipped - time + inset - padding;
+      const { color } = hap.context;
+      const opacity = fade ? 1 - Math.abs((hap.whole.begin - time) / min) : 1;
+      spiralSegment({
+        ctx,
+        ...settings,
+        from,
+        to,
+        rotate,
+        color: colorizeInactive || isActive ? color : inactiveColor,
+        fromOpacity: opacity,
+        toOpacity: opacity,
+      });
+    });
+    spiralSegment({
+      ctx,
+      ...playhead,
+      rotate,
+    });
+  }
+
+  return this.onPaint((ctx, time, haps, drawTime) => spiral({ ctx, time, haps, drawTime }));
+};

packages/core/test/controls.test.mjs

@@ -0,0 +1,28 @@
+/*
+controls.test.mjs - <short description TODO>
+Copyright (C) 2023 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/core/test/controls.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 controls from '../controls.mjs';
+import { mini } from '../../mini/mini.mjs';
+import { describe, it, expect } from 'vitest';
+
+describe('controls', () => {
+  it('should support controls', () => {
+    expect(controls.s('bd').firstCycleValues).toEqual([{ s: 'bd' }]);
+  });
+  it('should support compound controls', () => {
+    expect(controls.s(mini('bd:3')).firstCycleValues).toEqual([{ s: 'bd', n: 3 }]);
+    expect(controls.s(mini('bd:3 sd:4:1.4')).firstCycleValues).toEqual([
+      { s: 'bd', n: 3 },
+      { s: 'sd', n: 4, gain: 1.4 },
+    ]);
+  });
+  it('should support ignore extra elements in compound controls', () => {
+    expect(controls.s(mini('bd:3:0.4 sd:4:0.5:3:17')).firstCycleValues).toEqual([
+      { s: 'bd', n: 3, gain: 0.4 },
+      { s: 'sd', n: 4, gain: 0.5 },
+    ]);
+  });
+});

packages/core/test/pattern.test.mjs

@@ -976,6 +976,7 @@ describe('Pattern', () => {
       sameFirst(n(0, 1).weave(2, s('bd', silence), s(silence, 'sd')), sequence(s('bd').n(0), s('sd').n(1)));
     });
   });
+  */
   describe('slice', () => {
     it('Can slice a sample', () => {
       sameFirst(
@@ -1001,5 +1002,5 @@ describe('Pattern', () => {
         ),
       );
     });
-  });*/
+  });
 });

packages/core/test/solmization.test.js

@@ -0,0 +1,40 @@
+/*test for issue 302 support alternative solmization types */
+import { sol2note } from '../util.mjs';
+import { test } from 'vitest';
+import assert from 'assert';
+
+test('solmization - letters', () => {
+  const result = sol2note(60, 'letters');
+  const expected = 'C4';
+  assert.equal(result, expected);
+});
+
+test('solmization - solfeggio', () => {
+  const result = sol2note(60, 'solfeggio');
+  const expected = 'Do4';
+  assert.equal(result, expected);
+});
+
+test('solmization - indian', () => {
+  const result = sol2note(60, 'indian');
+  const expected = 'Sa4';
+  assert.equal(result, expected);
+});
+
+test('solmization - german', () => {
+  const result = sol2note(60, 'german');
+  const expected = 'C4';
+  assert.equal(result, expected);
+});
+
+test('solmization - byzantine', () => {
+  const result = sol2note(60, 'byzantine');
+  const expected = 'Ni4';
+  assert.equal(result, expected);
+});
+
+test('solmization - japanese', () => {
+  const result = sol2note(60, 'japanese');
+  const expected = 'I4';
+  assert.equal(result, expected);
+});

packages/core/test/util.test.mjs

@@ -8,8 +8,8 @@ import { pure } from '../pattern.mjs';
 import {
   isNote,
   tokenizeNote,
-  toMidi,
-  fromMidi,
+  noteToMidi,
+  midiToFreq,
   freqToMidi,
   _mod,
   compose,
@@ -75,27 +75,27 @@ describe('isNote', () => {
     expect(tokenizeNote(123)).toStrictEqual([]);
   });
 });
-describe('toMidi', () => {
+describe('noteToMidi', () => {
   it('should turn notes into midi', () => {
-    expect(toMidi('A4')).toEqual(69);
-    expect(toMidi('C4')).toEqual(60);
-    expect(toMidi('Db4')).toEqual(61);
-    expect(toMidi('C3')).toEqual(48);
-    expect(toMidi('Cb3')).toEqual(47);
-    expect(toMidi('Cbb3')).toEqual(46);
-    expect(toMidi('C#3')).toEqual(49);
-    expect(toMidi('C#3')).toEqual(49);
-    expect(toMidi('C##3')).toEqual(50);
+    expect(noteToMidi('A4')).toEqual(69);
+    expect(noteToMidi('C4')).toEqual(60);
+    expect(noteToMidi('Db4')).toEqual(61);
+    expect(noteToMidi('C3')).toEqual(48);
+    expect(noteToMidi('Cb3')).toEqual(47);
+    expect(noteToMidi('Cbb3')).toEqual(46);
+    expect(noteToMidi('C#3')).toEqual(49);
+    expect(noteToMidi('C#3')).toEqual(49);
+    expect(noteToMidi('C##3')).toEqual(50);
   });
   it('should throw an error when given a non-note', () => {
-    expect(() => toMidi('Q')).toThrowError(`not a note: "Q"`);
-    expect(() => toMidi('Z')).toThrowError(`not a note: "Z"`);
+    expect(() => noteToMidi('Q')).toThrowError(`not a note: "Q"`);
+    expect(() => noteToMidi('Z')).toThrowError(`not a note: "Z"`);
   });
 });
-describe('fromMidi', () => {
+describe('midiToFreq', () => {
   it('should turn midi into frequency', () => {
-    expect(fromMidi(69)).toEqual(440);
-    expect(fromMidi(57)).toEqual(220);
+    expect(midiToFreq(69)).toEqual(440);
+    expect(midiToFreq(57)).toEqual(220);
   });
 });
 describe('freqToMidi', () => {

packages/core/ui.mjs

@@ -1,6 +1,6 @@
 /*
 ui.mjs - <short description TODO>
-Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/tone/ui.mjs>
+Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/core/ui.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/>.
 */
 

packages/core/util.mjs

@@ -6,29 +6,32 @@ This program is free software: you can redistribute it and/or modify it under th
 
 // returns true if the given string is a note
 export const isNoteWithOctave = (name) => /^[a-gA-G][#bs]*[0-9]$/.test(name);
-export const isNote = (name) => /^[a-gA-G][#bs]*[0-9]?$/.test(name);
+export const isNote = (name) => /^[a-gA-G][#bsf]*[0-9]?$/.test(name);
 export const tokenizeNote = (note) => {
   if (typeof note !== 'string') {
     return [];
   }
-  const [pc, acc = '', oct] = note.match(/^([a-gA-G])([#bs]*)([0-9])?$/)?.slice(1) || [];
+  const [pc, acc = '', oct] = note.match(/^([a-gA-G])([#bsf]*)([0-9]*)$/)?.slice(1) || [];
   if (!pc) {
     return [];
   }
   return [pc, acc, oct ? Number(oct) : undefined];
 };
 
+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 };
+
 // turns the given note into its midi number representation
-export const toMidi = (note) => {
-  const [pc, acc, oct = 3] = tokenizeNote(note);
+export const noteToMidi = (note, defaultOctave = 3) => {
+  const [pc, acc, oct = defaultOctave] = tokenizeNote(note);
   if (!pc) {
     throw new Error('not a note: "' + note + '"');
   }
-  const chroma = { c: 0, d: 2, e: 4, f: 5, g: 7, a: 9, b: 11 }[pc.toLowerCase()];
-  const offset = acc?.split('').reduce((o, char) => o + { '#': 1, b: -1, s: 1 }[char], 0) || 0;
+  const chroma = chromas[pc.toLowerCase()];
+  const offset = acc?.split('').reduce((o, char) => o + accs[char], 0) || 0;
   return (Number(oct) + 1) * 12 + chroma + offset;
 };
-export const fromMidi = (n) => {
+export const midiToFreq = (n) => {
   return Math.pow(2, (n - 69) / 12) * 440;
 };
 
@@ -45,7 +48,7 @@ export const valueToMidi = (value, fallbackValue) => {
     return freqToMidi(freq);
   }
   if (typeof note === 'string') {
-    return toMidi(note);
+    return noteToMidi(note);
   }
   if (typeof note === 'number') {
     return note;
@@ -62,18 +65,19 @@ export const valueToMidi = (value, fallbackValue) => {
  */
 export const getFreq = (noteOrMidi) => {
   if (typeof noteOrMidi === 'number') {
-    return fromMidi(noteOrMidi);
+    return midiToFreq(noteOrMidi);
   }
-  return fromMidi(toMidi(noteOrMidi));
+  return midiToFreq(noteToMidi(noteOrMidi));
 };
 
+const pcs = ['C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B'];
 /**
- * @deprecated does not appear to be referenced or invoked anywhere in the codebase
+ * @deprecated only used in workshop (first-notes)
  * @noAutocomplete
  */
 export const midi2note = (n) => {
   const oct = Math.floor(n / 12) - 1;
-  const pc = ['C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B'][n % 12];
+  const pc = pcs[n % 12];
   return pc + oct;
 };
 
@@ -91,7 +95,7 @@ export const getPlayableNoteValue = (hap) => {
   }
   // if value is number => interpret as midi number as long as its not marked as frequency
   if (typeof note === 'number' && context.type !== 'frequency') {
-    note = fromMidi(hap.value);
+    note = midiToFreq(hap.value);
   } else if (typeof note === 'number' && context.type === 'frequency') {
     note = hap.value; // legacy workaround.. will be removed in the future
   } else if (typeof note !== 'string' || !isNote(note)) {
@@ -110,9 +114,9 @@ export const getFrequency = (hap) => {
     return getFreq(value.note || value.n || value.value);
   }
   if (typeof value === 'number' && context.type !== 'frequency') {
-    value = fromMidi(hap.value);
+    value = midiToFreq(hap.value);
   } else if (typeof value === 'string' && isNote(value)) {
-    value = fromMidi(toMidi(hap.value));
+    value = midiToFreq(noteToMidi(hap.value));
   } else if (typeof value !== 'number') {
     throw new Error('not a note or frequency: ' + value);
   }
@@ -170,7 +174,7 @@ export function parseNumeral(numOrString) {
     return asNumber;
   }
   if (isNote(numOrString)) {
-    return toMidi(numOrString);
+    return noteToMidi(numOrString);
   }
   throw new Error(`cannot parse as numeral: "${numOrString}"`);
 }
@@ -212,3 +216,61 @@ export const splitAt = function (index, value) {
 };
 
 export const zipWith = (f, xs, ys) => xs.map((n, i) => f(n, ys[i]));
+
+export const clamp = (num, min, max) => Math.min(Math.max(num, min), max);
+
+/* solmization, not used yet */
+const solfeggio = ['Do', 'Reb', 'Re', 'Mib', 'Mi', 'Fa', 'Solb', 'Sol', 'Lab', 'La', 'Sib', 'Si']; /*solffegio notes*/
+const indian = [
+  'Sa',
+  'Re',
+  'Ga',
+  'Ma',
+  'Pa',
+  'Dha',
+  'Ni',
+]; /*indian musical notes,  seems like they do not use flats or sharps*/
+const german = ['C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'Ab', 'A', 'Hb', 'H']; /*german & dutch musical notes*/
+const byzantine = [
+  'Ni',
+  'Pab',
+  'Pa',
+  'Voub',
+  'Vou',
+  'Ga',
+  'Dib',
+  'Di',
+  'Keb',
+  'Ke',
+  'Zob',
+  'Zo',
+]; /*byzantine musical notes*/
+const japanese = [
+  'I',
+  'Ro',
+  'Ha',
+  'Ni',
+  'Ho',
+  'He',
+  'To',
+]; /*traditional japanese musical notes, seems like they do not use falts or sharps*/
+
+const english = ['C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B'];
+
+export const sol2note = (n, notation = 'letters') => {
+  const pc =
+    notation === 'solfeggio'
+      ? solfeggio /*check if its is any of the following*/
+      : notation === 'indian'
+      ? indian
+      : notation === 'german'
+      ? german
+      : notation === 'byzantine'
+      ? byzantine
+      : notation === 'japanese'
+      ? japanese
+      : english; /*if not use standard version*/
+  const note = pc[n % 12]; /*calculating the midi value to the note*/
+  const oct = Math.floor(n / 12) - 1;
+  return note + oct;
+};

packages/csound/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel.cycles/csound",
-  "version": "0.6.2",
+  "version": "0.8.0",
   "description": "csound bindings for strudel",
   "main": "index.mjs",
   "publishConfig": {
@@ -32,11 +32,11 @@
   },
   "homepage": "https://github.com/tidalcycles/strudel#readme",
   "dependencies": {
-    "@csound/browser": "6.18.5",
+    "@csound/browser": "6.18.7",
     "@strudel.cycles/core": "workspace:*",
     "@strudel.cycles/webaudio": "workspace:*"
   },
   "devDependencies": {
-    "vite": "^3.2.2"
+    "vite": "^4.3.3"
   }
 }

packages/eval/.gitignore

@@ -1,3 +0,0 @@
-shift-parser
-shift-reducer
-!shift-traverser

packages/eval/README.md

@@ -1,50 +0,0 @@
-# @strudel.cycles/eval
-
-This package contains the strudel code transformer and evaluator.
-It allows creating strudel patterns from input code that is optimized for minimal keystrokes and human readability.
-
-## Deprecation Note
-
-This package will not be developed further. Consider using `@strudel.cycles/transpiler` as a replacement.
-
-## Install
-
-```sh
-npm i @strudel.cycles/eval --save
-```
-
-## Example
-
-```js
-import { evalScope } from '@strudel.cycles/core';
-import { evaluate } from '@strudel.cycles/eval';
-
-evalScope(
-  import('@strudel.cycles/core'),
-  // import other strudel packages here
-); // add strudel to eval scope
-
-async function run(code) {
-  const { pattern } = await evaluate(code);
-  const events = pattern.firstCycle();
-  console.log(events.map((e) => e.show()).join('\n'));
-}
-
-run('sequence([a3, [b3, c4]])');
-```
-
-yields:
-
-```js
-(0/1 -> 1/2, 0/1 -> 1/2, a3)
-(1/2 -> 3/4, 1/2 -> 3/4, b3)
-(3/4 -> 1/1, 3/4 -> 1/1, c4)
-```
-
-[play with @strudel.cycles/eval on codesandbox](https://codesandbox.io/s/strudel-eval-example-ndz1d8?file=/src/index.js)
-
-## Dev Notes
-
-shift-traverser is currently monkey patched because its package.json uses estraverse@^4.2.0,
-which does not support the spread operator (Error: Unknown node type SpreadProperty.).
-By monkey patched, I mean I copied the source of shift-traverser to a subfolder and installed the dependencies (shift-spec + estraverse@^5.3.0)

packages/eval/evaluate.mjs

@@ -1,12 +0,0 @@
-/*
-evaluate.mjs - <short description TODO>
-Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/eval/evaluate.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.cycles/core';
-import shapeshifter from './shapeshifter.mjs';
-
-export const evaluate = async (code) => {
-  return _evaluate(code, shapeshifter);
-};

packages/eval/index.mjs

@@ -1 +0,0 @@
-export * from './evaluate.mjs';

packages/eval/shapeshifter.mjs

@@ -1,296 +0,0 @@
-/*
-shapeshifter.mjs - <short description TODO>
-Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/eval/shapeshifter.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 { parseScriptWithLocation } from './shift-parser/index.js'; // npm module does not work in the browser
-import traverser from './shift-traverser/index.js'; // npm module does not work in the browser */
-import { parseScriptWithLocation } from 'shift-parser';
-import traverser from './shift-traverser/index.js';
-const { replace } = traverser;
-import {
-  LiteralStringExpression,
-  IdentifierExpression,
-  CallExpression,
-  StaticMemberExpression,
-  ReturnStatement,
-  ArrayExpression,
-  LiteralNumericExpression,
-} from 'shift-ast';
-import shiftCodegen from 'shift-codegen';
-const codegen = shiftCodegen.default || shiftCodegen; // parcel module resolution fuckup
-
-import * as strudel from '@strudel.cycles/core';
-
-const { Pattern } = strudel;
-
-const isNote = (name) => /^[a-gC-G][bs]?[0-9]$/.test(name);
-
-const addLocations = true;
-export const addMiniLocations = true;
-export const minifyStrings = true;
-export const wrappedAsync = false; // this is now handled by core evaluate by default
-export const shouldAddReturn = true;
-
-export default (_code) => {
-  const { code, addReturn } = wrapAsync(_code);
-  const ast = parseScriptWithLocation(disguiseImports(code));
-  const artificialNodes = [];
-  const parents = [];
-  const shifted = replace(ast.tree, {
-    enter(node, parent) {
-      parents.push(parent);
-      const isSynthetic = parents.some((p) => artificialNodes.includes(p));
-      if (isSynthetic) {
-        return node;
-      }
-
-      // replace template string `xxx` with mini(`xxx`)
-      if (minifyStrings && isBackTickString(node)) {
-        return minifyWithLocation(node, node, ast.locations, artificialNodes);
-      }
-      // allows to use top level strings, which are normally directives... but we don't need directives
-      if (minifyStrings && node.directives?.length === 1 && !node.statements?.length) {
-        const str = new LiteralStringExpression({ value: node.directives[0].rawValue });
-        const wrapped = minifyWithLocation(str, node.directives[0], ast.locations, artificialNodes);
-        return { ...node, directives: [], statements: [wrapped] };
-      }
-
-      // replace double quote string "xxx" with mini('xxx')
-      if (minifyStrings && isStringWithDoubleQuotes(node, ast.locations, code)) {
-        return minifyWithLocation(node, node, ast.locations, artificialNodes);
-      }
-
-      // operator overloading => still not done
-      const operators = {
-        '*': 'fast',
-        '/': 'slow',
-        '&': 'stack',
-        '&&': 'append',
-      };
-      if (
-        node.type === 'BinaryExpression' &&
-        operators[node.operator] &&
-        ['LiteralNumericExpression', 'LiteralStringExpression', 'IdentifierExpression'].includes(node.right?.type) &&
-        canBeOverloaded(node.left)
-      ) {
-        let arg = node.left;
-        if (node.left.type === 'IdentifierExpression') {
-          arg = wrapFunction('reify', node.left);
-        }
-        return new CallExpression({
-          callee: new StaticMemberExpression({
-            property: operators[node.operator],
-            object: wrapFunction('reify', arg),
-          }),
-          arguments: [node.right],
-        });
-      }
-
-      const isMarkable = isPatternArg(parents) || hasModifierCall(parent);
-      // add to location to pure(x) calls
-      if (node.type === 'CallExpression' && node.callee.name === 'pure') {
-        const literal = node.arguments[0];
-        // const value = literal[{ LiteralNumericExpression: 'value', LiteralStringExpression: 'name' }[literal.type]];
-        return reifyWithLocation(literal, node.arguments[0], ast.locations, artificialNodes);
-      }
-      // replace pseudo note variables
-      if (node.type === 'IdentifierExpression') {
-        if (isNote(node.name)) {
-          const value = node.name[1] === 's' ? node.name.replace('s', '#') : node.name;
-          if (addLocations && isMarkable) {
-            return reifyWithLocation(new LiteralStringExpression({ value }), node, ast.locations, artificialNodes);
-          }
-          return new LiteralStringExpression({ value });
-        }
-        if (node.name === 'r') {
-          return new IdentifierExpression({ name: 'silence' });
-        }
-      }
-      if (
-        addLocations &&
-        ['LiteralStringExpression' /* , 'LiteralNumericExpression' */].includes(node.type) &&
-        isMarkable
-      ) {
-        // TODO: to make LiteralNumericExpression work, we need to make sure we're not inside timeCat...
-        return reifyWithLocation(node, node, ast.locations, artificialNodes);
-      }
-      if (addMiniLocations) {
-        return addMiniNotationLocations(node, ast.locations, artificialNodes);
-      }
-      return node;
-    },
-    leave() {
-      parents.pop();
-    },
-  });
-  // add return to last statement (because it's wrapped in an async function artificially)
-  if (shouldAddReturn) {
-    addReturn(shifted);
-  }
-  const generated = undisguiseImports(codegen(shifted));
-  return generated;
-};
-
-// renames all import statements to "_mport" as Shift doesn't support dynamic import.
-// there shouldn't be any side-effects from this as this change does not affect
-// the syntax & will be undone by the equivalent replace in "undisguiseImports".
-function disguiseImports(code) {
-  return code.replaceAll('import', '_mport'); // Must be the same length!
-}
-
-// Rename the renamed import statements back to "import"
-function undisguiseImports(code) {
-  return code.replaceAll('_mport', 'import');
-}
-
-function wrapAsync(code) {
-  // wrap code in async to make await work on top level => this will create 1 line offset to locations
-  // this is why line offset is -1 in getLocationObject calls below
-  if (wrappedAsync) {
-    code = `(async () => {
-${code}
-})()`;
-  }
-  const addReturn = (ast) => {
-    const body = wrappedAsync ? ast.statements[0].expression.callee.body : ast;
-    body.statements = body.statements
-      .slice(0, -1)
-      .concat([new ReturnStatement({ expression: body.statements.slice(-1)[0] })]);
-  };
-  return {
-    code,
-    addReturn,
-  };
-}
-
-function addMiniNotationLocations(node, locations, artificialNodes) {
-  const miniFunctions = ['mini', 'm'];
-  // const isAlreadyWrapped = parent?.type === 'CallExpression' && parent.callee.name === 'withLocationOffset';
-  if (node.type === 'CallExpression' && miniFunctions.includes(node.callee.name)) {
-    // mini('c3')
-    if (node.arguments.length > 1) {
-      // TODO: transform mini(...args) to cat(...args.map(mini)) ?
-      console.warn('multi arg mini locations not supported yet...');
-      return node;
-    }
-    const str = node.arguments[0];
-    return minifyWithLocation(str, str, locations, artificialNodes);
-  }
-  if (node.type === 'StaticMemberExpression' && miniFunctions.includes(node.property)) {
-    // 'c3'.mini or 'c3'.m
-    return minifyWithLocation(node.object, node, locations, artificialNodes);
-  }
-  return node;
-}
-
-function wrapFunction(name, ...args) {
-  return new CallExpression({
-    callee: new IdentifierExpression({ name }),
-    arguments: args,
-  });
-}
-
-function isBackTickString(node) {
-  return node.type === 'TemplateExpression' && node.elements.length === 1;
-}
-
-function isStringWithDoubleQuotes(node, locations, code) {
-  if (node.type !== 'LiteralStringExpression') {
-    return false;
-  }
-  const loc = locations.get(node);
-  const snippet = code.slice(loc.start.offset, loc.end.offset);
-  return snippet[0] === '"'; // we can trust the end is also ", as the parsing did not fail
-}
-
-// returns true if the given parents belong to a pattern argument node
-// this is used to check if a node should receive a location for highlighting
-function isPatternArg(parents) {
-  if (!parents.length) {
-    return false;
-  }
-  const ancestors = parents.slice(0, -1);
-  const parent = parents[parents.length - 1];
-  if (isPatternFactory(parent)) {
-    return true;
-  }
-  if (parent?.type === 'ArrayExpression') {
-    return isPatternArg(ancestors);
-  }
-  return false;
-}
-
-function hasModifierCall(parent) {
-  // TODO: modifiers are more than composables, for example every is not composable but should be seen as modifier..
-  // need all prototypes of Pattern
-  return parent?.type === 'StaticMemberExpression';
-  // && Object.keys(Pattern.prototype.composable).includes(parent.property)
-}
-const factories = Object.keys(Pattern.prototype.factories).concat(['mini']);
-
-function isPatternFactory(node) {
-  return node?.type === 'CallExpression' && factories.includes(node.callee.name);
-}
-
-function canBeOverloaded(node) {
-  return (node.type === 'IdentifierExpression' && isNote(node.name)) || isPatternFactory(node);
-  // TODO: support sequence(c3).transpose(3).x.y.z
-}
-
-// turns node in reify(value).withLocation(location), where location is the node's location in the source code
-// with this, the reified pattern can pass its location to the event, to know where to highlight when it's active
-function reifyWithLocation(literalNode, node, locations, artificialNodes) {
-  const args = getLocationArguments(node, locations);
-  const withLocation = new CallExpression({
-    callee: new StaticMemberExpression({
-      object: wrapFunction('reify', literalNode),
-      property: 'withLocation',
-    }),
-    arguments: args,
-  });
-  artificialNodes.push(withLocation);
-  return withLocation;
-}
-
-// turns node in reify(value).withLocation(location), where location is the node's location in the source code
-// with this, the reified pattern can pass its location to the event, to know where to highlight when it's active
-function minifyWithLocation(literalNode, node, locations, artificialNodes) {
-  const args = getLocationArguments(node, locations);
-  const wrapped = wrapFunction('mini', literalNode);
-  if (!addMiniLocations) {
-    artificialNodes.push(wrapped);
-    return wrapped;
-  }
-  const withLocation = new CallExpression({
-    callee: new StaticMemberExpression({
-      object: wrapped,
-      property: 'withMiniLocation',
-    }),
-    arguments: args,
-  });
-  artificialNodes.push(withLocation);
-  return withLocation;
-}
-
-function getLocationArguments(node, locations) {
-  const loc = locations.get(node);
-  const lineOffset = wrappedAsync ? -1 : 0;
-  return [
-    new ArrayExpression({
-      elements: [
-        new LiteralNumericExpression({ value: loc.start.line + lineOffset }), // the minus 1 assumes the code has been wrapped in async iife
-        new LiteralNumericExpression({ value: loc.start.column }),
-        new LiteralNumericExpression({ value: loc.start.offset }),
-      ],
-    }),
-    new ArrayExpression({
-      elements: [
-        new LiteralNumericExpression({ value: loc.end.line + lineOffset }), // the minus 1 assumes the code has been wrapped in async iife
-        new LiteralNumericExpression({ value: loc.end.column }),
-        new LiteralNumericExpression({ value: loc.end.offset }),
-      ],
-    }),
-  ];
-}

packages/eval/shift-traverser/index.js

@@ -1,68 +0,0 @@
-/*
-index.js - <short description TODO>
-Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/eval/shift-traverser/index.js>
-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/>.
-*/
-
-/*
-  Copyright (C) 2014 Yusuke Suzuki <utatane.tea@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-import _Spec from 'shift-spec';
-const Spec = _Spec.default || _Spec; // parcel module resolution fuckup
-// import { version } from '../package.json'
-
-// Loading uncached estraverse for changing estraverse.Syntax.
-import _estraverse from 'estraverse';
-
-const estraverse = _estraverse.cloneEnvironment();
-
-// Adjust estraverse members.
-
-Object.keys(estraverse.Syntax)
-  .filter((key) => key !== 'Property')
-  .forEach((key) => {
-    delete estraverse.Syntax[key];
-    delete estraverse.VisitorKeys[key];
-  });
-
-Object.assign(
-  estraverse.Syntax,
-  Object.keys(Spec).reduce((result, key) => {
-    result[key] = key;
-    return result;
-  }, {}),
-);
-
-Object.assign(
-  estraverse.VisitorKeys,
-  Object.keys(Spec).reduce((result, key) => {
-    result[key] = Spec[key].fields.map((field) => field.name);
-    return result;
-  }, {}),
-);
-
-// estraverse.version = version;
-export default estraverse;
-
-/* vim: set sw=4 ts=4 et tw=80 : */

packages/eval/test/evaluate.test.mjs

@@ -1,32 +0,0 @@
-/*
-evaluate.test.mjs - <short description TODO>
-Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/eval/test/evaluate.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 { expect, describe, it } from 'vitest';
-
-import { evaluate } from '../evaluate.mjs';
-import { mini } from '@strudel.cycles/mini';
-import * as strudel from '@strudel.cycles/core';
-const { fastcat, evalScope } = strudel;
-
-describe('evaluate', async () => {
-  await evalScope({ mini }, strudel);
-  const ev = async (code) => (await evaluate(code)).pattern.firstCycleValues;
-  it('Should evaluate strudel functions', async () => {
-    expect(await ev('pure("c3")')).toEqual(['c3']);
-    expect(await ev('cat("c3")')).toEqual(['c3']);
-    expect(await ev('fastcat("c3", "d3")')).toEqual(['c3', 'd3']);
-    expect(await ev('slowcat("c3", "d3")')).toEqual(['c3']);
-  });
-  it('Scope should be extendable', async () => {
-    await evalScope({ myFunction: (...x) => fastcat(...x) });
-    expect(await ev('myFunction("c3", "d3")')).toEqual(['c3', 'd3']);
-  });
-  it('Should evaluate simple double quoted mini notation', async () => {
-    expect(await ev('"c3"')).toEqual(['c3']);
-    expect(await ev('"c3 d3"')).toEqual(['c3', 'd3']);
-    expect(await ev('"<c3 d3>"')).toEqual(['c3']);
-  });
-});

packages/eval/test/shapeshifter.test.mjs

@@ -1,25 +0,0 @@
-/*
-shapeshifter.test.mjs - <short description TODO>
-Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/eval/test/shapeshifter.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 { describe, it, expect } from 'vitest';
-import shapeshifter, { wrappedAsync } from '../shapeshifter.mjs';
-
-describe('shapeshifter', () => {
-  it('Should shift simple double quote string', () => {
-    if (wrappedAsync) {
-      expect(shapeshifter('"c3"')).toEqual('(async()=>{return mini("c3").withMiniLocation([1,0,15],[1,4,19])})()');
-    } else {
-      expect(shapeshifter('"c3"')).toEqual('return mini("c3").withMiniLocation([1,0,0],[1,4,4])');
-    }
-  });
-  if (wrappedAsync) {
-    it('Should handle dynamic imports', () => {
-      expect(shapeshifter('const { default: foo } = await import(\'https://bar.com/foo.js\');"c3"')).toEqual(
-        'const{default:foo}=await import("https://bar.com/foo.js");return mini("c3").withMiniLocation([1,64,79],[1,68,83])',
-      );
-    });
-  }
-});

packages/midi/midi.mjs

@@ -7,7 +7,7 @@ This program is free software: you can redistribute it and/or modify it under th
 import * as _WebMidi from 'webmidi';
 import { Pattern, isPattern, logger } from '@strudel.cycles/core';
 import { getAudioContext } from '@strudel.cycles/webaudio';
-import { toMidi } from '@strudel.cycles/core';
+import { noteToMidi } from '@strudel.cycles/core';
 
 // if you use WebMidi from outside of this package, make sure to import that instance:
 export const { WebMidi } = _WebMidi;
@@ -105,7 +105,7 @@ Pattern.prototype.midi = function (output) {
     hap.ensureObjectValue();
 
     // calculate time
-    const timingOffset = WebMidi.time - getAudioContext().currentTime * 1000;
+    const timingOffset = WebMidi.time - getAudioContext().getOutputTimestamp().contextTime * 1000;
     time = time * 1000 + timingOffset;
 
     // destructure value
@@ -113,8 +113,8 @@ Pattern.prototype.midi = function (output) {
     const velocity = hap.context?.velocity ?? 0.9; // TODO: refactor velocity
     const duration = hap.duration.valueOf() * 1000 - 5;
 
-    if (note) {
-      const midiNumber = toMidi(note);
+    if (note != null) {
+      const midiNumber = typeof note === 'number' ? note : noteToMidi(note);
       device.playNote(midiNumber, midichan, {
         time,
         duration,

packages/midi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel.cycles/midi",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Midi API for strudel",
   "main": "index.mjs",
   "publishConfig": {
@@ -31,9 +31,9 @@
   "dependencies": {
     "@strudel.cycles/core": "workspace:*",
     "@strudel.cycles/webaudio": "workspace:*",
-    "webmidi": "^3.0.21"
+    "webmidi": "^3.1.5"
   },
   "devDependencies": {
-    "vite": "^3.2.2"
+    "vite": "^4.3.3"
   }
 }

packages/mini/krill-parser.js

@@ -1,4 +1,4 @@
-// Generated by Peggy 2.0.1.
+// Generated by Peggy 3.0.2.
 //
 // https://peggyjs.org/
 
@@ -43,16 +43,19 @@ peg$SyntaxError.prototype.format = function(sources) {
       }
     }
     var s = this.location.start;
-    var loc = this.location.source + ":" + s.line + ":" + s.column;
+    var offset_s = (this.location.source && (typeof this.location.source.offset === "function"))
+      ? this.location.source.offset(s)
+      : s;
+    var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column;
     if (src) {
       var e = this.location.end;
-      var filler = peg$padEnd("", s.line.toString().length, ' ');
+      var filler = peg$padEnd("", offset_s.line.toString().length, ' ');
       var line = src[s.line - 1];
       var last = s.line === e.line ? e.column : line.length + 1;
       var hatLen = (last - s.column) || 1;
       str += "\n --> " + loc + "\n"
           + filler + " |\n"
-          + s.line + " | " + line + "\n"
+          + offset_s.line + " | " + line + "\n"
           + filler + " | " + peg$padEnd("", s.column - 1, ' ')
           + peg$padEnd("", hatLen, "^");
     } else {
@@ -182,21 +185,21 @@ function peg$parse(input, options) {
   var peg$c8 = "#";
   var peg$c9 = "^";
   var peg$c10 = "_";
-  var peg$c11 = ":";
-  var peg$c12 = "[";
-  var peg$c13 = "]";
-  var peg$c14 = "{";
-  var peg$c15 = "}";
-  var peg$c16 = "%";
-  var peg$c17 = "<";
-  var peg$c18 = ">";
-  var peg$c19 = "@";
-  var peg$c20 = "!";
-  var peg$c21 = "(";
-  var peg$c22 = ")";
-  var peg$c23 = "/";
-  var peg$c24 = "*";
-  var peg$c25 = "?";
+  var peg$c11 = "[";
+  var peg$c12 = "]";
+  var peg$c13 = "{";
+  var peg$c14 = "}";
+  var peg$c15 = "%";
+  var peg$c16 = "<";
+  var peg$c17 = ">";
+  var peg$c18 = "@";
+  var peg$c19 = "!";
+  var peg$c20 = "(";
+  var peg$c21 = ")";
+  var peg$c22 = "/";
+  var peg$c23 = "*";
+  var peg$c24 = "?";
+  var peg$c25 = ":";
   var peg$c26 = "struct";
   var peg$c27 = "target";
   var peg$c28 = "euclid";
@@ -237,21 +240,21 @@ function peg$parse(input, options) {
   var peg$e15 = peg$literalExpectation("#", false);
   var peg$e16 = peg$literalExpectation("^", false);
   var peg$e17 = peg$literalExpectation("_", false);
-  var peg$e18 = peg$literalExpectation(":", false);
-  var peg$e19 = peg$literalExpectation("[", false);
-  var peg$e20 = peg$literalExpectation("]", false);
-  var peg$e21 = peg$literalExpectation("{", false);
-  var peg$e22 = peg$literalExpectation("}", false);
-  var peg$e23 = peg$literalExpectation("%", false);
-  var peg$e24 = peg$literalExpectation("<", false);
-  var peg$e25 = peg$literalExpectation(">", false);
-  var peg$e26 = peg$literalExpectation("@", false);
-  var peg$e27 = peg$literalExpectation("!", false);
-  var peg$e28 = peg$literalExpectation("(", false);
-  var peg$e29 = peg$literalExpectation(")", false);
-  var peg$e30 = peg$literalExpectation("/", false);
-  var peg$e31 = peg$literalExpectation("*", false);
-  var peg$e32 = peg$literalExpectation("?", false);
+  var peg$e18 = peg$literalExpectation("[", false);
+  var peg$e19 = peg$literalExpectation("]", false);
+  var peg$e20 = peg$literalExpectation("{", false);
+  var peg$e21 = peg$literalExpectation("}", false);
+  var peg$e22 = peg$literalExpectation("%", false);
+  var peg$e23 = peg$literalExpectation("<", false);
+  var peg$e24 = peg$literalExpectation(">", false);
+  var peg$e25 = peg$literalExpectation("@", false);
+  var peg$e26 = peg$literalExpectation("!", false);
+  var peg$e27 = peg$literalExpectation("(", false);
+  var peg$e28 = peg$literalExpectation(")", false);
+  var peg$e29 = peg$literalExpectation("/", false);
+  var peg$e30 = peg$literalExpectation("*", false);
+  var peg$e31 = peg$literalExpectation("?", false);
+  var peg$e32 = peg$literalExpectation(":", false);
   var peg$e33 = peg$literalExpectation("struct", false);
   var peg$e34 = peg$literalExpectation("target", false);
   var peg$e35 = peg$literalExpectation("euclid", false);
@@ -279,36 +282,37 @@ function peg$parse(input, options) {
   var peg$f8 = function(p, s, r) { return x => x.options_['ops'].push({ type_: "bjorklund", arguments_ :{ pulse: p, step:s, rotation:r }}) };
   var peg$f9 = function(a) { return x => x.options_['ops'].push({ type_: "stretch", arguments_ :{ amount:a, type: 'slow' }}) };
   var peg$f10 = function(a) { return x => x.options_['ops'].push({ type_: "stretch", arguments_ :{ amount:a, type: 'fast' }}) };
-  var peg$f11 = function(a) { return x => x.options_['ops'].push({ type_: "degradeBy", arguments_ :{ amount:a } }) };
-  var peg$f12 = function(s, ops) { const result = new ElementStub(s, {ops: [], weight: 1, reps: 1});
+  var peg$f11 = function(a) { return x => x.options_['ops'].push({ type_: "degradeBy", arguments_ :{ amount:a, seed: seed++ } }) };
+  var peg$f12 = function(s) { return x => x.options_['ops'].push({ type_: "tail", arguments_ :{ element:s } }) };
+  var peg$f13 = function(s, ops) { const result = new ElementStub(s, {ops: [], weight: 1, reps: 1});
     for (const op of ops) {
       op(result);
     }
     return result;
   };
-  var peg$f13 = function(s) { return new PatternStub(s, 'fastcat'); };
-  var peg$f14 = function(tail) { return { alignment: 'stack', list: tail }; };
-  var peg$f15 = function(tail) { return { alignment: 'rand', list: tail }; };
-  var peg$f16 = function(head, tail) { if (tail && tail.list.length > 0) { return new PatternStub([head, ...tail.list], tail.alignment); } else { return head; } };
-  var peg$f17 = function(head, tail) { return new PatternStub(tail ? [head, ...tail.list] : [head], 'polymeter'); };
-  var peg$f18 = function(sc) { return sc; };
-  var peg$f19 = function(s) { return { name: "struct", args: { mini:s }}};
-  var peg$f20 = function(s) { return { name: "target", args : { name:s}}};
-  var peg$f21 = function(p, s, r) { return { name: "bjorklund", args :{ pulse: p, step:parseInt(s) }}};
-  var peg$f22 = function(a) { return { name: "stretch", args :{ amount: a}}};
-  var peg$f23 = function(a) { return { name: "shift", args :{ amount: "-"+a}}};
-  var peg$f24 = function(a) { return { name: "shift", args :{ amount: a}}};
-  var peg$f25 = function(a) { return { name: "stretch", args :{ amount: "1/"+a}}};
-  var peg$f26 = function(s) { return { name: "scale", args :{ scale: s.join("")}}};
-  var peg$f27 = function(s, v) { return v};
-  var peg$f28 = function(s, ss) { ss.unshift(s); return new PatternStub(ss, 'slowcat'); };
-  var peg$f29 = function(sg) {return sg};
-  var peg$f30 = function(o, soc) { return new OperatorStub(o.name,o.args,soc)};
-  var peg$f31 = function(sc) { return sc };
-  var peg$f32 = function(c) { return c };
-  var peg$f33 = function(v) { return new CommandStub("setcps", { value: v})};
-  var peg$f34 = function(v) { return new CommandStub("setcps", { value: (v/120/2)})};
-  var peg$f35 = function() { return new CommandStub("hush")};
+  var peg$f14 = function(s) { return new PatternStub(s, 'fastcat'); };
+  var peg$f15 = function(tail) { return { alignment: 'stack', list: tail }; };
+  var peg$f16 = function(tail) { return { alignment: 'rand', list: tail, seed: seed++ }; };
+  var peg$f17 = function(head, tail) { if (tail && tail.list.length > 0) { return new PatternStub([head, ...tail.list], tail.alignment, tail.seed); } else { return head; } };
+  var peg$f18 = function(head, tail) { return new PatternStub(tail ? [head, ...tail.list] : [head], 'polymeter'); };
+  var peg$f19 = function(sc) { return sc; };
+  var peg$f20 = function(s) { return { name: "struct", args: { mini:s }}};
+  var peg$f21 = function(s) { return { name: "target", args : { name:s}}};
+  var peg$f22 = function(p, s, r) { return { name: "bjorklund", args :{ pulse: p, step:parseInt(s) }}};
+  var peg$f23 = function(a) { return { name: "stretch", args :{ amount: a}}};
+  var peg$f24 = function(a) { return { name: "shift", args :{ amount: "-"+a}}};
+  var peg$f25 = function(a) { return { name: "shift", args :{ amount: a}}};
+  var peg$f26 = function(a) { return { name: "stretch", args :{ amount: "1/"+a}}};
+  var peg$f27 = function(s) { return { name: "scale", args :{ scale: s.join("")}}};
+  var peg$f28 = function(s, v) { return v};
+  var peg$f29 = function(s, ss) { ss.unshift(s); return new PatternStub(ss, 'slowcat'); };
+  var peg$f30 = function(sg) {return sg};
+  var peg$f31 = function(o, soc) { return new OperatorStub(o.name,o.args,soc)};
+  var peg$f32 = function(sc) { return sc };
+  var peg$f33 = function(c) { return c };
+  var peg$f34 = function(v) { return new CommandStub("setcps", { value: v})};
+  var peg$f35 = function(v) { return new CommandStub("setcps", { value: (v/120/2)})};
+  var peg$f36 = function() { return new CommandStub("hush")};
   var peg$currPos = 0;
   var peg$savedPos = 0;
   var peg$posDetailsCache = [{ line: 1, column: 1 }];
@@ -421,11 +425,11 @@ function peg$parse(input, options) {
     }
   }
 
-  function peg$computeLocation(startPos, endPos) {
+  function peg$computeLocation(startPos, endPos, offset) {
     var startPosDetails = peg$computePosDetails(startPos);
     var endPosDetails = peg$computePosDetails(endPos);
 
-    return {
+    var res = {
       source: peg$source,
       start: {
         offset: startPos,
@@ -438,6 +442,11 @@ function peg$parse(input, options) {
         column: endPosDetails.column
       }
     };
+    if (offset && peg$source && (typeof peg$source.offset === "function")) {
+      res.start = peg$source.offset(res.start);
+      res.end = peg$source.offset(res.end);
+    }
+    return res;
   }
 
   function peg$fail(expected) {
@@ -848,15 +857,6 @@ function peg$parse(input, options) {
                 s0 = peg$FAILED;
                 if (peg$silentFails === 0) { peg$fail(peg$e17); }
               }
-              if (s0 === peg$FAILED) {
-                if (input.charCodeAt(peg$currPos) === 58) {
-                  s0 = peg$c11;
-                  peg$currPos++;
-                } else {
-                  s0 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e18); }
-                }
-              }
             }
           }
         }
@@ -899,11 +899,11 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$parsews();
     if (input.charCodeAt(peg$currPos) === 91) {
-      s2 = peg$c12;
+      s2 = peg$c11;
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e19); }
+      if (peg$silentFails === 0) { peg$fail(peg$e18); }
     }
     if (s2 !== peg$FAILED) {
       s3 = peg$parsews();
@@ -911,11 +911,11 @@ function peg$parse(input, options) {
       if (s4 !== peg$FAILED) {
         s5 = peg$parsews();
         if (input.charCodeAt(peg$currPos) === 93) {
-          s6 = peg$c13;
+          s6 = peg$c12;
           peg$currPos++;
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e20); }
+          if (peg$silentFails === 0) { peg$fail(peg$e19); }
         }
         if (s6 !== peg$FAILED) {
           s7 = peg$parsews();
@@ -943,11 +943,11 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$parsews();
     if (input.charCodeAt(peg$currPos) === 123) {
-      s2 = peg$c14;
+      s2 = peg$c13;
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e21); }
+      if (peg$silentFails === 0) { peg$fail(peg$e20); }
     }
     if (s2 !== peg$FAILED) {
       s3 = peg$parsews();
@@ -955,11 +955,11 @@ function peg$parse(input, options) {
       if (s4 !== peg$FAILED) {
         s5 = peg$parsews();
         if (input.charCodeAt(peg$currPos) === 125) {
-          s6 = peg$c15;
+          s6 = peg$c14;
           peg$currPos++;
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e22); }
+          if (peg$silentFails === 0) { peg$fail(peg$e21); }
         }
         if (s6 !== peg$FAILED) {
           s7 = peg$parsepolymeter_steps();
@@ -990,11 +990,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 37) {
-      s1 = peg$c16;
+      s1 = peg$c15;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e23); }
+      if (peg$silentFails === 0) { peg$fail(peg$e22); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parseslice();
@@ -1019,11 +1019,11 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$parsews();
     if (input.charCodeAt(peg$currPos) === 60) {
-      s2 = peg$c17;
+      s2 = peg$c16;
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e24); }
+      if (peg$silentFails === 0) { peg$fail(peg$e23); }
     }
     if (s2 !== peg$FAILED) {
       s3 = peg$parsews();
@@ -1031,11 +1031,11 @@ function peg$parse(input, options) {
       if (s4 !== peg$FAILED) {
         s5 = peg$parsews();
         if (input.charCodeAt(peg$currPos) === 62) {
-          s6 = peg$c18;
+          s6 = peg$c17;
           peg$currPos++;
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          if (peg$silentFails === 0) { peg$fail(peg$e24); }
         }
         if (s6 !== peg$FAILED) {
           s7 = peg$parsews();
@@ -1088,6 +1088,9 @@ function peg$parse(input, options) {
             s0 = peg$parseop_replicate();
             if (s0 === peg$FAILED) {
               s0 = peg$parseop_degrade();
+              if (s0 === peg$FAILED) {
+                s0 = peg$parseop_tail();
+              }
             }
           }
         }
@@ -1102,11 +1105,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 64) {
-      s1 = peg$c19;
+      s1 = peg$c18;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e26); }
+      if (peg$silentFails === 0) { peg$fail(peg$e25); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parsenumber();
@@ -1130,11 +1133,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 33) {
-      s1 = peg$c20;
+      s1 = peg$c19;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e27); }
+      if (peg$silentFails === 0) { peg$fail(peg$e26); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parsenumber();
@@ -1158,11 +1161,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 40) {
-      s1 = peg$c21;
+      s1 = peg$c20;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e28); }
+      if (peg$silentFails === 0) { peg$fail(peg$e27); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parsews();
@@ -1186,11 +1189,11 @@ function peg$parse(input, options) {
             }
             s12 = peg$parsews();
             if (input.charCodeAt(peg$currPos) === 41) {
-              s13 = peg$c22;
+              s13 = peg$c21;
               peg$currPos++;
             } else {
               s13 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e29); }
+              if (peg$silentFails === 0) { peg$fail(peg$e28); }
             }
             if (s13 !== peg$FAILED) {
               peg$savedPos = s0;
@@ -1224,11 +1227,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 47) {
-      s1 = peg$c23;
+      s1 = peg$c22;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e30); }
+      if (peg$silentFails === 0) { peg$fail(peg$e29); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parseslice();
@@ -1252,11 +1255,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 42) {
-      s1 = peg$c24;
+      s1 = peg$c23;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+      if (peg$silentFails === 0) { peg$fail(peg$e30); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parseslice();
@@ -1280,11 +1283,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 63) {
-      s1 = peg$c25;
+      s1 = peg$c24;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e32); }
+      if (peg$silentFails === 0) { peg$fail(peg$e31); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parsenumber();
@@ -1301,6 +1304,34 @@ function peg$parse(input, options) {
     return s0;
   }
 
+  function peg$parseop_tail() {
+    var s0, s1, s2;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 58) {
+      s1 = peg$c25;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e32); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseslice();
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f12(s2);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
   function peg$parseslice_with_ops() {
     var s0, s1, s2, s3;
 
@@ -1314,7 +1345,7 @@ function peg$parse(input, options) {
         s3 = peg$parseslice_op();
       }
       peg$savedPos = s0;
-      s0 = peg$f12(s1, s2);
+      s0 = peg$f13(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -1339,7 +1370,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f13(s1);
+      s1 = peg$f14(s1);
     }
     s0 = s1;
 
@@ -1388,7 +1419,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f14(s1);
+      s1 = peg$f15(s1);
     }
     s0 = s1;
 
@@ -1437,7 +1468,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f15(s1);
+      s1 = peg$f16(s1);
     }
     s0 = s1;
 
@@ -1458,7 +1489,7 @@ function peg$parse(input, options) {
         s2 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f16(s1, s2);
+      s0 = peg$f17(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -1478,7 +1509,7 @@ function peg$parse(input, options) {
         s2 = null;
       }
       peg$savedPos = s0;
-      s0 = peg$f17(s1, s2);
+      s0 = peg$f18(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -1488,18 +1519,20 @@ function peg$parse(input, options) {
   }
 
   function peg$parsemini() {
-    var s0, s1, s2, s3, s4;
+    var s0, s1, s2, s3, s4, s5, s6;
 
     s0 = peg$currPos;
     s1 = peg$parsews();
     s2 = peg$parsequote();
     if (s2 !== peg$FAILED) {
-      s3 = peg$parsestack_or_choose();
-      if (s3 !== peg$FAILED) {
-        s4 = peg$parsequote();
-        if (s4 !== peg$FAILED) {
+      s3 = peg$parsews();
+      s4 = peg$parsestack_or_choose();
+      if (s4 !== peg$FAILED) {
+        s5 = peg$parsews();
+        s6 = peg$parsequote();
+        if (s6 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f18(s3);
+          s0 = peg$f19(s4);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -1561,7 +1594,7 @@ function peg$parse(input, options) {
       s3 = peg$parsemini_or_operator();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f19(s3);
+        s0 = peg$f20(s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -1594,7 +1627,7 @@ function peg$parse(input, options) {
           s5 = peg$parsequote();
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f20(s4);
+            s0 = peg$f21(s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -1639,7 +1672,7 @@ function peg$parse(input, options) {
             s7 = null;
           }
           peg$savedPos = s0;
-          s0 = peg$f21(s3, s5, s7);
+          s0 = peg$f22(s3, s5, s7);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -1672,7 +1705,7 @@ function peg$parse(input, options) {
       s3 = peg$parsenumber();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f22(s3);
+        s0 = peg$f23(s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -1701,7 +1734,7 @@ function peg$parse(input, options) {
       s3 = peg$parsenumber();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f23(s3);
+        s0 = peg$f24(s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -1730,7 +1763,7 @@ function peg$parse(input, options) {
       s3 = peg$parsenumber();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f24(s3);
+        s0 = peg$f25(s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -1759,7 +1792,7 @@ function peg$parse(input, options) {
       s3 = peg$parsenumber();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f25(s3);
+        s0 = peg$f26(s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -1801,7 +1834,7 @@ function peg$parse(input, options) {
           s5 = peg$parsequote();
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f26(s4);
+            s0 = peg$f27(s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -1876,11 +1909,11 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$parsews();
       if (input.charCodeAt(peg$currPos) === 91) {
-        s3 = peg$c12;
+        s3 = peg$c11;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e19); }
+        if (peg$silentFails === 0) { peg$fail(peg$e18); }
       }
       if (s3 !== peg$FAILED) {
         s4 = peg$parsews();
@@ -1893,7 +1926,7 @@ function peg$parse(input, options) {
             s9 = peg$parsemini_or_operator();
             if (s9 !== peg$FAILED) {
               peg$savedPos = s7;
-              s7 = peg$f27(s5, s9);
+              s7 = peg$f28(s5, s9);
             } else {
               peg$currPos = s7;
               s7 = peg$FAILED;
@@ -1910,7 +1943,7 @@ function peg$parse(input, options) {
               s9 = peg$parsemini_or_operator();
               if (s9 !== peg$FAILED) {
                 peg$savedPos = s7;
-                s7 = peg$f27(s5, s9);
+                s7 = peg$f28(s5, s9);
               } else {
                 peg$currPos = s7;
                 s7 = peg$FAILED;
@@ -1922,15 +1955,15 @@ function peg$parse(input, options) {
           }
           s7 = peg$parsews();
           if (input.charCodeAt(peg$currPos) === 93) {
-            s8 = peg$c13;
+            s8 = peg$c12;
             peg$currPos++;
           } else {
             s8 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e20); }
+            if (peg$silentFails === 0) { peg$fail(peg$e19); }
           }
           if (s8 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f28(s5, s6);
+            s0 = peg$f29(s5, s6);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -1976,7 +2009,7 @@ function peg$parse(input, options) {
         s4 = peg$parsecomment();
       }
       peg$savedPos = s0;
-      s0 = peg$f29(s1);
+      s0 = peg$f30(s1);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -1998,7 +2031,7 @@ function peg$parse(input, options) {
           s5 = peg$parsemini_or_operator();
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f30(s1, s5);
+            s0 = peg$f31(s1, s5);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -2023,7 +2056,7 @@ function peg$parse(input, options) {
     s1 = peg$parsemini_or_operator();
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f31(s1);
+      s1 = peg$f32(s1);
     }
     s0 = s1;
     if (s0 === peg$FAILED) {
@@ -2056,7 +2089,7 @@ function peg$parse(input, options) {
     if (s2 !== peg$FAILED) {
       s3 = peg$parsews();
       peg$savedPos = s0;
-      s0 = peg$f32(s2);
+      s0 = peg$f33(s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -2081,7 +2114,7 @@ function peg$parse(input, options) {
       s3 = peg$parsenumber();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f33(s3);
+        s0 = peg$f34(s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -2110,7 +2143,7 @@ function peg$parse(input, options) {
       s3 = peg$parsenumber();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f34(s3);
+        s0 = peg$f35(s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -2136,7 +2169,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f35();
+      s1 = peg$f36();
     }
     s0 = s1;
 
@@ -2162,10 +2195,13 @@ function peg$parse(input, options) {
     this.location_ = location();
   }
 
-  var PatternStub = function(source, alignment)
+  var PatternStub = function(source, alignment, seed)
   {
     this.type_ = "pattern";
-    this.arguments_ = { alignment : alignment};
+    this.arguments_ = { alignment: alignment };
+    if (seed !== undefined) {
+      this.arguments_.seed = seed;
+    }
     this.source_ = source;
   }
 
@@ -2191,6 +2227,7 @@ function peg$parse(input, options) {
     this.options_ = options;
   }
 
+  var seed = 0;
 
   peg$result = peg$startRuleFunction();
 

packages/mini/krill.pegjs

@@ -19,10 +19,13 @@ This program is free software: you can redistribute it and/or modify it under th
     this.location_ = location();
   }
 
-  var PatternStub = function(source, alignment)
+  var PatternStub = function(source, alignment, seed)
   {
     this.type_ = "pattern";
-    this.arguments_ = { alignment : alignment};
+    this.arguments_ = { alignment: alignment };
+    if (seed !== undefined) {
+      this.arguments_.seed = seed;
+    }
     this.source_ = source;
   }
 
@@ -48,6 +51,7 @@ This program is free software: you can redistribute it and/or modify it under th
     this.options_ = options;
   }
 
+  var seed = 0;
 }
 
 start = statement
@@ -96,7 +100,7 @@ quote = '"' / "'"
 // ------------------ steps and cycles ---------------------------
 
 // single step definition (e.g bd)
-step_char =  [0-9a-zA-Z~] / "-" / "#" / "." / "^" / "_" / ":"
+step_char =  [0-9a-zA-Z~] / "-" / "#" / "." / "^" / "_"
 step = ws chars:step_char+ ws { return new AtomStub(chars.join("")) }
 
 // define a sub cycle e.g. [1 2, 3 [4]]
@@ -119,7 +123,7 @@ slice = step / sub_cycle / polymeter / slow_sequence
 
 // slice modifier affects the timing/size of a slice (e.g. [a b c]@3)
 // at this point, we assume we can represent them as regular sequence operators
-slice_op = op_weight / op_bjorklund / op_slow / op_fast / op_replicate / op_degrade
+slice_op = op_weight / op_bjorklund / op_slow / op_fast / op_replicate / op_degrade / op_tail
 
 op_weight =  "@" a:number
   { return x => x.options_['weight'] = a }
@@ -137,7 +141,10 @@ op_fast = "*"a:slice
   { return x => x.options_['ops'].push({ type_: "stretch", arguments_ :{ amount:a, type: 'fast' }}) }
 
 op_degrade = "?"a:number?
-  { return x => x.options_['ops'].push({ type_: "degradeBy", arguments_ :{ amount:a } }) }
+  { return x => x.options_['ops'].push({ type_: "degradeBy", arguments_ :{ amount:a, seed: seed++ } }) }
+
+op_tail = ":" s:slice
+  { return x => x.options_['ops'].push({ type_: "tail", arguments_ :{ element:s } }) }
 
 // a slice with an modifier applied i.e [bd@4 sd@3]@2 hh]
 slice_with_ops = s:slice ops:slice_op*
@@ -159,12 +166,12 @@ stack_tail = tail:(comma @sequence)+
 // a choose is a series of pipe-separated sequence, one of which is
 // chosen at random, each cycle
 choose_tail = tail:(pipe @sequence)+
-  { return { alignment: 'rand', list: tail }; }
+  { return { alignment: 'rand', list: tail, seed: seed++ }; }
 
 // if the stack contains only one element, we don't create a stack but return the
 // underlying element
 stack_or_choose = head:sequence tail:(stack_tail / choose_tail)?
-  { if (tail && tail.list.length > 0) { return new PatternStub([head, ...tail.list], tail.alignment); } else { return head; } }
+  { if (tail && tail.list.length > 0) { return new PatternStub([head, ...tail.list], tail.alignment, tail.seed); } else { return head; } }
 
 polymeter_stack = head:sequence tail:stack_tail?
   { return new PatternStub(tail ? [head, ...tail.list] : [head], 'polymeter'); }
@@ -175,7 +182,7 @@ polymeter_stack = head:sequence tail:stack_tail?
 // Experimental haskellish parser begins
 
 // mini-notation = a quoted stack
-mini = ws quote sc:stack_or_choose quote
+mini = ws quote ws sc:stack_or_choose ws quote
   { return sc; }
 
 // ------------------ operators ---------------------------

packages/mini/mini.mjs

@@ -7,17 +7,13 @@ This program is free software: you can redistribute it and/or modify it under th
 import * as krill from './krill-parser.js';
 import * as strudel from '@strudel.cycles/core';
 
-/* var _seedState = 0;
-const randOffset = 0.0002;
+const randOffset = 0.0003;
 
-function _nextSeed() {
-  return _seedState++;
-} */
-
-const applyOptions = (parent, code) => (pat, i) => {
+const applyOptions = (parent, enter) => (pat, i) => {
   const ast = parent.source_[i];
   const options = ast.options_;
   const ops = options?.ops;
+
   if (ops) {
     for (const op of ops) {
       switch (op.type_) {
@@ -27,43 +23,26 @@ const applyOptions = (parent, code) => (pat, i) => {
           if (!legalTypes.includes(type)) {
             throw new Error(`mini: stretch: type must be one of ${legalTypes.join('|')} but got ${type}`);
           }
-          pat = strudel.reify(pat)[type](patternifyAST(amount, code));
+          pat = strudel.reify(pat)[type](enter(amount));
           break;
         }
         case 'bjorklund': {
           if (op.arguments_.rotation) {
-            pat = pat.euclidRot(
-              patternifyAST(op.arguments_.pulse, code),
-              patternifyAST(op.arguments_.step, code),
-              patternifyAST(op.arguments_.rotation, code),
-            );
+            pat = pat.euclidRot(enter(op.arguments_.pulse), enter(op.arguments_.step), enter(op.arguments_.rotation));
           } else {
-            pat = pat.euclid(patternifyAST(op.arguments_.pulse, code), patternifyAST(op.arguments_.step, code));
+            pat = pat.euclid(enter(op.arguments_.pulse), enter(op.arguments_.step));
           }
           break;
         }
         case 'degradeBy': {
-          // TODO: find out what is right here
-          // example:
-          /*
-           stack(
-             s("hh*8").degrade(),
-             s("[ht*8]?")
-           )
-        */
-          // above example will only be in sync when _degradeBy is used...
-          // it also seems that the nextSeed will create undeterministic behaviour
-          // as it uses a global _seedState. This is probably the reason for
-          // https://github.com/tidalcycles/strudel/issues/245
-
-          // this is how it was:
-          /* 
-        return strudel.reify(pat)._degradeByWith(
-          strudel.rand.early(randOffset * _nextSeed()).segment(1),
-          op.arguments_.amount ?? 0.5,
-        ); 
-        */
-          pat = strudel.reify(pat).degradeBy(op.arguments_.amount === null ? 0.5 : op.arguments_.amount);
+          pat = strudel
+            .reify(pat)
+            ._degradeByWith(strudel.rand.early(randOffset * op.arguments_.seed), op.arguments_.amount ?? 0.5);
+          break;
+        }
+        case 'tail': {
+          const friend = enter(op.arguments_.element);
+          pat = pat.fmap((a) => (b) => Array.isArray(a) ? [...a, b] : [a, b]).appLeft(friend);
           break;
         }
         default: {
@@ -89,11 +68,14 @@ function resolveReplications(ast) {
   );
 }
 
-export function patternifyAST(ast, code) {
+// expects ast from mini2ast + quoted mini string + optional callback when a node is entered
+export function patternifyAST(ast, code, onEnter, offset = 0) {
+  onEnter?.(ast);
+  const enter = (node) => patternifyAST(node, code, onEnter, offset);
   switch (ast.type_) {
     case 'pattern': {
       resolveReplications(ast);
-      const children = ast.source_.map((child) => patternifyAST(child, code)).map(applyOptions(ast, code));
+      const children = ast.source_.map((child) => enter(child)).map(applyOptions(ast, enter));
       const alignment = ast.arguments_.alignment;
       if (alignment === 'stack') {
         return strudel.stack(...children);
@@ -101,16 +83,14 @@ export function patternifyAST(ast, code) {
       if (alignment === 'polymeter') {
         // polymeter
         const stepsPerCycle = ast.arguments_.stepsPerCycle
-          ? patternifyAST(ast.arguments_.stepsPerCycle, code).fmap((x) => strudel.Fraction(x))
+          ? enter(ast.arguments_.stepsPerCycle).fmap((x) => strudel.Fraction(x))
           : strudel.pure(strudel.Fraction(children.length > 0 ? children[0].__weight : 1));
 
         const aligned = children.map((child) => child.fast(stepsPerCycle.fmap((x) => x.div(child.__weight || 1))));
         return strudel.stack(...aligned);
       }
       if (alignment === 'rand') {
-        // https://github.com/tidalcycles/strudel/issues/245#issuecomment-1345406422
-        // return strudel.chooseInWith(strudel.rand.early(randOffset * _nextSeed()).segment(1), children);
-        return strudel.chooseCycles(...children);
+        return strudel.chooseInWith(strudel.rand.early(randOffset * ast.arguments_.seed).segment(1), children);
       }
       const weightedChildren = ast.source_.some((child) => !!child.options_?.weight);
       if (!weightedChildren && alignment === 'slowcat') {
@@ -130,7 +110,7 @@ export function patternifyAST(ast, code) {
       return pat;
     }
     case 'element': {
-      return patternifyAST(ast.source_, code);
+      return enter(ast.source_);
     }
     case 'atom': {
       if (ast.source_ === '~') {
@@ -140,66 +120,82 @@ export function patternifyAST(ast, code) {
         console.warn('no location for', ast);
         return ast.source_;
       }
-      const { start, end } = ast.location_;
       const value = !isNaN(Number(ast.source_)) ? Number(ast.source_) : ast.source_;
-      // the following line expects the shapeshifter append .withMiniLocation
-      // because location_ is only relative to the mini string, but we need it relative to whole code
-      // make sure whitespaces are not part of the highlight:
-      const actual = code?.split('').slice(start.offset, end.offset).join('');
-      const [offsetStart = 0, offsetEnd = 0] = actual
-        ? actual.split(ast.source_).map((p) => p.split('').filter((c) => c === ' ').length)
-        : [];
-      return strudel
-        .pure(value)
-        .withLocation(
-          [start.line, start.column + offsetStart, start.offset + offsetStart],
-          [start.line, end.column - offsetEnd, end.offset - offsetEnd],
-        );
+      if (offset === -1) {
+        // skip location handling (used when getting leaves to avoid confusion)
+        return strudel.pure(value);
+      }
+      const [from, to] = getLeafLocation(code, ast, offset);
+      return strudel.pure(value).withLoc(from, to);
     }
     case 'stretch':
-      return patternifyAST(ast.source_, code).slow(patternifyAST(ast.arguments_.amount, code));
-    /* case 'scale':
-      let [tonic, scale] = Scale.tokenize(ast.arguments_.scale);
-      const intervals = Scale.get(scale).intervals;
-      const pattern = patternifyAST(ast.source_);
-      tonic = tonic || 'C4';
-      // console.log('scale', ast, pattern, tonic, scale);
-      console.log('tonic', tonic);
-      return pattern.fmap((step: any) => {
-        step = Number(step);
-        if (isNaN(step)) {
-          console.warn(`scale step "${step}" not a number`);
-          return step;
-        }
-        const octaves = Math.floor(step / intervals.length);
-        const mod = (n: number, m: number): number => (n < 0 ? mod(n + m, m) : n % m);
-        const index = mod(step, intervals.length); // % with negative numbers. e.g. -1 % 3 = 2
-        const interval = Interval.add(intervals[index], Interval.fromSemitones(octaves * 12));
-        return Note.transpose(tonic, interval || '1P');
-      }); */
-    /* case 'struct':
-      // TODO:
-      return strudel.silence; */
+      return enter(ast.source_).slow(enter(ast.arguments_.amount));
     default:
       console.warn(`node type "${ast.type_}" not implemented -> returning silence`);
       return strudel.silence;
   }
 }
 
+// takes quoted mini string + leaf node within, returns source location of node (whitespace corrected)
+export const getLeafLocation = (code, leaf, globalOffset = 0) => {
+  // value is expected without quotes!
+  const { start, end } = leaf.location_;
+  const actual = code?.split('').slice(start.offset, end.offset).join('');
+  // make sure whitespaces are not part of the highlight
+  const [offsetStart = 0, offsetEnd = 0] = actual
+    ? actual.split(leaf.source_).map((p) => p.split('').filter((c) => c === ' ').length)
+    : [];
+  return [start.offset + offsetStart + globalOffset, end.offset - offsetEnd + globalOffset];
+};
+
+// takes quoted mini string, returns ast
+export const mini2ast = (code) => krill.parse(code);
+
+// takes quoted mini string, returns all nodes that are leaves
+export const getLeaves = (code) => {
+  const ast = mini2ast(code);
+  let leaves = [];
+  patternifyAST(
+    ast,
+    code,
+    (node) => {
+      if (node.type_ === 'atom') {
+        leaves.push(node);
+      }
+    },
+    -1,
+  );
+  return leaves;
+};
+
+// takes quoted mini string, returns locations [fromCol,toCol] of all leaf nodes
+export const getLeafLocations = (code, offset = 0) => {
+  return getLeaves(code).map((l) => getLeafLocation(code, l, offset));
+};
+
 // mini notation only (wraps in "")
 export const mini = (...strings) => {
   const pats = strings.map((str) => {
     const code = `"${str}"`;
-    const ast = krill.parse(code);
+    const ast = mini2ast(code);
     return patternifyAST(ast, code);
   });
   return strudel.sequence(...pats);
 };
 
+// turns str mini string (without quotes) into pattern
+// offset is the position of the mini string in the JS code
+// each leaf node will get .withLoc added
+// this function is used by the transpiler for double quoted strings
+export const m = (str, offset) => {
+  const code = `"${str}"`;
+  const ast = mini2ast(code);
+  return patternifyAST(ast, code, null, offset);
+};
+
 // includes haskell style (raw krill parsing)
 export const h = (string) => {
-  const ast = krill.parse(string);
-  // console.log('ast', ast);
+  const ast = mini2ast(string);
   return patternifyAST(ast, string);
 };
 
@@ -209,3 +205,8 @@ export function minify(thing) {
   }
   return strudel.reify(thing);
 }
+
+// calling this function will cause patterns to parse strings as mini notation by default
+export function miniAllStrings() {
+  strudel.setStringParser(mini);
+}

packages/mini/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel.cycles/mini",
-  "version": "0.6.0",
+  "version": "0.8.2",
   "description": "Mini notation for strudel",
   "main": "index.mjs",
   "type": "module",
@@ -35,8 +35,8 @@
     "@strudel.cycles/core": "workspace:*"
   },
   "devDependencies": {
-    "peggy": "^2.0.1",
-    "vite": "^3.2.2",
-    "vitest": "^0.25.7"
+    "peggy": "^3.0.2",
+    "vite": "^4.3.3",
+    "vitest": "^0.33.0"
   }
 }

packages/mini/test/mini.test.mjs

@@ -4,7 +4,7 @@ Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/st
 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 { mini } from '../mini.mjs';
+import { getLeafLocation, getLeafLocations, mini, mini2ast } from '../mini.mjs';
 import '@strudel.cycles/core/euclid.mjs';
 import { describe, expect, it } from 'vitest';
 
@@ -140,7 +140,22 @@ describe('mini', () => {
     expect(haps.length < 230).toBe(true);
     // 'Had too many cycles remaining after degradeBy 0.8');
   });
-  /*it('supports the random choice operator ("|") with nesting', () => {
+  it('supports multiple independent uses of the random choice operator ("|")', () => {
+    const numCycles = 1000;
+    const values = mini('[a|b] [a|b]')
+      .queryArc(0, numCycles)
+      .map((e) => e.value);
+    const observed = { aa: 0, ab: 0, ba: 0, bb: 0 };
+    for (let i = 0; i < values.length; i += 2) {
+      const chunk = values.slice(i, i + 2);
+      observed[chunk.join('')]++;
+    }
+    for (const count of Object.values(observed)) {
+      // Should fall within 99% confidence interval for binomial with p=0.25.
+      expect(215 <= count && count <= 286).toBe(true);
+    }
+  });
+  it('supports the random choice operator ("|") with nesting', () => {
     const numCycles = 900;
     const haps = mini('a | [b | c] | [d | e | f]').queryArc(0, numCycles);
     // Should have about 1/3 a, 1/6 each of b | c, and 1/9 each of d | e | f.
@@ -165,6 +180,41 @@ describe('mini', () => {
     // 15.086 is the chisq for 5 degrees of freedom at 99%, so for 99% of uniformly-distributed
     //  PRNG, this test should succeed
     expect(chisq <= 15.086).toBe(true);
-    // assert(chisq <= 15.086, chisq + ' was expected to be less than 15.086 under chi-squared test');
-  });*/
+  });
+  it('supports lists', () => {
+    expect(minV('a:b c:d:[e:f] g')).toEqual([['a', 'b'], ['c', 'd', ['e', 'f']], 'g']);
+  });
+});
+
+describe('getLeafLocation', () => {
+  it('gets location of leaf nodes', () => {
+    const code = '"bd sd"';
+    const ast = mini2ast(code);
+
+    const bd = ast.source_[0].source_;
+    expect(getLeafLocation(code, bd)).toEqual([1, 3]);
+
+    const sd = ast.source_[1].source_;
+    expect(getLeafLocation(code, sd)).toEqual([4, 6]);
+  });
+});
+
+describe('getLeafLocations', () => {
+  it('gets locations of leaf nodes', () => {
+    expect(getLeafLocations('"bd sd"')).toEqual([
+      [1, 3], // bd columns
+      [4, 6], // sd columns
+    ]);
+    expect(getLeafLocations('"bd*2 [sd cp]"')).toEqual([
+      [1, 3], // bd columns
+      [7, 9], // sd columns
+      [10, 12], // cp columns
+      [4, 5], // "2" columns
+    ]);
+    expect(getLeafLocations('"bd*<2 3>"')).toEqual([
+      [1, 3], // bd columns
+      [5, 6], // "2" columns
+      [7, 8], // "3" columns
+    ]);
+  });
 });

packages/osc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel.cycles/osc",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "OSC messaging for strudel",
   "main": "osc.mjs",
   "publishConfig": {
@@ -40,7 +40,7 @@
     "osc-js": "^2.4.0"
   },
   "devDependencies": {
-    "pkg": "^5.7.0",
-    "vite": "^3.2.2"
+    "pkg": "^5.8.1",
+    "vite": "^4.3.3"
   }
 }

packages/react/examples/nano-repl/README.md

@@ -0,0 +1,15 @@
+# nano-repl
+
+this is an example of how to create a repl with strudel and react.
+
+## Usage
+
+after cloning the strudel repo:
+
+```sh
+pnpm i
+cd packages/react/examples/nano-repl
+pnpm dev
+```
+
+you should now have a repl running at `http://localhost:5173/`

packages/react/examples/nano-repl/package.json

@@ -15,17 +15,18 @@
     "@strudel.cycles/osc": "workspace:*",
     "@strudel.cycles/mini": "workspace:*",
     "@strudel.cycles/transpiler": "workspace:*",
+    "@strudel.cycles/soundfonts": "workspace:*",
     "@strudel.cycles/webaudio": "workspace:*",
     "@strudel.cycles/tonal": "workspace:*",
     "@strudel.cycles/react": "workspace:*"
   },
   "devDependencies": {
-    "@types/react": "^18.0.17",
-    "@types/react-dom": "^18.0.6",
-    "@vitejs/plugin-react": "^2.0.1",
-    "autoprefixer": "^10.4.8",
-    "postcss": "^8.4.16",
-    "tailwindcss": "^3.1.8",
-    "vite": "^3.0.7"
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.1",
+    "@vitejs/plugin-react": "^4.0.0",
+    "autoprefixer": "^10.4.14",
+    "postcss": "^8.4.23",
+    "tailwindcss": "^3.3.2",
+    "vite": "^4.3.3"
   }
 }

packages/react/examples/nano-repl/src/App.jsx

@@ -1,22 +1,34 @@
 import { controls, evalScope } from '@strudel.cycles/core';
 import { CodeMirror, useHighlighting, useKeydown, useStrudel, flash } from '@strudel.cycles/react';
-import { getAudioContext, initAudioOnFirstClick, panic, webaudioOutput } from '@strudel.cycles/webaudio';
+import {
+  getAudioContext,
+  initAudioOnFirstClick,
+  panic,
+  webaudioOutput,
+  registerSynthSounds,
+} from '@strudel.cycles/webaudio';
+import { registerSoundfonts } from '@strudel.cycles/soundfonts';
 import { useCallback, useState } from 'react';
 import './style.css';
 // import { prebake } from '../../../../../repl/src/prebake.mjs';
 
 initAudioOnFirstClick();
 
-// TODO: only import stuff when play is pressed?
-evalScope(
-  controls,
-  import('@strudel.cycles/core'),
-  import('@strudel.cycles/tonal'),
-  import('@strudel.cycles/mini'),
-  import('@strudel.cycles/xen'),
-  import('@strudel.cycles/webaudio'),
-  import('@strudel.cycles/osc'),
-);
+async function init() {
+  // TODO: only import stuff when play is pressed?
+  const loadModules = evalScope(
+    controls,
+    import('@strudel.cycles/core'),
+    import('@strudel.cycles/tonal'),
+    import('@strudel.cycles/mini'),
+    import('@strudel.cycles/xen'),
+    import('@strudel.cycles/webaudio'),
+    import('@strudel.cycles/osc'),
+  );
+
+  await Promise.all([loadModules, registerSynthSounds(), registerSoundfonts()]);
+}
+init();
 
 const defaultTune = `samples({
   bd: ['bd/BT0AADA.wav','bd/BT0AAD0.wav','bd/BT0A0DA.wav','bd/BT0A0D3.wav','bd/BT0A0D0.wav','bd/BT0A0A7.wav'],
@@ -31,7 +43,7 @@ stack(
   .off(1/8,x=>x.add(12).degradeBy(.5)) // random octave jumps
   .add(perlin.range(0,.5)) // random pitch variation
   .superimpose(add(.05)) // add second, slightly detuned voice
-  .n() // wrap in "n"
+  .note() // wrap in "note"
   .decay(.15).sustain(0) // make each note of equal length
   .s('sawtooth') // waveform
   .gain(.4) // turn down
@@ -40,7 +52,7 @@ stack(
   ,"<Am7!3 <Em7 E7b13 Em7 Ebm7b5>>".voicings('lefthand') // chords
   .superimpose(x=>x.add(.04)) // add second, slightly detuned voice
   .add(perlin.range(0,.5)) // random pitch variation
-  .n() // wrap in "n"
+  .note() // wrap in "n"
   .s('square') // waveform
   .gain(.16) // turn down
   .cutoff(500) // fixed cutoff
@@ -49,7 +61,7 @@ stack(
   ,"a4 c5 <e6 a6>".struct("x(5,8)")
   .superimpose(x=>x.add(.04)) // add second, slightly detuned voice
   .add(perlin.range(0,.5)) // random pitch variation
-  .n() // wrap in "n"
+  .note() // wrap in "note"
   .decay(.1).sustain(0) // make notes short
   .s('triangle') // waveform
   .degradeBy(perlin.range(0,.5)) // randomly controlled random removal :)
@@ -66,17 +78,18 @@ function App() {
   const [code, setCode] = useState(defaultTune);
   const [view, setView] = useState();
   // const [code, setCode] = useState(`"c3".note().slow(2)`);
-  const { scheduler, evaluate, schedulerError, evalError, isDirty, activeCode, pattern } = useStrudel({
+  const { scheduler, evaluate, schedulerError, evalError, isDirty, activeCode, pattern, started } = useStrudel({
     code,
     defaultOutput: webaudioOutput,
     getTime,
+    afterEval: ({ meta }) => setMiniLocations(meta.miniLocations),
   });
 
-  useHighlighting({
+  const { setMiniLocations } = useHighlighting({
     view,
     pattern,
-    active: !activeCode?.includes('strudel disable-highlighting'),
-    getTime: () => scheduler.getPhase(),
+    active: started && !activeCode?.includes('strudel disable-highlighting'),
+    getTime: () => scheduler.now(),
   });
 
   const error = evalError || schedulerError;
@@ -103,7 +116,7 @@ function App() {
           }
         }
       },
-      [scheduler, evaluate, view],
+      [scheduler, evaluate, view, code],
     ),
   );
   return (

packages/react/examples/nano-repl/src/style.css

@@ -2,6 +2,18 @@
 @tailwind components;
 @tailwind utilities;
 
+:root {
+  --background: #222;
+  --lineBackground: #22222250;
+  --foreground: #fff;
+  --caret: #ffcc00;
+  --selection: rgba(128, 203, 196, 0.5);
+  --selectionMatch: #036dd626;
+  --lineHighlight: #00000050;
+  --gutterBackground: transparent;
+  --gutterForeground: #8a919966;
+}
+
 body {
   background: #123;
 }

packages/react/examples/nano-repl/tailwind.config.cjs

@@ -6,9 +6,23 @@ This program is free software: you can redistribute it and/or modify it under th
 
 module.exports = {
   // TODO: find out if leaving out tutorial path works now
-  content: ['./src/**/*.{js,jsx,ts,tsx}'],
+  content: ['./src/**/*.{js,jsx,ts,tsx}', '../../src/**/*.{html,js,jsx,md,mdx,ts,tsx}'],
   theme: {
-    extend: {},
+    extend: {
+      colors: {
+        // codemirror-theme settings
+        background: 'var(--background)',
+        lineBackground: 'var(--lineBackground)',
+        foreground: 'var(--foreground)',
+        caret: 'var(--caret)',
+        selection: 'var(--selection)',
+        selectionMatch: 'var(--selectionMatch)',
+        gutterBackground: 'var(--gutterBackground)',
+        gutterForeground: 'var(--gutterForeground)',
+        gutterBorder: 'var(--gutterBorder)',
+        lineHighlight: 'var(--lineHighlight)',
+      },
+    },
   },
   plugins: [],
 };

packages/react/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel.cycles/react",
-  "version": "0.6.4",
+  "version": "0.8.0",
   "description": "React components for strudel",
   "main": "src/index.js",
   "publishConfig": {
@@ -32,33 +32,34 @@
   },
   "homepage": "https://github.com/tidalcycles/strudel#readme",
   "dependencies": {
-    "@codemirror/autocomplete": "^6.4.0",
-    "@codemirror/lang-javascript": "^6.1.1",
+    "@codemirror/autocomplete": "^6.6.0",
+    "@codemirror/lang-javascript": "^6.1.7",
     "@codemirror/state": "^6.2.0",
-    "@codemirror/view": "^6.7.3",
-    "@lezer/highlight": "^1.1.3",
-    "@replit/codemirror-emacs": "^6.0.0",
-    "@replit/codemirror-vim": "^6.0.6",
+    "@codemirror/view": "^6.10.0",
+    "@lezer/highlight": "^1.1.4",
+    "@replit/codemirror-emacs": "^6.0.1",
+    "@replit/codemirror-vim": "^6.0.14",
     "@strudel.cycles/core": "workspace:*",
     "@strudel.cycles/transpiler": "workspace:*",
     "@strudel.cycles/webaudio": "workspace:*",
-    "@uiw/codemirror-themes": "^4.12.4",
-    "@uiw/react-codemirror": "^4.12.4",
+    "@strudel/codemirror": "workspace:*",
+    "@uiw/codemirror-themes": "^4.19.16",
+    "@uiw/react-codemirror": "^4.19.16",
     "react-hook-inview": "^4.5.0"
   },
   "peerDependencies": {
-    "react": "^17.0.2",
-    "react-dom": "^17.0.2"
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
   },
   "devDependencies": {
-    "@types/react": "^17.0.2",
-    "@types/react-dom": "^17.0.2",
-    "@vitejs/plugin-react": "^2.2.0",
-    "autoprefixer": "^10.4.7",
-    "postcss": "^8.4.18",
-    "react": "^17.0.2",
-    "react-dom": "^17.0.2",
-    "tailwindcss": "^3.0.24",
-    "vite": "^3.2.2"
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.1",
+    "@vitejs/plugin-react": "^4.0.0",
+    "autoprefixer": "^10.4.14",
+    "postcss": "^8.4.23",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "tailwindcss": "^3.3.2",
+    "vite": "^4.3.3"
   }
 }

packages/react/src/App.jsx

@@ -8,8 +8,6 @@ evalScope(
   import('@strudel.cycles/core'),
   import('@strudel.cycles/tonal'),
   import('@strudel.cycles/mini'),
-  import('@strudel.cycles/midi'),
-  import('@strudel.cycles/xen'),
   import('@strudel.cycles/webaudio'),
 );
 

packages/react/src/components/CodeMirror6.jsx

@@ -1,109 +1,38 @@
-import React, { useMemo } from 'react';
-import _CodeMirror from '@uiw/react-codemirror';
-import { EditorView, Decoration } from '@codemirror/view';
-import { StateField, StateEffect } from '@codemirror/state';
-import { javascript } from '@codemirror/lang-javascript';
-import strudelTheme from '../themes/strudel-theme';
-import './style.css';
-import { useCallback } from 'react';
 import { autocompletion } from '@codemirror/autocomplete';
-//import { strudelAutocomplete } from './Autocomplete';
-import { vim } from '@replit/codemirror-vim';
+import { javascript, javascriptLanguage } from '@codemirror/lang-javascript';
+import { EditorView } from '@codemirror/view';
 import { emacs } from '@replit/codemirror-emacs';
-
-export const setFlash = StateEffect.define();
-const flashField = StateField.define({
-  create() {
-    return Decoration.none;
-  },
-  update(flash, tr) {
-    try {
-      for (let e of tr.effects) {
-        if (e.is(setFlash)) {
-          if (e.value) {
-            const mark = Decoration.mark({ attributes: { style: `background-color: #FFCA2880` } });
-            flash = Decoration.set([mark.range(0, tr.newDoc.length)]);
-          } else {
-            flash = Decoration.set([]);
-          }
-        }
-      }
-      return flash;
-    } catch (err) {
-      console.warn('flash error', err);
-      return flash;
-    }
-  },
-  provide: (f) => EditorView.decorations.from(f),
-});
-
-export const flash = (view) => {
-  view.dispatch({ effects: setFlash.of(true) });
-  setTimeout(() => {
-    view.dispatch({ effects: setFlash.of(false) });
-  }, 200);
-};
-
-export const setHighlights = StateEffect.define();
-const highlightField = StateField.define({
-  create() {
-    return Decoration.none;
-  },
-  update(highlights, tr) {
-    try {
-      for (let e of tr.effects) {
-        if (e.is(setHighlights)) {
-          const { haps } = e.value;
-          const marks =
-            haps
-              .map((hap) =>
-                (hap.context.locations || []).map(({ start, end }) => {
-                  // const color = hap.context.color || e.value.color || '#FFCA28';
-                  let from = tr.newDoc.line(start.line).from + start.column;
-                  let to = tr.newDoc.line(end.line).from + end.column;
-                  const l = tr.newDoc.length;
-                  if (from > l || to > l) {
-                    return; // dont mark outside of range, as it will throw an error
-                  }
-                  //const mark = Decoration.mark({ attributes: { style: `outline: 2px solid ${color};` } });
-                  const mark = Decoration.mark({ attributes: { class: `outline outline-2 outline-foreground` } });
-                  return mark.range(from, to);
-                }),
-              )
-              .flat()
-              .filter(Boolean) || [];
-          highlights = Decoration.set(marks, true);
-        }
-      }
-      return highlights;
-    } catch (err) {
-      // console.warn('highlighting error', err);
-      return Decoration.set([]);
-    }
-  },
-  provide: (f) => EditorView.decorations.from(f),
-});
-
-const staticExtensions = [
-  javascript(),
-  highlightField,
+import { vim } from '@replit/codemirror-vim';
+import _CodeMirror from '@uiw/react-codemirror';
+import React, { useCallback, useMemo } from 'react';
+import strudelTheme from '../themes/strudel-theme';
+import { strudelAutocomplete } from './Autocomplete';
+import {
+  highlightExtension,
   flashField,
-  // javascriptLanguage.data.of({ autocomplete: strudelAutocomplete }),
-  // autocompletion({ override: [strudelAutocomplete] }),
-  autocompletion({ override: [] }), // wait for https://github.com/uiwjs/react-codemirror/pull/458
-];
+  flash,
+  highlightMiniLocations,
+  updateMiniLocations,
+} from '@strudel/codemirror';
+import './style.css';
+
+export { flash, highlightMiniLocations, updateMiniLocations };
+
+const staticExtensions = [javascript(), flashField, highlightExtension];
 
 export default function CodeMirror({
   value,
   onChange,
   onViewChanged,
   onSelectionChange,
+  onDocChange,
   theme,
   keybindings,
+  isLineNumbersDisplayed,
+  isAutoCompletionEnabled,
+  isLineWrappingEnabled,
   fontSize = 18,
   fontFamily = 'monospace',
-  options,
-  editorDidMount,
 }) {
   const handleOnChange = useCallback(
     (value) => {
@@ -111,30 +40,52 @@ export default function CodeMirror({
     },
     [onChange],
   );
+
   const handleOnCreateEditor = useCallback(
     (view) => {
       onViewChanged?.(view);
     },
     [onViewChanged],
   );
+
   const handleOnUpdate = useCallback(
     (viewUpdate) => {
+      if (viewUpdate.docChanged && onDocChange) {
+        onDocChange?.(viewUpdate);
+      }
       if (viewUpdate.selectionSet && onSelectionChange) {
         onSelectionChange?.(viewUpdate.state.selection);
       }
     },
     [onSelectionChange],
   );
+
   const extensions = useMemo(() => {
+    let _extensions = [...staticExtensions];
     let bindings = {
       vim,
       emacs,
     };
+
     if (bindings[keybindings]) {
-      return [...staticExtensions, bindings[keybindings]()];
+      _extensions.push(bindings[keybindings]());
     }
-    return staticExtensions;
-  }, [keybindings]);
+
+    if (isAutoCompletionEnabled) {
+      _extensions.push(javascriptLanguage.data.of({ autocomplete: strudelAutocomplete }));
+    } else {
+      _extensions.push(autocompletion({ override: [] }));
+    }
+
+    if (isLineWrappingEnabled) {
+      _extensions.push(EditorView.lineWrapping);
+    }
+
+    return _extensions;
+  }, [keybindings, isAutoCompletionEnabled, isLineWrappingEnabled]);
+
+  const basicSetup = useMemo(() => ({ lineNumbers: isLineNumbersDisplayed }), [isLineNumbersDisplayed]);
+
   return (
     <div style={{ fontSize, fontFamily }} className="w-full">
       <_CodeMirror
@@ -144,107 +95,8 @@ export default function CodeMirror({
         onCreateEditor={handleOnCreateEditor}
         onUpdate={handleOnUpdate}
         extensions={extensions}
+        basicSetup={basicSetup}
       />
     </div>
   );
 }
-
-let parenMark;
-export const markParens = (editor, data) => {
-  const v = editor.getDoc().getValue();
-  const marked = getCurrentParenArea(v, data);
-  parenMark?.clear();
-  parenMark = editor.getDoc().markText(...marked, { css: 'background-color: #00007720' }); //
-};
-
-// returns { line, ch } from absolute character offset
-export function offsetToPosition(offset, code) {
-  const lines = code.split('\n');
-  let line = 0;
-  let ch = 0;
-  for (let i = 0; i < offset; i++) {
-    if (ch === lines[line].length) {
-      line++;
-      ch = 0;
-    } else {
-      ch++;
-    }
-  }
-  return { line, ch };
-}
-
-// returns absolute character offset from { line, ch }
-export function positionToOffset(position, code) {
-  const lines = code.split('\n');
-  if (position.line > lines.length) {
-    // throw new Error('positionToOffset: position.line > lines.length');
-    return 0;
-  }
-  let offset = 0;
-  for (let i = 0; i < position.line; i++) {
-    offset += lines[i].length + 1;
-  }
-  offset += position.ch;
-  return offset;
-}
-
-// given code and caret position, the functions returns the indices of the parens we are in
-export function getCurrentParenArea(code, caretPosition) {
-  const caret = positionToOffset(caretPosition, code);
-  let open, i, begin, end;
-  // walk left
-  i = caret;
-  open = 0;
-  while (i > 0) {
-    if (code[i - 1] === '(') {
-      open--;
-    } else if (code[i - 1] === ')') {
-      open++;
-    }
-    if (open === -1) {
-      break;
-    }
-    i--;
-  }
-  begin = i;
-  // walk right
-  i = caret;
-  open = 0;
-  while (i < code.length) {
-    if (code[i] === '(') {
-      open--;
-    } else if (code[i] === ')') {
-      open++;
-    }
-    if (open === 1) {
-      break;
-    }
-    i++;
-  }
-  end = i;
-  return [begin, end].map((o) => offsetToPosition(o, code));
-}
-
-/* 
-export const markEvent = (editor) => (time, event) => {
-  const locs = event.context.locations;
-  if (!locs || !editor) {
-    return;
-  }
-  const col = event.context?.color || '#FFCA28';
-  // mark active event
-  const marks = locs.map(({ start, end }) =>
-    editor.getDoc().markText(
-      { line: start.line - 1, ch: start.column },
-      { line: end.line - 1, ch: end.column },
-      //{ css: 'background-color: #FFCA28; color: black' } // background-color is now used by parent marking
-      { css: 'outline: 1px solid ' + col + '; box-sizing:border-box' },
-      //{ css: `background-color: ${col};border-radius:5px` },
-    ),
-  );
-  //Tone.Transport.schedule(() => { // problem: this can be cleared by scheduler...
-  setTimeout(() => {
-    marks.forEach((mark) => mark.clear());
-    // }, '+' + event.duration * 0.5);
-  }, event.duration * 1000);
-}; */

packages/react/src/components/MiniRepl.jsx

@@ -18,16 +18,24 @@ export function MiniRepl({
   tune,
   hideOutsideView = false,
   enableKeyboard,
+  onTrigger,
   drawTime,
   punchcard,
+  punchcardLabels,
+  onPaint,
   canvasHeight = 200,
+  fontSize = 18,
+  fontFamily,
+  hideHeader = false,
   theme,
+  keybindings,
+  isLineNumbersDisplayed,
 }) {
   drawTime = drawTime || (punchcard ? [0, 4] : undefined);
   const evalOnMount = !!drawTime;
   const drawContext = useCallback(
-    !!drawTime ? (canvasId) => document.querySelector('#' + canvasId)?.getContext('2d') : null,
-    [drawTime],
+    punchcard ? (canvasId) => document.querySelector('#' + canvasId)?.getContext('2d') : null,
+    [punchcard],
   );
   const {
     code,
@@ -47,11 +55,23 @@ export function MiniRepl({
   } = useStrudel({
     initialCode: tune,
     defaultOutput: webaudioOutput,
-    editPattern: (pat) => (punchcard ? pat.punchcard() : pat),
+    editPattern: (pat, id) => {
+      //pat = pat.withContext((ctx) => ({ ...ctx, id }));
+      if (onTrigger) {
+        pat = pat.onTrigger(onTrigger, false);
+      }
+      if (onPaint) {
+        pat = pat.onPaint(onPaint);
+      } else if (punchcard) {
+        pat = pat.punchcard({ labels: punchcardLabels });
+      }
+      return pat;
+    },
     getTime,
     evalOnMount,
     drawContext,
     drawTime,
+    afterEval: ({ meta }) => setMiniLocations(meta.miniLocations),
   });
 
   const [view, setView] = useState();
@@ -65,7 +85,7 @@ export function MiniRepl({
     }
     return isVisible || wasVisible.current;
   }, [isVisible, hideOutsideView]);
-  useHighlighting({
+  const { setMiniLocations } = useHighlighting({
     view,
     pattern,
     active: started && !activeCode?.includes('strudel disable-highlighting'),
@@ -82,7 +102,7 @@ export function MiniRepl({
               e.preventDefault();
               flash(view);
               await activateCode();
-            } else if (e.code === 'Period') {
+            } else if (e.key === '.' || e.code === 'Period') {
               stop();
               e.preventDefault();
             }
@@ -93,26 +113,6 @@ export function MiniRepl({
     ),
   );
 
-  // set active pattern on ctrl+enter
-  useLayoutEffect(() => {
-    if (enableKeyboard) {
-      const handleKeyPress = async (e) => {
-        if (e.ctrlKey || e.altKey) {
-          if (e.code === 'Enter') {
-            e.preventDefault();
-            flash(view);
-            await activateCode();
-          } else if (e.code === 'Period') {
-            stop();
-            e.preventDefault();
-          }
-        }
-      };
-      window.addEventListener('keydown', handleKeyPress, true);
-      return () => window.removeEventListener('keydown', handleKeyPress, true);
-    }
-  }, [enableKeyboard, pattern, code, evaluate, stop, view]);
-
   const [log, setLog] = useState([]);
   useLogger(
     useCallback((e) => {
@@ -121,7 +121,7 @@ export function MiniRepl({
       // const logId = data?.pattern?.meta?.id;
       if (logId === replId) {
         setLog((l) => {
-          return l.concat([e.detail]).slice(-10);
+          return l.concat([e.detail]).slice(-8);
         });
       }
     }, []),
@@ -129,33 +129,46 @@ export function MiniRepl({
 
   return (
     <div className="overflow-hidden rounded-t-md bg-background border border-lineHighlight" ref={ref}>
-      <div className="flex justify-between bg-lineHighlight">
-        <div className="flex">
-          <button
-            className={cx(
-              'cursor-pointer w-16 flex items-center justify-center p-1 border-r border-lineHighlight text-foreground bg-lineHighlight hover:bg-background',
-              started ? 'animate-pulse' : '',
-            )}
-            onClick={() => togglePlay()}
-          >
-            <Icon type={started ? 'stop' : 'play'} />
-          </button>
-          <button
-            className={cx(
-              'w-16 flex items-center justify-center p-1 text-foreground border-lineHighlight bg-lineHighlight',
-              isDirty ? 'text-foreground hover:bg-background cursor-pointer' : 'opacity-50 cursor-not-allowed',
-            )}
-            onClick={() => activateCode()}
-          >
-            <Icon type="refresh" />
-          </button>
+      {!hideHeader && (
+        <div className="flex justify-between bg-lineHighlight">
+          <div className="flex">
+            <button
+              className={cx(
+                'cursor-pointer w-16 flex items-center justify-center p-1 border-r border-lineHighlight text-foreground bg-lineHighlight hover:bg-background',
+                started ? 'animate-pulse' : '',
+              )}
+              onClick={() => togglePlay()}
+            >
+              <Icon type={started ? 'stop' : 'play'} />
+            </button>
+            <button
+              className={cx(
+                'w-16 flex items-center justify-center p-1 text-foreground border-lineHighlight bg-lineHighlight',
+                isDirty ? 'text-foreground hover:bg-background cursor-pointer' : 'opacity-50 cursor-not-allowed',
+              )}
+              onClick={() => activateCode()}
+            >
+              <Icon type="refresh" />
+            </button>
+          </div>
         </div>
-        {error && <div className="text-right p-1 text-sm text-red-200">{error.message}</div>}
-      </div>
+      )}
       <div className="overflow-auto relative">
-        {show && <CodeMirror6 value={code} onChange={setCode} onViewChanged={setView} theme={theme} />}
+        {show && (
+          <CodeMirror6
+            value={code}
+            onChange={setCode}
+            onViewChanged={setView}
+            theme={theme}
+            fontFamily={fontFamily}
+            fontSize={fontSize}
+            keybindings={keybindings}
+            isLineNumbersDisplayed={isLineNumbersDisplayed}
+          />
+        )}
+        {error && <div className="text-right p-1 text-md text-red-200">{error.message}</div>}
       </div>
-      {drawTime && (
+      {punchcard && (
         <canvas
           id={canvasId}
           className="w-full pointer-events-none"

packages/react/src/components/style.css

@@ -1,6 +1,6 @@
 :root {
   --background: #222;
-  --lineBackground: #22222250;
+  --lineBackground: #22222299;
   --foreground: #fff;
   --caret: #ffcc00;
   --selection: rgba(128, 203, 196, 0.5);
@@ -24,3 +24,7 @@
 .cm-theme-light {
   width: 100%;
 }
+
+footer {
+  z-index: 0 !important;
+}

packages/react/src/hooks/useHighlighting.mjs

@@ -1,10 +1,18 @@
-import { useEffect, useRef } from 'react';
-import { setHighlights } from '../components/CodeMirror6';
+import { useEffect, useRef, useState } from 'react';
+import { highlightMiniLocations, updateMiniLocations } from '../components/CodeMirror6';
 const round = (x) => Math.round(x * 1000) / 1000;
 
 function useHighlighting({ view, pattern, active, getTime }) {
   const highlights = useRef([]);
   const lastEnd = useRef(0);
+
+  const [miniLocations, setMiniLocations] = useState([]);
+  useEffect(() => {
+    if (view) {
+      updateMiniLocations(view, miniLocations);
+    }
+  }, [view, miniLocations]);
+
   useEffect(() => {
     if (view) {
       if (pattern && active) {
@@ -17,12 +25,12 @@ function useHighlighting({ view, pattern, active, getTime }) {
             const begin = Math.max(lastEnd.current ?? audioTime, audioTime - 1 / 10, -0.01); // negative time seems buggy
             const span = [round(begin), round(audioTime + 1 / 60)];
             lastEnd.current = span[1];
-            highlights.current = highlights.current.filter((hap) => hap.whole.end > audioTime); // keep only highlights that are still active
+            highlights.current = highlights.current.filter((hap) => hap.endClipped > audioTime); // keep only highlights that are still active
             const haps = pattern.queryArc(...span).filter((hap) => hap.hasOnset());
             highlights.current = highlights.current.concat(haps); // add potential new onsets
-            view.dispatch({ effects: setHighlights.of({ haps: highlights.current }) }); // highlight all still active + new active haps
+            highlightMiniLocations(view, begin, highlights.current);
           } catch (err) {
-            view.dispatch({ effects: setHighlights.of({ haps: [] }) });
+            highlightMiniLocations(view, 0, []);
           }
           frame = requestAnimationFrame(updateHighlights);
         });
@@ -31,10 +39,12 @@ function useHighlighting({ view, pattern, active, getTime }) {
         };
       } else {
         highlights.current = [];
-        view.dispatch({ effects: setHighlights.of({ haps: [] }) });
+        highlightMiniLocations(view, 0, highlights.current);
       }
     }
   }, [pattern, active, view]);
+
+  return { setMiniLocations };
 }
 
 export default useHighlighting;

packages/react/src/hooks/useStrudel.mjs

@@ -29,7 +29,8 @@ function useStrudel({
   const [pattern, setPattern] = useState();
   const [started, setStarted] = useState(false);
   const isDirty = code !== activeCode;
-  const shouldPaint = useCallback((pat) => !!(pat?.context?.onPaint && drawContext), [drawContext]);
+  //const shouldPaint = useCallback((pat) => !!(pat?.context?.onPaint && drawContext), [drawContext]);
+  const shouldPaint = useCallback((pat) => !!pat?.context?.onPaint, []);
 
   // TODO: make sure this hook reruns when scheduler.started changes
   const { scheduler, evaluate, start, stop, pause, setCps } = useMemo(
@@ -46,9 +47,9 @@ function useStrudel({
         drawContext,
         transpiler,
         editPattern,
-        beforeEval: ({ code }) => {
+        beforeEval: async ({ code }) => {
           setCode(code);
-          beforeEval?.();
+          await beforeEval?.();
         },
         afterEval: (res) => {
           const { pattern: _pattern, code } = res;

packages/react/src/index.js

@@ -1,6 +1,6 @@
 // import 'tailwindcss/tailwind.css';
 
-export { default as CodeMirror, flash } from './components/CodeMirror6'; // !SSR
+export { default as CodeMirror, flash, updateMiniLocations, highlightMiniLocations } from './components/CodeMirror6'; // !SSR
 export * from './components/MiniRepl'; // !SSR
 export { default as useHighlighting } from './hooks/useHighlighting'; // !SSR
 export { default as useStrudel } from './hooks/useStrudel'; // !SSR

packages/react/src/main.jsx

@@ -1,10 +1,9 @@
 import React from 'react';
-import ReactDOM from 'react-dom';
 import App from './App';
+import { createRoot } from 'react-dom/client';
 
-ReactDOM.render(
+createRoot(document.getElementById('root')).render(
   <React.StrictMode>
     <App />
   </React.StrictMode>,
-  document.getElementById('root'),
 );

packages/react/vite.config.js

@@ -22,8 +22,6 @@ export default defineConfig({
         ...Object.keys(peerDependencies),
         ...Object.keys(dependencies),
         // TODO: find out which of below names are obsolete now
-        '@strudel.cycles/tone',
-        '@strudel.cycles/eval',
         '@strudel.cycles/transpiler',
         'acorn',
         '@strudel.cycles/core',

packages/serial/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel.cycles/serial",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Webserial API for strudel",
   "main": "serial.mjs",
   "publishConfig": {
@@ -32,6 +32,6 @@
     "@strudel.cycles/core": "workspace:*"
   },
   "devDependencies": {
-    "vite": "^3.2.2"
+    "vite": "^4.3.3"
   }
 }

packages/soundfonts/fontloader.mjs

@@ -1,4 +1,6 @@
-import { toMidi } from '@strudel.cycles/core';
+import { noteToMidi, freqToMidi } from '@strudel.cycles/core';
+import { getAudioContext, registerSound, getEnvelope } from '@strudel.cycles/webaudio';
+import gm from './gm.mjs';
 
 let loadCache = {};
 async function loadFont(name) {
@@ -8,7 +10,6 @@ async function loadFont(name) {
   const load = async () => {
     // TODO: make soundfont source configurable
     const url = `https://felixroos.github.io/webaudiofontdata/sound/${name}.js`;
-    console.log('load font', name, url);
     const preset = await fetch(url).then((res) => res.text());
     let [_, data] = preset.split('={');
     return eval('{' + data);
@@ -17,15 +18,24 @@ async function loadFont(name) {
   return loadCache[name];
 }
 
-export async function getFontBufferSource(name, pitch, ac) {
-  if (typeof pitch === 'string') {
-    pitch = toMidi(pitch);
+export async function getFontBufferSource(name, value, ac) {
+  let { note = 'c3', freq } = value;
+  let midi;
+  if (freq) {
+    midi = freqToMidi(freq);
+  } else if (typeof note === 'string') {
+    midi = noteToMidi(note);
+  } else if (typeof note === 'number') {
+    midi = note;
+  } else {
+    throw new Error(`unexpected "note" type "${typeof note}"`);
   }
-  const { buffer, zone } = await getFontPitch(name, pitch, ac);
+
+  const { buffer, zone } = await getFontPitch(name, midi, ac);
   const src = ac.createBufferSource();
   src.buffer = buffer;
   const baseDetune = zone.originalPitch - 100.0 * zone.coarseTune - zone.fineTune;
-  const playbackRate = 1.0 * Math.pow(2, (100.0 * pitch - baseDetune) / 1200.0);
+  const playbackRate = 1.0 * Math.pow(2, (100.0 * midi - baseDetune) / 1200.0);
   // src detune?
   src.playbackRate.value = playbackRate;
   const loop = zone.loopStart > 1 && zone.loopStart < zone.loopEnd;
@@ -114,3 +124,32 @@ async function getBuffer(zone, audioContext) {
     }
   }
 }
+
+export function registerSoundfonts() {
+  Object.entries(gm).forEach(([name, fonts]) => {
+    registerSound(
+      name,
+      async (time, value, onended) => {
+        const { n = 0 } = value;
+        const { attack = 0.001, decay = 0.001, sustain = 1, release = 0.001 } = value;
+        const font = fonts[n % fonts.length];
+        const ctx = getAudioContext();
+        const bufferSource = await getFontBufferSource(font, value, ctx);
+        bufferSource.start(time);
+        const { node: envelope, stop: releaseEnvelope } = getEnvelope(attack, decay, sustain, release, 0.3, time);
+        bufferSource.connect(envelope);
+        const stop = (releaseTime) => {
+          bufferSource.stop(releaseTime + release);
+          releaseEnvelope(releaseTime);
+        };
+        bufferSource.onended = () => {
+          bufferSource.disconnect();
+          envelope.disconnect();
+          onended();
+        };
+        return { node: envelope, stop };
+      },
+      { type: 'soundfont', prebake: true, fonts },
+    );
+  });
+}

packages/soundfonts/index.mjs

@@ -1,6 +1,6 @@
-import { getFontBufferSource } from './fontloader.mjs';
+import { getFontBufferSource, registerSoundfonts } from './fontloader.mjs';
 import * as soundfontList from './list.mjs';
 import { startPresetNote } from 'sfumato';
 import { loadSoundfont } from './sfumato.mjs';
 
-export { loadSoundfont, startPresetNote, getFontBufferSource, soundfontList };
+export { loadSoundfont, startPresetNote, getFontBufferSource, soundfontList, registerSoundfonts };

packages/soundfonts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel.cycles/soundfonts",
-  "version": "0.6.0",
+  "version": "0.8.2",
   "description": "Soundsfont support for strudel",
   "main": "index.mjs",
   "publishConfig": {
@@ -36,7 +36,7 @@
     "soundfont2": "^0.4.0"
   },
   "devDependencies": {
-    "node-fetch": "^3.2.6",
-    "vite": "^3.2.2"
+    "node-fetch": "^3.3.1",
+    "vite": "^4.3.3"
   }
 }

packages/soundfonts/sfumato.mjs

@@ -1,5 +1,5 @@
-import { Pattern, getPlayableNoteValue, toMidi } from '@strudel.cycles/core';
-import { getAudioContext } from '@strudel.cycles/webaudio';
+import { Pattern, getPlayableNoteValue, noteToMidi } from '@strudel.cycles/core';
+import { getAudioContext, registerSound } from '@strudel.cycles/webaudio';
 import { loadSoundfont as _loadSoundfont, startPresetNote } from 'sfumato';
 
 Pattern.prototype.soundfont = function (sf, n = 0) {
@@ -8,7 +8,7 @@ Pattern.prototype.soundfont = function (sf, n = 0) {
     const note = getPlayableNoteValue(h);
     const preset = sf.presets[n % sf.presets.length];
     const deadline = ctx.currentTime + t - ct;
-    const args = [ctx, preset, toMidi(note), deadline];
+    const args = [ctx, preset, noteToMidi(note), deadline];
     const stop = startPresetNote(...args);
     stop(deadline + h.duration);
   });
@@ -21,5 +21,29 @@ export function loadSoundfont(url) {
   }
   const sf = _loadSoundfont(url);
   soundfontCache.set(url, sf);
+  /*sf.then((font) => {
+    font.presets.forEach((preset) => {
+      console.log('preset', preset.header.name);
+      registerSound(
+        preset.header.name.replaceAll(' ', '_'),
+        (time, value, onended) => {
+          const ctx = getAudioContext();
+          let { note } = value; // freq ?
+
+          const p = font.presets.find((p) => p.header.name === preset.header.name);
+
+          if (!p) {
+            throw new Error('preset not found');
+          }
+          const deadline = time; // - ctx.currentTime;
+          const args = [ctx, p, noteToMidi(note), deadline];
+          const stop = startPresetNote(...args);
+          return { node: undefined, stop };
+        },
+        { type: 'soundfont' },
+      );
+    });
+    //console.log('f', f);
+  });*/
   return sf;
 }

packages/tonal/index.mjs

@@ -3,3 +3,5 @@ import './voicings.mjs';
 
 export * from './tonal.mjs';
 export * from './voicings.mjs';
+
+import './ireal.mjs';

packages/tonal/ireal.mjs

@@ -0,0 +1,523 @@
+// explore them here: https://codesandbox.io/s/voicing-explorer-ireal-47tkx5?file=/src/ireal.js:0-16036
+// scraped via: https://codesandbox.io/s/ireal-midi-scraper-2-gjz2mr?file=/src/index.js
+
+export const simple = {
+  2: ['1P 5P 8P 9M', '1P 5P 8P 9M 12P', '5P 8P 9M 12P'],
+  5: ['1P 5P 8P 12P', '5P 8P 12P 15P'],
+  6: ['1P 5P 6M 8P 10M', '1P 5P 8P 10M 13M', '3M 5P 8P 10M 13M', '5P 8P 10M 12P 13M'],
+  7: [
+    '1P 5P 7m 8P 10M',
+    '1P 7m 8P 10M 12P',
+    '3M 7m 8P 10M 12P',
+    '3M 7m 8P 10M 14m',
+    '3M 7m 10M 12P 15P',
+    '7m 10M 12P 14m 15P',
+    '7m 10M 12P 15P 17M',
+  ],
+  9: [
+    '1P 5P 7m 9M 10M',
+    '1P 7m 9M 10M 12P',
+    '3M 7m 8P 9M 12P',
+    '7m 9M 10M 14m 15P',
+    '3M 7m 8P 12P 16M',
+    '7m 10M 12P 15P 16M',
+  ],
+  11: ['1P 5P 7m 9M 11P', '5P 7m 8P 9M 11P', '7m 8P 9M 11P 12P', '7m 8P 11P 12P 16M'],
+  13: ['1P 6M 7m 9M 10M', '1P 7m 9M 10M 13M', '3M 7m 8P 9M 13M', '7m 8P 9M 10M 13M', '7m 9M 10M 13M 15P'],
+  69: ['1P 5P 6M 9M 10M', '1P 5P 9M 10M 13M', '3M 5P 8P 9M 13M', '5P 8P 9M 10M 13M'],
+  add9: ['1P 5P 8P 9M 10M', '1P 5P 9M 10M 12P', '3M 8P 9M 10M 12P', '3M 8P 9M 12P 15P', '5P 8P 9M 12P 17M'],
+  '+': [
+    '1P 3M 6m 8P 10M',
+    '1P 6m 8P 10M 13m',
+    '3M 6m 8P 10M 13m',
+    '3M 8P 10M 13m 15P',
+    '6m 8P 10M 13m 15P',
+    '6m 10M 13m 15P 17M',
+  ],
+  o: ['1P 5d 8P 10m 12d', '3m 8P 10m 12d 15P', '5d 8P 10m 12d 15P'],
+  h: [
+    '3m 5d 7m 8P 10m',
+    '1P 5d 7m 10m 12d',
+    '3m 7m 8P 10m 12d',
+    '3m 7m 8P 12d 14m',
+    '5d 7m 8P 10m 14m',
+    '5d 8P 10m 12d 14m',
+    '7m 10m 12d 14m 15P',
+    '5d 8P 10m 14m 17m',
+  ],
+  sus: ['1P 4P 5P 8P', '1P 4P 5P 8P 11P', '5P 8P 11P 12P', '5P 8P 11P 12P 15P'],
+  '^': ['1P 5P 8P 10M', '1P 5P 8P 10M 12P', '3M 5P 8P 10M 12P', '3M 8P 10M 12P 15P', '5P 8P 10M 12P 15P'],
+  '-': ['1P 3m 5P 8P 10m', '1P 5P 8P 10m 12P', '3m 5P 8P 10m 12P', '5P 8P 10m 12P 15P'],
+  '^7': ['1P 5P 7M 10M 12P', '1P 10M 12P 14M', '3M 8P 10M 12P 14M', '5P 8P 10M 12P 14M', '5P 8P 10M 14M 17M'],
+  '-7': [
+    '1P 3m 5P 7m 10m',
+    '1P 5P 7m 10m 12P',
+    '3m 7m 8P 10m 12P',
+    '3m 7m 8P 10m 14m',
+    '5P 7m 8P 10m 14m',
+    '7m 10m 12P 14m 15P',
+    '5P 8P 10m 14m 17m',
+    '7m 10m 12P 15P 17m',
+  ],
+  '7sus': ['1P 5P 7m 8P 11P', '5P 8P 11P 12P 14m', '7m 8P 11P 12P 14m', '7m 11P 12P 14m 18P'],
+  h7: [
+    '3m 5d 7m 8P 10m',
+    '1P 5d 7m 10m 12d',
+    '1P 7m 10m 12d',
+    '3m 7m 8P 10m 12d',
+    '3m 7m 8P 12d 14m',
+    '5d 7m 8P 10m 14m',
+    '5d 8P 10m 12d 14m',
+    '7m 10m 12d 14m 15P',
+    '5d 8P 10m 14m 17m',
+  ],
+  o7: [
+    '1P 6M 8P 10m 12d',
+    '1P 6M 10m 12d 13M',
+    '3m 8P 10m 12d 13M',
+    '3m 8P 12d 13M 15P',
+    '5d 10m 12d 13M 15P',
+    '5d 10m 13M 15P 17m',
+    '6M 12d 13M 15P 17m',
+    '6M 12d 15P 17m 19d',
+  ],
+  '^9': [
+    '1P 5P 7M 9M 10M',
+    '1P 7M 9M 10M 12P',
+    '3M 7M 8P 9M 12P',
+    '3M 7M 8P 12P 16M',
+    '5P 8P 10M 14M 16M',
+    '7M 8P 10M 12P 16M',
+  ],
+  '^13': ['1P 6M 7M 9M 10M', '1P 7M 9M 10M 13M', '3M 7M 8P 9M 13M', '3M 7M 8P 13M 16M', '7M 8P 10M 13M 16M'],
+  '^7#11': ['1P 5P 7M 10M 12d', '3M 7M 8P 10M 12d', '1P 7M 10M 12d 14M', '3M 7M 8P 12d 14M', '5P 8P 10M 12d 14M'],
+  '^9#11': ['1P 3M 5d 7M 9M', '1P 7M 9M 10M 12d', '3M 7M 8P 9M 12d', '3M 8P 9M 12d 14M'],
+  '^7#5': ['1P 6m 7M 10M 13m', '3M 7M 8P 10M 13m', '6m 7M 8P 10M 13m'],
+  '-6': [
+    '1P 3m 5P 6M 8P',
+    '1P 5P 6M 8P 10m',
+    '3m 5P 6M 8P 10m',
+    '1P 5P 8P 10m 13M',
+    '3m 5P 8P 10m 13M',
+    '5P 8P 10m 12P 13M',
+    '5P 8P 10m 13M 15P',
+  ],
+  '-69': [
+    '1P 3m 5P 6M 9M',
+    '3m 5P 6M 8P 9M',
+    '3m 6M 9M 10m 12P',
+    '1P 5P 9M 10m 13M',
+    '3m 5P 8P 9M 13M',
+    '5P 8P 9M 10m 13M',
+    '5P 8P 10m 13M 16M',
+  ],
+  '-^7': ['1P 3m 5P 7M 10m', '1P 5P 7M 10m 12P', '3m 7M 8P 10m 12P', '5P 7M 8P 10m 14M', '5P 8P 10m 14M 17m'],
+  '-^9': ['1P 3m 5P 7M 9M', '1P 7M 9M 10m 12P', '3m 7M 8P 9M 12P', '5P 8P 9M 10m 14M'],
+  '-9': [
+    '1P 3m 5P 7m 9M',
+    '3m 5P 7m 8P 9M',
+    '3m 7m 8P 9M 12P',
+    '5P 8P 9M 10m 14m',
+    '3m 7m 9M 12P 15P',
+    '7m 10m 12P 15P 16M',
+  ],
+  '-add9': ['1P 2M 3m 5P 8P', '1P 3m 5P 9M', '3m 5P 8P 9M 12P', '5P 8P 9M 10m 12P'],
+  '-11': [
+    '1P 3m 7m 9M 11P',
+    '3m 7m 8P 9M 11P',
+    '1P 4P 7m 10m 12P',
+    '5P 8P 11P 14m',
+    '3m 7m 9M 11P 15P',
+    '5P 8P 11P 14m 16M',
+    '7m 10m 12P 15P 18P',
+  ],
+  '-7b5': [
+    '3m 5d 7m 8P 10m',
+    '1P 7m 10m 12d',
+    '1P 5d 7m 10m 12d',
+    '3m 7m 8P 10m 12d',
+    '3m 7m 8P 12d 14m',
+    '5d 7m 8P 10m 14m',
+    '5d 8P 10m 12d 14m',
+    '7m 10m 12d 14m 15P',
+    '5d 8P 10m 14m 17m',
+  ],
+  h9: ['1P 7m 9M 10m 12d', '3m 7m 8P 9M 12d', '5d 8P 9M 10m 14m', '7m 10m 12d 15P 16M'],
+  '-b6': ['1P 5P 6m 8P 10m', '1P 5P 8P 10m 13m', '3m 5P 8P 10m 13m', '5P 8P 10m 13m', '5P 8P 10m 13m 15P'],
+  '-#5': ['1P 6m 8P 10m 13m', '3m 6m 8P 10m 13m', '6m 8P 10m 13m 15P'],
+  '7b9': ['1P 3M 7m 9m 10M', '3M 7m 8P 9m 10M', '3M 7m 8P 9m 14m', '7m 9m 10M 14m 15P'],
+  '7#9': ['1P 3M 7m 10m', '3M 7m 8P 10m 14m', '7m 10m 10M 14m 15P'],
+  '7#11': ['1P 3M 7m 10M 12d', '3M 7m 8P 10M 12d', '7m 10M 12d 14m 15P'],
+  '7b5': ['1P 3M 7m 10M 12d', '3M 7m 8P 10M 12d', '7m 10M 12d 14m 15P'],
+  '7#5': ['1P 3M 7m 10M 13m', '3M 7m 8P 10M 13m', '3M 7m 8P 13m 14m', '7m 10M 13m 14m 15P'],
+  '9#11': ['1P 7m 9M 10M 12d', '3M 7m 8P 9M 12d', '7m 10M 12d 15P 16M'],
+  '9b5': ['1P 7m 9M 10M 12d', '3M 7m 8P 9M 12d', '7m 10M 12d 15P 16M'],
+  '9#5': ['1P 7m 9M 10M 13m', '3M 7m 9M 10M 13m', '3M 7m 9M 13m 14m', '7m 10M 13m 14m 16M', '7m 10M 13m 16M 17M'],
+  '7b13': ['1P 3M 7m 10M 13m', '3M 7m 8P 10M 13m', '3M 7m 8P 13m 14m', '7m 10M 13m 14m 15P'],
+  '7#9#5': ['1P 3M 7m 10m 13m', '3M 7m 10m 13m 15P', '7m 10M 13m 15P 17m'],
+  '7#9b5': ['1P 3M 7m 10m 12d', '3M 7m 10m 12d 15P', '7m 10M 12d 15P 17m'],
+  '7#9#11': ['1P 3M 7m 10m 12d', '3M 7m 10m 12d 15P', '7m 10M 12d 15P 17m'],
+  '7b9#11': ['1P 7m 9m 10M 12d', '3M 7m 8P 9m 12d', '7m 8P 10M 12d 16m'],
+  '7b9b5': ['1P 7m 9m 10M 12d', '3M 7m 8P 9m 12d', '7m 8P 10M 12d 16m'],
+  '7b9#5': ['1P 7m 9m 10M 13m', '3M 7m 8P 9m 13m', '7m 9m 10M 13m 15P'],
+  '7b9#9': ['1P 3M 7m 9m 10m', '3M 7m 8P 9m 10m', '7m 8P 10M 16m 17m'],
+  '7b9b13': ['1P 7m 9m 10M 13m', '3M 7m 8P 9m 13m', '7m 9m 10M 13m 15P'],
+  '7alt': [
+    '3M 7m 8P 9m 12d',
+    '1P 7m 10m 10M 13m',
+    '3M 7m 8P 10m 13m',
+    '3M 7m 9m 12d 15P',
+    '3M 7m 10m 13m 15P',
+    '7m 10M 12d 15P 17m',
+    '7m 10M 13m 15P 17m',
+  ],
+  '13#11': ['1P 6M 7m 10M 12d', '3M 7m 9M 12d 13M', '7m 10M 12d 13M 16M'],
+  '13b9': ['1P 3M 6M 7m 9m', '1P 6M 7m 9m 10M', '3M 7m 9m 10M 13M', '3M 7m 10M 13M 16m', '7m 10M 13M 16m 17M'],
+  '13#9': ['1P 3M 6M 7m 10m', '3M 7m 8P 10m 13M', '7m 10M 13M 14m 17m'],
+  '7b9sus': ['1P 5P 7m 9m 11P', '5P 7m 8P 9m 11P', '7m 8P 11P 14m 16m'],
+  '7susadd3': ['1P 4P 5P 7m 10M', '5P 8P 10M 11P 14m', '7m 11P 12P 15P 17M'],
+  '9sus': ['1P 5P 7m 9M 11P', '5P 7m 8P 9M 11P', '7m 8P 9M 11P 12P', '7m 8P 11P 12P 16M'],
+  '13sus': ['1P 4P 6M 7m 9M', '1P 7m 9M 11P 13M', '5P 7m 9M 11P 13M', '7m 9M 11P 13M 15P'],
+  '7b13sus': ['1P 5P 7m 11P 13m', '5P 7m 8P 11P 13m', '7m 11P 13m 14m 15P'],
+};
+
+export const complex = {
+  2: ['1P 5P 6M 8P 9M', '1P 5P 8P 9M 12P', '5P 8P 9M 12P 13M', '5P 8P 9M 12P 15P'],
+  5: ['1P 5P 8P 12P', '1P 5P 8P 9M 12P', '5P 8P 12P 15P', '5P 8P 12P 15P 16M'],
+  6: ['1P 5P 6M 9M 10M', '1P 5P 9M 10M 13M', '3M 5P 9M 10M 13M', '5P 8P 9M 10M 13M', '3M 6M 9M 12P 15P'],
+  7: [
+    '1P 5P 7m 8P 10M',
+    '1P 7m 8P 10M 12P',
+    '3M 7m 8P 10M 12P',
+    '3M 7m 8P 10M 14m',
+    '3M 7m 10M 12P 15P',
+    '7m 10M 12P 14m 15P',
+    '7m 10M 12P 15P 17M',
+    '7m 10M 14m 17M 19P',
+  ],
+  9: [
+    '1P 6M 7m 9M 10M',
+    '3M 7m 9M 10M 12P',
+    '1P 7m 9M 10M 13M',
+    '3M 7m 9M 10M 13M',
+    '3M 7m 9M 12P 15P',
+    '7m 10M 12P 13M 16M',
+    '7m 10M 13M 16M 17M',
+    '7m 10M 13M 16M 19P',
+  ],
+  11: [
+    '1P 4P 6M 7m 9M',
+    '1P 5P 7m 9M 11P',
+    '4P 6M 7m 9M 11P',
+    '5P 8P 9M 11P 14m',
+    '7m 9M 11P 13M 15P',
+    '7m 11P 12P 14m 18P',
+  ],
+  13: [
+    '3M 7m 9M 10M 13M',
+    '3M 7m 9M 13M 15P',
+    '3M 7m 10M 13M 16M',
+    '7m 10M 12P 13M 16M',
+    '7m 10M 13M 16M 17M',
+    '7m 10M 13M 16M 19P',
+  ],
+  69: ['1P 5P 6M 9M 10M', '1P 5P 9M 10M 13M', '3M 5P 9M 10M 13M', '5P 8P 9M 10M 13M', '3M 6M 9M 12P 15P'],
+  add9: [
+    '1P 5P 8P 9M 10M',
+    '1P 5P 9M 10M 12P',
+    '3M 8P 9M 10M 12P',
+    '3M 8P 9M 12P 15P',
+    '5P 8P 9M 10M 15P',
+    '5P 8P 9M 12P 17M',
+  ],
+  '+': [
+    '1P 6m 8P 9M 10M',
+    '1P 6m 8P 10M 13m',
+    '3M 8P 9M 10M 13m',
+    '3M 8P 10M 13m 15P',
+    '6m 10M 13m 15P 16M',
+    '6m 10M 13m 15P 17M',
+  ],
+  o: [
+    '1P 6M 8P 10m 12d',
+    '1P 6M 10m 12d 13M',
+    '3m 8P 10m 12d 13M',
+    '3m 8P 12d 13M 15P',
+    '5d 10m 12d 13M 15P',
+    '5d 10m 13M 15P 17m',
+    '6M 12d 13M 15P 17m',
+    '6M 12d 15P 17m 19d',
+  ],
+  h: [
+    '1P 5d 7m 10m 11P',
+    '3m 5d 7m 8P 11P',
+    '5d 7m 8P 10m 11P',
+    '1P 7m 10m 12d',
+    '3m 7m 8P 12d 14m',
+    '5d 8P 10m 11P 14m',
+    '7m 10m 11P 12d 14m',
+    '7m 10m 12d 14m 15P',
+    '5d 8P 10m 14m 17m',
+  ],
+  sus: [
+    '1P 4P 5P 8P 9M',
+    '1P 4P 5P 8P 11P',
+    '1P 5P 8P 9M 11P',
+    '5P 8P 9M 11P 12P',
+    '5P 8P 11P 12P 13M',
+    '5P 8P 11P 13M 15P',
+  ],
+  '^': [
+    '1P 3M 5P 6M 9M',
+    '1P 5P 8P 10M 12P',
+    '3M 5P 9M 10M 12P',
+    '1P 5P 8P 10M 13M',
+    '3M 8P 10M 13M 15P',
+    '5P 9M 10M 12P 15P',
+  ],
+  '-': [
+    '1P 3m 5P 8P 10m',
+    '1P 3m 5P 9M 11P',
+    '3m 5P 8P 9M 11P',
+    '5P 8P 9M 10m 11P',
+    '1P 5P 9M 10m 12P',
+    '3m 5P 8P 10m 12P',
+    '5P 8P 10m 12P 15P',
+  ],
+  '^7': [
+    '1P 6M 7M 9M 10M',
+    '3M 7M 9M 10M 12P',
+    '1P 7M 9M 10M 13M',
+    '3M 7M 9M 10M 13M',
+    '3M 7M 9M 12P 13M',
+    '3M 7M 9M 13M 14M',
+    '3M 7M 10M 13M 16M',
+    '7M 10M 13M 14M 16M',
+    '7M 10M 13M 16M 17M',
+    '7M 10M 13M 16M 19P',
+  ],
+  '-7': [
+    '1P 3m 5P 7m 9M',
+    '1P 3m 5P 7m 10m',
+    '1P 5P 7m 10m 11P',
+    '3m 7m 8P 10m 11P',
+    '1P 5P 7m 10m 12P',
+    '3m 7m 9M 10m 12P',
+    '3m 7m 8P 10m 14m',
+    '5P 7m 9M 10m 14m',
+    '7m 10m 11P 14m 15P',
+    '7m 10m 12P 15P 16M',
+    '5P 8P 11P 14m 17m',
+    '7m 10m 12P 15P 17m',
+  ],
+  '7sus': [
+    '1P 4P 6M 7m 9M',
+    '1P 5P 7m 9M 11P',
+    '4P 6M 7m 9M 11P',
+    '5P 8P 9M 11P 14m',
+    '7m 9M 11P 13M 15P',
+    '7m 11P 12P 14m 18P',
+  ],
+  h7: [
+    '1P 5d 7m 10m 11P',
+    '3m 5d 7m 8P 11P',
+    '5d 7m 8P 10m 11P',
+    '1P 7m 10m 12d',
+    '3m 7m 8P 10m 12d',
+    '3m 7m 8P 12d 14m',
+    '5d 8P 10m 11P 14m',
+    '7m 10m 11P 12d 14m',
+    '7m 10m 12d 14m 15P',
+    '5d 8P 10m 14m 17m',
+  ],
+  o7: [
+    '1P 6M 8P 10m 12d',
+    '1P 6M 10m 12d 13M',
+    '3m 8P 10m 12d 13M',
+    '3m 8P 12d 13M 15P',
+    '5d 10m 12d 13M 15P',
+    '5d 10m 13M 15P 17m',
+    '6M 12d 13M 15P 17m',
+    '6M 12d 15P 17m 19d',
+  ],
+  '^9': [
+    '1P 6M 7M 9M 10M',
+    '1P 7M 9M 10M 13M',
+    '3M 7M 9M 10M 13M',
+    '3M 7M 9M 12P 13M',
+    '3M 7M 8P 9M 13M',
+    '3M 7M 9M 13M 14M',
+    '3M 7M 10M 13M 16M',
+    '7M 10M 13M 14M 16M',
+    '7M 10M 13M 16M 17M',
+    '7M 10M 13M 16M 19P',
+  ],
+  '^13': [
+    '1P 6M 7M 9M 10M',
+    '1P 7M 9M 10M 13M',
+    '3M 7M 9M 12P 13M',
+    '3M 7M 9M 10M 13M',
+    '3M 7M 8P 9M 13M',
+    '3M 7M 9M 13M 14M',
+    '3M 7M 10M 13M 16M',
+    '7M 10M 13M 14M 16M',
+    '7M 10M 13M 16M 17M',
+    '7M 10M 13M 16M 19P',
+  ],
+  '^7#11': [
+    '1P 3M 5d 7M 9M',
+    '1P 7M 9M 10M 12d',
+    '3M 7M 9M 10M 12d',
+    '3M 7M 9M 12d 13M',
+    '3M 7M 10M 12d 14M',
+    '7M 10M 12d 13M 14M',
+    '7M 10M 12d 13M 16M',
+    '7M 10M 12d 14M 17M',
+  ],
+  '^9#11': [
+    '1P 3M 5d 7M 9M',
+    '1P 7M 9M 10M 12d',
+    '3M 7M 9M 10M 12d',
+    '3M 7M 9M 12d 13M',
+    '3M 7M 9M 12d 14M',
+    '7M 10M 12d 14M 16M',
+    '7M 10M 12d 13M 16M',
+  ],
+  '^7#5': ['1P 6m 7M 10M 13m', '3M 7M 9M 10M 13m', '3M 7M 10M 13m 14M', '7M 10M 13m 14M 16M', '7M 10M 13m 14M 17M'],
+  '-6': [
+    '1P 3m 5P 6M 9M',
+    '3m 5P 6M 8P 9M',
+    '1P 5P 6M 10m 11P',
+    '3m 5P 6M 8P 11P',
+    '1P 5P 9M 10m 13M',
+    '3m 5P 8P 9M 13M',
+    '5P 8P 10m 11P 13M',
+    '5P 8P 10m 13M 16M',
+  ],
+  '-69': [
+    '1P 3m 5P 6M 9M',
+    '3m 5P 6M 8P 9M',
+    '3m 6M 9M 10m 12P',
+    '1P 5P 9M 10m 13M',
+    '3m 5P 8P 9M 13M',
+    '5P 8P 9M 10m 13M',
+    '5P 8P 10m 13M 16M',
+  ],
+  '-^7': [
+    '1P 3m 5P 7M 9M',
+    '1P 5P 7M 10m 11P',
+    '3m 7M 9M 10m 11P',
+    '3m 7M 9M 10m 12P',
+    '3m 7M 9M 12P 14M',
+    '7M 10m 11P 12P 14M',
+    '7M 10m 12P 14M 16M',
+  ],
+  '-^9': [
+    '1P 3m 5P 7M 9M',
+    '1P 5P 7M 10m 11P',
+    '3m 7M 9M 10m 11P',
+    '3m 7M 9M 10m 12P',
+    '3m 7M 9M 12P 14M',
+    '7M 10m 11P 12P 14M',
+    '7M 10m 12P 14M 16M',
+  ],
+  '-9': [
+    '1P 3m 5P 7m 9M',
+    '1P 3m 7m 9M 11P',
+    '3m 7m 9M 10m 11P',
+    '3m 7m 9M 10m 12P',
+    '3m 7m 9M 10m 14m',
+    '3m 7m 9M 12P 15P',
+    '7m 10m 11P 14m 16M',
+    '7m 10m 12P 16M 18P',
+  ],
+  '-add9': ['1P 2M 3m 5P 8P', '1P 3m 5P 9M', '3m 5P 8P 9M 12P', '5P 8P 9M 10m 12P'],
+  '-11': [
+    '3m 5P 7m 9M 11P',
+    '7m 9M 10m 11P',
+    '1P 4P 7m 10m 12P',
+    '3m 7m 9M 11P 12P',
+    '7m 9M 10m 11P 12P',
+    '3m 7m 9M 11P 14m',
+    '4P 10m 12P 14m',
+    '5P 8P 11P 14m',
+    '5P 8P 11P 14m 16M',
+    '7m 10m 12P 16M 18P',
+    '7m 10m 11P 16M 21m',
+  ],
+  '-7b5': [
+    '1P 5d 7m 10m 11P',
+    '3m 5d 7m 8P 11P',
+    '5d 7m 8P 10m 11P',
+    '1P 7m 10m 12d',
+    '3m 7m 8P 10m 12d',
+    '3m 7m 8P 12d 14m',
+    '5d 8P 10m 11P 14m',
+    '7m 10m 11P 12d 14m',
+    '7m 10m 12d 14m 15P',
+    '5d 8P 10m 14m 17m',
+  ],
+  h9: [
+    '3m 5d 7m 9M 11P',
+    '1P 7m 9M 10m 12d',
+    '3m 7m 9M 12d 14m',
+    '5d 8P 9M 10m 14m',
+    '7m 10m 11P 12d 14m',
+    '7m 10m 12d 14m 16M',
+  ],
+  '-b6': ['1P 3m 5P 6m 8P', '3m 5P 8P 11P 13m', '5P 8P 10m 11P 13m'],
+  '-#5': ['1P 6m 8P 10m 13m', '3m 6m 8P 11P 13m', '6m 8P 10m 13m 15P'],
+  '7b9': ['1P 3M 7m 9m 10M', '3M 7m 8P 9m 10M', '3M 7m 8P 9m 14m', '7m 9m 10M 14m 15P'],
+  '7#9': ['1P 3M 7m 10m', '3M 7m 10m 10M 12P', '3M 7m 10m 12P 14m', '7m 10M 12P 14m 17m'],
+  '7#11': ['1P 3M 7m 9M 12d', '3M 7m 9M 12d 13M', '7m 10M 12d 13M 16M'],
+  '7b5': ['1P 3M 7m 9M 12d', '3M 7m 9M 12d 13M', '7m 10M 12d 13M 16M'],
+  '7#5': ['1P 3M 7m 10M 13m', '3M 7m 8P 10M 13m', '3M 7m 8P 13m 14m', '7m 10M 13m 14m 15P', '7m 10M 13m 14m 17M'],
+  '9#11': ['1P 7m 9M 10M 12d', '3M 7m 8P 9M 12d', '7m 10M 12d 15P 16M'],
+  '9b5': ['1P 7m 9M 10M 12d', '3M 7m 8P 9M 12d', '7m 10M 12d 15P 16M'],
+  '9#5': ['1P 7m 9M 10M 13m', '3M 7m 9M 10M 13m', '3M 7m 9M 13m 14m', '7m 10M 13m 14m 16M', '7m 10M 13m 16M 17M'],
+  '7b13': ['1P 3M 7m 10M 13m', '3M 7m 8P 10M 13m', '3M 7m 8P 13m 14m', '7m 10M 13m 14m 15P', '7m 10M 13m 14m 17M'],
+  '7#9#5': ['3M 7m 10m 10M 13m', '3M 7m 10m 13m 14m', '7m 10M 13m 14m 17m'],
+  '7#9b5': ['3M 7m 10m 10M 12d', '3M 7m 10m 12d 14m', '7m 10M 12d 14m 17m'],
+  '7#9#11': ['3M 7m 10m 10M 12d', '3M 7m 10m 12d 14m', '7m 10M 12d 14m 17m'],
+  '7b9#11': ['3M 7m 9m 10M 12d', '3M 7m 9m 12d 14m', '7m 8P 10M 12d 16m', '7m 10M 12d 14m 16m'],
+  '7b9b5': ['3M 7m 9m 10M 12d', '3M 7m 9m 12d 14m', '7m 8P 10M 12d 16m', '7m 10M 12d 14m 16m'],
+  '7b9#5': ['1P 7m 9m 10M 13m', '3M 7m 9m 10M 13m', '3M 7m 10M 13m 16m', '7m 10M 13m 14m 16m', '7m 10M 13m 16m 17M'],
+  '7b9#9': ['1P 3M 7m 9m 10m', '3M 7m 10m 13m 16m', '7m 10M 13m 16m 17m'],
+  '7b9b13': ['1P 7m 9m 10M 13m', '3M 7m 9m 10M 13m', '3M 7m 10M 13m 16m', '7m 10M 13m 14m 16m', '7m 10M 13m 16m 17M'],
+  '7alt': [
+    '3M 7m 8P 10m 13m',
+    '3M 7m 9m 12d 13m',
+    '3M 7m 9m 10m 13m',
+    '3M 7m 10m 13m 14m',
+    '3M 7m 9m 12d 14m',
+    '3M 7m 10m 13m 15P',
+    '3M 7m 10m 13m 16m',
+    '7m 10M 12d 14m 16m',
+    '7m 10M 12d 13m 16m',
+    '7m 10M 13m 15P 17m',
+    '7m 10M 13m 16m 17m',
+    '7m 10M 13m 16m 19d',
+  ],
+  '13#11': ['3M 7m 9M 12d 13M', '7m 10M 12d 13M 16M'],
+  '13b9': ['3M 7m 9m 10M 13M', '3M 7m 10M 13M 16m', '7m 10M 13M 16m 17M'],
+  '13#9': ['3M 7m 10m 10M 13M', '7m 10M 13M 14m 17m'],
+  '7b9sus': ['1P 5P 7m 9m 11P', '5P 7m 8P 9m 11P', '7m 8P 11P 14m 16m'],
+  '7susadd3': ['1P 4P 5P 7m 10M', '5P 8P 10M 11P 14m', '7m 11P 12P 15P 17M'],
+  '9sus': [
+    '1P 4P 6M 7m 9M',
+    '1P 5P 7m 9M 11P',
+    '4P 6M 7m 9M 11P',
+    '5P 8P 9M 11P 14m',
+    '7m 9M 11P 13M 15P',
+    '7m 11P 12P 14m 18P',
+  ],
+  '13sus': [
+    '1P 4P 6M 7m 9M',
+    '1P 7m 9M 11P 13M',
+    '4P 7m 9M 11P 13M',
+    '7m 9M 11P 13M 15P',
+    '7m 11P 13M 14m 16M',
+    '7m 11P 13M 16M 18P',
+  ],
+  '7b13sus': ['1P 5P 7m 11P 13m', '5P 7m 8P 11P 13m', '7m 11P 13m 14m 15P'],
+};

packages/tonal/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel.cycles/tonal",
-  "version": "0.6.0",
+  "version": "0.8.2",
   "description": "Tonal functions for strudel",
   "main": "index.mjs",
   "publishConfig": {
@@ -34,10 +34,10 @@
     "@strudel.cycles/core": "workspace:*",
     "@tonaljs/tonal": "^4.7.2",
     "chord-voicings": "^0.0.1",
-    "webmidi": "^3.0.21"
+    "webmidi": "^3.1.5"
   },
   "devDependencies": {
-    "vite": "^3.2.2",
-    "vitest": "^0.25.7"
+    "vite": "^4.3.3",
+    "vitest": "^0.33.0"
   }
 }

packages/tonal/test/tonal.test.mjs

@@ -9,6 +9,7 @@ This program is free software: you can redistribute it and/or modify it under th
 import '../tonal.mjs'; // need to import this to add prototypes
 import { pure, controls, seq } from '@strudel.cycles/core';
 import { describe, it, expect } from 'vitest';
+import { mini } from '../../mini/mini.mjs';
 const { n } = controls;
 
 describe('tonal', () => {
@@ -30,4 +31,18 @@ describe('tonal', () => {
         .firstCycleValues.map((h) => h.note),
     ).toEqual(['C3', 'D3', 'E3']);
   });
+  it('scale with colon', () => {
+    expect(
+      n(0, 1, 2)
+        .scale('C:major')
+        .firstCycleValues.map((h) => h.note),
+    ).toEqual(['C3', 'D3', 'E3']);
+  });
+  it('scale with mininotation colon', () => {
+    expect(
+      n(0, 1, 2)
+        .scale(mini('C:major'))
+        .firstCycleValues.map((h) => h.note),
+    ).toEqual(['C3', 'D3', 'E3']);
+  });
 });

packages/tonal/test/tonleiter.test.mjs

@@ -0,0 +1,152 @@
+/*
+tonleiter.test.mjs - <short description TODO>
+Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/tonal/test/tonleiter.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 { describe, test, expect } from 'vitest';
+import {
+  Step,
+  Note,
+  transpose,
+  pc2chroma,
+  rotateChroma,
+  chroma2pc,
+  tokenizeChord,
+  note2pc,
+  note2oct,
+  midi2note,
+  renderVoicing,
+  scaleStep,
+} from '../tonleiter.mjs';
+
+describe('tonleiter', () => {
+  test('Step ', () => {
+    expect(Step.tokenize('#11')).toEqual(['#', 11]);
+    expect(Step.tokenize('b13')).toEqual(['b', 13]);
+    expect(Step.tokenize('bb6')).toEqual(['bb', 6]);
+    expect(Step.tokenize('b3')).toEqual(['b', 3]);
+    expect(Step.tokenize('3')).toEqual(['', 3]);
+    expect(Step.tokenize('10')).toEqual(['', 10]);
+    // expect(Step.tokenize('asdasd')).toThrow();
+    expect(Step.accidentals('b3')).toEqual(-1);
+    expect(Step.accidentals('#11')).toEqual(1);
+  });
+  test('Note', () => {
+    expect(Note.tokenize('C##')).toEqual(['C', '##']);
+    expect(Note.tokenize('Bb')).toEqual(['B', 'b']);
+    expect(Note.accidentals('C#')).toEqual(1);
+    expect(Note.accidentals('C##')).toEqual(2);
+    expect(Note.accidentals('Eb')).toEqual(-1);
+    expect(Note.accidentals('Bbb')).toEqual(-2);
+  });
+  test('transpose', () => {
+    expect(transpose('F#', '3')).toEqual('A#');
+    expect(transpose('C', '3')).toEqual('E');
+    expect(transpose('D', '3')).toEqual('F#');
+    expect(transpose('E', '3')).toEqual('G#');
+    expect(transpose('Eb', '3')).toEqual('G');
+    expect(transpose('Ebb', '3')).toEqual('Gb');
+  });
+  test('pc2chroma', () => {
+    expect(pc2chroma('C')).toBe(0);
+    expect(pc2chroma('C#')).toBe(1);
+    expect(pc2chroma('C##')).toBe(2);
+    expect(pc2chroma('D')).toBe(2);
+    expect(pc2chroma('Db')).toBe(1);
+    expect(pc2chroma('Dbb')).toBe(0);
+    expect(pc2chroma('bb')).toBe(10);
+    expect(pc2chroma('f')).toBe(5);
+    expect(pc2chroma('c')).toBe(0);
+  });
+  test('rotateChroma', () => {
+    expect(rotateChroma(0, 1)).toBe(1);
+    expect(rotateChroma(0, -1)).toBe(11);
+    expect(rotateChroma(11, 1)).toBe(0);
+    expect(rotateChroma(11, 13)).toBe(0);
+  });
+  test('chroma2pc', () => {
+    expect(chroma2pc(0)).toBe('C');
+    expect(chroma2pc(1)).toBe('Db');
+    expect(chroma2pc(1, true)).toBe('C#');
+    expect(chroma2pc(2)).toBe('D');
+    expect(chroma2pc(3)).toBe('Eb');
+  });
+  test('tokenizeChord', () => {
+    expect(tokenizeChord('Cm7')).toEqual(['C', 'm7', undefined]);
+    expect(tokenizeChord('C#m7')).toEqual(['C#', 'm7', undefined]);
+    expect(tokenizeChord('Bb^7')).toEqual(['Bb', '^7', undefined]);
+    expect(tokenizeChord('Bb^7/F')).toEqual(['Bb', '^7', 'F']);
+  });
+  test('note2pc', () => {
+    expect(note2pc('C5')).toBe('C');
+    expect(note2pc('C52')).toBe('C');
+    expect(note2pc('Bb3')).toBe('Bb');
+    expect(note2pc('F')).toBe('F');
+  });
+  test('note2oct', () => {
+    expect(note2oct('C5')).toBe(5);
+    expect(note2oct('Bb3')).toBe(3);
+    expect(note2oct('C7')).toBe(7);
+    expect(note2oct('C10')).toBe(10);
+  });
+  test('midi2note', () => {
+    expect(midi2note(60)).toBe('C4');
+    expect(midi2note(61)).toBe('Db4');
+    expect(midi2note(61, true)).toBe('C#4');
+  });
+  test('scaleStep', () => {
+    expect(scaleStep([60, 63, 67], 0)).toBe(60);
+    expect(scaleStep([60, 63, 67], 1)).toBe(63);
+    expect(scaleStep([60, 63, 67], 2)).toBe(67);
+    expect(scaleStep([60, 63, 67], 3)).toBe(72);
+    expect(scaleStep([60, 63, 67], 4)).toBe(75);
+    expect(scaleStep([60, 63, 67], -1)).toBe(55);
+    expect(scaleStep([60, 63, 67], -2)).toBe(51);
+    expect(scaleStep([60, 63, 67], -3)).toBe(48);
+    expect(scaleStep([60, 63, 67], -4)).toBe(43);
+  });
+  test('renderVoicing', () => {
+    const dictionary = {
+      m7: [
+        '3 7 10 14', // b3 5 b7 9
+        '10 14 15 19', // b7 9 b3 5
+      ],
+    };
+    expect(renderVoicing({ chord: 'Em7', anchor: 'Bb4', dictionary, mode: 'below' })).toEqual([
+      'G3',
+      'B3',
+      'D4',
+      'Gb4',
+    ]);
+    expect(renderVoicing({ chord: 'Cm7', anchor: 'D5', dictionary, mode: 'below' })).toEqual([
+      'Eb4',
+      'G4',
+      'Bb4',
+      'D5',
+    ]);
+    expect(renderVoicing({ chord: 'Cm7', anchor: 'G5', dictionary, mode: 'below' })).toEqual([
+      'Bb4',
+      'D5',
+      'Eb5',
+      'G5',
+    ]);
+    expect(renderVoicing({ chord: 'Cm7', anchor: 'g5', dictionary, mode: 'below' })).toEqual([
+      'Bb4',
+      'D5',
+      'Eb5',
+      'G5',
+    ]);
+    expect(renderVoicing({ chord: 'Cm7', anchor: 'g5', dictionary, mode: 'below', n: 0 })).toEqual([70]); // Bb4
+    expect(renderVoicing({ chord: 'Cm7', anchor: 'g5', dictionary, mode: 'below', n: 1 })).toEqual([74]); // D5
+    expect(renderVoicing({ chord: 'Cm7', anchor: 'g5', dictionary, mode: 'below', n: 4 })).toEqual([82]); // Bb5
+    expect(renderVoicing({ chord: 'Cm7', anchor: 'g5', dictionary, mode: 'below', offset: 1 })).toEqual([
+      'Eb5',
+      'G5',
+      'Bb5',
+      'D6',
+    ]);
+    // expect(voiceBelow('G4', 'Cm7', voicingDictionary)).toEqual(['Bb3', 'D4', 'Eb4', 'G4']);
+    // TODO: test with offset
+  });
+});

packages/tonal/tonal.mjs

@@ -123,29 +123,37 @@ export const scaleTranspose = register('scaleTranspose', function (offset /* : n
 /**
  * Turns numbers into notes in the scale (zero indexed). Also sets scale for other scale operations, like {@link Pattern#scaleTranspose}.
  *
- * A scale consists of a root note (e.g. `c4`, `c`, `f#`, `bb4`) followed by a [scale type](https://github.com/tonaljs/tonal/blob/main/packages/scale-type/data.ts).
- * The root note defaults to octave 3, if no octave number is given.
- * Note that you currently cannot pattern `scale` with the mini notation, because the scale name includes a space.
- * This will be improved in the future. Until then, use a sequence function like `cat` or `seq`.
+ * A scale consists of a root note (e.g. `c4`, `c`, `f#`, `bb4`) followed by semicolon (':') and then a [scale type](https://github.com/tonaljs/tonal/blob/main/packages/scale-type/data.ts).
+ *
+ * The root note defaults to octave 3, if no octave number is given.
  *
- * @memberof Pattern
  * @name scale
  * @param {string} scale Name of scale
  * @returns Pattern
  * @example
- * "0 2 4 6 4 2".scale('C2 major').note()
+ * n("0 2 4 6 4 2").scale("C:major")
  * @example
- * "0 2 4 6 4 2"
- * .scale(seq('C2 major', 'C2 minor').slow(2))
- * .note()
+ * n("[0,7] 4 [2,7] 4")
+ * .scale("C:<major minor>/2")
+ * .s("piano")
+ * @example
+ * n(rand.range(0,12).segment(8).round())
+ * .scale("C:ritusen")
+ * .s("folkharp")
  */
 
-export const scale = register('scale', function (scale /* : string */, pat) {
+export const scale = register('scale', function (scale, pat) {
+  // Supports ':' list syntax in mininotation
+  if (Array.isArray(scale)) {
+    scale = scale.flat().join(' ');
+  }
   return pat.withHap((hap) => {
     const isObject = typeof hap.value === 'object';
     let note = isObject ? hap.value.n : hap.value;
     const asNumber = Number(note);
     if (!isNaN(asNumber)) {
+      // TODO: worth keeping for supporting ':' in (non-mininotation) strings?
+      scale = scale.replaceAll(':', ' ');
       let [tonic, scaleName] = Scale.tokenize(scale);
       const { pc, oct = 3 } = Note.get(tonic);
       note = scaleOffset(pc + ' ' + scaleName, asNumber, pc + oct);

packages/tonal/tonleiter.mjs

@@ -0,0 +1,190 @@
+import { isNote, isNoteWithOctave, _mod, noteToMidi, tokenizeNote } from '@strudel.cycles/core';
+import { Interval } from '@tonaljs/tonal';
+
+// https://codesandbox.io/s/stateless-voicings-g2tmz0?file=/src/lib.js:0-2515
+
+const flats = ['C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B'];
+const pcs = ['c', 'db', 'd', 'eb', 'e', 'f', 'gb', 'g', 'ab', 'a', 'bb', 'b'];
+const sharps = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'];
+const accs = { b: -1, '#': 1 };
+
+export const pc2chroma = (pc) => {
+  const [letter, ...rest] = pc.split('');
+  return pcs.indexOf(letter.toLowerCase()) + rest.reduce((sum, sign) => sum + accs[sign], 0);
+};
+
+export const rotateChroma = (chroma, steps) => (chroma + (steps % 12) + 12) % 12;
+
+export const chroma2pc = (chroma, sharp = false) => {
+  return (sharp ? sharps : flats)[chroma];
+};
+
+export function tokenizeChord(chord) {
+  const match = (chord || '').match(/^([A-G][b#]*)([^/]*)[/]?([A-G][b#]*)?$/);
+  if (!match) {
+    // console.warn('could not tokenize chord', chord);
+    return [];
+  }
+  return match.slice(1);
+}
+export const note2pc = (note) => note.match(/^[A-G][#b]?/i)[0];
+export const note2oct = (note) => tokenizeNote(note)[2];
+
+export const note2chroma = (note) => {
+  return pc2chroma(note2pc(note));
+};
+
+// TODO: test
+export const midi2chroma = (midi) => midi % 12;
+
+// TODO: test and use in voicing function
+export const pitch2chroma = (x, defaultOctave) => {
+  if (isNoteWithOctave(x)) {
+    return note2chroma(x);
+  }
+  if (isNote(x)) {
+    //pc
+    return pc2chroma(x, defaultOctave);
+  }
+  if (typeof x === 'number') {
+    // expect midi
+    return midi2chroma(x);
+  }
+};
+
+export const step2semitones = (x) => {
+  let num = Number(x);
+  if (!isNaN(num)) {
+    return num;
+  }
+  return Interval.semitones(x);
+};
+
+export const x2midi = (x) => {
+  if (typeof x === 'number') {
+    return x;
+  }
+  if (typeof x === 'string') {
+    return noteToMidi(x);
+  }
+};
+
+// duplicate: util.mjs (does not support sharp flag)
+export const midi2note = (midi, sharp = false) => {
+  const oct = Math.floor(midi / 12) - 1;
+  const pc = (sharp ? sharps : flats)[midi % 12];
+  return pc + oct;
+};
+
+export function scaleStep(notes, offset, octaves = 1) {
+  notes = notes.map((note) => (typeof note === 'string' ? noteToMidi(note) : note));
+  const octOffset = Math.floor(offset / notes.length) * octaves * 12;
+  offset = _mod(offset, notes.length);
+  return notes[offset] + octOffset;
+}
+
+// different ways to resolve the note to compare the anchor to (see renderVoicing)
+let modeTarget = {
+  below: (v) => v.slice(-1)[0],
+  duck: (v) => v.slice(-1)[0],
+  above: (v) => v[0],
+};
+
+export function renderVoicing({ chord, dictionary, offset = 0, n, mode = 'below', anchor = 'c5', octaves = 1 }) {
+  const [root, symbol] = tokenizeChord(chord);
+  const rootChroma = pc2chroma(root);
+  anchor = anchor?.note || anchor;
+  const anchorChroma = pitch2chroma(anchor);
+  const voicings = dictionary[symbol].map((voicing) =>
+    (typeof voicing === 'string' ? voicing.split(' ') : voicing).map(step2semitones),
+  );
+
+  let minDistance, bestIndex;
+  // calculate distances up from voicing top notes
+  let chromaDiffs = voicings.map((v, i) => {
+    const targetStep = modeTarget[mode](v);
+    const diff = _mod(anchorChroma - targetStep - rootChroma, 12);
+    if (minDistance === undefined || diff < minDistance) {
+      minDistance = diff;
+      bestIndex = i;
+    }
+    return diff;
+  });
+
+  const octDiff = Math.ceil(offset / voicings.length) * 12;
+  const indexWithOffset = _mod(bestIndex + offset, voicings.length);
+  const voicing = voicings[indexWithOffset];
+  const targetStep = modeTarget[mode](voicing);
+  const anchorMidi = noteToMidi(anchor, 4) - chromaDiffs[indexWithOffset] + octDiff;
+
+  const voicingMidi = voicing.map((v) => anchorMidi - targetStep + v);
+  let notes = voicingMidi.map((n) => midi2note(n));
+
+  if (mode === 'duck') {
+    notes = notes.filter((_, i) => voicingMidi[i] !== noteToMidi(anchor));
+  }
+  if (n !== undefined) {
+    return [scaleStep(notes, n, octaves)];
+  }
+  return notes;
+}
+
+// https://github.com/tidalcycles/strudel/blob/14184993d0ee7d69c47df57ac864a1a0f99a893f/packages/tonal/tonleiter.mjs
+const steps = [1, 0, 2, 0, 3, 4, 0, 5, 0, 6, 0, 7];
+const notes = ['C', '', 'D', '', 'E', 'F', '', 'G', '', 'A', '', 'B'];
+const noteLetters = ['C', 'D', 'E', 'F', 'G', 'A', 'B'];
+
+export const accidentalOffset = (accidentals) => {
+  return accidentals.split('#').length - accidentals.split('b').length;
+};
+
+const accidentalString = (offset) => {
+  if (offset < 0) {
+    return 'b'.repeat(-offset);
+  }
+  if (offset > 0) {
+    return '#'.repeat(offset);
+  }
+  return '';
+};
+
+export const Step = {
+  tokenize(step) {
+    const matches = step.match(/^([#b]*)([1-9][0-9]*)$/);
+    if (!matches) {
+      throw new Error(`Step.tokenize: not a valid step: ${step}`);
+    }
+    const [accidentals, stepNumber] = matches.slice(1);
+    return [accidentals, parseInt(stepNumber)];
+  },
+  accidentals(step) {
+    return accidentalOffset(Step.tokenize(step)[0]);
+  },
+};
+
+export const Note = {
+  // TODO: support octave numbers
+  tokenize(note) {
+    return [note[0], note.slice(1)];
+  },
+  accidentals(note) {
+    return accidentalOffset(this.tokenize(note)[1]);
+  },
+};
+
+// TODO: support octave numbers
+export function transpose(note, step) {
+  // example: E, 3
+  const stepNumber = Step.tokenize(step)[1]; // 3
+  const noteLetter = Note.tokenize(note)[0]; // E
+  const noteIndex = noteLetters.indexOf(noteLetter); // 2 "E is C+2"
+  const targetNote = noteLetters[(noteIndex + stepNumber - 1) % 8]; // G "G is a third above E"
+  const rootIndex = notes.indexOf(noteLetter); // 4 "E is 4 semitones above C"
+  const targetIndex = notes.indexOf(targetNote); // 7 "G is 7 semitones above C"
+  const indexOffset = targetIndex - rootIndex; // 3 (E to G is normally a 3 semitones)
+  const stepIndex = steps.indexOf(stepNumber); // 4 ("3" is normally 4 semitones)
+  const offsetAccidentals = accidentalString(Step.accidentals(step) + Note.accidentals(note) + stepIndex - indexOffset); // "we need to add a # to to the G to make it a major third from E"
+  return [targetNote, offsetAccidentals].join('');
+}
+
+//Note("Bb3").transpose("c3")

packages/tonal/voicings.mjs

@@ -5,11 +5,79 @@ This program is free software: you can redistribute it and/or modify it under th
 */
 
 import { stack, register } from '@strudel.cycles/core';
+import { renderVoicing } from './tonleiter.mjs';
 import _voicings from 'chord-voicings';
-const { dictionaryVoicing, minTopNoteDiff, lefthand } = _voicings.default || _voicings; // parcel module resolution fuckup
+import { complex, simple } from './ireal.mjs';
+const { dictionaryVoicing, minTopNoteDiff } = _voicings.default || _voicings; // parcel module resolution fuckup
+
+const lefthand = {
+  m7: ['3m 5P 7m 9M', '7m 9M 10m 12P'],
+  7: ['3M 6M 7m 9M', '7m 9M 10M 13M'],
+  '^7': ['3M 5P 7M 9M', '7M 9M 10M 12P'],
+  69: ['3M 5P 6A 9M'],
+  m7b5: ['3m 5d 7m 8P', '7m 8P 10m 12d'],
+  '7b9': ['3M 6m 7m 9m', '7m 9m 10M 13m'],
+  '7b13': ['3M 6m 7m 9m', '7m 9m 10M 13m'],
+  o7: ['1P 3m 5d 6M', '5d 6M 8P 10m'],
+  '7#11': ['7m 9M 11A 13A'],
+  '7#9': ['3M 7m 9A'],
+  mM7: ['3m 5P 7M 9M', '7M 9M 10m 12P'],
+  m6: ['3m 5P 6M 9M', '6M 9M 10m 12P'],
+};
+
+const guidetones = {
+  m7: ['3m 7m', '7m 10m'],
+  m9: ['3m 7m', '7m 10m'],
+  7: ['3M 7m', '7m 10M'],
+  '^7': ['3M 7M', '7M 10M'],
+  '^9': ['3M 7M', '7M 10M'],
+  69: ['3M 6M'],
+  6: ['3M 6M', '6M 10M'],
+  m7b5: ['3m 7m', '7m 10m'],
+  '7b9': ['3M 7m', '7m 10M'],
+  '7b13': ['3M 7m', '7m 10M'],
+  o7: ['3m 6M', '6M 10m'],
+  '7#11': ['3M 7m', '7m 10M'],
+  '7#9': ['3M 7m', '7m 10M'],
+  mM7: ['3m 7M', '7M 10m'],
+  m6: ['3m 6M', '6M 10m'],
+};
+
+const triads = {
+  '': ['1P 3M 5P', '3M 5P 8P', '5P 8P 10M'],
+  M: ['1P 3M 5P', '3M 5P 8P', '5P 8P 10M'],
+  m: ['1P 3m 5P', '3m 5P 8P', '5P 8P 10m'],
+  o: ['1P 3m 5d', '3m 5d 8P', '5d 8P 10m'],
+  aug: ['1P 3m 5A', '3m 5A 8P', '5A 8P 10m'],
+};
+
+const defaultDictionary = {
+  // triads
+  '': ['1P 3M 5P', '3M 5P 8P', '5P 8P 10M'],
+  M: ['1P 3M 5P', '3M 5P 8P', '5P 8P 10M'],
+  m: ['1P 3m 5P', '3m 5P 8P', '5P 8P 10m'],
+  o: ['1P 3m 5d', '3m 5d 8P', '5d 8P 10m'],
+  aug: ['1P 3m 5A', '3m 5A 8P', '5A 8P 10m'],
+  // sevenths chords
+  m7: ['3m 5P 7m 9M', '7m 9M 10m 12P'],
+  7: ['3M 6M 7m 9M', '7m 9M 10M 13M'],
+  '^7': ['3M 5P 7M 9M', '7M 9M 10M 12P'],
+  69: ['3M 5P 6A 9M'],
+  m7b5: ['3m 5d 7m 8P', '7m 8P 10m 12d'],
+  '7b9': ['3M 6m 7m 9m', '7m 9m 10M 13m'],
+  '7b13': ['3M 6m 7m 9m', '7m 9m 10M 13m'],
+  o7: ['1P 3m 5d 6M', '5d 6M 8P 10m'],
+  '7#11': ['7m 9M 11A 13A'],
+  '7#9': ['3M 7m 9A'],
+  mM7: ['3m 5P 7M 9M', '7M 9M 10m 12P'],
+  m6: ['3m 5P 6M 9M', '6M 9M 10m 12P'],
+};
 
 export const voicingRegistry = {
-  lefthand: { dictionary: lefthand, range: ['F3', 'A4'] },
+  lefthand: { dictionary: lefthand, range: ['F3', 'A4'], mode: 'below', anchor: 'a4' },
+  triads: { dictionary: triads, mode: 'below', anchor: 'a4' },
+  guidetones: { dictionary: guidetones, mode: 'above', anchor: 'a4' },
+  default: { dictionary: defaultDictionary, mode: 'below', anchor: 'a4' },
 };
 export const setVoicingRange = (name, range) => addVoicings(name, voicingRegistry[name].dictionary, range);
 
@@ -38,6 +106,11 @@ export const addVoicings = (name, dictionary, range = ['F3', 'A4']) => {
   Object.assign(voicingRegistry, { [name]: { dictionary, range } });
 };
 
+// new call signature
+export const registerVoicings = (name, dictionary, options = {}) => {
+  Object.assign(voicingRegistry, { [name]: { dictionary, ...options } });
+};
+
 const getVoicing = (chord, dictionaryName, lastVoicing) => {
   const { dictionary, range } = voicingRegistry[dictionaryName];
   return dictionaryVoicing({
@@ -50,6 +123,7 @@ const getVoicing = (chord, dictionaryName, lastVoicing) => {
 };
 
 /**
+ * DEPRECATED: still works, but it is recommended you use .voicing instead (without s).
  * Turns chord symbols into voicings, using the smoothest voice leading possible.
  * Uses [chord-voicings package](https://github.com/felixroos/chord-voicings#chord-voicings).
  *
@@ -86,7 +160,76 @@ export const voicings = register('voicings', function (dictionary, pat) {
  */
 export const rootNotes = register('rootNotes', function (octave, pat) {
   return pat.fmap((value) => {
-    const root = value.match(/^([a-gA-G][b#]?).*$/)[1];
-    return root + octave;
+    const chord = value.chord || value;
+    const root = chord.match(/^([a-gA-G][b#]?).*$/)[1];
+    const note = root + octave;
+    return value.chord ? { note } : note;
   });
 });
+
+/**
+ * Turns chord symbols into voicings. You can use the following control params:
+ *
+ * - `chord`: Note, followed by chord symbol, e.g. C Am G7 Bb^7
+ * - `dict`: voicing dictionary to use, falls back to default dictionary
+ * - `anchor`: the note that is used to align the chord
+ * - `mode`: how the voicing is aligned to the anchor
+ *   - `below`: top note <= anchor
+ *   - `duck`: top note <= anchor, anchor excluded
+ *   - `above`: bottom note >= anchor
+ * - `offset`: whole number that shifts the voicing up or down to the next voicing
+ * - `n`: if set, the voicing is played like a scale. Overshooting numbers will be octaved
+ *
+ * All of the above controls are optional, except `chord`.
+ * If you pass a pattern of strings to voicing, they will be interpreted as chords.
+ *
+ * @name voicing
+ * @param {string} dictionary which voicing dictionary to use.
+ * @returns Pattern
+ * @example
+ * voicing("<C Am F G>")
+ * @example
+ * n("0 1 2 3 4 5 6 7").chord("<C Am F G>").voicing()
+ */
+export const voicing = register('voicing', function (pat) {
+  return pat
+    .fmap((value) => {
+      // destructure voicing controls out
+      value = typeof value === 'string' ? { chord: value } : value;
+      let { dictionary = 'default', chord, anchor, offset, mode, n, octaves, ...rest } = value;
+      dictionary =
+        typeof dictionary === 'string' ? voicingRegistry[dictionary] : { dictionary, mode: 'below', anchor: 'c5' };
+      let notes = renderVoicing({ ...dictionary, chord, anchor, offset, mode, n, octaves });
+
+      return stack(...notes)
+        .note()
+        .set(rest); // rest does not include voicing controls anymore!
+    })
+    .outerJoin();
+});
+
+export function voicingAlias(symbol, alias, setOrSets) {
+  setOrSets = !Array.isArray(setOrSets) ? [setOrSets] : setOrSets;
+  setOrSets.forEach((set) => {
+    set[alias] = set[symbol];
+  });
+}
+
+// no symbol = major chord
+voicingAlias('^', '', [simple, complex]);
+
+Object.keys(simple).forEach((symbol) => {
+  // add aliases for "-" === "m"
+  if (symbol.includes('-')) {
+    let alias = symbol.replace('-', 'm');
+    voicingAlias(symbol, alias, [complex, simple]);
+  }
+  // add aliases for "^" === "M"
+  if (symbol.includes('^')) {
+    let alias = symbol.replace('^', 'M');
+    voicingAlias(symbol, alias, [complex, simple]);
+  }
+});
+
+registerVoicings('ireal', simple);
+registerVoicings('ireal-ext', complex);

packages/tone/README.md

@@ -1,34 +0,0 @@
-# @strudel.cycles/tone
-
-This package adds Tone.js functions to strudel Patterns.
-
-## Deprecation Note
-
-This package will not be developed further. Consider using `@strudel.cycles/webaudio` as a replacement.
-
-## Install
-
-```sh
-npm i @strudel.cycles/tone --save
-```
-
-## Example
-
-The following example will create a pattern and play it back with tone.js:
-
-```js
-import { sequence, stack, State, TimeSpan } from '@strudel.cycles/core';
-import { Tone, polysynth, osc, out } from '@strudel.cycles/tone';
-
-const pattern = sequence('c3', ['eb3', stack('g3', 'bb3')]).tone(polysynth().set(osc('sawtooth4')).chain(out()));
-
-document.getElementById('play').addEventListener('click', async () => {
-  await Tone.start();
-  Tone.getTransport().stop();
-  const events = pattern.query(new State(new TimeSpan(0, 4))).filter((e) => e.whole.begin.equals(e.part.begin));
-  events.forEach((event) =>
-    Tone.getTransport().schedule((time) => event.context.onTrigger(time, event), event.whole.begin.valueOf()),
-  );
-  Tone.getTransport().start('+0.1');
-});
-```

packages/tone/index.mjs

@@ -1 +0,0 @@
-export * from './tone.mjs';

packages/tone/package.json

@@ -1,40 +0,0 @@
-{
-  "name": "@strudel.cycles/tone",
-  "version": "0.6.0",
-  "description": "Tone.js API for strudel",
-  "main": "index.mjs",
-  "type": "module",
-  "publishConfig": {
-    "main": "dist/index.js",
-    "module": "dist/index.mjs"
-  },
-  "scripts": {
-    "build": "vite build",
-    "prepublishOnly": "npm run build"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/tidalcycles/strudel.git"
-  },
-  "keywords": [
-    "tidalcycles",
-    "strudel",
-    "pattern",
-    "livecoding",
-    "algorave"
-  ],
-  "author": "Felix Roos <flix91@gmail.com>",
-  "license": "AGPL-3.0-or-later",
-  "bugs": {
-    "url": "https://github.com/tidalcycles/strudel/issues"
-  },
-  "homepage": "https://github.com/tidalcycles/strudel#readme",
-  "dependencies": {
-    "@strudel.cycles/core": "workspace:*",
-    "tone": "^14.7.77"
-  },
-  "devDependencies": {
-    "vite": "^3.2.2",
-    "vitest": "^0.25.7"
-  }
-}

packages/tone/test/tone.test.mjs

@@ -1,18 +0,0 @@
-/*
-tone.test.mjs - <short description TODO>
-Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/tone/test/tone.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 '../tone.mjs';
-import { pure } from '@strudel.cycles/core';
-import { describe, it, expect } from 'vitest';
-
-describe('tone', () => {
-  it('Should have working tone function', () => {
-    // const s = synth().chain(out()); // TODO: mock audio context?
-    // assert.deepStrictEqual(s, new Tone.Synth().chain(out()));
-    const s = {};
-    expect(pure('c3').tone(s).firstCycleValues).toEqual(['c3']);
-  });
-});

packages/tone/tone.mjs

@@ -1,106 +0,0 @@
-/*
-tone.mjs - <short description TODO>
-Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/tone/tone.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 } from '@strudel.cycles/core';
-import * as _Tone from 'tone';
-
-// import Tone from here, to make sure to get the same AudioContext
-export const Tone = _Tone;
-
-const {
-  Filter,
-  Gain,
-  Synth,
-  PolySynth,
-  MembraneSynth,
-  MetalSynth,
-  MonoSynth,
-  AMSynth,
-  DuoSynth,
-  FMSynth,
-  NoiseSynth,
-  PluckSynth,
-  Sampler,
-  getDestination,
-  Players,
-} = Tone;
-import { getPlayableNoteValue } from '@strudel.cycles/core/util.mjs';
-
-// "balanced" | "interactive" | "playback";
-// Tone.setContext(new Tone.Context({ latencyHint: 'playback', lookAhead: 1 }));
-export const getDefaultSynth = () => {
-  const s = new PolySynth().chain(new Gain(0.5), getDestination());
-  s.set({
-    oscillator: { type: 'triangle' },
-    envelope: {
-      release: 0.01,
-    },
-  });
-  return s;
-};
-
-// what about
-// https://www.charlie-roberts.com/gibberish/playground/
-
-// with this function, you can play the pattern with any tone synth
-export const tone = register('tone', function (instrument, pat) {
-  return pat.onTrigger((time, hap) => {
-    let note;
-    let velocity = hap.context?.velocity ?? 0.75;
-    if (instrument instanceof PluckSynth) {
-      note = getPlayableNoteValue(hap);
-      instrument.triggerAttack(note, time);
-    } else if (instrument instanceof NoiseSynth) {
-      instrument.triggerAttackRelease(hap.duration.valueOf(), time); // noise has no value
-    } else if (instrument instanceof Sampler) {
-      note = getPlayableNoteValue(hap);
-      instrument.triggerAttackRelease(note, hap.duration.valueOf(), time, velocity);
-    } else if (instrument instanceof Players) {
-      if (!instrument.has(hap.value)) {
-        throw new Error(`name "${hap.value}" not defined for players`);
-      }
-      const player = instrument.player(hap.value);
-      // velocity ?
-      player.start(time);
-      player.stop(time + hap.duration.valueOf());
-    } else {
-      note = getPlayableNoteValue(hap);
-      instrument.triggerAttackRelease(note, hap.duration.valueOf(), time, velocity);
-    }
-  });
-});
-
-// synth helpers
-export const amsynth = (options) => new AMSynth(options);
-export const duosynth = (options) => new DuoSynth(options);
-export const fmsynth = (options) => new FMSynth(options);
-export const membrane = (options) => new MembraneSynth(options);
-export const metal = (options) => new MetalSynth(options);
-export const monosynth = (options) => new MonoSynth(options);
-export const noise = (options) => new NoiseSynth(options);
-export const pluck = (options) => new PluckSynth(options);
-export const polysynth = (options) => new PolySynth(options);
-export const sampler = (options, baseUrl) =>
-  new Promise((resolve) => {
-    const s = new Sampler(options, () => resolve(s), baseUrl);
-  });
-export const players = (options, baseUrl = '') => {
-  options = !baseUrl
-    ? options
-    : Object.fromEntries(Object.entries(options).map(([key, value]) => [key, baseUrl + value]));
-  return new Promise((resolve) => {
-    const s = new Players(options, () => resolve(s));
-  });
-};
-export const synth = (options) => new Synth(options);
-
-// effect helpers
-export const vol = (v) => new Gain(v);
-export const lowpass = (v) => new Filter(v, 'lowpass');
-export const highpass = (v) => new Filter(v, 'highpass');
-export const adsr = (a, d = 0.1, s = 0.4, r = 0.01) => ({ envelope: { attack: a, decay: d, sustain: s, release: r } });
-export const osc = (type) => ({ oscillator: { type } });
-export const out = () => getDestination();

packages/transpiler/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel.cycles/transpiler",
-  "version": "0.6.0",
+  "version": "0.8.2",
   "description": "Transpiler for strudel user code. Converts syntactically correct but semantically meaningless JS into evaluatable strudel code.",
   "main": "index.mjs",
   "publishConfig": {
@@ -31,12 +31,13 @@
   "homepage": "https://github.com/tidalcycles/strudel#readme",
   "dependencies": {
     "@strudel.cycles/core": "workspace:*",
+    "@strudel.cycles/mini": "workspace:*",
     "acorn": "^8.8.1",
     "escodegen": "^2.0.0",
     "estree-walker": "^3.0.1"
   },
   "devDependencies": {
-    "vite": "^3.2.2",
-    "vitest": "^0.25.8"
+    "vite": "^4.3.3",
+    "vitest": "^0.33.0"
   }
 }

packages/transpiler/test/transpiler.test.mjs

@@ -11,22 +11,20 @@ const simple = { wrapAsync: false, addReturn: false, simpleLocs: true };
 
 describe('transpiler', () => {
   it('wraps double quote string with mini and adds location', () => {
-    expect(transpiler('"c3"', simple)).toEqual("mini('c3').withMiniLocation(0, 4);");
-    expect(transpiler('stack("c3","bd sd")', simple)).toEqual(
-      "stack(mini('c3').withMiniLocation(6, 10), mini('bd sd').withMiniLocation(11, 18));",
-    );
+    expect(transpiler('"c3"', simple).output).toEqual("m('c3', 0);");
+    expect(transpiler('stack("c3","bd sd")', simple).output).toEqual("stack(m('c3', 6), m('bd sd', 11));");
   });
   it('wraps backtick string with mini and adds location', () => {
-    expect(transpiler('`c3`', simple)).toEqual("mini('c3').withMiniLocation(0, 4);");
+    expect(transpiler('`c3`', simple).output).toEqual("m('c3', 0);");
   });
   it('replaces note variables with note strings', () => {
-    expect(transpiler('seq(c3, d3)', simple)).toEqual("seq('c3', 'd3');");
+    expect(transpiler('seq(c3, d3)', simple).output).toEqual("seq('c3', 'd3');");
   });
   it('keeps tagged template literal as is', () => {
-    expect(transpiler('xxx`c3`', simple)).toEqual('xxx`c3`;');
+    expect(transpiler('xxx`c3`', simple).output).toEqual('xxx`c3`;');
   });
   it('supports top level await', () => {
-    expect(transpiler("await samples('xxx');", simple)).toEqual("await samples('xxx');");
+    expect(transpiler("await samples('xxx');", simple).output).toEqual("await samples('xxx');");
   });
   /*   it('parses dynamic imports', () => {
     expect(
@@ -36,4 +34,12 @@ describe('transpiler', () => {
       }),
     ).toEqual("const {default: foo} = await import('https://bar.com/foo.js');");
   }); */
+  it('collections locations', () => {
+    const { miniLocations } = transpiler(`s("bd", "hh oh")`, { ...simple, emitMiniLocations: true });
+    expect(miniLocations).toEqual([
+      [3, 5],
+      [9, 11],
+      [12, 14],
+    ]);
+  });
 });

packages/transpiler/transpiler.mjs

@@ -2,9 +2,10 @@ import escodegen from 'escodegen';
 import { parse } from 'acorn';
 import { walk } from 'estree-walker';
 import { isNoteWithOctave } from '@strudel.cycles/core';
+import { getLeafLocations } from '@strudel.cycles/mini';
 
 export function transpiler(input, options = {}) {
-  const { wrapAsync = false, addReturn = true, simpleLocs = false } = options;
+  const { wrapAsync = false, addReturn = true, emitMiniLocations = true } = options;
 
   let ast = parse(input, {
     ecmaVersion: 2022,
@@ -12,18 +13,27 @@ export function transpiler(input, options = {}) {
     locations: true,
   });
 
+  let miniLocations = [];
+  const collectMiniLocations = (value, node) => {
+    const leafLocs = getLeafLocations(`"${value}"`, node.start); // stimmt!
+    //const withOffset = leafLocs.map((offsets) => offsets.map((o) => o + node.start));
+    miniLocations = miniLocations.concat(leafLocs);
+  };
+
   walk(ast, {
-    enter(node, parent, prop, index) {
+    enter(node, parent /* , prop, index */) {
       if (isBackTickString(node, parent)) {
-        const { quasis, start, end } = node;
+        const { quasis } = node;
         const { raw } = quasis[0].value;
         this.skip();
-        return this.replace(miniWithLocation(raw, node, simpleLocs));
+        emitMiniLocations && collectMiniLocations(raw, node);
+        return this.replace(miniWithLocation(raw, node));
       }
       if (isStringWithDoubleQuotes(node)) {
-        const { value, start, end } = node;
+        const { value } = node;
         this.skip();
-        return this.replace(miniWithLocation(value, node, simpleLocs));
+        emitMiniLocations && collectMiniLocations(value, node);
+        return this.replace(miniWithLocation(value, node));
       }
       // TODO: remove pseudo note variables?
       if (node.type === 'Identifier' && isNoteWithOctave(node.name)) {
@@ -47,11 +57,14 @@ export function transpiler(input, options = {}) {
       argument: expression,
     };
   }
-  const output = escodegen.generate(ast);
+  let output = escodegen.generate(ast);
   if (wrapAsync) {
-    return `(async ()=>{${output}})()`;
+    output = `(async ()=>{${output}})()`;
   }
-  return output;
+  if (!emitMiniLocations) {
+    return { output };
+  }
+  return { output, miniLocations };
 }
 
 function isStringWithDoubleQuotes(node, locations, code) {
@@ -66,64 +79,18 @@ function isBackTickString(node, parent) {
   return node.type === 'TemplateLiteral' && parent.type !== 'TaggedTemplateExpression';
 }
 
-function miniWithLocation(value, node, simpleLocs) {
-  let locs;
-  const { start: fromOffset, end: toOffset } = node;
-  if (simpleLocs) {
-    locs = [
-      {
-        type: 'Literal',
-        value: fromOffset,
-      },
-      {
-        type: 'Literal',
-        value: toOffset,
-      },
-    ];
-  } else {
-    const {
-      loc: {
-        start: { line: fromLine, column: fromColumn },
-        end: { line: toLine, column: toColumn },
-      },
-    } = node;
-    locs = [
-      {
-        type: 'ArrayExpression',
-        elements: [fromLine, fromColumn, fromOffset].map((value) => ({
-          type: 'Literal',
-          value,
-        })),
-      },
-      {
-        type: 'ArrayExpression',
-        elements: [toLine, toColumn, toOffset].map((value) => ({
-          type: 'Literal',
-          value,
-        })),
-      },
-    ];
-  }
-  // with location
+function miniWithLocation(value, node) {
+  const { start: fromOffset } = node;
   return {
     type: 'CallExpression',
     callee: {
-      type: 'MemberExpression',
-      object: {
-        type: 'CallExpression',
-        callee: {
-          type: 'Identifier',
-          name: 'mini',
-        },
-        arguments: [{ type: 'Literal', value }],
-        optional: false,
-      },
-      property: {
-        type: 'Identifier',
-        name: 'withMiniLocation',
-      },
+      type: 'Identifier',
+      name: 'm',
     },
-    arguments: locs,
+    arguments: [
+      { type: 'Literal', value },
+      { type: 'Literal', value: fromOffset },
+    ],
     optional: false,
   };
 }

packages/web/README.md

@@ -0,0 +1,82 @@
+# @strudel/web
+
+This package provides an easy to use bundle of multiple strudel packages for the web.
+
+## Usage
+
+Save this code as a `.html` file and double click it:
+
+```html
+<!DOCTYPE html>
+<button id="play">play</button>
+<button id="stop">stop</button>
+<script type="module">
+  import { initStrudel } from 'https://cdn.skypack.dev/@strudel/web@0.8.2';
+
+  initStrudel();
+  document.getElementById('play').addEventListener('click', () => note('<c a f e>(3,8)').play());
+  document.getElementById('stop').addEventListener('click', () => hush());
+</script>
+```
+
+With the help of [skypack](https://www.skypack.dev/), you don't need a bundler nor a server.
+
+As soon as you call `initStrudel()`, all strudel functions are made available.
+In this case, we are using the `note` function to create a pattern.
+To actually play the pattern, you have to append `.play()` to the end.
+
+Note: Due to the [Autoplay policy](https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API/Best_practices#autoplay_policy), you can only play audio in a browser after a click event.
+
+### Via npm
+
+If you're using a bundler, you can install the package via `npm i @strudel/web`, then just import it like:
+
+```js
+import { initStrudel } from '@strudel/web';
+```
+
+The rest of the code should be the same. Check out [vite](https://vitejs.dev/) for a good bundler / dev server.
+
+### Loading samples
+
+By default, no external samples are loaded, but you can add them like this:
+
+```js
+initStrudel({
+  prebake: () => samples('github:tidalcycles/Dirt-Samples/master'),
+});
+
+document.getElementById('play').addEventListener('click', 
+  () => s("bd sd").play()
+)
+```
+
+You can learn [more about the `samples` function here](https://strudel.tidalcycles.org/learn/samples#loading-custom-samples).
+
+### Evaluating Code
+
+Instead of creating patterns directly in JS, you might also want to take in user input and turn that into a pattern.
+This is called evaluation: Taking a piece of code and executing it on the fly.
+
+To do that, you can use the `evaluate` function:
+
+```js
+initStrudel();
+document.getElementById('play').addEventListener('click', 
+  () => evaluate('note("c a f e").jux(rev)')
+);
+document.getElementById('play').addEventListener('stop', 
+  () => hush()
+);
+```
+
+### Double vs Single Quotes
+
+There is a tiny difference between the [Strudel REPL](https://strudel.tidalcycles.org/) and `@strudel/web`.
+In the REPL you can use 'single quotes' for regular JS strings and "double quotes" for mini notation patterns.
+In `@strudel/web`, it does not matter which types of quotes you're using.
+There will probably be an escapte hatch for that in the future.
+
+## More Examples
+
+Check out the examples folder for more examples, both using plain html and vite!

packages/web/examples/evaluate.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<button id="play">play</button>
+<button id="stop">stop</button>
+<script type="module">
+  import { initStrudel } from 'https://cdn.skypack.dev/@strudel/web@0.8.2';
+
+  initStrudel();
+  document.getElementById('play').addEventListener('click', () => evaluate('note("c a f e").jux(rev)'));
+  document.getElementById('play').addEventListener('stop', () => hush());
+</script>

packages/web/examples/headless-serverless-buildless.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<button id="a">A</button>
+<button id="b">B</button>
+<button id="c">C</button>
+<button id="stop">stop</button>
+<script type="module">
+  import { initStrudel } from 'https://cdn.skypack.dev/@strudel/web@0.8.2';
+  initStrudel({
+    prebake: () => samples('github:tidalcycles/Dirt-Samples/master'),
+  });
+  const click = (id, action) => document.getElementById(id).addEventListener('click', action);
+  click('a', () => evaluate(`s('bd,jvbass(3,8)').jux(rev)`));
+  click('b', () => s('bd*2,hh(3,4),jvbass(5,8,1)').jux(rev).play());
+  click('c', () => s('bd*2,hh(3,4),jvbass:[0 4](5,8,1)').jux(rev).stack(s('~ sd')).play());
+  click('stop', () => hush());
+</script>