remove pesky ticks and do it right

.gitignore

@@ -26,5 +26,4 @@ node_modules/
 .DS_Store
 repl-parcel
 mytunes.ts
-doc
-.parcel-cache
+doc

CONTRIBUTING.md

@@ -1,111 +0,0 @@
-# 🌀 Contributing to Strudel 🌀
-
-Thanks for wanting to contribute!!! There are many ways you can add value to this project
-
-## Communication Channels
-
-To get in touch with the contributors, either
-
-- open a [github discussion](https://github.com/tidalcycles/strudel/discussions) or
-- [join the Tidal Discord Channel](https://discord.gg/remJ6gQA) and go to the #strudel channel
-- Find related discussions on the [tidal club forum](https://club.tidalcycles.org/)
-
-## Ask a Question
-
-If you have any questions about strudel, make sure you've read the 
-[tutorial](https://strudel.tidalcycles.org/tutorial/) to find out if it answers your question.
-If not, use one of the Communication Channels above!
-
-Don't be afraid to ask! Your question might be of great value for other people too.
-
-## Give Feedback
-
-No matter if you've used the Strudel REPL or if you are using the strudel packages, we are happy to hear some feedback.
-Use one of the Communication Channels listed above and drop us a line or two!
-
-## Share Music
-
-If you made some music with strudel, you can give back some love and share what you've done!
-Your creation could also be part of the random selection in the REPL if you want.
-Use one of the Communication Channels listed above.
-
-## Improve the Tutorial
-
-If you find some weak spots in the [tutorial](https://strudel.tidalcycles.org/), 
-you are welcome to improve them by editing [this file](https://github.com/tidalcycles/strudel/blob/main/repl/src/tutorial/tutorial.mdx).
-This will even work without setting up a development environment, only a github account is required.
-
-## Propose a Feature
-
-If you want a specific feature that is not part of strudel yet, feel free to use one of the communication channels above.
-Maybe you even want to help with the implementation of that feature!
-
-## Report a Bug
-
-If you've found a bug, or some behaviour that does not seem right, you are welcome to file an [issue](https://github.com/tidalcycles/strudel/issues).
-Please check that it has not been reported before.
-
-## Fix a Bug
-
-To fix a bug that has been reported,
-
-1. check that nobody else is already fixing it and respond to the issue to let people know you're on it
-3. fork the repository
-4. make sure you've setup the project (see below)
-5. hopefully fix the bug
-6. make sure the tests pass
-7. send a pull request
-
-## Write Tests
-
-There are still many tests that have not been written yet! Reading and writing tests is a great opportunity to get familiar with the codebase.
-You can find the tests in each package in the `test` folder. To run all tests, run `npm test` from the root folder.
-
-## Project Setup
-
-To get the project up and running for development, make sure you have installed:
-
-- git
-- node, preferably v16
-
-then, do the following:
-
-```sh
-git clone https://github.com/tidalcycles/strudel.git && cd strudel
-npm i # install at root to symlink packages
-npx lerna bootstrap # install all dependencies in packages
-cd repl && npm i # install repl dependencies
-npm run start # start repl
-```
-
-Those commands might look slightly different for your OS. 
-Please report any problems you've had with the setup instructions!
-
-## Code Style
-
-To make sure the code changes only where it should, we are using prettier to unify the code style.
-If you use VSCode, you can
-
-1. install [the prettier extension](https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode)
-2. open command palette and run "Format Document With..."
-3. Choose "Configure Default Formatter..."
-4. Select prettier
-
-## Package Workflow
-
-The project is split into multiple [packages](https://github.com/tidalcycles/strudel/tree/main/packages) with independent versioning.
-When you run `npm i` on the root folder, [npm workspaces](https://docs.npmjs.com/cli/v7/using-npm/workspaces) will symlink all packages
-in the `node_modules` folder. This will allow any js file to import `@strudel.cycles/<package-name>` to get the local version, 
-which allows developing multiple packages at the same time
-
-## Package Publishing
-
-To publish all packages that have been changed since the last release, run:
-
-```sh
-npx lerna publish
-```
-
-## Have Fun
-
-Remember to have fun, and that this project is driven by the passion of volunteers!

README.md

@@ -4,42 +4,40 @@
 
 An experiment in making a [Tidal](https://github.com/tidalcycles/tidal/) using web technologies. This is unstable software, please tread carefully.
 
-- Try it here: <https://strudel.tidalcycles.org/>
-- Tutorial: <https://strudel.tidalcycles.org/tutorial/>
-- Technical Blog Post: <https://loophole-letters.vercel.app/strudel>
+Try it here: https://strudel.tidalcycles.org/
 
-## Running Locally
+Tutorial: https://strudel.tidalcycles.org/tutorial/
 
-After cloning the project, you can run the REPL locally:
+## Local development
+
+Run the REPL locally:
 
 ```bash
-npm run setup
-npm run repl
+npm install
+npx lerna bootstrap
+cd repl
+npm install
+npm run start
 ```
 
-## Using Strudel In Your Project
+## Publish Packages
 
-There are multiple npm packages you can use to use strudel, or only parts of it, in your project:
+To publish, just run:
 
-- [`core`](./packages/core/): tidal pattern engine
-- [`mini`](./packages/mini): mini notation parser + core binding
-- [`eval`](./packages/eval): user code evaluator. syntax sugar + highlighting
-- [`tone`](./packages/tone): bindings for Tone.js instruments and effects
-- [`osc`](./packages/osc): bindings to communicate via OSC
-- [`midi`](./packages/midi): webmidi bindings
-- [`tonal`](./packages/tonal): tonal functions
-- [`xen`](./packages/xen): microtonal / xenharmonic functions
+```sh
+npx lerna version
+```
 
-Click on the package names to find out more about each one.
+This will publish all packages that changed since the last version.
 
-## Contributing
+## Style
 
-There are many ways to contribute to this project! See [contribution guide](./CONTRIBUTING.md).
+For now, please try to copy the style of surrounding code. VS Code users can install the 'prettier' add-on which will use the .prettierrc configuration file for automatic formatting.
 
 ## Community
 
-There is a #strudel channel on the TidalCycles discord: <https://discord.com/invite/HGEdXmRkzT>
+There is a #strudel channel on the TidalCycles discord: https://discord.com/invite/HGEdXmRkzT
 
-You can also ask questions and find related discussions on the tidal club forum: <https://club.tidalcycles.org/>
+You can also ask questions and find related discussions on the tidal club forum: https://club.tidalcycles.org/
 
-The discord and forum is shared with the haskell (tidal) and python (vortex) siblings of this project.
+The discord and forum is shared with the haskell (tidal) and python (vortex) siblings of this project.

docs/asset-manifest.json

@@ -1,16 +1,16 @@
 {
   "files": {
     "main.css": "/static/css/main.0d689283.css",
-    "main.js": "/static/js/main.7e790d7f.js",
-    "static/js/787.1c52cb78.chunk.js": "/static/js/787.1c52cb78.chunk.js",
+    "main.js": "/static/js/main.77e38ada.js",
+    "static/js/787.8f7ec9e0.chunk.js": "/static/js/787.8f7ec9e0.chunk.js",
     "static/media/logo.svg": "/static/media/logo.ac95051720b3dccfe511e0e02d8e1029.svg",
     "index.html": "/index.html",
     "main.0d689283.css.map": "/static/css/main.0d689283.css.map",
-    "main.7e790d7f.js.map": "/static/js/main.7e790d7f.js.map",
-    "787.1c52cb78.chunk.js.map": "/static/js/787.1c52cb78.chunk.js.map"
+    "main.77e38ada.js.map": "/static/js/main.77e38ada.js.map",
+    "787.8f7ec9e0.chunk.js.map": "/static/js/787.8f7ec9e0.chunk.js.map"
   },
   "entrypoints": [
     "static/css/main.0d689283.css",
-    "static/js/main.7e790d7f.js"
+    "static/js/main.77e38ada.js"
   ]
 }

docs/index.html

@@ -1 +1 @@
-<!doctype html><html lang="en"><head><meta charset="utf-8"/><link rel="icon" href="/favicon.ico"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><meta name="description" content="Strudel REPL"/><title>Strudel REPL</title><script defer="defer" src="/static/js/main.7e790d7f.js"></script><link href="/static/css/main.0d689283.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>
+<!doctype html><html lang="en"><head><meta charset="utf-8"/><link rel="icon" href="/favicon.ico"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><meta name="description" content="Strudel REPL"/><title>Strudel REPL</title><script defer="defer" src="/static/js/main.77e38ada.js"></script><link href="/static/css/main.0d689283.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>

docs/static/js/787.1c52cb78.chunk.js

@@ -1,2 +0,0 @@
-"use strict";(self.webpackChunk_strudel_cycles_repl=self.webpackChunk_strudel_cycles_repl||[]).push([[787],{787:function(e,t,n){n.r(t),n.d(t,{getCLS:function(){return y},getFCP:function(){return g},getFID:function(){return C},getLCP:function(){return P},getTTFB:function(){return D}});var i,r,a,o,u=function(e,t){return{name:e,value:void 0===t?-1:t,delta:0,entries:[],id:"v2-".concat(Date.now(),"-").concat(Math.floor(8999999999999*Math.random())+1e12)}},c=function(e,t){try{if(PerformanceObserver.supportedEntryTypes.includes(e)){if("first-input"===e&&!("PerformanceEventTiming"in self))return;var n=new PerformanceObserver((function(e){return e.getEntries().map(t)}));return n.observe({type:e,buffered:!0}),n}}catch(e){}},f=function(e,t){var n=function n(i){"pagehide"!==i.type&&"hidden"!==document.visibilityState||(e(i),t&&(removeEventListener("visibilitychange",n,!0),removeEventListener("pagehide",n,!0)))};addEventListener("visibilitychange",n,!0),addEventListener("pagehide",n,!0)},s=function(e){addEventListener("pageshow",(function(t){t.persisted&&e(t)}),!0)},m=function(e,t,n){var i;return function(r){t.value>=0&&(r||n)&&(t.delta=t.value-(i||0),(t.delta||void 0===i)&&(i=t.value,e(t)))}},v=-1,p=function(){return"hidden"===document.visibilityState?0:1/0},d=function(){f((function(e){var t=e.timeStamp;v=t}),!0)},l=function(){return v<0&&(v=p(),d(),s((function(){setTimeout((function(){v=p(),d()}),0)}))),{get firstHiddenTime(){return v}}},g=function(e,t){var n,i=l(),r=u("FCP"),a=function(e){"first-contentful-paint"===e.name&&(f&&f.disconnect(),e.startTime<i.firstHiddenTime&&(r.value=e.startTime,r.entries.push(e),n(!0)))},o=window.performance&&performance.getEntriesByName&&performance.getEntriesByName("first-contentful-paint")[0],f=o?null:c("paint",a);(o||f)&&(n=m(e,r,t),o&&a(o),s((function(i){r=u("FCP"),n=m(e,r,t),requestAnimationFrame((function(){requestAnimationFrame((function(){r.value=performance.now()-i.timeStamp,n(!0)}))}))})))},h=!1,T=-1,y=function(e,t){h||(g((function(e){T=e.value})),h=!0);var n,i=function(t){T>-1&&e(t)},r=u("CLS",0),a=0,o=[],v=function(e){if(!e.hadRecentInput){var t=o[0],i=o[o.length-1];a&&e.startTime-i.startTime<1e3&&e.startTime-t.startTime<5e3?(a+=e.value,o.push(e)):(a=e.value,o=[e]),a>r.value&&(r.value=a,r.entries=o,n())}},p=c("layout-shift",v);p&&(n=m(i,r,t),f((function(){p.takeRecords().map(v),n(!0)})),s((function(){a=0,T=-1,r=u("CLS",0),n=m(i,r,t)})))},E={passive:!0,capture:!0},w=new Date,L=function(e,t){i||(i=t,r=e,a=new Date,F(removeEventListener),S())},S=function(){if(r>=0&&r<a-w){var e={entryType:"first-input",name:i.type,target:i.target,cancelable:i.cancelable,startTime:i.timeStamp,processingStart:i.timeStamp+r};o.forEach((function(t){t(e)})),o=[]}},b=function(e){if(e.cancelable){var t=(e.timeStamp>1e12?new Date:performance.now())-e.timeStamp;"pointerdown"==e.type?function(e,t){var n=function(){L(e,t),r()},i=function(){r()},r=function(){removeEventListener("pointerup",n,E),removeEventListener("pointercancel",i,E)};addEventListener("pointerup",n,E),addEventListener("pointercancel",i,E)}(t,e):L(t,e)}},F=function(e){["mousedown","keydown","touchstart","pointerdown"].forEach((function(t){return e(t,b,E)}))},C=function(e,t){var n,a=l(),v=u("FID"),p=function(e){e.startTime<a.firstHiddenTime&&(v.value=e.processingStart-e.startTime,v.entries.push(e),n(!0))},d=c("first-input",p);n=m(e,v,t),d&&f((function(){d.takeRecords().map(p),d.disconnect()}),!0),d&&s((function(){var a;v=u("FID"),n=m(e,v,t),o=[],r=-1,i=null,F(addEventListener),a=p,o.push(a),S()}))},k={},P=function(e,t){var n,i=l(),r=u("LCP"),a=function(e){var t=e.startTime;t<i.firstHiddenTime&&(r.value=t,r.entries.push(e),n())},o=c("largest-contentful-paint",a);if(o){n=m(e,r,t);var v=function(){k[r.id]||(o.takeRecords().map(a),o.disconnect(),k[r.id]=!0,n(!0))};["keydown","click"].forEach((function(e){addEventListener(e,v,{once:!0,capture:!0})})),f(v,!0),s((function(i){r=u("LCP"),n=m(e,r,t),requestAnimationFrame((function(){requestAnimationFrame((function(){r.value=performance.now()-i.timeStamp,k[r.id]=!0,n(!0)}))}))}))}},D=function(e){var t,n=u("TTFB");t=function(){try{var t=performance.getEntriesByType("navigation")[0]||function(){var e=performance.timing,t={entryType:"navigation",startTime:0};for(var n in e)"navigationStart"!==n&&"toJSON"!==n&&(t[n]=Math.max(e[n]-e.navigationStart,0));return t}();if(n.value=n.delta=t.responseStart,n.value<0||n.value>performance.now())return;n.entries=[t],e(n)}catch(e){}},"complete"===document.readyState?setTimeout(t,0):addEventListener("load",(function(){return setTimeout(t,0)}))}}}]);
-//# sourceMappingURL=787.1c52cb78.chunk.js.map

docs/static/js/787.8f7ec9e0.chunk.js

@@ -0,0 +1,2 @@
+"use strict";(self.webpackChunk_strudel_repl=self.webpackChunk_strudel_repl||[]).push([[787],{787:function(e,t,n){n.r(t),n.d(t,{getCLS:function(){return y},getFCP:function(){return g},getFID:function(){return C},getLCP:function(){return P},getTTFB:function(){return D}});var i,r,a,o,u=function(e,t){return{name:e,value:void 0===t?-1:t,delta:0,entries:[],id:"v2-".concat(Date.now(),"-").concat(Math.floor(8999999999999*Math.random())+1e12)}},c=function(e,t){try{if(PerformanceObserver.supportedEntryTypes.includes(e)){if("first-input"===e&&!("PerformanceEventTiming"in self))return;var n=new PerformanceObserver((function(e){return e.getEntries().map(t)}));return n.observe({type:e,buffered:!0}),n}}catch(e){}},f=function(e,t){var n=function n(i){"pagehide"!==i.type&&"hidden"!==document.visibilityState||(e(i),t&&(removeEventListener("visibilitychange",n,!0),removeEventListener("pagehide",n,!0)))};addEventListener("visibilitychange",n,!0),addEventListener("pagehide",n,!0)},s=function(e){addEventListener("pageshow",(function(t){t.persisted&&e(t)}),!0)},m=function(e,t,n){var i;return function(r){t.value>=0&&(r||n)&&(t.delta=t.value-(i||0),(t.delta||void 0===i)&&(i=t.value,e(t)))}},v=-1,p=function(){return"hidden"===document.visibilityState?0:1/0},d=function(){f((function(e){var t=e.timeStamp;v=t}),!0)},l=function(){return v<0&&(v=p(),d(),s((function(){setTimeout((function(){v=p(),d()}),0)}))),{get firstHiddenTime(){return v}}},g=function(e,t){var n,i=l(),r=u("FCP"),a=function(e){"first-contentful-paint"===e.name&&(f&&f.disconnect(),e.startTime<i.firstHiddenTime&&(r.value=e.startTime,r.entries.push(e),n(!0)))},o=window.performance&&performance.getEntriesByName&&performance.getEntriesByName("first-contentful-paint")[0],f=o?null:c("paint",a);(o||f)&&(n=m(e,r,t),o&&a(o),s((function(i){r=u("FCP"),n=m(e,r,t),requestAnimationFrame((function(){requestAnimationFrame((function(){r.value=performance.now()-i.timeStamp,n(!0)}))}))})))},h=!1,T=-1,y=function(e,t){h||(g((function(e){T=e.value})),h=!0);var n,i=function(t){T>-1&&e(t)},r=u("CLS",0),a=0,o=[],v=function(e){if(!e.hadRecentInput){var t=o[0],i=o[o.length-1];a&&e.startTime-i.startTime<1e3&&e.startTime-t.startTime<5e3?(a+=e.value,o.push(e)):(a=e.value,o=[e]),a>r.value&&(r.value=a,r.entries=o,n())}},p=c("layout-shift",v);p&&(n=m(i,r,t),f((function(){p.takeRecords().map(v),n(!0)})),s((function(){a=0,T=-1,r=u("CLS",0),n=m(i,r,t)})))},E={passive:!0,capture:!0},w=new Date,L=function(e,t){i||(i=t,r=e,a=new Date,F(removeEventListener),S())},S=function(){if(r>=0&&r<a-w){var e={entryType:"first-input",name:i.type,target:i.target,cancelable:i.cancelable,startTime:i.timeStamp,processingStart:i.timeStamp+r};o.forEach((function(t){t(e)})),o=[]}},b=function(e){if(e.cancelable){var t=(e.timeStamp>1e12?new Date:performance.now())-e.timeStamp;"pointerdown"==e.type?function(e,t){var n=function(){L(e,t),r()},i=function(){r()},r=function(){removeEventListener("pointerup",n,E),removeEventListener("pointercancel",i,E)};addEventListener("pointerup",n,E),addEventListener("pointercancel",i,E)}(t,e):L(t,e)}},F=function(e){["mousedown","keydown","touchstart","pointerdown"].forEach((function(t){return e(t,b,E)}))},C=function(e,t){var n,a=l(),v=u("FID"),p=function(e){e.startTime<a.firstHiddenTime&&(v.value=e.processingStart-e.startTime,v.entries.push(e),n(!0))},d=c("first-input",p);n=m(e,v,t),d&&f((function(){d.takeRecords().map(p),d.disconnect()}),!0),d&&s((function(){var a;v=u("FID"),n=m(e,v,t),o=[],r=-1,i=null,F(addEventListener),a=p,o.push(a),S()}))},k={},P=function(e,t){var n,i=l(),r=u("LCP"),a=function(e){var t=e.startTime;t<i.firstHiddenTime&&(r.value=t,r.entries.push(e),n())},o=c("largest-contentful-paint",a);if(o){n=m(e,r,t);var v=function(){k[r.id]||(o.takeRecords().map(a),o.disconnect(),k[r.id]=!0,n(!0))};["keydown","click"].forEach((function(e){addEventListener(e,v,{once:!0,capture:!0})})),f(v,!0),s((function(i){r=u("LCP"),n=m(e,r,t),requestAnimationFrame((function(){requestAnimationFrame((function(){r.value=performance.now()-i.timeStamp,k[r.id]=!0,n(!0)}))}))}))}},D=function(e){var t,n=u("TTFB");t=function(){try{var t=performance.getEntriesByType("navigation")[0]||function(){var e=performance.timing,t={entryType:"navigation",startTime:0};for(var n in e)"navigationStart"!==n&&"toJSON"!==n&&(t[n]=Math.max(e[n]-e.navigationStart,0));return t}();if(n.value=n.delta=t.responseStart,n.value<0||n.value>performance.now())return;n.entries=[t],e(n)}catch(e){}},"complete"===document.readyState?setTimeout(t,0):addEventListener("load",(function(){return setTimeout(t,0)}))}}}]);
+//# sourceMappingURL=787.8f7ec9e0.chunk.js.map

docs/tutorial/index.html

@@ -1 +1 @@
-<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><link rel="icon" href="/tutorial/favicon.e3ab9dd9.ico"><link rel="stylesheet" type="text/css" href="/tutorial/index.757e9f9d.css"><meta name="viewport" content="width=device-width, initial-scale=1"><meta name="description" content="Strudel REPL"><title>Strudel Tutorial</title></head><body> <div id="root"></div> <noscript>You need to enable JavaScript to run this app.</noscript> <script src="/tutorial/index.a0cd6c24.js" defer></script> </body></html>
+<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><link rel="icon" href="/tutorial/favicon.e3ab9dd9.ico"><link rel="stylesheet" type="text/css" href="/tutorial/index.999678aa.css"><meta name="viewport" content="width=device-width, initial-scale=1"><meta name="description" content="Strudel REPL"><title>Strudel Tutorial</title></head><body> <div id="root"></div> <noscript>You need to enable JavaScript to run this app.</noscript> <script src="/tutorial/index.097d520a.js" defer></script> </body></html>

featurelist.md

@@ -6,7 +6,7 @@
 - [ ] setcps
 - [ ] naming patterns? block based evaluation?
 - [ ] once
-- [x] silence
+- [ ] silence
 - [x] hush
 - [ ] panic
 
@@ -30,23 +30,22 @@ https://tidalcycles.org/docs/patternlib/tour/concatenation
 - [ ] overlay => like stack? "The overlay function is similar to cat" => wrong?
 - [ ] `<>` operator (=== overlay)
 - [x] stack
-- [x] superimpose
-- [x] layer
+- [x] superimpose => strudel supports multiple args => is this layer?
+- [ ] layer => is this like superimpose but with multiple args?
 - [ ] steps ?
-- [x] iter
-- [x] iter' = iterBack
+- [ ] iter, iter'
 
 ## Alteration
 
 - [ ] range, rangex
 - [ ] quantise
 - [ ] ply
-- [x] stutter = echo
+- [ ] stutter
 - [ ] stripe, slowstripe
 - [ ] palindrome = every(2, rev)
 - [ ] trunc
 - [ ] linger
-- [x] chunk, chunk'
+- [ ] chunk, chunk'
 - [ ] shuffle
 - [ ] scramble
 - [ ] rot
@@ -69,8 +68,7 @@ https://tidalcycles.org/docs/patternlib/tour/concatenation
 - [ ] select, selectF
 - [ ] pickF
 - [ ] squeeze
-- [x] euclid, euclidLegato
-- [ ] euclidInv, euclidFull
+- [ ] euclid, euclidInv, euclidFull
 - [ ] ifp
 
 ## Time
@@ -85,8 +83,7 @@ https://tidalcycles.org/docs/patternlib/tour/concatenation
 - [x] off
 - [ ] rotL / rotR
 - [x] rev
-- [x] jux
-- [ ] juxBy
+- [ ] jux / juxBy
 - [ ] swingBy / swing
 - [ ] ghost
 - [ ] inside / outside
@@ -117,7 +114,7 @@ https://tidalcycles.org/docs/patternlib/tour/concatenation
 - [ ] chop
 - [ ] striate / striateBy
 - [ ] loopAt
-- [x] segment
+- [ ] segment
 - [ ] discretise
 
 ## Randomness

index.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<script>import("./strudel.js").then(m => strudel = m)
+</script>
+<html>
+    <head>
+        <title>Bingo</title>
+    </head>
+    <body>
+        <button onclick="foo()">hello</button>
+        <button onclick="bar()">hello</button>
+
+        <script type="module" src="./strudel.js"></script>
+    </body>
+</html>

package.json

@@ -6,11 +6,7 @@
   "main": "strudel.mjs",
   "scripts": {
     "test": "npm run test --workspaces --if-present",
-    "bootstrap": "lerna bootstrap",
-    "setup": "npm i && npm run bootstrap && cd repl && npm i",
-    "repl": "cd repl && npm run start",
-    "osc": "cd packages/osc && npm run server",
-    "build": "cd repl && npm run build"
+    "bootstrap": "lerna bootstrap"
   },
   "workspaces": [
     "packages/*"

packages/core/README.md

@@ -11,18 +11,18 @@ npm i @strudel.cycles/core --save
 ## Example
 
 ```js
-import { sequence } from '@strudel.cycles/core';
+import { sequence, State, TimeSpan } from '@strudel.cycles/core';
 
 const pattern = sequence('a', ['b', 'c']);
 
-const events = pattern.queryArc(0, 1);
+const events = pattern.query(new State(new TimeSpan(0, 2)));
 
 const spans = events.map(
   (event) => `${event.value}: ${event.whole.begin.toFraction()} - ${event.whole.end.toFraction()} `,
 );
 ```
 
-yields:
+spans:
 
 ```log
 a: 0 - 1/2
@@ -33,6 +33,4 @@ b: 3/2 - 7/4
 c: 7/4 - 2
 ```
 
-- [play with @strudel.cycles/core on codesandbox](https://codesandbox.io/s/strudel-core-test-qmz6qr?file=/src/index.js).
-- [open color pattern example](https://raw.githack.com/tidalcycles/strudel/package-examples/packages/core/examples/canvas.html)
-- [open minimal repl example](https://raw.githack.com/tidalcycles/strudel/package-examples/packages/core/examples/metro.html)
+[play with @strudel.cycles/core on codesandbox](https://codesandbox.io/s/strudel-core-test-qmz6qr?file=/src/index.js).

packages/core/controls.mjs

@@ -1,288 +0,0 @@
-import { Pattern, sequence } from './pattern.mjs';
-
-const controls = {};
-const generic_params = [
-  ['s', 's', 'sound'],
-  //['s', 'toArg', 'for internal sound routing'],
-  // ["f", "from", "for internal sound routing"),
-  //['f', 'to', 'for internal sound routing'],
-  ['f', 'accelerate', 'a pattern of numbers that speed up (or slow down) samples while they play.'],
-  ['f', 'amp', 'like @gain@, but linear.'],
-  [
-    'f',
-    'attack',
-    'a pattern of numbers to specify the attack time (in seconds) of an envelope applied to each sample.',
-  ],
-  ['f', 'bandf', 'a pattern of numbers from 0 to 1. Sets the center frequency of the band-pass filter.'],
-  ['f', 'bandq', 'a pattern of anumbers from 0 to 1. Sets the q-factor of the band-pass filter.'],
-  [
-    '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.',
-  ],
-  ['f', 'legato', 'controls the amount of overlap between two adjacent sounds'],
-  // ['f', 'clhatdecay', ''],
-  [
-    'f',
-    'crush',
-    'bit crushing, a pattern of numbers from 1 (for drastic reduction in bit-depth) to 16 (for barely no reduction).',
-  ],
-  [
-    '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.',
-  ],
-  ['i', 'channel', 'choose the channel the pattern is sent to in superdirt'],
-  [
-    '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.',
-  ],
-  ['f', 'cutoff', 'a pattern of numbers from 0 to 1. Applies the cutoff frequency of the low-pass filter.'],
-  // ['f', 'cutoffegint', ''],
-  ['f', 'decay', ''],
-  ['f', 'delay', 'a pattern of numbers from 0 to 1. Sets the level of the delay signal.'],
-  ['f', 'delayfeedback', 'a pattern of numbers from 0 to 1. Sets the amount of delay feedback.'],
-  ['f', 'delaytime', 'a pattern of numbers from 0 to 1. Sets the length of the delay.'],
-  ['f', 'detune', ''],
-  ['f', 'djf', 'DJ filter, below 0.5 is low pass filter, above is high pass filter.'],
-  [
-    'f',
-    'dry',
-    'when set to `1` will disable all reverb for this pattern. See `room` and `size` for more information about reverb.',
-  ],
-  [
-    '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.',
-  ],
-  [
-    'f',
-    'fadeTime',
-    "Used when using begin/end or chop/striate and friends, to change the fade out time of the 'grain' envelope.",
-  ],
-  [
-    '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.',
-  ],
-  ['f', 'freq', ''],
-  [
-    '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@.',
-  ],
-  ['f', 'gate', ''],
-  // ['f', 'hatgrain', ''],
-  [
-    'f',
-    'hcutoff',
-    'a pattern of numbers from 0 to 1. Applies the cutoff frequency of the high-pass filter. Also has alias @hpf@',
-  ],
-  [
-    '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.',
-  ],
-  [
-    'f',
-    'hresonance',
-    'a pattern of numbers from 0 to 1. Applies the resonance of the high-pass filter. Has alias @hpq@',
-  ],
-  // ['f', 'lagogo', ''],
-  // ['f', 'lclap', ''],
-  // ['f', 'lclaves', ''],
-  // ['f', 'lclhat', ''],
-  // ['f', 'lcrash', ''],
-  ['f', 'leslie', ''],
-  ['f', 'lrate', ''],
-  ['f', 'lsize', ''],
-  // ['f', 'lfo', ''],
-  // ['f', 'lfocutoffint', ''],
-  // ['f', 'lfodelay', ''],
-  // ['f', 'lfoint', ''],
-  // ['f', 'lfopitchint', ''],
-  // ['f', 'lfoshape', ''],
-  // ['f', 'lfosync', ''],
-  // ['f', 'lhitom', ''],
-  // ['f', 'lkick', ''],
-  // ['f', 'llotom', ''],
-  [
-    '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.',
-  ],
-  ['f', 'loop', 'loops the sample (from `begin` to `end`) the specified number of times.'],
-  // ['f', 'lophat', ''],
-  // ['f', 'lsnare', ''],
-  ['f', 'n', 'The note or sample number to choose for a synth or sampleset'],
-  ['f', 'note', 'The note or pitch to play a sound or synth with'],
-  ['f', 'degree', ''],
-  ['f', 'mtranspose', ''],
-  ['f', 'ctranspose', ''],
-  ['f', 'harmonic', ''],
-  ['f', 'stepsPerOctave', ''],
-  ['f', 'octaveR', ''],
-  [
-    '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)',
-  ],
-  ['i', 'octave', ''],
-  ['f', 'offset', ''],
-  // ['f', 'ophatdecay', ''],
-  [
-    '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', ''],
-  ['f', 'overshape', ''],
-  [
-    'f',
-    'pan',
-    'a pattern of numbers between 0 and 1, from left to right (assuming stereo), once round a circle (assuming multichannel)',
-  ],
-  [
-    'f',
-    'panspan',
-    'a pattern of numbers between -inf and inf, which controls how much multichannel output is fanned out (negative is backwards ordering)',
-  ],
-  [
-    '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', ''],
-  ['f', 'rate', "used in SuperDirt softsynths as a control rate or 'speed'"],
-  [
-    'f',
-    'release',
-    'a pattern of numbers to specify the release time (in seconds) of an envelope applied to each sample.',
-  ],
-  ['f', 'resonance', 'a pattern of numbers from 0 to 1. Specifies the resonance of the low-pass filter.'],
-  ['f', 'room', 'a pattern of numbers from 0 to 1. Sets the level of reverb.'],
-  // ['f', 'sagogo', ''],
-  // ['f', 'sclap', ''],
-  // ['f', 'sclaves', ''],
-  // ['f', 'scrash', ''],
-  ['f', 'semitone', ''],
-  [
-    'f',
-    'shape',
-    'wave shaping distortion, a pattern of numbers from 0 for no distortion up to 1 for loads of distortion.',
-  ],
-  [
-    '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', 'slide', ''],
-  [
-    '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!',
-  ],
-  ['f', 'squiz', ''],
-  ['f', 'stutterdepth', ''],
-  ['f', 'stuttertime', ''],
-  ['f', 'sustain', ''],
-  ['f', 'timescale', ''],
-  ['f', 'timescalewin', ''],
-  // ['f', 'tomdecay', ''],
-  [
-    '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`.',
-  ],
-  ['f', 'velocity', ''],
-  // ['f', 'vcfegint', ''],
-  // ['f', 'vcoegint', ''],
-  ['f', 'voice', ''],
-  [
-    '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.',
-  ],
-  ['f', 'waveloss', ''],
-  ['f', 'dur', ''],
-  // ['f', 'modwheel', ''],
-  ['f', 'expression', ''],
-  ['f', 'sustainpedal', ''],
-  ['f', 'tremolodepth', "Tremolo Audio DSP effect | params are 'tremolorate' and 'tremolodepth'"],
-  ['f', 'tremolorate', "Tremolo Audio DSP effect | params are 'tremolorate' and 'tremolodepth'"],
-  ['f', 'phaserdepth', "Phaser Audio DSP effect | params are 'phaserrate' and 'phaserdepth'"],
-  ['f', 'phaserrate', "Phaser Audio DSP effect | params are 'phaserrate' and 'phaserdepth'"],
-  ['f', 'fshift', 'frequency shifter'],
-  ['f', 'fshiftnote', 'frequency shifter'],
-  ['f', 'fshiftphase', 'frequency shifter'],
-  ['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', ''],
-];
-
-const _name = (name, ...pats) => sequence(...pats).withValue((x) => ({ [name]: x }));
-
-const _setter = (func) =>
-  function (...pats) {
-    return this.set(func(...pats));
-  };
-
-generic_params.forEach(([type, name, description]) => {
-  controls[name] = (...pats) => _name(name, ...pats);
-  Pattern.prototype[name] = _setter(controls[name]);
-});
-
-export default controls;

packages/core/euclid.mjs

@@ -1,4 +1,4 @@
-import { Pattern, timeCat } from './pattern.mjs';
+import { Pattern, timeCat } from './strudel.mjs';
 import bjork from 'bjork';
 import { rotate } from './util.mjs';
 import Fraction from './fraction.mjs';

packages/core/examples/canvas.html

@@ -2,8 +2,8 @@
   <input
     type="text"
     id="text"
-    value="cat('orange', 'indigo')"
-    style="width: 100%; font-size: 2em; background: black; color: white; outline: none; position: absolute; top: 0"
+    value="cat('lime', slowcat('steelblue','darkblue'),'yellow','salmon','black').every(2,rev).fast(16)"
+    style="width: 100%; font-size: 1.5em; background: black; color: white; outline: none; position: absolute; top: 0"
     spellcheck="false"
   />
   <canvas id="canvas"></canvas>
@@ -25,6 +25,7 @@
     function paint(code) {
       const pattern = eval(code); // run code
       const events = pattern.firstCycle(); // query first cycle
+      ctx.clearRect(0, 0, canvas.width, canvas.height); // clear canvas
       events.forEach((event) => {
         ctx.fillStyle = event.value;
         ctx.fillRect(event.whole.begin * canvas.width, 0, event.duration * canvas.width, canvas.height);

packages/core/examples/metro.html

@@ -0,0 +1,237 @@
+<div style="position: absolute; top: 0; right: 0; padding: 4px">
+  <button id="start" style="margin-bottom: 4px; font-size: 2em">start</button><br />
+  <button id="stop" style="font-size: 2em">stop</button>
+</div>
+<textarea
+  style="font-size: 2em; background: #e8d565; color: #323230; height: 100%; width: 100%; outline: none; border: 0"
+  id="text"
+  spellcheck="false"
+>
+Loading...</textarea
+>
+<script type="module">
+  document.body.style = 'margin: 0';
+  import * as strudel from 'https://cdn.skypack.dev/@strudel.cycles/core@0.0.2';
+  import 'https://cdn.skypack.dev/@strudel.cycles/core@0.0.2/euclid.mjs';
+  const { cat, State, TimeSpan } = strudel;
+  let pattern;
+  Object.assign(window, strudel); // add strudel to eval scope
+  const input = document.getElementById('text');
+
+  let initialCode = `sequence(880, [440, 660], 440, 660)
+.div(slowcat(3,2).slow(2))
+.off(1/8,mul(2))
+.off(1/4,mul(3))
+.legato(2)
+.slow(2)`;
+  try {
+    initialCode = atob(decodeURIComponent(window.location.href.split('#')[1]));
+  } catch (err) {
+    console.warn('failed to decode', err);
+  }
+  input.value = initialCode;
+
+  const evaluate = () => {
+    try {
+      pattern = eval(input.value);
+      window.location.hash = '#' + encodeURIComponent(btoa(input.value)); // update url hash
+    } catch (err) {
+      console.warn(err);
+    }
+  };
+  input.addEventListener('input', () => evaluate());
+
+  // helpers to create a worker dynamically without needing a server / extra file
+  const stringifyFunction = (func) => '(' + func + ')();';
+  const urlifyFunction = (func) =>
+    URL.createObjectURL(new Blob([stringifyFunction(func)], { type: 'text/javascript' }));
+  const createWorker = (func) => new Worker(urlifyFunction(func));
+
+  const interval = 0.1;
+  const lookahead = 0.5;
+
+  // this class is basically the tale of two clocks
+  class Metro {
+    worker;
+    audioContext;
+    interval = 0.2; // query span
+    lastEnd = 0;
+    constructor(audioContext, callback, interval = this.interval) {
+      this.audioContext = audioContext;
+      this.interval = interval;
+      this.worker = createWorker(() => {
+        // we cannot use closures here!
+        let interval;
+        let timerID = null; // this is clock #1 (the sloppy js clock)
+        const clear = () => {
+          if (timerID) {
+            clearInterval(timerID);
+            timerID = null;
+          }
+        };
+        const start = () => {
+          clear();
+          if (!interval) {
+            throw new Error('no interval set! call worker.postMessage({interval}) before starting.');
+          }
+          timerID = setInterval(() => postMessage('tick'), interval * 1000);
+        };
+        self.onmessage = function (e) {
+          if (e.data == 'start') {
+            start();
+          } else if (e.data.interval) {
+            interval = e.data.interval;
+            if (timerID) {
+              start();
+            }
+          } else if (e.data == 'stop') {
+            clear();
+          }
+        };
+      });
+      this.worker.postMessage({ interval });
+      const round = (n, d) => Math.round(n * d) / d;
+      const precision = 100;
+      this.worker.onmessage = (e) => {
+        if (e.data === 'tick') {
+          const begin = this.lastEnd || this.audioContext.currentTime;
+          const end = this.audioContext.currentTime + this.interval; // DONT reference begin here!
+          this.lastEnd = end;
+          // callback with query span, using clock #2 (the audio clock)
+          callback(begin, end);
+        }
+      };
+    }
+    start() {
+      console.log('start...');
+      this.audioContext.resume();
+      this.worker.postMessage('start');
+    }
+    stop() {
+      console.log('stop...');
+      this.worker.postMessage('stop');
+    }
+  }
+
+  const audioContext = new AudioContext();
+  const metro = new Metro(
+    audioContext,
+    (begin, end) => {
+      pattern.query(new State(new TimeSpan(begin, end))).forEach((e) => {
+        if (!e.part.begin.equals(e.whole.begin)) {
+          return;
+        }
+        if (e.context.createAudioNode) {
+          e.context.createAudioNode(e);
+        } else {
+          // fallback sine wave
+          const attack = 0.01;
+          const decay = 0.05;
+          const sustain = 0.5;
+          const release = 0.01;
+          const velocity = (e.context?.velocity || 1) * 0.1;
+          const osc = audioContext.createOscillator();
+          osc.type = 'sine';
+          osc.frequency.value = e.value;
+          osc.start(e.whole.begin);
+          const envelope = adsr(attack, decay, sustain, release, velocity, e.whole.begin, e.whole.end);
+          osc.stop(e.whole.end + release);
+          osc.connect(envelope);
+          envelope.connect(audioContext.destination);
+        }
+      });
+    },
+    interval,
+    lookahead,
+  );
+
+  const adsr = (attack, decay, sustain, release, velocity, begin, end) => {
+    const gainNode = audioContext.createGain();
+    gainNode.gain.setValueAtTime(0, begin);
+    gainNode.gain.linearRampToValueAtTime(velocity, begin + attack); // attack
+    gainNode.gain.linearRampToValueAtTime(sustain * velocity, begin + attack + decay); // sustain start
+    gainNode.gain.setValueAtTime(sustain * velocity, end); // sustain end
+    gainNode.gain.linearRampToValueAtTime(0, end + release); // release
+    // for some reason, using exponential ramping creates little cracklings
+    return gainNode;
+  };
+
+  strudel.Pattern.prototype.withAudioNode = function (createAudioNode) {
+    return this._withEvent((event) => {
+      return event.setContext({
+        ...event.context,
+        createAudioNode: (e) => createAudioNode(e, event.context.createAudioNode?.(event)),
+      });
+    });
+  };
+
+  strudel.Pattern.prototype._osc = function (type) {
+    return this.withAudioNode((e) => {
+      const osc = audioContext.createOscillator();
+      osc.type = type;
+      osc.frequency.value = e.value; // expects frequency..
+      osc.start(e.whole.begin.valueOf() + lookahead);
+      osc.stop(e.whole.end.valueOf() + lookahead); // release?
+      // osc.connect(audioContext.destination);
+      return osc;
+    });
+  };
+  strudel.Pattern.prototype.define('osc', (type, pat) => pat.osc(type), { patternified: true });
+  strudel.Pattern.prototype.adsr = function (a = 0.01, d = 0.05, s = 1, r = 0.01) {
+    return this.withAudioNode((e, node) => {
+      const velocity = e.context?.velocity || 1;
+      const envelope = adsr(
+        a,
+        d,
+        s,
+        r,
+        velocity,
+        e.whole.begin.valueOf() + lookahead,
+        e.whole.end.valueOf() + lookahead,
+      );
+      node?.connect(envelope);
+      return envelope;
+    });
+  };
+  strudel.Pattern.prototype.filter = function (type = 'lowshelf', frequency = 1000, gain = 25) {
+    return this.withAudioNode((e, node) => {
+      const filter = audioContext.createBiquadFilter();
+      filter.type = type;
+      filter.frequency.value = frequency;
+      filter.gain.value = gain;
+      node?.connect(filter);
+      return filter;
+    });
+  };
+
+  strudel.Pattern.prototype.out = function () {
+    const master = audioContext.createGain();
+    master.gain.value = 0.1;
+    master.connect(audioContext.destination);
+    return this.withAudioNode((e, node) => {
+      if (!node) {
+        console.warn('out: no source! call .osc() first');
+      }
+      node?.connect(master);
+    });
+  };
+
+  document.getElementById('start').addEventListener('click', () => metro.start());
+  document.getElementById('stop').addEventListener('click', () => metro.stop());
+  evaluate(); // evaluate initial code
+  /*
+  sequence(1,3/2,1,2).stack(
+stack(5,3,4).velocity(.8).slow(2).legato(.2)
+//.echo(3, 1/4, .5)
+).mul(110) // frequencies
+.div(slowcat(slowcat(2,5/4, 3/2),slowcat(3,4/3)).slow(2))
+.echoWith(
+ 16, // n of partials / cutoff
+ tri2.slow(128).div(2), // time between partials
+ (x,n)=>x // n = partial index 0..n
+  .mul((n+1)*3/2)
+  .legato(2)
+  .velocity(1/((n+1)**1.6)) // amplitude falloff
+ ).legato(2) // note length
+  */
+</script>

packages/core/fraction.mjs

@@ -1,5 +1,5 @@
 import Fraction from 'fraction.js';
-import { TimeSpan } from './timespan.mjs';
+import { TimeSpan } from './strudel.mjs';
 
 // Returns the start of the cycle.
 Fraction.prototype.sam = function () {
@@ -16,11 +16,6 @@ Fraction.prototype.wholeCycle = function () {
   return new TimeSpan(this.sam(), this.nextSam());
 };
 
-// The position of a time value relative to the start of its cycle.
-Fraction.prototype.cyclePos = function () {
-  return this.sub(this.sam());
-};
-
 Fraction.prototype.lt = function (other) {
   return this.compare(other) < 0;
 };

packages/core/hap.mjs

@@ -1,90 +0,0 @@
-
-export class Hap {
-  /*
-      Event class, representing a value active during the timespan
-      'part'. This might be a fragment of an event, in which case the
-      timespan will be smaller than the 'whole' timespan, otherwise the
-      two timespans will be the same. The 'part' must never extend outside of the
-      'whole'. If the event represents a continuously changing value
-      then the whole will be returned as None, in which case the given
-      value will have been sampled from the point halfway between the
-      start and end of the 'part' timespan.
-      The context is to store a list of source code locations causing the event
-      */
-
-  constructor(whole, part, value, context = {}, stateful = false) {
-    this.whole = whole;
-    this.part = part;
-    this.value = value;
-    this.context = context;
-    this.stateful = stateful;
-    if (stateful) {
-      console.assert(typeof this.value === 'function', 'Stateful values must be functions');
-    }
-  }
-
-  get duration() {
-    return this.whole.end.sub(this.whole.begin).valueOf();
-  }
-
-  wholeOrPart() {
-    return this.whole ? this.whole : this.part;
-  }
-
-  withSpan(func) {
-    // Returns a new event with the function f applies to the event timespan.
-    const whole = this.whole ? func(this.whole) : undefined;
-    return new Hap(whole, func(this.part), this.value, this.context);
-  }
-
-  withValue(func) {
-    // Returns a new event with the function f applies to the event value.
-    return new Hap(this.whole, this.part, func(this.value), this.context);
-  }
-
-  hasOnset() {
-    // Test whether the event contains the onset, i.e that
-    // the beginning of the part is the same as that of the whole timespan."""
-    return this.whole != undefined && this.whole.begin.equals(this.part.begin);
-  }
-
-  resolveState(state) {
-    if (this.stateful && this.hasOnset()) {
-      console.log('stateful');
-      const func = this.value;
-      const [newState, newValue] = func(state);
-      return [newState, new Hap(this.whole, this.part, newValue, this.context, false)];
-    }
-    return [state, this];
-  }
-
-  spanEquals(other) {
-    return (this.whole == undefined && other.whole == undefined) || this.whole.equals(other.whole);
-  }
-
-  equals(other) {
-    return (
-      this.spanEquals(other) &&
-      this.part.equals(other.part) &&
-      // TODO would == be better ??
-      this.value === other.value
-    );
-  }
-
-  show() {
-    return (
-      '(' + (this.whole == undefined ? '~' : this.whole.show()) + ', ' + this.part.show() + ', ' + this.value + ')'
-    );
-  }
-
-  combineContext(b) {
-    const a = this;
-    return { ...a.context, ...b.context, locations: (a.context.locations || []).concat(b.context.locations || []) };
-  }
-
-  setContext(context) {
-    return new Hap(this.whole, this.part, this.value, context);
-  }
-}
-
-export default Hap;

packages/core/index.mjs

@@ -1,11 +0,0 @@
-export * from './controls.mjs';
-export * from './euclid.mjs';
-import Fraction from './fraction.mjs';
-export {Fraction};
-export * from './hap.mjs';
-export * from './pattern.mjs';
-export * from './signal.mjs';
-export * from './state.mjs';
-export * from './timespan.mjs';
-export * from './util.mjs';
-// export * from './value.mjs';

packages/core/package-lock.json

@@ -1,16 +1,17 @@
 {
 	"name": "@strudel.cycles/core",
-	"version": "0.0.5",
+	"version": "0.0.2",
 	"lockfileVersion": 2,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "@strudel.cycles/core",
-			"version": "0.0.3",
+			"version": "0.0.1",
 			"license": "GPL-3.0-or-later",
 			"dependencies": {
 				"bjork": "^0.0.1",
-				"fraction.js": "^4.2.0"
+				"fraction.js": "^4.2.0",
+				"ramda": "^0.28.0"
 			},
 			"devDependencies": {
 				"mocha": "^9.2.2"
@@ -732,6 +733,15 @@
 				"url": "https://github.com/sponsors/jonschlinkert"
 			}
 		},
+		"node_modules/ramda": {
+			"version": "0.28.0",
+			"resolved": "https://registry.npmjs.org/ramda/-/ramda-0.28.0.tgz",
+			"integrity": "sha512-9QnLuG/kPVgWvMQ4aODhsBUFKOUmnbUnsSXACv+NCQZcHbeb+v8Lodp8OVxtRULN1/xOyYLLaL6npE6dMq5QTA==",
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/ramda"
+			}
+		},
 		"node_modules/randombytes": {
 			"version": "2.1.0",
 			"resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz",
@@ -1475,6 +1485,11 @@
 			"integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
 			"dev": true
 		},
+		"ramda": {
+			"version": "0.28.0",
+			"resolved": "https://registry.npmjs.org/ramda/-/ramda-0.28.0.tgz",
+			"integrity": "sha512-9QnLuG/kPVgWvMQ4aODhsBUFKOUmnbUnsSXACv+NCQZcHbeb+v8Lodp8OVxtRULN1/xOyYLLaL6npE6dMq5QTA=="
+		},
 		"randombytes": {
 			"version": "2.1.0",
 			"resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz",

packages/core/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@strudel.cycles/core",
-  "version": "0.0.5",
+  "version": "0.0.2",
   "description": "Port of Tidal Cycles to JavaScript",
-  "main": "index.mjs",
+  "main": "strudel.mjs",
   "type": "module",
   "scripts": {
     "test": "mocha --colors"
@@ -26,10 +26,10 @@
   "homepage": "https://strudel.tidalcycles.org",
   "dependencies": {
     "bjork": "^0.0.1",
-    "fraction.js": "^4.2.0"
+    "fraction.js": "^4.2.0",
+    "ramda": "^0.28.0"
   },
   "devDependencies": {
     "mocha": "^9.2.2"
-  },
-  "gitHead": "0e26d4e741500f5bae35b023608f062a794905c2"
+  }
 }

packages/core/signal.mjs

@@ -1,209 +0,0 @@
-import { Hap } from './hap.mjs';
-import { Pattern, fastcat, reify, silence, stack } from './pattern.mjs';
-import Fraction from './fraction.mjs';
-import { id } from './util.mjs';
-
-export function steady(value) {
-  // A continuous value
-  return new Pattern((state) => [new Hap(undefined, state.span, value)]);
-}
-
-export const signal = (func) => {
-  const query = (state) => [new Hap(undefined, state.span, func(state.span.midpoint()))];
-  return new Pattern(query);
-};
-
-export const isaw = signal((t) => 1 - (t % 1));
-export const isaw2 = isaw._toBipolar();
-
-export const saw = signal((t) => t % 1);
-export const saw2 = saw._toBipolar();
-
-export const sine2 = signal((t) => Math.sin(Math.PI * 2 * t));
-export const sine = sine2._fromBipolar();
-export const cosine = sine._early(Fraction(1).div(4));
-export const cosine2 = sine2._early(Fraction(1).div(4));
-
-export const square = signal((t) => Math.floor((t * 2) % 2));
-export const square2 = square._toBipolar();
-
-export const tri = fastcat(isaw, saw);
-export const tri2 = fastcat(isaw2, saw2);
-
-export const time = signal(id);
-
-// random signals
-
-const xorwise = (x) => {
-  const a = (x << 13) ^ x;
-  const b = (a >> 17) ^ a;
-  return (b << 5) ^ b;
-};
-
-// stretch 300 cycles over the range of [0,2**29 == 536870912) then apply the xorshift algorithm
-const _frac = (x) => x - Math.trunc(x);
-
-const timeToIntSeed = (x) => xorwise(Math.trunc(_frac(x / 300) * 536870912));
-
-const intSeedToRand = (x) => (x % 536870912) / 536870912;
-
-const timeToRand = (x) => Math.abs(intSeedToRand(timeToIntSeed(x)));
-
-const timeToRandsPrime = (seed, n) => {
-  const result = [];
-  for (let i = 0; i < n; ++n) {
-    result.push(intSeedToRand(seed));
-    seed = xorwise(seed);
-  }
-  return result;
-};
-
-const timeToRands = (t, n) => timeToRandsPrime(timeToIntSeed(t), n);
-
-export const rand = signal(timeToRand);
-
-export const _brandBy = (p) => rand.fmap((x) => x < p);
-export const brandBy = (pPat) => reify(pPat).fmap(_brandBy).innerJoin();
-export const brand = _brandBy(0.5);
-
-export const _irand = (i) => rand.fmap((x) => Math.trunc(x * i));
-export const irand = (ipat) => reify(ipat).fmap(_irand).innerJoin();
-
-export const chooseWith = (pat, xs) => {
-  xs = xs.map(reify);
-  if (xs.length == 0) {
-    return silence;
-  }
-  return pat.range(0, xs.length).fmap((i) => xs[Math.floor(i)]).outerJoin();
-};
-
-export const choose = (...xs) => chooseWith(rand, xs);
-
-const _wchooseWith = function (pat, ...pairs) {
-  const values = pairs.map((pair) => reify(pair[0]));
-  const weights = [];
-  let accum = 0;
-  for (const pair of pairs) {
-    accum += pair[1];
-    weights.push(accum);
-  }
-  const total = accum;
-  const match = function(r) {
-    const find = r * total;
-    return values[weights.findIndex((x) => x > find, weights)];
-  };
-  return pat.fmap(match);
-};
-
-const wchooseWith = (...args) => _wchooseWith(...args).outerJoin()
-
-export const wchoose = (...pairs) => wchooseWith(rand, ...pairs);
-
-export const wchooseCycles = (...pairs) => _wchooseWith(rand, ...pairs).innerJoin();
-
-export const perlinWith = (pat) => {
-  const pata = pat.fmap(Math.floor);
-  const patb = pat.fmap((t) => Math.floor(t) + 1);
-  const smootherStep = (x) => 6.0 * x ** 5 - 15.0 * x ** 4 + 10.0 * x ** 3;
-  const interp = (x) => (a) => (b) => a + smootherStep(x) * (b - a);
-  return pat.sub(pata).fmap(interp).appBoth(pata.fmap(timeToRand)).appBoth(patb.fmap(timeToRand));
-};
-
-export const perlin = perlinWith(time);
-
-Pattern.prototype._degradeByWith = function (withPat, x) {
-  return this.fmap((a) => (_) => a).appLeft(withPat._filterValues((v) => v > x));
-};
-
-Pattern.prototype._degradeBy = function (x) {
-  return this._degradeByWith(rand, x);
-};
-
-Pattern.prototype.degrade = function () {
-  return this._degradeBy(0.5);
-};
-
-Pattern.prototype._undegradeBy = function (x) {
-  return this._degradeByWith(
-    rand.fmap((r) => 1 - r),
-    x,
-  );
-};
-
-Pattern.prototype.undegrade = function () {
-  return this._undegradeBy(0.5);
-};
-
-Pattern.prototype._sometimesBy = function (x, func) {
-  return stack(this._degradeBy(x), func(this._undegradeBy(1 - x)));
-};
-
-Pattern.prototype.sometimesBy = function (patx, func) {
-  const pat = this;
-  return reify(patx)
-    .fmap((x) => pat._sometimesBy(x, func))
-    .innerJoin();
-};
-
-Pattern.prototype._sometimesByPre = function (x, func) {
-  return stack(this._degradeBy(x), func(this).undegradeBy(1 - x));
-};
-
-Pattern.prototype.sometimesByPre = function (patx, func) {
-  const pat = this;
-  return reify(patx)
-    .fmap((x) => pat._sometimesByPre(x, func))
-    .innerJoin();
-};
-
-Pattern.prototype.sometimes = function (func) {
-  return this._sometimesBy(0.5, func);
-};
-
-Pattern.prototype.sometimesPre = function (func) {
-  return this._sometimesByPre(0.5, func);
-};
-
-Pattern.prototype._someCyclesBy = function (x, func) {
-  return stack(
-    this._degradeByWith(rand._segment(1), x),
-    func(this._degradeByWith(rand.fmap((r) => 1 - r)._segment(1), 1 - x)),
-  );
-};
-
-Pattern.prototype.someCyclesBy = function (patx, func) {
-  const pat = this;
-  return reify(patx)
-    .fmap((x) => pat._someCyclesBy(x, func))
-    .innerJoin();
-};
-
-Pattern.prototype.someCycles = function (func) {
-  return this._someCyclesBy(0.5, func);
-};
-
-Pattern.prototype.often = function (func) {
-  return this.sometimesBy(0.75, func);
-};
-
-Pattern.prototype.rarely = function (func) {
-  return this.sometimesBy(0.25, func);
-};
-
-Pattern.prototype.almostNever = function (func) {
-  return this.sometimesBy(0.1, func);
-};
-
-Pattern.prototype.almostAlways = function (func) {
-  return this.sometimesBy(0.9, func);
-};
-
-Pattern.prototype.never = function (func) {
-  return this;
-};
-
-Pattern.prototype.always = function (func) {
-  return func(this);
-};
-
-Pattern.prototype.patternified.push('degradeBy', 'undegradeBy');

packages/core/speak.mjs

@@ -1,33 +0,0 @@
-import { Pattern, patternify2 } from './index.mjs';
-
-const synth = window?.speechSynthesis;
-let allVoices = synth?.getVoices();
-// console.log('voices', allVoices);
-
-function speak(words, lang, voice) {
-  synth.cancel();
-  const utterance = new SpeechSynthesisUtterance(words);
-  utterance.lang = lang;
-  allVoices = synth.getVoices();
-  const voices = allVoices.filter((v) => v.lang.includes(lang));
-  if (typeof voice === 'number') {
-    utterance.voice = voices[voice % voices.length];
-  } else if (typeof voice === 'string') {
-    utterance.voice = voices.find((voice) => voice.name === voice);
-  }
-  // console.log(utterance.voice?.name, utterance.voice?.lang);
-  speechSynthesis.speak(utterance);
-}
-
-Pattern.prototype._speak = function (lang, voice) {
-  return this._withEvent((event) => {
-    const onTrigger = (time, event) => {
-      speak(event.value, lang, voice);
-    };
-    return event.setContext({ ...event.context, onTrigger });
-  });
-};
-
-Pattern.prototype.speak = function (lang, voice) {
-  return patternify2(Pattern.prototype._speak)(reify(lang), reify(voice), this);
-};

packages/core/state.mjs

@@ -1,22 +0,0 @@
-export class State {
-  constructor(span, controls = {}) {
-    this.span = span;
-    this.controls = controls;
-  }
-
-  // Returns new State with different span
-  setSpan(span) {
-    return new State(span, this.controls);
-  }
-
-  withSpan(func) {
-    return this.setSpan(func(this.span));
-  }
-
-  // Returns new State with different controls
-  setControls(controls) {
-    return new State(this.span, controls);
-  }
-}
-
-export default State;

packages/core/strudel.mjs

@@ -1,20 +1,224 @@
-import TimeSpan from './timespan.mjs';
 import Fraction from './fraction.mjs';
-import Hap from './hap.mjs';
-import State from './state.mjs';
+import { compose } from 'ramda'; // will remove this as soon as compose is implemented here
+import { isNote, toMidi } from './util.mjs';
 
-import { isNote, toMidi, compose, removeUndefineds, flatten, id, listRange, curry } from './util.mjs';
+// Removes 'None' values from given list
+const removeUndefineds = (xs) => xs.filter((x) => x != undefined);
 
-export class Pattern {
+const flatten = (arr) => [].concat(...arr);
+
+const id = (a) => a;
+
+const range = (min, max) => Array.from({ length: max - min + 1 }, (_, i) => i + min);
+
+export function curry(func, overload) {
+  const fn = function curried(...args) {
+    if (args.length >= func.length) {
+      return func.apply(this, args);
+    } else {
+      const partial = function (...args2) {
+        return curried.apply(this, args.concat(args2));
+      };
+      if (overload) {
+        overload(partial, args);
+      }
+      return partial;
+    }
+  };
+  if (overload) {
+    // overload function without args... needed for chordBass.transpose(2)
+    overload(fn, []);
+  }
+  return fn;
+}
+
+class TimeSpan {
+  constructor(begin, end) {
+    this.begin = Fraction(begin);
+    this.end = Fraction(end);
+  }
+
+  get spanCycles() {
+    const spans = [];
+    var begin = this.begin;
+    const end = this.end;
+    const end_sam = end.sam();
+
+    while (end.gt(begin)) {
+      // If begin and end are in the same cycle, we're done.
+      if (begin.sam().equals(end_sam)) {
+        spans.push(new TimeSpan(begin, this.end));
+        break;
+      }
+      // add a timespan up to the next sam
+      const next_begin = begin.nextSam();
+      spans.push(new TimeSpan(begin, next_begin));
+
+      // continue with the next cycle
+      begin = next_begin;
+    }
+    return spans;
+  }
+
+  withTime(func_time) {
+    // Applies given function to both the begin and end time value of the timespan"""
+    return new TimeSpan(func_time(this.begin), func_time(this.end));
+  }
+  withEnd(func_time) {
+    // Applies given function to both the begin and end time value of the timespan"""
+    return new TimeSpan(this.begin, func_time(this.end));
+  }
+
+  intersection(other) {
+    // Intersection of two timespans, returns None if they don't intersect.
+    const intersect_begin = this.begin.max(other.begin);
+    const intersect_end = this.end.min(other.end);
+
+    if (intersect_begin.gt(intersect_end)) {
+      return undefined;
+    }
+    if (intersect_begin.equals(intersect_end)) {
+      // Zero-width (point) intersection - doesn't intersect if it's at the end of a
+      // non-zero-width timespan.
+      if (intersect_begin.equals(this.end) && this.begin.lt(this.end)) {
+        return undefined;
+      }
+      if (intersect_begin.equals(other.end) && other.begin.lt(other.end)) {
+        return undefined;
+      }
+    }
+    return new TimeSpan(intersect_begin, intersect_end);
+  }
+
+  intersection_e(other) {
+    // Like 'sect', but raises an exception if the timespans don't intersect.
+    const result = this.intersection(other);
+    if (result == undefined) {
+      // TODO - raise exception
+      // raise ValueError(f'TimeSpan {self} and TimeSpan {other} do not intersect')
+    }
+    return result;
+  }
+
+  midpoint() {
+    return this.begin.add(this.end.sub(this.begin).div(Fraction(2)));
+  }
+
+  equals(other) {
+    return this.begin.equals(other.begin) && this.end.equals(other.end);
+  }
+
+  show() {
+    return this.begin.show() + ' -> ' + this.end.show();
+  }
+}
+
+class Hap {
+  /*
+    Event class, representing a value active during the timespan
+    'part'. This might be a fragment of an event, in which case the
+    timespan will be smaller than the 'whole' timespan, otherwise the
+    two timespans will be the same. The 'part' must never extend outside of the
+    'whole'. If the event represents a continuously changing value
+    then the whole will be returned as None, in which case the given
+    value will have been sampled from the point halfway between the
+    start and end of the 'part' timespan.
+    The context is to store a list of source code locations causing the event
+    */
+
+  constructor(whole, part, value, context = {}, stateful = false) {
+    this.whole = whole;
+    this.part = part;
+    this.value = value;
+    this.context = context;
+    this.stateful = stateful;
+    if (stateful) {
+      console.assert(typeof this.value === 'function', 'Stateful values must be functions');
+    }
+  }
+
+  get duration() {
+    return this.whole.end.sub(this.whole.begin).valueOf();
+  }
+
+  withSpan(func) {
+    // Returns a new event with the function f applies to the event timespan.
+    const whole = this.whole ? func(this.whole) : undefined;
+    return new Hap(whole, func(this.part), this.value, this.context);
+  }
+
+  withValue(func) {
+    // Returns a new event with the function f applies to the event value.
+    return new Hap(this.whole, this.part, func(this.value), this.context);
+  }
+
+  hasOnset() {
+    // Test whether the event contains the onset, i.e that
+    // the beginning of the part is the same as that of the whole timespan."""
+    return this.whole != undefined && this.whole.begin.equals(this.part.begin);
+  }
+
+  resolveState(state) {
+    if (this.stateful && this.hasOnset()) {
+      console.log('stateful');
+      const func = this.value;
+      const [newState, newValue] = func(state);
+      return [newState, new Hap(this.whole, this.part, newValue, this.context, false)];
+    }
+    return [state, this];
+  }
+
+  spanEquals(other) {
+    return (this.whole == undefined && other.whole == undefined) || this.whole.equals(other.whole);
+  }
+
+  equals(other) {
+    return (
+      this.spanEquals(other) &&
+      this.part.equals(other.part) &&
+      // TODO would == be better ??
+      this.value === other.value
+    );
+  }
+
+  show() {
+    return (
+      '(' + (this.whole == undefined ? '~' : this.whole.show()) + ', ' + this.part.show() + ', ' + this.value + ')'
+    );
+  }
+
+  setContext(context) {
+    return new Hap(this.whole, this.part, this.value, context);
+  }
+}
+
+export class State {
+  constructor(span, controls = {}) {
+    this.span = span;
+    this.controls = controls;
+  }
+
+  // Returns new State with different span
+  setSpan(span) {
+    return new State(span, this.controls);
+  }
+
+  withSpan(func) {
+    return this.setSpan(func(this.span));
+  }
+
+  // Returns new State with different controls
+  setControls(controls) {
+    return new State(this.span, controls);
+  }
+}
+
+class Pattern {
   // the following functions will get patternFactories as nested functions:
   constructor(query) {
     this.query = query;
   }
 
-  queryArc(begin, end) {
-    return this.query(new State(new TimeSpan(begin, end)));
-  }
-
   _splitQueries() {
     // Splits queries at cycle boundaries. This makes some calculations
     // easier to express, as all events are then constrained to happen within
@@ -148,11 +352,12 @@ export class Pattern {
         if (s == undefined) {
           return undefined;
         }
+        // TODO: is it right to add event_val.context here?
         return new Hap(
           whole_func(event_func.whole, event_val.whole),
           s,
           event_func.value(event_val.value),
-          event_val.combineContext(event_func),
+          event_val.context,
         );
       };
       return flatten(
@@ -179,16 +384,17 @@ export class Pattern {
     const query = function (state) {
       const haps = [];
       for (const hap_func of pat_func.query(state)) {
-        const event_vals = pat_val.query(state.setSpan(hap_func.wholeOrPart()));
+        const event_vals = pat_val.query(state.setSpan(hap_func.part));
         for (const hap_val of event_vals) {
           const new_whole = hap_func.whole;
-          const new_part = hap_func.part.intersection(hap_val.part);
-          if (new_part) {
-            const new_value = hap_func.value(hap_val.value);
-            const new_context = hap_val.combineContext(hap_func);
-            const hap = new Hap(new_whole, new_part, new_value, new_context);
-            haps.push(hap);
-          }
+          const new_part = hap_func.part.intersection_e(hap_val.part);
+          const new_value = hap_func.value(hap_val.value);
+          const hap = new Hap(new_whole, new_part, new_value, {
+            ...hap_val.context,
+            ...hap_func.context,
+            locations: (hap_val.context.locations || []).concat(hap_func.context.locations || []),
+          });
+          haps.push(hap);
         }
       }
       return haps;
@@ -202,16 +408,17 @@ export class Pattern {
     const query = function (state) {
       const haps = [];
       for (const hap_val of pat_val.query(state)) {
-        const hap_funcs = pat_func.query(state.setSpan(hap_val.wholeOrPart()));
+        const hap_funcs = pat_func.query(state.setSpan(hap_val.part));
         for (const hap_func of hap_funcs) {
           const new_whole = hap_val.whole;
-          const new_part = hap_func.part.intersection(hap_val.part);
-          if (new_part) {
-            const new_value = hap_func.value(hap_val.value);
-            const new_context = hap_val.combineContext(hap_func);
-            const hap = new Hap(new_whole, new_part, new_value, new_context);
-            haps.push(hap);
-          }
+          const new_part = hap_func.part.intersection_e(hap_val.part);
+          const new_value = hap_func.value(hap_val.value);
+          const hap = new Hap(new_whole, new_part, new_value, {
+            ...hap_func.context,
+            ...hap_val.context,
+            locations: (hap_val.context.locations || []).concat(hap_func.context.locations || []),
+          });
+          haps.push(hap);
         }
       }
       return haps;
@@ -247,24 +454,9 @@ export class Pattern {
     );
   }
 
-  _opLeft(other, func) {
+  _opleft(other, func) {
     return this.fmap(func).appLeft(reify(other));
   }
-  _opRight(other, func) {
-    return this.fmap(func).appRight(reify(other));
-  }
-  _opBoth(other, func) {
-    return this.fmap(func).appBoth(reify(other));
-  }
-  _opSqueeze(other, func) {
-    const otherPat = reify(other);
-    return this.fmap((a) => otherPat.fmap((b) => func(a)(b)))._squeezeJoin();
-  }
-  _opSqueezeFlip(other, func) {
-    const thisPat = this;
-    const otherPat = reify(other);
-    return otherPat.fmap((a) => thisPat.fmap((b) => func(b)(a)))._squeezeJoin();
-  }
 
   _asNumber(silent = false) {
     return this._withEvent((event) => {
@@ -290,6 +482,22 @@ export class Pattern {
     })._removeUndefineds();
   }
 
+  add(other) {
+    return this._asNumber()._opleft(other, (a) => (b) => a + b);
+  }
+
+  sub(other) {
+    return this._asNumber()._opleft(other, (a) => (b) => a - b);
+  }
+
+  mul(other) {
+    return this._asNumber()._opleft(other, (a) => (b) => a * b);
+  }
+
+  div(other) {
+    return this._asNumber()._opleft(other, (a) => (b) => a / b);
+  }
+
   round() {
     return this._asNumber().fmap((v) => Math.round(v));
   }
@@ -302,25 +510,8 @@ export class Pattern {
     return this._asNumber().fmap((v) => Math.ceil(v));
   }
 
-  _toBipolar() {
-    return this.fmap((x) => x * 2 - 1);
-  }
-  _fromBipolar() {
-    return this.fmap((x) => (x + 1) / 2);
-  }
-
-  // Assumes source pattern of numbers in range 0..1
-  range(min, max) {
-    return this.mul(max - min).add(min);
-  }
-
-  rangex(min, max) {
-    return this.range(Math.log(min), Math.log(max)).fmap(Math.exp);
-  }
-
-  // Assumes source pattern of numbers in range -1..1
-  range2(min, max) {
-    return this._fromBipolar().range(min, max);
+  union(other) {
+    return this._opleft(other, (a) => (b) => Object.assign({}, a, b));
   }
 
   _bindWhole(choose_whole, func) {
@@ -362,18 +553,8 @@ export class Pattern {
     return this.bind(id);
   }
 
-  outerBind(func) {
-    return this._bindWhole((a, _) => a, func);
-  }
-
-  outerJoin() {
-    // Flattens a pattern of patterns into a pattern, where wholes are
-    // taken from inner events.
-    return this.outerBind(id);
-  }
-
   innerBind(func) {
-    return this._bindWhole((_, b) => b, func);
+    return this._bindWhole((a, _) => a, func);
   }
 
   innerJoin() {
@@ -382,41 +563,14 @@ export class Pattern {
     return this.innerBind(id);
   }
 
-  _squeezeJoin() {
-    const pat_of_pats = this;
-    function query(state) {
-      const haps = pat_of_pats.query(state);
-      function flatHap(outerHap) {
-        const pat = outerHap.value._compressSpan(outerHap.wholeOrPart().cycleArc());
-        const innerHaps = pat.query(state.setSpan(outerHap.part));
-        function munge(outer, inner) {
-          let whole = undefined;
-          if (inner.whole && outer.whole) {
-            whole = inner.whole.intersection(outer.whole);
-            if (!whole) {
-              // The wholes are present, but don't intersect
-              return undefined;
-            }
-          }
-          const part = inner.part.intersection(outer.part);
-          if (!part) {
-            // The parts don't intersect
-            return undefined;
-          }
-          const context = inner.combineContext(outer);
-          return new Hap(whole, part, inner.value, context);
-        }
-        return innerHaps.map((innerHap) => munge(outerHap, innerHap));
-      }
-      const result = flatten(haps.map(flatHap));
-      // remove undefineds
-      return result.filter((x) => x);
-    }
-    return new Pattern(query);
+  outerBind(func) {
+    return this._bindWhole((_, b) => b, func);
   }
 
-  _squeezeBind(func) {
-    return this.fmap(func)._squeezeJoin();
+  outerJoin() {
+    // Flattens a pattern of patterns into a pattern, where wholes are
+    // taken from inner events.
+    return this.outerBind(id);
   }
 
   _apply(func) {
@@ -436,7 +590,7 @@ export class Pattern {
       args = args.map((arg) => (isPattern(arg) ? arg.fmap((value) => value.value || value) : arg));
       const pat_arg = sequence(...args);
       // arg.locations has to go somewhere..
-      return pat_arg.fmap((arg) => func.call(pat, arg)).innerJoin();
+      return pat_arg.fmap((arg) => func.call(pat, arg)).outerJoin();
     };
     return patterned;
   }
@@ -462,17 +616,15 @@ export class Pattern {
     return this.withQuerySpan(qf).withEventSpan(ef)._splitQueries();
   }
 
-  _compress(b, e) {
-    if (b.gt(e) || b.gt(1) || e.gt(1) || b.lt(0) || e.lt(0)) {
+  _compressSpan(span) {
+    const b = span.begin;
+    const e = span.end;
+    if (b > e || b > 1 || e > 1 || b < 0 || e < 0) {
       return silence;
     }
     return this._fastGap(Fraction(1).div(e.sub(b)))._late(b);
   }
 
-  _compressSpan(span) {
-    return this._compress(span.begin, span.end);
-  }
-
   _fast(factor) {
     const fastQuery = this.withQueryTime((t) => t.mul(factor));
     return fastQuery.withEventTime((t) => t.div(factor));
@@ -482,26 +634,6 @@ export class Pattern {
     return this._fast(Fraction(1).div(factor));
   }
 
-  _ply(factor) {
-    return this.fmap((x) => pure(x)._fast(factor))._squeezeJoin();
-  }
-
-  _chop(n) {
-    const slices = Array.from({ length: n }, (x, i) => i);
-    const slice_objects = slices.map((i) => ({ begin: i / n, end: (i + 1) / n }));
-    const func = function (o) {
-      return sequence(slice_objects.map((slice_o) => Object.assign({}, o, slice_o)));
-    };
-    return this._squeezeBind(func);
-  }
-
-  _striate(n) {
-    const slices = Array.from({ length: n }, (x, i) => i);
-    const slice_objects = slices.map((i) => ({ begin: i / n, end: (i + 1) / n }));
-    const slicePat = slowcat(...slice_objects);
-    return this.set(slicePat)._fast(n);
-  }
-
   // cpm = cycles per minute
   _cpm(cpm) {
     return this._fast(cpm / 60);
@@ -519,28 +651,6 @@ export class Pattern {
     return this._early(Fraction(0).sub(offset));
   }
 
-  _zoom(s, e) {
-    e = Fraction(e);
-    s = Fraction(s);
-    const d = e.sub(s);
-    return this.withQuerySpan((span) => span.withCycle((t) => t.mul(d).add(s)))
-      .withEventSpan((span) => span.withCycle((t) => t.sub(s).div(d)))
-      ._splitQueries();
-  }
-
-  _zoomArc(a) {
-    return this.zoom(a.begin, a.end);
-  }
-
-  _linger(t) {
-    if (t == 0) {
-      return silence;
-    } else if (t < 0) {
-      return this._zoom(t.add(1), 1)._slow(t);
-    }
-    return this._zoom(0, t)._slow(t);
-  }
-
   struct(...binary_pats) {
     // Re structure the pattern according to a binary pattern (false values are dropped)
     const binary_pat = sequence(binary_pats);
@@ -564,7 +674,7 @@ export class Pattern {
   }
 
   _segment(rate) {
-    return this.struct(pure(true)._fast(rate));
+    return this.struct(pure(true).fast(rate));
   }
 
   invert() {
@@ -591,10 +701,6 @@ export class Pattern {
   }
 
   every(n, func) {
-    if (func instanceof Pattern) {
-      const p = func;
-      func = (x) => x.set(p);
-    }
     const pat = this;
     const pats = Array(n - 1).fill(pat);
     pats.unshift(func(pat));
@@ -625,11 +731,7 @@ export class Pattern {
     return new Pattern(query)._splitQueries();
   }
 
-  palindrome() {
-    return this.every(2, rev);
-  }
-
-  juxBy(by, func) {
+  jux(func, by = 1) {
     by /= 2;
     const elem_or = function (dict, key, dflt) {
       if (key in dict) {
@@ -643,10 +745,6 @@ export class Pattern {
     return stack(left, func(right));
   }
 
-  _jux(func) {
-    return this.juxBy(1, func);
-  }
-
   // is there a different name for those in tidal?
   stack(...pats) {
     return stack(this, ...pats);
@@ -660,7 +758,7 @@ export class Pattern {
   }
 
   stutWith(times, time, func) {
-    return stack(...listRange(0, times - 1).map((i) => func(this.late(Fraction(time).mul(i)), i)));
+    return stack(...range(0, times - 1).map((i) => func(this.late(i * time), i)));
   }
 
   stut(times, feedback, time) {
@@ -669,7 +767,7 @@ export class Pattern {
 
   // these might change with: https://github.com/tidalcycles/Tidal/issues/902
   _echoWith(times, time, func) {
-    return stack(...listRange(0, times - 1).map((i) => func(this.late(Fraction(time).mul(i)), i)));
+    return stack(...range(0, times - 1).map((i) => func(this.late(i * time), i)));
   }
 
   _echo(times, time, feedback) {
@@ -677,7 +775,7 @@ export class Pattern {
   }
 
   iter(times, back = false) {
-    return slowcat(...listRange(0, times - 1).map((i) => (back ? this.late(i / times) : this.early(i / times))));
+    return slowcat(...range(0, times - 1).map((i) => (back ? this.late(i / times) : this.early(i / times))));
   }
 
   // known as iter' in tidalcycles
@@ -727,67 +825,19 @@ export class Pattern {
   }
 }
 
-// pattern composers
-const composers = {
-  set: [
-    (a) => (b) => {
-      // If an object is involved, do a union, discarding matching keys from a.
-      // Otherwise, just return b.
-      if (a instanceof Object || b instanceof Object) {
-        if (!a instanceof Object) {
-          a = { value: a };
-        }
-        if (!b instanceof Object) {
-          b = { value: b };
-        }
-        return Object.assign({}, a, b);
-      }
-      return b;
-    },
-    id,
-  ],
-  add: [(a) => (b) => a + b, (x) => x._asNumber()],
-  sub: [(a) => (b) => a - b, (x) => x._asNumber()],
-  mul: [(a) => (b) => a * b, (x) => x._asNumber()],
-  div: [(a) => (b) => a / b, (x) => x._asNumber()],
-};
-
-for (const [name, op] of Object.entries(composers)) {
-  Pattern.prototype[name] = function (...other) {
-    return op[1](this)._opLeft(sequence(other), op[0]);
-  };
-  Pattern.prototype[name + 'Flip'] = function (...other) {
-    return op[1](this)._opRight(sequence(other), op[0]);
-  };
-  Pattern.prototype[name + 'Sect'] = function (...other) {
-    return op[1](this)._opBoth(sequence(other), op[0]);
-  };
-  Pattern.prototype[name + 'Squeeze'] = function (...other) {
-    return op[1](this)._opSqueeze(sequence(other), op[0]);
-  };
-  Pattern.prototype[name + 'SqueezeFlip'] = function (...other) {
-    return op[1](this)._opSqueezeFlip(sequence(other), op[0]);
-  };
-}
-
 // methods of Pattern that get callable factories
 Pattern.prototype.patternified = [
   'apply',
-  'chop',
-  'color',
-  'cpm',
-  'duration',
-  'early',
   'fast',
-  'jux',
-  'late',
-  'legato',
-  'linger',
-  'ply',
-  'segment',
-  'striate',
   'slow',
+  'cpm',
+  'early',
+  'late',
+  'duration',
+  'legato',
   'velocity',
+  'segment',
+  'color',
 ];
 // methods that create patterns, which are added to patternified Pattern methods
 Pattern.prototype.factories = { pure, stack, slowcat, fastcat, cat, timeCat, sequence, polymeter, pm, polyrhythm, pr };
@@ -796,9 +846,9 @@ Pattern.prototype.factories = { pure, stack, slowcat, fastcat, cat, timeCat, seq
 // Elemental patterns
 
 // Nothing
-export const silence = new Pattern((_) => []);
+const silence = new Pattern((_) => []);
 
-export function pure(value) {
+function pure(value) {
   // A discrete value that repeats once per cycle
   function query(state) {
     return state.span.spanCycles.map((subspan) => new Hap(Fraction(subspan.begin).wholeCycle(), subspan, value));
@@ -806,12 +856,43 @@ export function pure(value) {
   return new Pattern(query);
 }
 
+function steady(value) {
+  // A continuous value
+  return new Pattern((span) => Hap(undefined, span, value));
+}
+
+export const signal = (func) => {
+  const query = (state) => [new Hap(undefined, state.span, func(state.span.midpoint()))];
+  return new Pattern(query);
+};
+
+const _toBipolar = (pat) => pat.fmap((x) => x * 2 - 1);
+const _fromBipolar = (pat) => pat.fmap((x) => (x + 1) / 2);
+
+export const sine2 = signal((t) => Math.sin(Math.PI * 2 * t));
+export const sine = _fromBipolar(sine2);
+
+export const cosine2 = sine2._early(Fraction(1).div(4));
+export const cosine = sine._early(Fraction(1).div(4));
+
+export const saw = signal((t) => t % 1);
+export const saw2 = _toBipolar(saw);
+
+export const isaw = signal((t) => 1 - (t % 1));
+export const isaw2 = _toBipolar(isaw);
+
+export const tri2 = fastcat(isaw2, saw2);
+export const tri = fastcat(isaw, saw);
+
+export const square = signal((t) => Math.floor((t * 2) % 2));
+export const square2 = _toBipolar(square);
+
 export function isPattern(thing) {
   // thing?.constructor?.name !== 'Pattern' // <- this will fail when code is mangled
   return thing instanceof Pattern;
 }
 
-export function reify(thing) {
+function reify(thing) {
   // Turns something into a pattern, unless it's already a pattern
   if (isPattern(thing)) {
     return thing;
@@ -820,13 +901,13 @@ export function reify(thing) {
 }
 // Basic functions for combining patterns
 
-export function stack(...pats) {
+function stack(...pats) {
   const reified = pats.map((pat) => reify(pat));
   const query = (state) => flatten(reified.map((pat) => pat.query(state)));
   return new Pattern(query);
 }
 
-export function slowcat(...pats) {
+function slowcat(...pats) {
   // Concatenation: combines a list of patterns, switching between them
   // successively, one per cycle.
   pats = pats.map(reify);
@@ -847,7 +928,7 @@ export function slowcat(...pats) {
   return new Pattern(query)._splitQueries();
 }
 
-export function slowcatPrime(...pats) {
+function slowcatPrime(...pats) {
   // Concatenation: combines a list of patterns, switching between them
   // successively, one per cycle. Unlike slowcat, this version will skip cycles.
   pats = pats.map(reify);
@@ -859,24 +940,24 @@ export function slowcatPrime(...pats) {
   return new Pattern(query)._splitQueries();
 }
 
-export function fastcat(...pats) {
+function fastcat(...pats) {
   // Concatenation: as with slowcat, but squashes a cycle from each
   // pattern into one cycle
   return slowcat(...pats)._fast(pats.length);
 }
 
-export function cat(...pats) {
+function cat(...pats) {
   return fastcat(...pats);
 }
 
-export function timeCat(...timepats) {
+function timeCat(...timepats) {
   // Like cat, but where each step has a temporal 'weight'
   const total = timepats.map((a) => a[0]).reduce((a, b) => a.add(b), Fraction(0));
   let begin = Fraction(0);
   const pats = [];
   for (const [time, pat] of timepats) {
     const end = begin.add(time);
-    pats.push(reify(pat)._compress(begin.div(total), end.div(total)));
+    pats.push(reify(pat)._compressSpan(new TimeSpan(begin.div(total), end.div(total))));
     begin = end;
   }
   return stack(...pats);
@@ -895,11 +976,11 @@ function _sequenceCount(x) {
   return [reify(x), 1];
 }
 
-export function sequence(...xs) {
+function sequence(...xs) {
   return _sequenceCount(xs)[0];
 }
 
-export function polymeterSteps(steps, ...args) {
+function polymeter(steps = 0, ...args) {
   const seqs = args.map((a) => _sequenceCount(a));
   if (seqs.length == 0) {
     return silence;
@@ -918,19 +999,15 @@ export function polymeterSteps(steps, ...args) {
       pats.push(seq[0]._fast(Fraction(steps).div(Fraction(seq[1]))));
     }
   }
-  return stack(...pats);
-}
-
-export function polymeter(...args) {
-  return polymeterSteps(0, ...args);
+  return stack(pats);
 }
 
 // alias
-export function pm(...args) {
-  polymeter(...args);
+function pm(args) {
+  polymeter(args);
 }
 
-export function polyrhythm(...xs) {
+function polyrhythm(...xs) {
   const seqs = xs.map((a) => sequence(a));
 
   if (seqs.length == 0) {
@@ -940,40 +1017,35 @@ export function polyrhythm(...xs) {
 }
 
 // alias
-export function pr(args) {
+function pr(args) {
   polyrhythm(args);
 }
 
-export const add = curry((a, pat) => pat.add(a));
-export const append = curry((a, pat) => pat.append(a));
-export const chunk = curry((a, pat) => pat.chunk(a));
-export const chunkBack = curry((a, pat) => pat.chunkBack(a));
-export const div = curry((a, pat) => pat.div(a));
-export const early = curry((a, pat) => pat.early(a));
-export const echo = curry((a, b, c, pat) => pat.echo(a, b, c));
-export const every = curry((i, f, pat) => pat.every(i, f));
-export const fast = curry((a, pat) => pat.fast(a));
-export const inv = (pat) => pat.inv();
-export const invert = (pat) => pat.invert();
-export const iter = curry((a, pat) => pat.iter(a));
-export const iterBack = curry((a, pat) => pat.iter(a));
-export const jux = curry((f, pat) => pat.jux(f));
-export const juxBy = curry((by, f, pat) => pat.juxBy(by, f));
-export const late = curry((a, pat) => pat.late(a));
-export const linger = curry((a, pat) => pat.linger(a));
-export const mask = curry((a, pat) => pat.mask(a));
-export const mul = curry((a, pat) => pat.mul(a));
-export const off = curry((t, f, pat) => pat.off(t, f));
-export const ply = curry((a, pat) => pat.ply(a));
-export const range = curry((a, b, pat) => pat.range(a, b));
-export const range2 = curry((a, b, pat) => pat.range2(a, b));
-export const rev = (pat) => pat.rev();
-export const slow = curry((a, pat) => pat.slow(a));
-export const struct = curry((a, pat) => pat.struct(a));
-export const sub = curry((a, pat) => pat.sub(a));
-export const superimpose = curry((array, pat) => pat.superimpose(...array));
-export const set = curry((a, pat) => pat.set(a));
-export const when = curry((binary, f, pat) => pat.when(binary, f));
+const fast = curry((a, pat) => pat.fast(a));
+const slow = curry((a, pat) => pat.slow(a));
+const early = curry((a, pat) => pat.early(a));
+const late = curry((a, pat) => pat.late(a));
+const rev = (pat) => pat.rev();
+const add = curry((a, pat) => pat.add(a));
+const sub = curry((a, pat) => pat.sub(a));
+const mul = curry((a, pat) => pat.mul(a));
+const div = curry((a, pat) => pat.div(a));
+const union = curry((a, pat) => pat.union(a));
+const every = curry((i, f, pat) => pat.every(i, f));
+const when = curry((binary, f, pat) => pat.when(binary, f));
+const off = curry((t, f, pat) => pat.off(t, f));
+const jux = curry((f, pat) => pat.jux(f));
+const append = curry((a, pat) => pat.append(a));
+const superimpose = curry((array, pat) => pat.superimpose(...array));
+const struct = curry((a, pat) => pat.struct(a));
+const mask = curry((a, pat) => pat.mask(a));
+const echo = curry((a, b, c, pat) => pat.echo(a, b, c));
+const invert = (pat) => pat.invert();
+const inv = (pat) => pat.inv();
+const iter = curry((a, pat) => pat.iter(a));
+const iterBack = curry((a, pat) => pat.iter(a));
+const chunk = curry((a, pat) => pat.chunk(a));
+const chunkBack = curry((a, pat) => pat.chunkBack(a));
 
 // problem: curried functions with spread arguments must have pat at the beginning
 // with this, we cannot keep the pattern open at the end.. solution for now: use array to keep using pat as last arg
@@ -997,24 +1069,24 @@ export function makeComposable(func) {
   return func;
 }
 
-export const patternify2 = (f) => (pata, patb, pat) =>
+const patternify2 = (f) => (pata, patb, pat) =>
   pata
     .fmap((a) => (b) => f.call(pat, a, b))
     .appLeft(patb)
-    .innerJoin();
-export const patternify3 = (f) => (pata, patb, patc, pat) =>
+    .outerJoin();
+const patternify3 = (f) => (pata, patb, patc, pat) =>
   pata
     .fmap((a) => (b) => (c) => f.call(pat, a, b, c))
     .appLeft(patb)
     .appLeft(patc)
-    .innerJoin();
-export const patternify4 = (f) => (pata, patb, patc, patd, pat) =>
+    .outerJoin();
+const patternify4 = (f) => (pata, patb, patc, patd, pat) =>
   pata
     .fmap((a) => (b) => (c) => (d) => f.call(pat, a, b, c, d))
     .appLeft(patb)
     .appLeft(patc)
     .appLeft(patd)
-    .innerJoin();
+    .outerJoin();
 
 Pattern.prototype.echo = function (...args) {
   args = args.map(reify);
@@ -1032,14 +1104,6 @@ Pattern.prototype.chunkBack = function (...args) {
   args = args.map(reify);
   return patternify2(Pattern.prototype._chunkBack)(...args, this);
 };
-Pattern.prototype.zoom = function (...args) {
-  args = args.map(reify);
-  return patternify2(Pattern.prototype._zoom)(...args, this);
-};
-Pattern.prototype.compress = function (...args) {
-  args = args.map(reify);
-  return patternify2(Pattern.prototype._compress)(...args, this);
-};
 
 // call this after all Patter.prototype.define calls have been executed! (right before evaluate)
 Pattern.prototype.bootstrap = function () {
@@ -1092,3 +1156,50 @@ Pattern.prototype.define = (name, func, options = {}) => {
 // Pattern.prototype.define('early', (a, pat) => pat.early(a), { patternified: true, composable: true });
 Pattern.prototype.define('hush', (pat) => pat.hush(), { patternified: false, composable: true });
 Pattern.prototype.define('bypass', (pat) => pat.bypass(on), { patternified: true, composable: true });
+
+export {
+  Fraction,
+  TimeSpan,
+  Hap,
+  Pattern,
+  pure,
+  stack,
+  slowcat,
+  fastcat,
+  cat,
+  timeCat,
+  sequence,
+  polymeter,
+  pm,
+  polyrhythm,
+  pr,
+  reify,
+  silence,
+  fast,
+  slow,
+  early,
+  late,
+  rev,
+  add,
+  sub,
+  mul,
+  div,
+  union,
+  every,
+  when,
+  off,
+  jux,
+  append,
+  superimpose,
+  struct,
+  mask,
+  invert,
+  inv,
+  id,
+  range,
+  echo,
+  iter,
+  iterBack,
+  chunk,
+  chunkBack,
+};

packages/core/test/util.test.mjs

@@ -1,6 +1,5 @@
 import { strict as assert } from 'assert';
-import { pure } from '../pattern.mjs';
-import { isNote, tokenizeNote, toMidi, fromMidi, mod, compose, getFrequency } from '../util.mjs';
+import { isNote, tokenizeNote, toMidi, mod } from '../util.mjs';
 
 describe('isNote', () => {
   it('should recognize notes without accidentals', () => {
@@ -65,21 +64,6 @@ describe('toMidi', () => {
     assert.equal(toMidi('C##3'), 50);
   });
 });
-describe('fromMidi', () => {
-  it('should turn midi into frequency', () => {
-    assert.equal(fromMidi(69), 440);
-    assert.equal(fromMidi(57), 220);
-  });
-});
-describe('getFrequency', () => {
-  it('should turn midi into frequency', () => {
-    const happify = (val, context = {}) => pure(val).firstCycle()[0].setContext(context);
-    assert.equal(getFrequency(happify('a4')), 440);
-    assert.equal(getFrequency(happify('a3')), 220);
-    assert.equal(getFrequency(happify(440, { type: 'frequency' })), 440); // TODO: migrate when values are objects..
-    assert.equal(getFrequency(happify(432, { type: 'frequency' })), 432);
-  });
-});
 
 describe('mod', () => {
   it('should work like regular modulo with positive numbers', () => {
@@ -99,16 +83,3 @@ describe('mod', () => {
     assert.equal(mod(-3, 2), 1);
   });
 });
-
-describe('compose', () => {
-  const add1 = (a) => a + 1;
-  it('should compose', () => {
-    assert.equal(compose(add1, add1)(0), 2);
-    assert.equal(compose(add1)(0), 1);
-  });
-  const addS = (s) => (a) => a + s;
-  it('should compose left to right', () => {
-    assert.equal(compose(addS('a'), addS('b'))(''), 'ab');
-    assert.equal(compose(addS('a'), addS('b'))('x'), 'xab');
-  });
-});

packages/core/timespan.mjs

@@ -1,102 +0,0 @@
-import Fraction from './fraction.mjs';
-
-export class TimeSpan {
-  constructor(begin, end) {
-    this.begin = Fraction(begin);
-    this.end = Fraction(end);
-  }
-
-  get spanCycles() {
-    const spans = [];
-    var begin = this.begin;
-    const end = this.end;
-    const end_sam = end.sam();
-
-    while (end.gt(begin)) {
-      // If begin and end are in the same cycle, we're done.
-      if (begin.sam().equals(end_sam)) {
-        spans.push(new TimeSpan(begin, this.end));
-        break;
-      }
-      // add a timespan up to the next sam
-      const next_begin = begin.nextSam();
-      spans.push(new TimeSpan(begin, next_begin));
-
-      // continue with the next cycle
-      begin = next_begin;
-    }
-    return spans;
-  }
-
-  cycleArc() {
-    // Shifts a timespan to one of equal duration that starts within cycle zero.
-    // (Note that the output timespan probably does not start *at* Time 0 --
-    // that only happens when the input Arc starts at an integral Time.)
-    const b = this.begin.cyclePos();
-    const e = b.add(this.end.sub(this.begin));
-    return new TimeSpan(b, e);
-  }
-
-  withTime(func_time) {
-    // Applies given function to both the begin and end time of the timespan"""
-    return new TimeSpan(func_time(this.begin), func_time(this.end));
-  }
-
-  withEnd(func_time) {
-    // Applies given function to the end time of the timespan"""
-    return new TimeSpan(this.begin, func_time(this.end));
-  }
-
-  withCycle(func_time) {
-    // Like withTime, but time is relative to relative to the cycle (i.e. the
-    // sam of the start of the timespan)
-    const sam = this.begin.sam();
-    const b = sam.add(func_time(this.begin.sub(sam)));
-    const e = sam.add(func_time(this.end.sub(sam)));
-    return new TimeSpan(b, e);
-  }
-
-  intersection(other) {
-    // Intersection of two timespans, returns None if they don't intersect.
-    const intersect_begin = this.begin.max(other.begin);
-    const intersect_end = this.end.min(other.end);
-
-    if (intersect_begin.gt(intersect_end)) {
-      return undefined;
-    }
-    if (intersect_begin.equals(intersect_end)) {
-      // Zero-width (point) intersection - doesn't intersect if it's at the end of a
-      // non-zero-width timespan.
-      if (intersect_begin.equals(this.end) && this.begin.lt(this.end)) {
-        return undefined;
-      }
-      if (intersect_begin.equals(other.end) && other.begin.lt(other.end)) {
-        return undefined;
-      }
-    }
-    return new TimeSpan(intersect_begin, intersect_end);
-  }
-
-  intersection_e(other) {
-    // Like 'sect', but raises an exception if the timespans don't intersect.
-    const result = this.intersection(other);
-    if (result == undefined) {
-      throw 'TimeSpans do not intersect';
-    }
-    return result;
-  }
-
-  midpoint() {
-    return this.begin.add(this.end.sub(this.begin).div(Fraction(2)));
-  }
-
-  equals(other) {
-    return this.begin.equals(other.begin) && this.end.equals(other.end);
-  }
-
-  show() {
-    return this.begin.show() + ' -> ' + this.end.show();
-  }
-}
-
-export default TimeSpan;

packages/core/util.mjs

@@ -40,63 +40,5 @@ export const getPlayableNoteValue = (event) => {
   return note;
 };
 
-export const getFrequency = (event) => {
-  let { value, context } = event;
-  // if value is number => interpret as midi number as long as its not marked as frequency
-  if (typeof value === 'object' && value.freq) {
-    return value.freq;
-  }
-  if (typeof value === 'number' && context.type !== 'frequency') {
-    value = fromMidi(event.value);
-  } else if (typeof value === 'string' && isNote(value)) {
-    value = fromMidi(toMidi(event.value));
-  } else if (typeof value !== 'number') {
-    throw new Error('not a note or frequency:' + value);
-  }
-  return value;
-};
-
 // rotate array by n steps (to the left)
 export const rotate = (arr, n) => arr.slice(n).concat(arr.slice(0, n));
-
-export const pipe = (...funcs) => {
-  return funcs.reduce(
-    (f, g) =>
-      (...args) =>
-        f(g(...args)),
-    (x) => x,
-  );
-};
-
-export const compose = (...funcs) => pipe(...funcs.reverse());
-
-// Removes 'None' values from given list
-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 listRange = (min, max) => Array.from({ length: max - min + 1 }, (_, i) => i + min);
-
-export function curry(func, overload) {
-  const fn = function curried(...args) {
-    if (args.length >= func.length) {
-      return func.apply(this, args);
-    } else {
-      const partial = function (...args2) {
-        return curried.apply(this, args.concat(args2));
-      };
-      if (overload) {
-        overload(partial, args);
-      }
-      return partial;
-    }
-  };
-  if (overload) {
-    // overload function without args... needed for chordBass.transpose(2)
-    overload(fn, []);
-  }
-  return fn;
-}

packages/core/value.mjs

@@ -1,4 +1,4 @@
-import { curry } from './util.mjs';
+import { curry } from 'ramda';
 
 function unionWithObj(a, b, func) {
   const common = Object.keys(a).filter((k) => Object.keys(b).includes(k));

packages/eval/package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "@strudel.cycles/eval",
-	"version": "0.0.5",
+	"version": "0.0.2",
 	"lockfileVersion": 2,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "@strudel.cycles/eval",
-			"version": "0.0.3",
+			"version": "0.0.1",
 			"license": "GPL-3.0-or-later",
 			"dependencies": {
 				"estraverse": "^5.3.0",

packages/eval/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel.cycles/eval",
-  "version": "0.0.5",
+  "version": "0.0.2",
   "description": "Code evaluator for strudel",
   "main": "evaluate.mjs",
   "directories": {
@@ -28,7 +28,7 @@
   },
   "homepage": "https://github.com/tidalcycles/strudel#readme",
   "dependencies": {
-    "@strudel.cycles/core": "^0.0.5",
+    "@strudel.cycles/core": "^0.0.2",
     "estraverse": "^5.3.0",
     "shift-ast": "^6.1.0",
     "shift-codegen": "^7.0.3",

packages/eval/shapeshifter.mjs

@@ -15,7 +15,7 @@ import {
 import shiftCodegen from 'shift-codegen';
 const codegen = shiftCodegen.default || shiftCodegen; // parcel module resolution fuckup
 
-import * as strudel from '@strudel.cycles/core';
+import * as strudel from '@strudel.cycles/core/strudel.mjs';
 
 const { Pattern } = strudel;
 

packages/midi/midi.mjs

@@ -1,6 +1,6 @@
 import { isNote } from 'tone';
 import _WebMidi from 'webmidi';
-import { Pattern, isPattern } from '@strudel.cycles/core';
+import { Pattern, isPattern } from '@strudel.cycles/core/strudel.mjs';
 import { Tone } from '@strudel.cycles/tone';
 
 // if you use WebMidi from outside of this package, make sure to import that instance:

packages/midi/package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "@strudel.cycles/midi",
-	"version": "0.0.6",
+	"version": "0.0.3",
 	"lockfileVersion": 2,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "@strudel.cycles/midi",
-			"version": "0.0.4",
+			"version": "0.0.1",
 			"license": "GPL-3.0-or-later",
 			"dependencies": {
 				"tone": "^14.7.77",

packages/midi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel.cycles/midi",
-  "version": "0.0.6",
+  "version": "0.0.3",
   "description": "Midi API for strudel",
   "main": "midi.mjs",
   "repository": {
@@ -21,7 +21,7 @@
   },
   "homepage": "https://github.com/tidalcycles/strudel#readme",
   "dependencies": {
-    "@strudel.cycles/tone": "^0.0.6",
+    "@strudel.cycles/tone": "^0.0.3",
     "tone": "^14.7.77",
     "webmidi": "^2.5.2"
   }

packages/mini/mini.mjs

@@ -1,5 +1,5 @@
 import * as krill from './krill-parser.js';
-import * as strudel from '@strudel.cycles/core';
+import * as strudel from '@strudel.cycles/core/strudel.mjs';
 import { addMiniLocations } from '@strudel.cycles/eval/shapeshifter.mjs';
 
 const { pure, Pattern, Fraction, stack, slowcat, sequence, timeCat, silence, reify } = strudel;

packages/mini/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel.cycles/mini",
-  "version": "0.0.7",
+  "version": "0.0.3",
   "description": "Mini notation for strudel",
   "main": "mini.mjs",
   "type": "module",
@@ -25,8 +25,7 @@
   },
   "homepage": "https://github.com/tidalcycles/strudel#readme",
   "dependencies": {
-    "@strudel.cycles/core": "^0.0.5",
-    "@strudel.cycles/eval": "^0.0.5",
-    "@strudel.cycles/tone": "^0.0.6"
+    "@strudel.cycles/eval": "^0.0.2",
+    "@strudel.cycles/tone": "^0.0.3"
   }
 }

packages/osc/README.md

@@ -1,37 +0,0 @@
-# @strudel.cycles/osc
-
-OSC output for strudel patterns! Currently only tested with super collider / super dirt.
-
-## Usage
-
-OSC will only work if you run the REPL locally + the OSC server besides it:
-
-From the project root:
-
-```js
-npm run repl
-```
-
-and in a seperate shell:
-
-```js
-npm run osc
-```
-
-This should give you
-
-```log
-osc client running on port 57120
-osc server running on port 57121
-websocket server running on port 8080
-```
-
-Now open Supercollider (with the super dirt startup file)
-
-Now open the REPL and type:
-
-```js
-s("<bd sd> hh").osc()
-```
-
-or just [click here](http://localhost:3000/#cygiPGJkIHNkPiBoaCIpLm9zYygp)...

packages/osc/index.html

@@ -1,22 +0,0 @@
-<button id="send" style="font-size: 2em">Thank you @ojack</button>
-<script type="text/javascript" src="./node_modules/osc-js/lib/osc.min.js"></script>
-<script type="text/javascript">
-  const comm = new OSC();
-  comm.open(); // connect by default to ws://localhost:8080
-  document.getElementById('send').addEventListener('click', function () {
-    // this will send a message via websocket to the node server
-
-    // the great question: how do i know which time super collider is at????????
-    const message = new OSC.Message(
-      '/dirt/play',
-      ...['_id_', '1', 'cps', 0.5625, 'cycle', 412.3333435058594, 'delta', 0.592592716217041, 'orbit', 0, 's', 'hh'],
-    );
-
-    comm.send(message);
-    console.log('sent:', message.address, message.args);
-  });
-  /* 
-  comm.on('*', (m) => {
-    console.log('received:', m.address, m.args);
-  }); */
-</script>

packages/osc/osc.mjs

@@ -1,23 +0,0 @@
-import OSC from 'osc-js';
-import { Pattern } from '@strudel.cycles/core';
-
-const comm = new OSC();
-comm.open();
-const latency = 0.1;
-
-Pattern.prototype.osc = function () {
-  return this._withEvent((event) => {
-    const onTrigger = (time, event, currentTime) => {
-      // time should be audio time of onset
-      // currentTime should be current time of audio context (slightly before time)
-      const keyvals = Object.entries(event.value).flat();
-      const offset = (time - currentTime + latency) * 1000;
-      const ts = Math.floor(Date.now() + offset);
-      const message = new OSC.Message('/dirt/play', ...keyvals);
-      const bundle = new OSC.Bundle([message], ts);
-      bundle.timestamp(ts); // workaround for https://github.com/adzialocha/osc-js/issues/60
-      comm.send(bundle);
-    };
-    return event.setContext({ ...event.context, onTrigger });
-  });
-};

packages/osc/package-lock.json

@@ -1,60 +0,0 @@
-{
-	"name": "@strudel.cycles/osc",
-	"version": "0.0.2",
-	"lockfileVersion": 2,
-	"requires": true,
-	"packages": {
-		"": {
-			"name": "@strudel.cycles/osc",
-			"version": "0.0.1",
-			"license": "GPL-3.0-or-later",
-			"dependencies": {
-				"osc-js": "^2.3.2"
-			}
-		},
-		"node_modules/osc-js": {
-			"version": "2.3.2",
-			"resolved": "https://registry.npmjs.org/osc-js/-/osc-js-2.3.2.tgz",
-			"integrity": "sha512-9i7J4u1hH+glooGMh+ki1ni0JGqKmylT8r0nXKugHbRK63rR+kl4O+5tGW6+/EszjbCju3KV+eXQQzFDdGrmhg==",
-			"dependencies": {
-				"ws": "^8.5.0"
-			}
-		},
-		"node_modules/ws": {
-			"version": "8.5.0",
-			"resolved": "https://registry.npmjs.org/ws/-/ws-8.5.0.tgz",
-			"integrity": "sha512-BWX0SWVgLPzYwF8lTzEy1egjhS4S4OEAHfsO8o65WOVsrnSRGaSiUaa9e0ggGlkMTtBlmOpEXiie9RUcBO86qg==",
-			"engines": {
-				"node": ">=10.0.0"
-			},
-			"peerDependencies": {
-				"bufferutil": "^4.0.1",
-				"utf-8-validate": "^5.0.2"
-			},
-			"peerDependenciesMeta": {
-				"bufferutil": {
-					"optional": true
-				},
-				"utf-8-validate": {
-					"optional": true
-				}
-			}
-		}
-	},
-	"dependencies": {
-		"osc-js": {
-			"version": "2.3.2",
-			"resolved": "https://registry.npmjs.org/osc-js/-/osc-js-2.3.2.tgz",
-			"integrity": "sha512-9i7J4u1hH+glooGMh+ki1ni0JGqKmylT8r0nXKugHbRK63rR+kl4O+5tGW6+/EszjbCju3KV+eXQQzFDdGrmhg==",
-			"requires": {
-				"ws": "^8.5.0"
-			}
-		},
-		"ws": {
-			"version": "8.5.0",
-			"resolved": "https://registry.npmjs.org/ws/-/ws-8.5.0.tgz",
-			"integrity": "sha512-BWX0SWVgLPzYwF8lTzEy1egjhS4S4OEAHfsO8o65WOVsrnSRGaSiUaa9e0ggGlkMTtBlmOpEXiie9RUcBO86qg==",
-			"requires": {}
-		}
-	}
-}

packages/osc/package.json

@@ -1,33 +0,0 @@
-{
-  "name": "@strudel.cycles/osc",
-  "version": "0.0.2",
-  "description": "OSC messaging for strudel",
-  "main": "osc.mjs",
-  "scripts": {
-    "test": "echo \"No tests present.\" && exit 0",
-    "server": "node server.js",
-    "tidal-sniffer": "node tidal-sniffer.js",
-    "client": "npx serve -p 4321"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/tidalcycles/strudel.git"
-  },
-  "keywords": [
-    "tidalcycles",
-    "strudel",
-    "pattern",
-    "livecoding",
-    "algorave"
-  ],
-  "author": "Felix Roos <flix91@gmail.com>",
-  "contributors": ["Alex McLean <alex@slab.org>"],
-  "license": "GPL-3.0-or-later",
-  "bugs": {
-    "url": "https://github.com/tidalcycles/strudel/issues"
-  },
-  "homepage": "https://github.com/tidalcycles/strudel#readme",
-  "dependencies": {
-    "osc-js": "^2.3.2"
-  }
-}

packages/osc/server.js

@@ -1,30 +0,0 @@
-const OSC = require('osc-js');
-
-const config = {
-  receiver: 'ws', // @param {string} Where messages sent via 'send' method will be delivered to, 'ws' for Websocket clients, 'udp' for udp client
-  udpServer: {
-    host: 'localhost', // @param {string} Hostname of udp server to bind to
-    port: 57121, // @param {number} Port of udp client for messaging
-    // enabling the following line will receive tidal messages:
-    // port: 57120, // @param {number} Port of udp client for messaging
-    exclusive: false, // @param {boolean} Exclusive flag
-  },
-  udpClient: {
-    host: 'localhost', // @param {string} Hostname of udp client for messaging
-    port: 57120, // @param {number} Port of udp client for messaging
-  },
-  wsServer: {
-    host: 'localhost', // @param {string} Hostname of WebSocket server
-    port: 8080, // @param {number} Port of WebSocket server
-  },
-};
-
-
-
-const osc = new OSC({ plugin: new OSC.BridgePlugin(config) });
-
-osc.open(); // start a WebSocket server on port 8080
-
-console.log('osc client running on port', config.udpClient.port);
-console.log('osc server running on port', config.udpServer.port);
-console.log('websocket server running on port', config.wsServer.port);

packages/osc/tidal-sniffer.js

@@ -1,125 +0,0 @@
-const OSC = require('osc-js');
-
-const config = {
-  receiver: 'ws', // @param {string} Where messages sent via 'send' method will be delivered to, 'ws' for Websocket clients, 'udp' for udp client
-  udpServer: {
-    host: 'localhost', // @param {string} Hostname of udp server to bind to
-    port: 57120, // @param {number} Port of udp client for messaging
-    exclusive: false, // @param {boolean} Exclusive flag
-  },
-  udpClient: {
-    host: 'localhost', // @param {string} Hostname of udp client for messaging
-    // port: 57120, // @param {number} Port of udp client for messaging
-    port: 41235, // @param {number} Port of udp client for messaging
-  },
-  wsServer: {
-    host: 'localhost', // @param {string} Hostname of WebSocket server
-    port: 8080, // @param {number} Port of WebSocket server
-  },
-};
-const osc = new OSC({ plugin: new OSC.BridgePlugin(config) });
-
-osc.open(); // start a WebSocket server on port 8080
-
-console.log('osc client running on port', config.udpClient.port);
-console.log('osc server running on port', config.udpServer.port);
-console.log('websocket server running on port', config.wsServer.port);
-
-// listen for messages from the client
-osc.on('*', (m) => {
-  console.log('received:', m.address, m.args);
-});
-
-/*
-example tidal messages:
-
-/*
-
-received: /dirt/play [
-  '_id_',
-  '1',
-  'cps',
-  0.5625,
-  'cycle',
-  503.5,
-  'delta',
-  0.8888888359069824,
-  'orbit',
-  0,
-  's',
-  'bd'
-]
-received: /dirt/play [
-  '_id_',  '1',
-  'cps',   0.5625,
-  'cycle', 503.6666564941406,
-  'delta', 0.592592716217041,
-  'orbit', 0,
-  's',     'hh'
-]
-received: /dirt/play [
-  '_id_',
-  '1',
-  'cps',
-  0.5625,
-  'cycle',
-  504,
-  'delta',
-  0.8888888359069824,
-  'orbit',
-  0,
-  's',
-  'bd'
-]
-received: /dirt/play [
-  '_id_',
-  '1',
-  'cps',
-  0.5625,
-  'cycle',
-  504,
-  'delta',
-  0.592592716217041,
-  'orbit',
-  0,
-  's',
-  'hh'
-]
-received: /dirt/play [
-  '_id_',
-  '1',
-  'cps',
-  0.5625,
-  'cycle',
-  504.3333435058594,
-  'delta',
-  0.5925922393798828,
-  'orbit',
-  0,
-  's',
-  'hh'
-]
-received: /dirt/play [
-  '_id_',
-  '1',
-  'cps',
-  0.5625,
-  'cycle',
-  504.5,
-  'delta',
-  0.8888888359069824,
-  'orbit',
-  0,
-  's',
-  'bd'
-]
-received: /dirt/play [
-  '_id_',  '1',
-  'cps',   0.5625,
-  'cycle', 504.6666564941406,
-  'delta', 0.592592716217041,
-  'orbit', 0,
-  's',     'hh'
-]
-
-*/

packages/serial/README.md

@@ -1,4 +0,0 @@
-# @strudel.cycles/serial
-
-This package adds webserial functionality to strudel Patterns, for e.g. sending messages to arduino microcontrollers.
-

packages/serial/package.json

@@ -1,24 +0,0 @@
-{
-  "name": "@strudel.cycles/serial",
-  "version": "0.0.6",
-  "description": "Webserial API for strudel",
-  "main": "serial.mjs",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/tidalcycles/strudel.git"
-  },
-  "keywords": [
-    "titdalcycles",
-    "strudel",
-    "pattern",
-    "livecoding",
-    "algorave"
-  ],
-  "author": "Alex McLean <alex@slab.org>",
-  "license": "GPL-3.0-or-later",
-  "bugs": {
-    "url": "https://github.com/tidalcycles/strudel/issues"
-  },
-  "homepage": "https://github.com/tidalcycles/strudel#readme",
-  "dependencies": {}
-}

packages/serial/serial.mjs

@@ -1,52 +0,0 @@
-import { Pattern, isPattern } from '@strudel.cycles/core';
-
-var serialWriter;
-var choosing = false;
-
-export async function getWriter(br=115200) {
-  if (choosing) {
-    return;
-  }
-  choosing = true;
-  if (serialWriter) {
-    return serialWriter;
-  }
-  if ('serial' in navigator) {
-    const port = await navigator.serial.requestPort();
-    await port.open({ baudRate: br });
-    const textEncoder = new TextEncoderStream();
-    const writableStreamClosed = textEncoder.readable.pipeTo(port.writable);
-    const writer = textEncoder.writable.getWriter();
-    serialWriter = function (message) {
-      writer.write(message)
-    }
-  }
-  else {
-    throw('Webserial is not available in this browser.')
-  }
-}
-
-const latency = 0.1;
-
-// Pattern.prototype.midi = function (output: string | number, channel = 1) {
-Pattern.prototype.serial = async function (...args) {
-  return this._withEvent((event) => {
-    if (!serialWriter) {
-      getWriter(...args);
-    }
-    const onTrigger = (time, event, currentTime) => {
-      var message = "";
-      if (typeof event.value === 'object') {
-        for (const [key, val] of Object.entries(event.value).flat()) {
-          message += `${key}:${val};`
-        }
-      }
-      else {
-        message = event.value;
-      }
-      const offset = (time - currentTime + latency) * 1000;
-      window.setTimeout(serialWriter, offset, message);
-    };
-    return event.setContext({ ...event.context, onTrigger });
-  });
-};

packages/tonal/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel.cycles/tonal",
-  "version": "0.0.5",
+  "version": "0.0.2",
   "description": "Tonal functions for strudel",
   "main": "tonal.mjs",
   "type": "module",
@@ -25,7 +25,7 @@
   },
   "homepage": "https://github.com/tidalcycles/strudel#readme",
   "dependencies": {
-    "@strudel.cycles/core": "^0.0.5",
+    "@strudel.cycles/core": "^0.0.2",
     "@tonaljs/tonal": "^4.6.5",
     "webmidi": "^3.0.15"
   }

packages/tonal/test/tonal.test.mjs

@@ -1,6 +1,6 @@
 import { strict as assert } from 'assert';
 import '../tonal.mjs'; // need to import this to add prototypes
-import { pure } from '@strudel.cycles/core';
+import { pure } from '@strudel.cycles/core/strudel.mjs';
 
 describe('tonal', () => {
   it('Should run tonal functions ', () => {

packages/tonal/tonal.mjs

@@ -1,5 +1,6 @@
 import { Note, Interval, Scale } from '@tonaljs/tonal';
-import { Pattern, mod } from '@strudel.cycles/core';
+import { Pattern } from '@strudel.cycles/core';
+import { mod } from '@strudel.cycles/core/util.mjs';
 
 // transpose note inside scale by offset steps
 // function scaleTranspose(scale: string, offset: number, note: string) {

packages/tonal/voicings.mjs

@@ -1,4 +1,4 @@
-import { Pattern as _Pattern, stack, Hap, reify } from '@strudel.cycles/core';
+import { Pattern as _Pattern, stack, Hap, reify } from '@strudel.cycles/core/strudel.mjs';
 import _voicings from 'chord-voicings';
 const { dictionaryVoicing, minTopNoteDiff, lefthand } = _voicings.default || _voicings; // parcel module resolution fuckup
 

packages/tone/package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "@strudel.cycles/tone",
-	"version": "0.0.6",
+	"version": "0.0.3",
 	"lockfileVersion": 2,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "@strudel.cycles/tone",
-			"version": "0.0.4",
+			"version": "0.0.1",
 			"license": "GPL-3.0-or-later",
 			"dependencies": {
 				"@tonejs/piano": "^0.2.1",

packages/tone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel.cycles/tone",
-  "version": "0.0.6",
+  "version": "0.0.3",
   "description": "Tone.js API for strudel",
   "main": "tone.mjs",
   "type": "module",
@@ -22,7 +22,7 @@
   },
   "homepage": "https://github.com/tidalcycles/strudel#readme",
   "dependencies": {
-    "@strudel.cycles/core": "^0.0.5",
+    "@strudel.cycles/core": "^0.0.2",
     "@tonejs/piano": "^0.2.1",
     "chord-voicings": "^0.0.1",
     "tone": "^14.7.77"

packages/tone/test/tone.test.mjs

@@ -1,6 +1,6 @@
 import { strict as assert } from 'assert';
 import '../tone.mjs';
-import { pure } from '@strudel.cycles/core';
+import { pure } from '@strudel.cycles/core/strudel.mjs';
 import Tone from 'tone';
 
 describe('tone', () => {

packages/tone/tone.mjs

@@ -30,16 +30,13 @@ import { getPlayableNoteValue } from '@strudel.cycles/core/util.mjs';
 
 // "balanced" | "interactive" | "playback";
 // Tone.setContext(new Tone.Context({ latencyHint: 'playback', lookAhead: 1 }));
-export const getDefaultSynth = () => {
-  const s = new PolySynth().chain(new Gain(0.5), getDestination());
-  s.set({
-    oscillator: { type: 'triangle' },
-    envelope: {
-      release: 0.01,
-    },
-  });
-  return s;
-};
+export const defaultSynth = new PolySynth().chain(new Gain(0.5), getDestination());
+defaultSynth.set({
+  oscillator: { type: 'triangle' },
+  envelope: {
+    release: 0.01,
+  },
+});
 
 // what about
 // https://www.charlie-roberts.com/gibberish/playground/
@@ -117,3 +114,157 @@ export const highpass = (v) => new Filter(v, 'highpass');
 export const adsr = (a, d = 0.1, s = 0.4, r = 0.01) => ({ envelope: { attack: a, decay: d, sustain: s, release: r } });
 export const osc = (type) => ({ oscillator: { type } });
 export const out = () => getDestination();
+
+/*
+
+You are entering experimental zone
+
+*/
+
+// the following code is an attempt to minimize tonejs code.. it is still an experiment
+
+const chainable = function (instr) {
+  const _chain = instr.chain.bind(instr);
+  let chained = [];
+  instr.chain = (...args) => {
+    chained = chained.concat(args);
+    instr.disconnect(); // disconnect from destination / previous chain
+    return _chain(...chained, getDestination());
+  };
+  // shortcuts: chaining multiple won't work forn now.. like filter(1000).gain(0.5). use chain + native Tone calls instead
+  // instr.filter = (freq = 1000, type: BiquadFilterType = 'lowpass') =>
+  instr.filter = (freq = 1000, type = 'lowpass') =>
+    instr.chain(
+      new Filter(freq, type), // .Q.setValueAtTime(q, time);
+    );
+  instr.gain = (gain = 0.9) => instr.chain(new Gain(gain));
+  return instr;
+};
+
+// helpers
+export const poly = (type) => {
+  const s = new PolySynth(Synth, { oscillator: { type } }).toDestination();
+  return chainable(s);
+};
+
+Pattern.prototype._poly = function (type = 'triangle') {
+  const instrumentConfig = {
+    oscillator: { type },
+    envelope: { attack: 0.01, decay: 0.01, sustain: 0.6, release: 0.01 },
+  };
+  if (!this.instrument) {
+    // create only once to keep the js heap happy
+    // this.instrument = new PolySynth(Synth, instrumentConfig).toDestination();
+    this.instrument = poly(type);
+  }
+  return this._withEvent((event) => {
+    const onTrigger = (time, event) => {
+      this.instrument.set(instrumentConfig);
+      this.instrument.triggerAttackRelease(event.value, event.duration, time);
+    };
+    return event.setContext({ ...event.context, instrumentConfig, onTrigger });
+  });
+};
+
+Pattern.prototype.define('poly', (type, pat) => pat.poly(type), { composable: true, patternified: true });
+
+/*
+
+You are entering danger zone
+
+*/
+
+// everything below is nice in theory, but not healthy for the JS heap, as nodes get recreated on every call
+
+const getTrigger = (getChain, value) => (time, event) => {
+  const chain = getChain(); // make sure this returns a node that is connected toDestination // time
+  if (!isNote(value)) {
+    throw new Error('not a note: ' + value);
+  }
+  chain.triggerAttackRelease(value, event.duration, time);
+  setTimeout(() => {
+    // setTimeout is a little bit better compared to Transport.scheduleOnce
+    chain.dispose(); // mark for garbage collection
+  }, event.duration * 2000);
+};
+
+Pattern.prototype._synth = function (type = 'triangle') {
+  return this._withEvent((event) => {
+    const instrumentConfig = {
+      oscillator: { type },
+      envelope: { attack: 0.01, decay: 0.01, sustain: 0.6, release: 0.01 },
+    };
+    const getInstrument = () => {
+      const instrument = new Synth();
+      instrument.set(instrumentConfig);
+      return instrument;
+    };
+    const onTrigger = getTrigger(() => getInstrument().toDestination(), event.value);
+    return event.setContext({ ...event.context, getInstrument, instrumentConfig, onTrigger });
+  });
+};
+
+Pattern.prototype.adsr = function (attack = 0.01, decay = 0.01, sustain = 0.6, release = 0.01) {
+  return this._withEvent((event) => {
+    if (!event.context.getInstrument) {
+      throw new Error('cannot chain adsr: need instrument first (like synth)');
+    }
+    const instrumentConfig = { ...event.context.instrumentConfig, envelope: { attack, decay, sustain, release } };
+    const getInstrument = () => {
+      const instrument = event.context.getInstrument();
+      instrument.set(instrumentConfig);
+      return instrument;
+    };
+    const onTrigger = getTrigger(() => getInstrument().toDestination(), event.value);
+    return event.setContext({ ...event.context, getInstrument, instrumentConfig, onTrigger });
+  });
+};
+
+Pattern.prototype.chain = function (...effectGetters) {
+  return this._withEvent((event) => {
+    if (!event.context?.getInstrument) {
+      throw new Error('cannot chain: need instrument first (like synth)');
+    }
+    const chain = (event.context.chain || []).concat(effectGetters);
+    const getChain = () => {
+      const effects = chain.map((getEffect) => getEffect());
+      return event.context.getInstrument().chain(...effects, getDestination());
+    };
+    const onTrigger = getTrigger(getChain, event.value);
+    return event.setContext({ ...event.context, getChain, onTrigger, chain });
+  });
+};
+
+export const autofilter =
+  (freq = 1) =>
+  () =>
+    new AutoFilter(freq).start();
+
+export const filter =
+  // (freq = 1, q = 1, type: BiquadFilterType = 'lowpass') =>
+
+
+    (freq = 1, q = 1, type = 'lowpass') =>
+    () =>
+      new Filter(freq, type); // .Q.setValueAtTime(q, time);
+
+export const gain =
+  (gain = 0.9) =>
+  () =>
+    new Gain(gain);
+
+Pattern.prototype._gain = function (g) {
+  return this.chain(gain(g));
+};
+// Pattern.prototype._filter = function (freq: number, q: number, type: BiquadFilterType = 'lowpass') {
+Pattern.prototype._filter = function (freq, q, type = 'lowpass') {
+  return this.chain(filter(freq, q, type));
+};
+Pattern.prototype._autofilter = function (g) {
+  return this.chain(autofilter(g));
+};
+
+Pattern.prototype.define('synth', (type, pat) => pat.synth(type), { composable: true, patternified: true });
+Pattern.prototype.define('gain', (gain, pat) => pat.synth(gain), { composable: true, patternified: true });
+Pattern.prototype.define('filter', (cutoff, pat) => pat.filter(cutoff), { composable: true, patternified: true });
+Pattern.prototype.define('autofilter', (cutoff, pat) => pat.filter(cutoff), { composable: true, patternified: true });

packages/webaudio/README.md

@@ -1,29 +0,0 @@
-# @strudel.cycles/webaudio
-
-This package contains a scheduler + a clockworker and synths based on the Web Audio API.
-It's an alternative to `@strudel.cycles/tone`, with better performance, but less features.
-
-## Install
-
-```sh
-npm i @strudel.cycles/webaudio --save
-```
-
-## Example
-
-```js
-import { Scheduler, getAudioContext } from '@strudel.cycles/webaudio';
-
-const scheduler = new Scheduler({
-    audioContext: getAudioContext(),
-    interval: 0.1,
-    onEvent: (e) => e.context?.createAudioNode?.(e),
-  });
-const pattern = sequence([55, 99], 110).osc('sawtooth').out()
-scheduler.setPattern(pattern);
-scheduler.start()
-//scheduler.stop()
-```
-
-A more sophisticated example can be found in [examples/repl.html](./examples/repl.html).
-You can run it by opening the html file with your browser, or by clicking [this link](https://raw.githack.com/tidalcycles/strudel/main/packages/webaudio/examples/repl.html)

packages/webaudio/clockworker.mjs

@@ -1,69 +0,0 @@
-// helpers to create a worker dynamically without needing a server / extra file
-const stringifyFunction = (func) => '(' + func + ')();';
-const urlifyFunction = (func) => URL.createObjectURL(new Blob([stringifyFunction(func)], { type: 'text/javascript' }));
-const createWorker = (func) => new Worker(urlifyFunction(func));
-
-// this class is basically the tale of two clocks
-class ClockWorker {
-  worker;
-  audioContext;
-  interval = 0.2; // query span
-  lastEnd = 0;
-  constructor(audioContext, callback, interval = this.interval) {
-    this.audioContext = audioContext;
-    this.interval = interval;
-    this.worker = createWorker(() => {
-      // we cannot use closures here!
-      let interval;
-      let timerID = null; // this is clock #1 (the sloppy js clock)
-      const clear = () => {
-        if (timerID) {
-          clearInterval(timerID);
-          timerID = null;
-        }
-      };
-      const start = () => {
-        clear();
-        if (!interval) {
-          throw new Error('no interval set! call worker.postMessage({interval}) before starting.');
-        }
-        timerID = setInterval(() => postMessage('tick'), interval * 1000);
-      };
-      self.onmessage = function (e) {
-        if (e.data == 'start') {
-          start();
-        } else if (e.data.interval) {
-          interval = e.data.interval;
-          if (timerID) {
-            start();
-          }
-        } else if (e.data == 'stop') {
-          clear();
-        }
-      };
-    });
-    this.worker.postMessage({ interval });
-    // const round = (n, d) => Math.round(n * d) / d;
-    const precision = 100;
-    this.worker.onmessage = (e) => {
-      if (e.data === 'tick') {
-        const begin = this.lastEnd || this.audioContext.currentTime;
-        const end = this.audioContext.currentTime + this.interval; // DONT reference begin here!
-        this.lastEnd = end;
-        // callback with query span, using clock #2 (the audio clock)
-        callback(begin, end);
-      }
-    };
-  }
-  start() {
-    console.log('start...');
-    this.audioContext.resume();
-    this.worker.postMessage('start');
-  }
-  stop() {
-    console.log('stop...');
-    this.worker.postMessage('stop');
-  }
-}
-
-export default ClockWorker;

packages/webaudio/examples/repl.html

@@ -1,64 +0,0 @@
-<div style="position: absolute; top: 0; right: 0; padding: 4px">
-  <button id="start" style="margin-bottom: 4px; font-size: 2em">start</button><br />
-  <button id="stop" style="font-size: 2em">stop</button>
-</div>
-<textarea
-  style="font-size: 2em; background: #bce865; color: #323230; height: 100%; width: 100%; outline: none; border: 0"
-  id="text"
-  spellcheck="false"
->
-Loading...</textarea
->
-<script type="module">
-  document.body.style = 'margin: 0';
-  // import * as strudel from '@strudel.cycles/core';
-  import * as strudel from '../../core/index.mjs';
-  import * as util from '../../core/util.mjs';
-  import '@strudel.cycles/core/euclid.mjs';
-  // import { Scheduler, getAudioContext } from 'https://cdn.skypack.dev/@strudel.cycles/webaudio@0.0.4';
-  import { Scheduler, getAudioContext } from '../index.mjs';
-
-  const { cat, State, TimeSpan } = strudel;
-  Object.assign(window, strudel); // add strudel to eval scope
-
-  const scheduler = new Scheduler({
-    audioContext: getAudioContext(),
-    interval: 0.1,
-    onEvent: (e) => {
-      e.context?.createAudioNode?.(e);
-    },
-  });
-
-  let initialCode = `sequence(1,2).mul(55/2) // frequencies
-.mul(slowcat(1,2))
-.mul(slowcat(1,3/2,4/3,5/3).slow(8))
-.fast(3)
-.velocity(.5)
-.wave(cat('sawtooth','square').fast(2))
-.adsr(0.01,.02,.5,0.1)
-.filter('lowshelf',800,25)
-.out()`;
-
-  try {
-    const base64 = decodeURIComponent(window.location.href.split('#')[1]);
-    initialCode = atob(base64);
-  } catch (err) {
-    console.warn('failed to decode', err);
-  }
-  const input = document.getElementById('text');
-  input.value = initialCode;
-  const evaluate = () => {
-    try {
-      const pattern = eval(input.value);
-      scheduler.setPattern(pattern);
-      window.location.hash = '#' + encodeURIComponent(btoa(input.value)); // update url hash
-    } catch (err) {
-      console.warn(err);
-    }
-  };
-  evaluate();
-  input.addEventListener('input', () => evaluate());
-
-  document.getElementById('start').addEventListener('click', () => scheduler.start());
-  document.getElementById('stop').addEventListener('click', () => scheduler.stop());
-</script>

packages/webaudio/index.mjs

@@ -1,3 +0,0 @@
-export { default as ClockWorker } from './clockworker.mjs';
-export { default as Scheduler } from './scheduler.mjs';
-export * from './webaudio.mjs';

packages/webaudio/package.json

@@ -1,32 +0,0 @@
-{
-  "name": "@strudel.cycles/webaudio",
-  "version": "0.0.6",
-  "description": "Web Audio helpers for Strudel",
-  "main": "index.mjs",
-  "directories": {
-    "example": "examples"
-  },
-  "scripts": {
-    "example": "npx parcel examples/repl.html"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/tidalcycles/strudel.git"
-  },
-  "keywords": [
-    "tidalcycles",
-    "strudel",
-    "pattern",
-    "livecoding",
-    "algorave"
-  ],
-  "author": "Felix Roos <flix91@gmail.com>",
-  "license": "GPL-3.0-or-later",
-  "bugs": {
-    "url": "https://github.com/tidalcycles/strudel/issues"
-  },
-  "homepage": "https://github.com/tidalcycles/strudel#readme",
-  "dependencies": {
-    "@strudel.cycles/core": "^0.0.5"
-  }
-}

packages/webaudio/scheduler.mjs

@@ -1,39 +0,0 @@
-import ClockWorker from './clockworker.mjs';
-import { State, TimeSpan } from '@strudel.cycles/core';
-
-class Scheduler {
-  worker;
-  pattern;
-  constructor({ audioContext, interval = 0.2, onEvent }) {
-    this.worker = new ClockWorker(
-      audioContext,
-      (begin, end) => {
-        this.pattern.query(new State(new TimeSpan(begin, end))).forEach((e) => {
-          if (!e.part.begin.equals(e.whole.begin)) {
-            return;
-          }
-          if (onEvent) {
-            onEvent?.(e);
-          } else {
-            console.warn('unplayable event: no audio node nor onEvent callback', e);
-          }
-        });
-      },
-      interval,
-    );
-  }
-  start() {
-    if (!this.pattern) {
-      throw new Error('Scheduler: no pattern set! call .setPattern first.');
-    }
-    this.worker.start();
-  }
-  stop() {
-    this.worker.stop();
-  }
-  setPattern(pat) {
-    this.pattern = pat;
-  }
-}
-
-export default Scheduler;

packages/webaudio/webaudio.mjs

@@ -1,87 +0,0 @@
-import { Pattern, getFrequency, patternify2 } from '@strudel.cycles/core';
-import { Tone } from '@strudel.cycles/tone';
-
-// let audioContext;
-export const getAudioContext = () => {
-  return Tone.getContext().rawContext;
-  /* if (!audioContext) {
-    audioContext = new AudioContext();
-  }
-  return audioContext; */
-};
-
-const lookahead = 0.2;
-
-const adsr = (attack, decay, sustain, release, velocity, begin, end) => {
-  const gainNode = getAudioContext().createGain();
-  gainNode.gain.setValueAtTime(0, begin);
-  gainNode.gain.linearRampToValueAtTime(velocity, begin + attack); // attack
-  gainNode.gain.linearRampToValueAtTime(sustain * velocity, begin + attack + decay); // sustain start
-  gainNode.gain.setValueAtTime(sustain * velocity, end); // sustain end
-  gainNode.gain.linearRampToValueAtTime(0, end + release); // release
-  // for some reason, using exponential ramping creates little cracklings
-  return gainNode;
-};
-
-Pattern.prototype.withAudioNode = function (createAudioNode) {
-  return this._withEvent((event) => {
-    return event.setContext({
-      ...event.context,
-      createAudioNode: (t, e) => createAudioNode(t, e, event.context.createAudioNode?.(t, event)),
-    });
-  });
-};
-
-Pattern.prototype._wave = function (type) {
-  return this.withAudioNode((t, e) => {
-    const osc = getAudioContext().createOscillator();
-    osc.type = type;
-    const f = getFrequency(e);
-    osc.frequency.value = f; // expects frequency..
-    const begin = t ?? e.whole.begin.valueOf() + lookahead;
-    const end = begin + e.duration;
-    osc.start(begin);
-    osc.stop(end); // release?
-    return osc;
-  });
-};
-Pattern.prototype.adsr = function (a = 0.01, d = 0.05, s = 1, r = 0.01) {
-  return this.withAudioNode((t, e, node) => {
-    const velocity = e.context?.velocity || 1;
-    const begin = t ?? e.whole.begin.valueOf() + lookahead;
-    const end = begin + e.duration + lookahead;
-    const envelope = adsr(a, d, s, r, velocity, begin, end);
-    node?.connect(envelope);
-    return envelope;
-  });
-};
-Pattern.prototype._filter = function (type = 'lowpass', frequency = 1000) {
-  return this.withAudioNode((t, e, node) => {
-    const filter = getAudioContext().createBiquadFilter();
-    filter.type = type;
-    filter.frequency.value = frequency;
-    node?.connect(filter);
-    return filter;
-  });
-};
-
-Pattern.prototype.filter = function (type, frequency) {
-  return patternify2(Pattern.prototype._filter)(reify(type), reify(frequency), this);
-};
-
-Pattern.prototype.out = function () {
-  const master = getAudioContext().createGain();
-  master.gain.value = 0.1;
-  master.connect(getAudioContext().destination);
-  return this.withAudioNode((t, e, node) => {
-    if (!node) {
-      console.warn('out: no source! call .osc() first');
-    }
-    node?.connect(master);
-  })._withEvent((event) => {
-    const onTrigger = (time, e) => e.context?.createAudioNode?.(time, e);
-    return event.setContext({ ...event.context, onTrigger });
-  });
-};
-
-Pattern.prototype.define('wave', (type, pat) => pat.wave(type), { patternified: true });

packages/xen/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel.cycles/xen",
-  "version": "0.0.5",
+  "version": "0.0.2",
   "description": "Xenharmonic API for strudel",
   "main": "xen.mjs",
   "scripts": {
@@ -24,6 +24,6 @@
   },
   "homepage": "https://github.com/tidalcycles/strudel#readme",
   "dependencies": {
-    "@strudel.cycles/core": "^0.0.5"
+    "@strudel.cycles/core": "^0.0.2"
   }
 }

packages/xen/tune.mjs

@@ -1,5 +1,5 @@
 import Tune from './tunejs.js';
-import { Pattern } from '@strudel.cycles/core';
+import { Pattern } from '@strudel.cycles/core/strudel.mjs';
 
 Pattern.prototype._tune = function (scale, tonic = 220) {
   const tune = new Tune();

packages/xen/xen.mjs

@@ -1,4 +1,5 @@
-import { Pattern, mod } from '@strudel.cycles/core';
+import { Pattern } from '@strudel.cycles/core/strudel.mjs';
+import { mod } from '@strudel.cycles/core/util.mjs';
 
 export function edo(name) {
   if (!/^[1-9]+[0-9]*edo$/.test(name)) {

repl/README.md

@@ -13,8 +13,11 @@ The REPL is deployed at [strudel.tidalcycles.org](https://strudel.tidalcycles.or
 
 ```bash
 # from project root
-npm run setup
-npm run repl
+npm install
+npx lerna bootstrap
+cd repl
+npm install
+npm run start
 ```
 
 ## Build REPL
@@ -24,3 +27,7 @@ cd repl
 npm run build # <- builds repl + tutorial to ../docs
 npm run static # <- test static build
 ```
+
+## Dev Notes
+
+~~Always run `npm i --legacy-peer-deps`, otherwise `@tonejs/piano` will break.~~

repl/src/App.js

@@ -3,14 +3,14 @@ import CodeMirror, { markEvent, markParens } from './CodeMirror';
 import cx from './cx';
 import logo from './logo.svg';
 import playStatic from './static.mjs';
-import { getDefaultSynth } from '@strudel.cycles/tone';
+import { defaultSynth } from '@strudel.cycles/tone';
 import * as tunes from './tunes.mjs';
 import useRepl from './useRepl.mjs';
 import { useWebMidi } from './useWebMidi';
 import './App.css';
 // eval stuff start
 import { evaluate, extend } from '@strudel.cycles/eval';
-import * as strudel from '@strudel.cycles/core';
+import * as strudel from '@strudel.cycles/core/strudel.mjs';
 import gist from '@strudel.cycles/core/gist.js';
 import { mini } from '@strudel.cycles/mini/mini.mjs';
 import { Tone } from '@strudel.cycles/tone';
@@ -26,30 +26,15 @@ import '@strudel.cycles/tonal/tonal.mjs';
 import '@strudel.cycles/xen/xen.mjs';
 import '@strudel.cycles/xen/tune.mjs';
 import '@strudel.cycles/core/euclid.mjs';
-import '@strudel.cycles/core/speak.mjs';
 import '@strudel.cycles/tone/pianoroll.mjs';
 import '@strudel.cycles/tone/draw.mjs';
-import '@strudel.cycles/osc/osc.mjs';
-import '@strudel.cycles/webaudio/webaudio.mjs';
-import '@strudel.cycles/serial/serial.mjs';
-import controls from '@strudel.cycles/core/controls.mjs';
 
-extend(
+extend(Tone, strudel, strudel.Pattern.prototype.bootstrap(), toneHelpers, voicingHelpers, drawHelpers, uiHelpers, {
+  gist,
+  euclid,
+  mini,
   Tone,
-  strudel,
-  strudel.Pattern.prototype.bootstrap(),
-  controls,
-  toneHelpers,
-  voicingHelpers,
-  drawHelpers,
-  uiHelpers,
-  {
-    gist,
-    euclid,
-    mini,
-    Tone,
-  },
-);
+});
 // eval stuff end
 
 const codeParam = window.location.href.split('#')[1];
@@ -67,7 +52,6 @@ function getRandomTune() {
 }
 
 const randomTune = getRandomTune();
-const defaultSynth = getDefaultSynth();
 
 function App() {
   const [editor, setEditor] = useState();
@@ -91,10 +75,8 @@ function App() {
       if (e.ctrlKey || e.altKey) {
         if (e.code === 'Enter') {
           await activateCode();
-          e.preventDefault();
         } else if (e.code === 'Period') {
           cycle.stop();
-          e.preventDefault();
         }
       }
     };

repl/src/static.mjs

@@ -2,9 +2,7 @@ import { Tone } from '@strudel.cycles/tone';
 import { State, TimeSpan } from '@strudel.cycles/core';
 import { getPlayableNoteValue } from '@strudel.cycles/core/util.mjs';
 import { evaluate } from '@strudel.cycles/eval';
-import { getDefaultSynth } from '@strudel.cycles/tone';
-
-const defaultSynth = getDefaultSynth();
+import { defaultSynth } from '@strudel.cycles/tone';
 
 // this is a test to play back events with as less runtime code as possible..
 // the code asks for the number of seconds to prequery

repl/src/tunes.mjs

@@ -668,159 +668,3 @@ export const echoPiano = `"<0 2 [4 6](3,4,1) 3*2>"
 .echo(4, 1/8, .5)
 .tone((await piano()).chain(out()))
 .pianoroll()`;
-
-export const sml1 = `
-stack(
-  // melody
-  \`<
-  [e5 ~] [[d5@2 c5] [~@2 e5]] ~ [~ [c5@2 d5]] [e5 e5] [d5 c5] [e5 f5] [g5 a5]
-  [~ c5] [c5 d5] [e5 [c5@2 c5]] [~ c5] [f5 e5] [c5 d5] [~ g6] [g6 ~]
-  [e5 ~] [[d5@2 c5] [~@2 e5]] ~ [~ [c5@2 d5]] [e5 e5] [d5 c5] [a5 g5] [c6 [e5@2 d5]]
-  [~ c5] [c5 d5] [e5 [c5@2 c5]] [~ c5] [f5 e5] [c5 d5] [~ [g6@2 ~] ~@2] [g5 ~] 
-  [~ a5] [b5 c6] [b5@2 ~@2 g5] ~
-  [f5 ~] [[g5@2 f5] ~] [[e5 ~] [f5 ~]] [[f#5 ~] [g5 ~]]
-  [~ a5] [b5 c6] [b5@2 ~@2 g5] ~
-  [eb6 d6] [~ c6] ~!2
-  >\`
-  .legato(.95),
-  // sub melody
-  \`<
-  [~ g4]!2 [~ ab4]!2 [~ a4]!2 [~ bb4]!2 
-  [~ a4]!2 [~ g4]!2 [d4 e4] [f4 gb4] ~!2
-  [~ g4]!2 [~ ab4]!2 [~ a4]!2 [~ bb4]!2 
-  [~ a4]!2 [~ g4]!2 [d4 e4] [f4 gb4] ~!2
-  [~ c5]!4 [~ a4]!2 [[c4 ~] [d4 ~]] [[eb4 ~] [e4 ~]]
-  [~ c5]!4 [~ eb5]!2 [g4*2 [f4 ~]] [[e4 ~] [d4 ~]]
-  >\`,
-  // bass
-  \`<
-  c3!7 a3 f3!2
-  e3!2 ~!4
-  c3!7 a3 f3!2
-  e3!2 ~!4
-  f3!2 e3!2 d3!2 ~!2
-  f3!2 e3!2 ab3!2 ~!2
-  >\`
-  .legato(.5)
-).fast(2) //.tone((await piano()).chain(out()))`;
-
-export const speakerman = `backgroundImage('https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Fi.ytimg.com%2Fvi%2FXR0rKqW3VwY%2Fmaxresdefault.jpg&f=1&nofb=1', 
-{ className:'darken', style:'background-size:cover'})
-stack(
-  "[g3,bb3,d4] [f3,a3,c4] [c3,e3,g3]@2".slow(2).late(.1),
-  slowcat(
-  'Baker man',
-  'is baking bread',
-  'Baker man',
-  'is baking bread',
-  'Sagabona',
-  'kunjani wena',
-  'Sagabona',
-  'kunjani wena',
-  'The night train, is coming',
-  'got to keep on running',
-  'The night train, is coming',
-  'got to keep on running',
-  ).speak("en zu en".slow(12), "<0 2 3 4 5 6>".slow(2)),
-).slow(4)`;
-
-export const randomBells = `const delay = new FeedbackDelay(1/3, .8).chain(vol(.2), out());
-let bell = await sampler({
-  C6: 'https://freesound.org/data/previews/411/411089_5121236-lq.mp3'
-})
-const bass = await sampler({
-  d2: 'https://freesound.org/data/previews/608/608286_13074022-lq.mp3'
-});
-bell = bell.chain(vol(0.6).connect(delay),out());
-
-"0".euclidLegato(3,8)
-  .echo(3, 1/16, .5)
-  .add(rand.range(0,12))
-  .velocity(rand.range(.5,1))
-  .legato(rand.range(.4,3))
-  .scale(slowcat('D minor pentatonic')).tone(bell)
-  .stack("<D2 A2 G2 F2>".euclidLegato(6,8,1).tone(bass.toDestination()))
-  .slow(6)
-  .pianoroll({minMidi:20,maxMidi:120,background:'transparent'})`;
-
-export const waa = `"a4 [a3 c3] a3 c3"
-.sub("<7 12>/2")
-.off(1/8, add("12"))
-.off(1/4, add("7"))
-.legato(.5)
-.slow(2)
-.wave("sawtooth square")
-.filter('lowpass', "<2000 1000 500>")
-.out()`;
-
-export const waar = `"a4 [a3 c3] a3 c3".color('#F9D649')
-.sub("<7 12 5 12>".slow(2))
-.off(1/4,x=>x.add(7).color("#FFFFFF #0C3AA1 #C63928"))
-.off(1/8,x=>x.add(12).color('#215CB6'))
-.slow(2)
-.legato(sine.range(0.3, 2).slow(28))
-.wave("sawtooth square".fast(2))
-.filter('lowpass', cosine.range(500,4000).slow(16))
-.out()
-.pianoroll({minMidi:20,maxMidi:120,background:'#202124'})`;
-
-export const hyperpop = `const lfo = cosine.slow(15);
-const lfo2 = sine.slow(16);
-const filter1 = x=>x.filter('lowpass', lfo2.range(300,3000));
-const filter2 = x=>x.filter('highpass', lfo.range(1000,6000)).filter('lowpass',4000)
-const scales = slowcat('D3 major', 'G3 major').slow(8)
-
-const drums = await players({
-  bd: '344/344757_1676145-lq.mp3',
-  sn: '387/387186_7255534-lq.mp3',
-  hh: '561/561241_12517458-lq.mp3',
-  hh2:'44/44944_236326-lq.mp3',
-  hh3: '44/44944_236326-lq.mp3',
-}, 'https://freesound.org/data/previews/')
-
-stack(
-  "-7 0 -7 7".struct("x(5,8,2)").fast(2).sub(7)
-  .scale(scales).wave("sawtooth,square").velocity(.3).adsr(0.01,0.1,.5,0)
-  .apply(filter1),
-  "~@3 [<2 3>,<4 5>]"
-  .echo(8,1/16,.7)
-  .scale(scales)
-  .wave('square').velocity(.7).adsr(0.01,0.1,0).apply(filter1),
-  "6 5 4".add(14)
-  .superimpose(sub("5"))
-  .fast(1).euclidLegato(3,8)
-  .mask("<1 0@7>")
-  .fast(2)
-  .echo(32, 1/8, .9)
-  .scale(scales)
-  .wave("sawtooth")
-  .velocity(.2)
-  .adsr(.01,.5,0)
-  .apply(filter2)
-  //.echo(4,1/16,.5)
-).out().stack(
-  stack(
-    "bd <~@7 [~ bd]>".fast(2),
-    "~ sn",
-    "[~ hh3]*2"
-  ).tone(drums.chain(vol(.18),out())).fast(2)
-).slow(2)
-
-//.pianoroll({minMidi:20, maxMidi:160})
-// strudel disable-highlighting`;
-
-export const festivalOfFingers3 = `"[-7*3],0,2,6,[8 7]"
-.echoWith(4,1/4, (x,n)=>x
-          .add(n*7)
-          .velocity(1/(n+1))
-          .legato(1/(n+1)))
-.velocity(perlin.range(.5,.9).slow(8))
-.stack("[22 25]*3"
-       .legato(sine.range(.5,2).slow(8))
-       .velocity(sine.range(.4,.8).slow(5))
-       .echo(4,1/12,.5))
-.scale(slowcat('D dorian','G mixolydian','C dorian','F mixolydian'))
-.legato(1)
-.slow(2)
-.tone((await piano()).toDestination())
-//.pianoroll({maxMidi:160})`;

repl/src/tutorial/MiniRepl.jsx

@@ -6,7 +6,7 @@ import cx from '../cx';
 
 // eval stuff start
 import { extend } from '@strudel.cycles/eval';
-import * as strudel from '@strudel.cycles/core';
+import * as strudel from '@strudel.cycles/core/strudel.mjs';
 import gist from '@strudel.cycles/core/gist.js';
 import { mini } from '@strudel.cycles/mini/mini.mjs';
 import { Tone } from '@strudel.cycles/tone';

repl/src/tutorial/tutorial.mdx

@@ -99,7 +99,7 @@ You can also press "play" on the next player without needing to stop the last on
 
 ## Sequences
 
-We can play more notes by separating them with spaces:
+We can play more notes by seperating them with spaces:
 
 <MiniRepl tune={`"e5 b4 d5 c5"`} />
 
@@ -195,14 +195,14 @@ Internally, the mini notation will expand to use the actual functional JavaScrip
 
 Notes are automatically available as variables:
 
-<MiniRepl tune={`sequence(d4, fs4, a4)`} />
+<MiniRepl tune={`e4`} />
 
 An important difference to the mini notation:
 For sharp notes, the letter "s" is used instead of "#", because JavaScript does not support "#" in a variable name.
 
 The above is the same as:
 
-<MiniRepl tune={`sequence('d4', 'f#4', 'a4')`} />
+<MiniRepl tune={`"e4"`} />
 
 Using strings, you can also use "#".
 
@@ -331,13 +331,13 @@ Will reverse the pattern:
 
 Will apply the given function every n cycles:
 
-<MiniRepl tune={`cat(e5, "b4".every(4, late(0.5)))`} />
+<MiniRepl tune={`cat(e5, pure(b4).every(4, late(0.5)))`} />
 
 <!-- TODO: should be able to do b4.every => like already possible with fast slow etc.. -->
 
 Note that late is called directly. This is a shortcut for:
 
-<MiniRepl tune={`cat(e5, "b4".every(4, x => x.late(0.5)))`} />
+<MiniRepl tune={`cat(e5, pure(b4).every(4, x => x.late(0.5)))`} />
 
 <!-- TODO: should the function really run the first cycle? -->
 
@@ -590,6 +590,59 @@ Helper to set the envelope of a Tone.js instrument. Intended to be used with Ton
 .tone(synth(adsr(0,.1,0,0)).chain(out()))`}
 />
 
+### Experimental: Patternification
+
+While the above methods work for static sounds, there is also the option to patternify tone methods.
+This is currently experimental, because the performance is not stable, and audio glitches will appear after some time.
+It would be great to get this to work without glitches though, because it is fun!
+
+#### synth(type)
+
+With .synth, you can create a synth with a variable wave type:
+
+<MiniRepl
+  tune={`"[c4 c4 bb3 c4] [~ g3 ~ g3] [c4 f4 e4 c4] ~"
+.synth("<sawtooth8 square8>").slow(4)`}
+/>
+
+#### adsr(attack, decay?, sustain?, release?)
+
+Chainable Envelope helper:
+
+<MiniRepl
+  tune={`"[c5 c5 bb4 c5] [~ g4 ~ g4] [c5 f5 e5 c5] ~".slow(4)
+  .synth('sawtooth16').adsr(0,.1,0,0)`}
+/>
+
+Due to having more than one argument, this method is not patternified.
+
+#### filter(cuttoff)
+
+Patternified filter:
+
+<MiniRepl
+  tune={`"[c4 c4 bb3 c4] [~ g3 ~ g3] [c4 f4 e4 c4] ~"
+  .synth('sawtooth16').filter("[500 2000]*8").slow(4)`}
+/>
+
+#### gain(value)
+
+Patternified gain:
+
+<MiniRepl
+  tune={`"[c4 c4 bb3 c4] [~ g3 ~ g3] [c4 f4 e4 c4] ~"
+  .synth('sawtooth16').gain("[.2 .8]*8").slow(4)`}
+/>
+
+#### autofilter(value)
+
+Patternified autofilter:
+
+<MiniRepl
+  tune={`"c2 c3"
+  .synth('sawtooth16').autofilter("<1 4 8>"")`}
+/>
+
 ## Tonal API
 
 The Tonal API, uses [tonaljs](https://github.com/tonaljs/tonal) to provide helpers for musical operations.

repl/src/useCycle.mjs

@@ -39,10 +39,10 @@ function useCycle(props) {
 
     // schedule events for next cycle
     events
-      ?.filter((event) => event.part.begin.equals(event.whole?.begin))
+      ?.filter((event) => event.part.begin.equals(event.whole.begin))
       .forEach((event) => {
         Tone.getTransport().schedule((time) => {
-          onEvent(time, event, Tone.getContext().currentTime);
+          onEvent(time, event);
           Tone.Draw.schedule(() => {
             // do drawing or DOM manipulation here
             onDraw?.(time, event);

repl/src/useRepl.mjs

@@ -23,18 +23,11 @@ function useRepl({ tune, defaultSynth, autolink = true, onEvent, onDraw }) {
   const dirty = useMemo(() => code !== activeCode || error, [code, activeCode, error]);
   const pushLog = useCallback((message) => setLog((log) => log + `${log ? '\n\n' : ''}${message}`), []);
 
-  // below block allows disabling the highlighting by including "strudel disable-highlighting" in the code (as comment)
-  onDraw = useMemo(() => {
-    if (activeCode && !activeCode.includes('strudel disable-highlighting')) {
-      return onDraw;
-    }
-  }, [activeCode, onDraw]);
-  
   // cycle hook to control scheduling
   const cycle = useCycle({
     onDraw,
     onEvent: useCallback(
-      (time, event, currentTime) => {
+      (time, event) => {
         try {
           onEvent?.(event);
           const { onTrigger, velocity } = event.context;
@@ -48,7 +41,7 @@ function useRepl({ tune, defaultSynth, autolink = true, onEvent, onDraw }) {
             /* console.warn('no instrument chosen', event);
           throw new Error(`no instrument chosen for ${JSON.stringify(event)}`); */
           } else {
-            onTrigger(time, event, currentTime);
+            onTrigger(time, event);
           }
         } catch (err) {
           console.warn(err);
@@ -118,6 +111,13 @@ function useRepl({ tune, defaultSynth, autolink = true, onEvent, onDraw }) {
     }
   };
 
+  // below block allows disabling the highlighting by including "strudel disable-highlighting" in the code (as comment)
+  onDraw = useMemo(() => {
+    if (activeCode && !activeCode.includes('strudel disable-highlighting')) {
+      return onDraw;
+    }
+  }, [activeCode, onDraw]);
+
   const togglePlay = () => {
     if (!cycle.started) {
       activateCode();

snowpack.config.js

@@ -0,0 +1,21 @@
+// Snowpack Configuration File
+// See all supported options: https://www.snowpack.dev/reference/configuration
+
+/** @type {import("snowpack").SnowpackUserConfig } */
+module.exports = {
+  mount: {
+    /* ... */
+  },
+  plugins: [
+    /* ... */
+  ],
+  packageOptions: {
+    /* ... */
+  },
+  devOptions: {
+    /* ... */
+  },
+  buildOptions: {
+    /* ... */
+  },
+};