Merge branch 'main' into glossing/scale-for-notes

2025-08-21 15:58:43 -05:00 · 2025-08-21 15:58:43 -05:00 · 938c92fda2
commit 938c92fda2
parent c8c6a2ce08 0693a32736
49 changed files with 857 additions and 194 deletions
--- a/packages/codemirror/autocomplete.mjs
+++ b/packages/codemirror/autocomplete.mjs
@ -1,68 +1,91 @@
 import jsdoc from '../../doc.json';
-// import { javascriptLanguage } from '@codemirror/lang-javascript';
 import { autocompletion } from '@codemirror/autocomplete';
 import { h } from './html';

-function plaintext(str) {
+const escapeHtml = (str) => {
  const div = document.createElement('div');
  div.innerText = str;
  return div.innerHTML;
-}
+};

-const getDocLabel = (doc) => doc.name || doc.longname;
-const getInnerText = (html) => {
-  var div = document.createElement('div');
+const stripHtml = (html) => {
+  const div = document.createElement('div');
  div.innerHTML = html;
  return div.textContent || div.innerText || '';
 };

-export function Autocomplete({ doc, label }) {
-  return h`<div class="prose dark:prose-invert max-h-[400px] overflow-auto p-2">
-<h1 class="pt-0 mt-0">${label || getDocLabel(doc)}</h1>
-${doc.description}
-<ul>
-  ${doc.params?.map(
-    ({ name, type, description }) =>
-      `<li>${name} : ${type.names?.join(' | ')} ${description ? ` - ${getInnerText(description)}` : ''}</li>`,
-  )}
-</ul>
-<div>
-  ${doc.examples?.map((example) => `<div><pre>${plaintext(example)}</pre></div>`)}
-</div>
-</div>`[0];
-  /*
-<pre
-className="cursor-pointer"
-onMouseDown={(e) => {
-  console.log('ola!');
-  navigator.clipboard.writeText(example);
-  e.stopPropagation();
-}}
->
-{example}
-</pre>
-*/
-}
+const getDocLabel = (doc) => doc.name || doc.longname;
+
+const buildParamsList = (params) =>
+  params?.length
+    ? `
+    <div class="autocomplete-info-params-section">
+      <h4 class="autocomplete-info-section-title">Parameters</h4>
+      <ul class="autocomplete-info-params-list">
+        ${params
+          .map(
+            ({ name, type, description }) => `
+          <li class="autocomplete-info-param-item">
+            <span class="autocomplete-info-param-name">${name}</span>
+            <span class="autocomplete-info-param-type">${type.names?.join(' | ')}</span>
+            ${description ? `<div class="autocomplete-info-param-desc">${stripHtml(description)}</div>` : ''}
+          </li>
+        `,
+          )
+          .join('')}
+      </ul>
+    </div>
+  `
+    : '';
+
+const buildExamples = (examples) =>
+  examples?.length
+    ? `
+    <div class="autocomplete-info-examples-section">
+      <h4 class="autocomplete-info-section-title">Examples</h4>
+      ${examples
+        .map(
+          (example) => `
+        <pre class="autocomplete-info-example-code">${escapeHtml(example)}</pre>
+      `,
+        )
+        .join('')}
+    </div>
+  `
+    : '';
+
+export const Autocomplete = ({ doc, label }) =>
+  h`
+  <div class="autocomplete-info-tooltip">
+    <h3 class="autocomplete-info-function-name">${label || getDocLabel(doc)}</h3>
+    ${doc.description ? `<p class="autocomplete-info-function-description">${doc.description}</p>` : ''}
+    ${buildParamsList(doc.params)}
+    ${buildExamples(doc.examples)}
+  </div>
+`[0];
+
+const isValidDoc = (doc) => {
+  const label = getDocLabel(doc);
+  return label && !label.startsWith('_') && !['package'].includes(doc.kind);
+};
+
+const hasExcludedTags = (doc) =>
+  ['superdirtOnly', 'noAutocomplete'].some((tag) => doc.tags?.find((t) => t.originalTitle === tag));

 const jsdocCompletions = jsdoc.docs
-  .filter(
-    (doc) =>
-      getDocLabel(doc) &&
-      !getDocLabel(doc).startsWith('_') &&
-      !['package'].includes(doc.kind) &&
-      !['superdirtOnly', 'noAutocomplete'].some((tag) => doc.tags?.find((t) => t.originalTitle === tag)),
-  )
+  .filter((doc) => isValidDoc(doc) && !hasExcludedTags(doc))
  // https://codemirror.net/docs/ref/#autocomplete.Completion
-  .map((doc) /*: Completion */ => ({
+  .map((doc) => ({
    label: getDocLabel(doc),
    // detail: 'xxx', // An optional short piece of information to show (with a different style) after the label.
    info: () => Autocomplete({ doc }),
    type: 'function', // https://codemirror.net/docs/ref/#autocomplete.Completion.type
  }));

-export const strudelAutocomplete = (context /* : CompletionContext */) => {
-  let word = context.matchBefore(/\w*/);
-  if (word.from == word.to && !context.explicit) return null;
+export const strudelAutocomplete = (context) => {
+  const word = context.matchBefore(/\w*/);
+  if (word.from === word.to && !context.explicit) return null;
+
  return {
    from: word.from,
    options: jsdocCompletions,
@ -74,11 +97,5 @@ export const strudelAutocomplete = (context /* : CompletionContext */) => {
  };
 };

-export function isAutoCompletionEnabled(on) {
-  return on
-    ? [
-        autocompletion({ override: [strudelAutocomplete] }),
-        //javascriptLanguage.data.of({ autocomplete: strudelAutocomplete }),
-      ]
-    : []; // autocompletion({ override: [] })
-}
+export const isAutoCompletionEnabled = (enabled) =>
+  enabled ? [autocompletion({ override: [strudelAutocomplete] })] : [];
--- a/packages/codemirror/package.json
+++ b/packages/codemirror/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/codemirror",
-  "version": "1.2.2",
+  "version": "1.2.3",
  "description": "Codemirror Extensions for Strudel",
  "main": "index.mjs",
  "publishConfig": {
--- a/packages/core/controls.mjs
+++ b/packages/core/controls.mjs
@ -541,28 +541,40 @@ export const { tremoloshape } = registerControl('tremoloshape', 'tremshape');
 *
 */

-// TODO: SUPRADOUGH implement post orbit "pump" sidechain effect
-// /**
-//  * modulate the amplitude of an orbit to create a "sidechain" like effect
-//  *
-//  * @name pump
-//  * @param {number | Pattern} speed modulation speed in cycles
-//  * @example
-//  * note("{f g c d}%16").s("sawtooth").pump(".25:.75")
-//  *
-//  */
-// export const { pump } = registerControl(['pump', 'pumpdepth']);
+/**
+ * modulate the amplitude of an orbit to create a "sidechain" like effect
+ *
+ * @name duckorbit
+ * @param {number | Pattern} orbit target orbit
+ * @example
+ * $: n(run(16)).scale("c:minor:pentatonic").s("sawtooth").delay(.7).orbit(2)
+ * $: s("bd:4!4").beat("0,4,8,11,14",16).duckorbit(2).duckattack(0.2).duckdepth(1)
+ *
+ */
+export const { duck } = registerControl('duckorbit', 'duck');

-// /**
-//  * modulate the amplitude of an orbit to create a "sidechain" like effect
-//  *
-//  * @name pumpdepth
-//  * @param {number | Pattern} depth depth of modulation from 0 to 1
-//  * @example
-//  * note("{f g c d}%16").s("sawtooth").pump(".25").depth("<.25 .5 .75 1>")
-//  *
-//  */
-// export const { pumpdepth } = registerControl('pumpdepth');
+/**
+ *  the amount of ducking applied to target orbit
+ *
+ * @name duckdepth
+ * @param {number | Pattern} depth depth of modulation from 0 to 1
+ * @example
+ * stack( n(run(8)).scale("c:minor").s("sawtooth").delay(.7).orbit(2), s("bd:4!4").beat("0,4,8,11,14",16).duckorbit(2).duckattack(0.2).duckdepth("<1 .9 .6 0>"))
+ *
+ */
+
+export const { duckdepth } = registerControl('duckdepth');
+
+/**
+ *  the attack time of the duck effect
+ *
+ * @name duckattack
+ * @param {number | Pattern} time
+ * @example
+ * stack( n(run(8)).scale("c:minor").s("sawtooth").delay(.7).orbit(2), s("bd:4!4").beat("0,4,8,11,14",16).duckorbit(2).duckattack("<0.2 0 0.4>").duckdepth(1))
+ *
+ */
+export const { duckattack } = registerControl('duckattack', 'duckatt');

 export const { drive } = registerControl('drive');

--- a/packages/core/euclid.mjs
+++ b/packages/core/euclid.mjs
@ -10,7 +10,7 @@ https://rohandrape.net/?t=hmt
 This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

-import { timeCat, register, silence } from './pattern.mjs';
+import { timeCat, register, silence, stack, pure, _morph } from './pattern.mjs';
 import { rotate, flatten, splitAt, zipWith } from './util.mjs';
 import Fraction, { lcm } from './fraction.mjs';

@ -196,3 +196,26 @@ export const euclidLegato = register(['euclidLegato'], function (pulses, steps,
 export const euclidLegatoRot = register(['euclidLegatoRot'], function (pulses, steps, rotation, pat) {
  return _euclidLegato(pulses, steps, rotation, pat);
 });
+
+/**
+ * A 'euclid' variant with an additional parameter that morphs the resulting
+ * rhythm from 0 (no morphing) to 1 (completely 'even'). For example
+ * `sound("bd").euclidish(3,8,0)` would be the same as
+ * `sound("bd").euclid(3,8)`, and `sound("bd").euclidish(3,8,1)` would be the
+ * same as `sound("bd bd bd")`. `sound("bd").euclidish(3,8,0.5)` would have a
+ * groove somewhere between.
+ * Inspired by the work of Malcom Braff.
+ * @name euclidish
+ * @synonyms eish
+ * @memberof Pattern
+ * @param {number} pulses the number of onsets
+ * @param {number} steps the number of steps to fill
+ * @param {number} groove exists between the extremes of 0 (straight euclidian) and 1 (straight pulse)
+ * @example
+ * sound("hh").euclidish(7,12,sine.slow(8))
+ * .pan(sine.slow(8))
+ */
+export const { euclidish, eish } = register(['euclidish', 'eish'], function (pulses, steps, perc, pat) {
+  const morphed = _morph(bjork(pulses, steps), new Array(pulses).fill(1), perc);
+  return pat.struct(morphed).setSteps(steps);
+});
--- a/packages/core/hap.mjs
+++ b/packages/core/hap.mjs
@ -4,6 +4,7 @@ Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/
 This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 import Fraction from './fraction.mjs';
+import { stringifyValues } from './util.mjs';

 export class Hap {
  /*
@ -148,13 +149,7 @@ export class Hap {
  }

  showWhole(compact = false) {
-    return `${this.whole == undefined ? '~' : this.whole.show()}: ${
-      typeof this.value === 'object'
-        ? compact
-          ? JSON.stringify(this.value).slice(1, -1).replaceAll('"', '').replaceAll(',', ' ')
-          : JSON.stringify(this.value)
-        : this.value
-    }`;
+    return `${this.whole == undefined ? '~' : this.whole.show()}: ${stringifyValues(this.value, compact)}`;
  }

  combineContext(b) {
--- a/packages/core/logger.mjs
+++ b/packages/core/logger.mjs
@ -6,7 +6,7 @@ let debounce = 1000,

 export function errorLogger(e, origin = 'cyclist') {
  //TODO: add some kind of debug flag that enables this  while in dev mode
-  // console.error(e)
+  // console.error(e);
  logger(`[${origin}] error: ${e.message}`);
 }

--- a/packages/core/package.json
+++ b/packages/core/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/core",
-  "version": "1.2.2",
+  "version": "1.2.3",
  "description": "Port of Tidal Cycles to JavaScript",
  "main": "index.mjs",
  "type": "module",
--- a/packages/core/pattern.mjs
+++ b/packages/core/pattern.mjs
@ -21,6 +21,8 @@ import {
  numeralArgs,
  parseNumeral,
  pairs,
+  zipWith,
+  stringifyValues,
 } from './util.mjs';
 import drawLine from './drawLine.mjs';
 import { logger } from './logger.mjs';
@ -852,14 +854,29 @@ export class Pattern {
    );
  }

-  log(func = (_, hap) => `[hap] ${hap.showWhole(true)}`, getData = (_, hap) => ({ hap })) {
+  /**
+   * Writes the content of the current event to the console (visible in the side menu).
+   * @name log
+   * @memberof Pattern
+   * @example
+   * s("bd sd").log()
+   */
+  log(func = (hap) => `[hap] ${hap.showWhole(true)}`, getData = (hap) => ({ hap })) {
    return this.onTrigger((...args) => {
      logger(func(...args), undefined, getData(...args));
    }, false);
  }

-  logValues(func = id) {
-    return this.log((_, hap) => func(hap.value));
+  /**
+   * A simplified version of `log` which writes all "values" (various configurable parameters)
+   * within the event to the console (visible in the side menu).
+   * @name logValues
+   * @memberof Pattern
+   * @example
+   * s("bd sd").gain("0.25 0.5 1").n("2 1 0").logValues()
+   */
+  logValues(func = (value) => `[hap] ${stringifyValues(value, true)}`) {
+    return this.log((hap) => func(hap.value));
  }

  //////////////////////////////////////////////////////////////////////
@ -3400,3 +3417,69 @@ export const { beat } = register(
  ['beat'],
  __beat((x) => x.innerJoin()),
 );
+
+export const _morph = (from, to, by) => {
+  by = Fraction(by);
+  const dur = Fraction(1).div(from.length);
+  const positions = (list) => {
+    const result = [];
+    for (const [pos, value] of list.entries()) {
+      if (value) {
+        result.push([Fraction(pos).div(list.length), value]);
+      }
+    }
+    return result;
+  };
+  const arcs = zipWith(
+    ([posa, valuea], [posb, valueb]) => {
+      const b = by.mul(posb - posa).add(posa);
+      const e = b.add(dur);
+      return new TimeSpan(b, e);
+    },
+    positions(from),
+    positions(to),
+  );
+  function query(state) {
+    const cycle = state.span.begin.sam();
+    const cycleArc = state.span.cycleArc();
+    const result = [];
+    for (const whole of arcs) {
+      const part = whole.intersection(cycleArc);
+      if (part !== undefined) {
+        result.push(
+          new Hap(
+            whole.withTime((x) => x.add(cycle)),
+            part.withTime((x) => x.add(cycle)),
+            true,
+          ),
+        );
+      }
+    }
+    return result;
+  }
+  return new Pattern(query).splitQueries();
+};
+
+/**
+ * Takes two binary rhythms represented as lists of 1s and 0s, and a number
+ * between 0 and 1 that morphs between them. The two lists should contain the same
+ * number of true values.
+ * @example
+ * sound("hh").struct(morph([1,0,1,0,1,0,1,0], // straight rhythm
+ *                          [1,1,0,1,0,1,0], // wonky rhythm
+ *                          0.25 // creates a slightly wonky rhythm
+ *                         )
+ *                   )
+ * @example
+ * sound("hh").struct(morph("1:0:1:0:1:0:1:0", // straight rhythm
+ *                          "1:1:0:1:0:1:0", // wonky rhythm
+ *                          sine.slow(8) // slowly morph between the rhythms
+ *                         )
+ *                   )
+ */
+export const morph = (frompat, topat, bypat) => {
+  frompat = reify(frompat);
+  topat = reify(topat);
+  bypat = reify(bypat);
+  return frompat.innerBind((from) => topat.innerBind((to) => bypat.innerBind((by) => _morph(from, to, by))));
+};
--- a/packages/core/test/pattern.test.mjs
+++ b/packages/core/test/pattern.test.mjs
@ -6,7 +6,7 @@ This program is free software: you can redistribute it and/or modify it under th

 import Fraction from 'fraction.js';

-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';

 import {
  TimeSpan,
@ -55,6 +55,8 @@ import {
  expand,
 } from '../index.mjs';

+import { log, logValues } from '../pattern.mjs';
+
 import { steady } from '../signal.mjs';

 import { n, s } from '../controls.mjs';
@ -1306,4 +1308,40 @@ describe('Pattern', () => {
      );
    });
  });
+  describe('log', () => {
+    it('logs to console', () => {
+      const mockConsoleLog = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const pattern = pure('a').log();
+      const haps = pattern.queryArc(0, 1);
+
+      // Force a trigger
+      haps.forEach((hap) => {
+        hap.context?.onTrigger?.(hap);
+      });
+
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        '%c[hap] 0/1 → 1/1: a',
+        'background-color: black;color:white;border-radius:15px',
+      );
+      mockConsoleLog.mockRestore();
+    });
+  });
+  describe('logValues', () => {
+    it('logs values to console', () => {
+      const mockConsoleLog = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const pattern = pure('a').note('c#').logValues();
+      const haps = pattern.queryArc(0, 1);
+
+      // Force a trigger
+      haps.forEach((hap) => {
+        hap.context?.onTrigger?.(hap);
+      });
+
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        '%c[hap] value:a note:c#',
+        'background-color: black;color:white;border-radius:15px',
+      );
+      mockConsoleLog.mockRestore();
+    });
+  });
 });
--- a/packages/core/timespan.mjs
+++ b/packages/core/timespan.mjs
@ -72,7 +72,7 @@ export class TimeSpan {
  }

  intersection(other) {
-    // Intersection of two timespans, returns None if they don't intersect.
+    // Intersection of two timespans, returns undefined if they don't intersect.
    const intersect_begin = this.begin.max(other.begin);
    const intersect_end = this.end.min(other.end);

--- a/packages/core/util.mjs
+++ b/packages/core/util.mjs
@ -487,3 +487,13 @@ export function getCurrentKeyboardState() {
 //   }
 //   return lcm((x * y) / gcd(x, y), ...z);
 // };
+
+// Takes values -- typically derived from events, i.e. `hap`s -- and renders them
+// into a readable format
+export function stringifyValues(value, compact = false) {
+  return typeof value === 'object'
+    ? compact
+      ? JSON.stringify(value).slice(1, -1).replaceAll('"', '').replaceAll(',', ' ')
+      : JSON.stringify(value)
+    : value;
+}
--- a/packages/csound/package.json
+++ b/packages/csound/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/csound",
-  "version": "1.2.3",
+  "version": "1.2.4",
  "description": "csound bindings for strudel",
  "main": "index.mjs",
  "type": "module",
--- a/packages/draw/package.json
+++ b/packages/draw/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/draw",
-  "version": "1.2.2",
+  "version": "1.2.3",
  "description": "Helpers for drawing with Strudel",
  "main": "index.mjs",
  "type": "module",
--- a/packages/embed/package.json
+++ b/packages/embed/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/embed",
-  "version": "1.1.0",
+  "version": "1.1.1",
  "description": "Embeddable Web Component to load a Strudel REPL into an iframe",
  "main": "embed.js",
  "type": "module",
--- a/packages/gamepad/package.json
+++ b/packages/gamepad/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/gamepad",
-  "version": "1.2.2",
+  "version": "1.2.3",
  "description": "Gamepad Inputs for strudel",
  "main": "index.mjs",
  "type": "module",
--- a/packages/hydra/package.json
+++ b/packages/hydra/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/hydra",
-  "version": "1.2.2",
+  "version": "1.2.3",
  "description": "Hydra integration for strudel",
  "main": "hydra.mjs",
  "type": "module",
--- a/packages/midi/midi.mjs
+++ b/packages/midi/midi.mjs
@ -493,6 +493,9 @@ export async function midin(input) {
        otherInputs?.length ? `Also available: ${getMidiDeviceNamesString(otherInputs)}` : ''
      }`,
    );
+  }
+  // ensure refs for this input are initialized
+  if (!refs[input]) {
    refs[input] = {};
  }
  const cc = (cc) => ref(() => refs[input][cc] || 0);
--- a/packages/midi/package.json
+++ b/packages/midi/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/midi",
-  "version": "1.2.3",
+  "version": "1.2.4",
  "description": "Midi API for strudel",
  "main": "index.mjs",
  "type": "module",
--- a/packages/mini/package.json
+++ b/packages/mini/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/mini",
-  "version": "1.2.2",
+  "version": "1.2.3",
  "description": "Mini notation for strudel",
  "main": "index.mjs",
  "type": "module",
--- a/packages/mondo/package.json
+++ b/packages/mondo/package.json
@ -1,6 +1,6 @@
 {
  "name": "mondolang",
-  "version": "1.1.0",
+  "version": "1.1.1",
  "description": "a language for functional composition that translates to js",
  "main": "mondo.mjs",
  "type": "module",
--- a/packages/mondough/package.json
+++ b/packages/mondough/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/mondo",
-  "version": "1.1.0",
+  "version": "1.1.1",
  "description": "mondo notation for strudel",
  "main": "mondough.mjs",
  "type": "module",
--- a/packages/motion/package.json
+++ b/packages/motion/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/motion",
-  "version": "1.2.2",
+  "version": "1.2.3",
  "description": "DeviceMotion API for strudel",
  "main": "index.mjs",
  "type": "module",
--- a/packages/mqtt/package.json
+++ b/packages/mqtt/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/mqtt",
-  "version": "1.2.2",
+  "version": "1.2.3",
  "description": "MQTT API for strudel",
  "main": "mqtt.mjs",
  "type": "module",
--- a/packages/osc/package.json
+++ b/packages/osc/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/osc",
-  "version": "1.2.2",
+  "version": "1.2.3",
  "description": "OSC messaging for strudel",
  "main": "osc.mjs",
  "type": "module",
--- a/packages/reference/package.json
+++ b/packages/reference/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/reference",
-  "version": "1.2.0",
+  "version": "1.2.1",
  "description": "Headless reference of all strudel functions",
  "main": "index.mjs",
  "type": "module",
--- a/packages/repl/package.json
+++ b/packages/repl/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/repl",
-  "version": "1.2.3",
+  "version": "1.2.4",
  "description": "Strudel REPL as a Web Component",
  "module": "index.mjs",
  "publishConfig": {
--- a/packages/sampler/README.md
+++ b/packages/sampler/README.md
@ -20,3 +20,13 @@ samples('http://localhost:5432')
 LOG=1 npx @strudel/sampler # adds logging
 PORT=5555 npx @strudel/sampler # changes port
 ```
+
+## static json
+
+when running with `--json`, you will simply get the json logged back:
+
+```sh
+npx --yes @strudel/sampler --json > strudel.json
+```
+
+this is useful if you want to create a sample pack from the current folder.
--- a/packages/sampler/package.json
+++ b/packages/sampler/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/sampler",
-  "version": "0.2.0",
+  "version": "0.2.2",
  "description": "",
  "keywords": [
    "tidalcycles",
--- a/packages/sampler/sample-server.mjs
+++ b/packages/sampler/sample-server.mjs
@ -10,14 +10,6 @@ import os from 'os';
 // eslint-disable-next-line
 const LOG = !!process.env.LOG || false;

-console.log(
-  cowsay.say({
-    text: 'welcome to @strudel/sampler',
-    e: 'oO',
-    T: 'U ',
-  }),
-);
-
 async function getFilesInDirectory(directory) {
  let files = [];
  const dirents = await readdir(directory, { withFileTypes: true });
@ -60,8 +52,26 @@ async function getBanks(directory) {
  return { banks, files };
 }

+const args = process.argv.slice(2);
+
 // eslint-disable-next-line
 const directory = process.cwd();
+
+if (args.includes('--json')) {
+  const { banks, files } = await getBanks(directory);
+  const json = JSON.stringify(banks);
+  console.log(json);
+  process.exit(0);
+}
+
+console.log(
+  cowsay.say({
+    text: 'welcome to @strudel/sampler',
+    e: 'oO',
+    T: 'U ',
+  }),
+);
+
 const server = http.createServer(async (req, res) => {
  res.setHeader('Access-Control-Allow-Origin', '*');
  const { banks, files } = await getBanks(directory);
--- a/packages/serial/package.json
+++ b/packages/serial/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/serial",
-  "version": "1.2.2",
+  "version": "1.2.3",
  "description": "Webserial API for strudel",
  "main": "serial.mjs",
  "type": "module",
--- a/packages/soundfonts/package.json
+++ b/packages/soundfonts/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/soundfonts",
-  "version": "1.2.3",
+  "version": "1.2.4",
  "description": "Soundsfont support for strudel",
  "main": "index.mjs",
  "publishConfig": {
--- a/packages/superdough/helpers.mjs
+++ b/packages/superdough/helpers.mjs
@ -209,7 +209,8 @@ export function getVibratoOscillator(param, value, t) {
 // ConstantSource inherits AudioScheduledSourceNode, which has scheduling abilities
 // a bit of a hack, but it works very well :)
 export function webAudioTimeout(audioContext, onComplete, startTime, stopTime) {
-  const constantNode = audioContext.createConstantSource();
+  const constantNode = new ConstantSourceNode(audioContext);
+
  constantNode.start(startTime);
  constantNode.stop(stopTime);
  constantNode.onended = () => {
@ -264,7 +265,7 @@ export function applyFM(param, value, begin) {

    modulator = fmmod.node;
    stop = fmmod.stop;
-    if (![fmAttack, fmDecay, fmSustain, fmRelease, fmVelocity].find((v) => v !== undefined)) {
+    if (![fmAttack, fmDecay, fmSustain, fmRelease, fmVelocity].some((v) => v !== undefined)) {
      // no envelope by default
      modulator.connect(param);
    } else {
--- a/packages/superdough/logger.mjs
+++ b/packages/superdough/logger.mjs
@ -1,5 +1,11 @@
 let log = (msg) => console.log(msg);

+export function errorLogger(e, origin = 'cyclist') {
+  //TODO: add some kind of debug flag that enables this  while in dev mode
+  // console.error(e);
+  logger(`[${origin}] error: ${e.message}`);
+}
+
 export const logger = (...args) => log(...args);

 export const setLogger = (fn) => {
--- a/packages/superdough/package.json
+++ b/packages/superdough/package.json
@ -1,6 +1,6 @@
 {
  "name": "superdough",
-  "version": "1.2.3",
+  "version": "1.2.4",
  "description": "simple web audio synth and sampler intended for live coding. inspired by superdirt and webdirt.",
  "main": "index.mjs",
  "type": "module",
--- a/packages/superdough/superdough.mjs
+++ b/packages/superdough/superdough.mjs
@ -9,9 +9,9 @@ import './reverb.mjs';
 import './vowel.mjs';
 import { clamp, nanFallback, _mod, cycleToSeconds, secondsToCycle } from './util.mjs';
 import workletsUrl from './worklets.mjs?audioworklet';
-import { createFilter, gainNode, getCompressor, getWorklet } from './helpers.mjs';
+import { createFilter, gainNode, getCompressor, getWorklet, webAudioTimeout } from './helpers.mjs';
 import { map } from 'nanostores';
-import { logger } from './logger.mjs';
+import { logger, errorLogger } from './logger.mjs';
 import { loadBuffer } from './sampler.mjs';

 export const DEFAULT_MAX_POLYPHONY = 128;
@ -331,16 +331,18 @@ function getDelay(orbit, delaytime, delayfeedback, t, channels) {
    //logger(`delayfeedback was clamped to ${maxfeedback} to save your ears`);
  }
  delayfeedback = clamp(delayfeedback, 0, 0.98);
-  if (!delays[orbit]) {
+  if (!orbits[orbit].delayNode) {
    const ac = getAudioContext();
    const dly = ac.createFeedbackDelay(1, delaytime, delayfeedback);
    dly.start?.(t); // for some reason, this throws when audion extension is installed..
-    connectToDestination(dly, channels);
-    delays[orbit] = dly;
+    connectToOrbit(dly, orbit);
+    orbits[orbit].delayNode = dly;
  }
-  delays[orbit].delayTime.value !== delaytime && delays[orbit].delayTime.setValueAtTime(delaytime, t);
-  delays[orbit].feedback.value !== delayfeedback && delays[orbit].feedback.setValueAtTime(delayfeedback, t);
-  return delays[orbit];
+  orbits[orbit].delayNode.delayTime.value !== delaytime &&
+    orbits[orbit].delayNode.delayTime.setValueAtTime(delaytime, t);
+  orbits[orbit].delayNode.feedback.value !== delayfeedback &&
+    orbits[orbit].delayNode.feedback.setValueAtTime(delayfeedback, t);
+  return orbits[orbit].delayNode;
 }

 export function getLfo(audioContext, begin, end, properties = {}) {
@ -365,22 +367,6 @@ export function getLfo(audioContext, begin, end, properties = {}) {
  return getWorklet(audioContext, 'lfo-processor', lfoprops);
 }

-export function getSyncedLfo(audioContext, time, end, cps, cycle, properties = {}) {
-  const frequency = cycle / cps;
-
-  return getWorklet(audioContext, 'lfo-processor', {
-    frequency,
-    depth: 1,
-    skew: 0,
-    phaseoffset: 0,
-    time,
-    end,
-    shape: 1,
-    dcoffset: -0.5,
-    ...properties,
-  });
-}
-
 function getPhaser(time, end, frequency = 1, depth = 0.5, centerFrequency = 1000, sweep = 2000) {
  const ac = getAudioContext();
  const lfoGain = getLfo(ac, time, end, { frequency, depth: sweep * 2 });
@ -412,31 +398,73 @@ function getFilterType(ftype) {
  return typeof ftype === 'number' ? filterTypes[Math.floor(_mod(ftype, filterTypes.length))] : ftype;
 }

-let reverbs = {};
+//type orbit {
+// gain: number,
+// reverbNode: reverbNode
+// delayNode: delayNode
+//}
+let orbits = {};
+function connectToOrbit(node, orbit) {
+  if (orbits[orbit] == null) {
+    errorLogger(new Error('target orbit does not exist'), 'superdough');
+  }
+  node.connect(orbits[orbit].gain);
+}
+
+function setOrbit(audioContext, orbit, channels) {
+  if (orbits[orbit] == null) {
+    orbits[orbit] = {
+      gain: new GainNode(audioContext, { gain: 1 }),
+    };
+    connectToDestination(orbits[orbit].gain, channels);
+  }
+}
+function duckOrbit(audioContext, targetOrbit, t, attacktime = 0.1, duckdepth = 1) {
+  const targetArr = [targetOrbit].flat();
+
+  targetArr.forEach((target) => {
+    if (orbits[target] == null) {
+      errorLogger(new Error(`duck target orbit ${target} does not exist`), 'superdough');
+      return;
+    }
+    webAudioTimeout(
+      audioContext,
+      () => {
+        orbits[target].gain.gain.cancelScheduledValues(t);
+        const currVal = orbits[target].gain.gain.value;
+        orbits[target].gain.gain.linearRampToValueAtTime(clamp(1 - Math.pow(duckdepth, 0.5), 0.01, currVal), t);
+        orbits[target].gain.gain.exponentialRampToValueAtTime(1, t + Math.max(0.002, attacktime));
+      },
+      0,
+      t - 0.01,
+    );
+  });
+}
+
 let hasChanged = (now, before) => now !== undefined && now !== before;
-function getReverb(orbit, duration, fade, lp, dim, ir, channels) {
+function getReverb(orbit, duration, fade, lp, dim, ir) {
  // If no reverb has been created for a given orbit, create one
-  if (!reverbs[orbit]) {
+  if (!orbits[orbit].reverbNode) {
    const ac = getAudioContext();
    const reverb = ac.createReverb(duration, fade, lp, dim, ir);
-    connectToDestination(reverb, channels);
-    reverbs[orbit] = reverb;
+    connectToOrbit(reverb, orbit);
+    orbits[orbit].reverbNode = reverb;
  }
  if (
-    hasChanged(duration, reverbs[orbit].duration) ||
-    hasChanged(fade, reverbs[orbit].fade) ||
-    hasChanged(lp, reverbs[orbit].lp) ||
-    hasChanged(dim, reverbs[orbit].dim) ||
-    reverbs[orbit].ir !== ir
+    hasChanged(duration, orbits[orbit].reverbNode.duration) ||
+    hasChanged(fade, orbits[orbit].reverbNode.fade) ||
+    hasChanged(lp, orbits[orbit].reverbNode.lp) ||
+    hasChanged(dim, orbits[orbit].reverbNode.dim) ||
+    orbits[orbit].reverbNode.ir !== ir
  ) {
    // only regenerate when something has changed
    // avoids endless regeneration on things like
    // stack(s("a"), s("b").rsize(8)).room(.5)
    // this only works when args may stay undefined until here
    // setting default values breaks this
-    reverbs[orbit].generate(duration, fade, lp, dim, ir);
+    orbits[orbit].reverbNode.generate(duration, fade, lp, dim, ir);
  }
-  return reverbs[orbit];
+  return orbits[orbit].reverbNode;
 }

 export let analysers = {},
@ -479,8 +507,7 @@ function effectSend(input, effect, wet) {
 }

 export function resetGlobalEffects() {
-  delays = {};
-  reverbs = {};
+  orbits = {};
  analysers = {};
  analysersData = {};
 }
@ -533,6 +560,9 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
    gain = getDefaultValue('gain'),
    postgain = getDefaultValue('postgain'),
    density = getDefaultValue('density'),
+    duckorbit,
+    duckattack,
+    duckdepth,
    // filters
    fanchor = getDefaultValue('fanchor'),
    drive = 0.69,
@ -571,6 +601,7 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
    coarse,

    crush,
+    dry,
    shape,
    shapevol = getDefaultValue('shapevol'),
    distort,
@ -604,7 +635,13 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
  const orbitChannels = mapChannelNumbers(
    multiChannelOrbits && orbit > 0 ? [orbit * 2 - 1, orbit * 2] : getDefaultValue('channels'),
  );
+
  const channels = value.channels != null ? mapChannelNumbers(value.channels) : orbitChannels;
+  setOrbit(ac, orbit, channels, t, cycle, cps);
+
+  if (duckorbit != null) {
+    duckOrbit(ac, duckorbit, t, duckattack, duckdepth);
+  }

  gain = applyGainCurve(nanFallback(gain, 1));
  postgain = applyGainCurve(postgain);
@ -791,7 +828,6 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
  // last gain
  const post = new GainNode(ac, { gain: postgain });
  chain.push(post);
-  connectToDestination(post, channels);

  // delay
  let delaySend;
@ -826,6 +862,14 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
    analyserSend = effectSend(post, analyserNode, 1);
    audioNodes.push(analyserSend);
  }
+  if (dry != null) {
+    dry = applyGainCurve(dry);
+    const dryGain = new GainNode(ac, { gain: dry });
+    chain.push(dryGain);
+    connectToOrbit(dryGain, orbit);
+  } else {
+    connectToOrbit(post, orbit);
+  }

  // connect chain elements together
  chain.slice(1).reduce((last, current) => last.connect(current), chain[0]);
--- a/packages/superdough/synth.mjs
+++ b/packages/superdough/synth.mjs
@ -201,10 +201,7 @@ export function registerSynthSounds() {
      const gainAdjustment = 1 / Math.sqrt(voices);
      getPitchEnvelope(o.parameters.get('detune'), value, begin, holdend);
      const vibratoOscillator = getVibratoOscillator(o.parameters.get('detune'), value, begin);
-      // const fm = applyFM(o.parameters.get('frequency'), value, begin);
-      // https://codeberg.org/uzu/strudel/issues/1428
-      // if you think about re-enabling this, please test with fm > 1 first
-      // it's like 10x gain, so it's really dangerous
+      const fm = applyFM(o.parameters.get('frequency'), value, begin);
      let envGain = gainNode(1);
      envGain = o.connect(envGain);

@ -216,7 +213,7 @@ export function registerSynthSounds() {
          destroyAudioWorkletNode(o);
          envGain.disconnect();
          onended();
-          // fm?.stop();
+          fm?.stop();
          vibratoOscillator?.stop();
        },
        begin,
--- a/packages/superdough/worklets.mjs
+++ b/packages/superdough/worklets.mjs
@ -8,18 +8,28 @@ import FFT from './fft.js';
 const clamp = (num, min, max) => Math.min(Math.max(num, min), max);
 const _mod = (n, m) => ((n % m) + m) % m;

+// Restrict phase to the range [0, maxPhase) via wrapping
+function wrapPhase(phase, maxPhase = 1) {
+  if (phase >= maxPhase) {
+    phase -= maxPhase;
+  } else if (phase < 0) {
+    phase += maxPhase;
+  }
+  return phase;
+}
 const blockSize = 128;
-// adjust waveshape to remove frequencies above nyquist to prevent aliasing
+// Smooth waveshape near discontinuities to remove frequencies above Nyquist and prevent aliasing
 // referenced from https://www.kvraudio.com/forum/viewtopic.php?t=375517
 function polyBlep(phase, dt) {
-  // 0 <= phase < 1
+  dt = Math.min(dt, 1 - dt);
+  // Start of cycle
  if (phase < dt) {
    phase /= dt;
    // 2 * (phase - phase^2/2 - 0.5)
    return phase + phase - phase * phase - 1;
  }

-  // -1 < phase < 0
+  // End of cycle
  else if (phase > 1 - dt) {
    phase = (phase - 1) / dt;
    // 2 * (phase^2/2 + phase + 0.5)
@ -115,7 +125,6 @@ class LFOProcessor extends AudioWorkletProcessor {

  process(inputs, outputs, parameters) {
    const begin = parameters['begin'][0];
-    // eslint-disable-next-line no-undef
    if (currentTime >= parameters.end[0]) {
      return false;
    }
@ -143,7 +152,6 @@ class LFOProcessor extends AudioWorkletProcessor {
    if (this.phase == null) {
      this.phase = _mod(time * frequency + phaseoffset, 1);
    }
-    // eslint-disable-next-line no-undef
    const dt = frequency / sampleRate;
    for (let n = 0; n < blockSize; n++) {
      for (let i = 0; i < output.length; i++) {
@ -305,7 +313,6 @@ class LadderProcessor extends AudioWorkletProcessor {
    const drive = clamp(Math.exp(parameters.drive[0]), 0.1, 2000);

    let cutoff = parameters.frequency[0];
-    // eslint-disable-next-line no-undef
    cutoff = (cutoff * 2 * _PI) / sampleRate;
    cutoff = cutoff > 1 ? 1 : cutoff;

@ -438,18 +445,13 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
    ];
  }
  process(input, outputs, params) {
-    // eslint-disable-next-line no-undef
    if (currentTime <= params.begin[0]) {
      return true;
    }
-    // eslint-disable-next-line no-undef
    if (currentTime >= params.end[0]) {
      // this.port.postMessage({ type: 'onended' });
      return false;
    }
-    let frequency = params.frequency[0];
-    //apply detune in cents
-    frequency = frequency * Math.pow(2, params.detune[0] / 1200);

    const output = outputs[0];
    const voices = params.voices[0];
@ -460,9 +462,6 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {

    for (let n = 0; n < voices; n++) {
      const isOdd = (n & 1) == 1;
-
-      //applies unison "spread" detune in semitones
-      const freq = applySemitoneDetuneToFrequency(frequency, getUnisonDetune(voices, freqspread, n));
      let gainL = gain1;
      let gainR = gain2;
      // invert right and left gain
@ -470,21 +469,21 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
        gainL = gain2;
        gainR = gain1;
      }
-      // eslint-disable-next-line no-undef
-      const dt = freq / sampleRate;
-
      for (let i = 0; i < output[0].length; i++) {
+        // Main detuning
+        let freq = applySemitoneDetuneToFrequency(params.frequency[i] ?? params.frequency[0], params.detune[0] / 100);
+        // Individual voice detuning
+        freq = applySemitoneDetuneToFrequency(freq, getUnisonDetune(voices, freqspread, n));
+        // We must wrap this here because it is passed into sawblep below which
+        // has domain [0, 1]
+        const dt = _mod(freq / sampleRate, 1);
        this.phase[n] = this.phase[n] ?? Math.random();
        const v = waveshapes.sawblep(this.phase[n], dt);

        output[0][i] = output[0][i] + v * gainL;
        output[1][i] = output[1][i] + v * gainR;

-        this.phase[n] += dt;
-
-        if (this.phase[n] > 1.0) {
-          this.phase[n] = this.phase[n] - 1;
-        }
+        this.phase[n] = wrapPhase(this.phase[n] + dt);
      }
    }
    return true;
@ -493,7 +492,7 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {

 registerProcessor('supersaw-oscillator', SuperSawOscillatorProcessor);

-// Phase Vocoder sourced from // sourced from https://github.com/olvb/phaze/tree/master?tab=readme-ov-file
+// Phase Vocoder sourced from https://github.com/olvb/phaze/tree/master?tab=readme-ov-file
 const BUFFERED_BLOCK_SIZE = 2048;

 function genHannWindow(length) {
--- a/packages/tonal/package.json
+++ b/packages/tonal/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/tonal",
-  "version": "1.2.2",
+  "version": "1.2.3",
  "description": "Tonal functions for strudel",
  "main": "index.mjs",
  "publishConfig": {
--- a/packages/transpiler/package.json
+++ b/packages/transpiler/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/transpiler",
-  "version": "1.2.2",
+  "version": "1.2.3",
  "description": "Transpiler for strudel user code. Converts syntactically correct but semantically meaningless JS into evaluatable strudel code.",
  "main": "index.mjs",
  "type": "module",
--- a/packages/web/package.json
+++ b/packages/web/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/web",
-  "version": "1.2.3",
+  "version": "1.2.4",
  "description": "Easy to setup, opiniated bundle of Strudel for the browser.",
  "module": "web.mjs",
  "publishConfig": {
--- a/packages/webaudio/package.json
+++ b/packages/webaudio/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/webaudio",
-  "version": "1.2.3",
+  "version": "1.2.4",
  "description": "Web Audio helpers for Strudel",
  "main": "index.mjs",
  "type": "module",
--- a/packages/xen/package.json
+++ b/packages/xen/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/xen",
-  "version": "1.2.2",
+  "version": "1.2.3",
  "description": "Xenharmonic API for strudel",
  "main": "index.mjs",
  "type": "module",