moontide-mcp 2.1.0 → 2.2.0

package/page/midi-clock.js

@@ -148,6 +148,9 @@ function defaultOnError(text, err) {
  * - onState(port, state): called when a port's state changes.
  * - onError(text, err).
  * - alignment: { ms }, default the page-wide one.
+ * - rampSeconds(fromCycle, toCycle): while a tempo ramp runs, `{ seconds, lagSeconds }`: the seconds of music between two cycles
+ *   through the ramp's steps and how far that can be off when the tempo trails the plan by a step; null when no ramp runs
+ *   (default: always null). Only stampOfCycle uses it: a line far enough ahead to lie behind several tempo steps.
  * Returns { want, stop, stateOf, holdsNotes, stamp, stampOfCycle, stats }.
  */
 export function createPageClock({
@@ -162,6 +165,7 @@ export function createPageClock({
   onState = () => {},
   onError = defaultOnError,
   alignment = pageAlignment,
+  rampSeconds = () => null,
 }) {
   // port -> { entry: { port, id }, nextTick, startAt, startCycle, stopOwedFrom, holdSince, holdExpired }
   const wanted = new Map();
@@ -202,6 +206,20 @@ export function createPageClock({
     return (c - seg.c) / seg.cps + seg.s + s.latency;
   }
 
+  /**
+   * AudioContext time of the cycle line `c` a change waits for. Like audioTimeOf, except that while a tempo ramp runs the
+   * seconds from the start of the latest tempo segment to the line go through the ramp's own steps: one segment at the
+   * tempo of the moment puts a line early on a slowing ramp and late on a rising one. With `early` the time is the
+   * earliest the line can be heard, the ramp's lag taken off, for a setup that must land before the line.
+   */
+  function lineAudioTimeOf(s, c, early) {
+    let seg = segments[0];
+    for (const candidate of segments) if (candidate.c <= c) seg = candidate;
+    const through = c > seg.c ? rampSeconds(seg.c, c) : null;
+    const seconds = through === null ? (c - seg.c) / seg.cps : through.seconds - (early ? through.lagSeconds : 0);
+    return seconds + seg.s + s.latency;
+  }
+
   /**
    * performance.now() time of an AudioContext time, from getOutputTimestamp pairs lined up with Strudel's own
    * mapping by the page-wide alignment. Null when nothing can be scheduled yet (no alignment, no usable pair).
@@ -275,16 +293,17 @@ export function createPageClock({
    * a tick and a stamped note of that position use), or null when none can be given: the cycle is not a finite
    * number, the scheduler cannot be read or does not run, its numbers cannot be used, no tempo segment is known yet,
    * or stamp() has none. Reads the scheduler and notes its segment as a pass does, so it also serves while no
-   * instrument wants the clock. Never throws.
+   * instrument wants the clock. While a tempo ramp runs the line is worked out through the ramp, and with `early` it is the
+   * earliest time the line can be heard (see lineAudioTimeOf). Never throws.
    */
-  function stampOfCycle(cycle) {
+  function stampOfCycle(cycle, { early = false } = {}) {
     if (typeof cycle !== 'number' || !Number.isFinite(cycle)) return null;
     try {
       const s = readCyclist(getScheduler());
       if (!s.started || unusableReason(s) !== null) return null;
       if (s.num_ticks_since_cps_change !== 0) noteSegment(s);
       if (segments.length === 0) return null;
-      return stamp(audioTimeOf(s, cycle));
+      return stamp(lineAudioTimeOf(s, cycle, early));
     } catch {
       return null;
     }

package/page/midi-out.js

@@ -193,6 +193,8 @@ export function createMidiOut({
   getScheduler,
   getAudioContext,
   perfNow,
+  // (fromCycle, toCycle) => { seconds, lagSeconds } through a running tempo ramp, or null: lines far ahead are stamped through it.
+  rampSeconds = () => null,
   onClockState = () => {},
   resetSettleMs = RESET_SETTLE_MS,
   now = () => Date.now(),
@@ -1550,6 +1552,7 @@ export function createMidiOut({
           getScheduler,
           getAudioContext,
           perfNow,
+          rampSeconds,
           setTimer,
           clearTimer,
           isPlaying,
@@ -1899,7 +1902,7 @@ export function createMidiOut({
 
   /**
    * The timestamp for the setup of a change that waits for cycle `atCycle`: the page clock's stamp of that line minus
-   * SETUP_BEFORE_LINE_MS. When no stamp can be given or it is more than NOTE_STAMP_MAX_AHEAD_MS ahead (a far timestamp
+   * SETUP_BEFORE_LINE_MS (while a tempo ramp runs, the earliest the line can be heard: the setup must land before it). When no stamp can be given or it is more than NOTE_STAMP_MAX_AHEAD_MS ahead (a far timestamp
    * would park bytes in the OS queue, which cannot take them back), says so in one Moontide: line, waits until the
    * line through the injected timer and resolves undefined: the setup then goes out without a timestamp. `track` gets
    * { cancel } while that wait runs, so a dropped plan ends it. Never rejects.
@@ -1907,7 +1910,7 @@ export function createMidiOut({
   async function timedSetupAt(atCycle, track) {
     let line = null;
     try {
-      line = pageClock === null ? null : pageClock.stampOfCycle(atCycle);
+      line = pageClock === null ? null : pageClock.stampOfCycle(atCycle, { early: true });
     } catch (err) {
       onError('Moontide: the page clock could not give the timestamp of the line:', err);
     }

package/page/mixer-view.js

@@ -2048,7 +2048,7 @@ export function createMixerView({ document, gesture, midiPreview, onStripSelect
       mixerStrips.replaceChildren();
       renderInspector();
       refreshNotice();
-      return;
+      return { created: 0 };
     }
     mixerMessage.hidden = true;
     mixerBody.hidden = false;
@@ -2058,6 +2058,9 @@ export function createMixerView({ document, gesture, midiPreview, onStripSelect
     if (noNotesText === null) mixerNoNotes.removeAttribute('title');
     else mixerNoNotes.title = MIXER_COPY.noNotesTitle;
     mixerNoNotes.hidden = noNotesText === null;
+    // How many strips and group frames this render built new. A new element starts dark, so the caller makes the lights write
+    // their lit values again when it is more than 0.
+    let created = 0;
     const seen = new Set();
     // The strips placed in the DOM whose fader the hand holds: they are not moved or removed until it lets go.
     const held = new Set();
@@ -2081,6 +2084,7 @@ export function createMixerView({ document, gesture, midiPreview, onStripSelect
       if (!ref) {
         ref = createStrip(strip);
         refs.set(strip.identity, ref);
+        created += 1;
       }
       updateStrip(ref, strip);
     });
@@ -2124,6 +2128,7 @@ export function createMixerView({ document, gesture, midiPreview, onStripSelect
           if (groupRef === undefined) {
             groupRef = createGroupFrame(item);
             groupRefs.set(item.key, groupRef);
+            created += 1;
           }
           updateGroupFrame(groupRef, item);
           desired.push(groupRef.el);
@@ -2169,6 +2174,7 @@ export function createMixerView({ document, gesture, midiPreview, onStripSelect
       refs.delete(identity);
     }
     refreshDisabled();
+    return { created };
   }
 
   return {

package/page/note-panel.js

@@ -267,19 +267,40 @@ export function rangeWhereText(track) {
   return fill(TIMELINE_COPY.noteRangeWhere, { lane: track });
 }
 
+/** The longest section part of a range's identity line, the same 200 characters as every text of a request. */
+const MAX_RANGE_SECTIONS_TEXT = 200;
+
+/**
+ * The section part of a range's identity line for `sections` (names in playing order) and the `moreSections` names a list already
+ * left out. A list that fits shows whole; a longer one keeps the first names that, with ' and N more', fit 200 characters (at least
+ * the first), and N counts every name not shown.
+ */
+function rangeSectionsText(sections, moreSections) {
+  const quoted = sections.map((name) => `'${displayName(name)}'`);
+  if (sections.length === 1 && moreSections === 0) return fill(TIMELINE_COPY.noteSection, { section: displayName(sections[0]) });
+  const build = (shown) => {
+    const left = sections.length - shown + moreSections;
+    return fill(TIMELINE_COPY.noteRangeSectionList, { list: quoted.slice(0, shown).join(', ') }) + (left > 0 ? fill(TIMELINE_COPY.noteRangeSectionsMore, { n: left }) : '');
+  };
+  let shown = sections.length;
+  while (shown > 1 && build(shown).length > MAX_RANGE_SECTIONS_TEXT) shown--;
+  return build(shown);
+}
+
 /**
- * The muted part of the identity line of a range: ` · cycles 12 to 15` (` · cycle 12` for one), the section when the piece has a
- * song (` · section 'y'`, ` · sections 'x' to 'z'` when the range crosses a boundary) and the notes (` · 14 notes`, ` · 1 note`,
- * ` · no notes`). `range` is `{ from, to, section, sectionTo, count }`; `section` and `sectionTo` are names or absent.
+ * The muted part of the identity line of a range: ` · cycles 12 to 15` (` · cycle 12` for one), the sections it crosses when the
+ * piece has a song (` · section 'y'`, ` · sections 'z', 'x', 'y'` in playing order, a section that comes back named again) and the
+ * notes (` · 14 notes`, ` · 1 note`, ` · no notes`). `range` is `{ from, to, sections, moreSections, count }`; `sections` is a
+ * list of names or absent (a piece without a song) and `moreSections` counts the names the list left out.
  */
-export function rangePositionText({ from, to, section = null, sectionTo = null, count }) {
+export function rangePositionText({ from, to, sections = null, moreSections = 0, count }) {
   if (!Number.isInteger(from) || !Number.isInteger(to) || to < from) throw new Error('Moontide: a range has whole cycles, the last not before the first.');
   if (!Number.isInteger(count) || count < 0) throw new Error('Moontide: a range has a count of notes of at least 0.');
-  if (sectionTo !== null && section === null) throw new Error('Moontide: a range that ends in a second section starts in a first one.');
+  if (!Number.isInteger(moreSections) || moreSections < 0) throw new Error('Moontide: a range has a count of more sections of at least 0.');
+  if (sections !== null && sections.length === 0) throw new Error('Moontide: a range that names its sections names at least one section.');
+  if (sections === null && moreSections > 0) throw new Error('Moontide: a range cannot have more sections without a list of sections.');
   let text = from === to ? fill(TIMELINE_COPY.noteRangeCycle, { a: from }) : fill(TIMELINE_COPY.noteRangeCycles, { a: from, b: to });
-  if (section !== null) {
-    text += sectionTo === null ? fill(TIMELINE_COPY.noteSection, { section: displayName(section) }) : fill(TIMELINE_COPY.noteRangeSections, { first: displayName(section), last: displayName(sectionTo) });
-  }
+  if (sections !== null) text += rangeSectionsText(sections, moreSections);
   if (count === 0) return text + TIMELINE_COPY.noteRangeNoNotes;
   return text + (count === 1 ? TIMELINE_COPY.noteRangeOneNote : fill(TIMELINE_COPY.noteRangeNotes, { n: count }));
 }

package/page/note-tag.js

@@ -24,6 +24,9 @@ import { labelKey } from './tracks.js';
 
 const subscribers = new Set();
 
+/** How many different failure messages are printed before one closing line says the rest are not. */
+export const MAX_REPORTED_FAILURES = 20;
+
 /**
  * Calls `listener(event)` for every note of a labeled track, where event is `{ key, hap, target,
  * stamp }`. The key is the track's Mixer identity, or `$n` for the n-th `$` statement of the
@@ -64,14 +67,26 @@ export function installNoteTag(PatternClass, { stampOf } = {}) {
   // Undefined at page start: the repl assigns p only when it evaluates code.
   let repl = PatternClass.prototype.p;
   let dollar = 0;
-  let errorReported = false;
+  // The messages already printed. The tag is installed once per page load, so each different failure is said once per load,
+  // and the set cannot grow past MAX_REPORTED_FAILURES.
+  const reportedMessages = new Set();
+  let boundSaid = false;
   // A note reaches one observer per tag; this keeps a pattern tagged twice under one key to one report.
   const reported = new WeakSet();
 
+  // A listener that throws on every note would print on every note; one that fails differently each time would never stop.
+  // So a failure is printed once per message, and after MAX_REPORTED_FAILURES different messages one last line says so.
   function reportOnce(err) {
-    if (errorReported) return;
-    errorReported = true;
-    console.error('Moontide: a note listener or the MIDI timestamp lookup failed; later failures are not repeated:', err);
+    const message = err instanceof Error ? err.message : String(err);
+    if (reportedMessages.has(message)) return;
+    if (reportedMessages.size >= MAX_REPORTED_FAILURES) {
+      if (boundSaid) return;
+      boundSaid = true;
+      console.error('Moontide: more note listener failures happened; they are not reported.');
+      return;
+    }
+    reportedMessages.add(message);
+    console.error('Moontide: a note listener or the MIDI timestamp lookup failed:', err);
   }
 
   function observerFor(key) {

package/page/page-rewrite.js

@@ -46,7 +46,7 @@ function refused(reason) {
  *   evalError() -> the evaluation's error or null,
  *   revertAndReport(error) -> { errorText, line }: sets the editor back to the committed code and shows the banner,
  *   markPageOrigin() -> the playing code now has no Claude evaluate id,
- *   whenFinished(record, fn) -> runs fn when the waiting change takes over (or is dropped),
+ *   whenFinished(record, fn) -> runs fn when the waiting change takes over; never when it is canceled (replaced or stopped),
  *   markPageOriginAtTakeover() -> the same mark, for the moment a waiting change takes over.
  */
 export function createPageRewrite(deps) {

package/page/query-check.js

@@ -80,8 +80,13 @@ export function captureQueryTypes(kept, globals) {
  *   `onReached` when the gate first queries past the line, because the old music that keeps playing must
  *   not have its errors forwarded a second time and the new pattern's first errors must still count.
  *   `getPlayingCode()` gives the code that plays now, for the waiting record.
+ *
+ * `refuse`, when given, is asked first, for every value handed over, before the pattern is checked or installed: when it
+ * returns a text, setPattern throws an Error with that text. This is the one seam where a change can be refused for
+ * something only the finished program knows (the tempo it set) and still fail the evaluation before the new pattern or a
+ * waiting record exists: the scheduler's pattern and any waiting change stay as they were.
  */
-export function installQueryCheck(scheduler, { getTypes, queryErrors, schedulerQueries, takeover, getPlayingCode }) {
+export function installQueryCheck(scheduler, { getTypes, queryErrors, schedulerQueries, takeover, getPlayingCode, refuse }) {
   const originalSetPattern = scheduler.setPattern;
   if (typeof originalSetPattern !== 'function') {
     throw new Error('Moontide: the scheduler of the pinned @strudel/repl 1.3.0 has no setPattern function.');
@@ -103,6 +108,10 @@ export function installQueryCheck(scheduler, { getTypes, queryErrors, schedulerQ
     return result;
   }
   scheduler.setPattern = function (pattern, autostart) {
+    if (typeof refuse === 'function') {
+      const refusal = refuse();
+      if (typeof refusal === 'string') throw new Error(refusal);
+    }
     // The repl's own handling of a value that is not a pattern stays as before (a waiting change is replaced too).
     if (pattern === null || pattern === undefined || typeof pattern.query !== 'function') {
       queryErrors.reset();
@@ -154,8 +163,11 @@ export function installQueryCheck(scheduler, { getTypes, queryErrors, schedulerQ
  * to `onError` as the bundle's log text (`[query] error: <message>`), then return no events as the
  * bundle does. Every other query keeps the bundle's own `queryArc`, whose log the page ignores.
  * `getTypes()` gives { State, TimeSpan }.
+ * `onSchedulerQuery`, when given, is called once on each of the scheduler's own queries, before the query runs (it is the
+ * tempo ramp's way to learn that the scheduler is playing). It is the scheduler's slice that calls it, so a throw is
+ * caught here, logged as one `Moontide:` line and never reaches the scheduler.
  */
-export function createSchedulerQueryScope({ getTypes, onError }) {
+export function createSchedulerQueryScope({ getTypes, onError, onSchedulerQuery }) {
   const wrapped = new WeakSet();
   return {
     wrap(pattern) {
@@ -169,6 +181,13 @@ export function createSchedulerQueryScope({ getTypes, onError }) {
         if (controls === null || typeof controls !== 'object' || typeof controls.cyclist !== 'string') {
           return original.call(this, begin, end, controls);
         }
+        if (typeof onSchedulerQuery === 'function') {
+          try {
+            onSchedulerQuery();
+          } catch (err) {
+            console.error('Moontide: the hook on the scheduler query failed:', err);
+          }
+        }
         const { State, TimeSpan } = getTypes();
         try {
           return this.query(new State(new TimeSpan(begin, end), controls));