only add long lived functions to the composifyRegistry

packages/core/controls.mjs

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

packages/core/cyclist.mjs

@@ -10,49 +10,44 @@ import { logger } from './logger.mjs';
 export class Cyclist {
   constructor({ interval, onTrigger, onToggle, onError, getTime, latency = 0.1 }) {
     this.started = false;
-    this.cps = 1;
-    this.lastTick = 0; // absolute time when last tick (clock callback) happened
-    this.lastBegin = 0; // query begin of last tick
-    this.lastEnd = 0; // query end of last tick
-    this.getTime = getTime; // get absolute time
+    this.cps = 1; // TODO
+    this.phase = 0;
+    this.getTime = getTime;
     this.onToggle = onToggle;
-    this.latency = latency; // fixed trigger time offset
+    this.latency = latency;
     const round = (x) => Math.round(x * 1000) / 1000;
     this.clock = createClock(
       getTime,
-      // called slightly before each cycle
       (phase, duration, tick) => {
         if (tick === 0) {
           this.origin = phase;
         }
+        const begin = round(phase - this.origin);
+        this.phase = begin - latency;
+        const end = round(begin + duration);
+        const time = getTime();
         try {
-          const time = getTime();
-          const begin = this.lastEnd;
-          this.lastBegin = begin;
-          const end = round(begin + duration * this.cps);
-          this.lastEnd = end;
-          const haps = this.pattern.queryArc(begin, end);
-          const tickdeadline = phase - time; // time left till phase begins
-          this.lastTick = time + tickdeadline;
-
+          const haps = this.pattern.queryArc(begin, end); // get Haps
           haps.forEach((hap) => {
             if (hap.part.begin.equals(hap.whole.begin)) {
-              const deadline = (hap.whole.begin - begin) / this.cps + tickdeadline + latency;
-              const duration = hap.duration / this.cps;
-              onTrigger?.(hap, deadline, duration, this.cps);
+              const deadline = hap.whole.begin + this.origin - time + latency;
+              const duration = hap.duration * 1;
+              onTrigger?.(hap, deadline, duration);
             }
           });
         } catch (e) {
           logger(`[cyclist] error: ${e.message}`);
           onError?.(e);
         }
-      },
+      }, // called slightly before each cycle
       interval, // duration of each cycle
     );
   }
+  getPhase() {
+    return this.getTime() - this.origin - this.latency;
+  }
   now() {
-    const secondsSinceLastTick = this.getTime() - this.lastTick - this.clock.duration;
-    return this.lastBegin + secondsSinceLastTick * this.cps; // + this.clock.minLatency;
+    return this.getTime() - this.origin + this.clock.minLatency;
   }
   setStarted(v) {
     this.started = v;

packages/core/evaluate.mjs

@@ -6,7 +6,12 @@ This program is free software: you can redistribute it and/or modify it under th
 
 import { isPattern } from './index.mjs';
 
+let scoped = false;
 export const evalScope = async (...args) => {
+  if (scoped) {
+    console.warn('evalScope was called more than once.');
+  }
+  scoped = true;
   const results = await Promise.allSettled(args);
   const modules = results.filter((result) => result.status === 'fulfilled').map((r) => r.value);
   results.forEach((result, i) => {
@@ -37,6 +42,9 @@ function safeEval(str, options = {}) {
 }
 
 export const evaluate = async (code, transpiler) => {
+  if (!scoped) {
+    await evalScope(); // at least scope Pattern.prototype.boostrap
+  }
   if (transpiler) {
     code = transpiler(code); // transform syntactically correct js code to semantically usable code
   }

packages/core/pattern.mjs

@@ -21,6 +21,143 @@ let stringParser;
 // intended to use with mini to automatically interpret all strings as mini notation
 export const setStringParser = (parser) => (stringParser = parser);
 
+const alignments = ['in', 'out', 'mix', 'squeeze', 'squeezeout', 'trig', 'trigzero'];
+
+const methodRegistry = [];
+const getterRegistry = [];
+const controlRegistry = [];
+const controlSubscribers = [];
+const composifiedRegistry = [];
+
+//////////////////////////////////////////////////////////////////////
+// Magic for supporting higher order composition of method chains
+
+// Dresses the given (unary) function with methods for composition chaining, so e.g.
+// `fast(2).iter(4)` composes to pattern functions into a new one.
+function composify(func, longlived) {
+  if (!func.__composified) {
+    for (const [name, method] of methodRegistry) {
+      func[name] = method;
+    }
+    for (const [name, getter] of getterRegistry) {
+      Object.defineProperty(func, name, getter);
+    }
+    func.__composified = true;
+    if (longlived) {
+      composifiedRegistry.push(func);
+    }
+  } else {
+    console.log('Warning: attempt at composifying a function more than once');
+  }
+  return func;
+}
+
+export function registerMethod(name, addAlignments = false, addControls = false) {
+  if (addAlignments || addControls) {
+    // This method needs to make its 'this' object available to chained alignments and/or
+    // control parameters, so it has to be implemented as a getter
+    const getter = {
+      get: function () {
+        const func = this;
+        const wrapped = function (...args) {
+          const composed = (pat) => func(pat)[name](...args);
+          return composify(composed);
+        };
+
+        if (addAlignments) {
+          for (const alignment of alignments) {
+            wrapped[alignment] = function (...args) {
+              const composed = (pat) => func(pat)[name][alignment](...args);
+              return composify(composed);
+            };
+            for (const [controlname, controlfunc] of controlRegistry) {
+              wrapped[alignment][controlname] = function (...args) {
+                const composed = (pat) => func(pat)[name][alignment](controlfunc(...args));
+                return composify(composed);
+              };
+            }
+          }
+        }
+        if (addControls) {
+          for (const [controlname, controlfunc] of controlRegistry) {
+            wrapped[controlname] = function (...args) {
+              const composed = (pat) => func(pat)[name](controlfunc(...args));
+              return composify(composed);
+            };
+          }
+        }
+        return wrapped;
+      },
+    };
+
+    getterRegistry.push([name, getter]);
+
+    // Add to functions already 'composified'
+    for (const composified of composifiedRegistry) {
+      Object.defineProperty(composified, name, getter);
+    }
+  } else {
+    // No chained alignments/controls needed, so we can just add as a plain method,
+    // probably more efficient this way?
+    const method = function (...args) {
+      const func = this;
+      const composed = (pat) => func(pat)[name](...args);
+      return composify(composed);
+    };
+
+    methodRegistry.push([name, method]);
+
+    // Add to functions already 'composified'
+    for (const composified of composifiedRegistry) {
+      composified[name] = method;
+    }
+  }
+}
+
+export function registerControl(controlname, controlfunc) {
+  registerMethod(controlname);
+  controlRegistry.push([controlname, controlfunc]);
+  for (const subscriber of controlSubscribers) {
+    subscriber(controlname, controlfunc);
+  }
+}
+
+export function withControls(func) {
+  for (const [controlname, controlfunc] of controlRegistry) {
+    func(controlname, controlfunc);
+  }
+  controlSubscribers.push(func);
+}
+
+export function addToPrototype(name, func) {
+  Pattern.prototype[name] = func;
+  registerMethod(name);
+}
+
+export function curryPattern(func, arity = func.length, longlived = false) {
+  const fn = function curried(...args) {
+    if (args.length >= arity) {
+      return func.apply(this, args);
+    }
+
+    const partial = function (...args2) {
+      return curried.apply(this, args.concat(args2));
+    };
+    if (args.length == arity - 1) {
+      return composify(partial);
+    }
+
+    return partial;
+  };
+  if (arity == 1) {
+    composify(fn, longlived);
+  }
+  return fn;
+}
+
+//////////////////////////////////////////////////////////////////////
+// The core Pattern class
+
 /** @class Class representing a pattern. */
 export class Pattern {
   /**
@@ -643,7 +780,9 @@ export class Pattern {
    * @noAutocomplete
    */
   get firstCycleValues() {
-    return this.firstCycle().map((hap) => hap.value);
+    return this.sortHapsByPart()
+      .firstCycle()
+      .map((hap) => hap.value);
   }
 
   /**
@@ -693,7 +832,7 @@ export class Pattern {
     const otherPat = reify(other);
     return this.fmap((a) => otherPat.fmap((b) => func(a)(b))).squeezeJoin();
   }
-  _opSqueezeOut(other, func) {
+  _opSqueezeout(other, func) {
     const thisPat = this;
     const otherPat = reify(other);
     return otherPat.fmap((a) => thisPat.fmap((b) => func(b)(a))).squeezeJoin();
@@ -860,11 +999,11 @@ function groupHapsBy(eq, haps) {
 const congruent = (a, b) => a.spanEquals(b);
 // Pattern<Hap<T>> -> Pattern<Hap<T[]>>
 // returned pattern contains arrays of congruent haps
-Pattern.prototype.collect = function () {
+addToPrototype('collect', function () {
   return this.withHaps((haps) =>
     groupHapsBy(congruent, haps).map((_haps) => new Hap(_haps[0].whole, _haps[0].part, _haps, {})),
   );
-};
+});
 
 /**
  * Selects indices in in stacked notes.
@@ -872,12 +1011,12 @@ Pattern.prototype.collect = function () {
  * note("<[c,eb,g]!2 [c,f,ab] [d,f,ab]>")
  * .arpWith(haps => haps[2])
  * */
-Pattern.prototype.arpWith = function (func) {
+addToPrototype('arpWith', function (func) {
   return this.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.
@@ -885,27 +1024,28 @@ Pattern.prototype.arpWith = function (func) {
  * note("<[c,eb,g]!2 [c,f,ab] [d,f,ab]>")
  * .arp("0 [0,2] 1 [0,2]").slow(2)
  * */
-Pattern.prototype.arp = function (pat) {
+addToPrototype('arp', function (pat) {
   return this.arpWith((haps) => pat.fmap((i) => haps[i % haps.length]));
-};
+});
 
-/*
+/**
  * Takes a time duration followed by one or more patterns, and shifts the given patterns in time, so they are
  * distributed equally over the given time duration. They are then combined with the pattern 'weave' is called on, after it has been stretched out (i.e. slowed down by) the time duration.
  * @name weave
  * @memberof Pattern
  * @example pan(saw).weave(4, s("bd(3,8)"), s("~ sd"))
  * @example n("0 1 2 3 4 5 6 7").weave(8, s("bd(3,8)"), s("~ sd"))
+ */
 
 addToPrototype('weave', function (t, ...pats) {
   return this.weaveWith(t, ...pats.map((x) => set.out(x)));
 });
 
-*/
-/*
+/**
  * Like 'weave', but accepts functions rather than patterns, which are applied to the pattern.
  * @name weaveWith
  * @memberof Pattern
+ */
 
 addToPrototype('weaveWith', function (t, ...funcs) {
   const pat = this;
@@ -916,7 +1056,6 @@ addToPrototype('weaveWith', function (t, ...funcs) {
   }
   return stack(...funcs.map((func, i) => pat.inside(t, func).early(Fraction(i).div(l))))._slow(t);
 });
-*/
 
 //////////////////////////////////////////////////////////////////////
 // compose matrix functions
@@ -1014,15 +1153,15 @@ function _composeOp(a, b, func) {
     func: [(a, b) => b(a)],
   };
 
-  const hows = ['In', 'Out', 'Mix', 'Squeeze', 'SqueezeOut', 'Trig', 'Trigzero'];
+  const hows = alignments.map((x) => x.charAt(0).toUpperCase() + x.slice(1));
 
   // generate methods to do what and how
   for (const [what, [op, preprocess]] of Object.entries(composers)) {
     // make plain version, e.g. pat._add(value) adds that plain value
     // to all the values in pat
-    Pattern.prototype['_' + what] = function (value) {
+    addToPrototype('_' + what, function (value) {
       return this.fmap((x) => op(x, value));
-    };
+    });
 
     // make patternified monster version
     Object.defineProperty(Pattern.prototype, what, {
@@ -1036,7 +1175,7 @@ function _composeOp(a, b, func) {
 
         // add methods to that function for each behaviour
         for (const how of hows) {
-          wrapper[how.toLowerCase()] = function (...other) {
+          const howfunc = function (...other) {
             var howpat = pat;
             other = sequence(other);
             if (preprocess) {
@@ -1054,19 +1193,41 @@ function _composeOp(a, b, func) {
             }
             return result;
           };
+
+          for (const [controlname, controlfunc] of controlRegistry) {
+            howfunc[controlname] = (...args) => howfunc(controlfunc(...args));
+          }
+          wrapper[how.toLowerCase()] = howfunc;
         }
         wrapper.squeezein = wrapper.squeeze;
 
+        for (const [controlname, controlfunc] of controlRegistry) {
+          wrapper[controlname] = (...args) => wrapper.in(controlfunc(...args));
+        }
+
         return wrapper;
       },
     });
 
-    // Default op to 'set', e.g. pat.squeeze(pat2) = pat.set.squeeze(pat2)
-    for (const how of hows) {
-      Pattern.prototype[how.toLowerCase()] = function (...args) {
-        return this.set[how.toLowerCase()](args);
-      };
-    }
+    registerMethod(what, true, true);
+  }
+
+  // Default op to 'set', e.g. pat.squeeze(pat2) = pat.set.squeeze(pat2)
+  for (const howLower of alignments) {
+    // Using a 'get'ted function so that all the controls are added
+    Object.defineProperty(Pattern.prototype, howLower, {
+      get: function () {
+        const pat = this;
+        const howfunc = function (...args) {
+          return pat.set[howLower](args);
+        };
+        for (const [controlname, controlfunc] of controlRegistry) {
+          howfunc[controlname] = (...args) => howfunc(controlfunc(...args));
+        }
+        return howfunc;
+      },
+    });
+    registerMethod(howLower, false, true);
   }
 
   // binary composers
@@ -1078,36 +1239,36 @@ function _composeOp(a, b, func) {
    *   .struct("x ~ x ~ ~ x ~ x ~ ~ ~ x ~ x ~ ~")
    *   .slow(4)
    */
-  Pattern.prototype.struct = function (...args) {
+  addToPrototype('struct', function (...args) {
     return this.keepif.out(...args);
-  };
-  Pattern.prototype.structAll = function (...args) {
+  });
+  addToPrototype('structAll', function (...args) {
     return this.keep.out(...args);
-  };
+  });
   /**
    * Returns silence when mask is 0 or "~"
    *
    * @example
    * note("c [eb,g] d [eb,g]").mask("<1 [0 1]>").slow(2)
    */
-  Pattern.prototype.mask = function (...args) {
+  addToPrototype('mask', function (...args) {
     return this.keepif.in(...args);
-  };
-  Pattern.prototype.maskAll = function (...args) {
+  });
+  addToPrototype('maskAll', function (...args) {
     return this.keep.in(...args);
-  };
+  });
   /**
    * Resets the pattern to the start of the cycle for each onset of the reset pattern.
    *
    * @example
    * s("<bd lt> sd, hh*4").reset("<x@3 x(3,8)>")
    */
-  Pattern.prototype.reset = function (...args) {
+  addToPrototype('reset', function (...args) {
     return this.keepif.trig(...args);
-  };
-  Pattern.prototype.resetAll = function (...args) {
+  });
+  addToPrototype('resetAll', function (...args) {
     return this.keep.trig(...args);
-  };
+  });
   /**
    * Restarts the pattern for each onset of the restart pattern.
    * While reset will only reset the current cycle, restart will start from cycle 0.
@@ -1115,12 +1276,12 @@ function _composeOp(a, b, func) {
    * @example
    * s("<bd lt> sd, hh*4").restart("<x@3 x(3,8)>")
    */
-  Pattern.prototype.restart = function (...args) {
+  addToPrototype('restart', function (...args) {
     return this.keepif.trigzero(...args);
-  };
-  Pattern.prototype.restartAll = function (...args) {
+  });
+  addToPrototype('restartAll', function (...args) {
     return this.keep.trigzero(...args);
-  };
+  });
 })();
 
 // aliases
@@ -1365,36 +1526,68 @@ export function pm(...args) {
   polymeter(...args);
 }
 
-export const mask = curry((a, b) => reify(b).mask(a));
-export const struct = curry((a, b) => reify(b).struct(a));
-export const superimpose = curry((a, b) => reify(b).superimpose(...a));
+export const mask = curryPattern((a, b) => reify(b).mask(a));
+export const struct = curryPattern((a, b) => reify(b).struct(a));
+export const superimpose = curryPattern((a, b) => reify(b).superimpose(...a));
+
+const methodToFunction = function (name, addAlignments = false) {
+  const func = curryPattern((a, b) => reify(b)[name](a));
+
+  withControls((controlname, controlfunc) => {
+    func[controlname] = function (...pats) {
+      return func(controlfunc(...pats));
+    };
+  });
+
+  if (addAlignments) {
+    for (const alignment of alignments) {
+      func[alignment] = curryPattern((a, b) => reify(b)[name][alignment](a));
+      withControls((controlname, controlfunc) => {
+        func[alignment][controlname] = function (...pats) {
+          return func[alignment](controlfunc(...pats));
+        };
+      });
+    }
+  }
+
+  return func;
+};
 
 // operators
-export const set = curry((a, b) => reify(b).set(a));
-export const keep = curry((a, b) => reify(b).keep(a));
-export const keepif = curry((a, b) => reify(b).keepif(a));
-export const add = curry((a, b) => reify(b).add(a));
-export const sub = curry((a, b) => reify(b).sub(a));
-export const mul = curry((a, b) => reify(b).mul(a));
-export const div = curry((a, b) => reify(b).div(a));
-export const mod = curry((a, b) => reify(b).mod(a));
-export const pow = curry((a, b) => reify(b).pow(a));
-export const band = curry((a, b) => reify(b).band(a));
-export const bor = curry((a, b) => reify(b).bor(a));
-export const bxor = curry((a, b) => reify(b).bxor(a));
-export const blshift = curry((a, b) => reify(b).blshift(a));
-export const brshift = curry((a, b) => reify(b).brshift(a));
-export const lt = curry((a, b) => reify(b).lt(a));
-export const gt = curry((a, b) => reify(b).gt(a));
-export const lte = curry((a, b) => reify(b).lte(a));
-export const gte = curry((a, b) => reify(b).gte(a));
-export const eq = curry((a, b) => reify(b).eq(a));
-export const eqt = curry((a, b) => reify(b).eqt(a));
-export const ne = curry((a, b) => reify(b).ne(a));
-export const net = curry((a, b) => reify(b).net(a));
-export const and = curry((a, b) => reify(b).and(a));
-export const or = curry((a, b) => reify(b).or(a));
-export const func = curry((a, b) => reify(b).func(a));
+export const set = methodToFunction('set', true);
+export const keep = methodToFunction('keep', true);
+export const keepif = methodToFunction('keepif', true);
+export const add = methodToFunction('add', true);
+export const sub = methodToFunction('sub', true);
+export const mul = methodToFunction('mul', true);
+export const div = methodToFunction('div', true);
+export const mod = methodToFunction('mod', true);
+export const pow = methodToFunction('pow', true);
+export const band = methodToFunction('band', true);
+export const bor = methodToFunction('bor', true);
+export const bxor = methodToFunction('bxor', true);
+export const blshift = methodToFunction('blshift', true);
+export const brshift = methodToFunction('brshift', true);
+export const lt = methodToFunction('lt', true);
+export const gt = methodToFunction('gt', true);
+export const lte = methodToFunction('lte', true);
+export const gte = methodToFunction('gte', true);
+export const eq = methodToFunction('eq', true);
+export const eqt = methodToFunction('eqt', true);
+export const ne = methodToFunction('ne', true);
+export const net = methodToFunction('net', true);
+export const and = methodToFunction('and', true);
+export const or = methodToFunction('or', true);
+export const func = methodToFunction('func', true);
+
+// alignments
+// export const in = methodToFunction('in'); // reserved word :(
+export const out = methodToFunction('out');
+export const mix = methodToFunction('mix');
+export const squeeze = methodToFunction('squeeze');
+export const squeezeout = methodToFunction('squeezeout');
+export const trig = methodToFunction('trig');
+export const trigzero = methodToFunction('trigzero');
 
 /**
  * Registers a new pattern method. The method is added to the Pattern class + the standalone function is returned from register.
@@ -1413,7 +1606,10 @@ export function register(name, func, patternify = true) {
     return result;
   }
   const arity = func.length;
-  var pfunc; // the patternified function
+
+  registerMethod(name);
+
+  var pfunc;
 
   if (patternify) {
     pfunc = function (...args) {
@@ -1432,8 +1628,14 @@ export function register(name, func, patternify = true) {
           .map((_, i) => args[i] ?? undefined);
         return func(...args, pat);
       };
-      mapFn = curry(mapFn, null, arity - 1);
-      return right.reduce((acc, p) => acc.appLeft(p), left.fmap(mapFn)).innerJoin();
+      mapFn = curryPattern(mapFn, arity - 1);
+
+      const app = function (acc, p, i) {
+        return acc.appLeft(p);
+      };
+      const start = left.fmap(mapFn);
+
+      return right.reduce(app, start).innerJoin();
     };
   } else {
     pfunc = function (...args) {
@@ -1464,7 +1666,9 @@ export function register(name, func, patternify = true) {
 
   // toplevel functions get curried as well as patternified
   // because pfunc uses spread args, we need to state the arity explicitly!
-  return curry(pfunc, null, arity);
+  // set 'longlived' to true for single-argument functions, so their 'composified'
+  // methods get updated for things added in the future
+  return curryPattern(pfunc, arity, arity == 1);
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -2230,7 +2434,7 @@ const _loopAt = function (factor, pat, cps = 1) {
     .slow(factor);
 };
 
-/*
+/**
  * Chops samples into the given number of slices, triggering those slices with a given pattern of slice numbers.
  * @name slice
  * @memberof Pattern
@@ -2239,7 +2443,6 @@ const _loopAt = function (factor, pat, cps = 1) {
  * await samples('github:tidalcycles/Dirt-Samples/master')
  * s("breaks165").slice(8, "0 1 <2 2*2> 3 [4 0] 5 6 7".every(3, rev)).slow(1.5)
  */
-
 const slice = register(
   'slice',
   function (npat, ipat, opat) {
@@ -2258,7 +2461,7 @@ const slice = register(
   false, // turns off auto-patternification
 );
 
-/*
+/**
  * Works the same as slice, but changes the playback speed of each slice to match the duration of its step.
  * @name splice
  * @memberof Pattern
@@ -2267,7 +2470,6 @@ const slice = register(
  * await samples('github:tidalcycles/Dirt-Samples/master')
  * s("breaks165").splice(8,  "0 1 [2 3 0]@2 3 0@2 7").hurry(0.65)
  */
-
 const splice = register(
   'splice',
   function (npat, ipat, opat) {

packages/core/repl.mjs

@@ -2,7 +2,6 @@ import { Cyclist } from './cyclist.mjs';
 import { evaluate as _evaluate } from './evaluate.mjs';
 import { logger } from './logger.mjs';
 import { setTime } from './time.mjs';
-import { evalScope } from './evaluate.mjs';
 
 export function repl({
   interval,
@@ -18,12 +17,13 @@ export function repl({
 }) {
   const scheduler = new Cyclist({
     interval,
-    onTrigger: async (hap, deadline, duration, cps) => {
+    onTrigger: async (hap, deadline, duration) => {
       try {
         if (!hap.context.onTrigger || !hap.context.dominantTrigger) {
-          await defaultOutput(hap, deadline, duration, cps);
+          await defaultOutput(hap, deadline, duration);
         }
         if (hap.context.onTrigger) {
+          const cps = 1;
           // call signature of output / onTrigger is different...
           await hap.context.onTrigger(getTime() + deadline, hap, getTime(), cps);
         }
@@ -42,17 +42,6 @@ export function repl({
     }
     try {
       beforeEval?.({ code });
-      scheduler.setCps(1); // reset cps in case the code does not contain a setCps call
-      // problem: when the code does contain a setCps after an awaited promise,
-      // the cps will be 1 until the promise resolves
-      // example:
-      /*
-      await new Promise(resolve => setTimeout(resolve,1000))
-      setCps(.5)
-      note("c a f e")
-      */
-      // to make sure the setCps inside the code is called immediately,
-      // it has to be placed first
       let { pattern } = await _evaluate(code, transpiler);
 
       logger(`[eval] code updated`);
@@ -69,10 +58,5 @@ export function repl({
   const stop = () => scheduler.stop();
   const start = () => scheduler.start();
   const pause = () => scheduler.pause();
-  const setCps = (cps) => scheduler.setCps(cps);
-  evalScope({
-    setCps,
-    setcps: setCps,
-  });
-  return { scheduler, evaluate, start, stop, pause, setCps };
+  return { scheduler, evaluate, start, stop, pause };
 }

packages/core/test/controls.test.mjs

@@ -1,28 +0,0 @@
-/*
-controls.test.mjs - <short description TODO>
-Copyright (C) 2023 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/core/test/controls.test.mjs>
-This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-import controls from '../controls.mjs';
-import { mini } from '../../mini/mini.mjs';
-import { describe, it, expect } from 'vitest';
-
-describe('controls', () => {
-  it('should support controls', () => {
-    expect(controls.s('bd').firstCycleValues).toEqual([{ s: 'bd' }]);
-  });
-  it('should support compound controls', () => {
-    expect(controls.s(mini('bd:3')).firstCycleValues).toEqual([{ s: 'bd', n: 3 }]);
-    expect(controls.s(mini('bd:3 sd:4:1.4')).firstCycleValues).toEqual([
-      { s: 'bd', n: 3 },
-      { s: 'sd', n: 4, gain: 1.4 },
-    ]);
-  });
-  it('should support ignore extra elements in compound controls', () => {
-    expect(controls.s(mini('bd:3:0.4 sd:4:0.5:3:17')).firstCycleValues).toEqual([
-      { s: 'bd', n: 3, gain: 0.4 },
-      { s: 'sd', n: 4, gain: 0.5 },
-    ]);
-  });
-});

packages/core/test/pattern.test.mjs

@@ -45,6 +45,9 @@ import {
   rev,
   time,
   run,
+  hitch,
+  set,
+  begin,
 } from '../index.mjs';
 
 import { steady } from '../signal.mjs';
@@ -204,7 +207,7 @@ describe('Pattern', () => {
         ),
       );
     });
-    it('can SqueezeOut() structure', () => {
+    it('can squeezeout() structure', () => {
       sameFirst(
         sequence(1, [2, 3]).add.squeezeout(10, 20, 30),
         sequence([11, [12, 13]], [21, [22, 23]], [31, [32, 33]]),
@@ -252,7 +255,7 @@ describe('Pattern', () => {
         ),
       );
     });
-    it('can SqueezeOut() structure', () => {
+    it('can squeezeout() structure', () => {
       sameFirst(sequence(1, [2, 3]).keep.squeezeout(10, 20, 30), sequence([1, [2, 3]], [1, [2, 3]], [1, [2, 3]]));
     });
   });
@@ -294,7 +297,7 @@ describe('Pattern', () => {
         ),
       );
     });
-    it('can SqueezeOut() structure', () => {
+    it('can squeezeout() structure', () => {
       sameFirst(sequence(1, [2, 3]).keepif.squeezeout(true, true, false), sequence([1, [2, 3]], [1, [2, 3]], silence));
     });
   });
@@ -929,6 +932,14 @@ describe('Pattern', () => {
     });
   });
   describe('alignments', () => {
+    it('Can combine controls', () => {
+      sameFirst(s('bd').set.in.n(3), s('bd').n(3));
+      sameFirst(s('bd').set.squeeze.n(3, 4), sequence(s('bd').n(3), s('bd').n(4)));
+    });
+    it('Can combine functions with alignmed controls', () => {
+      sameFirst(s('bd').apply(fast(2).set(n(3))), s('bd').fast(2).set.in.n(3));
+      sameFirst(s('bd').apply(fast(2).set.in.n(3)), s('bd').fast(2).set.in.n(3));
+    });
     it('Can squeeze arguments', () => {
       expect(sequence(1, 2).add.squeeze(4, 5).firstCycle()).toStrictEqual(sequence(5, 6, 6, 7).firstCycle());
     });
@@ -959,7 +970,7 @@ describe('Pattern', () => {
       sameFirst(s('a', 'b').hurry(2), s('a', 'b').fast(2).speed(2));
     });
   });
-  /*describe('composable functions', () => {
+  describe('composable functions', () => {
     it('Can compose functions', () => {
       sameFirst(sequence(3, 4).fast(2).rev().fast(2), fast(2).rev().fast(2)(sequence(3, 4)));
     });
@@ -976,7 +987,6 @@ describe('Pattern', () => {
       sameFirst(n(0, 1).weave(2, s('bd', silence), s(silence, 'sd')), sequence(s('bd').n(0), s('sd').n(1)));
     });
   });
-  */
   describe('slice', () => {
     it('Can slice a sample', () => {
       sameFirst(

packages/core/util.mjs

@@ -139,7 +139,7 @@ export const removeUndefineds = (xs) => xs.filter((x) => x != undefined);
 export const flatten = (arr) => [].concat(...arr);
 
 export const id = (a) => a;
-export const constant = (a, b) => a;
+export const constant = curry((a, b) => a);
 
 export const listRange = (min, max) => Array.from({ length: max - min + 1 }, (_, i) => i + min);
 

packages/core/zyklus.mjs

@@ -44,6 +44,6 @@ function createClock(
   };
   const getPhase = () => phase;
   // setCallback
-  return { setDuration, start, stop, pause, duration, interval, getPhase, minLatency };
+  return { setDuration, start, stop, pause, duration, getPhase, minLatency };
 }
 export default createClock;

packages/mini/krill.pegjs

@@ -19,13 +19,6 @@ This program is free software: you can redistribute it and/or modify it under th
     this.location_ = location();
   }
 
-  var MemoryStub = function(source)
-  {
-    this.type_ = "memory";
-    this.source_ = source;
-    this.location_ = location();
-  }
-
   var PatternStub = function(source, alignment)
   {
     this.type_ = "pattern";
@@ -103,11 +96,9 @@ quote = '"' / "'"
 // ------------------ steps and cycles ---------------------------
 
 // single step definition (e.g bd)
-step_char =  [0-9a-zA-Z~] / "-" / "#" / "." / "_" / "^"
+step_char =  [0-9a-zA-Z~] / "-" / "#" / "." / "^" / "_" / ":"
 step = ws chars:step_char+ ws { return new AtomStub(chars.join("")) }
 
-memory = ws "^" h:[A-Za-z] t:[A-Za-z0-9_]+ { return new MemoryStub(h + t.join("")) }
-
 // define a sub cycle e.g. [1 2, 3 [4]]
 sub_cycle = ws  "[" ws s:stack_or_choose ws "]" ws { return s }
 
@@ -124,11 +115,11 @@ slow_sequence = ws "<" ws s:sequence ws ">" ws
   { s.arguments_.alignment = 'slowcat'; return s; }
 
 // a slice is either a single step or a sub cycle
-slice = memory / step / sub_cycle / polymeter / slow_sequence
+slice = step / sub_cycle / polymeter / slow_sequence
 
 // slice modifier affects the timing/size of a slice (e.g. [a b c]@3)
 // at this point, we assume we can represent them as regular sequence operators
-slice_op = op_weight / op_bjorklund / op_slow / op_fast / op_replicate / op_degrade / op_tail
+slice_op = op_weight / op_bjorklund / op_slow / op_fast / op_replicate / op_degrade
 
 op_weight =  "@" a:number
   { return x => x.options_['weight'] = a }
@@ -148,9 +139,6 @@ op_fast = "*"a:slice
 op_degrade = "?"a:number?
   { return x => x.options_['ops'].push({ type_: "degradeBy", arguments_ :{ amount:a } }) }
 
-op_tail = ":" s:slice
-  { return x => x.options_['ops'].push({ type_: "tail", arguments_ :{ element:s } }) }
-
 // a slice with an modifier applied i.e [bd@4 sd@3]@2 hh]
 slice_with_ops = s:slice ops:slice_op*
   { const result = new ElementStub(s, {ops: [], weight: 1, reps: 1});

packages/mini/mini.mjs

@@ -14,22 +14,10 @@ function _nextSeed() {
   return _seedState++;
 } */
 
-const memory = {};
-
-export const remember = (name, pat) => {
-  if (pat) {
-    memory[name] = pat;
-  } else {
-    pat = memory[name];
-  }
-  return pat;
-};
-
 const applyOptions = (parent, code) => (pat, i) => {
   const ast = parent.source_[i];
   const options = ast.options_;
   const ops = options?.ops;
-
   if (ops) {
     for (const op of ops) {
       switch (op.type_) {
@@ -78,11 +66,6 @@ const applyOptions = (parent, code) => (pat, i) => {
           pat = strudel.reify(pat).degradeBy(op.arguments_.amount === null ? 0.5 : op.arguments_.amount);
           break;
         }
-        case 'tail': {
-          const friend = patternifyAST(op.arguments_.element, code);
-          pat = pat.fmap((a) => (b) => Array.isArray(a) ? [...a, b] : [a, b]).appLeft(friend);
-          break;
-        }
         default: {
           console.warn(`operator "${op.type_}" not implemented`);
         }
@@ -149,16 +132,6 @@ export function patternifyAST(ast, code) {
     case 'element': {
       return patternifyAST(ast.source_, code);
     }
-    case 'memory': {
-      const name = ast.source_;
-      if (name in memory) {
-        return new strudel.Pattern((state) => {
-          return memory[name].query(state);
-        });
-      }
-      // TODO - how to default a memory.. via a list?
-      return strudel.pure(undefined);
-    }
     case 'atom': {
       if (ast.source_ === '~') {
         return strudel.silence;

packages/mini/test/mini.test.mjs

@@ -140,9 +140,6 @@ describe('mini', () => {
     expect(haps.length < 230).toBe(true);
     // 'Had too many cycles remaining after degradeBy 0.8');
   });
-  it('supports lists', () => {
-    expect(minV('a:b c:d:[e:f] g')).toEqual([['a', 'b'], ['c', 'd', ['e', 'f']], 'g']);
-  });
   /*it('supports the random choice operator ("|") with nesting', () => {
     const numCycles = 900;
     const haps = mini('a | [b | c] | [d | e | f]').queryArc(0, numCycles);

packages/react/README.md

@@ -13,43 +13,24 @@ npm i @strudel.cycles/react
 Here is a minimal example of how to set up a MiniRepl:
 
 ```jsx
-import * as React from 'react';
-import '@strudel.cycles/react/dist/style.css';
-import { MiniRepl } from '@strudel.cycles/react';
 import { evalScope, controls } from '@strudel.cycles/core';
-import { samples, initAudioOnFirstClick } from '@strudel.cycles/webaudio';
+import { MiniRepl } from '@strudel.cycles/react';
+import { prebake } from '../repl/src/prebake.mjs';
 
-async function prebake() {
-  await samples(
-    'https://strudel.tidalcycles.org/tidal-drum-machines.json',
-    'github:ritchse/tidal-drum-machines/main/machines/'
-  );
-  await samples(
-    'https://strudel.tidalcycles.org/EmuSP12.json',
-    'https://strudel.tidalcycles.org/EmuSP12/'
-  );
-}
+evalScope(
+  controls,
+  import('@strudel.cycles/core'),
+  import('@strudel.cycles/tonal'),
+  import('@strudel.cycles/mini'),
+  import('@strudel.cycles/webaudio'),
+  /* probably import other strudel packages */
+);
 
-async function init() {
-  await evalScope(
-    controls,
-    import('@strudel.cycles/core'),
-    import('@strudel.cycles/mini'),
-    import('@strudel.cycles/webaudio'),
-    import('@strudel.cycles/tonal')
-  );
-  await prebake();
-  initAudioOnFirstClick();
-}
+prebake();
 
-if (typeof window !== 'undefined') {
-  init();
-}
-
-export default function App() {
-  return <MiniRepl tune={`s("bd sd,hh*4")`} />;
+export function Repl({ tune }) {
+  return <MiniRepl tune={tune} hideOutsideView={true} />;
 }
 ```
 
-- Open [example on stackblitz](https://stackblitz.com/edit/react-ts-saaair?file=tune.tsx,App.tsx)
-- Also check out the [nano-repl](./examples/nano-repl/) for a more sophisticated example
+For a more sophisticated example, check out the [nano-repl](./examples/nano-repl/)!

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

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

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

@@ -66,7 +66,7 @@ function App() {
   const [code, setCode] = useState(defaultTune);
   const [view, setView] = useState();
   // const [code, setCode] = useState(`"c3".note().slow(2)`);
-  const { scheduler, evaluate, schedulerError, evalError, isDirty, activeCode, pattern, started } = useStrudel({
+  const { scheduler, evaluate, schedulerError, evalError, isDirty, activeCode, pattern } = useStrudel({
     code,
     defaultOutput: webaudioOutput,
     getTime,
@@ -75,8 +75,8 @@ function App() {
   useHighlighting({
     view,
     pattern,
-    active: started && !activeCode?.includes('strudel disable-highlighting'),
-    getTime: () => scheduler.now(),
+    active: !activeCode?.includes('strudel disable-highlighting'),
+    getTime: () => scheduler.getPhase(),
   });
 
   const error = evalError || schedulerError;

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

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

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

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

packages/react/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel.cycles/react",
-  "version": "0.6.4",
+  "version": "0.6.0",
   "description": "React components for strudel",
   "main": "src/index.js",
   "publishConfig": {

packages/react/src/components/CodeMirror6.jsx

@@ -7,7 +7,7 @@ import strudelTheme from '../themes/strudel-theme';
 import './style.css';
 import { useCallback } from 'react';
 import { autocompletion } from '@codemirror/autocomplete';
-//import { strudelAutocomplete } from './Autocomplete';
+import { strudelAutocomplete } from './Autocomplete';
 import { vim } from '@replit/codemirror-vim';
 import { emacs } from '@replit/codemirror-emacs';
 

packages/react/src/components/MiniRepl.jsx

@@ -7,6 +7,7 @@ import useHighlighting from '../hooks/useHighlighting.mjs';
 import useStrudel from '../hooks/useStrudel.mjs';
 import CodeMirror6, { flash } from './CodeMirror6';
 import { Icon } from './Icon';
+import styles from './MiniRepl.module.css';
 import './style.css';
 import { logger } from '@strudel.cycles/core';
 import useEvent from '../hooks/useEvent.mjs';
@@ -128,31 +129,19 @@ export function MiniRepl({
   );
 
   return (
-    <div className="overflow-hidden rounded-t-md bg-background border border-lineHighlight" ref={ref}>
-      <div className="flex justify-between bg-lineHighlight">
-        <div className="flex">
-          <button
-            className={cx(
-              'cursor-pointer w-16 flex items-center justify-center p-1 border-r border-lineHighlight text-foreground bg-lineHighlight hover:bg-background',
-              started ? 'animate-pulse' : '',
-            )}
-            onClick={() => togglePlay()}
-          >
+    <div className={styles.container} ref={ref}>
+      <div className={styles.header}>
+        <div className={styles.buttons}>
+          <button className={cx(styles.button, started ? 'animate-pulse' : '')} onClick={() => togglePlay()}>
             <Icon type={started ? 'stop' : 'play'} />
           </button>
-          <button
-            className={cx(
-              'w-16 flex items-center justify-center p-1 text-foreground border-lineHighlight bg-lineHighlight',
-              isDirty ? 'text-foreground hover:bg-background cursor-pointer' : 'opacity-50 cursor-not-allowed',
-            )}
-            onClick={() => activateCode()}
-          >
+          <button className={cx(isDirty ? styles.button : styles.buttonDisabled)} onClick={() => activateCode()}>
             <Icon type="refresh" />
           </button>
         </div>
-        {error && <div className="text-right p-1 text-sm text-red-200">{error.message}</div>}
+        {error && <div className={styles.error}>{error.message}</div>}
       </div>
-      <div className="overflow-auto relative">
+      <div className={styles.body}>
         {show && <CodeMirror6 value={code} onChange={setCode} onViewChanged={setView} theme={theme} />}
       </div>
       {drawTime && (

packages/react/src/components/MiniRepl.module.css

@@ -0,0 +1,27 @@
+.container {
+  @apply overflow-hidden;
+}
+
+.header {
+  @apply flex justify-between bg-lineHighlight border-t border-l border-r border-lineHighlight rounded-t-md overflow-hidden;
+}
+
+.buttons {
+  @apply flex;
+}
+
+.button {
+  @apply cursor-pointer w-16 flex items-center justify-center p-1 border-r border-lineHighlight text-foreground hover:bg-background;
+}
+
+.buttonDisabled {
+  @apply w-16 flex items-center justify-center p-1 opacity-50 cursor-not-allowed border-r border-lineHighlight;
+}
+
+.error {
+  @apply text-right p-1 text-sm text-red-200;
+}
+
+.body {
+  @apply overflow-auto relative;
+}

packages/react/src/components/style.css

@@ -1,15 +1,3 @@
-:root {
-  --background: #222;
-  --lineBackground: #22222250;
-  --foreground: #fff;
-  --caret: #ffcc00;
-  --selection: rgba(128, 203, 196, 0.5);
-  --selectionMatch: #036dd626;
-  --lineHighlight: #00000050;
-  --gutterBackground: transparent;
-  --gutterForeground: #8a919966;
-}
-
 .cm-editor {
   background-color: transparent !important;
   height: 100%;

packages/react/src/hooks/useHighlighting.mjs

@@ -1,6 +1,5 @@
 import { useEffect, useRef } from 'react';
 import { setHighlights } from '../components/CodeMirror6';
-const round = (x) => Math.round(x * 1000) / 1000;
 
 function useHighlighting({ view, pattern, active, getTime }) {
   const highlights = useRef([]);
@@ -15,7 +14,7 @@ function useHighlighting({ view, pattern, active, getTime }) {
             // force min framerate of 10 fps => fixes crash on tab refocus, where lastEnd could be far away
             // see https://github.com/tidalcycles/strudel/issues/108
             const begin = Math.max(lastEnd.current ?? audioTime, audioTime - 1 / 10, -0.01); // negative time seems buggy
-            const span = [round(begin), round(audioTime + 1 / 60)];
+            const span = [begin, audioTime + 1 / 60];
             lastEnd.current = span[1];
             highlights.current = highlights.current.filter((hap) => hap.whole.end > audioTime); // keep only highlights that are still active
             const haps = pattern.queryArc(...span).filter((hap) => hap.hasOnset());

packages/react/src/hooks/useStrudel.mjs

@@ -32,7 +32,7 @@ function useStrudel({
   const shouldPaint = useCallback((pat) => !!(pat?.context?.onPaint && drawContext), [drawContext]);
 
   // TODO: make sure this hook reruns when scheduler.started changes
-  const { scheduler, evaluate, start, stop, pause, setCps } = useMemo(
+  const { scheduler, evaluate, start, stop, pause } = useMemo(
     () =>
       repl({
         interval,
@@ -153,7 +153,6 @@ function useStrudel({
     stop,
     pause,
     togglePlay,
-    setCps,
   };
 }
 

packages/react/tailwind.config.js

@@ -1,21 +1,7 @@
 module.exports = {
   content: ['./src/**/*.{js,jsx,ts,tsx}'],
   theme: {
-    extend: {
-      colors: {
-        // codemirror-theme settings
-        background: 'var(--background)',
-        lineBackground: 'var(--lineBackground)',
-        foreground: 'var(--foreground)',
-        caret: 'var(--caret)',
-        selection: 'var(--selection)',
-        selectionMatch: 'var(--selectionMatch)',
-        gutterBackground: 'var(--gutterBackground)',
-        gutterForeground: 'var(--gutterForeground)',
-        gutterBorder: 'var(--gutterBorder)',
-        lineHighlight: 'var(--lineHighlight)',
-      },
-    },
+    extend: {},
   },
   plugins: [],
   corePlugins: {

packages/tonal/test/tonal.test.mjs

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

packages/tonal/tonal.mjs

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

packages/webaudio/webaudio.mjs

@@ -97,6 +97,17 @@ const getSoundfontKey = (s) => {
   return;
 };
 
+const splitSN = (s, n) => {
+  if (!s.includes(':')) {
+    return [s, n];
+  }
+  let [s2, n2] = s.split(':');
+  if (isNaN(Number(n2))) {
+    return [s, n];
+  }
+  return [s2, n2];
+};
+
 let workletsLoading;
 function loadWorklets() {
   if (workletsLoading) {
@@ -180,7 +191,7 @@ function effectSend(input, effect, wet) {
 }
 
 // export const webaudioOutput = async (t, hap, ct, cps) => {
-export const webaudioOutput = async (hap, deadline, hapDuration, cps) => {
+export const webaudioOutput = async (hap, deadline, hapDuration) => {
   const ac = getAudioContext();
   hap.ensureObjectValue();
 
@@ -197,14 +208,20 @@ export const webaudioOutput = async (hap, deadline, hapDuration, cps) => {
     note,
     gain = 0.8,
     // low pass
-    cutoff,
-    resonance = 1,
+    lpf,
+    cutoff = lpf,
+    lpq = 1,
+    resonance = lpq,
     // high pass
-    hcutoff,
-    hresonance = 1,
+    hpf,
+    hcutoff = hpf,
+    hpq = 1,
+    hresonance = hpq,
     // band pass
-    bandf,
-    bandq = 1,
+    bpf,
+    bandf = bpf,
+    bpq = 1,
+    bandq = bpq,
     //
     coarse,
     crush,
@@ -224,6 +241,7 @@ export const webaudioOutput = async (hap, deadline, hapDuration, cps) => {
     orbit = 1,
     room,
     size = 2,
+    roomsize = size,
   } = hap.value;
   const { velocity = 1 } = hap.context;
   gain *= velocity; // legacy fix for velocity
@@ -232,6 +250,12 @@ export const webaudioOutput = async (hap, deadline, hapDuration, cps) => {
   if (bank && s) {
     s = `${bank}_${s}`;
   }
+  if (typeof s === 'string') {
+    [s, n] = splitSN(s, n);
+  }
+  if (typeof note === 'string') {
+    [note, n] = splitSN(note, n);
+  }
   if (!s || ['sine', 'square', 'triangle', 'sawtooth'].includes(s)) {
     // destructure adsr here, because the default should be different for synths and samples
     const { attack = 0.001, decay = 0.05, sustain = 0.6, release = 0.01 } = hap.value;
@@ -288,7 +312,7 @@ export const webaudioOutput = async (hap, deadline, hapDuration, cps) => {
     bufferSource.playbackRate.value = Math.abs(speed) * bufferSource.playbackRate.value;
     if (unit === 'c') {
       // are there other units?
-      bufferSource.playbackRate.value = bufferSource.playbackRate.value * bufferSource.buffer.duration * cps;
+      bufferSource.playbackRate.value = bufferSource.playbackRate.value * bufferSource.buffer.duration;
     }
     let duration = soundfont || clip ? hapDuration : bufferSource.buffer.duration / bufferSource.playbackRate.value;
     // "The computation of the offset into the sound is performed using the sound buffer's natural sample rate,
@@ -349,8 +373,8 @@ export const webaudioOutput = async (hap, deadline, hapDuration, cps) => {
   }
   // reverb
   let reverbSend;
-  if (room > 0 && size > 0) {
-    const reverbNode = getReverb(orbit, size);
+  if (room > 0 && roomsize > 0) {
+    const reverbNode = getReverb(orbit, roomsize);
     reverbSend = effectSend(post, reverbNode, room);
   }
 
@@ -361,7 +385,7 @@ export const webaudioOutput = async (hap, deadline, hapDuration, cps) => {
   chain[0].onended = () => chain.concat([delaySend, reverbSend]).forEach((n) => n?.disconnect());
 };
 
-export const webaudioOutputTrigger = (t, hap, ct, cps) => webaudioOutput(hap, t - ct, hap.duration / cps, cps);
+export const webaudioOutputTrigger = (t, hap, ct, cps) => webaudioOutput(hap, t - ct, hap.duration / cps);
 
 Pattern.prototype.webaudio = function () {
   // TODO: refactor (t, hap, ct, cps) to (hap, deadline, duration) ?

test/__snapshots__/examples.test.mjs.snap

@@ -885,39 +885,39 @@ exports[`runs examples > example "begin" example index 0 1`] = `
 
 exports[`runs examples > example "bpf" example index 0 1`] = `
 [
-  "[ 0/1 → 1/2 | s:bd bandf:1000 ]",
-  "[ 1/2 → 1/1 | s:sd bandf:1000 ]",
-  "[ 0/1 → 1/3 | s:hh bandf:1000 ]",
-  "[ 1/3 → 2/3 | s:hh bandf:1000 ]",
-  "[ 2/3 → 1/1 | s:hh bandf:1000 ]",
-  "[ 1/1 → 3/2 | s:bd bandf:2000 ]",
-  "[ 3/2 → 2/1 | s:sd bandf:2000 ]",
-  "[ 1/1 → 4/3 | s:hh bandf:2000 ]",
-  "[ 4/3 → 5/3 | s:hh bandf:2000 ]",
-  "[ 5/3 → 2/1 | s:hh bandf:2000 ]",
-  "[ 2/1 → 5/2 | s:bd bandf:4000 ]",
-  "[ 5/2 → 3/1 | s:sd bandf:4000 ]",
-  "[ 2/1 → 7/3 | s:hh bandf:4000 ]",
-  "[ 7/3 → 8/3 | s:hh bandf:4000 ]",
-  "[ 8/3 → 3/1 | s:hh bandf:4000 ]",
-  "[ 3/1 → 7/2 | s:bd bandf:8000 ]",
-  "[ 7/2 → 4/1 | s:sd bandf:8000 ]",
-  "[ 3/1 → 10/3 | s:hh bandf:8000 ]",
-  "[ 10/3 → 11/3 | s:hh bandf:8000 ]",
-  "[ 11/3 → 4/1 | s:hh bandf:8000 ]",
+  "[ 0/1 → 1/2 | s:bd bpf:1000 ]",
+  "[ 1/2 → 1/1 | s:sd bpf:1000 ]",
+  "[ 0/1 → 1/3 | s:hh bpf:1000 ]",
+  "[ 1/3 → 2/3 | s:hh bpf:1000 ]",
+  "[ 2/3 → 1/1 | s:hh bpf:1000 ]",
+  "[ 1/1 → 3/2 | s:bd bpf:2000 ]",
+  "[ 3/2 → 2/1 | s:sd bpf:2000 ]",
+  "[ 1/1 → 4/3 | s:hh bpf:2000 ]",
+  "[ 4/3 → 5/3 | s:hh bpf:2000 ]",
+  "[ 5/3 → 2/1 | s:hh bpf:2000 ]",
+  "[ 2/1 → 5/2 | s:bd bpf:4000 ]",
+  "[ 5/2 → 3/1 | s:sd bpf:4000 ]",
+  "[ 2/1 → 7/3 | s:hh bpf:4000 ]",
+  "[ 7/3 → 8/3 | s:hh bpf:4000 ]",
+  "[ 8/3 → 3/1 | s:hh bpf:4000 ]",
+  "[ 3/1 → 7/2 | s:bd bpf:8000 ]",
+  "[ 7/2 → 4/1 | s:sd bpf:8000 ]",
+  "[ 3/1 → 10/3 | s:hh bpf:8000 ]",
+  "[ 10/3 → 11/3 | s:hh bpf:8000 ]",
+  "[ 11/3 → 4/1 | s:hh bpf:8000 ]",
 ]
 `;
 
 exports[`runs examples > example "bpq" example index 0 1`] = `
 [
-  "[ 0/1 → 1/2 | s:bd bandf:500 bandq:0 ]",
-  "[ 1/2 → 1/1 | s:sd bandf:500 bandq:0 ]",
-  "[ 1/1 → 3/2 | s:bd bandf:500 bandq:1 ]",
-  "[ 3/2 → 2/1 | s:sd bandf:500 bandq:1 ]",
-  "[ 2/1 → 5/2 | s:bd bandf:500 bandq:2 ]",
-  "[ 5/2 → 3/1 | s:sd bandf:500 bandq:2 ]",
-  "[ 3/1 → 7/2 | s:bd bandf:500 bandq:3 ]",
-  "[ 7/2 → 4/1 | s:sd bandf:500 bandq:3 ]",
+  "[ 0/1 → 1/2 | s:bd bpf:500 bpq:0 ]",
+  "[ 1/2 → 1/1 | s:sd bpf:500 bpq:0 ]",
+  "[ 1/1 → 3/2 | s:bd bpf:500 bpq:1 ]",
+  "[ 3/2 → 2/1 | s:sd bpf:500 bpq:1 ]",
+  "[ 2/1 → 5/2 | s:bd bpf:500 bpq:2 ]",
+  "[ 5/2 → 3/1 | s:sd bpf:500 bpq:2 ]",
+  "[ 3/1 → 7/2 | s:bd bpf:500 bpq:3 ]",
+  "[ 7/2 → 4/1 | s:sd bpf:500 bpq:3 ]",
 ]
 `;
 
@@ -1399,19 +1399,6 @@ exports[`runs examples > example "delay" example index 0 1`] = `
 ]
 `;
 
-exports[`runs examples > example "delay" example index 1 1`] = `
-[
-  "[ 0/1 → 1/2 | s:bd delay:0.65 delaytime:0.25 delayfeedback:0.9 ]",
-  "[ 1/2 → 1/1 | s:bd delay:0.65 delaytime:0.125 delayfeedback:0.7 ]",
-  "[ 1/1 → 3/2 | s:bd delay:0.65 delaytime:0.25 delayfeedback:0.9 ]",
-  "[ 3/2 → 2/1 | s:bd delay:0.65 delaytime:0.125 delayfeedback:0.7 ]",
-  "[ 2/1 → 5/2 | s:bd delay:0.65 delaytime:0.25 delayfeedback:0.9 ]",
-  "[ 5/2 → 3/1 | s:bd delay:0.65 delaytime:0.125 delayfeedback:0.7 ]",
-  "[ 3/1 → 7/2 | s:bd delay:0.65 delaytime:0.25 delayfeedback:0.9 ]",
-  "[ 7/2 → 4/1 | s:bd delay:0.65 delaytime:0.125 delayfeedback:0.7 ]",
-]
-`;
-
 exports[`runs examples > example "delayfeedback" example index 0 1`] = `
 [
   "[ (0/1 → 1/1) ⇝ 2/1 | s:bd delay:0.25 delayfeedback:0.25 ]",
@@ -1909,107 +1896,78 @@ exports[`runs examples > example "gain" example index 0 1`] = `
 
 exports[`runs examples > example "hpf" example index 0 1`] = `
 [
-  "[ 0/1 → 1/2 | s:bd hcutoff:4000 ]",
-  "[ 1/2 → 1/1 | s:sd hcutoff:4000 ]",
-  "[ 0/1 → 1/4 | s:hh hcutoff:4000 ]",
-  "[ 1/4 → 1/2 | s:hh hcutoff:4000 ]",
-  "[ 1/2 → 3/4 | s:hh hcutoff:4000 ]",
-  "[ 3/4 → 1/1 | s:hh hcutoff:4000 ]",
-  "[ 1/1 → 3/2 | s:bd hcutoff:2000 ]",
-  "[ 3/2 → 2/1 | s:sd hcutoff:2000 ]",
-  "[ 1/1 → 5/4 | s:hh hcutoff:2000 ]",
-  "[ 5/4 → 3/2 | s:hh hcutoff:2000 ]",
-  "[ 3/2 → 7/4 | s:hh hcutoff:2000 ]",
-  "[ 7/4 → 2/1 | s:hh hcutoff:2000 ]",
-  "[ 2/1 → 5/2 | s:bd hcutoff:1000 ]",
-  "[ 5/2 → 3/1 | s:sd hcutoff:1000 ]",
-  "[ 2/1 → 9/4 | s:hh hcutoff:1000 ]",
-  "[ 9/4 → 5/2 | s:hh hcutoff:1000 ]",
-  "[ 5/2 → 11/4 | s:hh hcutoff:1000 ]",
-  "[ 11/4 → 3/1 | s:hh hcutoff:1000 ]",
-  "[ 3/1 → 7/2 | s:bd hcutoff:500 ]",
-  "[ 7/2 → 4/1 | s:sd hcutoff:500 ]",
-  "[ 3/1 → 13/4 | s:hh hcutoff:500 ]",
-  "[ 13/4 → 7/2 | s:hh hcutoff:500 ]",
-  "[ 7/2 → 15/4 | s:hh hcutoff:500 ]",
-  "[ 15/4 → 4/1 | s:hh hcutoff:500 ]",
-]
-`;
-
-exports[`runs examples > example "hpf" example index 1 1`] = `
-[
-  "[ 0/1 → 1/2 | s:bd hcutoff:2000 ]",
-  "[ 1/2 → 1/1 | s:sd hcutoff:2000 ]",
-  "[ 0/1 → 1/4 | s:hh hcutoff:2000 ]",
-  "[ 1/4 → 1/2 | s:hh hcutoff:2000 ]",
-  "[ 1/2 → 3/4 | s:hh hcutoff:2000 ]",
-  "[ 3/4 → 1/1 | s:hh hcutoff:2000 ]",
-  "[ 1/1 → 3/2 | s:bd hcutoff:2000 hresonance:25 ]",
-  "[ 3/2 → 2/1 | s:sd hcutoff:2000 hresonance:25 ]",
-  "[ 1/1 → 5/4 | s:hh hcutoff:2000 hresonance:25 ]",
-  "[ 5/4 → 3/2 | s:hh hcutoff:2000 hresonance:25 ]",
-  "[ 3/2 → 7/4 | s:hh hcutoff:2000 hresonance:25 ]",
-  "[ 7/4 → 2/1 | s:hh hcutoff:2000 hresonance:25 ]",
-  "[ 2/1 → 5/2 | s:bd hcutoff:2000 ]",
-  "[ 5/2 → 3/1 | s:sd hcutoff:2000 ]",
-  "[ 2/1 → 9/4 | s:hh hcutoff:2000 ]",
-  "[ 9/4 → 5/2 | s:hh hcutoff:2000 ]",
-  "[ 5/2 → 11/4 | s:hh hcutoff:2000 ]",
-  "[ 11/4 → 3/1 | s:hh hcutoff:2000 ]",
-  "[ 3/1 → 7/2 | s:bd hcutoff:2000 hresonance:25 ]",
-  "[ 7/2 → 4/1 | s:sd hcutoff:2000 hresonance:25 ]",
-  "[ 3/1 → 13/4 | s:hh hcutoff:2000 hresonance:25 ]",
-  "[ 13/4 → 7/2 | s:hh hcutoff:2000 hresonance:25 ]",
-  "[ 7/2 → 15/4 | s:hh hcutoff:2000 hresonance:25 ]",
-  "[ 15/4 → 4/1 | s:hh hcutoff:2000 hresonance:25 ]",
+  "[ 0/1 → 1/2 | s:bd hpf:4000 ]",
+  "[ 1/2 → 1/1 | s:sd hpf:4000 ]",
+  "[ 0/1 → 1/4 | s:hh hpf:4000 ]",
+  "[ 1/4 → 1/2 | s:hh hpf:4000 ]",
+  "[ 1/2 → 3/4 | s:hh hpf:4000 ]",
+  "[ 3/4 → 1/1 | s:hh hpf:4000 ]",
+  "[ 1/1 → 3/2 | s:bd hpf:2000 ]",
+  "[ 3/2 → 2/1 | s:sd hpf:2000 ]",
+  "[ 1/1 → 5/4 | s:hh hpf:2000 ]",
+  "[ 5/4 → 3/2 | s:hh hpf:2000 ]",
+  "[ 3/2 → 7/4 | s:hh hpf:2000 ]",
+  "[ 7/4 → 2/1 | s:hh hpf:2000 ]",
+  "[ 2/1 → 5/2 | s:bd hpf:1000 ]",
+  "[ 5/2 → 3/1 | s:sd hpf:1000 ]",
+  "[ 2/1 → 9/4 | s:hh hpf:1000 ]",
+  "[ 9/4 → 5/2 | s:hh hpf:1000 ]",
+  "[ 5/2 → 11/4 | s:hh hpf:1000 ]",
+  "[ 11/4 → 3/1 | s:hh hpf:1000 ]",
+  "[ 3/1 → 7/2 | s:bd hpf:500 ]",
+  "[ 7/2 → 4/1 | s:sd hpf:500 ]",
+  "[ 3/1 → 13/4 | s:hh hpf:500 ]",
+  "[ 13/4 → 7/2 | s:hh hpf:500 ]",
+  "[ 7/2 → 15/4 | s:hh hpf:500 ]",
+  "[ 15/4 → 4/1 | s:hh hpf:500 ]",
 ]
 `;
 
 exports[`runs examples > example "hpq" example index 0 1`] = `
 [
-  "[ 0/1 → 1/2 | s:bd hcutoff:2000 hresonance:0 ]",
-  "[ 1/2 → 1/1 | s:sd hcutoff:2000 hresonance:0 ]",
-  "[ 0/1 → 1/4 | s:hh hcutoff:2000 hresonance:0 ]",
-  "[ 1/4 → 1/2 | s:hh hcutoff:2000 hresonance:0 ]",
-  "[ 1/2 → 3/4 | s:hh hcutoff:2000 hresonance:0 ]",
-  "[ 3/4 → 1/1 | s:hh hcutoff:2000 hresonance:0 ]",
-  "[ 1/1 → 3/2 | s:bd hcutoff:2000 hresonance:10 ]",
-  "[ 3/2 → 2/1 | s:sd hcutoff:2000 hresonance:10 ]",
-  "[ 1/1 → 5/4 | s:hh hcutoff:2000 hresonance:10 ]",
-  "[ 5/4 → 3/2 | s:hh hcutoff:2000 hresonance:10 ]",
-  "[ 3/2 → 7/4 | s:hh hcutoff:2000 hresonance:10 ]",
-  "[ 7/4 → 2/1 | s:hh hcutoff:2000 hresonance:10 ]",
-  "[ 2/1 → 5/2 | s:bd hcutoff:2000 hresonance:20 ]",
-  "[ 5/2 → 3/1 | s:sd hcutoff:2000 hresonance:20 ]",
-  "[ 2/1 → 9/4 | s:hh hcutoff:2000 hresonance:20 ]",
-  "[ 9/4 → 5/2 | s:hh hcutoff:2000 hresonance:20 ]",
-  "[ 5/2 → 11/4 | s:hh hcutoff:2000 hresonance:20 ]",
-  "[ 11/4 → 3/1 | s:hh hcutoff:2000 hresonance:20 ]",
-  "[ 3/1 → 7/2 | s:bd hcutoff:2000 hresonance:30 ]",
-  "[ 7/2 → 4/1 | s:sd hcutoff:2000 hresonance:30 ]",
-  "[ 3/1 → 13/4 | s:hh hcutoff:2000 hresonance:30 ]",
-  "[ 13/4 → 7/2 | s:hh hcutoff:2000 hresonance:30 ]",
-  "[ 7/2 → 15/4 | s:hh hcutoff:2000 hresonance:30 ]",
-  "[ 15/4 → 4/1 | s:hh hcutoff:2000 hresonance:30 ]",
+  "[ 0/1 → 1/2 | s:bd hpf:2000 hpq:0 ]",
+  "[ 1/2 → 1/1 | s:sd hpf:2000 hpq:0 ]",
+  "[ 0/1 → 1/4 | s:hh hpf:2000 hpq:0 ]",
+  "[ 1/4 → 1/2 | s:hh hpf:2000 hpq:0 ]",
+  "[ 1/2 → 3/4 | s:hh hpf:2000 hpq:0 ]",
+  "[ 3/4 → 1/1 | s:hh hpf:2000 hpq:0 ]",
+  "[ 1/1 → 3/2 | s:bd hpf:2000 hpq:10 ]",
+  "[ 3/2 → 2/1 | s:sd hpf:2000 hpq:10 ]",
+  "[ 1/1 → 5/4 | s:hh hpf:2000 hpq:10 ]",
+  "[ 5/4 → 3/2 | s:hh hpf:2000 hpq:10 ]",
+  "[ 3/2 → 7/4 | s:hh hpf:2000 hpq:10 ]",
+  "[ 7/4 → 2/1 | s:hh hpf:2000 hpq:10 ]",
+  "[ 2/1 → 5/2 | s:bd hpf:2000 hpq:20 ]",
+  "[ 5/2 → 3/1 | s:sd hpf:2000 hpq:20 ]",
+  "[ 2/1 → 9/4 | s:hh hpf:2000 hpq:20 ]",
+  "[ 9/4 → 5/2 | s:hh hpf:2000 hpq:20 ]",
+  "[ 5/2 → 11/4 | s:hh hpf:2000 hpq:20 ]",
+  "[ 11/4 → 3/1 | s:hh hpf:2000 hpq:20 ]",
+  "[ 3/1 → 7/2 | s:bd hpf:2000 hpq:30 ]",
+  "[ 7/2 → 4/1 | s:sd hpf:2000 hpq:30 ]",
+  "[ 3/1 → 13/4 | s:hh hpf:2000 hpq:30 ]",
+  "[ 13/4 → 7/2 | s:hh hpf:2000 hpq:30 ]",
+  "[ 7/2 → 15/4 | s:hh hpf:2000 hpq:30 ]",
+  "[ 15/4 → 4/1 | s:hh hpf:2000 hpq:30 ]",
 ]
 `;
 
 exports[`runs examples > example "hurry" example index 0 1`] = `
 [
   "[ 0/1 → 3/4 | s:bd speed:1 ]",
-  "[ (3/4 → 1/1) ⇝ 3/2 | s:sd n:2 speed:1 ]",
-  "[ 3/4 ⇜ (1/1 → 3/2) | s:sd n:2 speed:1 ]",
+  "[ (3/4 → 1/1) ⇝ 3/2 | s:sd:2 speed:1 ]",
+  "[ 3/4 ⇜ (1/1 → 3/2) | s:sd:2 speed:1 ]",
   "[ 3/2 → 15/8 | s:bd speed:2 ]",
-  "[ (15/8 → 2/1) ⇝ 9/4 | s:sd n:2 speed:2 ]",
-  "[ 15/8 ⇜ (2/1 → 9/4) | s:sd n:2 speed:2 ]",
+  "[ (15/8 → 2/1) ⇝ 9/4 | s:sd:2 speed:2 ]",
+  "[ 15/8 ⇜ (2/1 → 9/4) | s:sd:2 speed:2 ]",
   "[ 9/4 → 21/8 | s:bd speed:2 ]",
-  "[ 21/8 → 3/1 | s:sd n:2 speed:2 ]",
+  "[ 21/8 → 3/1 | s:sd:2 speed:2 ]",
   "[ 3/1 → 51/16 | s:bd speed:4 ]",
-  "[ 51/16 → 27/8 | s:sd n:2 speed:4 ]",
+  "[ 51/16 → 27/8 | s:sd:2 speed:4 ]",
   "[ 27/8 → 57/16 | s:bd speed:4 ]",
-  "[ 57/16 → 15/4 | s:sd n:2 speed:4 ]",
+  "[ 57/16 → 15/4 | s:sd:2 speed:4 ]",
   "[ 15/4 → 63/16 | s:bd speed:4 ]",
-  "[ (63/16 → 4/1) ⇝ 33/8 | s:sd n:2 speed:4 ]",
+  "[ (63/16 → 4/1) ⇝ 33/8 | s:sd:2 speed:4 ]",
 ]
 `;
 
@@ -2425,92 +2383,55 @@ exports[`runs examples > example "loopAtCps" example index 0 1`] = `
 
 exports[`runs examples > example "lpf" example index 0 1`] = `
 [
-  "[ 0/1 → 1/2 | s:bd cutoff:4000 ]",
-  "[ 1/2 → 1/1 | s:sd cutoff:4000 ]",
-  "[ 0/1 → 1/3 | s:hh cutoff:4000 ]",
-  "[ 1/3 → 2/3 | s:hh cutoff:4000 ]",
-  "[ 2/3 → 1/1 | s:hh cutoff:4000 ]",
-  "[ 1/1 → 3/2 | s:bd cutoff:2000 ]",
-  "[ 3/2 → 2/1 | s:sd cutoff:2000 ]",
-  "[ 1/1 → 4/3 | s:hh cutoff:2000 ]",
-  "[ 4/3 → 5/3 | s:hh cutoff:2000 ]",
-  "[ 5/3 → 2/1 | s:hh cutoff:2000 ]",
-  "[ 2/1 → 5/2 | s:bd cutoff:1000 ]",
-  "[ 5/2 → 3/1 | s:sd cutoff:1000 ]",
-  "[ 2/1 → 7/3 | s:hh cutoff:1000 ]",
-  "[ 7/3 → 8/3 | s:hh cutoff:1000 ]",
-  "[ 8/3 → 3/1 | s:hh cutoff:1000 ]",
-  "[ 3/1 → 7/2 | s:bd cutoff:500 ]",
-  "[ 7/2 → 4/1 | s:sd cutoff:500 ]",
-  "[ 3/1 → 10/3 | s:hh cutoff:500 ]",
-  "[ 10/3 → 11/3 | s:hh cutoff:500 ]",
-  "[ 11/3 → 4/1 | s:hh cutoff:500 ]",
-]
-`;
-
-exports[`runs examples > example "lpf" example index 1 1`] = `
-[
-  "[ 0/1 → 1/8 | s:bd cutoff:1000 resonance:0 ]",
-  "[ 1/8 → 1/4 | s:bd cutoff:1000 resonance:0 ]",
-  "[ 1/4 → 3/8 | s:bd cutoff:1000 resonance:10 ]",
-  "[ 3/8 → 1/2 | s:bd cutoff:1000 resonance:10 ]",
-  "[ 1/2 → 5/8 | s:bd cutoff:1000 resonance:20 ]",
-  "[ 5/8 → 3/4 | s:bd cutoff:1000 resonance:20 ]",
-  "[ 3/4 → 7/8 | s:bd cutoff:1000 resonance:30 ]",
-  "[ 7/8 → 1/1 | s:bd cutoff:1000 resonance:30 ]",
-  "[ 1/1 → 9/8 | s:bd cutoff:1000 resonance:0 ]",
-  "[ 9/8 → 5/4 | s:bd cutoff:1000 resonance:0 ]",
-  "[ 5/4 → 11/8 | s:bd cutoff:1000 resonance:10 ]",
-  "[ 11/8 → 3/2 | s:bd cutoff:1000 resonance:10 ]",
-  "[ 3/2 → 13/8 | s:bd cutoff:1000 resonance:20 ]",
-  "[ 13/8 → 7/4 | s:bd cutoff:1000 resonance:20 ]",
-  "[ 7/4 → 15/8 | s:bd cutoff:1000 resonance:30 ]",
-  "[ 15/8 → 2/1 | s:bd cutoff:1000 resonance:30 ]",
-  "[ 2/1 → 17/8 | s:bd cutoff:1000 resonance:0 ]",
-  "[ 17/8 → 9/4 | s:bd cutoff:1000 resonance:0 ]",
-  "[ 9/4 → 19/8 | s:bd cutoff:1000 resonance:10 ]",
-  "[ 19/8 → 5/2 | s:bd cutoff:1000 resonance:10 ]",
-  "[ 5/2 → 21/8 | s:bd cutoff:1000 resonance:20 ]",
-  "[ 21/8 → 11/4 | s:bd cutoff:1000 resonance:20 ]",
-  "[ 11/4 → 23/8 | s:bd cutoff:1000 resonance:30 ]",
-  "[ 23/8 → 3/1 | s:bd cutoff:1000 resonance:30 ]",
-  "[ 3/1 → 25/8 | s:bd cutoff:1000 resonance:0 ]",
-  "[ 25/8 → 13/4 | s:bd cutoff:1000 resonance:0 ]",
-  "[ 13/4 → 27/8 | s:bd cutoff:1000 resonance:10 ]",
-  "[ 27/8 → 7/2 | s:bd cutoff:1000 resonance:10 ]",
-  "[ 7/2 → 29/8 | s:bd cutoff:1000 resonance:20 ]",
-  "[ 29/8 → 15/4 | s:bd cutoff:1000 resonance:20 ]",
-  "[ 15/4 → 31/8 | s:bd cutoff:1000 resonance:30 ]",
-  "[ 31/8 → 4/1 | s:bd cutoff:1000 resonance:30 ]",
+  "[ 0/1 → 1/2 | s:bd lpf:4000 ]",
+  "[ 1/2 → 1/1 | s:sd lpf:4000 ]",
+  "[ 0/1 → 1/3 | s:hh lpf:4000 ]",
+  "[ 1/3 → 2/3 | s:hh lpf:4000 ]",
+  "[ 2/3 → 1/1 | s:hh lpf:4000 ]",
+  "[ 1/1 → 3/2 | s:bd lpf:2000 ]",
+  "[ 3/2 → 2/1 | s:sd lpf:2000 ]",
+  "[ 1/1 → 4/3 | s:hh lpf:2000 ]",
+  "[ 4/3 → 5/3 | s:hh lpf:2000 ]",
+  "[ 5/3 → 2/1 | s:hh lpf:2000 ]",
+  "[ 2/1 → 5/2 | s:bd lpf:1000 ]",
+  "[ 5/2 → 3/1 | s:sd lpf:1000 ]",
+  "[ 2/1 → 7/3 | s:hh lpf:1000 ]",
+  "[ 7/3 → 8/3 | s:hh lpf:1000 ]",
+  "[ 8/3 → 3/1 | s:hh lpf:1000 ]",
+  "[ 3/1 → 7/2 | s:bd lpf:500 ]",
+  "[ 7/2 → 4/1 | s:sd lpf:500 ]",
+  "[ 3/1 → 10/3 | s:hh lpf:500 ]",
+  "[ 10/3 → 11/3 | s:hh lpf:500 ]",
+  "[ 11/3 → 4/1 | s:hh lpf:500 ]",
 ]
 `;
 
 exports[`runs examples > example "lpq" example index 0 1`] = `
 [
-  "[ 0/1 → 1/2 | s:bd cutoff:2000 resonance:0 ]",
-  "[ 1/2 → 1/1 | s:sd cutoff:2000 resonance:0 ]",
-  "[ 0/1 → 1/4 | s:hh cutoff:2000 resonance:0 ]",
-  "[ 1/4 → 1/2 | s:hh cutoff:2000 resonance:0 ]",
-  "[ 1/2 → 3/4 | s:hh cutoff:2000 resonance:0 ]",
-  "[ 3/4 → 1/1 | s:hh cutoff:2000 resonance:0 ]",
-  "[ 1/1 → 3/2 | s:bd cutoff:2000 resonance:10 ]",
-  "[ 3/2 → 2/1 | s:sd cutoff:2000 resonance:10 ]",
-  "[ 1/1 → 5/4 | s:hh cutoff:2000 resonance:10 ]",
-  "[ 5/4 → 3/2 | s:hh cutoff:2000 resonance:10 ]",
-  "[ 3/2 → 7/4 | s:hh cutoff:2000 resonance:10 ]",
-  "[ 7/4 → 2/1 | s:hh cutoff:2000 resonance:10 ]",
-  "[ 2/1 → 5/2 | s:bd cutoff:2000 resonance:20 ]",
-  "[ 5/2 → 3/1 | s:sd cutoff:2000 resonance:20 ]",
-  "[ 2/1 → 9/4 | s:hh cutoff:2000 resonance:20 ]",
-  "[ 9/4 → 5/2 | s:hh cutoff:2000 resonance:20 ]",
-  "[ 5/2 → 11/4 | s:hh cutoff:2000 resonance:20 ]",
-  "[ 11/4 → 3/1 | s:hh cutoff:2000 resonance:20 ]",
-  "[ 3/1 → 7/2 | s:bd cutoff:2000 resonance:30 ]",
-  "[ 7/2 → 4/1 | s:sd cutoff:2000 resonance:30 ]",
-  "[ 3/1 → 13/4 | s:hh cutoff:2000 resonance:30 ]",
-  "[ 13/4 → 7/2 | s:hh cutoff:2000 resonance:30 ]",
-  "[ 7/2 → 15/4 | s:hh cutoff:2000 resonance:30 ]",
-  "[ 15/4 → 4/1 | s:hh cutoff:2000 resonance:30 ]",
+  "[ 0/1 → 1/2 | s:bd lpf:2000 lpq:0 ]",
+  "[ 1/2 → 1/1 | s:sd lpf:2000 lpq:0 ]",
+  "[ 0/1 → 1/4 | s:hh lpf:2000 lpq:0 ]",
+  "[ 1/4 → 1/2 | s:hh lpf:2000 lpq:0 ]",
+  "[ 1/2 → 3/4 | s:hh lpf:2000 lpq:0 ]",
+  "[ 3/4 → 1/1 | s:hh lpf:2000 lpq:0 ]",
+  "[ 1/1 → 3/2 | s:bd lpf:2000 lpq:10 ]",
+  "[ 3/2 → 2/1 | s:sd lpf:2000 lpq:10 ]",
+  "[ 1/1 → 5/4 | s:hh lpf:2000 lpq:10 ]",
+  "[ 5/4 → 3/2 | s:hh lpf:2000 lpq:10 ]",
+  "[ 3/2 → 7/4 | s:hh lpf:2000 lpq:10 ]",
+  "[ 7/4 → 2/1 | s:hh lpf:2000 lpq:10 ]",
+  "[ 2/1 → 5/2 | s:bd lpf:2000 lpq:20 ]",
+  "[ 5/2 → 3/1 | s:sd lpf:2000 lpq:20 ]",
+  "[ 2/1 → 9/4 | s:hh lpf:2000 lpq:20 ]",
+  "[ 9/4 → 5/2 | s:hh lpf:2000 lpq:20 ]",
+  "[ 5/2 → 11/4 | s:hh lpf:2000 lpq:20 ]",
+  "[ 11/4 → 3/1 | s:hh lpf:2000 lpq:20 ]",
+  "[ 3/1 → 7/2 | s:bd lpf:2000 lpq:30 ]",
+  "[ 7/2 → 4/1 | s:sd lpf:2000 lpq:30 ]",
+  "[ 3/1 → 13/4 | s:hh lpf:2000 lpq:30 ]",
+  "[ 13/4 → 7/2 | s:hh lpf:2000 lpq:30 ]",
+  "[ 7/2 → 15/4 | s:hh lpf:2000 lpq:30 ]",
+  "[ 15/4 → 4/1 | s:hh lpf:2000 lpq:30 ]",
 ]
 `;
 
@@ -3310,29 +3231,16 @@ exports[`runs examples > example "room" example index 0 1`] = `
 ]
 `;
 
-exports[`runs examples > example "room" example index 1 1`] = `
-[
-  "[ 0/1 → 1/2 | s:bd room:0.9 size:1 ]",
-  "[ 1/2 → 1/1 | s:sd room:0.9 size:1 ]",
-  "[ 1/1 → 3/2 | s:bd room:0.9 size:4 ]",
-  "[ 3/2 → 2/1 | s:sd room:0.9 size:4 ]",
-  "[ 2/1 → 5/2 | s:bd room:0.9 size:1 ]",
-  "[ 5/2 → 3/1 | s:sd room:0.9 size:1 ]",
-  "[ 3/1 → 7/2 | s:bd room:0.9 size:4 ]",
-  "[ 7/2 → 4/1 | s:sd room:0.9 size:4 ]",
-]
-`;
-
 exports[`runs examples > example "roomsize" example index 0 1`] = `
 [
-  "[ 0/1 → 1/2 | s:bd room:0.8 size:0 ]",
-  "[ 1/2 → 1/1 | s:sd room:0.8 size:0 ]",
-  "[ 1/1 → 3/2 | s:bd room:0.8 size:1 ]",
-  "[ 3/2 → 2/1 | s:sd room:0.8 size:1 ]",
-  "[ 2/1 → 5/2 | s:bd room:0.8 size:2 ]",
-  "[ 5/2 → 3/1 | s:sd room:0.8 size:2 ]",
-  "[ 3/1 → 7/2 | s:bd room:0.8 size:4 ]",
-  "[ 7/2 → 4/1 | s:sd room:0.8 size:4 ]",
+  "[ 0/1 → 1/2 | s:bd room:0.8 roomsize:0 ]",
+  "[ 1/2 → 1/1 | s:sd room:0.8 roomsize:0 ]",
+  "[ 1/1 → 3/2 | s:bd room:0.8 roomsize:1 ]",
+  "[ 3/2 → 2/1 | s:sd room:0.8 roomsize:1 ]",
+  "[ 2/1 → 5/2 | s:bd room:0.8 roomsize:2 ]",
+  "[ 5/2 → 3/1 | s:sd room:0.8 roomsize:2 ]",
+  "[ 3/1 → 7/2 | s:bd room:0.8 roomsize:4 ]",
+  "[ 7/2 → 4/1 | s:sd room:0.8 roomsize:4 ]",
 ]
 `;
 
@@ -3396,27 +3304,6 @@ exports[`runs examples > example "s" example index 0 1`] = `
 ]
 `;
 
-exports[`runs examples > example "s" example index 1 1`] = `
-[
-  "[ 0/1 → 1/4 | s:bd n:0 ]",
-  "[ 1/4 → 1/2 | s:bd n:1 ]",
-  "[ 1/2 → 3/4 | s:bd n:0 gain:0.3 ]",
-  "[ 3/4 → 1/1 | s:bd n:1 gain:1.4 ]",
-  "[ 1/1 → 5/4 | s:bd n:0 ]",
-  "[ 5/4 → 3/2 | s:bd n:1 ]",
-  "[ 3/2 → 7/4 | s:bd n:0 gain:0.3 ]",
-  "[ 7/4 → 2/1 | s:bd n:1 gain:1.4 ]",
-  "[ 2/1 → 9/4 | s:bd n:0 ]",
-  "[ 9/4 → 5/2 | s:bd n:1 ]",
-  "[ 5/2 → 11/4 | s:bd n:0 gain:0.3 ]",
-  "[ 11/4 → 3/1 | s:bd n:1 gain:1.4 ]",
-  "[ 3/1 → 13/4 | s:bd n:0 ]",
-  "[ 13/4 → 7/2 | s:bd n:1 ]",
-  "[ 7/2 → 15/4 | s:bd n:0 gain:0.3 ]",
-  "[ 15/4 → 4/1 | s:bd n:1 gain:1.4 ]",
-]
-`;
-
 exports[`runs examples > example "samples" example index 0 1`] = `
 [
   "[ 0/1 → 1/4 | s:bd ]",
@@ -3567,43 +3454,6 @@ exports[`runs examples > example "scale" example index 1 1`] = `
 ]
 `;
 
-exports[`runs examples > example "scale" example index 2 1`] = `
-[
-  "[ 7/8 → 1/1 | note:C2 s:folkharp ]",
-  "[ 3/4 → 7/8 | note:D2 s:folkharp ]",
-  "[ 5/8 → 3/4 | note:E2 s:folkharp ]",
-  "[ 1/2 → 5/8 | note:F2 s:folkharp ]",
-  "[ 3/8 → 1/2 | note:G2 s:folkharp ]",
-  "[ 1/4 → 3/8 | note:A2 s:folkharp ]",
-  "[ 1/8 → 1/4 | note:B2 s:folkharp ]",
-  "[ 0/1 → 1/8 | note:C3 s:folkharp ]",
-  "[ 15/8 → 2/1 | note:C2 s:folkharp ]",
-  "[ 7/4 → 15/8 | note:D2 s:folkharp ]",
-  "[ 13/8 → 7/4 | note:Eb2 s:folkharp ]",
-  "[ 3/2 → 13/8 | note:F2 s:folkharp ]",
-  "[ 11/8 → 3/2 | note:G2 s:folkharp ]",
-  "[ 5/4 → 11/8 | note:Ab2 s:folkharp ]",
-  "[ 9/8 → 5/4 | note:Bb2 s:folkharp ]",
-  "[ 1/1 → 9/8 | note:C3 s:folkharp ]",
-  "[ 23/8 → 3/1 | note:C2 s:folkharp ]",
-  "[ 11/4 → 23/8 | note:D2 s:folkharp ]",
-  "[ 21/8 → 11/4 | note:E2 s:folkharp ]",
-  "[ 5/2 → 21/8 | note:F2 s:folkharp ]",
-  "[ 19/8 → 5/2 | note:G2 s:folkharp ]",
-  "[ 9/4 → 19/8 | note:A2 s:folkharp ]",
-  "[ 17/8 → 9/4 | note:B2 s:folkharp ]",
-  "[ 2/1 → 17/8 | note:C3 s:folkharp ]",
-  "[ 31/8 → 4/1 | note:C2 s:folkharp ]",
-  "[ 15/4 → 31/8 | note:D2 s:folkharp ]",
-  "[ 29/8 → 15/4 | note:Eb2 s:folkharp ]",
-  "[ 7/2 → 29/8 | note:F2 s:folkharp ]",
-  "[ 27/8 → 7/2 | note:G2 s:folkharp ]",
-  "[ 13/4 → 27/8 | note:Ab2 s:folkharp ]",
-  "[ 25/8 → 13/4 | note:Bb2 s:folkharp ]",
-  "[ 3/1 → 25/8 | note:C3 s:folkharp ]",
-]
-`;
-
 exports[`runs examples > example "scaleTranspose" example index 0 1`] = `
 [
   "[ 0/1 → 1/2 | note:C3 ]",
@@ -3840,6 +3690,39 @@ exports[`runs examples > example "sine" example index 0 1`] = `
 ]
 `;
 
+exports[`runs examples > example "slice" example index 0 1`] = `
+[
+  "[ (15/16 → 1/1) ⇝ 9/8 | begin:0.25 end:0.375 _slices:8 s:breaks165 ]",
+  "[ 3/4 → 15/16 | begin:0.375 end:0.5 _slices:8 s:breaks165 ]",
+  "[ 21/32 → 3/4 | begin:0.5 end:0.625 _slices:8 s:breaks165 ]",
+  "[ 9/16 → 21/32 | begin:0 end:0.125 _slices:8 s:breaks165 ]",
+  "[ 3/8 → 9/16 | begin:0.625 end:0.75 _slices:8 s:breaks165 ]",
+  "[ 3/16 → 3/8 | begin:0.75 end:0.875 _slices:8 s:breaks165 ]",
+  "[ 0/1 → 3/16 | begin:0.875 end:1 _slices:8 s:breaks165 ]",
+  "[ 21/16 → 3/2 | begin:0 end:0.125 _slices:8 s:breaks165 ]",
+  "[ 9/8 → 21/16 | begin:0.125 end:0.25 _slices:8 s:breaks165 ]",
+  "[ 15/16 ⇜ (1/1 → 9/8) | begin:0.25 end:0.375 _slices:8 s:breaks165 ]",
+  "[ 3/2 → 27/16 | begin:0 end:0.125 _slices:8 s:breaks165 ]",
+  "[ 27/16 → 15/8 | begin:0.125 end:0.25 _slices:8 s:breaks165 ]",
+  "[ 15/8 → 63/32 | begin:0.25 end:0.375 _slices:8 s:breaks165 ]",
+  "[ (63/32 → 2/1) ⇝ 33/16 | begin:0.25 end:0.375 _slices:8 s:breaks165 ]",
+  "[ 63/32 ⇜ (2/1 → 33/16) | begin:0.25 end:0.375 _slices:8 s:breaks165 ]",
+  "[ 33/16 → 9/4 | begin:0.375 end:0.5 _slices:8 s:breaks165 ]",
+  "[ 9/4 → 75/32 | begin:0.5 end:0.625 _slices:8 s:breaks165 ]",
+  "[ 75/32 → 39/16 | begin:0 end:0.125 _slices:8 s:breaks165 ]",
+  "[ 39/16 → 21/8 | begin:0.625 end:0.75 _slices:8 s:breaks165 ]",
+  "[ 21/8 → 45/16 | begin:0.75 end:0.875 _slices:8 s:breaks165 ]",
+  "[ 45/16 → 3/1 | begin:0.875 end:1 _slices:8 s:breaks165 ]",
+  "[ 3/1 → 51/16 | begin:0 end:0.125 _slices:8 s:breaks165 ]",
+  "[ 51/16 → 27/8 | begin:0.125 end:0.25 _slices:8 s:breaks165 ]",
+  "[ 27/8 → 57/16 | begin:0.25 end:0.375 _slices:8 s:breaks165 ]",
+  "[ 57/16 → 15/4 | begin:0.375 end:0.5 _slices:8 s:breaks165 ]",
+  "[ 15/4 → 123/32 | begin:0.5 end:0.625 _slices:8 s:breaks165 ]",
+  "[ 123/32 → 63/16 | begin:0 end:0.125 _slices:8 s:breaks165 ]",
+  "[ (63/16 → 4/1) ⇝ 33/8 | begin:0.625 end:0.75 _slices:8 s:breaks165 ]",
+]
+`;
+
 exports[`runs examples > example "slow" example index 0 1`] = `
 [
   "[ 0/1 → 1/1 | s:bd ]",
@@ -3965,6 +3848,36 @@ exports[`runs examples > example "speed" example index 1 1`] = `
 ]
 `;
 
+exports[`runs examples > example "splice" example index 0 1`] = `
+[
+  "[ 0/1 → 5/26 | speed:0.65 unit:c begin:0 end:0.125 _slices:8 s:breaks165 ]",
+  "[ 5/26 → 5/13 | speed:0.65 unit:c begin:0.125 end:0.25 _slices:8 s:breaks165 ]",
+  "[ 5/13 → 20/39 | speed:0.9750000000000001 unit:c begin:0.25 end:0.375 _slices:8 s:breaks165 ]",
+  "[ 20/39 → 25/39 | speed:0.9750000000000001 unit:c begin:0.375 end:0.5 _slices:8 s:breaks165 ]",
+  "[ 25/39 → 10/13 | speed:0.9750000000000001 unit:c begin:0 end:0.125 _slices:8 s:breaks165 ]",
+  "[ 10/13 → 25/26 | speed:0.65 unit:c begin:0.375 end:0.5 _slices:8 s:breaks165 ]",
+  "[ (25/26 → 1/1) ⇝ 35/26 | speed:0.325 unit:c begin:0 end:0.125 _slices:8 s:breaks165 ]",
+  "[ 25/26 ⇜ (1/1 → 35/26) | speed:0.325 unit:c begin:0 end:0.125 _slices:8 s:breaks165 ]",
+  "[ 35/26 → 20/13 | speed:0.65 unit:c begin:0.875 end:1 _slices:8 s:breaks165 ]",
+  "[ 20/13 → 45/26 | speed:0.65 unit:c begin:0 end:0.125 _slices:8 s:breaks165 ]",
+  "[ 45/26 → 25/13 | speed:0.65 unit:c begin:0.125 end:0.25 _slices:8 s:breaks165 ]",
+  "[ (25/13 → 2/1) ⇝ 80/39 | speed:0.9750000000000001 unit:c begin:0.25 end:0.375 _slices:8 s:breaks165 ]",
+  "[ 25/13 ⇜ (2/1 → 80/39) | speed:0.9750000000000001 unit:c begin:0.25 end:0.375 _slices:8 s:breaks165 ]",
+  "[ 80/39 → 85/39 | speed:0.9750000000000001 unit:c begin:0.375 end:0.5 _slices:8 s:breaks165 ]",
+  "[ 85/39 → 30/13 | speed:0.9750000000000001 unit:c begin:0 end:0.125 _slices:8 s:breaks165 ]",
+  "[ 30/13 → 5/2 | speed:0.65 unit:c begin:0.375 end:0.5 _slices:8 s:breaks165 ]",
+  "[ 5/2 → 75/26 | speed:0.325 unit:c begin:0 end:0.125 _slices:8 s:breaks165 ]",
+  "[ (75/26 → 3/1) ⇝ 40/13 | speed:0.65 unit:c begin:0.875 end:1 _slices:8 s:breaks165 ]",
+  "[ 75/26 ⇜ (3/1 → 40/13) | speed:0.65 unit:c begin:0.875 end:1 _slices:8 s:breaks165 ]",
+  "[ 40/13 → 85/26 | speed:0.65 unit:c begin:0 end:0.125 _slices:8 s:breaks165 ]",
+  "[ 85/26 → 45/13 | speed:0.65 unit:c begin:0.125 end:0.25 _slices:8 s:breaks165 ]",
+  "[ 45/13 → 140/39 | speed:0.9750000000000001 unit:c begin:0.25 end:0.375 _slices:8 s:breaks165 ]",
+  "[ 140/39 → 145/39 | speed:0.9750000000000001 unit:c begin:0.375 end:0.5 _slices:8 s:breaks165 ]",
+  "[ 145/39 → 50/13 | speed:0.9750000000000001 unit:c begin:0 end:0.125 _slices:8 s:breaks165 ]",
+  "[ (50/13 → 4/1) ⇝ 105/26 | speed:0.65 unit:c begin:0.375 end:0.5 _slices:8 s:breaks165 ]",
+]
+`;
+
 exports[`runs examples > example "square" example index 0 1`] = `
 [
   "[ 0/1 → 1/2 | note:C3 ]",
@@ -4381,6 +4294,48 @@ exports[`runs examples > example "vowel" example index 0 1`] = `
 ]
 `;
 
+exports[`runs examples > example "weave" example index 0 1`] = `
+[
+  "[ 0/1 → 1/8 | pan:0.015625 s:bd ]",
+  "[ 3/8 → 1/2 | pan:0.109375 s:bd ]",
+  "[ 3/4 → 7/8 | pan:0.203125 s:bd ]",
+  "[ 1/1 → 9/8 | pan:0.265625 s:bd ]",
+  "[ 11/8 → 3/2 | pan:0.359375 s:bd ]",
+  "[ 7/4 → 15/8 | pan:0.453125 s:bd ]",
+  "[ 2/1 → 17/8 | pan:0.515625 s:bd ]",
+  "[ 19/8 → 5/2 | pan:0.609375 s:bd ]",
+  "[ 11/4 → 23/8 | pan:0.703125 s:bd ]",
+  "[ 3/1 → 25/8 | pan:0.765625 s:bd ]",
+  "[ 27/8 → 7/2 | pan:0.859375 s:bd ]",
+  "[ 15/4 → 31/8 | pan:0.953125 s:bd ]",
+  "[ 1/2 → 1/1 | pan:0.6875 s:sd ]",
+  "[ 3/2 → 2/1 | pan:0.9375 s:sd ]",
+  "[ 5/2 → 3/1 | pan:0.1875 s:sd ]",
+  "[ 7/2 → 4/1 | pan:0.4375 s:sd ]",
+]
+`;
+
+exports[`runs examples > example "weave" example index 1 1`] = `
+[
+  "[ 0/1 → 1/8 | n:0 s:bd ]",
+  "[ 3/8 → 1/2 | n:0 s:bd ]",
+  "[ 3/4 → 7/8 | n:0 s:bd ]",
+  "[ 1/1 → 9/8 | n:1 s:bd ]",
+  "[ 11/8 → 3/2 | n:1 s:bd ]",
+  "[ 7/4 → 15/8 | n:1 s:bd ]",
+  "[ 2/1 → 17/8 | n:2 s:bd ]",
+  "[ 19/8 → 5/2 | n:2 s:bd ]",
+  "[ 11/4 → 23/8 | n:2 s:bd ]",
+  "[ 3/1 → 25/8 | n:3 s:bd ]",
+  "[ 27/8 → 7/2 | n:3 s:bd ]",
+  "[ 15/4 → 31/8 | n:3 s:bd ]",
+  "[ 1/2 → 1/1 | n:4 s:sd ]",
+  "[ 3/2 → 2/1 | n:5 s:sd ]",
+  "[ 5/2 → 3/1 | n:6 s:sd ]",
+  "[ 7/2 → 4/1 | n:7 s:sd ]",
+]
+`;
+
 exports[`runs examples > example "webdirt" example index 0 1`] = `
 [
   "[ 0/1 → 1/8 | s:bd n:0 ]",

test/__snapshots__/tunes.test.mjs.snap

@@ -298,11 +298,11 @@ exports[`renders tunes > tune: bassFuge 1`] = `
   "[ -3/4 ⇜ (0/1 → 3/4) ⇝ 5/4 | note:C5 s:flbass n:0 gain:0.3 cutoff:2924.3791043233605 resonance:10 clip:1 ]",
   "[ -3/4 ⇜ (3/4 → 1/1) ⇝ 5/4 | note:A4 s:flbass n:0 gain:0.3 cutoff:2924.3791043233605 resonance:10 clip:1 ]",
   "[ -3/4 ⇜ (3/4 → 1/1) ⇝ 5/4 | note:C5 s:flbass n:0 gain:0.3 cutoff:2924.3791043233605 resonance:10 clip:1 ]",
-  "[ 0/1 → 1/2 | s:bd n:1 ]",
-  "[ 1/2 → 1/1 | s:bd n:1 ]",
-  "[ 1/2 → 1/1 | s:sd n:0 ]",
-  "[ 1/4 → 1/2 | s:hh n:0 ]",
-  "[ 3/4 → 1/1 | s:hh n:0 ]",
+  "[ 0/1 → 1/2 | s:bd:1 ]",
+  "[ 1/2 → 1/1 | s:bd:1 ]",
+  "[ 1/2 → 1/1 | s:sd:0 ]",
+  "[ 1/4 → 1/2 | s:hh:0 ]",
+  "[ 3/4 → 1/1 | s:hh:0 ]",
 ]
 `;
 
@@ -313,7 +313,7 @@ exports[`renders tunes > tune: belldub 1`] = `
   "[ (5/8 → 1/1) ⇝ 5/4 | s:hh room:0 end:0.04483079938329212 ]",
   "[ 0/1 → 5/16 | s:mt gain:0.5 room:0.5 ]",
   "[ (15/16 → 1/1) ⇝ 5/4 | s:lt gain:0.5 room:0.5 ]",
-  "[ (0/1 → 1/1) ⇝ 5/1 | s:misc n:2 speed:1 delay:0.5 delaytime:0.3333333333333333 gain:0.4 ]",
+  "[ (0/1 → 1/1) ⇝ 5/1 | s:misc:2 speed:1 delay:0.5 delaytime:0.3333333333333333 gain:0.4 ]",
   "[ (5/8 → 1/1) ⇝ 5/4 | note:F3 s:sawtooth gain:0.5 cutoff:400.16785462816676 decay:0.05380063255866716 sustain:0 delay:0.9 room:1 ]",
   "[ (5/8 → 1/1) ⇝ 5/4 | note:A3 s:sawtooth gain:0.5 cutoff:400.16785462816676 decay:0.05380063255866716 sustain:0 delay:0.9 room:1 ]",
   "[ (5/8 → 1/1) ⇝ 5/4 | note:Bb3 s:sawtooth gain:0.5 cutoff:400.16785462816676 decay:0.05380063255866716 sustain:0 delay:0.9 room:1 ]",
@@ -6974,16 +6974,16 @@ exports[`renders tunes > tune: flatrave 1`] = `
   "[ 1/2 → 1/1 | s:bd bank:RolandTR909 ]",
   "[ 1/2 → 1/1 | s:cp bank:RolandTR909 ]",
   "[ 1/2 → 1/1 | s:sd bank:RolandTR909 ]",
-  "[ 0/1 → 1/4 | s:hh n:1 end:0.02000058072071123 bank:RolandTR909 room:0.5 gain:0.4 ]",
-  "[ 0/1 ⇜ (1/8 → 1/4) | s:hh n:1 end:0.02000058072071123 bank:RolandTR909 room:0.5 gain:0.4 ]",
-  "[ 1/4 → 3/8 | s:hh n:1 end:0.02000875429921906 bank:RolandTR909 room:0.5 gain:0.4 ]",
-  "[ 1/4 → 3/8 | s:hh n:1 end:0.02000875429921906 bank:RolandTR909 room:0.5 gain:0.4 ]",
-  "[ 3/8 → 1/2 | s:hh n:1 end:0.020023446730265706 bank:RolandTR909 room:0.5 gain:0.4 ]",
-  "[ 5/8 → 3/4 | s:hh n:1 end:0.020086608138500644 bank:RolandTR909 room:0.5 gain:0.4 ]",
-  "[ 5/8 → 3/4 | s:hh n:1 end:0.020086608138500644 bank:RolandTR909 room:0.5 gain:0.4 ]",
-  "[ 3/4 → 7/8 | s:hh n:1 end:0.02013941880355398 bank:RolandTR909 room:0.5 gain:0.4 ]",
-  "[ 1/8 → 1/4 | s:hh n:1 speed:0.5 delay:0.5 end:0.020001936784171157 bank:RolandTR909 room:0.5 gain:0.4 ]",
-  "[ 1/8 → 1/4 | s:hh n:1 speed:0.5 delay:0.5 end:0.020001936784171157 bank:RolandTR909 room:0.5 gain:0.4 ]",
+  "[ 0/1 → 1/4 | s:hh:1 end:0.02000058072071123 bank:RolandTR909 room:0.5 gain:0.4 ]",
+  "[ 0/1 ⇜ (1/8 → 1/4) | s:hh:1 end:0.02000058072071123 bank:RolandTR909 room:0.5 gain:0.4 ]",
+  "[ 1/4 → 3/8 | s:hh:1 end:0.02000875429921906 bank:RolandTR909 room:0.5 gain:0.4 ]",
+  "[ 1/4 → 3/8 | s:hh:1 end:0.02000875429921906 bank:RolandTR909 room:0.5 gain:0.4 ]",
+  "[ 3/8 → 1/2 | s:hh:1 end:0.020023446730265706 bank:RolandTR909 room:0.5 gain:0.4 ]",
+  "[ 5/8 → 3/4 | s:hh:1 end:0.020086608138500644 bank:RolandTR909 room:0.5 gain:0.4 ]",
+  "[ 5/8 → 3/4 | s:hh:1 end:0.020086608138500644 bank:RolandTR909 room:0.5 gain:0.4 ]",
+  "[ 3/4 → 7/8 | s:hh:1 end:0.02013941880355398 bank:RolandTR909 room:0.5 gain:0.4 ]",
+  "[ 1/8 → 1/4 | s:hh:1 speed:0.5 delay:0.5 end:0.020001936784171157 bank:RolandTR909 room:0.5 gain:0.4 ]",
+  "[ 1/8 → 1/4 | s:hh:1 speed:0.5 delay:0.5 end:0.020001936784171157 bank:RolandTR909 room:0.5 gain:0.4 ]",
   "[ 1/8 → 1/4 | note:G1 s:sawtooth decay:0.1 sustain:0 ]",
   "[ 1/4 → 3/8 | note:G1 s:sawtooth decay:0.1 sustain:0 ]",
   "[ 1/2 → 5/8 | note:G1 s:sawtooth decay:0.1 sustain:0 ]",
@@ -8127,8 +8127,8 @@ exports[`renders tunes > tune: loungeSponge 1`] = `
 
 exports[`renders tunes > tune: meltingsubmarine 1`] = `
 [
-  "[ (0/1 → 1/1) ⇝ 3/2 | s:bd n:5 speed:0.7519542165100574 ]",
-  "[ (3/4 → 1/1) ⇝ 3/2 | s:sd n:1 speed:0.7931522866332671 ]",
+  "[ (0/1 → 1/1) ⇝ 3/2 | s:bd:5 speed:0.7519542165100574 ]",
+  "[ (3/4 → 1/1) ⇝ 3/2 | s:sd:1 speed:0.7931522866332671 ]",
   "[ 3/8 → 3/4 | s:hh27 speed:0.7285963821098448 ]",
   "[ (3/4 → 1/1) ⇝ 9/8 | s:hh27 speed:0.77531205091027 ]",
   "[ (0/1 → 1/1) ⇝ 3/2 | note:33.129885541275144 decay:0.15 sustain:0 s:sawtooth gain:0.4 cutoff:3669.6267869262615 ]",
@@ -8364,15 +8364,15 @@ exports[`renders tunes > tune: randomBells 1`] = `
 
 exports[`renders tunes > tune: sampleDemo 1`] = `
 [
-  "[ 0/1 → 1/4 | s:woodblock n:1 ]",
-  "[ 1/4 → 3/8 | s:woodblock n:2 ]",
-  "[ 0/1 → 1/8 | s:brakedrum n:1 ]",
-  "[ 3/4 → 7/8 | s:brakedrum n:1 ]",
-  "[ 3/8 → 1/2 | s:woodblock n:2 speed:2 ]",
-  "[ 1/2 → 1/1 | s:snare_rim n:0 speed:2 ]",
+  "[ 0/1 → 1/4 | s:woodblock:1 ]",
+  "[ 1/4 → 3/8 | s:woodblock:2 ]",
+  "[ 0/1 → 1/8 | s:brakedrum:1 ]",
+  "[ 3/4 → 7/8 | s:brakedrum:1 ]",
+  "[ 3/8 → 1/2 | s:woodblock:2 speed:2 ]",
+  "[ 1/2 → 1/1 | s:snare_rim:0 speed:2 ]",
   "[ (0/1 → 1/1) ⇝ 8/1 | s:gong speed:2 ]",
-  "[ 3/8 → 1/2 | s:brakedrum n:1 speed:2 ]",
-  "[ 3/4 → 1/1 | s:cowbell n:3 speed:2 ]",
+  "[ 3/8 → 1/2 | s:brakedrum:1 speed:2 ]",
+  "[ 3/4 → 1/1 | s:cowbell:3 speed:2 ]",
   "[ -3/4 ⇜ (0/1 → 1/4) | note:Bb3 s:clavisynth gain:0.2 delay:0.25 pan:0 ]",
   "[ (3/4 → 1/1) ⇝ 7/4 | note:Bb3 s:clavisynth gain:0.2 delay:0.25 pan:1 ]",
   "[ -1/4 ⇜ (0/1 → 3/4) | note:F3 s:clavisynth gain:0.2 delay:0.25 pan:1 ]",

website/src/components/Header/Header.astro

@@ -19,10 +19,7 @@ const langCode = 'en'; // getLanguageFromURL(currentPage);
 const sidebar = SIDEBAR[langCode];
 ---
 
-<nav
-  class="flex justify-between py-2 px-4 items-center h-14 max-h-14 bg-lineHighlight text-foreground"
-  title="Top Navigation"
->
+<nav class="flex justify-between py-2 px-4 items-center h-14 max-h-14 bg-lineHighlight text-foreground" title="Top Navigation">
   <!--     <div class="menu-toggle">
       <SidebarToggle client:idle />
     </div> -->
@@ -39,7 +36,7 @@ const sidebar = SIDEBAR[langCode];
   </div>
   {/* KNOWN_LANGUAGE_CODES.length > 1 && <LanguageSelect lang={lang} client:idle /> */}
   <div class="search-item h-10">
-    <!-- <Search client:idle /> -->
+    <!--     <Search client:idle /> -->
   </div>
   <a href="./" class="hidden md:flex cursor-pointer items-center space-x-1"
     ><CommandLineIcon className="w-5 h-5" /><span>go to REPL</span>

website/src/components/LeftSidebar/LeftSidebar.astro

@@ -23,7 +23,7 @@ const sidebar = SIDEBAR[langCode];
             <h2>{header}</h2>
             <ul>
               {children.map((child) => {
-                const url = Astro.site?.pathname + child.link;
+                const url = '.' + Astro.site?.pathname + child.link;
                 return (
                   <li class="">
                     <a

website/src/config.ts

@@ -33,9 +33,9 @@ export const COMMUNITY_INVITE_URL = `https://discord.com/invite/HGEdXmRkzT`;
 
 // See "Algolia" section of the README for more information.
 export const ALGOLIA = {
-  indexName: 'strudel-tidalcycles',
-  appId: 'SAZ71S8CLS',
-  apiKey: 'd5044f9d21b80e7721e5b0067a8730b1',
+  indexName: 'XXXXXXXXXX',
+  appId: 'XXXXXXXXXX',
+  apiKey: 'XXXXXXXXXX',
 };
 
 export type Sidebar = Record<(typeof KNOWN_LANGUAGE_CODES)[number], Record<string, { text: string; link: string }[]>>;

website/src/repl/Footer.jsx

@@ -92,7 +92,7 @@ export function Footer({ context }) {
           {activeFooter === 'console' && <ConsoleTab log={log} />}
           {activeFooter === 'samples' && <SamplesTab />}
           {activeFooter === 'reference' && <Reference />}
-          {activeFooter === 'settings' && <SettingsTab scheduler={context.scheduler} />}
+          {activeFooter === 'settings' && <SettingsTab />}
         </div>
       )}
     </footer>
@@ -284,28 +284,10 @@ const fontFamilyOptions = {
   PressStart: 'PressStart2P',
 };
 
-function SettingsTab({ scheduler }) {
+function SettingsTab() {
   const { theme, keybindings, fontSize, fontFamily } = useSettings();
   return (
     <div className="text-foreground p-4 space-y-4">
-      {/* <FormItem label="Tempo">
-        <div className="space-x-4">
-          <button
-            onClick={() => {
-              scheduler.setCps(scheduler.cps - 0.1);
-            }}
-          >
-            slower
-          </button>
-          <button
-            onClick={() => {
-              scheduler.setCps(scheduler.cps + 0.1);
-            }}
-          >
-            faster
-          </button>
-        </div>
-      </FormItem> */}
       <FormItem label="Theme">
         <SelectInput options={themeOptions} value={theme} onChange={(theme) => settingsMap.setKey('theme', theme)} />
       </FormItem>

website/src/repl/Repl.jsx

@@ -242,7 +242,6 @@ export function Repl({ embedded = false }) {
     }
   };
   const context = {
-    scheduler,
     embedded,
     started,
     pending,
@@ -274,10 +273,7 @@ export function Repl({ embedded = false }) {
             fontSize={fontSize}
             fontFamily={fontFamily}
             onChange={handleChangeCode}
-            onViewChanged={(v) => {
-              setView(v);
-              // window.editorView = v;
-            }}
+            onViewChanged={setView}
             onSelectionChange={handleSelectionChange}
           />
         </section>