takomusic 1.2.0

package/dist/utils/stdlib.js

@@ -0,0 +1,51 @@
+// Standard library path resolution
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Package root (where lib/ is located)
+const packageRoot = path.resolve(__dirname, '..', '..');
+// Available standard library modules
+export const STDLIB_MODULES = [
+    'theory',
+    'patterns',
+    'rhythm',
+    'dynamics',
+    'expression',
+    'articulation',
+    'ornaments',
+    'notation',
+    'genres',
+    'composition',
+    'curves',
+    'utils',
+];
+/**
+ * Check if an import path is a standard library import
+ * @param importPath The import path (e.g., "std:theory" or "./local.mf")
+ */
+export function isStdlibImport(importPath) {
+    return importPath.startsWith('std:');
+}
+/**
+ * Resolve a standard library import to its file path
+ * @param importPath The import path (e.g., "std:theory")
+ * @returns The absolute path to the stdlib module file
+ */
+export function resolveStdlibPath(importPath) {
+    if (!isStdlibImport(importPath)) {
+        throw new Error(`Not a stdlib import: ${importPath}`);
+    }
+    const moduleName = importPath.slice(4); // Remove "std:" prefix
+    if (!STDLIB_MODULES.includes(moduleName)) {
+        throw new Error(`Unknown stdlib module: ${moduleName}. Available: ${STDLIB_MODULES.join(', ')}`);
+    }
+    return path.join(packageRoot, 'lib', `${moduleName}.mf`);
+}
+/**
+ * Get the standard library directory path
+ */
+export function getStdlibDir() {
+    return path.join(packageRoot, 'lib');
+}
+//# sourceMappingURL=stdlib.js.map

package/dist/utils/stdlib.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdlib.js","sourceRoot":"","sources":["../../src/utils/stdlib.ts"],"names":[],"mappings":"AAAA,mCAAmC;AACnC,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,CAAC;AAEpC,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClD,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;AAE3C,uCAAuC;AACvC,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AAExD,qCAAqC;AACrC,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,QAAQ;IACR,UAAU;IACV,QAAQ;IACR,UAAU;IACV,YAAY;IACZ,cAAc;IACd,WAAW;IACX,UAAU;IACV,QAAQ;IACR,aAAa;IACb,QAAQ;IACR,OAAO;CACC,CAAC;AAIX;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,UAAkB;IAC/C,OAAO,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;AACvC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,UAAkB;IAClD,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CAAC,wBAAwB,UAAU,EAAE,CAAC,CAAC;IACxD,CAAC;IAED,MAAM,UAAU,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,uBAAuB;IAE/D,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,UAA0B,CAAC,EAAE,CAAC;QACzD,MAAM,IAAI,KAAK,CAAC,0BAA0B,UAAU,gBAAgB,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACnG,CAAC;IAED,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,EAAE,GAAG,UAAU,KAAK,CAAC,CAAC;AAC3D,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,YAAY;IAC1B,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;AACvC,CAAC"}

package/lib/articulation.mf

@@ -0,0 +1,46 @@
+// Articulation functions for TakoMusic
+// These can be imported and used instead of built-in articulation functions
+
+// staccato - play note shorter and slightly accented
+export proc staccato(pitch, dur, vel) {
+  const actualVel = vel + 10;
+  const actualDur = dur / 2;
+  note(pitch, actualDur, actualVel);
+}
+
+// legato - play note with full duration, slightly softer
+export proc legato(pitch, dur, vel) {
+  const actualVel = vel - 5;
+  note(pitch, dur, actualVel);
+}
+
+// accent - play note with increased velocity
+export proc accent(pitch, dur, vel) {
+  const actualVel = vel + 20;
+  note(pitch, dur, actualVel);
+}
+
+// tenuto - play note with full duration and slight emphasis
+export proc tenuto(pitch, dur, vel) {
+  const actualVel = vel + 8;
+  note(pitch, dur, actualVel);
+}
+
+// marcato - play note with strong accent
+export proc marcato(pitch, dur, vel) {
+  const actualVel = vel + 30;
+  const actualDur = dur * 3/4;
+  note(pitch, actualDur, actualVel);
+}
+
+// portato - detached but with some weight (between staccato and legato)
+export proc portato(pitch, dur, vel) {
+  const actualDur = dur * 3/4;
+  note(pitch, actualDur, vel);
+}
+
+// sforzando - sudden strong accent
+export proc sforzando(pitch, dur, vel) {
+  const actualVel = min(127, vel + 40);
+  note(pitch, dur, actualVel);
+}

package/lib/composition.mf

@@ -0,0 +1,299 @@
+// Composition techniques for TakoMusic
+// Melodic and structural transformations
+
+import { clip } from "./utils.mf";
+
+// Melodic sequence - transpose pattern by intervals
+export proc sequence(melody, intervals, dur) {
+  // Play original
+  for (i in 0..len(melody)) {
+    note(melody[i], dur);
+  }
+
+  // Play transposed versions
+  for (j in 0..len(intervals)) {
+    for (i in 0..len(melody)) {
+      note(transpose(melody[i], intervals[j]), dur);
+    }
+  }
+}
+
+// Sequence with individual durations
+export proc sequenceWithDurs(melody, durs, intervals) {
+  // Play original
+  for (i in 0..len(melody)) {
+    note(melody[i], durs[i]);
+  }
+
+  // Play transposed versions
+  for (j in 0..len(intervals)) {
+    for (i in 0..len(melody)) {
+      note(transpose(melody[i], intervals[j]), durs[i]);
+    }
+  }
+}
+
+// Call and response pattern
+export proc callResponse(call, response, callDur, responseDur, gap) {
+  // Call
+  for (i in 0..len(call)) {
+    note(call[i], callDur);
+  }
+
+  // Gap
+  rest(gap);
+
+  // Response
+  for (i in 0..len(response)) {
+    note(response[i], responseDur);
+  }
+}
+
+// Call and response with automatic response generation (echo)
+export proc callEcho(call, callDur, interval, gap) {
+  // Call
+  for (i in 0..len(call)) {
+    note(call[i], callDur);
+  }
+
+  // Gap
+  rest(gap);
+
+  // Echo (transposed and softer)
+  for (i in 0..len(call)) {
+    note(transpose(call[i], interval), callDur, 70);
+  }
+}
+
+// Ostinato - repeating pattern
+export proc ostinato(pattern, dur, repetitions) {
+  for (rep in 0..repetitions) {
+    for (i in 0..len(pattern)) {
+      note(pattern[i], dur);
+    }
+  }
+}
+
+// Ostinato with individual durations
+export proc ostinatoWithDurs(pattern, durs, repetitions) {
+  for (rep in 0..repetitions) {
+    for (i in 0..len(pattern)) {
+      note(pattern[i], durs[i]);
+    }
+  }
+}
+
+// Canon - same melody with delayed entries
+// Returns the total duration for synchronization
+export proc canonMelody(melody, dur, delayBeats) {
+  for (i in 0..len(melody)) {
+    note(melody[i], dur);
+  }
+  return len(melody) * dur;
+}
+
+// Helper to create canon entry point
+export proc canonEntry(melody, dur, entryNumber, delayBeats) {
+  // Wait for entry
+  rest(delayBeats * entryNumber);
+
+  // Play melody
+  for (i in 0..len(melody)) {
+    note(melody[i], dur);
+  }
+}
+
+// Imitation - similar to canon but with transformation
+export proc imitation(melody, dur, interval, invert) {
+  for (i in 0..len(melody)) {
+    let pitch = melody[i];
+
+    if (invert) {
+      // Invert around first note
+      const axis = melody[0];
+      const axisMidi = pitchMidi(axis);
+      const noteMidi = pitchMidi(pitch);
+      const inverted = axisMidi - (noteMidi - axisMidi);
+      pitch = midiPitch(clip(inverted, 0, 127));
+    }
+
+    note(transpose(pitch, interval), dur);
+  }
+}
+
+// Theme and variation - apply transformation to theme
+export proc variation(theme, dur, variationType) {
+  if (variationType == "original") {
+    for (i in 0..len(theme)) {
+      note(theme[i], dur);
+    }
+  }
+
+  if (variationType == "octave") {
+    for (i in 0..len(theme)) {
+      note(transpose(theme[i], 12), dur);
+    }
+  }
+
+  if (variationType == "retrograde") {
+    for (i in 0..len(theme)) {
+      const idx = len(theme) - 1 - i;
+      note(theme[idx], dur);
+    }
+  }
+
+  if (variationType == "augment") {
+    for (i in 0..len(theme)) {
+      note(theme[i], dur * 2);
+    }
+  }
+
+  if (variationType == "diminish") {
+    for (i in 0..len(theme)) {
+      note(theme[i], dur / 2);
+    }
+  }
+
+  if (variationType == "invert") {
+    const axis = theme[0];
+    const axisMidi = pitchMidi(axis);
+
+    for (i in 0..len(theme)) {
+      const noteMidi = pitchMidi(theme[i]);
+      const inverted = axisMidi - (noteMidi - axisMidi);
+      note(midiPitch(clip(inverted, 0, 127)), dur);
+    }
+  }
+}
+
+// Hocket - alternating notes between voices (returns patterns)
+export proc hocket(melody) {
+  let voice1 = [];
+  let voice2 = [];
+
+  for (i in 0..len(melody)) {
+    if (i % 2 == 0) {
+      push(voice1, melody[i]);
+      push(voice2, 0);  // 0 = rest
+    } else {
+      push(voice1, 0);
+      push(voice2, melody[i]);
+    }
+  }
+
+  return [voice1, voice2];
+}
+
+// Play hocket pattern (0 = rest)
+export proc playHocket(pattern, dur) {
+  for (i in 0..len(pattern)) {
+    if (pattern[i] == 0) {
+      rest(dur);
+    } else {
+      note(pattern[i], dur);
+    }
+  }
+}
+
+// Stretto - overlapping entries
+export proc strettoEntry(melody, dur, entryOffset) {
+  rest(entryOffset);
+  for (i in 0..len(melody)) {
+    note(melody[i], dur);
+  }
+}
+
+// Pedal point - sustained bass note under changing harmony
+export proc pedalPoint(pitch, dur, repetitions) {
+  for (i in 0..repetitions) {
+    note(pitch, dur);
+  }
+}
+
+// Drone - continuous sustained notes
+export proc drone(pitches, dur) {
+  chord(pitches, dur);
+}
+
+// Arpeggio patterns for accompaniment
+export proc albertiPattern(chordPitches, dur, repetitions) {
+  const pattern = [0, 2, 1, 2];  // Alberti bass pattern
+
+  for (rep in 0..repetitions) {
+    for (i in 0..len(pattern)) {
+      const idx = pattern[i];
+      if (idx < len(chordPitches)) {
+        note(chordPitches[idx], dur);
+      }
+    }
+  }
+}
+
+// Broken chord ascending
+export proc brokenChordUp(chordPitches, dur) {
+  for (i in 0..len(chordPitches)) {
+    note(chordPitches[i], dur);
+  }
+}
+
+// Broken chord descending
+export proc brokenChordDown(chordPitches, dur) {
+  for (i in 0..len(chordPitches)) {
+    const idx = len(chordPitches) - 1 - i;
+    note(chordPitches[idx], dur);
+  }
+}
+
+// Antiphonal - alternating between two groups
+export proc antiphonal(group1, group2, dur, exchanges) {
+  for (ex in 0..exchanges) {
+    // Group 1
+    for (i in 0..len(group1)) {
+      note(group1[i], dur);
+    }
+
+    // Group 2
+    for (i in 0..len(group2)) {
+      note(group2[i], dur);
+    }
+  }
+}
+
+// Motivic development - fragment and develop
+export proc motifFragment(melody, startIdx, endIdx, dur) {
+  for (i in startIdx..endIdx) {
+    if (i < len(melody)) {
+      note(melody[i], dur);
+    }
+  }
+}
+
+// Extend motif by repetition with variation
+export proc motifExtend(motif, dur, extensions) {
+  // Original
+  for (i in 0..len(motif)) {
+    note(motif[i], dur);
+  }
+
+  // Extended with last note repeated
+  for (ext in 0..extensions) {
+    note(motif[len(motif) - 1], dur);
+  }
+}
+
+// Rhythmic displacement - shift pattern by offset
+export proc displace(melody, dur, offsetDur) {
+  rest(offsetDur);
+  for (i in 0..len(melody)) {
+    note(melody[i], dur);
+  }
+}
+
+// Polymelody helper - returns starting position
+export proc layerMelody(melody, dur, startOffset) {
+  rest(startOffset);
+  for (i in 0..len(melody)) {
+    note(melody[i], dur);
+  }
+  return startOffset + len(melody) * dur;
+}

package/lib/curves.mf

@@ -0,0 +1,183 @@
+// Curve and interpolation functions for TakoMusic
+// Generate smooth transitions and automation curves
+
+import { lerp, clip } from "./utils.mf";
+
+// Linear curve from start to end
+export proc linearCurve(startVal, endVal, steps) {
+  let curve = [];
+  for (i in 0..=steps) {
+    const t = i / steps;
+    push(curve, lerp(startVal, endVal, t));
+  }
+  return curve;
+}
+
+// Quadratic ease-in curve (starts slow, ends fast)
+export proc easeInQuad(startVal, endVal, steps) {
+  let curve = [];
+  for (i in 0..=steps) {
+    const t = i / steps;
+    const eased = t * t;
+    push(curve, lerp(startVal, endVal, eased));
+  }
+  return curve;
+}
+
+// Quadratic ease-out curve (starts fast, ends slow)
+export proc easeOutQuad(startVal, endVal, steps) {
+  let curve = [];
+  for (i in 0..=steps) {
+    const t = i / steps;
+    const eased = t * (2 - t);
+    push(curve, lerp(startVal, endVal, eased));
+  }
+  return curve;
+}
+
+// Quadratic ease-in-out curve (slow-fast-slow)
+export proc easeInOutQuad(startVal, endVal, steps) {
+  let curve = [];
+  for (i in 0..=steps) {
+    const t = i / steps;
+    let eased = 0.0;
+    if (t < 0.5) {
+      eased = 2 * t * t;
+    } else {
+      eased = 1 - 2 * (1 - t) * (1 - t);
+    }
+    push(curve, lerp(startVal, endVal, eased));
+  }
+  return curve;
+}
+
+// Cubic ease-in curve
+export proc easeInCubic(startVal, endVal, steps) {
+  let curve = [];
+  for (i in 0..=steps) {
+    const t = i / steps;
+    const eased = t * t * t;
+    push(curve, lerp(startVal, endVal, eased));
+  }
+  return curve;
+}
+
+// Cubic ease-out curve
+export proc easeOutCubic(startVal, endVal, steps) {
+  let curve = [];
+  for (i in 0..=steps) {
+    const t = i / steps;
+    const t1 = t - 1;
+    const eased = t1 * t1 * t1 + 1;
+    push(curve, lerp(startVal, endVal, eased));
+  }
+  return curve;
+}
+
+// S-curve (smooth step)
+export proc smoothstep(startVal, endVal, steps) {
+  let curve = [];
+  for (i in 0..=steps) {
+    const t = i / steps;
+    const eased = t * t * (3 - 2 * t);
+    push(curve, lerp(startVal, endVal, eased));
+  }
+  return curve;
+}
+
+// Exponential curve approximation (for positive exponents)
+export proc exponentialCurve(startVal, endVal, steps, exponent) {
+  let curve = [];
+  for (i in 0..=steps) {
+    const t = i / steps;
+    let eased = t;
+
+    // Approximate power function for common exponents
+    if (exponent == 2) {
+      eased = t * t;
+    } else {
+      if (exponent == 3) {
+        eased = t * t * t;
+      } else {
+        if (exponent == 4) {
+          eased = t * t * t * t;
+        } else {
+          // For other exponents, use repeated multiplication
+          eased = 1.0;
+          for (j in 0..floor(exponent)) {
+            eased = eased * t;
+          }
+        }
+      }
+    }
+
+    push(curve, lerp(startVal, endVal, eased));
+  }
+  return curve;
+}
+
+// Apply curve to MIDI CC automation
+export proc applyCurveToCC(ccNum, curve, startTick, endTick) {
+  const steps = len(curve);
+  const tickRange = endTick - startTick;
+
+  for (i in 0..steps) {
+    const tick = startTick + floor(tickRange * i / (steps - 1));
+    const value = clip(floor(curve[i]), 0, 127);
+    atTick(tick);
+    cc(ccNum, value);
+  }
+}
+
+// Tempo curve automation
+export proc tempoCurveLinear(startTempo, endTempo, dur) {
+  const ticks = durToTicks(dur);
+  const steps = 32;
+  const curve = linearCurve(startTempo, endTempo, steps);
+
+  for (i in 0..len(curve)) {
+    const tick = floor(ticks * i / (len(curve) - 1));
+    atTick(tick);
+    tempo(floor(curve[i]));
+  }
+}
+
+// Expression (dynamics) curve
+export proc expressionCurveSmooth(startVal, endVal, dur) {
+  const ticks = durToTicks(dur);
+  const steps = 16;
+  const curve = smoothstep(startVal, endVal, steps);
+
+  applyCurveToCC(11, curve, 0, ticks);
+}
+
+// Volume fade
+export proc volumeFade(startVol, endVol, dur) {
+  const ticks = durToTicks(dur);
+  const steps = 16;
+  const curve = linearCurve(startVol, endVol, steps);
+
+  applyCurveToCC(7, curve, 0, ticks);
+}
+
+// Pan sweep
+export proc panSweep(startPan, endPan, dur) {
+  const ticks = durToTicks(dur);
+  const steps = 16;
+  const curve = linearCurve(startPan, endPan, steps);
+
+  applyCurveToCC(10, curve, 0, ticks);
+}
+
+// Pitch bend curve (smooth glissando)
+export proc pitchBendCurveSmooth(startBend, endBend, dur) {
+  const ticks = durToTicks(dur);
+  const steps = 32;
+  const curve = smoothstep(startBend, endBend, steps);
+
+  for (i in 0..len(curve)) {
+    const tick = floor(ticks * i / (len(curve) - 1));
+    atTick(tick);
+    pitchBend(floor(curve[i]));
+  }
+}