cf

Merge branch 'main' into daslyfe/jade/delaycycle
Merge pull request 'Case insensitive search in the reference tab' (#1420 ) from kdiab/strudel:main into main
2026-07-21 20:55:12 -04:00 · 2025-06-28 14:06:16 -04:00 · 2025-06-28 20:01:57 +02:00 · 2025-06-28 13:44:47 +02:00 · 2025-06-28 00:04:12 +02:00 · 2025-06-27 22:59:01 +01:00
67 changed files with 3829 additions and 1412 deletions
@@ -1,6 +1,6 @@
 name: Strudel tests

-on: [push, pull_request]
+on: [push]

 jobs:
  build:
@@ -11,13 +11,15 @@ jobs:

    steps:
      - uses: actions/checkout@v4
+      - name: apt install ztd
+        run: apt update && apt install -y zstd
      - uses: pnpm/action-setup@v4
        with:
          version: 9.12.2
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
-          # cache: 'pnpm'
+          cache: 'pnpm'
      - run: pnpm install
      - run: pnpm run format-check
      - run: pnpm run lint
@@ -17,7 +17,7 @@ git remote set-url origin git@codeberg.org:uzu/strudel.git

 To get in touch with the contributors, either

- [join the Tidal Discord Channel](https://discord.gg/remJ6gQA) and go to the #strudel channel
+- [join the Tidal Discord Channel](https://discord.com/invite/HGEdXmRkzT) and go to the #strudel channel
 - Find related discussions on the [tidal club forum](https://club.tidalcycles.org/)

 ## Ask a Question
@@ -32,7 +32,7 @@ This project is organized into many [packages](./packages), which are also avail

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

-You will need to abide by the terms of the [GNU Affero Public Licence v3](LICENSE.md). As such, Strudel code can only be shared within free/open source projects under the same license -- see the license for details.
+You will need to abide by the terms of the [GNU Affero Public Licence v3](LICENSE). As such, Strudel code can only be shared within free/open source projects under the same license -- see the license for details.

 Licensing info for the default sound banks can be found over on the [dough-samples](https://github.com/felixroos/dough-samples/blob/main/README.md) repository.

@@ -201,7 +201,7 @@ interfaces.

 The Strudel REPL is available at <https://strudel.cc>,
 including an interactive tutorial. The repository is at
-<https://github.com/tidalcycles/strudel>, all the code is open source
+<https://codeberg.org/uzu/strudel/releases>, all the code is open source
 under the GPL-3.0 License.

 # Acknowledgments
@@ -128,7 +128,7 @@ For the future, it is planned to integrate alternative sound engines such as Gli
 # Links

 The Strudel REPL is available at <https://strudel.cc>, including an interactive tutorial.
-The repository is at <https://github.com/tidalcycles/strudel>, all the code is open source under the GPL-3.0 License.
+The repository is at <https://codeberg.org/uzu/strudel/releases>, all the code is open source under the GPL-3.0 License.

 # Acknowledgments

@@ -451,7 +451,7 @@ While Haskell's type system makes it a great language for the ongoing developmen
 # Links

 The Strudel REPL is available at <https://strudel.cc>, including an interactive tutorial.
-The repository is at <https://github.com/tidalcycles/strudel>, all the code is open source under the AGPL-3.0 License.
+The repository is at <https://codeberg.org/uzu/strudel>, all the code is open source under the AGPL-3.0 License.

 # Acknowledgments

@@ -1,80 +1,63 @@
-$if(false)$
-
-This is a pandoc template and should not be edited.
-
-$endif$
+$if(false)$ This is a pandoc template and should not be edited. $endif$
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"$if(lang)$ lang="$lang$" xml:lang="$lang$"$endif$>
-<head>
-  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-  <meta http-equiv="Content-Style-Type" content="text/css" />
-  <meta name="generator" content="pandoc" />
-$for(author-meta)$
-  <meta name="author" content="$author-meta$" />
-$endfor$
-$if(date-meta)$
-  <meta name="date" content="$date-meta$" />
-$endif$
-  <title>$if(title-prefix)$$title-prefix$ - $endif$$pagetitle$</title>
-  <style type="text/css">code{white-space: pre;}</style>
-$if(quotes)$
-  <style type="text/css">q { quotes: "“" "”" "‘" "’"; }</style>
-$endif$
-$if(highlighting-css)$
-  <style type="text/css">
-$highlighting-css$
-  </style>
-$endif$
-  <link rel="stylesheet" href="css/iclc.css" $if(html5)$$else$type="text/css" $endif$/>
-$for(css)$
-  <link rel="stylesheet" href="$css$" $if(html5)$$else$type="text/css" $endif$/>
-$endfor$
-$if(math)$
-  $math$
-$endif$
-$for(header-includes)$
-  $header-includes$
-$endfor$
-</head>
-<body>
-$for(include-before)$
-$include-before$
-$endfor$
-$if(title)$
-<div id="$idprefix$header">
-<h1 class="title">$title$</h1>
-$if(subtitle)$
-<h1 class="subtitle">$subtitle$</h1>
-$endif$
-<ul id="authorlist">
-$for(author)$
-<li>$author$</li>
-$endfor$
-</ul>
-$if(date)$
-<h3 class="date">$date$</h3>
-$endif$
-</div>
-$endif$
-$if(toc)$
-<div id="$idprefix$TOC">
-$toc$
-</div>
-$endif$
+<html xmlns="http://www.w3.org/1999/xhtml" $if(lang)$ lang="$lang$" xml:lang="$lang$" $endif$>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <meta http-equiv="Content-Style-Type" content="text/css" />
+    <meta name="generator" content="pandoc" />
+    $for(author-meta)$
+    <meta name="author" content="$author-meta$" />
+    $endfor$ $if(date-meta)$
+    <meta name="date" content="$date-meta$" />
+    $endif$
+    <title>$if(title-prefix)$$title-prefix$ - $endif$$pagetitle$</title>
+    <style type="text/css">
+      code {
+        white-space: pre;
+      }
+    </style>
+    $if(quotes)$
+    <style type="text/css">
+      q {
+        quotes: '“' '”' '‘' '’';
+      }
+    </style>
+    $endif$ $if(highlighting-css)$
+    <style type="text/css">
+      $highlighting-css$
+    </style>
+    $endif$
+    <link rel="stylesheet" href="css/iclc.css" $if(html5)$$else$type="text/css" $endif$ />
+    $for(css)$
+    <link rel="stylesheet" href="$css$" $if(html5)$$else$type="text/css" $endif$ />
+    $endfor$ $if(math)$ $math$ $endif$ $for(header-includes)$ $header-includes$ $endfor$
+  </head>
+  <body>
+    $for(include-before)$ $include-before$ $endfor$ $if(title)$
+    <div id="$idprefix$header">
+      <h1 class="title">$title$</h1>
+      $if(subtitle)$
+      <h1 class="subtitle">$subtitle$</h1>
+      $endif$
+      <ul id="authorlist">
+        $for(author)$
+        <li>$author$</li>
+        $endfor$
+      </ul>
+      $if(date)$
+      <h3 class="date">$date$</h3>
+      $endif$
+    </div>
+    $endif$ $if(toc)$
+    <div id="$idprefix$TOC">$toc$</div>
+    $endif$

-<h2 class="abstract">Abstract</h2>
-<div id="abstract">
-$if(abstract)$
-$abstract$
-$else$
-Please provide an abstract in the metadata block at the top of your
-markdown document. Refer to template.txt for details.
-$endif$
-</div>
+    <h2 class="abstract">Abstract</h2>
+    <div id="abstract">
+      $if(abstract)$ $abstract$ $else$ Please provide an abstract in the metadata block at the top of your markdown
+      document. Refer to template.txt for details. $endif$
+    </div>

-$body$
-$for(include-after)$
-$include-after$
-$endfor$
-</body>
+    $body$ $for(include-after)$ $include-after$ $endfor$
+  </body>
 </html>
@@ -2,4 +2,4 @@

 Each folder represents one of the @strudel/* packages [published to npm](https://www.npmjs.com/org/strudel).

-To understand how those pieces connect, refer to the [Technical Manual](https://codeberg.org/uzu/strudel/src/branch/main/technical-manual.md) or the individual READMEs.
+To understand how those pieces connect, refer to the [Technical Manual](https://codeberg.org/uzu/strudel/wiki/Technical-Manual) or the individual READMEs.
@@ -62,7 +62,7 @@ export const codemirrorSettings = persistentAtom('codemirror-settings', defaultS
 });

 // https://codemirror.net/docs/guide/
-export function initEditor({ initialCode = '', onChange, onEvaluate, onStop, root }) {
+export function initEditor({ initialCode = '', onChange, onEvaluate, onStop, root, mondo }) {
  const settings = codemirrorSettings.get();
  const initialSettings = Object.keys(compartments).map((key) =>
    compartments[key].of(extensions[key](parseBooleans(settings[key]))),
@@ -75,7 +75,7 @@ export function initEditor({ initialCode = '', onChange, onEvaluate, onStop, roo
      /* search(),
      highlightSelectionMatches(), */
      ...initialSettings,
-      javascript(),
+      mondo ? [] : javascript(),
      sliderPlugin,
      widgetPlugin,
      // indentOnInput(), // works without. already brought with javascript extension?
@@ -209,6 +209,7 @@ export class StrudelMirror {
      },
      onEvaluate: () => this.evaluate(),
      onStop: () => this.stop(),
+      mondo: replOptions.mondo,
    });
    const cmEditor = this.root.querySelector('.cm-editor');
    if (cmEditor) {
@@ -1,4 +1,4 @@
-import { RangeSetBuilder, StateEffect, StateField } from '@codemirror/state';
+import { RangeSetBuilder, StateEffect, StateField, Prec } from '@codemirror/state';
 import { Decoration, EditorView } from '@codemirror/view';

 export const setMiniLocations = StateEffect.define();
@@ -134,5 +134,5 @@ export const isPatternHighlightingEnabled = (on, config) => {
    setTimeout(() => {
      updateMiniLocations(config.editor, config.miniLocations);
    }, 100);
-  return on ? highlightExtension : [];
+  return on ? Prec.highest(highlightExtension) : [];
 };
@@ -8,6 +8,11 @@ import CutiePi, { settings as CutiePiSettings } from './themes/CutiePi.mjs';
 import sonicPink, { settings as sonicPinkSettings } from './themes/sonic-pink.mjs';
 import redText, { settings as redTextSettings } from './themes/red-text.mjs';
 import greenText, { settings as greenTextSettings } from './themes/green-text.mjs';
+import archBtw, { settings as archBtwSettings } from './themes/archBtw.mjs';
+import fruitDaw, { settings as fruitDawSettings } from './themes/fruitDaw.mjs';
+
+import bluescreenlight, { settings as bluescreenlightsettings } from './themes/bluescreenlight.mjs';
+
 import androidstudio, { settings as androidstudioSettings } from './themes/androidstudio.mjs';
 import atomone, { settings as atomOneSettings } from './themes/atomone.mjs';
 import aura, { settings as auraSettings } from './themes/aura.mjs';
@@ -39,17 +44,20 @@ import { setTheme } from '@strudel/draw';
 export const themes = {
  strudelTheme,
  algoboy,
+  archBtw,
  androidstudio,
  atomone,
  aura,
  bbedit,
  blackscreen,
  bluescreen,
+  bluescreenlight,
  CutiePi,
  darcula,
  dracula,
  duotoneDark,
  eclipse,
+  fruitDaw,
  githubDark,
  githubLight,
  greenText,
@@ -78,10 +86,12 @@ export const themes = {
 export const settings = {
  strudelTheme: strudelThemeSettings,
  bluescreen: bluescreenSettings,
+  bluescreenlight: bluescreenlightsettings,
  blackscreen: blackscreenSettings,
  whitescreen: whitescreenSettings,
  teletext: teletextSettings,
  algoboy: algoboySettings,
+  archBtw: archBtwSettings,
  androidstudio: androidstudioSettings,
  atomone: atomOneSettings,
  aura: auraSettings,
@@ -92,9 +102,11 @@ export const settings = {
  eclipse: eclipseSettings,
  CutiePi: CutiePiSettings,
  sonicPink: sonicPinkSettings,
+  fruitDaw: fruitDawSettings,
  githubLight: githubLightSettings,
  githubDark: githubDarkSettings,
  greenText: greenTextSettings,
+
  gruvboxDark: gruvboxDarkSettings,
  gruvboxLight: gruvboxLightSettings,
  materialDark: materialDarkSettings,
@@ -0,0 +1,38 @@
+/*
+ * Arch Btw
+ * Modern terminal inspired theme
+ * made by Jade
+ */
+import { tags as t } from '@lezer/highlight';
+import { createTheme } from './theme-helper.mjs';
+
+const hex = ['rgb(0, 0, 0)', 'rgb(82, 208, 250)', 'rgba(113, 208, 250, .4)', 'rgba(113, 208, 250, .15)'];
+
+export const settings = {
+  background: hex[0],
+  lineBackground: 'transparent',
+  foreground: hex[1],
+  selection: hex[2],
+  selectionMatch: hex[0],
+  gutterBackground: hex[0],
+  gutterForeground: hex[2],
+  gutterBorder: 'transparent',
+  lineHighlight: hex[0],
+};
+
+export default createTheme({
+  theme: 'dark',
+  settings,
+  styles: [
+    {
+      tag: [t.function(t.variableName), t.function(t.propertyName), t.url, t.processingInstruction],
+      color: hex[1],
+    },
+    { tag: [t.atom, t.bool, t.special(t.variableName)], color: hex[1] },
+    { tag: [t.comment, t.brace, t.bracket], color: hex[2] },
+    { tag: [t.variableName, t.propertyName, t.labelName], color: hex[1] },
+    { tag: [t.attributeName, t.number], color: hex[1] },
+    { tag: t.keyword, color: hex[1] },
+    { tag: [t.string, t.regexp, t.special(t.propertyName)], color: hex[1] },
+  ],
+});
@@ -0,0 +1,37 @@
+/*
+ * A lighter blue screen theme
+ * made by Jade
+ */
+import { tags as t } from '@lezer/highlight';
+import { createTheme } from './theme-helper.mjs';
+
+const hex = ['rgb(75, 130, 247)', 'rgb(47, 108, 246)', 'rgb(255, 255, 255)', 'rgba(255, 255, 255,.3)'];
+
+export const settings = {
+  background: hex[0],
+  lineBackground: 'transparent',
+  foreground: hex[2],
+  selection: hex[3],
+  selectionMatch: hex[0],
+  gutterBackground: hex[0],
+  gutterForeground: hex[2],
+  gutterBorder: 'transparent',
+  lineHighlight: hex[1],
+};
+
+export default createTheme({
+  theme: 'dark',
+  settings,
+  styles: [
+    {
+      tag: [t.function(t.variableName), t.function(t.propertyName), t.url, t.processingInstruction],
+      color: hex[2],
+    },
+    { tag: [t.atom, t.bool, t.special(t.variableName)], color: hex[2] },
+    { tag: [t.comment, t.bracket, t.brace, t.compareOperator], color: hex[3] },
+    { tag: [t.variableName, t.propertyName, t.labelName], color: hex[2] },
+    { tag: [t.attributeName, t.number], color: hex[2] },
+    { tag: t.keyword, color: hex[2] },
+    { tag: [t.string, t.regexp, t.special(t.propertyName)], color: hex[2] },
+  ],
+});
@@ -0,0 +1,50 @@
+/*
+ * Fruit Daw
+ * made by Jade
+ */
+import { tags as t } from '@lezer/highlight';
+import { createTheme } from './theme-helper.mjs';
+
+const hex = [
+  'rgb(84, 93, 98)',
+  'rgb(255, 255, 255)',
+  'rgba(255, 255, 255, .25)',
+  'rgb(67, 76, 81)',
+  'rgb(186, 230, 115)',
+  'rgb(252, 184, 67)',
+  'rgb(124, 206, 254)',
+  'rgb(83, 101, 102)',
+  'rgba(46, 62, 72,.5)',
+  'rgb(94, 100, 108)',
+  'rgb(167, 216, 177)',
+];
+
+export const settings = {
+  background: hex[0],
+  lineBackground: 'transparent',
+  foreground: hex[10],
+  selection: hex[8],
+  selectionMatch: hex[0],
+  gutterBackground: hex[3],
+  gutterForeground: hex[2],
+  gutterBorder: 'transparent',
+  lineHighlight: hex[3],
+};
+
+export default createTheme({
+  theme: 'dark',
+  settings,
+  styles: [
+    {
+      tag: [t.function(t.variableName), t.function(t.propertyName), t.url, t.processingInstruction],
+      color: hex[1],
+    },
+    { tag: [t.bool, t.special(t.variableName)], color: hex[1] },
+    { tag: [t.comment, t.brace, t.bracket], color: hex[2] },
+    { tag: [t.variableName], color: hex[1] },
+    { tag: [t.labelName, t.propertyName, t.self, t.atom], color: hex[5] },
+    { tag: [t.attributeName, t.number], color: hex[6] },
+    { tag: t.keyword, color: hex[5] },
+    { tag: [t.string, t.regexp, t.special(t.propertyName)], color: hex[4] },
+  ],
+});
@@ -4,13 +4,14 @@ Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/
 This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

-import { Pattern, register, sequence } from './pattern.mjs';
+import { Pattern, register, reify } from './pattern.mjs';

 export function createParam(names) {
  let isMulti = Array.isArray(names);
  names = !isMulti ? [names] : names;
  const name = names[0];

+  // todo: make this less confusing
  const withVal = (xs) => {
    let bag;
    // check if we have an object with an unnamed control (.value)
@@ -35,25 +36,34 @@ export function createParam(names) {
    }
  };

-  const func = (...pats) => sequence(...pats).withValue(withVal);
-
-  const setter = function (...pats) {
-    if (!pats.length) {
-      return this.fmap(withVal);
+  // todo: make this less confusing
+  const func = function (value, pat) {
+    if (!pat) {
+      return reify(value).withValue(withVal);
    }
-    return this.set(func(...pats));
+    if (typeof value === 'undefined') {
+      return pat.fmap(withVal);
+    }
+    return pat.set(reify(value).withValue(withVal));
+  };
+  Pattern.prototype[name] = function (value) {
+    return func(value, this);
  };
-  Pattern.prototype[name] = setter;
  return func;
 }

 // maps control alias names to the "main" control name
 const controlAlias = new Map();

+export function isControlName(name) {
+  return controlAlias.has(name);
+}
+
 export function registerControl(names, ...aliases) {
  const name = Array.isArray(names) ? names[0] : names;
  let bag = {};
  bag[name] = createParam(names);
+  controlAlias.set(name, name);
  aliases.forEach((alias) => {
    bag[alias] = bag[name];
    controlAlias.set(alias, name);
@@ -975,15 +985,31 @@ export const { delayfeedback, delayfb, dfb } = registerControl('delayfeedback',
 *
 */
 export const { delaytime, delayt, dt } = registerControl('delaytime', 'delayt', 'dt');
-/* // TODO: test
+
+/**
+ * Sets the time of the delay effect in cycles.
+ *
+ * @name delaysync
+ * @param {number | Pattern} cycles delay length in cycles
+ * @synonyms delayt, dt
+ * @example
+ * s("bd bd").delay(.25).delaysync("<1 2 3 5>".div(8))
+ *
+ */
+export const { delaysync } = registerControl('delaysync');
+
+/**
 * Specifies whether delaytime is calculated relative to cps.
 *
 * @name lock
 * @param {number | Pattern} enable When set to 1, delaytime is a direct multiple of a cycle.
+ * @superdirtOnly
 * @example
 * s("sd").delay().lock(1).osc()
 *
+ *
 */
+
 export const { lock } = registerControl('lock');
 /**
 * Set detune for stacked voices of supported oscillators
@@ -139,6 +139,14 @@ export const euclid = register('euclid', function (pulses, steps, pat) {
  return pat.struct(_euclidRot(pulses, steps, 0));
 });

+export const e = register('e', function (euc, pat) {
+  if (!Array.isArray(euc)) {
+    euc = [euc];
+  }
+  const [pulses, steps = pulses, rot = 0] = euc;
+  return pat.struct(_euclidRot(pulses, steps, rot));
+});
+
 export const { euclidrot, euclidRot } = register(['euclidrot', 'euclidRot'], function (pulses, steps, rotation, pat) {
  return pat.struct(_euclidRot(pulses, steps, rotation));
 });
@@ -4,6 +4,8 @@ Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/
 This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

+export const strudelScope = {};
+
 export const evalScope = async (...args) => {
  const results = await Promise.allSettled(args);
  const modules = results.filter((result) => result.status === 'fulfilled').map((r) => r.value);
@@ -18,6 +20,7 @@ export const evalScope = async (...args) => {
  modules.forEach((module) => {
    Object.entries(module).forEach(([name, value]) => {
      globalThis[name] = value;
+      strudelScope[name] = value;
    });
  });
  return modules;
@@ -869,6 +869,31 @@ export class Pattern {
    console.log(drawLine(this));
    return this;
  }
+
+  //////////////////////////////////////////////////////////////////////
+  // methods relating to breaking patterns into subcycles
+
+  // Breaks a pattern into a pattern of patterns, according to the structure of the given binary pattern.
+  unjoin(pieces, func = id) {
+    return pieces.withHap((hap) =>
+      hap.withValue((v) => (v ? func(this.ribbon(hap.whole.begin, hap.whole.duration)) : this)),
+    );
+  }
+
+  /**
+   * Breaks a pattern into pieces according to the structure of a given pattern.
+   * True values in the given pattern cause the corresponding subcycle of the
+   * source pattern to be looped, and for an (optional) given function to be
+   * applied. False values result in the corresponding part of the source pattern
+   * to be played unchanged.
+   * @name into
+   * @memberof Pattern
+   * @example
+   * sound("bd sd ht lt").into("1 0", hurry(2))
+   */
+  into(pieces, func) {
+    return this.unjoin(pieces, func).innerJoin();
+  }
 }

 //////////////////////////////////////////////////////////////////////
@@ -904,12 +929,13 @@ Pattern.prototype.collect = function () {
 * note("<[c,eb,g]!2 [c,f,ab] [d,f,ab]>")
 * .arpWith(haps => haps[2])
 * */
-Pattern.prototype.arpWith = function (func) {
-  return this.collect()
+export const arpWith = register('arpWith', (func, pat) => {
+  return pat
+    .collect()
    .fmap((v) => reify(func(v)))
    .innerJoin()
    .withHap((h) => new Hap(h.whole, h.part, h.value.value, h.combineContext(h.value)));
-};
+});

 /**
 * Selects indices in in stacked notes.
@@ -917,9 +943,11 @@ Pattern.prototype.arpWith = function (func) {
 * note("<[c,eb,g]!2 [c,f,ab] [d,f,ab]>")
 * .arp("0 [0,2] 1 [0,2]")
 * */
-Pattern.prototype.arp = function (pat) {
-  return this.arpWith((haps) => pat.fmap((i) => haps[i % haps.length]));
-};
+export const arp = register(
+  'arp',
+  (indices, pat) => pat.arpWith((haps) => reify(indices).fmap((i) => haps[i % haps.length])),
+  false,
+);

 /*
 * Takes a time duration followed by one or more patterns, and shifts the given patterns in time, so they are
@@ -1981,6 +2009,7 @@ export const apply = register('apply', function (func, pat) {

 /**
 * Plays the pattern at the given cycles per minute.
+ * @deprecated
 * @example
 * s("<bd sd>,hh*2").cpm(90) // = 90 bpm
 */
@@ -2490,6 +2519,37 @@ export const { fastchunk, fastChunk } = register(
  true,
 );

+/**
+ * Like `chunk`, but the function is applied to a looped subcycle of the source pattern.
+ * @name chunkInto
+ * @synonym chunkinto
+ * @memberof Pattern
+ * @example
+ * sound("bd sd ht lt bd - cp lt").chunkInto(4, hurry(2))
+ *   .bank("tr909")
+ */
+export const { chunkinto, chunkInto } = register(['chunkinto', 'chunkInto'], function (n, func, pat) {
+  return pat.into(fastcat(true, ...Array(n - 1).fill(false))._iterback(n), func);
+});
+
+/**
+ * Like `chunkInto`, but moves backwards through the chunks.
+ * @name chunkBackInto
+ * @synonym chunkbackinto
+ * @memberof Pattern
+ * @example
+ * sound("bd sd ht lt bd - cp lt").chunkInto(4, hurry(2))
+ *   .bank("tr909")
+ */
+export const { chunkbackinto, chunkBackInto } = register(['chunkbackinto', 'chunkBackInto'], function (n, func, pat) {
+  return pat.into(
+    fastcat(true, ...Array(n - 1).fill(false))
+      ._iter(n)
+      ._early(1),
+    func,
+  );
+});
+
 // TODO - redefine elsewhere in terms of mask
 export const bypass = register(
  'bypass',
@@ -2719,7 +2779,7 @@ export function stepcat(...timepats) {
  if (timepats.length === 0) {
    return nothing;
  }
-  const findsteps = (x) => (Array.isArray(x) ? x : [x._steps, x]);
+  const findsteps = (x) => (Array.isArray(x) ? x : [x._steps ?? 1, x]);
  timepats = timepats.map(findsteps);
  if (timepats.find((x) => x[0] === undefined)) {
    const times = timepats.map((a) => a[0]).filter((x) => x !== undefined);
@@ -21,6 +21,7 @@ export function repl({
  setInterval,
  clearInterval,
  id,
+  mondo = false,
 }) {
  const state = {
    schedulerError: undefined,
@@ -85,6 +86,17 @@ export function repl({
  const pause = () => scheduler.pause();
  const toggle = () => scheduler.toggle();
  const setCps = (cps) => scheduler.setCps(cps);
+
+  /**
+   * Changes the global tempo to the given cycles per minute
+   *
+   * @name setcpm
+   * @alias setCpm
+   * @param {number} cpm cycles per minute
+   * @example
+   * setcpm(140/4) // =140 bpm in 4/4
+   * $: s("bd*4,[- sd]*2").bank('tr707')
+   */
  const setCpm = (cpm) => scheduler.setCps(cpm / 60);

  // TODO - not documented as jsdoc examples as the test framework doesn't simulate enough context for `each` and `all`..
@@ -102,8 +114,9 @@ export function repl({
   * all(x => x.pianoroll())
   * ```
   */
+  let allTransforms = [];
  const all = function (transform) {
-    allTransform = transform;
+    allTransforms.push(transform);
    return silence;
  };
  /** Applies a function to each of the running patterns separately. This is intended for future use with upcoming 'stepwise' features. See `all` for a version that applies the function to all the patterns stacked together into a single pattern.
@@ -179,7 +192,12 @@ export function repl({
      await injectPatternMethods();
      setTime(() => scheduler.now()); // TODO: refactor?
      await beforeEval?.({ code });
+      allTransforms = []; // reset all transforms
      shouldHush && hush();
+
+      if (mondo) {
+        code = `mondolang\`${code}\``;
+      }
      let { pattern, meta } = await _evaluate(code, transpiler, transpilerOptions);
      if (Object.keys(pPatterns).length) {
        let patterns = Object.values(pPatterns);
@@ -191,8 +209,10 @@ export function repl({
      } else if (eachTransform) {
        pattern = eachTransform(pattern);
      }
-      if (allTransform) {
-        pattern = allTransform(pattern);
+      if (allTransforms.length) {
+        for (let i in allTransforms) {
+          pattern = allTransforms[i](pattern);
+        }
      }
      if (!isPattern(pattern)) {
        const message = `got "${typeof evaluated}" instead of pattern`;
@@ -71,7 +71,6 @@ export const sine2 = signal((t) => Math.sin(Math.PI * 2 * t));

 /**
 *  A sine signal between 0 and 1.
- *
 * @return {Pattern}
 * @example
 * n(sine.segment(16).range(0,15))
@@ -100,7 +99,6 @@ export const cosine2 = sine2._early(Fraction(1).div(4));

 /**
 *  A square signal between 0 and 1.
- *
 * @return {Pattern}
 * @example
 * n(square.segment(4).range(0,7)).scale("C:minor")
@@ -285,7 +283,7 @@ const _rearrangeWith = (ipat, n, pat) => {
 * @example
 * note("c d e f").sound("piano").shuffle(4)
 * @example
- * note("c d e f".shuffle(4), "g").sound("piano")
+ * seq("c d e f".shuffle(4), "g").note().sound("piano")
 */
 export const shuffle = register('shuffle', (n, pat) => {
  return _rearrangeWith(randrun(n), n, pat);
@@ -298,7 +296,7 @@ export const shuffle = register('shuffle', (n, pat) => {
 * @example
 * note("c d e f").sound("piano").scramble(4)
 * @example
- * note("c d e f".scramble(4), "g").sound("piano")
+ * seq("c d e f".scramble(4), "g").note().sound("piano")
 */
 export const scramble = register('scramble', (n, pat) => {
  return _rearrangeWith(_irand(n)._segment(n), n, pat);
@@ -398,6 +396,10 @@ export const chooseInWith = (pat, xs) => {
 */
 export const choose = (...xs) => chooseWith(rand, xs);

+// todo: doc
+export const chooseIn = (...xs) => chooseInWith(rand, xs);
+export const chooseOut = choose;
+
 /**
 * Chooses from the given list of values (or patterns of values), according
 * to the pattern that the method is called on. The pattern should be in
@@ -52,6 +52,7 @@ import {
  stackCentre,
  stepcat,
  sometimes,
+  expand,
 } from '../index.mjs';

 import { steady } from '../signal.mjs';
@@ -884,7 +885,7 @@ describe('Pattern', () => {
      );
    });
    it('Doesnt drop haps in the 9th cycle', () => {
-      // fixed with https://github.com/tidalcycles/strudel/commit/72eeaf446e3d5e186d63cc0d2276f0723cde017a
+      // fixed with https://codeberg.org/uzu/strudel/commit/72eeaf446e3d5e186d63cc0d2276f0723cde017a
      expect(sequence(1, 2, 3).ply(2).early(8).firstCycle().length).toBe(6);
    });
  });
@@ -1001,7 +1002,7 @@ describe('Pattern', () => {
  });
  describe('hurry', () => {
    it('Can speed up patterns and sounds', () => {
-      sameFirst(s('a', 'b').hurry(2), s('a', 'b').fast(2).speed(2));
+      sameFirst(s(sequence('a', 'b')).hurry(2), s(sequence('a', 'b')).fast(2).speed(2));
    });
  });
  /*describe('composable functions', () => {
@@ -1179,6 +1180,9 @@ describe('Pattern', () => {
    it('calculates undefined steps as the average', () => {
      expect(sameFirst(stepcat(pure(1), pure(2), pure(3).setSteps(undefined)), fastcat(1, 2, 3)));
    });
+    it('works with auto-reified values', () => {
+      expect(sameFirst(stepcat(expand(3, 'bd'), 'rim'), stepcat(expand(3, 'bd'), pure('rim'))));
+    });
  });
  describe('shrink', () => {
    it('can shrink', () => {
@@ -1267,4 +1271,39 @@ describe('Pattern', () => {
      );
    });
  });
+  describe('unjoin', () => {
+    it('destructures a pattern into subcycles', () => {
+      sameFirst(
+        fastcat('a', 'b', 'c', 'd')
+          .unjoin(fastcat(true, fastcat(true, true)))
+          .fmap(fast(2))
+          .join(),
+        fastcat('a', 'b', 'a', 'b', 'c', 'c', 'd', 'd'),
+      );
+    });
+  });
+  describe('into', () => {
+    it('applies a function to subcycles of a pattern', () => {
+      sameFirst(
+        fastcat('a', 'b', 'c', 'd').into(fastcat(fastcat('true', 'true'), 'true'), fast(2)),
+        fastcat('a', 'a', 'b', 'b', 'c', 'd', 'c', 'd'),
+      );
+    });
+  });
+  describe('chunkinto', () => {
+    it('chunks into subcycles', () => {
+      sameFirst(
+        fastcat('a', 'b', 'c').chunkInto(3, fast(2)).fast(3),
+        fastcat(fastcat('a', 'a'), 'b', 'c', 'a', fastcat('b', 'b'), 'c', 'a', 'b', fastcat('c', 'c')),
+      );
+    });
+  });
+  describe('chunkbackinto', () => {
+    it('chunks into subcycles backwards', () => {
+      sameFirst(
+        fastcat('a', 'b', 'c').chunkBackInto(3, fast(2)).fast(3),
+        fastcat('a', 'b', fastcat('c', 'c'), 'a', fastcat('b', 'b'), 'c', fastcat('a', 'a'), 'b', 'c'),
+      );
+    });
+  });
 });
@@ -150,7 +150,7 @@ export class Drawer {
        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.endClipped >= phase - lookbehind - lookahead)
+          .filter((h) => h.whole && h.endClipped >= phase - lookbehind - lookahead)
          // add new haps with onset (think right edge bars scrolling in)
          .concat(haps.filter((h) => h.hasOnset()));
        const time = phase - lookahead;
@@ -175,7 +175,7 @@ export class Drawer {
    // +0.1 = workaround for weird holes in query..
    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);
+    this.visibleHaps = this.visibleHaps.filter((h) => h.whole?.begin < t);
    this.painters = []; // will get populated by .onPaint calls attached to the pattern
    // query future haps
    const futureHaps = scheduler.pattern.queryArc(begin, end, { painters: this.painters });
@@ -56,14 +56,15 @@ You can use button inputs to control different aspects of your music, such as ga
 <MiniRepl
  client:idle
  tune={`const gp = gamepad(0)
-  // Use button values to control amplitude
+setcpm(120) 
+// Use button values to control amplitude
 $: stack(
  s("[[hh hh] oh hh oh]/2").mask(gp.tglX).bank("RolandTR909"), // X btn for HH
   s("cr*1").mask(gp.Y).bank("RolandTR909"), // LB btn for CR
  s("bd").mask(gp.tglA).bank("RolandTR909"), // A btn for BD
  s("[ht - - mt - - lt - ]/2").mask(gp.tglB).bank("RolandTR909"), // B btn for Toms
  s("sd*4").mask(gp.RB).bank("RolandTR909"), // RB btn for SD
-).cpm(120)
+)
 `}
 />

@@ -74,14 +75,13 @@ Analog sticks can be used for continuous control, such as pitch shifting or pann
 <MiniRepl
  client:idle
  tune={`const gp = gamepad(0)
-  // Use analog stick for continuous control
+setcpm(120)
+// Use analog stick for continuous control
 $: note("c4 d3 a3 e3").sound("sawtooth") 
  .lpf(gp.x1.range(100,4000)) 
  .lpq(gp.y1.range(5,30))
  .decay(gp.y2.range(0.1,2))
-  .lpenv(gp.x2.range(-5,5))
-  .cpm(120)
-  `}
+  .lpenv(gp.x2.range(-5,5))`}
 />

 ### Button Sequences
@@ -89,6 +89,7 @@ $: note("c4 d3 a3 e3").sound("sawtooth")
 You can define button sequences to trigger specific actions, like playing a sound when a sequence is detected.

 <MiniRepl client:idle tune={`const gp = gamepad(0)
+setcpm(120)
 // Define button sequences
 const HADOUKEN = [
  'd',               // Down
@@ -99,7 +100,7 @@ const KONAMI = 'uuddlrlrba' //Konami Code ↑↑↓↓←→←→BA

 // Check butto-n sequence (returns 1 while detected, 0 when not within last 1 second)
 $: s("free_hadouken -").slow(2)
-.mask(gp.btnSequence(HADOUKEN)).room(1).cpm(120)
+.mask(gp.btnSequence(HADOUKEN)).room(1)

 // hadouken.wav by Syna-Max
 //https://freesound.org/people/Syna-Max/sounds/67674/
@@ -0,0 +1,39 @@
+# mondo
+
+a lisp-based language intended to be used as a custom dsl for patterns that can stand on its own feet. 
+see the `test` folder for usage examples
+
+more info:
+
+- [uzulang I](https://garten.salat.dev/uzu/uzulang1.html)
+- [uzulang II](https://garten.salat.dev/uzu/uzulang2.html)
+
+## Example Usage
+
+```js
+import { MondoRunner } from 'mondolang'
+// define our library of functions and variables
+let lib = {
+  add: (a, b) => a + b,
+  mul: (a, b) => a * b,
+  PI: Math.PI,
+};
+// this function will evaluate nodes in the syntax tree
+function evaluator(node) {
+  // check if node is a leaf node (!= list)
+  if (node.type !== 'list') {
+    // check lib if we find a match in the lib, otherwise return value
+    return lib[node.value] ?? node.value;
+  }
+  // now it can only be a list..
+  const [fn, ...args] = node.children;
+  // children in a list will already be evaluated
+  // the first child is expected to be a function
+  if (typeof fn !== 'function') {
+    throw new Error(`"${fn}" is not a function`);
+  }
+  return fn(...args);
+}
+const runner = new MondoRunner({ evaluator });
+const pat = runner.run('add 1 (mul 2 PI)') // 7.283185307179586
+```
@@ -0,0 +1,484 @@
+/*
+mondo.mjs - <short description TODO>
+Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/mini/test/mini.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/>.
+*/
+
+// evolved from https://garten.salat.dev/lisp/parser.html
+export class MondoParser {
+  // these are the tokens we expect
+  token_types = {
+    comment: /^\/\/(.*?)(?=\n|$)/,
+    quotes_double: /^"(.*?)"/,
+    quotes_single: /^'(.*?)'/,
+    open_list: /^\(/,
+    close_list: /^\)/,
+    open_angle: /^</,
+    close_angle: /^>/,
+    open_square: /^\[/,
+    close_square: /^\]/,
+    open_curly: /^\{/,
+    close_curly: /^\}/,
+    number: /^-?[0-9]*\.?[0-9]+/, // before pipe!
+    // TODO: better error handling when "-" is used as rest, e.g "s [- bd]"
+    op: /^[*/:!@%?+-]|^\.{2}/, // * / : ! @ % ? ..
+    // dollar: /^\$/,
+    pipe: /^#/,
+    stack: /^[,$]/,
+    or: /^[|]/,
+    plain: /^[a-zA-Z0-9-~_^#]+/,
+  };
+  // matches next token
+  next_token(code, offset = 0) {
+    for (let type in this.token_types) {
+      const match = code.match(this.token_types[type]);
+      if (match) {
+        let token = { type, value: match[0] };
+        if (offset !== -1) {
+          // add location
+          token.loc = [offset, offset + match[0].length];
+        }
+        return token;
+      }
+    }
+    throw new Error(`mondo: could not match '${code}'`);
+  }
+  // takes code string, returns list of matched tokens (if valid)
+  tokenize(code, offset = 0) {
+    let tokens = [];
+    let locEnabled = offset !== -1;
+    let trim = () => {
+      // trim whitespace at start, update offset
+      offset += code.length - code.trimStart().length;
+      // trim start and end to not confuse parser
+      return code.trim();
+    };
+    code = trim();
+    while (code.length > 0) {
+      code = trim();
+      const token = this.next_token(code, locEnabled ? offset : -1);
+      code = code.slice(token.value.length);
+      offset += token.value.length;
+      tokens.push(token);
+    }
+    return tokens;
+  }
+  // take code, return abstract syntax tree
+  parse(code, offset) {
+    this.code = code;
+    this.offset = offset;
+    this.tokens = this.tokenize(code, offset);
+    const expressions = [];
+    while (this.tokens.length) {
+      expressions.push(this.parse_expr());
+    }
+    if (expressions.length === 0) {
+      // empty case
+      return { type: 'list', children: [] };
+    }
+    // do we have multiple top level expressions or a single non list?
+    if (expressions.length > 1 || expressions[0].type !== 'list') {
+      return {
+        type: 'list',
+        children: this.desugar(expressions),
+      };
+    }
+    // we have a single list
+    return expressions[0];
+  }
+  // parses any valid expression
+  parse_expr() {
+    if (!this.tokens[0]) {
+      throw new Error(`unexpected end of file`);
+      // TODO: could we allow that? like (((((((( s bd
+      // return { type: 'list', children: [] };
+    }
+    let next = this.tokens[0]?.type;
+    if (next === 'open_list') {
+      return this.parse_list();
+    }
+    if (next === 'open_angle') {
+      return this.parse_angle();
+    }
+    if (next === 'open_square') {
+      return this.parse_square();
+    }
+    if (next === 'open_curly') {
+      return this.parse_curly();
+    }
+    return this.consume(next);
+  }
+  // Token[] => Token[][], e.g. (x , y z) => [['x'],['y','z']]
+  split_children(children, split_type) {
+    const chunks = [];
+    while (true) {
+      let splitIndex = children.findIndex((child) => child.type === split_type);
+      if (splitIndex === -1) break;
+      const chunk = children.slice(0, splitIndex);
+      chunks.push(chunk);
+      children = children.slice(splitIndex + 1);
+    }
+    chunks.push(children);
+    return chunks;
+  }
+  desugar_split(children, split_type, next) {
+    const chunks = this.split_children(children, split_type);
+    if (chunks.length === 1) {
+      return next(children);
+    }
+    // collect args of stack function
+    const args = chunks
+      .map((chunk) => {
+        if (!chunk.length) {
+          return; // useful for things like "$ s bd $ s hh*8" (first chunk is empty)
+        }
+        if (chunk.length === 1) {
+          // chunks of one element can be added to the stack as is
+          return chunk[0];
+        }
+        // chunks of multiple args
+        chunk = next(chunk);
+        return { type: 'list', children: chunk };
+      })
+      .filter(Boolean); // ignore empty chunks
+    return [{ type: 'plain', value: split_type }, ...args];
+  }
+  // prevents to get a list, e.g. ((x y)) => (x y)
+  unwrap_children(children) {
+    if (children.length === 1) {
+      return children[0].children;
+    }
+    return children;
+  }
+  desugar_ops(children) {
+    while (true) {
+      let opIndex = children.findIndex((child) => child.type === 'op');
+      if (opIndex === -1) break;
+      const op = { type: 'plain', value: children[opIndex].value };
+      if (opIndex === children.length - 1) {
+        //throw new Error(`cannot use operator as last child.`);
+        children[opIndex] = op; // ignore operator if last child.. e.g. "note [c -]"
+        continue;
+      }
+      if (opIndex === 0) {
+        // regular function call (assuming each operator exists as function)
+        children[opIndex] = op;
+        continue;
+      }
+      // convert infix to prefix notation
+      const left = children[opIndex - 1];
+      const right = children[opIndex + 1];
+      if (left.type === 'pipe') {
+        // "x !* 2" => (* 2 x)
+        children[opIndex] = op;
+        continue;
+      }
+      // some careful error handling
+      if (left.type === 'op') {
+        throw new Error(`got 2 ops in a row: "${left.value}${op.value}"`);
+      }
+      if (right.type === 'op') {
+        let err = `got 2 ops in a row: "${op.value}${right.value}"`;
+        if (op.value === '-') {
+          // yes i know this file is not supposed to know about rests x.X
+          err += '. you probably want a rest, which is "_" in mondo!';
+        }
+        throw new Error(err);
+      }
+      const call = { type: 'list', children: [op, right, left] };
+      // insert call while keeping other siblings
+      children = [...children.slice(0, opIndex - 1), call, ...children.slice(opIndex + 2)];
+      children = this.unwrap_children(children);
+    }
+    return children;
+  }
+  get_lambda(args, children) {
+    // (.fast 2) = (fn (_) (fast _ 2))
+    children = this.desugar(children);
+    const body = children.length === 1 ? children[0] : { type: 'list', children };
+    return [{ type: 'plain', value: 'fn' }, { type: 'list', children: args }, body];
+  }
+  // returns location range of given ast (even if desugared)
+  get_range(ast, range = [Infinity, 0]) {
+    let union = (a, b) => [Math.min(a[0], b[0]), Math.max(a[1], b[1])];
+    if (ast.loc) {
+      return union(range, ast.loc);
+    }
+    if (ast.type !== 'list') {
+      return range;
+    }
+    return ast.children.reduce((range, child) => {
+      const childrange = this.get_range(child, range);
+      return union(range, childrange);
+    }, range);
+  }
+  errorhead(ast) {
+    return `[mondo ${this.get_range(ast)?.join(':') || '?'}]`;
+  }
+  // returns original user code where the given ast originates (even if desugared)
+  get_code_snippet(ast) {
+    const [min, max] = this.get_range(ast);
+    return this.code.slice(min - this.offset, max - this.offset);
+  }
+  desugar_pipes(children) {
+    let chunks = this.split_children(children, 'pipe');
+    while (chunks.length > 1) {
+      let [left, right, ...rest] = chunks;
+
+      if (!left.length) {
+        const arg = { type: 'plain', value: '_' };
+        return this.get_lambda([arg], [arg, ...children]);
+      }
+      // s jazz hh.fast 2 => (fast 2 (s jazz hh))
+      const call = left.length > 1 ? { type: 'list', children: left } : left[0];
+      chunks = [[...right, call], ...rest];
+    }
+    // return next(chunks[0]);
+    return chunks[0];
+  }
+  parse_pair(open_type, close_type) {
+    const begin = this.tokens[0].loc?.[0];
+    this.consume(open_type);
+    const children = [];
+    while (this.tokens[0]?.type !== close_type) {
+      children.push(this.parse_expr());
+    }
+    const end = this.tokens[0].loc?.[1];
+    this.consume(close_type);
+    const node = { type: 'list', children };
+    if (begin !== undefined) {
+      node.loc = [begin, end];
+      node.raw = this.code.slice(begin, end);
+    }
+    return node;
+  }
+  desugar(children, type) {
+    // if type is given, the first element is expected to contain it as plain value
+    // e.g. with (square a b, c), we want to split (a b, c) and ignore "square"
+    children = type ? children.slice(1) : children;
+    children = this.desugar_split(children, 'stack', (children) =>
+      this.desugar_split(children, 'or', (children) => {
+        // chunks of multiple args
+        if (type) {
+          // the type we've removed before splitting needs to be added back
+          children = [{ type: 'plain', value: type }, ...children];
+        }
+        children = this.desugar_ops(children);
+        // children = this.desugar_pipes(children, (children) => this.desugar_dollars(children));
+        children = this.desugar_pipes(children);
+        return children;
+      }),
+    );
+    return children;
+  }
+  parse_list() {
+    let node = this.parse_pair('open_list', 'close_list');
+    node.children = this.desugar(node.children);
+    return node;
+  }
+  parse_angle() {
+    let node = this.parse_pair('open_angle', 'close_angle');
+    node.children.unshift({ type: 'plain', value: 'angle' });
+    node.children = this.desugar(node.children, 'angle');
+    return node;
+  }
+  parse_square() {
+    let node = this.parse_pair('open_square', 'close_square');
+    node.children.unshift({ type: 'plain', value: 'square' });
+    node.children = this.desugar(node.children, 'square');
+    return node;
+  }
+  parse_curly() {
+    let node = this.parse_pair('open_curly', 'close_curly');
+    node.children.unshift({ type: 'plain', value: 'curly' });
+    node.children = this.desugar(node.children, 'curly');
+    return node;
+  }
+  consume(type) {
+    // shift removes first element and returns it
+    const token = this.tokens.shift();
+    if (token.type !== type) {
+      throw new Error(`expected token type ${type}, got ${token.type}`);
+    }
+    return token;
+  }
+  get_locations(code, offset = 0) {
+    let walk = (ast, locations = []) => {
+      if (ast.type === 'list') {
+        return ast.children.forEach((child) => walk(child, locations));
+      }
+      if (ast.loc) {
+        locations.push(ast.loc);
+      }
+    };
+    const ast = this.parse(code, offset);
+    let locations = [];
+    walk(ast, locations);
+    return locations;
+  }
+}
+
+export function printAst(ast, compact = false, lvl = 0) {
+  const br = compact ? '' : '\n';
+  const spaces = compact ? '' : Array(lvl).fill(' ').join('');
+  if (ast.type === 'list') {
+    return `${lvl ? br : ''}${spaces}(${ast.children.map((child) => printAst(child, compact, lvl + 1)).join(' ')}${
+      ast.children.find((child) => child.type === 'list') ? `${br}${spaces})` : ')'
+    }`;
+  }
+  return `${ast.value}`;
+}
+
+// lisp runner
+export class MondoRunner {
+  constructor({ evaluator } = {}) {
+    this.parser = new MondoParser();
+    this.evaluator = evaluator;
+    this.assert(typeof evaluator === 'function', `expected an evaluator function to be passed to new MondoRunner`);
+  }
+  // a helper to check conditions and throw if they are not met
+  assert(condition, error) {
+    if (!condition) {
+      throw new Error(error);
+    }
+  }
+  run(code, scope, offset = 0) {
+    const ast = this.parser.parse(code, offset);
+    //console.log(printAst(ast));
+    return this.evaluate(ast, scope);
+  }
+  evaluate_let(ast, scope) {
+    // (let ((x 3) (y 4)) ...body)
+    // = ((fn (x y) ...body) 3 4)
+    const defs = ast.children[1].children;
+    const args = defs.map((pair) => pair.children[0]);
+    const vals = defs.map((pair) => pair.children[1]);
+    const body = ast.children.slice(2);
+    const lambda = {
+      type: 'list',
+      children: [{ type: 'plain', value: 'fn' }, { type: 'list', children: args }, ...body],
+    };
+    return this.evaluate({ type: 'list', children: [lambda, ...vals] }, scope);
+  }
+  evaluate_def(ast, scope) {
+    // function definition special form?
+    if (ast.children[1].type === 'list') {
+      // (def (add a b) (+ a b))
+      // => (def add (fn (a b) (+ a b)) )
+      const args = ast.children[1].children.slice(1);
+      const lambda = {
+        // lambda
+        type: 'list',
+        children: [
+          { type: 'plain', value: 'fn' },
+          { type: 'list', children: args },
+          ...ast.children.slice(2), // body
+        ],
+      };
+      // we mutate to make sure the old ast wont make a mess later
+      ast.children[1] = ast.children[1].children[0];
+      ast.children[2] = lambda;
+      ast.children = ast.children.slice(0, 3); // throw away rest
+    }
+    // (def name body)
+    if (ast.children.length !== 3) {
+      throw new Error(`expected "def" to have 3 children, but got ${ast.children.length}`);
+    }
+    const name = ast.children[1].value;
+    const body = this.evaluate(ast.children[2], scope);
+    scope[name] = body;
+    // def with fall through
+  }
+  evaluate_match(ast, scope) {
+    // (match (p1 e1) (p2 e2) ... (pn en))
+    // = cond in lisp
+    if (ast.children.length < 2) {
+      return;
+    }
+    const [_, ...body] = ast.children;
+    for (let i = 0; i < body.length; ++i) {
+      const [predicate, exp] = body[i].children;
+      if (predicate.value === 'else') {
+        return this.evaluate(exp, scope);
+      }
+      const outcome = this.evaluate(predicate, scope);
+      if (outcome) {
+        return this.evaluate(exp, scope);
+      }
+    }
+    return undefined; // nothing was matched
+  }
+  evaluate_if(ast, scope) {
+    // if is a special case of match
+    if (ast.children.length !== 4) {
+      return;
+    }
+    // (if predicate consequent alternative)
+    const [_, predicate, consequent, alternative] = ast.children;
+    // (match (predicate consequent) (else alternative))
+    const matcher = {
+      type: 'list',
+      children: [
+        { type: 'plain', value: 'match' },
+        { type: 'list', children: [predicate, consequent] },
+        { type: 'list', children: [{ type: 'plain', value: 'else' }, alternative] },
+      ],
+    };
+    return this.evaluate_match(matcher, scope);
+  }
+  evaluate_lambda(ast, scope) {
+    // (fn (_)   (ply 2 _)
+    //     ^args ^ body
+    const [_, formalArgs, ...body] = ast.children;
+    return (...args) => {
+      const params = Object.fromEntries(formalArgs.children.map((arg, i) => [arg.value, args[i]]));
+      const closure = {
+        ...scope,
+        ...params,
+      };
+      // body can have multiple expressions
+      const res = body.map((exp) => this.evaluate(exp, closure));
+      // last expression is the return value
+      return res[res.length - 1];
+    };
+  }
+  evaluate_list(ast, scope) {
+    // evaluate all children before evaluating list (dont mutate!!!)
+    const args = ast.children
+      .filter((child) => child.type !== 'comment') // ignore comments
+      .map((arg) => this.evaluate(arg, scope));
+    const node = { type: 'list', children: args };
+    return this.evaluator(node, scope);
+  }
+  evaluate_leaf(ast, scope) {
+    if (ast.type === 'number') {
+      ast.value = Number(ast.value);
+    } else if (['quotes_double', 'quotes_single'].includes(ast.type)) {
+      ast.value = ast.value.slice(1, -1);
+      ast.type = 'string';
+    }
+    return this.evaluator(ast, scope);
+  }
+  evaluate(ast, scope = {}) {
+    if (ast.type !== 'list') {
+      return this.evaluate_leaf(ast, scope);
+    }
+    const name = ast.children[0]?.value;
+    if (name === 'fn') {
+      return this.evaluate_lambda(ast, scope);
+    }
+    if (name === 'match') {
+      return this.evaluate_match(ast, scope);
+    }
+    if (name === 'if') {
+      return this.evaluate_if(ast, scope);
+    }
+    if (name === 'let') {
+      return this.evaluate_let(ast, scope);
+    }
+    if (name === 'def') {
+      this.evaluate_def(ast, scope);
+    }
+    return this.evaluate_list(ast, scope);
+  }
+}
@@ -0,0 +1,37 @@
+{
+  "name": "mondolang",
+  "version": "1.1.0",
+  "description": "a language for functional composition that translates to js",
+  "main": "mondo.mjs",
+  "type": "module",
+  "publishConfig": {
+    "main": "dist/mondo.mjs"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "bench": "vitest bench",
+    "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/blob/main/packages/mondo/README.md",
+  "devDependencies": {
+    "vite": "^6.0.11",
+    "vitest": "^3.0.4"
+  }
+}
@@ -0,0 +1,978 @@
+/*
+mondo.test.mjs - <short description TODO>
+Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/mini/test/mini.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, expect, it } from 'vitest';
+import { MondoParser, printAst, MondoRunner } from '../mondo.mjs';
+
+const parser = new MondoParser();
+const p = (code) => parser.parse(code, -1);
+
+describe('mondo tokenizer', () => {
+  const parser = new MondoParser();
+  it('should tokenize with locations', () =>
+    expect(
+      parser
+        .tokenize('(one two three)')
+        .map((t) => t.value + '=' + t.loc.join('-'))
+        .join(' '),
+    ).toEqual('(=0-1 one=1-4 two=5-8 three=9-14 )=14-15'));
+  // it('should parse with loangleions', () => expect(parser.parse('(one two three)')).toEqual());
+  it('should get loangleions', () =>
+    expect(parser.get_locations('s bd rim')).toEqual([
+      [0, 1],
+      [2, 4],
+      [5, 8],
+    ]));
+});
+describe('mondo s-expressions parser', () => {
+  it('should parse an empty string', () => expect(p('')).toEqual({ type: 'list', children: [] }));
+  it('should parse a single item', () =>
+    expect(p('a')).toEqual({ type: 'list', children: [{ type: 'plain', value: 'a' }] }));
+  it('should parse an empty list', () => expect(p('()')).toEqual({ type: 'list', children: [] }));
+  it('should parse a list with 1 item', () =>
+    expect(p('(a)')).toEqual({ type: 'list', children: [{ type: 'plain', value: 'a' }] }));
+  it('should parse a list with 2 items', () =>
+    expect(p('(a b)')).toEqual({
+      type: 'list',
+      children: [
+        { type: 'plain', value: 'a' },
+        { type: 'plain', value: 'b' },
+      ],
+    }));
+  it('should parse a list with 2 items', () =>
+    expect(p('(a (b c))')).toEqual({
+      type: 'list',
+      children: [
+        { type: 'plain', value: 'a' },
+        {
+          type: 'list',
+          children: [
+            { type: 'plain', value: 'b' },
+            { type: 'plain', value: 'c' },
+          ],
+        },
+      ],
+    }));
+  it('should parse numbers', () =>
+    expect(p('(1 .2 1.2 10 22.3)')).toEqual({
+      type: 'list',
+      children: [
+        { type: 'number', value: '1' },
+        { type: 'number', value: '.2' },
+        { type: 'number', value: '1.2' },
+        { type: 'number', value: '10' },
+        { type: 'number', value: '22.3' },
+      ],
+    }));
+  it('should parse comments', () =>
+    expect(p('a // hello')).toEqual({
+      type: 'list',
+      children: [
+        { type: 'plain', value: 'a' },
+        { type: 'comment', value: '// hello' },
+      ],
+    }));
+});
+
+let desguar = (a) => {
+  return printAst(parser.parse(a), true);
+};
+
+describe('mondo sugar', () => {
+  it('should desugar []', () => expect(desguar('[a b c]')).toEqual('(square a b c)'));
+  it('should desugar [] nested', () => expect(desguar('[a [b c] d]')).toEqual('(square a (square b c) d)'));
+  it('should desugar <>', () => expect(desguar('<a b c>')).toEqual('(angle a b c)'));
+  it('should desugar <> nested', () => expect(desguar('<a <b c> d>')).toEqual('(angle a (angle b c) d)'));
+  it('should desugar mixed [] <>', () => expect(desguar('[a <b c>]')).toEqual('(square a (angle b c))'));
+  it('should desugar mixed <> []', () => expect(desguar('<a [b c]>')).toEqual('(angle a (square b c))'));
+
+  it('should desugar #', () => expect(desguar('s jazz # fast 2')).toEqual('(fast 2 (s jazz))'));
+  it('should desugar # square', () => expect(desguar('[bd cp # fast 2]')).toEqual('(fast 2 (square bd cp))'));
+  it('should desugar # twice', () => expect(desguar('s jazz # fast 2 # slow 2')).toEqual('(slow 2 (fast 2 (s jazz)))'));
+  it('should desugar # nested', () => expect(desguar('(s cp # fast 2)')).toEqual('(fast 2 (s cp))'));
+  it('should desugar # within []', () => expect(desguar('[bd cp # fast 2]')).toEqual('(fast 2 (square bd cp))'));
+  it('should desugar # within , within []', () =>
+    expect(desguar('[bd cp # fast 2, x]')).toEqual('(stack (fast 2 (square bd cp)) x)'));
+
+  // it('should desugar .(.', () => expect(desguar('[jazz hh.(.fast 2)]')).toEqual('(square jazz (fast 2 hh))'));
+
+  it('should desugar , |', () => expect(desguar('[bd, hh | oh]')).toEqual('(stack bd (or hh oh))'));
+  it('should desugar , | of []', () =>
+    expect(desguar('[bd, hh | [oh rim]]')).toEqual('(stack bd (or hh (square oh rim)))'));
+  it('should desugar , square', () => expect(desguar('[bd, hh]')).toEqual('(stack bd hh)'));
+  it('should desugar , square 2', () => expect(desguar('[bd, hh oh]')).toEqual('(stack bd (square hh oh))'));
+  it('should desugar , square 3', () =>
+    expect(desguar('[bd cp, hh oh]')).toEqual('(stack (square bd cp) (square hh oh))'));
+  it('should desugar , angle', () => expect(desguar('<bd, hh>')).toEqual('(stack bd hh)'));
+  it('should desugar , angle 2', () => expect(desguar('<bd, hh oh>')).toEqual('(stack bd (angle hh oh))'));
+  it('should desugar , angle 3', () =>
+    expect(desguar('<bd cp, hh oh>')).toEqual('(stack (angle bd cp) (angle hh oh))'));
+  it('should desugar , ()', () => expect(desguar('(s bd, s cp)')).toEqual('(stack (s bd) (s cp))'));
+  it('should desugar * /', () => expect(desguar('[a b*2 c d/3 e]')).toEqual('(square a (* 2 b) c (/ 3 d) e)'));
+  it('should desugar []*x', () => expect(desguar('[a [b c]*3]')).toEqual('(square a (* 3 (square b c)))'));
+  it('should desugar []*<x y>', () => expect(desguar('[a b*<2 3> c]')).toEqual('(square a (* (angle 2 3) b) c)'));
+  it('should desugar x:y', () => expect(desguar('x:y')).toEqual('(: y x)'));
+  it('should desugar x:y:z', () => expect(desguar('x:y:z')).toEqual('(: z (: y x))'));
+  it('should desugar x:y*x', () => expect(desguar('bd:0*2')).toEqual('(* 2 (: 0 bd))'));
+  it('should desugar a..b', () => expect(desguar('0..2')).toEqual('(.. 2 0)'));
+  /* it('should desugar x $ y', () => expect(desguar('x $ y')).toEqual('(x y)'));
+  it('should desugar x $ y z', () => expect(desguar('x $ y z')).toEqual('(x (y z))'));
+  it('should desugar x $ y . z', () => expect(desguar('x $ y . z')).toEqual('(z (x y))')); */
+
+  it('should desugar README example', () =>
+    expect(desguar('s [bd hh*2 (cp # crush 4) <mt ht lt>] # speed .8')).toEqual(
+      '(speed .8 (s (square bd (* 2 hh) (crush 4 cp) (angle mt ht lt))))',
+    ));
+
+  it('should desugar (#)', () => expect(desguar('(#)')).toEqual('(fn (_) _)'));
+  it('should desugar lambda', () => expect(desguar('(# fast 2)')).toEqual('(fn (_) (fast 2 _))'));
+  it('should desugar lambda call', () => expect(desguar('((# mul 2) 2)')).toEqual('((fn (_) (mul 2 _)) 2)'));
+  it('should desugar lambda with pipe', () =>
+    expect(desguar('(# fast 2 # room 1)')).toEqual('(fn (_) (room 1 (fast 2 _)))'));
+  /* const lambda = parser.parse('(lambda (_) (fast 2 _))');
+  const target = { type: 'plain', value: 'xyz' };
+  it('should desugar_lambda', () =>
+    expect(printAst(parser.desugar_lambda(lambda.children, target))).toEqual('(fast 2 xyz)')); */
+});
+
+describe('mondo arithmetic', () => {
+  let multi =
+    (op) =>
+    (init, ...rest) =>
+      rest.reduce((acc, arg) => op(acc, arg), init);
+
+  let lib = {
+    '+': multi((a, b) => a + b),
+    add: multi((a, b) => a + b),
+    '-': multi((a, b) => a - b),
+    sub: multi((a, b) => a - b),
+    '*': multi((a, b) => a * b),
+    '/': multi((a, b) => a / b),
+    mod: multi((a, b) => a % b),
+    eq: (a, b) => a === b,
+    lt: (a, b) => a < b,
+    gt: (a, b) => a > b,
+    and: (a, b) => a && b,
+    or: (a, b) => a || b,
+    not: (a) => !a,
+    run: (...args) => args[args.length - 1],
+    def: () => 0,
+    sin: Math.sin,
+    cos: Math.cos,
+    PI: Math.PI,
+    cons: (a, b) => [a, ...(Array.isArray(b) ? b : [b])],
+    car: (pair) => pair[0],
+    cdr: (pair) => pair.slice(1),
+    list: (...items) => items,
+    nil: [],
+    isnull: (items) => items.length === 0,
+    concat: (...msgs) => msgs.join(''),
+    error: (...msgs) => {
+      throw new Error(msgs.join(' '));
+    },
+  };
+  function evaluator(node, scope) {
+    if (node.type !== 'list') {
+      // is leaf
+      return scope[node.value] ?? lib[node.value] ?? node.value;
+    }
+    // is list
+    const [fn, ...args] = node.children;
+    if (typeof fn !== 'function') {
+      throw new Error(`"${fn}": expected function, got ${typeof fn} "${fn}"`);
+    }
+    return fn(...args);
+  }
+  const runner = new MondoRunner({ evaluator });
+  let evaluate = (exp, scope) => runner.run(`run ${exp}`, scope);
+  let pretty = (exp) => printAst(runner.parser.parse(exp), false);
+  //it('should eval nested expression', () => expect(runner.run('add 1 (mul 2 PI)').toFixed(2)).toEqual('7.28'));
+
+  it('eval number', () => expect(evaluate('2')).toEqual(2));
+  it('eval string', () => expect(evaluate('abc')).toEqual('abc'));
+  it('eval list', () => expect(evaluate('(+ 1 2)')).toEqual(3));
+  it('eval nested list', () => expect(evaluate('(+ 1 (+ 2 3))')).toEqual(6));
+  it('def number', () => expect(evaluate('(def a 2) a')).toEqual(2));
+  it('def + ref number', () => expect(evaluate('(def a 2) (* a a)')).toEqual(4));
+  it('def + call lambda', () => expect(evaluate('(def sqr (fn (x) (* x x))) (sqr 3)')).toEqual(9));
+
+  // sicp
+  it('sicp 8.1', () => expect(evaluate('(+ 137 349)')).toEqual(486));
+  it('sicp 8.2', () => expect(evaluate('(- 1000 334)')).toEqual(666));
+  it('sicp 8.3', () => expect(evaluate('(* 5 99)')).toEqual(495));
+  it('sicp 8.4', () => expect(evaluate('(/ 10 5)')).toEqual(2));
+  it('sicp 8.5', () => expect(evaluate('(+ 2.7 10)')).toEqual(12.7));
+  it('sicp 9.1', () => expect(evaluate('(+ 21 35 12 7)')).toEqual(75));
+  it('sicp 9.2', () => expect(evaluate('(* 25 4 12)')).toEqual(1200));
+  it('sicp 9.3', () => expect(evaluate('(+ (* 3 5) (- 10 6))')).toEqual(19));
+  it('sicp 9.4', () =>
+    expect(pretty('(+ (* 3 (+ (* 2 4) (+ 3 5))) (+ (- 10 7) 6))')).toEqual(`(+ 
+ (* 3 
+  (+ 
+   (* 2 4) 
+   (+ 3 5)
+  )
+ ) 
+ (+ 
+  (- 10 7) 6
+ )
+)`)); // this is not exactly pretty printing by convention..
+
+  let scope = {};
+  it('sicp 11.1', () => expect(evaluate('(def size 2) (* 5 size)', scope)).toEqual(10));
+  it('sicp 11.2', () =>
+    expect(evaluate('(def pi 3.14159) (def radius 10) (* pi (* radius radius))', scope)).toEqual(314.159));
+  it('sicp 11.3', () => expect(evaluate('(def circumference (* 2 pi radius))', scope)).toEqual(0));
+  it('sicp 11.4', () => expect(evaluate('circumference', scope)).toEqual(62.8318));
+  it('sicp 13.1', () => expect(evaluate('(* (+ 2 (* 4 6)) (+ 3 5 7))')).toEqual(390));
+  it('sicp 16.1', () => expect(evaluate('(def (square x) (* x x))', scope)).toEqual(0));
+  // it('sicp 16.1', () => expect(evaluate('(def (square x) (* x x))', scope)).toEqual(0));
+  it('sicp 17.1', () => expect(evaluate('(square 21)', scope)).toEqual(441));
+  it('sicp 17.2', () => expect(evaluate('(square (+ 2 5))', scope)).toEqual(49));
+  it('sicp 17.3', () => expect(evaluate('(square (square 3))', scope)).toEqual(81));
+  it('sicp 17.4', () => expect(evaluate(`(def (sumofsquares x y) (+ (square x) (square y)))`, scope)).toEqual(0));
+  it('sicp 17.5', () => expect(evaluate(`(sumofsquares 3 4)`, scope)).toEqual(25));
+  it('sicp 17.6', () => expect(evaluate(`(def (f a) (sumofsquares (+ a 1) (* a 2))) (f 5)`, scope)).toEqual(136));
+  it('sicp 21.1', () => expect(evaluate(`(sumofsquares (+ 5 1) (* 5 2))`, scope)).toEqual(136));
+
+  it('sicp 22.1', () =>
+    expect(
+      evaluate(
+        `(def (abs x) 
+        (match 
+         ((gt x 0) x) 
+         ((eq x 0) 0)
+         ((lt x 0) (- 0 x))
+      ))`, // sicp was doing (- x), which doesnt work with our -
+        scope,
+      ),
+    ).toEqual(0));
+
+  it('sicp gt1', () => expect(evaluate(`(gt -12 0)`, scope)).toEqual(false));
+  it('sicp gt2', () => expect(evaluate(`(gt 0 -12)`, scope)).toEqual(true));
+  it('sicp lt1', () => expect(evaluate(`(lt -12 0)`, scope)).toEqual(true));
+  it('sicp lt2', () => expect(evaluate(`(lt 0 -12)`, scope)).toEqual(false));
+
+  it('sicp 24.1', () => expect(evaluate(`(abs (- 3))`, scope)).toEqual(3));
+  it('sicp 24.2', () => expect(evaluate(`(abs (+ 3))`, scope)).toEqual(3));
+  it('sicp 24.3', () => expect(evaluate(`(abs -12)`, scope)).toEqual(12));
+
+  it('sicp 24.4', () => expect(evaluate(`(def (abs x) (if (lt x 0) (- 0 x) x))`, scope)).toEqual(0));
+  it('sicp 24.5', () => expect(evaluate(`(abs -13)`, scope)).toEqual(13));
+  it('sicp 25.1', () => expect(evaluate(`(and (gt 6 5) (lt 6 10))`, scope)).toEqual(true));
+  it('sicp 25.2', () => expect(evaluate(`(and (gt 4 5) (lt 6 10))`, scope)).toEqual(false));
+
+  it('sicp ex1.1.1', () => expect(evaluate(`(def a 3)`, scope)).toEqual(0));
+  it('sicp ex1.1.2', () => expect(evaluate(`(def b (+ a 1))`, scope)).toEqual(0));
+  it('sicp ex1.1.3', () => expect(evaluate(`(+ a b (* a b))`, scope)).toEqual(19));
+  it('sicp ex1.1.4', () => expect(evaluate(`(if (and (gt b a) (lt b (* a b))) b a)`, scope)).toEqual(4));
+  it('sicp ex1.1.5', () => expect(evaluate(`(match ((eq a 4) 6) ((eq b 4) (+ 6 7 a)) (else 25))`, scope)).toEqual(16));
+  it('sicp ex1.1.6', () => expect(evaluate(`(+ 2 (if (gt b a) b a))`, scope)).toEqual(6));
+  it('sicp ex1.1.7', () =>
+    expect(evaluate(`(* (match ((gt a b) a) ((lt a b) b) (else -1)) (+ a 1))`, scope)).toEqual(16));
+
+  // .. cant use "+" and "-" as standalone expressions, because they are parsed as operators...
+  it('sicp ex1.4.1', () => expect(evaluate(`(def (foo a b) ((if (gt b 0) add sub) a b))`, scope)).toEqual(0));
+  it('sicp ex1.4.1', () => expect(evaluate(`(foo 3 1)`, scope)).toEqual(4));
+  it('sicp ex1.4.2', () => expect(evaluate(`(foo 3 -1)`, scope)).toEqual(4));
+
+  // 1.1.7 Example: Square Roots by Newton’s Method
+  it('sicp 30.1', () =>
+    expect(evaluate(`(def (goodenuf guess x) (lt (abs (- (square guess) x)) 0.001))`, scope)).toEqual(0));
+  it('sicp 30.2', () => expect(evaluate(`(goodenuf 1 1.001)`, scope)).toEqual(true));
+  it('sicp 30.3', () => expect(evaluate(`(goodenuf 1 1.002)`, scope)).toEqual(false));
+  it('sicp 30.4', () => expect(evaluate(`(def (average x y) (/ (+ x y) 2))`, scope)).toEqual(0));
+  it('sicp 30.5', () => expect(evaluate(`(average 18 20)`, scope)).toEqual(19));
+  it('sicp 30.6', () => expect(evaluate(`(def (improve guess x) (average guess (/ x guess)))`, scope)).toEqual(0));
+  it('sicp 31.1', () =>
+    expect(
+      evaluate(
+        `(def (sqrtiter guess x) (if (goodenuf guess x)
+      guess
+      (sqrtiter (improve guess x) x)))`,
+        scope,
+      ),
+    ).toEqual(0));
+  it('sicp 31.2', () => expect(evaluate(`(def (sqrt x) (sqrtiter 1.0 x))`, scope)).toEqual(0));
+  it('sicp 31.3', () => expect(evaluate(`(sqrt 9)`, scope)).toEqual(3.00009155413138));
+  it('sicp 31.4', () => expect(evaluate(`(sqrt (+ 100 37))`, scope)).toEqual(11.704699917758145));
+  // eslint-disable-next-line no-loss-of-precision
+  it('sicp 31.5', () => expect(evaluate(`(sqrt (+ (sqrt 2) (sqrt 3)))`, scope)).toEqual(1.77392790232078925));
+  it('sicp 31.6', () => expect(evaluate(`(square (sqrt 1000))`, scope)).toEqual(1000.000369924366));
+
+  // lexical scoping
+  it('sicp 39.1', () =>
+    expect(
+      evaluate(
+        `
+(def (sqrt x)
+ (def (goodenough guess)
+  (lt (abs (- (square guess) x)) 0.001)) 
+(def (improve guess)
+ (average guess (/ x guess))) 
+(def (sqrt-iter guess)
+ (if (goodenough guess) guess (sqrt-iter (improve guess))))
+(sqrtiter 1.0))
+  
+  `,
+        scope,
+      ),
+    ).toEqual(0));
+
+  // recursive fac
+  it('sicp 41.1', () => expect(evaluate(`(def (fac n) (if (eq n 1) 1 (* n (fac (- n 1)))))`, scope)).toEqual(0));
+  it('sicp 41.2', () => expect(evaluate(`(fac 4)`, scope)).toEqual(24));
+
+  // iterative fac
+  it('sicp 41.3', () =>
+    expect(
+      evaluate(
+        `
+(def (factorial n) (factiter 1 1 n))
+(def (factiter product counter maxcount) 
+ (if (gt counter maxcount)
+  product
+  (factiter (* counter product)
+             (+ counter 1)
+             maxcount)))
+`,
+        scope,
+      ),
+    ).toEqual(0));
+  it('sicp 41.4', () => expect(evaluate(`(fac 4)`, scope)).toEqual(24));
+
+  // 46.1
+  /* (def (+ a b)
+(if (= a 0) b (inc (+ (dec a) b))))
+(def (+ a b)
+(if (= a 0) b (+ (dec a) (inc b)))) */
+
+  // Exercise 1.10
+  //  Ackermann’s function
+  it('sicp 47.1', () =>
+    expect(
+      evaluate(
+        `
+(def (A x y) (match ((eq y 0) 0) 
+((eq x 0) (* 2 y))
+((eq y 1) 2)
+(else (A (- x 1) (A x (- y 1))))))
+`,
+        scope,
+      ),
+    ).toEqual(0));
+  it('sicp 47.2', () => expect(evaluate(`(A 1 10)`, scope)).toEqual(1024));
+  it('sicp 47.3', () => expect(evaluate(`(A 2 4)`, scope)).toEqual(65536));
+  it('sicp 47.4', () => expect(evaluate(`(A 3 3)`, scope)).toEqual(65536));
+  it('sicp 47.5', () =>
+    expect(
+      evaluate(
+        `
+(def (f n) (A 0 n))
+(def (g n) (A 1 n)))
+(def (h n) (A 2 n))
+(def (k n) (* 5 n n))
+    `,
+        scope,
+      ),
+    ).toEqual(0));
+
+  // Tree Recursion
+  // recursive process
+  it('sicp 48.1', () =>
+    expect(
+      evaluate(
+        `
+(def (fib n) (match ((eq n 0) 0) ((eq n 1) 1)
+(else (+ (fib (- n 1)) (fib (- n 2))))))
+(fib 7)
+    `,
+        scope,
+      ),
+    ).toEqual(13));
+
+  // iterative process
+  it('sicp 48.2', () =>
+    expect(
+      evaluate(
+        `
+(def (fib n) (fibiter 1 0 n))
+(def (fibiter a b count) (if (eq count 0)
+      b
+      (fibiter (+ a b) a (- count 1))))
+(fib 7)
+    `,
+        scope,
+      ),
+    ).toEqual(13));
+
+  // example: counting change
+  it('sicp 52.2', () =>
+    expect(
+      evaluate(
+        `
+(def (countchange amount) (cc amount 5))
+(def (cc amount kindsofcoins)
+ (match 
+  ((eq amount 0) 1)
+  ((or (lt amount 0) (eq kindsofcoins 0)) 0)
+  (else (+ 
+   (cc amount (- kindsofcoins 1))
+   (cc (- amount (firstdenomination kindsofcoins)) kindsofcoins)))))
+
+(def (firstdenomination kindsofcoins)
+(match 
+ ((eq kindsofcoins 1) 1) 
+ ((eq kindsofcoins 2) 5)
+ ((eq kindsofcoins 3) 10)
+ ((eq kindsofcoins 4) 25)
+ ((eq kindsofcoins 5) 50)))
+
+(countchange 100)
+    `,
+        scope,
+      ),
+    ).toEqual(292));
+
+  // todo: pascals triangle
+  it('sicp 57.1', () =>
+    expect(
+      evaluate(
+        `
+(def (cube x) (* x x x))
+(def (p x) (sub (* 3 x) (* 4 (cube x))))
+(def (sine angle)
+(if (not (gt (abs angle) 0.1)) angle
+(p (sine (/ angle 3.0)))))
+
+(sine 12.15)
+    `,
+        scope,
+      ),
+    ).toEqual(-0.39980345741334));
+
+  // exponentiation recursive
+  it('sicp 57.2', () =>
+    expect(
+      evaluate(
+        `
+(def (expt b n) (if (eq n 0) 1 (* b (expt b (- n 1)))))
+(expt 2 4)
+`,
+        scope,
+      ),
+    ).toEqual(16));
+
+  // exponentiation iterative
+  it('sicp 58.1b', () =>
+    expect(
+      evaluate(
+        `
+(def (expt b n) (exptiter b n 1))
+(def (exptiter b counter product) (if (eq counter 0)
+      product
+      (exptiter b (- counter 1) (* b product))))
+(expt 2 5)
+  `,
+        scope,
+      ),
+    ).toEqual(32));
+
+  // exponentiation fast
+  it('sicp 58.2', () =>
+    expect(
+      evaluate(
+        `
+(def (fastexpt b n) (match ((eq n 0) 1)
+((iseven n) (square (fastexpt b (/ n 2)))) (else (* b (fastexpt b (- n 1))))))
+(def (iseven n)
+(eq (mod n 2) 0))
+(fastexpt 2 5)
+   `,
+        scope,
+      ),
+    ).toEqual(32));
+
+  // * = repeated addition
+  it('sicp 60.1', () =>
+    expect(
+      evaluate(
+        `(def (mult a b) (if (eq b 0)
+        0
+        (+ a (* a (- b 1)))))
+        (mult 3 15)
+   `,
+      ),
+    ).toEqual(45));
+
+  // gcd / euclid
+  it('sicp 63.1', () =>
+    expect(
+      evaluate(
+        `(def (gcd a b) (if (eq b 0)
+      a
+      (gcd b (mod a b))))
+      (gcd 20 6)
+     `,
+        scope,
+      ),
+    ).toEqual(2));
+
+  // 65 smallest divisor
+  // 67 fermat test
+  // ....
+
+  // higher order procedures
+
+  it('sicp 77.1', () =>
+    expect(
+      evaluate(
+        `
+(def (sum term a next b)
+(if (gt a b) 0 (+ (term a)
+(sum term (next a) next b))))
+`,
+        scope,
+      ),
+    ).toEqual(0));
+
+  it('sicp 78.1', () =>
+    expect(
+      evaluate(
+        `
+(def (inc n) (+ n 1))
+(def (cube a) (* a a a))
+(def (sumcubes a b)
+(sum cube a inc b))
+(sumcubes 1 10)
+  `,
+        scope,
+      ),
+    ).toEqual(3025));
+
+  it('sicp 78.2', () =>
+    expect(
+      evaluate(
+        `
+    (def (identity x) x)
+    (def (sumintegers a b)
+    (sum identity a inc b))
+    (sumintegers 1 10)
+    `,
+        scope,
+      ),
+    ).toEqual(55));
+
+  // pisum
+  it('sicp 79.1', () =>
+    expect(
+      evaluate(
+        `
+(def (pisum a b) 
+ (def (piterm x)
+  (/ 1.0 (* x (+ x 2)))) 
+(def (pinext x) (+ x 4))
+(sum piterm a pinext b))
+(* 8 (pisum 1 1000))
+`,
+        scope,
+      ),
+    ).toEqual(3.139592655589783));
+
+  // integral
+  it('sicp 79.2', () =>
+    expect(
+      evaluate(
+        `
+(def (integral f a b dx) 
+ (def (adddx x) (+ x dx))
+(* (sum f (+ a (/ dx 2.0)) adddx b) dx))
+(integral cube 0 1 0.01)
+  `,
+        scope,
+      ),
+    ).toEqual(0.24998750000000042));
+  // maximum callstack...
+  //it('sicp 79.3', () => expect(evaluate(`(integral cube 0 1 0.001)`, scope)).toEqual(0.249999875000001));
+
+  //lambdas
+  it('sicp 83.1', () => expect(evaluate(`((fn (x) (+ x 4)) 5)`)).toEqual(9));
+
+  it('sicp 83.2', () =>
+    expect(
+      evaluate(
+        `
+(def (pisum a b)
+  (sum (fn (x) (/ 1.0 (* x (+ x 2))))
+        a
+        (fn (x) (+ x 4)) 
+        b))
+(* 8 (pisum 1 1000))
+`,
+        scope,
+      ),
+    ).toEqual(3.139592655589783));
+  it('sicp 83.3', () =>
+    expect(
+      evaluate(
+        `
+(def (integral f a b dx) 
+ (* (sum f
+         (+ a (/ dx 2.0)) 
+         (fn (x) (+ x dx)) 
+         b)
+    dx))
+(integral cube 0 1 0.01)
+`,
+        scope,
+      ),
+    ).toEqual(0.24998750000000042));
+  it('sicp 84.1', () => expect(evaluate(`((fn (x y z) (+ x y (square z))) 1 2 3)`, scope)).toEqual(12));
+
+  // let expressions
+  it('sicp 87.1', () =>
+    expect(
+      evaluate(
+        `
+(+ (let ((x 3))
+(+ x (* x 10))) x)
+`,
+        { x: 5 },
+      ),
+    ).toEqual(38));
+  it('sicp 87.2', () =>
+    expect(
+      evaluate(
+        `
+(let ((x 3)
+(y (+ x 2)))
+(* x y))
+  `,
+        { x: 2 },
+      ),
+    ).toEqual(12));
+  it('sicp 88.1', () =>
+    expect(
+      evaluate(
+        `
+(def (f g) (g 2))
+(f square)
+      `,
+        scope,
+      ),
+    ).toEqual(4));
+  it('sicp 88.2', () =>
+    expect(
+      evaluate(
+        `
+  (def (f g) (g 2))
+  (f (fn (z) (* z (+ z 1))))
+            `,
+        scope,
+      ),
+    ).toEqual(6));
+
+  // Finding roots of equations by the half-interval method
+  it('sicp 89.1', () =>
+    expect(
+      evaluate(
+        `
+(def (search f negpoint pospoint)
+ (let ((midpoint (average negpoint pospoint)))
+ (if (closeenough negpoint pospoint) 
+  midpoint
+  (let ((testvalue (f midpoint))) 
+   (match ((positive testvalue)
+           (search f negpoint midpoint))
+          ((negative testvalue)
+           (search f midpoint pospoint)) 
+          (else midpoint))))))
+
+(def (closeenough x y) (lt (abs (- x y)) 0.001))
+
+(def (negative x) (lt x 0))
+(def (positive x) (gt x 0))
+
+(def (halfintervalmethod f a b) (let ((avalue (f a))
+(bvalue (f b)))
+(match ((and (negative avalue) (positive bvalue))
+(search f a b))
+((and (negative bvalue) (positive avalue))
+(search f b a)) (else
+(error "Values are not of opposite sign" a b)))))
+
+(halfintervalmethod sin 2.0 4.0)
+`,
+        scope,
+      ),
+    ).toEqual(3.14111328125));
+
+  it('sicp 89.1', () =>
+    expect(evaluate(`(halfintervalmethod (fn (x) (- (* x x x) (* 2 x) 3)) 1.0 2.0)`, scope)).toEqual(1.89306640625));
+
+  // Finding fixed points of functions
+  it('sicp 92.1', () =>
+    expect(
+      evaluate(
+        `
+(def tolerance 0.00001)
+(def (fixedpoint f first-guess)
+ (def (closeenough v1 v2) (lt (abs (- v1 v2)) tolerance)) 
+ (def (try guess)
+  (let ((next (f guess)))
+  (if (closeenough guess next) next (try next))))
+ (try first-guess))
+
+(fixedpoint cos 1.0)
+`,
+        scope,
+      ),
+    ).toEqual(0.7390822985224023));
+  it('sicp 93.1', () =>
+    expect(evaluate(`(fixedpoint (fn (y) (+ (sin y) (cos y))) 1.0)`, scope)).toEqual(1.2587315962971173));
+  // Maximum call stack size exceeded (expected)
+  /* it('sicp 93.2', () =>
+    expect(evaluate(`(def (sqrt x) (fixedpoint (fn (y) (/ x y)) 1.0)) (sqrt 4)`, scope)).toEqual(0)); */
+  it('sicp 93.3', () =>
+    expect(evaluate(`(def (sqrt x) (fixedpoint (fn (y) (average y (/ x y))) 1.0)) (sqrt 7)`, scope)).toEqual(
+      2.6457513110645907,
+    ));
+  // Procedures as Returned Values
+  it('sicp 97.1', () =>
+    expect(evaluate(`(def (averagedamp f) (fn (x) (average x (f x)))) ((averagedamp square) 10)`, scope)).toEqual(55));
+  it('sicp 98.1', () =>
+    expect(evaluate(`(def (sqrt x) (fixedpoint (averagedamp (fn (y) (/ x y))) 1.0)) (sqrt 7)`, scope)).toEqual(
+      2.6457513110645907,
+    ));
+  it('sicp 98.2', () =>
+    expect(
+      evaluate(`(def (cuberoot x) (fixedpoint (averagedamp (fn (y) (/ x (square y)))) 1.0)) (cuberoot 7)`, scope),
+    ).toEqual(1.912934258514886));
+  it('sicp 99.1', () =>
+    expect(
+      evaluate(
+        `
+        (def (deriv g) (fn (x) (/ (- (g (+ x dx)) (g x)) dx))) 
+        (def dx 0.00001)
+        (def (cube x) (* x x x))
+        ((deriv cube) 5)
+        `,
+        scope,
+      ),
+    ).toEqual(75.00014999664018));
+  // With the aid of deriv, we can express Newton’s method as a fixed-point process:
+  it('sicp 100.1', () =>
+    expect(
+      evaluate(
+        `
+(def (newtontransform g)
+(fn (x) (- x (/ (g x) ((deriv g) x)))))
+(def (newtonsmethod g guess) (fixedpoint (newtontransform g) guess))
+(def (sqrt x) (newtonsmethod (fn (y) (- (square y) x)) 1.0))
+(sqrt 7)
+          `,
+        scope,
+      ),
+    ).toEqual(2.6457513110645907));
+  // whatever this is
+  it('sicp 101.1', () =>
+    expect(
+      evaluate(
+        `
+  (def (fixedpointoftransform g transform guess) (fixedpoint (transform g) guess))
+  (def (sqrt x) (fixedpointoftransform
+  (fn (y) (/ x y)) averagedamp 1.0))
+  (sqrt 7)
+  `,
+        scope,
+      ),
+    ).toEqual(2.6457513110645907));
+  it('sicp 101.2', () =>
+    expect(
+      evaluate(
+        `
+(def (sqrt x) (fixedpointoftransform
+(fn (y) (- (square y) x)) newtontransform 1.0))
+(sqrt 7)
+    `,
+        scope,
+      ),
+    ).toEqual(2.6457513110645907));
+
+  // data abstraction
+
+  // rational arithmetic
+  it('sicp 114.1', () =>
+    expect(
+      evaluate(
+        `
+(def (addrat x y)
+ (makerat (+ (* 
+   (numer x) (denom y))
+   (* (numer y) (denom x)))
+  (* (denom x) (denom y))))
+(def (subrat x y)
+ (makerat (- (* (numer x) (denom y))
+   (* (numer y) (denom x)))
+  (* (denom x) (denom y))))
+(def (mulrat x y)
+ (makerat (* (numer x) (numer y))
+  (* (denom x) (denom y)))) 
+(def (divrat x y)
+  (makerat (* (numer x) (denom y))
+   (* (denom x) (numer y))))
+(def (equalrat x y)
+  (eq (* (numer x) (denom y))
+     (* (numer y) (denom x))))
+        `,
+        scope,
+      ),
+    ).toEqual(0));
+
+  // markerat number denom
+  it('sicp 117.1', () =>
+    expect(
+      evaluate(
+        `
+(def (makerat n d) (cons n d)) 
+(def (numer x) (car x))
+(def (denom x) (cdr x))
+(def (printrat x) (concat (numer x) ':' (denom x)))
+      `,
+        scope,
+      ),
+    ).toEqual(0));
+
+  it('sicp 117.1', () => expect(evaluate(`(def onehalf (makerat 1 2)) (printrat onehalf)`, scope)).toEqual('1:2'));
+  it('sicp 117.2', () =>
+    expect(evaluate(`(def onethird (makerat 1 3)) (printrat (addrat onehalf onethird))`, scope)).toEqual('5:6'));
+  it('sicp 117.3', () => expect(evaluate(`(printrat (mulrat onehalf onethird))`, scope)).toEqual('1:6'));
+  it('sicp 117.4', () => expect(evaluate(`(printrat (addrat onethird onethird))`, scope)).toEqual('6:9'));
+  it('sicp 118.1', () =>
+    expect(evaluate(`(def (makerat n d) (let ((g (gcd n d))) (cons (/ n g) (/ d g))))`, scope)).toEqual(0));
+  it('sicp 118.1', () => expect(evaluate(`(printrat (addrat onethird onethird))`, scope)).toEqual('2:3'));
+
+  let lscope = {};
+  // pairs with lambda
+  it('sicp 124.1', () =>
+    expect(
+      evaluate(
+        `
+(def (cons x y) 
+ (def (dispatch m)
+  (match 
+   ((eq m 0) x) 
+   ((eq m 1) y)
+   (else (error "argument not 0 or 1: CONS" m)))
+  ) dispatch)
+ (def (car z) (z 0)) 
+ (def (cdr z) (z 1))
+      `,
+        lscope,
+      ),
+    ).toEqual(0));
+  it('sicp 124.1', () => expect(evaluate(`(car (cons first second))`, lscope)).toEqual('first'));
+  it('sicp 124.2', () => expect(evaluate(`(cdr (cons first second))`, lscope)).toEqual('second'));
+  // lists
+  it('sicp 135.1', () => expect(evaluate(`(list 1 2 3 4)`)).toEqual([1, 2, 3, 4]));
+  it('sicp 137.1', () => expect(evaluate(`(car (list 1 2 3 4))`)).toEqual(1));
+  it('sicp 137.2', () => expect(evaluate(`(cdr (list 1 2 3 4))`)).toEqual([2, 3, 4]));
+  it('sicp 137.3', () => expect(evaluate(`(car (cdr (list 1 2 3 4)))`)).toEqual(2));
+  it('sicp 137.4', () => expect(evaluate(`(cons 10 (list 1 2 3 4))`)).toEqual([10, 1, 2, 3, 4]));
+  // listref
+  it('sicp 138.1', () =>
+    expect(
+      evaluate(
+        `
+(def (listref items n) (if (eq n 0) (car items) 
+ (listref (cdr items) (- n 1)))) 
+(def squares (list 1 4 9 16 25)) 
+(listref squares 3)`,
+        scope,
+      ),
+    ).toEqual(16));
+  // length recursive
+  it('sicp 138.2', () =>
+    expect(
+      evaluate(
+        `
+  (def (length items) 
+   (if (isnull items) 0
+    (+ 1 (length (cdr items))))) 
+  (def odds (list 1 3 5 7)) 
+  (length odds)`,
+      ),
+    ).toEqual(4));
+  // length iterative
+  it('sicp 139.1', () =>
+    expect(
+      evaluate(
+        `
+  (def (length items)
+  (def (lengthiter a count)
+   (if (isnull a) count
+    (lengthiter (cdr a) (+ 1 count))))
+    (lengthiter items 0))
+  (def odds (list 1 3 5 7)) 
+  (length odds)
+  `,
+        scope,
+      ),
+    ).toEqual(4));
+  // append
+  it('sicp 139.1', () =>
+    expect(
+      evaluate(
+        `
+(def (append list1 list2) 
+(if (isnull list1)
+  list2
+  (cons (car list1) (append (cdr list1) list2))))
+  (append squares odds)
+    `,
+        scope,
+      ),
+    ).toEqual([1, 4, 9, 16, 25, 1, 3, 5, 7]));
+  // (define (f x y . z) ⟨body⟩) <- tbd: variable argument count
+  // Mapping over lists
+
+  it('sicp 143.1', () =>
+    expect(
+      evaluate(
+        `
+(def (scalelist items factor) (if (isnull items) nil
+    (cons (* (car items) factor)
+          (scalelist (cdr items) factor))))
+(scalelist (list 1 2 3 4 5) 10)
+    `,
+        scope,
+      ),
+    ).toEqual([10, 20, 30, 40, 50]));
+
+  it('sicp 143.1', () =>
+    expect(
+      evaluate(
+        `
+  (def (map proc items) (if (isnull items) nil
+        (cons (proc (car items))
+              (map proc (cdr items)))))
+  (map abs (list -10 2.5 -11.6 17))
+  `,
+        scope,
+      ),
+    ).toEqual([10, 2.5, 11.6, 17]));
+  it('sicp 143.1', () => expect(evaluate(`(map (fn (x) (* x x)) (list 1 2 3 4))`, scope)).toEqual([1, 4, 9, 16]));
+  it('sicp 143.1', () =>
+    expect(
+      evaluate(
+        `
+(def (scalelist items factor) (map (fn (x) (* x factor)) items))
+(scalelist (list 1 2 3 4 5) 10)
+`,
+        scope,
+      ),
+    ).toEqual([10, 20, 30, 40, 50]));
+});
@@ -0,0 +1,19 @@
+import { defineConfig } from 'vite';
+//import { dependencies } from './package.json';
+import { resolve } from 'path';
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [],
+  build: {
+    lib: {
+      entry: resolve(__dirname, 'mondo.mjs'),
+      formats: ['es'],
+      fileName: (ext) => ({ es: 'mondo.mjs' })[ext],
+    },
+    rollupOptions: {
+      // external: [...Object.keys(dependencies)],
+    },
+    target: 'esnext',
+  },
+});
@@ -0,0 +1,3 @@
+# @strudel/mondough
+
+connects mondo to strudel.
@@ -0,0 +1,131 @@
+import {
+  strudelScope,
+  reify,
+  fast,
+  slow,
+  seq,
+  stepcat,
+  extend,
+  expand,
+  pace,
+  chooseIn,
+  degradeBy,
+  silence,
+} from '@strudel/core';
+import { registerLanguage } from '@strudel/transpiler';
+import { MondoRunner } from 'mondolang';
+
+const tail = (friend, pat) => pat.fmap((a) => (b) => (Array.isArray(a) ? [...a, b] : [a, b])).appLeft(friend);
+
+const arrayRange = (start, stop, step = 1) =>
+  Array.from({ length: Math.abs(stop - start) / step + 1 }, (_, index) =>
+    start < stop ? start + index * step : start - index * step,
+  );
+const range = (max, min) => min.squeezeBind((a) => max.bind((b) => seq(...arrayRange(a, b))));
+
+let nope = (...args) => args[args.length - 1];
+
+let lib = {};
+lib['nope'] = nope;
+lib['-'] = (a, b) => b.early(a);
+lib['+'] = (a, b) => b.late(a);
+lib['_'] = silence;
+lib['~'] = silence;
+lib.curly = stepcat;
+lib.square = (...args) => stepcat(...args).setSteps(1);
+lib.angle = (...args) => stepcat(...args).pace(1);
+lib['*'] = fast;
+lib['/'] = slow;
+lib['!'] = extend;
+lib['@'] = expand;
+lib['%'] = pace;
+lib['?'] = degradeBy; // todo: default 0.5 not working..
+lib[':'] = tail;
+lib['..'] = range;
+lib['or'] = (...children) => chooseIn(...children); // always has structure but is cyclewise.. e.g. "s oh*8.dec[.04 | .5]"
+//lib['or'] = (...children) => chooseOut(...children); // "s oh*8.dec[.04 | .5]" is better but "dec[.04 | .5].s oh*8" has no struct
+
+function evaluator(node, scope) {
+  const { type } = node;
+  // node is list
+  if (type === 'list') {
+    const { children } = node;
+    const [name, ...args] = children;
+    // some functions wont be reified to make sure they work (e.g. see extend below)
+    if (typeof name === 'function') {
+      return name(...args);
+    }
+    if (name.value === 'def') {
+      return silence;
+    }
+    // name is expected to be a pattern of functions!
+    const first = name.firstCycle(true)[0];
+    const type = typeof first?.value;
+    if (type !== 'function') {
+      throw new Error(`[mondough] expected function, got "${first?.value}"`);
+    }
+    return name
+      .fmap((fn) => {
+        if (typeof fn !== 'function') {
+          throw new Error(`[mondough] "${fn}" is not a function b`);
+        }
+        return fn(...args);
+      })
+      .innerJoin();
+  }
+  // node is leaf
+  let { value } = node;
+  if (type === 'plain' && scope[value]) {
+    return reify(scope[value]); // -> local scope has no location
+  }
+  const variable = lib[value] ?? strudelScope[value];
+  // problem: collisions when we want a string that happens to also be a variable name
+  // example: "s sine" -> sine is also a variable
+  let pat;
+  if (type === 'plain' && typeof variable !== 'undefined') {
+    // some function names are not patternable, so we skip reification here
+    if (['!', 'extend', '@', 'expand', 'square', 'angle'].includes(value)) {
+      return variable;
+    }
+    pat = reify(variable);
+  } else {
+    pat = reify(value);
+  }
+  if (node.loc) {
+    pat = pat.withLoc(node.loc[0], node.loc[1]);
+  }
+  return pat;
+}
+
+let runner = new MondoRunner({ evaluator });
+
+export function mondo(code, offset = 0) {
+  if (Array.isArray(code)) {
+    code = code.join('');
+  }
+  const pat = runner.run(code, undefined, offset);
+  return pat.markcss('color: var(--caret,--foreground);text-decoration:underline');
+}
+
+let getLocations = (code, offset) => runner.parser.get_locations(code, offset);
+
+export const mondi = (str, offset) => {
+  const code = `[${str}]`;
+  return mondo(code, offset);
+};
+
+// tell transpiler how to get locations for mondo`` calls
+registerLanguage('mondo', {
+  getLocations,
+});
+
+// this is like mondo, but with a zero offset
+export const mondolang = (code) => mondo(code, 0);
+registerLanguage('mondolang', {
+  getLocations: (code) => getLocations(code, 0),
+});
+// uncomment the following to use mondo as mini notation language
+/* registerLanguage('minilang', {
+  name: 'mondi',
+  getLocations,
+}); */
@@ -0,0 +1,44 @@
+{
+  "name": "@strudel/mondo",
+  "version": "1.1.0",
+  "description": "mondo notation for strudel",
+  "main": "mondough.mjs",
+  "type": "module",
+  "publishConfig": {
+    "main": "dist/mondough.mjs"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "bench": "vitest bench",
+    "build:parser": "peggy -o krill-parser.js --format es ./krill.pegjs",
+    "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/core": "workspace:*",
+    "@strudel/transpiler": "workspace:*",
+    "mondolang": "workspace:*"
+  },
+  "devDependencies": {
+    "mondo": "*",
+    "vite": "^6.0.11",
+    "vitest": "^3.0.4"
+  }
+}
@@ -0,0 +1,19 @@
+import { defineConfig } from 'vite';
+//import { dependencies } from './package.json';
+import { resolve } from 'path';
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [],
+  build: {
+    lib: {
+      entry: resolve(__dirname, 'mondough.mjs'),
+      formats: ['es'],
+      fileName: (ext) => ({ es: 'mondough.mjs' })[ext],
+    },
+    rollupOptions: {
+      // external: [...Object.keys(dependencies)],
+    },
+    target: 'esnext',
+  },
+});
@@ -17,7 +17,7 @@ You can also pin the version like this:
 ```

 This has the advantage that your code will always work, regardless of potential breaking changes in the strudel codebase.
-See [releases](https://github.com/tidalcycles/strudel/releases) for the latest versions.
+See [releases](https://codeberg.org/uzu/strudel/releases) for the latest versions.

 ## Use Web Component

@@ -7,7 +7,7 @@ This program is free software: you can redistribute it and/or modify it under th
 import './feedbackdelay.mjs';
 import './reverb.mjs';
 import './vowel.mjs';
-import { clamp, nanFallback, _mod } from './util.mjs';
+import { clamp, nanFallback, _mod, cycleToSeconds } from './util.mjs';
 import workletsUrl from './worklets.mjs?audioworklet';
 import { createFilter, gainNode, getCompressor, getWorklet } from './helpers.mjs';
 import { map } from 'nanostores';
@@ -107,6 +107,10 @@ export async function aliasBank(...args) {
 }

 export function getSound(s) {
+  if (typeof s !== 'string') {
+    console.warn(`getSound: expected string got "${s}". fall back to triangle`);
+    return soundMap.get().triangle; // is this good?
+  }
  return soundMap.get()[s.toLowerCase()];
 }

@@ -139,7 +143,7 @@ const defaultDefaultValues = {
  delay: 0,
  byteBeatExpression: '0',
  delayfeedback: 0.5,
-  delaytime: 0.25,
+  delaysync: 3 / 16,
  orbit: 1,
  i: 1,
  velocity: 1,
@@ -446,7 +450,7 @@ function mapChannelNumbers(channels) {
  return (Array.isArray(channels) ? channels : [channels]).map((ch) => ch - 1);
 }

-export const superdough = async (value, t, hapDuration, cps) => {
+export const superdough = async (value, t, hapDuration, cps = 0.5) => {
  const ac = getAudioContext();
  t = typeof t === 'string' && t.startsWith('=') ? Number(t.slice(1)) : ac.currentTime + t;
  let { stretch } = value;
@@ -524,7 +528,8 @@ export const superdough = async (value, t, hapDuration, cps) => {
    vowel,
    delay = getDefaultValue('delay'),
    delayfeedback = getDefaultValue('delayfeedback'),
-    delaytime = getDefaultValue('delaytime'),
+    delaysync = getDefaultValue('delaysync'),
+    delaytime,
    orbit = getDefaultValue('orbit'),
    room,
    roomfade,
@@ -543,6 +548,8 @@ export const superdough = async (value, t, hapDuration, cps) => {
    compressorRelease,
  } = value;

+  delaytime = delaytime ?? cycleToSeconds(delaysync, cps);
+
  const orbitChannels = mapChannelNumbers(
    multiChannelOrbits && orbit > 0 ? [orbit * 2 - 1, orbit * 2] : getDefaultValue('channels'),
  );
@@ -571,6 +578,9 @@ export const superdough = async (value, t, hapDuration, cps) => {

  let audioNodes = [];

+  if (['-', '~', '_'].includes(s)) {
+    return;
+  }
  if (bank && s) {
    s = `${bank}_${s}`;
    value.s = s;
@@ -718,8 +728,8 @@ export const superdough = async (value, t, hapDuration, cps) => {
  // delay
  let delaySend;
  if (delay > 0 && delaytime > 0 && delayfeedback > 0) {
-    const delyNode = getDelay(orbit, delaytime, delayfeedback, t, orbitChannels);
-    delaySend = effectSend(post, delyNode, delay);
+    const delayNode = getDelay(orbit, delaytime, delayfeedback, t, orbitChannels);
+    delaySend = effectSend(post, delayNode, delay);
    audioNodes.push(delaySend);
  }
  // reverb
@@ -1,5 +1,5 @@
 import { clamp, midiToFreq, noteToMidi } from './util.mjs';
-import { registerSound, getAudioContext, getLfo } from './superdough.mjs';
+import { registerSound, getAudioContext, soundMap, getLfo } from './superdough.mjs';
 import {
  applyFM,
  gainNode,
@@ -34,6 +34,12 @@ function destroyAudioWorkletNode(node) {
 }

 const waveforms = ['triangle', 'square', 'sawtooth', 'sine'];
+const waveformAliases = [
+  ['tri', 'triangle'],
+  ['sqr', 'square'],
+  ['saw', 'sawtooth'],
+  ['sin', 'sine'],
+];
 const noises = ['pink', 'white', 'brown', 'crackle'];

 export function registerSynthSounds() {
@@ -342,6 +348,7 @@ export function registerSynthSounds() {
      { type: 'synth', prebake: true },
    );
  });
+  waveformAliases.forEach(([alias, actual]) => soundMap.set({ ...soundMap.get(), [alias]: soundMap.get()[actual] }));
 }

 export function waveformN(partials, type) {
@@ -68,3 +68,7 @@ export const _mod = (n, m) => ((n % m) + m) % m;
 export const getSoundIndex = (n, numSounds) => {
  return _mod(Math.round(nanFallback(n, 0)), numSounds);
 };
+
+export function cycleToSeconds(cycle, cps) {
+  return cycle / cps;
+}
@@ -25,28 +25,35 @@ describe('tonal', () => {
  });
  it('scale with n values', () => {
    expect(
-      n(0, 1, 2)
+      n(seq(0, 1, 2))
        .scale('C major')
        .firstCycleValues.map((h) => h.note),
    ).toEqual(['C3', 'D3', 'E3']);
  });
  it('scale with colon', () => {
    expect(
-      n(0, 1, 2)
+      n(seq(0, 1, 2))
        .scale('C:major')
        .firstCycleValues.map((h) => h.note),
    ).toEqual(['C3', 'D3', 'E3']);
  });
+  it('scale without tonic', () => {
+    expect(
+      n(seq(0, 1, 2))
+        .scale('major')
+        .firstCycleValues.map((h) => h.note),
+    ).toEqual(['C3', 'D3', 'E3']);
+  });
  it('scale with mininotation colon', () => {
    expect(
-      n(0, 1, 2)
+      n(seq(0, 1, 2))
        .scale(mini('C:major'))
        .firstCycleValues.map((h) => h.note),
    ).toEqual(['C3', 'D3', 'E3']);
  });
  it('transposes note numbers with interval numbers', () => {
    expect(
-      note(40, 40, 40)
+      note(seq(40, 40, 40))
        .transpose(0, 1, 2)
        .firstCycleValues.map((h) => h.note),
    ).toEqual([40, 41, 42]);
@@ -54,7 +61,7 @@ describe('tonal', () => {
  });
  it('transposes note numbers with interval strings', () => {
    expect(
-      note(40, 40, 40)
+      note(seq(40, 40, 40))
        .transpose('1P', '2M', '3m')
        .firstCycleValues.map((h) => h.note),
    ).toEqual([40, 42, 43]);
@@ -62,7 +69,7 @@ describe('tonal', () => {
  });
  it('transposes note strings with interval numbers', () => {
    expect(
-      note('c', 'c', 'c')
+      note(seq('c', 'c', 'c'))
        .transpose(0, 1, 2)
        .firstCycleValues.map((h) => h.note),
    ).toEqual(['C', 'Db', 'D']);
@@ -70,7 +77,7 @@ describe('tonal', () => {
  });
  it('transposes note strings with interval strings', () => {
    expect(
-      note('c', 'c', 'c')
+      note(seq('c', 'c', 'c'))
        .transpose('1P', '2M', '3m')
        .firstCycleValues.map((h) => h.note),
    ).toEqual(['C', 'D', 'Eb']);
@@ -14,7 +14,7 @@ function scaleStep(step, scale) {
  scale = scale.replaceAll(':', ' ');
  step = Math.ceil(step);
  let { intervals, tonic, empty } = Scale.get(scale);
-  if ((empty && isNote(scale)) || (!empty && !tonic)) {
+  if ((empty && isNote(scale)) || (empty && !tonic)) {
    throw new Error(`incomplete scale. Make sure to use ":" instead of spaces, example: .scale("C:major")`);
  } else if (empty) {
    throw new Error(`invalid scale "${scale}"`);
@@ -8,6 +8,16 @@ export function registerWidgetType(type) {
  widgetMethods.push(type);
 }

+let languages = new Map();
+// config = { getLocations: (code: string, offset?: number) => number[][] }
+// see mondough.mjs for example use
+// the language will kick in when the code contains a template literal of type
+// example: mondo`...` will use language of type "mondo"
+// TODO: refactor tidal.mjs to use this
+export function registerLanguage(type, config) {
+  languages.set(type, config);
+}
+
 export function transpiler(input, options = {}) {
  const { wrapAsync = false, addReturn = true, emitMiniLocations = true, emitWidgets = true } = options;

@@ -19,14 +29,33 @@ export function transpiler(input, options = {}) {

  let miniLocations = [];
  const collectMiniLocations = (value, node) => {
-    const leafLocs = getLeafLocations(`"${value}"`, node.start, input);
-    miniLocations = miniLocations.concat(leafLocs);
+    const minilang = languages.get('minilang');
+    if (minilang) {
+      const code = `[${value}]`;
+      const locs = minilang.getLocations(code, node.start);
+      miniLocations = miniLocations.concat(locs);
+    } else {
+      const leafLocs = getLeafLocations(`"${value}"`, node.start, input);
+      miniLocations = miniLocations.concat(leafLocs);
+    }
  };
  let widgets = [];

  walk(ast, {
    enter(node, parent /* , prop, index */) {
-      if (isTidalTeplateLiteral(node)) {
+      if (isLanguageLiteral(node)) {
+        const { name } = node.tag;
+        const language = languages.get(name);
+        const code = node.quasi.quasis[0].value.raw;
+        const offset = node.quasi.start + 1;
+        if (emitMiniLocations) {
+          const locs = language.getLocations(code, offset);
+          miniLocations = miniLocations.concat(locs);
+        }
+        this.skip();
+        return this.replace(languageWithLocation(name, code, offset));
+      }
+      if (isTemplateLiteral(node, 'tidal')) {
        const raw = node.quasi.quasis[0].value.raw;
        const offset = node.quasi.start + 1;
        if (emitMiniLocations) {
@@ -84,8 +113,18 @@ export function transpiler(input, options = {}) {
    leave(node, parent, prop, index) {},
  });

-  const { body } = ast;
-  if (!body?.[body.length - 1]?.expression) {
+  let { body } = ast;
+
+  if (!body.length) {
+    console.warn('empty body -> fallback to silence');
+    body.push({
+      type: 'ExpressionStatement',
+      expression: {
+        type: 'Identifier',
+        name: 'silence',
+      },
+    });
+  } else if (!body?.[body.length - 1]?.expression) {
    throw new Error('unexpected ast format without body expression');
  }

@@ -120,11 +159,18 @@ function isBackTickString(node, parent) {

 function miniWithLocation(value, node) {
  const { start: fromOffset } = node;
+
+  const minilang = languages.get('minilang');
+  let name = 'm';
+  if (minilang && minilang.name) {
+    name = minilang.name; // name is expected to be exported from the package of the minilang
+  }
+
  return {
    type: 'CallExpression',
    callee: {
      type: 'Identifier',
-      name: 'm',
+      name,
    },
    arguments: [
      { type: 'Literal', value },
@@ -219,12 +265,16 @@ function labelToP(node) {
  };
 }

+function isLanguageLiteral(node) {
+  return node.type === 'TaggedTemplateExpression' && languages.has(node.tag.name);
+}
+
 // tidal highlighting
 // this feels kind of stupid, when we also know the location inside the string op (tidal.mjs)
 // but maybe it's the only way

-function isTidalTeplateLiteral(node) {
-  return node.type === 'TaggedTemplateExpression' && node.tag.name === 'tidal';
+function isTemplateLiteral(node, value) {
+  return node.type === 'TaggedTemplateExpression' && node.tag.name === value;
 }

 function collectHaskellMiniLocations(haskellCode, offset) {
@@ -262,3 +312,18 @@ function tidalWithLocation(value, offset) {
    optional: false,
  };
 }
+
+function languageWithLocation(name, value, offset) {
+  return {
+    type: 'CallExpression',
+    callee: {
+      type: 'Identifier',
+      name: name,
+    },
+    arguments: [
+      { type: 'Literal', value },
+      { type: 'Literal', value: offset },
+    ],
+    optional: false,
+  };
+}
@@ -16,9 +16,10 @@ const hap2value = (hap) => {
 };

 export const webaudioOutputTrigger = (t, hap, ct, cps) => superdough(hap2value(hap), t - ct, hap.duration / cps, cps);
-// uses more precise, absolute t if available, see https://codeberg.org/uzu/strudel/pulls/1004
-export const webaudioOutput = (hap, deadline, hapDuration, cps, t) =>
-  superdough(hap2value(hap), t ? `=${t}` : deadline, hapDuration);
+// uses more precise, absolute t if available, see https://github.com/tidalcycles/strudel/pull/1004
+export const webaudioOutput = (hap, deadline, hapDuration, cps, t) => {
+  return superdough(hap2value(hap), t ? `=${t}` : deadline, hapDuration, cps);
+};

 Pattern.prototype.webaudio = function () {
  return this.onTrigger(webaudioOutputTrigger);
@@ -347,6 +347,37 @@ importers:
        specifier: ^3.0.4
        version: 3.0.4(@types/debug@4.1.12)(@types/node@22.10.10)(@vitest/ui@3.0.4)(jiti@2.4.2)(lightningcss@1.29.1)(terser@5.37.0)(yaml@2.7.0)

+  packages/mondo:
+    devDependencies:
+      vite:
+        specifier: ^6.0.11
+        version: 6.0.11(@types/node@22.10.10)(jiti@2.4.2)(lightningcss@1.29.1)(terser@5.37.0)(yaml@2.7.0)
+      vitest:
+        specifier: ^3.0.4
+        version: 3.0.4(@types/debug@4.1.12)(@types/node@22.10.10)(@vitest/ui@3.0.4)(jiti@2.4.2)(lightningcss@1.29.1)(terser@5.37.0)(yaml@2.7.0)
+
+  packages/mondough:
+    dependencies:
+      '@strudel/core':
+        specifier: workspace:*
+        version: link:../core
+      '@strudel/transpiler':
+        specifier: workspace:*
+        version: link:../transpiler
+      mondolang:
+        specifier: workspace:*
+        version: link:../mondo
+    devDependencies:
+      mondo:
+        specifier: '*'
+        version: 0.4.4
+      vite:
+        specifier: ^6.0.11
+        version: 6.0.11(@types/node@22.10.10)(jiti@2.4.2)(lightningcss@1.29.1)(terser@5.37.0)(yaml@2.7.0)
+      vitest:
+        specifier: ^3.0.4
+        version: 3.0.4(@types/debug@4.1.12)(@types/node@22.10.10)(@vitest/ui@3.0.4)(jiti@2.4.2)(lightningcss@1.29.1)(terser@5.37.0)(yaml@2.7.0)
+
  packages/motion:
    dependencies:
      '@strudel/core':
@@ -683,6 +714,9 @@ importers:
      '@strudel/mini':
        specifier: workspace:*
        version: link:../packages/mini
+      '@strudel/mondo':
+        specifier: workspace:*
+        version: link:../packages/mondough
      '@strudel/motion':
        specifier: workspace:*
        version: link:../packages/motion
@@ -2975,6 +3009,10 @@ packages:
    resolution: {integrity: sha512-groO71Fvi5SWpxjI9Ia+chy0QBwT61mg6yxJV27f5YFf+Mw+STT75K6SHySpP8Co5LsCrtsbCH5dJZSRtkSKaQ==}
    engines: {node: '>= 14.0.0'}

+  amdefine@1.0.1:
+    resolution: {integrity: sha512-S2Hw0TtNkMJhIabBwIojKL9YHO5T0n5eNqWJ7Lrlel/zDbftQpxpapi8tZs3X1HWa+u+QeydGmzzNU0m09+Rcg==}
+    engines: {node: '>=0.4.2'}
+
  ansi-align@3.0.1:
    resolution: {integrity: sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==}

@@ -3103,6 +3141,9 @@ packages:
    resolution: {integrity: sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==}
    engines: {node: '>= 0.4'}

+  async@0.2.10:
+    resolution: {integrity: sha512-eAkdoKxU6/LkKDBzLpT+t6Ff5EtfSF4wx1WfJiPEEV7WNLnDaRXk0oVysiEPm262roaachGexwUv94WhSgN5TQ==}
+
  async@3.2.6:
    resolution: {integrity: sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==}

@@ -3337,6 +3378,9 @@ packages:
  claviature@0.1.0:
    resolution: {integrity: sha512-Ai12axNwQ7x/F9QAj64RYKsgvi5Y33+X3GUSKAC/9s/adEws8TSSc0efeiqhKNGKBo6rT/c+CSCwSXzXxwxZzQ==}

+  cldr-plurals@1.0.0:
+    resolution: {integrity: sha512-xGkehDsjj/ng1LtYiAzdiqDgqTQ/qmWafDlB6R8CfXbpXe4Ge2Tl4l7gxiA+yaD1WCTP3EVfwerdmVwfco7vxw==}
+
  clean-stack@2.2.0:
    resolution: {integrity: sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==}
    engines: {node: '>=6'}
@@ -4378,6 +4422,9 @@ packages:
    resolution: {integrity: sha512-e1LleDykUz2Iu+MTYdkSsuWX8lvAjAcs0Xef0lNIu0S2wOAzuTxCJtcd9S3cijlwYF18EsU3rzb8jPVobxDh9Q==}
    engines: {node: '>=16 || 14 >=14.17'}

+  globalize@0.1.1:
+    resolution: {integrity: sha512-5e01v8eLGfuQSOvx2MsDMOWS0GFtCx1wPzQSmcHw4hkxFzrQDBO3Xwg/m8Hr/7qXMrHeOIE29qWVzyv06u1TZA==}
+
  globals@11.12.0:
    resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==}
    engines: {node: '>=4'}
@@ -4439,6 +4486,11 @@ packages:
  h3@1.14.0:
    resolution: {integrity: sha512-ao22eiONdgelqcnknw0iD645qW0s9NnrJHr5OBz4WOMdBdycfSas1EQf1wXRsm+PcB2Yoj43pjBPwqIpJQTeWg==}

+  handlebars@1.1.2:
+    resolution: {integrity: sha512-6lekK3aSHE7XnEqEs+JWQJRSRdCqJYHEVjEfWWZv9pjLUYZNeP26EtlgOrpDCSX+k5N1m74urTbztgBOCko1Kg==}
+    engines: {node: '>=0.4.7'}
+    hasBin: true
+
  handlebars@4.7.8:
    resolution: {integrity: sha512-vafaFqs8MZkRrSX7sFVUdo3ap/eNiLnb4IakshzvP56X5Nr1iGKAIqdX6tMlm6HcNRIkr6AxO5jFEoJzzpT8aQ==}
    engines: {node: '>=0.4.7'}
@@ -5586,6 +5638,10 @@ packages:
    engines: {node: '>=18'}
    hasBin: true

+  mondo@0.4.4:
+    resolution: {integrity: sha512-3ot6iKwC9KZvwmyZ9dgPCnlt0O1GuBnK8QZyhnoJdtkIiRL9X/cmQuu88CbFSznQx6bq19xQdwJHpv8hggH62Q==}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
+
  mrmime@2.0.0:
    resolution: {integrity: sha512-eu38+hdgojoyq63s+yTpN4XMBdt5l8HhMhc4VKLO9KM5caLIBvUm4thi7fFaxyTmCKeNnXZ5pAlBwCUnhA09uw==}
    engines: {node: '>=10'}
@@ -5827,6 +5883,9 @@ packages:
    resolution: {integrity: sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==}
    engines: {node: '>=12'}

+  optimist@0.3.7:
+    resolution: {integrity: sha512-TCx0dXQzVtSCg2OgY/bO9hjM9cV4XYx09TVK+s3+FhkjT6LovsLe+pPMzpWf+6yXK/hUizs2gUoTw3jHM0VaTQ==}
+
  optionator@0.9.4:
    resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==}
    engines: {node: '>= 0.8.0'}
@@ -6725,6 +6784,10 @@ packages:
  source-map-support@0.5.21:
    resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==}

+  source-map@0.1.43:
+    resolution: {integrity: sha512-VtCvB9SIQhk3aF6h+N85EaqIaBFIAfZ9Cu+NJHHVvc8BbEcnvDcFw6sqQ2dQrT6SlOrZq3tIvyD9+EGq/lJryQ==}
+    engines: {node: '>=0.8.0'}
+
  source-map@0.5.7:
    resolution: {integrity: sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==}
    engines: {node: '>=0.10.0'}
@@ -7155,6 +7218,11 @@ packages:
  ufo@1.5.4:
    resolution: {integrity: sha512-UsUk3byDzKd04EyoZ7U4DOlxQaD14JUKQl6/P7wiX4FNvUfm3XL246n9W5AmqwW5RSFJ27NAuM0iLscAOYUiGQ==}

+  uglify-js@2.3.6:
+    resolution: {integrity: sha512-T2LWWydxf5+Btpb0S/Gg/yKFmYjnX9jtQ4mdN9YRq73BhN21EhU0Dvw3wYDLqd3TooGUJlCKf3Gfyjjy/RTcWA==}
+    engines: {node: '>=0.4.0'}
+    hasBin: true
+
  uglify-js@3.19.3:
    resolution: {integrity: sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ==}
    engines: {node: '>=0.8.0'}
@@ -7173,6 +7241,9 @@ packages:
  underscore@1.13.7:
    resolution: {integrity: sha512-GMXzWtsc57XAtguZgaQViUOzs0KTkk8ojr3/xAxXLITqf/3EMwxC0inyETfDFjH/Krbhuep0HNbbjI9i/q3F3g==}

+  underscore@1.5.2:
+    resolution: {integrity: sha512-yejOFsRnTJs0N9CK5Apzf6maDO2djxGoLLrlZlvGs2o9ZQuhIhDL18rtFyy4FBIbOkzA6+4hDgXbgz5EvDQCXQ==}
+
  undici-types@6.20.0:
    resolution: {integrity: sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==}

@@ -7555,6 +7626,10 @@ packages:
    resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==}
    engines: {node: '>=0.10.0'}

+  wordwrap@0.0.3:
+    resolution: {integrity: sha512-1tMA907+V4QmxV7dbRvb4/8MaRALK6q9Abid3ndMYnbyo8piisCmeONVqVSXqQA3KaP4SLt5b7ud6E2sqP8TFw==}
+    engines: {node: '>=0.4.0'}
+
  wordwrap@1.0.0:
    resolution: {integrity: sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==}

@@ -10438,6 +10513,9 @@ snapshots:
      '@algolia/requester-fetch': 5.20.0
      '@algolia/requester-node-http': 5.20.0

+  amdefine@1.0.1:
+    optional: true
+
  ansi-align@3.0.1:
    dependencies:
      string-width: 4.2.3
@@ -10647,6 +10725,9 @@ snapshots:

  async-function@1.0.0: {}

+  async@0.2.10:
+    optional: true
+
  async@3.2.6: {}

  asynckit@0.4.0: {}
@@ -10904,6 +10985,8 @@ snapshots:

  claviature@0.1.0: {}

+  cldr-plurals@1.0.0: {}
+
  clean-stack@2.2.0: {}

  cli-boxes@3.0.0: {}
@@ -12046,6 +12129,8 @@ snapshots:
      minipass: 4.2.8
      path-scurry: 1.11.1

+  globalize@0.1.1: {}
+
  globals@11.12.0: {}

  globals@14.0.0: {}
@@ -12112,6 +12197,12 @@ snapshots:
      uncrypto: 0.1.3
      unenv: 1.10.0

+  handlebars@1.1.2:
+    dependencies:
+      optimist: 0.3.7
+    optionalDependencies:
+      uglify-js: 2.3.6
+
  handlebars@4.7.8:
    dependencies:
      minimist: 1.2.8
@@ -13695,6 +13786,13 @@ snapshots:
      requirejs: 2.3.7
      requirejs-config-file: 4.0.0

+  mondo@0.4.4:
+    dependencies:
+      cldr-plurals: 1.0.0
+      globalize: 0.1.1
+      handlebars: 1.1.2
+      underscore: 1.5.2
+
  mrmime@2.0.0: {}

  ms@2.0.0: {}
@@ -13987,6 +14085,10 @@ snapshots:
      is-docker: 2.2.1
      is-wsl: 2.2.0

+  optimist@0.3.7:
+    dependencies:
+      wordwrap: 0.0.3
+
  optionator@0.9.4:
    dependencies:
      deep-is: 0.1.4
@@ -15094,6 +15196,11 @@ snapshots:
      buffer-from: 1.1.2
      source-map: 0.6.1

+  source-map@0.1.43:
+    dependencies:
+      amdefine: 1.0.1
+    optional: true
+
  source-map@0.5.7: {}

  source-map@0.6.1: {}
@@ -15561,6 +15668,13 @@ snapshots:

  ufo@1.5.4: {}

+  uglify-js@2.3.6:
+    dependencies:
+      async: 0.2.10
+      optimist: 0.3.7
+      source-map: 0.1.43
+    optional: true
+
  uglify-js@3.19.3:
    optional: true

@@ -15577,6 +15691,8 @@ snapshots:

  underscore@1.13.7: {}

+  underscore@1.5.2: {}
+
  undici-types@6.20.0: {}

  unenv@1.10.0:
@@ -15957,6 +16073,8 @@ snapshots:

  word-wrap@1.2.5: {}

+  wordwrap@0.0.3: {}
+
  wordwrap@1.0.0: {}

  workbox-background-sync@7.0.0:
@@ -1,193 +0,0 @@
-This document introduces you to Strudel in a technical sense. If you just want to *use* Strudel, have a look at the [Tutorial](https://strudel.tidalcycles.org/tutorial/).
-
-## Strudel Packages
-
-There are different packages for different purposes. They..
-
- split up the code into smaller chunks
- can be selectively used to implement some sort of time based system
-
-Please refer to the individual README files in the [packages folder](https://codeberg.org/uzu/strudel/src/branch/main/packages)
-
-## REPL
-
-The [REPL](https://strudel.tidalcycles.org/) is the place where all packages come together to form a live coding system. It can also be seen as a reference implementation for users of the library.
-
-More info in the [REPL README](https://codeberg.org/uzu/strudel/src/branch/main/packages/repl/README.md)
-
-# High Level Overview
-
-<img src="https://codeberg.org/uzu/strudel/raw/branch/talk/talk/public/strudelflow.png" width="600" />
-
-## 1. End User Code
-
-The End User Code is written in JavaScript with added syntax sugar. The [eval package](https://codeberg.org/uzu/strudel/src/branch/main/packages/eval#strudelcycleseval) evaluates the user code
-after a transpilation step, which resolves the syntax sugar. If you don't want the syntax sugar, you can omit the eval package and call the native javascript `eval` instead.
-
-### 🍭 Syntax Sugar
-
-JavaScript Transpilation = converting valid JavaScript to valid JavaScript:
-
-```js
-"c3 [e3 g3]".fast(2)
-```
-
-becomes
-
-```js
-mini('c3 [e3 g3]')
-  .withMiniLocation([1, 0, 0], [1, 11, 11]) // source location
-  .fast(2);
-```
-
- double quoted strings and backtick strings are turned into `mini` calls (single quoted strings are left as is)
- The source location is added by chaining `withMiniLocation`, which enables the real time highlighting later
- (psuedo) variable names that look like notes (like `c4`, `bb2` or `fs3`) are turned into strings
- support for top level await
- operator overloading could be implemented in the future
-
-This is how it works:
-
-<img src="https://codeberg.org/uzu/strudel/raw/branch/talk/talk/public/shiftflow.png" width="800" />
-
- The user code is parsed with a [shift parser](https://github.com/shapesecurity/shift-parser-js), generating an AST
- The AST is transformed to resolve the syntax sugar
- The AST is used to generate code again (shift-codegen)
-
-Shift will most likely be replaced with acorn in the future, see https://codeberg.org/uzu/strudel/issues/174
-
-### Mini Notation
-
-Another important part of the user code is the mini notation, which allows to express rhythms in a short manner.
-
- the mini notation is [implemented as a PEG grammar](https://codeberg.org/uzu/strudel/src/branch/main/packages/mini/krill.pegjs), living in the [mini package](https://codeberg.org/uzu/strudel/src/branch/main/packages/mini)
- it is based on [krill](https://github.com/Mdashdotdashn/krill) by Mdashdotdashn
- the peg grammar is used to generate a parser with [peggyjs](https://peggyjs.org/)
- the generated parser takes a mini notation string and outputs an AST
- the AST can then be used to construct a pattern using the regular Strudel API
-
-Here's an example AST:
-
-```json
-{
-  "type_": "pattern",
-  "arguments_": { "alignment": "h" },
-  "source_": [
-    {
-      "type_": "element", "source_": "c3",
-      "location_": { "start": { "offset": 1, "line": 1, "column": 2 }, "end": { "offset": 4, "line": 1, "column": 5 } }
-    },
-    {
-      "type_": "element",
-      "location_": { "start": { "offset": 4, "line": 1, "column": 5 }, "end": { "offset": 11, "line": 1, "column": 12 } }
-      "source_": {
-        "type_": "pattern", "arguments_": { "alignment": "h" },
-        "source_": [
-          {
-            "type_": "element", "source_": "e3",
-            "location_": { "start": { "offset": 5, "line": 1, "column": 6 }, "end": { "offset": 8, "line": 1, "column": 9 } }
-          },
-          {
-            "type_": "element", "source_": "g3",
-            "location_": { "start": { "offset": 8, "line": 1, "column": 9 }, "end": { "offset": 10, "line": 1, "column": 11 } }
-          }
-        ]
-      },
-    }
-  ]
-}
-```
-
-which translates to `seq(c3, seq(e3, g3))`
-
-## 2. Querying & Scheduling
-
-When the user code has been evaluated, we hopefully get a Pattern instance, which we can use to query events from. 
-These events can then be used to trigger side effects in the real world. On that note, Events are mostly called Hap(s) in the codebase, because JS already has a built in `Event` class.
-
-### Querying
-
-> Querying = Asking a Pattern for Events within a certain time span
-
-```js
-seq('c3', ['e3', 'g3']) // <--- Pattern
-  .queryArc(0, 2) // query events within 0 and 2 cycles
-  .map((hap) => hap.showWhole()); // make readable
-```
-
-yields 
-
-```js
-[
-  '0/1 -> 1/2: c3', // cycle 0
-  '1/2 -> 3/4: e3',
-  '3/4 -> 1/1: g3',
-  '1/1 -> 3/2: c3', // cycle 1
-  '3/2 -> 7/4: e3',
-  '7/4 -> 2/1: g3',
-];
-```
-
-### 🗓️ Scheduling
-
-The scheduler will query events repeatedly, creating a possibly endless loop of time slices.
-Here is a simplified example of how it works 
-
-```js
-let step = 0.5; // query interval in seconds
-let tick = 0; // how many intervals have passed
-let pattern = seq('c3', ['e3', 'g3']); // pattern from user
-setInterval(() => {
-  const events = pattern.queryArc(tick * step, ++tick * step);
-  events.forEach((event) => {
-    console.log(event.showWhole());
-    const o = getAudioContext().createOscillator();
-    o.frequency.value = getFreq(event.value);
-    o.start(event.whole.begin);
-    o.stop(event.whole.begin + event.duration);
-    o.connect(getAudioContext().destination);
-  });
-}, step * 1000); // query each "step" seconds
-```
-
-## 3. Sound Output
-
-The third and last step is to use the scheduled events to make sound. 
-Patterns are wrapped with param functions to compose different properties of the sound.
-
-```js
-note("[c2(3,8) [<eb2 g1> bb1]]") // sets frequency
-  .s("<sawtooth square>") // sound source
-  .gain(.5) // turn down volume
-  .cutoff(sine.range(200,1000).slow(4)) // modulated cutoff
-  .slow(2)
-  .out().logValues()`,
-  ]}
-/>
-```
-
-Here is an example Hap value with different properties:
-
-```js
-{ note: 'a4', s: 'sawtooth', gain: 0.5, cutoff: 267 }
-```
-<img src="https://codeberg.org/uzu/strudel/raw/branch/talk/talk/public/waa-nodes.png" width="600" />
-
-<div className="text-left">
-
- Patterns represent just values in time!
- Suitable for any time based output (music, visuals, movement, .. ?)
-
-### Supported Outputs
-
-At the time of writing this doc, the following outputs are supported:
-
- Web Audio API `.out()` see [/webaudio](https://codeberg.org/uzu/strudel/src/branch/main/packages/webaudio)
- MIDI `.midi()` see [/midi](https://codeberg.org/uzu/strudel/src/branch/main/packages/midi)
- OSC `.osc()` see [/osc](https://codeberg.org/uzu/strudel/src/branch/main/packages/osc)
- Serial `.serial()` see [/serial](https://codeberg.org/uzu/strudel/src/branch/main/packages/serial)
- Tone.js `.tone()` (deprecated?) [/tone](https://codeberg.org/uzu/strudel/src/branch/main/packages/tone)
- WebDirt `.webdirt()` (deprecated?) [/webdirt](https://codeberg.org/uzu/strudel/src/branch/main/packages/webdirt)
- Speech `.speak()` (experimental) part of [/core](https://codeberg.org/uzu/strudel/src/branch/main/packages/core)
-
-These could change, so make sure to check the [packages folder](https://codeberg.org/uzu/strudel/src/branch/main/packages).
@@ -1889,6 +1889,86 @@ exports[`runs examples > example "chunkBack" example index 0 1`] = `
 ]
 `;

+exports[`runs examples > example "chunkBackInto" example index 0 1`] = `
+[
+  "[ 0/1 → 1/16 | s:bd speed:2 bank:tr909 ]",
+  "[ 1/16 → 1/8 | s:sd speed:2 bank:tr909 ]",
+  "[ 1/8 → 3/16 | s:bd speed:2 bank:tr909 ]",
+  "[ 3/16 → 1/4 | s:sd speed:2 bank:tr909 ]",
+  "[ 1/4 → 3/8 | s:ht bank:tr909 ]",
+  "[ 3/8 → 1/2 | s:lt bank:tr909 ]",
+  "[ 1/2 → 5/8 | s:bd bank:tr909 ]",
+  "[ 3/4 → 7/8 | s:cp bank:tr909 ]",
+  "[ 7/8 → 1/1 | s:lt bank:tr909 ]",
+  "[ 1/1 → 9/8 | s:bd bank:tr909 ]",
+  "[ 9/8 → 5/4 | s:sd bank:tr909 ]",
+  "[ 5/4 → 21/16 | s:ht speed:2 bank:tr909 ]",
+  "[ 21/16 → 11/8 | s:lt speed:2 bank:tr909 ]",
+  "[ 11/8 → 23/16 | s:ht speed:2 bank:tr909 ]",
+  "[ 23/16 → 3/2 | s:lt speed:2 bank:tr909 ]",
+  "[ 3/2 → 13/8 | s:bd bank:tr909 ]",
+  "[ 7/4 → 15/8 | s:cp bank:tr909 ]",
+  "[ 15/8 → 2/1 | s:lt bank:tr909 ]",
+  "[ 2/1 → 17/8 | s:bd bank:tr909 ]",
+  "[ 17/8 → 9/4 | s:sd bank:tr909 ]",
+  "[ 9/4 → 19/8 | s:ht bank:tr909 ]",
+  "[ 19/8 → 5/2 | s:lt bank:tr909 ]",
+  "[ 5/2 → 41/16 | s:bd speed:2 bank:tr909 ]",
+  "[ 21/8 → 43/16 | s:bd speed:2 bank:tr909 ]",
+  "[ 11/4 → 23/8 | s:cp bank:tr909 ]",
+  "[ 23/8 → 3/1 | s:lt bank:tr909 ]",
+  "[ 3/1 → 25/8 | s:bd bank:tr909 ]",
+  "[ 25/8 → 13/4 | s:sd bank:tr909 ]",
+  "[ 13/4 → 27/8 | s:ht bank:tr909 ]",
+  "[ 27/8 → 7/2 | s:lt bank:tr909 ]",
+  "[ 7/2 → 29/8 | s:bd bank:tr909 ]",
+  "[ 15/4 → 61/16 | s:cp speed:2 bank:tr909 ]",
+  "[ 61/16 → 31/8 | s:lt speed:2 bank:tr909 ]",
+  "[ 31/8 → 63/16 | s:cp speed:2 bank:tr909 ]",
+  "[ 63/16 → 4/1 | s:lt speed:2 bank:tr909 ]",
+]
+`;
+
+exports[`runs examples > example "chunkInto" example index 0 1`] = `
+[
+  "[ 0/1 → 1/16 | s:bd speed:2 bank:tr909 ]",
+  "[ 1/16 → 1/8 | s:sd speed:2 bank:tr909 ]",
+  "[ 1/8 → 3/16 | s:bd speed:2 bank:tr909 ]",
+  "[ 3/16 → 1/4 | s:sd speed:2 bank:tr909 ]",
+  "[ 1/4 → 3/8 | s:ht bank:tr909 ]",
+  "[ 3/8 → 1/2 | s:lt bank:tr909 ]",
+  "[ 1/2 → 5/8 | s:bd bank:tr909 ]",
+  "[ 3/4 → 7/8 | s:cp bank:tr909 ]",
+  "[ 7/8 → 1/1 | s:lt bank:tr909 ]",
+  "[ 1/1 → 9/8 | s:bd bank:tr909 ]",
+  "[ 9/8 → 5/4 | s:sd bank:tr909 ]",
+  "[ 5/4 → 21/16 | s:ht speed:2 bank:tr909 ]",
+  "[ 21/16 → 11/8 | s:lt speed:2 bank:tr909 ]",
+  "[ 11/8 → 23/16 | s:ht speed:2 bank:tr909 ]",
+  "[ 23/16 → 3/2 | s:lt speed:2 bank:tr909 ]",
+  "[ 3/2 → 13/8 | s:bd bank:tr909 ]",
+  "[ 7/4 → 15/8 | s:cp bank:tr909 ]",
+  "[ 15/8 → 2/1 | s:lt bank:tr909 ]",
+  "[ 2/1 → 17/8 | s:bd bank:tr909 ]",
+  "[ 17/8 → 9/4 | s:sd bank:tr909 ]",
+  "[ 9/4 → 19/8 | s:ht bank:tr909 ]",
+  "[ 19/8 → 5/2 | s:lt bank:tr909 ]",
+  "[ 5/2 → 41/16 | s:bd speed:2 bank:tr909 ]",
+  "[ 21/8 → 43/16 | s:bd speed:2 bank:tr909 ]",
+  "[ 11/4 → 23/8 | s:cp bank:tr909 ]",
+  "[ 23/8 → 3/1 | s:lt bank:tr909 ]",
+  "[ 3/1 → 25/8 | s:bd bank:tr909 ]",
+  "[ 25/8 → 13/4 | s:sd bank:tr909 ]",
+  "[ 13/4 → 27/8 | s:ht bank:tr909 ]",
+  "[ 27/8 → 7/2 | s:lt bank:tr909 ]",
+  "[ 7/2 → 29/8 | s:bd bank:tr909 ]",
+  "[ 15/4 → 61/16 | s:cp speed:2 bank:tr909 ]",
+  "[ 61/16 → 31/8 | s:lt speed:2 bank:tr909 ]",
+  "[ 31/8 → 63/16 | s:cp speed:2 bank:tr909 ]",
+  "[ 63/16 → 4/1 | s:lt speed:2 bank:tr909 ]",
+]
+`;
+
 exports[`runs examples > example "clip" example index 0 1`] = `
 [
  "[ 0/1 → 1/4 | note:c s:piano clip:0.5 ]",
@@ -2505,6 +2585,19 @@ exports[`runs examples > example "delayfeedback" example index 0 1`] = `
 ]
 `;

+exports[`runs examples > example "delaysync" example index 0 1`] = `
+[
+  "[ 0/1 → 1/2 | s:bd delay:0.25 delaysync:0.125 ]",
+  "[ 1/2 → 1/1 | s:bd delay:0.25 delaysync:0.125 ]",
+  "[ 1/1 → 3/2 | s:bd delay:0.25 delaysync:0.25 ]",
+  "[ 3/2 → 2/1 | s:bd delay:0.25 delaysync:0.25 ]",
+  "[ 2/1 → 5/2 | s:bd delay:0.25 delaysync:0.375 ]",
+  "[ 5/2 → 3/1 | s:bd delay:0.25 delaysync:0.375 ]",
+  "[ 3/1 → 7/2 | s:bd delay:0.25 delaysync:0.625 ]",
+  "[ 7/2 → 4/1 | s:bd delay:0.25 delaysync:0.625 ]",
+]
+`;
+
 exports[`runs examples > example "delaytime" example index 0 1`] = `
 [
  "[ 0/1 → 1/2 | s:bd delay:0.25 delaytime:0.125 ]",
@@ -4391,6 +4484,35 @@ exports[`runs examples > example "inside" example index 0 1`] = `
 ]
 `;

+exports[`runs examples > example "into" example index 0 1`] = `
+[
+  "[ 0/1 → 1/8 | s:bd speed:2 ]",
+  "[ 1/8 → 1/4 | s:sd speed:2 ]",
+  "[ 1/4 → 3/8 | s:bd speed:2 ]",
+  "[ 3/8 → 1/2 | s:sd speed:2 ]",
+  "[ 1/2 → 3/4 | s:ht ]",
+  "[ 3/4 → 1/1 | s:lt ]",
+  "[ 1/1 → 9/8 | s:bd speed:2 ]",
+  "[ 9/8 → 5/4 | s:sd speed:2 ]",
+  "[ 5/4 → 11/8 | s:bd speed:2 ]",
+  "[ 11/8 → 3/2 | s:sd speed:2 ]",
+  "[ 3/2 → 7/4 | s:ht ]",
+  "[ 7/4 → 2/1 | s:lt ]",
+  "[ 2/1 → 17/8 | s:bd speed:2 ]",
+  "[ 17/8 → 9/4 | s:sd speed:2 ]",
+  "[ 9/4 → 19/8 | s:bd speed:2 ]",
+  "[ 19/8 → 5/2 | s:sd speed:2 ]",
+  "[ 5/2 → 11/4 | s:ht ]",
+  "[ 11/4 → 3/1 | s:lt ]",
+  "[ 3/1 → 25/8 | s:bd speed:2 ]",
+  "[ 25/8 → 13/4 | s:sd speed:2 ]",
+  "[ 13/4 → 27/8 | s:bd speed:2 ]",
+  "[ 27/8 → 7/2 | s:sd speed:2 ]",
+  "[ 7/2 → 15/4 | s:ht ]",
+  "[ 15/4 → 4/1 | s:lt ]",
+]
+`;
+
 exports[`runs examples > example "invert" example index 0 1`] = `
 [
  "[ 0/1 → 1/8 | s:bd ]",
@@ -5016,6 +5138,15 @@ exports[`runs examples > example "linger" example index 0 1`] = `
 ]
 `;

+exports[`runs examples > example "lock" example index 0 1`] = `
+[
+  "[ 0/1 → 1/1 | delay:{s:sd} lock:1 ]",
+  "[ 1/1 → 2/1 | delay:{s:sd} lock:1 ]",
+  "[ 2/1 → 3/1 | delay:{s:sd} lock:1 ]",
+  "[ 3/1 → 4/1 | delay:{s:sd} lock:1 ]",
+]
+`;
+
 exports[`runs examples > example "loop" example index 0 1`] = `
 [
  "[ 0/1 → 1/1 | s:casio loop:1 ]",
@@ -8450,6 +8581,35 @@ exports[`runs examples > example "seqPLoop" example index 0 1`] = `
 ]
 `;

+exports[`runs examples > example "setcpm" example index 0 1`] = `
+[
+  "[ 0/1 → 1/4 | s:bd bank:tr707 ]",
+  "[ 1/4 → 1/2 | s:bd bank:tr707 ]",
+  "[ 1/4 → 1/2 | s:sd bank:tr707 ]",
+  "[ 1/2 → 3/4 | s:bd bank:tr707 ]",
+  "[ 3/4 → 1/1 | s:bd bank:tr707 ]",
+  "[ 3/4 → 1/1 | s:sd bank:tr707 ]",
+  "[ 1/1 → 5/4 | s:bd bank:tr707 ]",
+  "[ 5/4 → 3/2 | s:bd bank:tr707 ]",
+  "[ 5/4 → 3/2 | s:sd bank:tr707 ]",
+  "[ 3/2 → 7/4 | s:bd bank:tr707 ]",
+  "[ 7/4 → 2/1 | s:bd bank:tr707 ]",
+  "[ 7/4 → 2/1 | s:sd bank:tr707 ]",
+  "[ 2/1 → 9/4 | s:bd bank:tr707 ]",
+  "[ 9/4 → 5/2 | s:bd bank:tr707 ]",
+  "[ 9/4 → 5/2 | s:sd bank:tr707 ]",
+  "[ 5/2 → 11/4 | s:bd bank:tr707 ]",
+  "[ 11/4 → 3/1 | s:bd bank:tr707 ]",
+  "[ 11/4 → 3/1 | s:sd bank:tr707 ]",
+  "[ 3/1 → 13/4 | s:bd bank:tr707 ]",
+  "[ 13/4 → 7/2 | s:bd bank:tr707 ]",
+  "[ 13/4 → 7/2 | s:sd bank:tr707 ]",
+  "[ 7/2 → 15/4 | s:bd bank:tr707 ]",
+  "[ 15/4 → 4/1 | s:bd bank:tr707 ]",
+  "[ 15/4 → 4/1 | s:sd bank:tr707 ]",
+]
+`;
+
 exports[`runs examples > example "shape" example index 0 1`] = `
 [
  "[ 0/1 → 1/8 | s:hh shape:0 ]",
@@ -97,6 +97,7 @@ const toneHelpersMocked = {
  '_pianoroll',
  '_spectrum',
  'markcss',
+  'p',
 ].forEach((mock) => {
  strudel.Pattern.prototype[mock] = function () {
    return this;
@@ -163,6 +164,7 @@ evalScope(
    loadCsound,
    loadcsound,
    setcps: id,
+    setcpm: id,
    Clock: {}, // whatever
  },
 );
@@ -42,6 +42,7 @@
    "@strudel/tonal": "workspace:*",
    "@strudel/transpiler": "workspace:*",
    "@strudel/webaudio": "workspace:*",
+    "@strudel/mondo": "workspace:*",
    "@strudel/xen": "workspace:*",
    "@supabase/supabase-js": "^2.48.1",
    "@tailwindcss/forms": "^0.5.10",
@@ -1,169 +0,0 @@
---
-// fetch all commits for just this page's path
-type Props = {
-  path: string;
-};
-const { path } = Astro.props as Props;
-const resolvedPath = `website/src/pages${path}.mdx`;
-const url = `https://api.github.com/repos/tidalcycles/strudel/commits?path=${resolvedPath}`;
-const commitsURL = `https://github.com/tidalcycles/strudel/commits/main/${resolvedPath}`;
-
-type Commit = {
-  author: {
-    id: string;
-    login: string;
-  };
-};
-
-async function getCommits(url: string) {
-  try {
-    const token = import.meta.env.SNOWPACK_PUBLIC_GITHUB_TOKEN ?? 'hello';
-    if (!token) {
-      throw new Error('Cannot find "SNOWPACK_PUBLIC_GITHUB_TOKEN" used for escaping rate-limiting.');
-    }
-
-    const auth = `Basic ${Buffer.from(token, 'binary').toString('base64')}`;
-
-    const res = await fetch(url, {
-      method: 'GET',
-      headers: {
-        Authorization: auth,
-        'User-Agent': 'astro-docs/1.0',
-      },
-    });
-
-    const data = await res.json();
-
-    if (!res.ok) {
-      throw new Error(
-        `Request to fetch commits failed. Reason: ${res.statusText}
-       Message: ${data.message}`,
-      );
-    }
-
-    return data as Commit[];
-  } catch (e) {
-    console.warn(`[error]  /src/components/AvatarList.astro 
-    ${(e as any)?.message ?? e}`);
-    return [] as Commit[];
-  }
-}
-
-function removeDups(arr: Commit[]) {
-  const map = new Map<string, Commit['author']>();
-  for (let item of arr) {
-    const author = item.author;
-    // Deduplicate based on author.id
-    //map.set(author.id, { login: author.login, id: author.id });
-    author && map.set(author.id, { login: author.login, id: author.id });
-  }
-
-  return [...map.values()];
-}
-
-const data = await getCommits(url);
-const unique = removeDups(data);
-const recentContributors = unique.slice(0, 3); // only show avatars for the 3 most recent contributors
-const additionalContributors = unique.length - recentContributors.length; // list the rest of them as # of extra contributors
---
-
-<!-- Thanks to @5t3ph for https://smolcss.dev/#smol-avatar-list! -->
-<div class="contributors px-4 mb-8">
-  <ul class="avatar-list" style={`--avatar-count: ${recentContributors.length}`}>
-    {
-      recentContributors.map((item) => (
-        <li>
-          <a href={`https://github.com/${item.login}`}>
-            <img
-              alt={`Contributor ${item.login}`}
-              title={`Contributor ${item.login}`}
-              width="64"
-              height="64"
-              src={`https://avatars.githubusercontent.com/u/${item.id}`}
-            />
-          </a>
-        </li>
-      ))
-    }
-  </ul>
-  {
-    additionalContributors > 0 && (
-      <span>
-        <a href={commitsURL}>{`and ${additionalContributors} additional contributor${
-          additionalContributors > 1 ? 's' : ''
-        }.`}</a>
-      </span>
-    )
-  }
-  {unique.length === 0 && <a href={commitsURL}>Contributors</a>}
-</div>
-
-<style>
-  .avatar-list {
-    --avatar-size: 2.5rem;
-    --avatar-count: 3;
-
-    display: grid;
-    list-style: none;
-    /* Default to displaying most of the avatar to
-  enable easier access on touch devices, ensuring
-  the WCAG touch target size is met or exceeded */
-    grid-template-columns: repeat(var(--avatar-count), max(44px, calc(var(--avatar-size) / 1.15)));
-    /* `padding` matches added visual dimensions of
-  the `box-shadow` to help create a more accurate
-  computed component size */
-    padding: 0.08em;
-    font-size: var(--avatar-size);
-  }
-
-  @media (any-hover: hover) and (any-pointer: fine) {
-    .avatar-list {
-      /* We create 1 extra cell to enable the computed 
-    width to match the final visual width */
-      grid-template-columns: repeat(calc(var(--avatar-count) + 1), calc(var(--avatar-size) / 1.75));
-    }
-  }
-
-  .avatar-list li {
-    width: var(--avatar-size);
-    height: var(--avatar-size);
-  }
-
-  .avatar-list li:hover ~ li a,
-  .avatar-list li:focus-within ~ li a {
-    transform: translateX(33%);
-  }
-
-  .avatar-list img,
-  .avatar-list a {
-    display: block;
-    border-radius: 50%;
-  }
-
-  .avatar-list a {
-    transition: transform 180ms ease-in-out;
-  }
-
-  .avatar-list img {
-    width: 100%;
-    height: 100%;
-    object-fit: cover;
-    background-color: #fff;
-    box-shadow: 0 0 0 0.05em #fff, 0 0 0 0.08em rgba(0, 0, 0, 0.15);
-  }
-
-  .avatar-list a:focus {
-    outline: 2px solid transparent;
-    /* Double-layer trick to work for dark and light backgrounds */
-    box-shadow: 0 0 0 0.08em var(--theme-accent), 0 0 0 0.12em white;
-  }
-
-  .contributors {
-    display: flex;
-    align-items: center;
-  }
-
-  .contributors > * + * {
-    margin-left: 0.75rem;
-  }
-</style>
@@ -82,7 +82,7 @@ export default function Search() {
            appId={ALGOLIA.appId}
            apiKey={ALGOLIA.apiKey}
            getMissingResultsUrl={({ query }) => {
-              return `https://github.com/tidalcycles/strudel/issues/new?title=Missing doc for ${query}`;
+              return `https://codeberg.org/uzu/strudel/issues/new?title=Missing%20doc%20for${encodeURIComponent(query)}`;
            }}
            transformItems={(items) => {
              return items.map((item) => {
@@ -18,5 +18,4 @@ currentPage = currentPage.endsWith('/') ? currentPage.slice(0, -1) : currentPage
 <nav aria-labelledby="grid-right" class="w-64 text-foreground">
  <TableOfContents client:media="(min-width: 50em)" headings={headings} currentPage={currentPage} />
  <MoreMenu editHref={githubEditUrl} />
-  <!-- <AvatarList path={currentPage} /> -->
 </nav>
@@ -81,6 +81,7 @@ export const SIDEBAR: Sidebar = {
      { text: 'Visual Feedback', link: 'learn/visual-feedback' },
      { text: 'Offline', link: 'learn/pwa' },
      { text: 'Patterns', link: 'technical-manual/patterns' },
+      { text: 'Mondo Notation', link: 'learn/mondo-notation' },
      { text: 'Music metadata', link: 'learn/metadata' },
      { text: 'CSound', link: 'learn/csound' },
      { text: 'Hydra', link: 'learn/hydra' },
@@ -30,6 +30,7 @@ export function MiniRepl({
  maxHeight,
  autodraw,
  drawTime,
+  mondo = false,
 }) {
  const code = tunes ? tunes[0] : tune;
  const id = useMemo(() => s4(), []);
@@ -85,6 +86,7 @@ export function MiniRepl({
      },
      beforeStart: () => audioReady,
      afterEval: ({ code }) => setVersionDefaultsFrom(code),
+      mondo,
    });
    // init settings
    editor.setCode(code);
@@ -168,9 +168,14 @@ Korrekt, der echte Vorteil dieser Schreibweise zeigt sich wenn du Elemente entfe

 </Box>

-**Tempo ändern mit `cpm`**
+**Tempo ändern mit `setcpm`**

-<MiniRepl client:visible tune={`sound("<bd hh rim hh>*8").cpm(90/4)`} punchcard />
+<MiniRepl
+  client:visible
+  tune={`setcpm(90/4)
+sound("<bd hh rim hh>*8")`}
+  punchcard
+/>

 <Box>

@@ -233,8 +238,9 @@ Bolero:

 <MiniRepl
  client:visible
-  tune={`sound("sd sd*3 sd sd*3 sd sd sd sd*3 sd sd*3 sd*3 sd*3")
-.cpm(10)`}
+  tune={`
+setcpm(10)
+sound("sd sd*3 sd sd*3 sd sd sd sd*3 sd sd*3 sd*3 sd*3")`}
  punchcard
 />

@@ -313,18 +319,23 @@ Das haben wir bisher gelernt:
 Die mit Apostrophen umgebene Mini-Notation benutzt man normalerweise in einer sogenannten Funktion.
 Die folgenden Funktionen haben wir bereits gesehen:

-| Name  | Description                            | Example                                                                 |
-| ----- | -------------------------------------- | ----------------------------------------------------------------------- |
-| sound | Spielt den Sound mit dem Namen         | <MiniRepl client:visible tune={`sound("bd sd")`} />                     |
-| bank  | Wählt die Soundbank / Drum Machine     | <MiniRepl client:visible tune={`sound("bd sd").bank("RolandTR909")`} /> |
-| cpm   | Tempo in **C**ycles **p**ro **M**inute | <MiniRepl client:visible tune={`sound("bd sd").cpm(90)`} />             |
-| n     | Sample Nummer                          | <MiniRepl client:visible tune={`n("0 1 4 2").sound("jazz")`} />         |
+| Name   | Description                            | Example                                                                 |
+| ------ | -------------------------------------- | ----------------------------------------------------------------------- |
+| sound  | Spielt den Sound mit dem Namen         | <MiniRepl client:visible tune={`sound("bd sd")`} />                     |
+| bank   | Wählt die Soundbank / Drum Machine     | <MiniRepl client:visible tune={`sound("bd sd").bank("RolandTR909")`} /> |
+| setcpm | Tempo in **C**ycles **p**ro **M**inute | <MiniRepl client:visible tune={`setcpm(90); sound("bd sd")`} />         |
+| n      | Sample Nummer                          | <MiniRepl client:visible tune={`n("0 1 4 2").sound("jazz")`} />         |

 ## Beispiele

 **Einfacher Rock Beat**

-<MiniRepl client:visible tune={`sound("bd sd, hh*4").bank("RolandTR505").cpm(100/2)`} punchcard />
+<MiniRepl
+  client:visible
+  tune={`setcpm(100/2)
+sound("bd sd, hh*4").bank("RolandTR505")`}
+  punchcard
+/>

 **Klassischer House**

@@ -339,7 +350,12 @@ Bestimmte Drum Patterns werden oft genreübergreifend wiederverwendet.

 We Will Rock you

-<MiniRepl client:visible tune={`sound("bd*2 cp").bank("RolandTR707").cpm(81/2)`} punchcard />
+<MiniRepl
+  client:visible
+  tune={`setcpm(81/2)
+sound("bd*2 cp").bank("RolandTR707")`}
+  punchcard
+/>

 **Yellow Magic Orchestra - Firecracker**

@@ -354,12 +370,13 @@ We Will Rock you

 <MiniRepl
  client:visible
-  tune={`sound(\`
+  tune={`setcpm(90/4)
+sound(\`
 [-  -  oh - ] [-  -  -  - ] [-  -  -  - ] [-  -  -  - ],
 [hh hh -  - ] [hh -  hh - ] [hh -  hh - ] [hh -  hh - ],
 [-  -  -  - ] [cp -  -  - ] [-  -  -  - ] [cp -  -  - ],
 [bd -  -  - ] [-  -  -  bd] [-  -  bd - ] [-  -  -  bd]
-\`).cpm(90/4)`}
+\`)`}
  punchcard
 />

@@ -367,12 +384,13 @@ We Will Rock you

 <MiniRepl
  client:visible
-  tune={`sound(\`
+  tune={`setcpm(88/4)
+sound(\`
 [-  -  -  - ] [-  -  -  - ] [-  -  -  - ] [-  -  oh:1 - ],
 [hh hh hh hh] [hh hh hh hh] [hh hh hh hh] [hh hh -  - ],
 [-  -  -  - ] [cp -  -  - ] [-  -  -  - ] [-  cp -  - ],
 [bd bd -  - ] [-  -  bd - ] [bd bd - bd ] [-  -  -  - ]
-\`).bank("RolandTR808").cpm(88/4)`}
+\`).bank("RolandTR808")`}
  punchcard
 />

@@ -380,11 +398,11 @@ We Will Rock you

 <MiniRepl
  client:visible
-  tune={`s(\`jazz*2, 
+  tune={`setcpm(100/2)
+s(\`jazz*2, 
 insect [crow metal] - -, 
 - space:4 - space:1,
- wind\`)
-.cpm(100/2)`}
+- wind\`)`}
  punchcard
 />

@@ -56,13 +56,13 @@ Diese Seite ist eine Auflistung aller im Workshop vorgestellten Funktionen.

 ## Pattern-Effekte

-| Name | Beschreibung                      | Beispiel                                                                            |
-| ---- | --------------------------------- | ----------------------------------------------------------------------------------- |
-| cpm  | Tempo in Cycles pro Minute        | <MiniRepl client:visible tune={`sound("bd sd").cpm(90)`} />                         |
-| fast | schneller                         | <MiniRepl client:visible tune={`sound("bd sd").fast(2)`} />                         |
-| slow | langsamer                         | <MiniRepl client:visible tune={`sound("bd sd").slow(2)`} />                         |
-| rev  | rückwärts                         | <MiniRepl client:visible tune={`n("0 2 4 6").scale("C:minor").rev()`} />            |
-| jux  | einen Stereo-Kanal modifizieren   | <MiniRepl client:visible tune={`n("0 2 4 6").scale("C:minor").jux(rev)`} />         |
-| add  | addiert Zahlen oder Noten         | <MiniRepl client:visible tune={`n("0 2 4 6".add("<0 1 2 1>")).scale("C:minor")`} /> |
-| ply  | jedes Element schneller machen    | <MiniRepl client:visible tune={`s("bd sd").ply("<1 2 3>")`} />                      |
-| off  | verzögert eine modifizierte Kopie | <MiniRepl client:visible tune={`s("bd sd, hh*4").off(1/8, x=>x.speed(2))`} />       |
+| Name   | Beschreibung                      | Beispiel                                                                            |
+| ------ | --------------------------------- | ----------------------------------------------------------------------------------- |
+| setcpm | Tempo in Cycles pro Minute        | <MiniRepl client:visible tune={`setcpm(90); sound("bd sd")`} />                     |
+| fast   | schneller                         | <MiniRepl client:visible tune={`sound("bd sd").fast(2)`} />                         |
+| slow   | langsamer                         | <MiniRepl client:visible tune={`sound("bd sd").slow(2)`} />                         |
+| rev    | rückwärts                         | <MiniRepl client:visible tune={`n("0 2 4 6").scale("C:minor").rev()`} />            |
+| jux    | einen Stereo-Kanal modifizieren   | <MiniRepl client:visible tune={`n("0 2 4 6").scale("C:minor").jux(rev)`} />         |
+| add    | addiert Zahlen oder Noten         | <MiniRepl client:visible tune={`n("0 2 4 6".add("<0 1 2 1>")).scale("C:minor")`} /> |
+| ply    | jedes Element schneller machen    | <MiniRepl client:visible tune={`s("bd sd").ply("<1 2 3>")`} />                      |
+| off    | verzögert eine modifizierte Kopie | <MiniRepl client:visible tune={`s("bd sd, hh*4").off(1/8, x=>x.speed(2))`} />       |
@@ -14,7 +14,7 @@ These pages will introduce you to [Strudel](https://strudel.cc/), a web-based [l

 # What is Strudel?

-[Strudel](https://strudel.cc/) is a version of [Tidal Cycles](https://tidalcycles.org) written in [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript), initiated by [Alex McLean](https://slab.org) and [Felix Roos](https://github.com/felixroos) in 2022.
+[Strudel](https://strudel.cc/) is a version of [Tidal Cycles](https://tidalcycles.org) written in [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript), initiated by [Alex McLean](https://slab.org) and [Felix Roos](https://froos.cc/) in 2022.
 Tidal Cycles, also known as Tidal, is a language for [algorithmic pattern](https://algorithmicpattern.org), and though it is most commonly used for [making music](https://tidalcycles.org/docs/showcase), it can be used for any kind of pattern making activity, including [weaving](https://www.youtube.com/watch?v=TfEmEsusXjU).

 Tidal was first implemented as a library written in the [Haskell](https://www.haskell.org/) functional programming language, and by itself it does not make any sound.
@@ -0,0 +1,178 @@
+---
+title: Mondo Notation
+layout: ../../layouts/MainLayout.astro
+---
+
+import { MiniRepl } from '../../docs/MiniRepl';
+import { JsDoc } from '../../docs/JsDoc';
+
+# Mondo Notation
+
+"Mondo Notation" is a new kind of notation that is similar to [Mini Notation](/learn/mini-notation/), but with enough abilities to make it work as a standalone pattern language.
+Here's an example:
+
+<MiniRepl
+  mondo
+  client:idle
+  tune={`$ note (c2 # euclid <3 6 3> <8 16>) # *2 
+  # s "sine" # add (note [0 <12 24>]*2)
+  # dec(sine # range .2 2) 
+  # room .5
+  # lpf (sine/3 # range 120 400)
+  # lpenv (rand # range .5 4)
+  # lpq (perlin # range 5 12 # * 2)
+  # dist 1 # fm 4 # fmh 5.01 # fmdecay <.1 .2>
+  # postgain .6 # delay .1 # clip 5
+
+$ s [bd bd bd bd] # bank tr909 # clip .5
+
+# ply <1 [1 [2 4]]>
+
+$ s oh\*4 # press # bank tr909 # speed.8
+
+# dec (<.02 .05>\*2 # add (saw/8 # range 0 1))
+
+`}
+/>
+
+## Mondo in the REPL
+
+For now, you can only use mondo in the repl like this:
+
+<MiniRepl client:idle tune={'mondo`s hh*8`'} />
+
+The rest of this site will only use the mondo notation itself.
+In the future, the REPL might get a way to use mondo notation directly.
+
+## Calling Functions
+
+Compared to Mini Notation, the most notable feature of Mondo Notation is the ability to call functions using round brackets:
+
+<MiniRepl mondo client:idle tune={`(s hh*8)`} />
+
+The first element inside the brackets is the function name. In JS, this would look like:
+
+<MiniRepl client:idle tune={`s("hh*8")`} />
+
+The outermost parens are not needed, so we can drop them:
+
+<MiniRepl mondo client:idle tune={`s hh*8`} />
+
+## Mini Notation Features
+
+Besides function calling with round parens, Mondo Notation has a lot in common with Mini Notation:
+
+### Brackets
+
+- `[]` for 1-cycle sequences
+- `<>` for multi-cycle sequences
+- `{}` for stepped sequences (more on that later)
+
+### Infix Operators
+
+- \* => [fast](/learn/time-modifiers/#fast)
+- / => [slow](/learn/time-modifiers/#slow)
+- ! => [extend](/learn/stepwise/#extend)
+- @ => [expand](/learn/stepwise/#expand)
+- % => [pace](/learn/stepwise/#pace)
+- ? => [degradeBy](/learn/random-modifiers/#degradeby) (currently requires right operand)
+- : => tail (creates a list)
+- .. => range (between numbers)
+- , => [stack](/learn/factories/#stack)
+- | => [chooseIn](/learn/random-modifiers/#choose)
+
+### Example
+
+<MiniRepl
+  mondo
+  client:idle
+  tune={`note <
+[e5 [b4 c5] d5 [c5 b4]]
+[a4 [a4 c5] e5 [d5 c5]]
+[b4 [~ c5] d5 e5]
+[c5 a4 a4 ~]
+[[~ d5] [~ f5] a5 [g5 f5]]
+[e5 [~ c5] e5 [d5 c5]]
+[b4 [b4 c5] d5 e5]
+[c5 a4 a4 ~]
+>`}
+/>
+
+## Chaining Functions
+
+Similar to how "." works in javascript (JS), we can chain functions calls with the "#" operator:
+
+<MiniRepl
+  mondo
+  client:idle
+  tune={`n <0 2 4 [3 1] -1>*4 
+ # scale C4:minor 
+ # jux rev 
+ # dec .2
+ # delay .5`}
+/>
+
+Here's the same written in JS:
+
+<MiniRepl
+  client:idle
+  tune={`n("<0 2 4 [3 1] -1>*4")
+ .scale("C4:minor")
+ .jux(rev)
+ .dec(.2)
+ .delay(.5)`}
+/>
+
+### Chaining Functions Locally
+
+A function can be applied to a single element by wrapping it in round parens:
+
+<MiniRepl mondo client:idle tune={`s [bd hh bd (cp # delay .6)] # bank tr909`} />
+
+in this case, `delay .6` will only be applied to `cp`. compare this with the JS version:
+
+<MiniRepl client:idle tune={`s(seq("bd", "hh", "bd", "cp".delay(.6))).bank('tr909')`} />
+
+here we can see how much we can save when there's no boundary between mini notation and function calls!
+
+### Chaining Infix Operators
+
+Infix operators exist as regular functions, so they can be chained as well:
+
+<MiniRepl client:idle mondo tune={`s [bd hh] # bank tr909 # *2`} />
+
+In this case, the \*2 will be applied to the whole pattern.
+
+### Lambda Functions
+
+Some functions in strudel expect a function as input, for example:
+
+<MiniRepl client:idle tune={`n("0 .. 7").scale("C:minor").sometimes(x=>x.dec(.1))`} />
+
+in mondo, the `x=>x.` can be shortened to:
+
+<MiniRepl client:idle mondo tune={`n 0..7 # scale C:minor # sometimes (# dec .1)`} />
+
+chaining works as expected:
+
+<MiniRepl client:idle mondo tune={`n 0..7 # scale C:minor # sometimes (# dec .1 # jux rev)`} />
+
+## Strings
+
+You can use "double quotes" and 'single quotes' to get a string:
+
+<MiniRepl client:idle mondo tune={`n 0..7 # scale 'C minor'`} />
+
+## Multiple Patterns
+
+The `$` sign can be used to separate multiple patterns:
+
+<MiniRepl
+  client:idle
+  mondo
+  tune={`$ s [bd rim [~ bd] rim] # bank tr707
+$ chord <Dm9!3 Db7> # voicing
+  # struct[x ~ ~ x ~ x ~ ~] # delay .5`}
+/>
+
+The `$` sign is an alias for `,` so it will create a stack behind the scenes.
@@ -247,15 +247,17 @@ We can also declare different samples for different regions of the keyboard:

 <MiniRepl
  client:idle
-  tune={`samples({
+  tune={`setcpm(60)
+samples({
  'moog': {
    'g2': 'moog/004_Mighty%20Moog%20G2.wav',
    'g3': 'moog/005_Mighty%20Moog%20G3.wav',
    'g4': 'moog/006_Mighty%20Moog%20G4.wav',
-  }}, 'github:tidalcycles/dirt-samples');
+  }}, 'github:tidalcycles/dirt-samples')
+
 note("g2!2 <bb2 c3>!2, <c4@3 [<eb4 bb3> g4 f4]>")
-  .s('moog').clip(1)
-  .gain(.5).cpm(60)`}
+.s('moog').clip(1)
+.gain(.5)`}
 />

 The sampler will always pick the closest matching sample for the current note!
@@ -43,21 +43,33 @@ This is why the same CPS can produce different perceived tempos.

 ## Setting CPM

-If you're familiar with BPM, you can use the `cpm` method to set the tempo in cycles per minute:
+If you're familiar with BPM, you can use the `setcpm` method to set the global tempo in cycles per minute:

-<MiniRepl client:visible tune={`s("bd hh").cpm(110)`} />
+<MiniRepl
+  client:visible
+  tune={`setcpm(110)
+s("bd hh")`}
+/>

 If you want to add more beats per cycle, you might want to divide the cpm:

-<MiniRepl client:visible tune={`s("bd sd bd rim, hh*8").cpm(110/4)`} />
+<MiniRepl
+  client:visible
+  tune={`setcpm(110/4)
+s("bd sd bd rim, hh*8")`}
+/>

 Or using 2 beats per cycle:

-<MiniRepl client:visible tune={`s("bd sd, hh*4").cpm(110/2)`} />
+<MiniRepl
+  client:visible
+  tune={`setcpm(110/2)
+s("bd sd, hh*4")`}
+/>

 <Box>

-To set a specific bpm, use `.cpm(bpm/bpc)`
+To set a specific bpm, use `setcpm(bpm/bpc)`

 - bpm: the target beats per minute
 - bpc: the number of perceived beats per cycle
@@ -74,22 +86,31 @@ Many music programs use it as a default.
 Strudel does not a have concept of bars or measures, there are only cycles.
 How you use them is up to you. Above, we've had this example:

-<MiniRepl client:visible tune={`s("bd sd bd rim, hh*8").cpm(110/4)`} />
+<MiniRepl
+  client:visible
+  tune={`setcpm(110/4)
+s("bd sd bd rim, hh*8")`}
+/>

 This could be interpreted as 4/4 time with a tempo of 110bpm.
 We could write out multiple bars like this:

 <MiniRepl
  client:visible
-  tune={`s(\`<
+  tune={`setcpm(110/4)
+s(\`<
 [bd sd bd rim, hh*8] 
 [bd sd bd rim*2, hh*8]
->\`).cpm(110/4)`}
+>\`)`}
 />

 Instead of writing out each bar separately, we could express this much shorter:

-<MiniRepl client:visible tune={`s("bd <sd rim*<1 2>>,hh*4").cpm(110/2)`} />
+<MiniRepl
+  client:visible
+  tune={`setcpm(110/2)
+s("bd <sd rim*<1 2>>,hh*4")`}
+/>

 Here we can see that thinking in cycles rather than bars simplifies things a lot!
 These types of simplifications work because of the repetitive nature of rhythm.
@@ -109,10 +130,11 @@ We could also write multiple bars with different time signatures:

 <MiniRepl
  client:visible
-  tune={`s(\`<
+  tune={`setcpm(110*2)
+s(\`<
 [bd hh rim]@3
 [bd hh rim sd]@4
->\`).cpm(110*2)`}
+>\`)`}
 />

 Here we switch between 3/4 and 4/4, keeping the same tempo.
@@ -121,10 +143,11 @@ If we don't specify the length, we get what's called a metric modulation:

 <MiniRepl
  client:visible
-  tune={`s(\`<
+  tune={`setcpm(110/2)
+s(\`<
 [bd hh rim]
 [bd hh rim sd]
->\`).cpm(110/2)`}
+>\`)`}
 />

 Now the 3 elements get the same time as the 4 elements, which is why the tempo changes.
@@ -216,8 +216,9 @@ Finding the right notes can be difficult.. Scales are here to help:

 <MiniRepl
  client:visible
-  tune={`n("0 2 4 <[6,8] [7,9]>")
-.scale("C:minor").sound("piano").cpm(60)`}
+  tune={`setcpm(60)
+n("0 2 4 <[6,8] [7,9]>")
+.scale("C:minor").sound("piano")`}
  punchcard
 />

@@ -242,9 +243,10 @@ Just like anything, we can automate the scale with a pattern:

 <MiniRepl
  client:visible
-  tune={`n("<0 -3>, 2 4 <[6,8] [7,9]>")
+  tune={`setcpm(60)
+n("<0 -3>, 2 4 <[6,8] [7,9]>")
 .scale("<C:major D:mixolydian>/4")
-.sound("piano").cpm(60)`}
+.sound("piano")`}
  punchcard
 />

@@ -275,9 +277,10 @@ Try changing that number!

 <MiniRepl
  client:visible
-  tune={`n("<[4@2 4] [5@2 5] [6@2 6] [5@2 5]>*2")
+  tune={`setcpm(60)
+n("<[4@2 4] [5@2 5] [6@2 6] [5@2 5]>*2")
 .scale("<C2:mixolydian F2:mixolydian>/4")
-.sound("gm_acoustic_bass").cpm(60)`}
+.sound("gm_acoustic_bass")`}
  punchcard
 />

@@ -291,7 +294,12 @@ This is also sometimes called triplet swing. You'll often find it in blues and j

 **Replicate**

-<MiniRepl client:visible tune={`note("c!2 [eb,<g a bb a>]").sound("piano").cpm(60)`} punchcard />
+<MiniRepl
+  client:visible
+  tune={`setcpm(60)
+note("c!2 [eb,<g a bb a>]").sound("piano")`}
+  punchcard
+/>

 <Box>

@@ -166,9 +166,14 @@ Try also changing the number at the end to change the tempo!

 </Box>

-**changing the tempo with cpm**
+**changing the tempo with setcpm**

-<MiniRepl client:visible tune={`sound("<bd hh rim hh>*8").cpm(90/4)`} punchcard />
+<MiniRepl
+  client:visible
+  tune={`setcpm(90/4)
+sound("<bd hh rim hh>*8")`}
+  punchcard
+/>

 <Box>

@@ -283,12 +288,12 @@ This is what we've learned so far:

 The Mini-Notation is usually used inside some function. These are the functions we've seen so far:

-| Name  | Description                         | Example                                                                           |
-| ----- | ----------------------------------- | --------------------------------------------------------------------------------- |
-| sound | plays the sound of the given name   | <MiniRepl client:visible tune={`sound("bd sd [- bd] sd")`} />                     |
-| bank  | selects the sound bank              | <MiniRepl client:visible tune={`sound("bd sd [- bd] sd").bank("RolandTR909")`} /> |
-| cpm   | sets the tempo in cycles per minute | <MiniRepl client:visible tune={`sound("bd sd [- bd] sd").cpm(45)`} />             |
-| n     | select sample number                | <MiniRepl client:visible tune={`n("0 1 4 2 0 6 3 2").sound("jazz")`} />           |
+| Name   | Description                         | Example                                                                           |
+| ------ | ----------------------------------- | --------------------------------------------------------------------------------- |
+| sound  | plays the sound of the given name   | <MiniRepl client:visible tune={`sound("bd sd [- bd] sd")`} />                     |
+| bank   | selects the sound bank              | <MiniRepl client:visible tune={`sound("bd sd [- bd] sd").bank("RolandTR909")`} /> |
+| setcpm | sets the tempo in cycles per minute | <MiniRepl client:visible tune={`setcpm(45); sound("bd sd [- bd] sd")`} />         |
+| n      | select sample number                | <MiniRepl client:visible tune={`n("0 1 4 2 0 6 3 2").sound("jazz")`} />           |

 ## Examples

@@ -296,8 +301,8 @@ The Mini-Notation is usually used inside some function. These are the functions

 <MiniRepl
  client:visible
-  tune={`sound("[bd sd]*2, hh*8").bank("RolandTR505")
-.cpm(100/4)`}
+  tune={`setcpm(100/4)
+sound("[bd sd]*2, hh*8").bank("RolandTR505")`}
  punchcard
 />

@@ -314,14 +319,20 @@ Certain drum patterns are reused across genres.

 We Will Rock you

-<MiniRepl client:visible tune={`sound("bd*2 cp").bank("RolandTR707").cpm(81/2)`} punchcard />
+<MiniRepl
+  client:visible
+  tune={`setcpm(81/2)
+sound("bd*2 cp").bank("RolandTR707")`}
+  punchcard
+/>

 **Yellow Magic Orchestra - Firecracker**

 <MiniRepl
  client:visible
-  tune={`sound("bd sd, - - - hh - hh - -, - perc - perc:1*2")
-  .bank("RolandCompurhythm1000").cpm(120/2)`}
+  tune={`setcpm(120/2)
+sound("bd sd, - - - hh - hh - -, - perc - perc:1*2")
+.bank("RolandCompurhythm1000")`}
  punchcard
 />

@@ -329,12 +340,14 @@ We Will Rock you

 <MiniRepl
  client:visible
-  tune={`sound(\`
+  tune={`
+setcpm(90/4)
+sound(\`
 [-  -  oh - ] [-  -  -  - ] [-  -  -  - ] [-  -  -  - ],
 [hh hh -  - ] [hh -  hh - ] [hh -  hh - ] [hh -  hh - ],
 [-  -  -  - ] [cp -  -  - ] [-  -  -  - ] [cp -  -  - ],
 [bd -  -  - ] [-  -  -  bd] [-  -  bd - ] [-  -  -  bd]
-\`).cpm(90/4)`}
+\`)`}
  punchcard
 />

@@ -342,12 +355,13 @@ We Will Rock you

 <MiniRepl
  client:visible
-  tune={`sound(\`
+  tune={`setcpm(88/4)
+sound(\`
 [-  -  -  - ] [-  -  -  - ] [-  -  -  - ] [-  -  oh:1 - ],
 [hh hh hh hh] [hh hh hh hh] [hh hh hh hh] [hh hh -  - ],
 [-  -  -  - ] [cp -  -  - ] [-  -  -  - ] [~  cp -  - ],
 [bd bd -  - ] [-  -  bd - ] [bd bd - bd ] [-  -  -  - ]
-\`).bank("RolandTR808").cpm(88/4)`}
+\`).bank("RolandTR808")`}
  punchcard
 />

@@ -355,11 +369,11 @@ We Will Rock you

 <MiniRepl
  client:visible
-  tune={`s(\`jazz*2, 
+  tune={`setcpm(100/2)
+s(\`jazz*2, 
 insect [crow metal] - -, 
 - space:4 - space:1,
- wind\`)
-.cpm(100/2)`}
+- wind\`)`}
  punchcard
 />

@@ -68,9 +68,10 @@ Try commenting out one or more by adding `//` before a line

 <MiniRepl
  client:visible
-  tune={`note("c2 [eb3,g3] ".add("<0 <1 -1>>"))
+  tune={`setcpm(60)
+note("c2 [eb3,g3] ".add("<0 <1 -1>>"))
 .color("<cyan <magenta yellow>>").adsr("[.1 0]:.2:[1 0]")
-.sound("gm_acoustic_bass").room(.5).cpm(60)`}
+.sound("gm_acoustic_bass").room(.5)`}
  punchcard
 />

@@ -84,9 +85,10 @@ We can add as often as we like:

 <MiniRepl
  client:visible
-  tune={`note("c2 [eb3,g3]".add("<0 <1 -1>>").add("0,7"))
+  tune={`setcpm(60)
+note("c2 [eb3,g3]".add("<0 <1 -1>>").add("0,7"))
 .color("<cyan <magenta yellow>>").adsr("[.1 0]:.2:[1 0]")
-.sound("gm_acoustic_bass").room(.5).cpm(60)`}
+.sound("gm_acoustic_bass").room(.5)`}
  punchcard
 />

@@ -56,13 +56,13 @@ This page is just a listing of all functions covered in the workshop!

 ## Pattern Effects

-| name | description                         | example                                                                             |
-| ---- | ----------------------------------- | ----------------------------------------------------------------------------------- |
-| cpm  | sets the tempo in cycles per minute | <MiniRepl client:visible tune={`sound("bd sd [~ bd] sd").cpm(45)`} />               |
-| fast | speed up                            | <MiniRepl client:visible tune={`sound("bd sd [~ bd] sd").fast(2)`} />               |
-| slow | slow down                           | <MiniRepl client:visible tune={`sound("bd sd [~ bd] sd").slow(2)`} />               |
-| rev  | reverse                             | <MiniRepl client:visible tune={`n("0 2 4 6").scale("C:minor").rev()`} />            |
-| jux  | split left/right, modify right      | <MiniRepl client:visible tune={`n("0 2 4 6").scale("C:minor").jux(rev)`} />         |
-| add  | add numbers / notes                 | <MiniRepl client:visible tune={`n("0 2 4 6".add("<0 1 2 1>")).scale("C:minor")`} /> |
-| ply  | speed up each event n times         | <MiniRepl client:visible tune={`s("bd sd").ply("<1 2 3>")`} />                      |
-| off  | copy, shift time & modify           | <MiniRepl client:visible tune={`s("bd sd, hh*4").off(1/8, x=>x.speed(2))`} />       |
+| name   | description                         | example                                                                             |
+| ------ | ----------------------------------- | ----------------------------------------------------------------------------------- |
+| setcpm | sets the tempo in cycles per minute | <MiniRepl client:visible tune={`setcpm(45); sound("bd sd [~ bd] sd")`} />           |
+| fast   | speed up                            | <MiniRepl client:visible tune={`sound("bd sd [~ bd] sd").fast(2)`} />               |
+| slow   | slow down                           | <MiniRepl client:visible tune={`sound("bd sd [~ bd] sd").slow(2)`} />               |
+| rev    | reverse                             | <MiniRepl client:visible tune={`n("0 2 4 6").scale("C:minor").rev()`} />            |
+| jux    | split left/right, modify right      | <MiniRepl client:visible tune={`n("0 2 4 6").scale("C:minor").jux(rev)`} />         |
+| add    | add numbers / notes                 | <MiniRepl client:visible tune={`n("0 2 4 6".add("<0 1 2 1>")).scale("C:minor")`} /> |
+| ply    | speed up each event n times         | <MiniRepl client:visible tune={`s("bd sd").ply("<1 2 3>")`} />                      |
+| off    | copy, shift time & modify           | <MiniRepl client:visible tune={`s("bd sd, hh*4").off(1/8, x=>x.speed(2))`} />       |
@@ -21,7 +21,11 @@ export function Reference() {
        return true;
      }

-      return entry.name.includes(search) || (entry.synonyms?.some((s) => s.includes(search)) ?? false);
+      const lowCaseSearch = search.toLowerCase();
+      return (
+        entry.name.toLowerCase().includes(lowCaseSearch) ||
+        (entry.synonyms?.some((s) => s.includes(lowCaseSearch)) ?? false)
+      );
    });
  }, [search]);

@@ -70,7 +74,7 @@ export function Reference() {
              <ul>
                {entry.params?.map(({ name, type, description }, i) => (
                  <li key={i}>
-                    {name} : {type.names?.join(' | ')} {description ? <> - {getInnerText(description)}</> : ''}
+                    {name} : {type?.names?.join(' | ')} {description ? <> - {getInnerText(description)}</> : ''}
                  </li>
                ))}
              </ul>
@@ -20,7 +20,7 @@ export function WelcomeTab({ context }) {
      </p>
      <p>
        {/* To learn more about what this all means, check out the{' '} */}
-        To get started, check out the
+        To get started, check out the{' '}
        <a href={`${baseNoTrailing}/workshop/getting-started/`} target="_blank">
          interactive tutorial
        </a>
@@ -42,8 +42,8 @@ export function WelcomeTab({ context }) {
          GNU Affero General Public License
        </a>
        . You can find the source code at{' '}
-        <a href="https://github.com/tidalcycles/strudel" target="_blank">
-          github
+        <a href="https://codeberg.org/uzu/strudel" target="_blank">
+          codeberg
        </a>
        . You can also find <a href="https://github.com/felixroos/dough-samples/blob/main/README.md">licensing info</a>{' '}
        for the default sound banks there. Please consider to{' '}
@@ -69,32 +69,32 @@ stack(

 export const giantSteps = `// John Coltrane - Giant Steps

-let melody = note(
+let melody = seq(
  "[F#5 D5] [B4 G4] Bb4 [B4 A4]",
  "[D5 Bb4] [G4 Eb4] F#4 [G4 F4]",
  "Bb4 [B4 A4] D5 [D#5 C#5]",
  "F#5 [G5 F5] Bb5 [F#5 F#5]",
-)
+).note()

 stack(
  // melody
  melody.color('#F8E71C'),
  // chords
-  chord(
+  seq(
    "[B^7 D7] [G^7 Bb7] Eb^7 [Am7 D7]",
    "[G^7 Bb7] [Eb^7 F#7] B^7 [Fm7 Bb7]",
    "Eb^7 [Am7 D7] G^7 [C#m7 F#7]",
    "B^7 [Fm7 Bb7] Eb^7 [C#m7 F#7]"
-  ).dict('lefthand')
+  ).chord().dict('lefthand')
  .anchor(melody).mode('duck')
  .voicing().color('#7ED321'),
  // bass
-  note(
+  seq(
    "[B2 D2] [G2 Bb2] [Eb2 Bb3] [A2 D2]",
    "[G2 Bb2] [Eb2 F#2] [B2 F#2] [F2 Bb2]",
    "[Eb2 Bb2] [A2 D2] [G2 D2] [C#2 F#2]",
    "[B2 F#2] [F2 Bb2] [Eb2 Bb3] [C#2 F#2]"
-  ).color('#00B8D4')
+  ).note().color('#00B8D4')
 ).slow(20)
 .pianoroll({fold:1})`;

@@ -313,26 +313,6 @@ stack(
 )
  .fast(2/3)
  .pianoroll()`;
-/* 
-export const bridgeIsOver = `// "Bridge is over"
-// @license CC BY-NC-SA 4.0 https://creativecommons.org/licenses/by-nc-sa/4.0/
-// @by Felix Roos, bassline by BDP - The Bridge Is Over
-
-samples({mad:'https://freesound.org/data/previews/22/22274_109943-lq.mp3'})
-stack(
-  stack(
-  note("c3*2 [[c3@1.4 bb2] ab2] gb2*2 <[[gb2@1.4 ab2] bb2] gb2>")
-    .gain(.8).clip("[.5 1]*2"),
-  n("<0 1 2 3 4 3 2 1>")
-    .clip(.5)
-    .echoWith(8, 1/32, (x,i)=>x.add(n(i)).velocity(Math.pow(.7,i)))
-    .scale('c4 whole tone')
-    .echo(3, 1/8, .5)
-  ).piano(),
-  s("mad").slow(2)
-).cpm(78).slow(4)
-  .pianoroll()
-`; */

 export const goodTimes = `// "Good times"
 // @license CC BY-NC-SA 4.0 https://creativecommons.org/licenses/by-nc-sa/4.0/
@@ -84,6 +84,7 @@ export function loadModules() {
    import('@strudel/gamepad'),
    import('@strudel/motion'),
    import('@strudel/mqtt'),
+    import('@strudel/mondo'),
  ];
  if (isTauri()) {
    modules = modules.concat([
Author	SHA1	Message	Date
Jade (Rose) Rowland	77bab433e0	cf	2025-06-28 14:06:16 -04:00
daslyfe	f8cc1c2022	Merge branch 'main' into daslyfe/jade/delaycycle	2025-06-28 20:01:57 +02:00
froos	e0bf9ea4d6	Merge pull request 'Case insensitive search in the reference tab' (#1420 ) from kdiab/strudel:main into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1420	2025-06-28 13:44:47 +02:00
Alex McLean	374661eb23	Merge pull request 'add unjoin, into and chunkinto' (#1418 ) from add-unjoin into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1418	2025-06-28 00:04:12 +02:00
alex	df06248c54	snapshot	2025-06-27 22:59:01 +01:00
alex	27073d6c17	format	2025-06-27 22:56:19 +01:00
alex	f44caf9096	tests and tweaks, and add chunkBackInto	2025-06-27 22:51:47 +01:00
alex	ff5b11f5ed	test + bugfix for chunkinto	2025-06-27 22:44:15 +01:00
Alex McLean	719c70a598	Merge branch 'main' into add-unjoin	2025-06-27 22:40:40 +02:00
Jade (Rose) Rowland	7a53f6c021	add test	2025-06-27 15:56:37 -04:00
Jade (Rose) Rowland	09d05abd70	delaysync	2025-06-27 15:54:39 -04:00
Jade (Rose) Rowland	3acc364a03	Merge branch 'main' into daslyfe/jade/delaycycle	2025-06-27 15:53:48 -04:00
Felix Roos	b1aba294ad	hotfix: fix upstream test	2025-06-26 15:39:35 +02:00
froos	63ac80eb79	Merge pull request 'mondo notation' (#1311 ) from uzu into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1311	2025-06-26 15:29:45 +02:00
Felix Roos	82e3f9b837	fix: js example	2025-06-26 14:59:24 +02:00
Khalid	e19fd24447	Case insensitive search in the reference tab	2025-06-25 08:44:12 -04:00
alex	fe9a91d1e4	add unjoin, into and chunkinto	2025-06-24 23:22:42 +01:00
froos	860bb58d61	Merge pull request 'allow calling `all` multiple times' (#1417 ) from multiple-all-calls into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1417	2025-06-24 06:14:15 +02:00
Felix Roos	d58b3e490b	fix: reset all transforms before eval	2025-06-24 06:12:21 +02:00
Felix Roos	0003ce174e	allow calling `all` multiple times	2025-06-24 06:06:37 +02:00
froos	8e0f23e081	Merge pull request 'tonal: allow scales without tonic (default to C)' (#1092 ) from kasparsj/tonal-fix into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1092	2025-06-24 05:53:21 +02:00
Felix Roos	71e60ed8de	add back comment	2025-06-24 05:45:36 +02:00
Felix Roos	e2a29914c7	don't interpret note as n	2025-06-24 05:43:06 +02:00
Felix Roos	a9a3d491a2	Merge branch 'main' into kasparsj/tonal-fix	2025-06-24 05:39:59 +02:00
yaxu	a750764f88	Update CONTRIBUTING.md	2025-06-23 11:13:00 +02:00
froos	5b397009ab	Merge pull request 'website intro: fix whitespace and code hosting name' (#1400 ) from trofi/strudel:website-intro-minor into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1400	2025-06-20 20:00:11 +02:00
Sergei Trofimovich	e68df9e789	website intro: fix whitespace and code hosting name	2025-06-20 18:33:58 +01:00
yaxu	4d3bbd5057	Update README.md	2025-06-19 17:44:45 +02:00
Felix Roos	15f3321b04	fix: extend in some situations, like [[bd]@3 bd]	2025-06-19 11:33:22 +02:00
froos	67bfedb317	Merge branch 'main' into uzu	2025-06-19 10:21:04 +02:00
Alex McLean	c0184dd827	Merge pull request 'fix stepcat #1396 ' (#1398 ) from fix-stepcat into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1398	2025-06-19 10:15:06 +02:00
Alex McLean	09fdc45ff2	Merge branch 'main' into fix-stepcat	2025-06-19 10:08:08 +02:00
alex	c01b4c651c	don't trash lists passed to timecat	2025-06-19 09:06:53 +01:00
froos	634eed1d82	Merge pull request 'deprecate cpm + refactor docs to use setcpm' (#1397 ) from reference-improvements into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1397	2025-06-19 09:52:36 +02:00
froos	01810f379f	Merge branch 'main' into reference-improvements	2025-06-19 09:47:01 +02:00
alex	f3c4afaa54	apt install zstd for caching	2025-06-19 08:42:33 +01:00
alex	a8757fecc8	avoid double action for PRs, try turning on pnpm cache	2025-06-19 08:39:05 +01:00
alex	a1d181d609	format	2025-06-19 08:27:41 +01:00
alex	440f1cb081	reify arguments of stepcat	2025-06-19 08:27:23 +01:00
alex	95193b0bfd	a test for #1396	2025-06-19 08:18:20 +01:00
Felix Roos	66673d211e	fix: cpm -> setcpm	2025-06-19 09:13:48 +02:00
Felix Roos	64ab3c9ba7	fix: tests	2025-06-19 09:12:05 +02:00
Felix Roos	6c4aa12c60	refactor: replace .cpm with setcpm calls + doc setcpm	2025-06-19 09:09:45 +02:00
daslyfe	a8f2537e31	Merge pull request 'feat: 3 new codemirror themes' (#1394 ) from jade/themes into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1394	2025-06-19 02:49:08 +02:00
Jade (Rose) Rowland	7e6876c282	comment	2025-06-18 20:44:09 -04:00
Felix Roos	1cc15c7e8d	fix: fall back to silence when empty removes annoying error	2025-06-18 22:25:05 +02:00
Felix Roos	10ac7c353c	use + and - as late / early + add some extra error handling	2025-06-18 22:07:16 +02:00
Felix Roos	9412bf60bf	add e as euclid that accepts a list	2025-06-18 22:06:18 +02:00
Felix Roos	c751bb7e5f	allow _ as silence	2025-06-18 21:36:34 +02:00
Felix Roos	28cd7c1681	Merge branch 'main' into uzu	2025-06-18 21:26:51 +02:00
Jade (Rose) Rowland	011139eff8	arch2	2025-06-18 20:12:36 +02:00
Jade (Rose) Rowland	184cb746f3	arch	2025-06-18 19:55:30 +02:00
alex	351314ccdf	rename .github to .forgejo	2025-06-15 09:23:29 +01:00
Felix Roos	e52017c0d8	fix: reference tab critical fail	2025-06-15 10:12:17 +02:00
alex	b253d437d3	Merge branch 'main' of ssh://codeberg.org/uzu/strudel	2025-06-15 08:06:12 +01:00
alex	bebbe30b50	codeformat	2025-06-15 08:03:23 +01:00
alex	489d3f8d4d	Merge branch 'reorganise-docs'	2025-06-15 08:01:44 +01:00
Felix Roos	ee7d783099	fix homepage link	2025-06-14 16:27:54 +02:00
Felix Roos	9becd0a3f0	Merge branch 'main' of https://codeberg.org/uzu/strudel	2025-06-14 16:23:36 +02:00
Felix Roos	9738c90b82	even more degithubbing	2025-06-14 16:23:03 +02:00
Alex McLean	f7b58f2e3e	Merge pull request 'link back to tech manual in wiki' (#1382 ) from techmanual-wiki into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1382	2025-06-14 16:22:59 +02:00
alex	d856e567c1	link back to tech manual in wiki	2025-06-14 15:22:27 +01:00
alex	1b3b07842e	format again..	2025-05-03 21:57:01 +01:00
alex	98efd72ab4	delint	2025-05-03 20:59:05 +01:00
alex	1eb5f6a995	format	2025-05-03 20:38:43 +01:00
alex	9b10dc8535	change pipe symbol from '.' to '#'	2025-05-03 20:37:44 +01:00
Felix Roos	2951a60fac	fix: rests at the end	2025-05-03 11:44:02 +02:00
Jade (Rose) Rowland	94257e81ee	lint	2025-05-02 23:44:55 -04:00
Jade (Rose) Rowland	006ce9d1da	delaytime	2025-05-02 23:33:58 -04:00
Felix Roos	607a6121bc	rename mondo package to mondolang	2025-05-02 16:20:23 +02:00
Felix Roos	4208c79c09	fix: ! and @ operators	2025-05-02 15:13:04 +02:00
Felix Roos	7565354274	superdough: fallback to triangle when non-string is given	2025-05-02 08:54:34 +02:00
Felix Roos	ffe831d24b	mondo: strings now get type "string" to be discernable from plain variables	2025-05-02 08:53:55 +02:00
Felix Roos	60dd8bd763	tweak again	2025-05-02 08:35:16 +02:00
Felix Roos	29e5833c8c	tweak	2025-05-02 08:32:46 +02:00
Felix Roos	e3a6444f41	mondo: support line comments	2025-05-02 08:30:09 +02:00
Felix Roos	30fd4c5dec	Merge branch 'main' into uzu	2025-05-02 08:16:52 +02:00
Felix Roos	2da03ab46f	Merge remote-tracking branch 'origin/main' into uzu	2025-05-01 11:15:24 +02:00
Felix Roos	243adda3dd	mondo: more sicp tests	2025-05-01 10:56:33 +02:00
Felix Roos	7fc21d55d7	mondo: rational number test	2025-04-04 10:04:22 +02:00
Felix Roos	d5ef686fe0	mondo: sicp 100	2025-04-04 00:45:00 +02:00
Felix Roos	d4733a30ab	mondo: add half interval method example	2025-04-03 17:30:03 +02:00
Felix Roos	989bd0990e	mondo: let expressions	2025-04-03 17:01:36 +02:00
Felix Roos	60d09adb44	mondo: more tests	2025-04-02 22:33:18 +02:00
Felix Roos	b2588e8c93	fix: lint	2025-04-02 22:11:06 +02:00
Felix Roos	39d2784441	mondo: more sicp tests + support special form for function def (might remove later) + support multiple expressions in fn body + support lexical scoping	2025-04-02 22:09:17 +02:00
Felix Roos	aa70246afc	mondo: more sicp	2025-04-01 23:24:47 +02:00
Felix Roos	f6ffdd6ae6	mondo: move +- to ops + add "raw" to parsed pairs + implement match + if + add more sicp examples	2025-04-01 22:31:42 +02:00
Felix Roos	077aac1888	mondo: add some examples from sicp book	2025-04-01 21:50:03 +02:00
Felix Roos	94a3a60e49	mondo: remember pair locations + allow passing a scope to MondoRunner.run + make def a side effect + proper lambda with multiple args + closure	2025-04-01 21:49:28 +02:00
Felix Roos	f2372e7a41	mondo: refactor evaluate function into bits	2025-03-30 17:55:37 +02:00
Felix Roos	a0fb8fb37f	mondo: def node	2025-03-30 11:43:01 +02:00
Felix Roos	b4027fd92a	fix: mondo dont mutate (breaks lambdas)	2025-03-30 11:42:50 +02:00
Felix Roos	c9cafa37fd	mondo: improve mondo package api + update readme	2025-03-29 21:33:51 +01:00
Felix Roos	2e017e46f9	trim readme	2025-03-29 20:17:09 +01:00
Felix Roos	c9f58220a3	remove minor change	2025-03-29 19:55:29 +01:00
Felix Roos	e9de45993e	signal: remove signal synonyms for now	2025-03-29 19:54:04 +01:00
Felix Roos	6b2b8b5124	fix: test	2025-03-26 09:30:49 +01:00
Felix Roos	64a6dacc1e	mondo: patternable function names	2025-03-26 09:27:02 +01:00
Felix Roos	1738e4d538	fix: lint	2025-03-26 03:55:54 +01:00
Felix Roos	abc7a1e48d	mondo: this is the way	2025-03-26 03:55:00 +01:00
Felix Roos	7716fdb98e	mondo: refactor - rename MondoRunner.call => .evaluate - can now evaluate leafs - remove .( because it's confusing and half baked - support (.) as id function	2025-03-26 03:22:23 +01:00
Felix Roos	2938bfd88f	mondo: add highly impractical .(. notation for local infix application	2025-03-26 02:46:26 +01:00
Felix Roos	222e479e30	mondo: more docs	2025-03-23 23:18:57 +01:00
Felix Roos	92b5b6538f	mondo: improve doc	2025-03-23 23:12:52 +01:00
Felix Roos	3a19e23473	mondo: doc	2025-03-23 22:49:56 +01:00
Felix Roos	dd5743ab8c	mondo: bring back $ for stacking	2025-03-23 22:49:23 +01:00
Felix Roos	51e3aa257c	mondolang function for mondo repl + fix rests	2025-03-23 22:49:03 +01:00
Felix Roos	5eabcf0618	mondo mode for StrudelMirror / repl / mini repl	2025-03-23 22:47:33 +01:00
Felix Roos	6d21456423	mondo: allow # character in plain values (for sharps)	2025-03-23 11:18:18 +01:00
Felix Roos	bca16cdf99	mondo: rename resolve_ -> desugar_	2025-03-22 23:51:23 +01:00
Felix Roos	492271d786	mondo: support $ tidal style	2025-03-22 23:28:57 +01:00
Felix Roos	f71db4aeed	mondo: flip pipe order: now pining to the end of the function...	2025-03-21 23:50:14 +01:00
Felix Roos	5d4ef46ac7	mondo cleanup	2025-03-21 22:43:39 +01:00
Felix Roos	bd93e44154	mondo: fix combination of \| and ,	2025-03-21 22:34:53 +01:00
Felix Roos	6fd89ddee7	mondo: add \| and ?	2025-03-21 11:10:43 +01:00
Felix Roos	cf1f4ec35c	fix: patterns without structure would error on draw	2025-03-21 11:10:25 +01:00
Felix Roos	12bb82d295	add chooseIn + chooseOut	2025-03-21 11:10:06 +01:00
Felix Roos	c33cfc78c5	waveform aliases: tri, sqr, saw, sin	2025-03-20 21:19:47 +01:00
Felix Roos	ac6472a43a	mondo: mondo as minilang (inactive)	2025-03-20 21:19:21 +01:00
Felix Roos	989fdfa20b	transpiler: add mechanism to register custom mini language	2025-03-20 21:18:32 +01:00
Felix Roos	05ae31838e	add sin sqr cos aliases	2025-03-20 18:01:41 +01:00
Felix Roos	c691916cbf	mondo: generic bracket names + simplify call handler + refactor mondough	2025-03-20 17:55:40 +01:00
Felix Roos	e16295623d	mondo: use stepcat for curly braces	2025-03-20 14:09:32 +01:00
Felix Roos	9626f3cc9a	mondo add % for pace	2025-03-20 13:24:31 +01:00
Felix Roos	432e8dcccc	mondo: support ! and @, also express seq and cat with stepcat	2025-03-20 13:15:48 +01:00
Felix Roos	d2e93a99f1	fix: lint	2025-03-20 10:24:22 +01:00
Felix Roos	3505732afa	mondo: add .. operator	2025-03-20 09:34:47 +01:00
Felix Roos	55a5f1d62a	transpiler cleanup	2025-03-20 09:10:54 +01:00
Felix Roos	3657e2fd65	mondo: change default markcss	2025-03-20 09:10:45 +01:00
Felix Roos	65a7b3030e	fix: markcss can now override styles (like color)	2025-03-20 09:10:12 +01:00
Felix Roos	208706fb52	simplify mondo: ":" is just another operator	2025-03-20 09:09:29 +01:00
Felix Roos	e04f250adb	mondo: proper lambda functions with local scope	2025-03-19 18:16:37 +01:00
Felix Roos	642ddcdb59	support : in mondo	2025-03-19 17:03:17 +01:00
Felix Roos	88ca54461e	rename @strudel/mondough to @strudel/mondo	2025-03-19 00:15:53 +01:00
Felix Roos	129fd7d6b0	add notes	2025-03-19 00:13:06 +01:00
Felix Roos	7db52b3dc2	mondo improvements: - add second string type - add $ as alias for stack - simplify leaf handling	2025-03-18 22:33:14 +01:00
Felix Roos	40f6489111	reify variables	2025-03-16 23:30:41 +01:00
Felix Roos	118b619b74	mondo: support - ~ in plain type + simplify errors	2025-03-16 23:10:52 +01:00
Felix Roos	2dd445c102	mondo: support variables	2025-03-16 23:10:23 +01:00
Felix Roos	3c3832dbce	superdough: native support for rest symbols - ~ in s	2025-03-16 23:08:31 +01:00
Felix Roos	9b8761bc45	fix: top-level functions arp/arpWith	2025-03-16 22:31:40 +01:00
Felix Roos	77ade0758e	mondo: slightly improve error handling	2025-03-16 22:07:03 +01:00
Felix Roos	902012759a	fix:support negative numbers	2025-03-16 21:24:22 +01:00
Felix Roos	ea61627963	fix: lint error	2025-03-16 21:05:04 +01:00
Felix Roos	95526ac99c	fix: formatting	2025-03-16 21:04:28 +01:00
Felix Roos	b0da353115	mondo highlighting	2025-03-16 21:04:05 +01:00
Felix Roos	fae59a6bcd	feat: add mondough package to run strudel via mondo	2025-03-16 10:49:18 +01:00
Felix Roos	11196fb1e6	breaking: refactor controls - multiple args wont be interpreted as sequence anymore - you can now pass value, pat to set value to pat	2025-03-16 10:48:38 +01:00
Felix Roos	e782dc09dd	export strudelScope for mondo to use	2025-03-16 10:47:32 +01:00
Felix Roos	e3df504423	rename uzu to mondo	2025-03-16 02:01:16 +01:00
Felix Roos	b71b1354c3	uzu: stacks now work within () + write more tests	2025-03-16 00:51:59 +01:00
Felix Roos	dbe3915368	fix: lint errors	2025-03-15 10:35:22 +01:00
Felix Roos	62705da3de	begin uzu package	2025-03-15 10:29:23 +01:00
Kaspars	81ca199a96	Merge branch 'upstream-main' into tonal-fix	2024-06-02 12:39:14 +03:00
Kaspars	8d8b8ab99e	codeformat	2024-05-08 10:42:06 +02:00
Kaspars	a4f10d5339	bug fix	2024-05-08 10:38:06 +02:00
Kaspars	33a73c37bc	fix tests	2024-05-08 00:46:27 +02:00
Kaspars	4e6d39666a	codeformat	2024-05-08 00:00:58 +02:00
Kaspars	a5b6022506	- fix scale() to allow both n() and note() at the same time - fix scale() to allow scale names without tonic and then default it to C	2024-05-07 23:56:39 +02:00