moontide-mcp 2.0.2 → 2.2.0

package/page/takeover.js

@@ -64,7 +64,7 @@ export function gatePattern(oldPattern, newPattern, boundary, { TimeSpan, leadCy
  * The waiting change of the page: one record at most (a newer change replaces it, last wins). The factory
  * only keeps the record and calls the injected hooks; the page decides what follows the takeover.
  *   getScheduler() -> the scheduler (started, pattern, cps, lastEnd), getTypes() -> { TimeSpan },
- *   getTiming() -> the parsed timing of the change being evaluated ({ at, lineLength }),
+ *   getTiming() -> the parsed timing of the change being evaluated ({ at, lineLength }, plus atCycle when the change is written for one given line),
  *   getCps() -> the tempo that plays now (cycles per second), for the line and the lead hook; the scheduler's own cps
  *   by default, but a program's setcps has already reached the scheduler when a change is armed, so the page gives the
  *   tempo from before the evaluation,
@@ -138,18 +138,29 @@ export function createTakeover({
   }
 
   return {
-    /** null when the change takes over at once; otherwise { boundary }. Changes no state. */
+    /**
+     * null when the change takes over at once; otherwise { boundary }. A timing that carries `atCycle` (a change written
+     * for one given line, see pinnedTiming) takes that line while it is still at least MIN_TAKEOVER_LEAD_SECONDS ahead
+     * of the scheduler frontier: { boundary: atCycle, pinned: true }; once it is closer, the next line of the timing's
+     * own length is taken and the result says { pinned: false }, so the caller can write its change again for that line.
+     * Changes no state.
+     */
     plan() {
       const timing = getTiming();
       if (timing.at === 'now' || !isPlaying()) return null;
       const scheduler = getScheduler();
+      const cps = getCps();
+      const pinnedLine = timing.atCycle;
+      if (pinnedLine !== undefined && (pinnedLine - scheduler.lastEnd) / cps >= MIN_TAKEOVER_LEAD_SECONDS) {
+        return { boundary: pinnedLine, pinned: true };
+      }
       const boundary = boundaryCycle({
         frontier: scheduler.lastEnd,
-        cps: getCps(),
+        cps,
         lineLength: timing.lineLength,
         minLeadSeconds: MIN_TAKEOVER_LEAD_SECONDS,
       });
-      return { boundary };
+      return pinnedLine === undefined ? { boundary } : { boundary, pinned: false };
     },
 
     /**
@@ -242,7 +253,11 @@ export function createTakeover({
       record.finishers.push(fn);
     },
 
-    /** Drops the waiting record (no-op without one); its continuations never run. */
+    /**
+     * Drops the waiting record (no-op without one); its continuations never run. `reason` says why: 'stop' (the sound
+     * stopped), 'replaced' (a newer change took its place), 'superseded' and 'unload' (this tab lost its role or closes) and
+     * 'canceled', the person's own cancel of a waiting section launch.
+     */
     cancel,
 
     /** The poll fallback: finishes the waiting record when the scheduler's cycle has reached its boundary. */

package/page/tempo-glide.js

@@ -0,0 +1,330 @@
+// A tempo ramp for Moontide's browser page: the tempo moves in small steps from the tempo that plays to the tempo
+// the code sets, over a number of bars. No DOM access at import time, so node:test can import it.
+
+// Why the page owns the ramp. setcps and setcpm read their value once, when the code runs, so a ramp cannot live in
+// the code; it has to be a series of tempo steps made by the page.
+//
+// Why the plan is in cycles. The steps follow the music's own position (the cycle the scheduler has queried up to),
+// never the wall clock, so a scheduler that stalls or is throttled stalls the ramp with it, and the ramp always
+// ends exactly on the cycle it was planned for.
+//
+// How a step is taken. The driver hooks the scheduler's own queries: every query the scheduler makes asks it to look at
+// the music's position, and about 25 ms later it sets the step of that position. The wait matters. The scheduler takes a
+// new tempo over at its next tick, and the page's MIDI clock reads the takeover on its own 10 ms passes; a step set in
+// the very task of the tick that took the previous step over would replace that takeover before the clock could read
+// it, and the clock would drift from the music. A step 25 ms after the tick leaves every takeover in place for at
+// least two clock passes. At most one step is set for each pair of scheduler ticks (about 100 ms), which is also the
+// finest the scheduler can follow.
+//
+// Steps reach the scheduler only through the injected `apply`, which the page backs with the tempo guard, so a step is
+// never recorded as the tempo a program asked for.
+
+import { BEATS_PER_CYCLE } from './change-timing.js';
+
+// The shortest and longest ramp, in whole bars (one bar is one cycle). src/protocol.ts mirrors both by hand, and a test
+// checks both sides.
+export const MIN_GLIDE_BARS = 1;
+export const MAX_GLIDE_BARS = 64;
+// No step lasts less than this at the fastest tempo of the ramp.
+export const GLIDE_STEP_SECONDS = 0.1;
+// No step is finer than this in BPM, the one decimal the tempo readout shows.
+export const GLIDE_FINEST_STEP_BPM = 0.1;
+// How long after the scheduler query that found a step the step is set.
+export const GLIDE_APPLY_DELAY_MS = 25;
+
+// Cycle positions and tempo distances are floats; a boundary or a count within this of a whole number counts as it.
+const TOLERANCE = 1e-9;
+
+const bpmOfCps = (cps) => cps * 60 * BEATS_PER_CYCLE;
+
+function requireCps(name, value) {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
+    throw new Error(`Moontide: the ramp's ${name} must be a finite tempo above 0, got ${String(value)}.`);
+  }
+}
+
+/**
+ * The number of bars of a ramp: undefined (no ramp asked for) gives null, a whole number from MIN_GLIDE_BARS to
+ * MAX_GLIDE_BARS gives itself, and anything else throws a `Moontide:` Error naming the value.
+ */
+export function parseGlideBars(value) {
+  if (value === undefined) return null;
+  if (typeof value !== 'number' || !Number.isInteger(value) || value < MIN_GLIDE_BARS || value > MAX_GLIDE_BARS) {
+    const shown = typeof value === 'string' ? JSON.stringify(value) : String(value);
+    throw new Error(`Moontide: glideBars ${shown} is not a whole number from ${MIN_GLIDE_BARS} to ${MAX_GLIDE_BARS}.`);
+  }
+  return value;
+}
+
+/**
+ * The plan of a ramp from `fromCps` to `toCps` over `bars` bars, starting at the cycle `startCycle`. Returns a frozen
+ * { fromCps, toCps, bars, startCycle, endCycle, steps } (endCycle is startCycle + bars). The number of steps follows
+ * from the distance and the length, never from a timer: the most that keeps every step at least GLIDE_STEP_SECONDS
+ * long at the fastest tempo of the ramp, but no more than keeps every step at least GLIDE_FINEST_STEP_BPM wide, and
+ * at least one. Throws a `Moontide:` Error for a tempo that is not finite and above 0, equal tempos, a number of bars
+ * parseGlideBars refuses, or a start cycle that is not finite.
+ */
+export function planGlide({ fromCps, toCps, bars, startCycle }) {
+  requireCps('start tempo', fromCps);
+  requireCps('end tempo', toCps);
+  if (fromCps === toCps) {
+    throw new Error('Moontide: a ramp needs two different tempos, but the start and the end tempo are equal.');
+  }
+  if (bars === undefined || parseGlideBars(bars) === null) {
+    throw new Error('Moontide: a ramp needs a number of bars.');
+  }
+  if (typeof startCycle !== 'number' || !Number.isFinite(startCycle)) {
+    throw new Error(`Moontide: a ramp needs a finite start cycle, got ${String(startCycle)}.`);
+  }
+  const distanceBpm = Math.abs(bpmOfCps(toCps) - bpmOfCps(fromCps));
+  const byLength = Math.floor(bars / (GLIDE_STEP_SECONDS * Math.max(fromCps, toCps)) + TOLERANCE);
+  const byDistance = Math.floor(distanceBpm / GLIDE_FINEST_STEP_BPM + TOLERANCE);
+  const steps = Math.max(1, Math.min(byLength, byDistance));
+  return Object.freeze({ fromCps, toCps, bars, startCycle, endCycle: startCycle + bars, steps });
+}
+
+/**
+ * The whole step number, 0 to `plan.steps`, that plays at `cycle`: 0 before the first boundary, `steps` from the end
+ * of the ramp on. Step k begins at startCycle + bars * k / steps; a cycle exactly on a boundary counts as that step.
+ */
+export function glideStepAt(plan, cycle) {
+  if (typeof cycle !== 'number' || !Number.isFinite(cycle)) {
+    throw new Error(`Moontide: a ramp step is read at a finite cycle, got ${String(cycle)}.`);
+  }
+  const reached = Math.floor(((cycle - plan.startCycle + TOLERANCE) * plan.steps) / plan.bars);
+  return Math.min(plan.steps, Math.max(0, reached));
+}
+
+/**
+ * The tempo of step `k` (whole, 0 to `plan.steps`): the start tempo for 0, the end tempo itself for the last step, so
+ * no float drift is left after the ramp, and linear in BPM between.
+ */
+export function glideCpsOf(plan, k) {
+  if (typeof k !== 'number' || !Number.isInteger(k) || k < 0 || k > plan.steps) {
+    throw new Error(`Moontide: a ramp of ${plan.steps} steps has no step ${String(k)}.`);
+  }
+  if (k === 0) return plan.fromCps;
+  if (k === plan.steps) return plan.toCps;
+  return plan.fromCps + ((plan.toCps - plan.fromCps) * k) / plan.steps;
+}
+
+/**
+ * The seconds the music takes to play the cycles from `fromCycle` to `toCycle` while the ramp of `plan` moves the tempo: 0
+ * when `toCycle` is not above `fromCycle`, the span divided by the start tempo before the ramp starts and by the end tempo
+ * after it ends, and in between the sum over the steps of the cycles of each divided by the tempo of that step (the same steps
+ * glideStepAt and glideCpsOf name). It is pure and grows with `toCycle`; a span split in two sums to the whole. A cycle that
+ * is not finite throws a `Moontide:` Error.
+ */
+export function glideSeconds(plan, fromCycle, toCycle) {
+  for (const [name, value] of [['first', fromCycle], ['last', toCycle]]) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+      throw new Error(`Moontide: the ${name} cycle of a ramp's time must be finite, got ${String(value)}.`);
+    }
+  }
+  if (toCycle <= fromCycle) return 0;
+  const stepCycles = plan.bars / plan.steps;
+  // Step k plays from startCycle + k * stepCycles to the next boundary; step 0 reaches back and the last step on.
+  const first = Math.max(0, glideStepAt(plan, fromCycle) - 1);
+  const last = Math.min(plan.steps, glideStepAt(plan, toCycle) + 1);
+  let seconds = 0;
+  for (let k = first; k <= last; k++) {
+    const begin = k === 0 ? Number.NEGATIVE_INFINITY : plan.startCycle + k * stepCycles;
+    const end = k === plan.steps ? Number.POSITIVE_INFINITY : plan.startCycle + (k + 1) * stepCycles;
+    const cycles = Math.min(toCycle, end) - Math.max(fromCycle, begin);
+    if (cycles > 0) seconds += cycles / glideCpsOf(plan, k);
+  }
+  return seconds;
+}
+
+/**
+ * The most that the seconds of `glideSeconds` can be wrong because the tempo that plays trails the plan by one step: a step
+ * is set a little after its cycle (a timer after the scheduler's query) and the scheduler takes it over at its next tick, so
+ * on a rising ramp the music runs a little slower than the plan and on a falling ramp a little faster. It is the sum, over
+ * the cycles from `fromCycle` to `toCycle`, of the cycles of each step times how much its seconds per cycle differ from the
+ * step before. 0 when `toCycle` is not above `fromCycle`. Pure; a cycle that is not finite throws a `Moontide:` Error.
+ */
+export function glideLagSeconds(plan, fromCycle, toCycle) {
+  for (const [name, value] of [['first', fromCycle], ['last', toCycle]]) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+      throw new Error(`Moontide: the ${name} cycle of a ramp's lag must be finite, got ${String(value)}.`);
+    }
+  }
+  if (toCycle <= fromCycle) return 0;
+  const stepCycles = plan.bars / plan.steps;
+  const first = Math.max(1, glideStepAt(plan, fromCycle) - 1);
+  const last = Math.min(plan.steps, glideStepAt(plan, toCycle) + 1);
+  let seconds = 0;
+  // The lag is one step long: the end tempo is reached one step late, then the lag is over.
+  for (let k = first; k <= last; k++) {
+    const begin = plan.startCycle + k * stepCycles;
+    const end = plan.startCycle + (k + 1) * stepCycles;
+    const cycles = Math.min(toCycle, end) - Math.max(fromCycle, begin);
+    if (cycles > 0) seconds += cycles * Math.abs(1 / glideCpsOf(plan, k - 1) - 1 / glideCpsOf(plan, k));
+  }
+  return seconds;
+}
+
+/**
+ * What a change that waited for its bar or phrase line does to the tempo when its line is reached, as one word:
+ * - a change that asks for a ramp: 'start-glide' (the ramp starts at the line from the tempo that plays then);
+ * - a ramp runs and the change states its target: 'keep' (nothing is applied, the step that plays stays);
+ * - a ramp runs and the change states no tempo: 'cancel-no-tempo' (the ramp ends, the tempo stays);
+ * - a ramp runs and the change states another tempo: 'cancel-and-apply' (that tempo applies at once, the ramp ends);
+ * - no ramp runs: 'apply' for a stated tempo and 'nothing' for none (the usual path of a waiting change).
+ * `newCps` is the tempo the waiting code stated, or null. The target is compared with `===`: it came from the same
+ * program text as the target of the ramp, so a program that restates it yields the same number, and no rounding to
+ * a BPM enters the rule. A change that asks for a ramp must state a tempo (a finite number above 0), or this throws.
+ */
+export function lineTempoAction({ running, targetCps, newCps, startsGlide }) {
+  if (startsGlide) {
+    requireCps('target tempo', newCps);
+    return 'start-glide';
+  }
+  if (running) {
+    if (newCps === null) return 'cancel-no-tempo';
+    return newCps === targetCps ? 'keep' : 'cancel-and-apply';
+  }
+  return newCps === null ? 'nothing' : 'apply';
+}
+
+/**
+ * The words of the three refusals of a change that asks for a ramp it cannot make. Each says that nothing was changed.
+ */
+export const GLIDE_REFUSALS = Object.freeze({
+  nothingPlays:
+    'Nothing plays, so there is no tempo to ramp from. Nothing was changed. Send the change again without glideBars.',
+  noTempo:
+    'The code sets no tempo with setcps or setcpm, so there is nothing to ramp to. Nothing was changed.',
+  sameTempo:
+    'The code sets the tempo that already plays, so there is nothing to ramp. Nothing was changed.',
+});
+
+/**
+ * The driver of one ramp at a time. `scheduler` is read for `cps`, `lastEnd` (the cycle a new tempo starts at) and
+ * `started`; `apply(cps)` sets a tempo (the page's tempo guard); `setTimer` and `clearTimer` are the page's timers.
+ * `onEvent` hears { kind: 'started', plan }, { kind: 'finished', plan } and { kind: 'canceled', reason, plan, cps }
+ * (`cps` is the scheduler's tempo when the ramp was canceled); `onError(text, err)` hears an error once for each text.
+ * Returns:
+ * - `start({ fromCps, toCps, bars, startCycle })`: plans the ramp (a refusal throws and changes nothing), cancels a
+ *   running one with the reason 'replaced' first, and returns the plan;
+ * - `onSchedulerQuery()`: called on every query the scheduler itself makes; it never throws;
+ * - `cancel(reason)`: ends the ramp where it is and returns true, or returns false when none runs;
+ * - `running()`, `current()` (null or a frozen { ...plan, applied, stepCps }) and `targetCps()` (null or the end tempo);
+ * - `runs(plan)`: whether `plan` (as `start` returned it) is the ramp that runs now; false once it finished, was canceled
+ *   or was replaced, and for anything that is not such a plan. A report of a ramp goes to the server only while this is
+ *   true, so every end of that ramp is told after the report and the server's record of it can always be cleared;
+ * - `secondsBetween(fromCycle, toCycle)`: the seconds of the music between two cycles through the ramp's own tempo
+ *   (glideSeconds on the running plan), null with no ramp;
+ * - `lagSecondsBetween(fromCycle, toCycle)`: how far that can be off when the tempo trails the plan by a step
+ *   (glideLagSeconds on the running plan), null with no ramp;
+ * - `fastestCps()`: the fastest tempo the ramp still reaches, the larger of the step that plays and the end tempo, null with
+ *   no ramp;
+ * - `barsLeft(cycle)`: the bars to the end of the ramp at `cycle`, rounded up, never below 1 and never above the ramp's
+ *   length, null with no ramp.
+ */
+export function createTempoGlide({ scheduler, apply, setTimer, clearTimer, onEvent = () => {}, onError = (text, err) => console.error(text, err) }) {
+  if (scheduler === null || typeof scheduler !== 'object' || typeof scheduler.cps !== 'number') {
+    throw new Error('Moontide: the tempo ramp needs a scheduler with a numeric cps.');
+  }
+  for (const [name, fn] of [['apply', apply], ['setTimer', setTimer], ['clearTimer', clearTimer]]) {
+    if (typeof fn !== 'function') throw new Error(`Moontide: the tempo ramp needs a ${name} function.`);
+  }
+  let ramp = null; // { plan, applied } while a ramp runs
+  let pending = false;
+  let timer = null;
+  const reported = new Set();
+
+  const report = (text, err) => {
+    if (reported.has(text)) return;
+    reported.add(text);
+    try {
+      onError(text, err);
+    } catch {
+      // Reporting must not be able to break the scheduler either.
+    }
+  };
+  const emit = (event) => {
+    try {
+      onEvent(event);
+    } catch (err) {
+      report('Moontide: a tempo ramp listener failed:', err);
+    }
+  };
+  const clearPending = () => {
+    if (pending) clearTimer(timer);
+    pending = false;
+    timer = null;
+  };
+
+  function cancel(reason) {
+    if (ramp === null) return false;
+    const { plan } = ramp;
+    ramp = null;
+    clearPending();
+    emit({ kind: 'canceled', reason, plan, cps: scheduler.cps });
+    return true;
+  }
+
+  function fire(mine) {
+    pending = false;
+    timer = null;
+    try {
+      if (ramp !== mine) return;
+      if (scheduler.started === false) return;
+      if (typeof scheduler.lastEnd !== 'number' || !Number.isFinite(scheduler.lastEnd)) return;
+      const k = glideStepAt(mine.plan, scheduler.lastEnd);
+      if (k > mine.applied) {
+        apply(glideCpsOf(mine.plan, k));
+        mine.applied = k;
+      }
+      if (mine.applied >= mine.plan.steps) {
+        ramp = null;
+        emit({ kind: 'finished', plan: mine.plan });
+      }
+    } catch (err) {
+      cancel('error');
+      report(`Moontide: a tempo ramp step failed, so the ramp was canceled: ${err instanceof Error ? err.message : String(err)}`, err);
+    }
+  }
+
+  return {
+    start(input) {
+      const plan = planGlide(input);
+      cancel('replaced');
+      ramp = { plan, applied: 0 };
+      emit({ kind: 'started', plan });
+      return plan;
+    },
+    onSchedulerQuery() {
+      try {
+        if (ramp === null || pending) return;
+        const mine = ramp;
+        pending = true;
+        timer = setTimer(() => fire(mine), GLIDE_APPLY_DELAY_MS);
+      } catch (err) {
+        pending = false;
+        timer = null;
+        report('Moontide: the tempo ramp could not follow the scheduler:', err);
+      }
+    },
+    cancel,
+    running: () => ramp !== null,
+    runs: (plan) => ramp !== null && ramp.plan === plan,
+    current() {
+      if (ramp === null) return null;
+      return Object.freeze({ ...ramp.plan, applied: ramp.applied, stepCps: glideCpsOf(ramp.plan, ramp.applied) });
+    },
+    targetCps: () => (ramp === null ? null : ramp.plan.toCps),
+    secondsBetween: (fromCycle, toCycle) => (ramp === null ? null : glideSeconds(ramp.plan, fromCycle, toCycle)),
+    lagSecondsBetween: (fromCycle, toCycle) => (ramp === null ? null : glideLagSeconds(ramp.plan, fromCycle, toCycle)),
+    fastestCps: () => (ramp === null ? null : Math.max(glideCpsOf(ramp.plan, ramp.applied), ramp.plan.toCps)),
+    barsLeft(cycle) {
+      if (typeof cycle !== 'number' || !Number.isFinite(cycle)) {
+        throw new Error(`Moontide: the bars left of a ramp are read at a finite cycle, got ${String(cycle)}.`);
+      }
+      if (ramp === null) return null;
+      const { plan } = ramp;
+      return Math.min(plan.bars, Math.max(1, Math.ceil(plan.endCycle - cycle - TOLERANCE)));
+    },
+  };
+}

package/page/tempo-guard.js

@@ -19,10 +19,11 @@
 // scheduler.cps while it builds the pattern).
 
 /**
- * Wraps `scheduler.setCps`. Call `begin()` before an evaluation and `end(failed, { hold })` after it: when
- * `failed` is true, or `hold` is true, and the evaluation changed the tempo, the tempo from before it is
- * asked of the scheduler again. `end` returns `{ requested }`: the tempo the program asked for (the
- * scheduler's cps read before any restore), or undefined when it failed or never called `setCps`.
+ * Wraps `scheduler.setCps`. Call `begin()` before an evaluation and `end(failed, { hold, startsGlide })` after it: when
+ * `failed` is true, or `hold` or `startsGlide` is true, and the evaluation changed the tempo, the tempo from before it is
+ * asked of the scheduler again. `end` returns `{ requested, glide }`: `requested` is the tempo the program asked for (the
+ * scheduler's cps read before any restore), or undefined when it failed or never called `setCps`; `glide` says what the
+ * evaluation did to a running tempo ramp: 'none' (no ramp ran), 'kept', 'other-tempo' or 'no-tempo' (the ramp was canceled).
  * `apply(cps)` sets a tempo through the raw setter without touching an open evaluation's requested value; the applied
  * tempo becomes the tempo that evaluation restores on a failure or a hold, and an immediate success whose program set
  * its own tempo before the apply keeps the program's tempo.
@@ -30,8 +31,23 @@
  * `cps` when the evaluation begins, because that is the tempo that plays: the page's scheduler is the
  * pinned Cyclist, whose `setCps` takes effect at once, and whose tick also sets `cps` itself when a hap
  * carries a `cps` control, a change that never went through `setCps`.
+ *
+ * With a `glide` (the tempo ramp: `running()`, `targetCps()`, `cancel(reason)`), the end of every evaluation decides what
+ * happens to a ramp that runs, in this order of who wins:
+ * - a failed evaluation changes nothing: the step that played comes back and the ramp goes on;
+ * - a change that waits for its line (`hold`) leaves the ramp alone and the step stays; its line decides later;
+ * - a change that asks for a new ramp (`startsGlide`) gets the step that played back, and the caller replaces the ramp
+ *   with one that starts from it;
+ * - a program that states the ramp's own target (the same number, since both came from the same program text) keeps
+ *   the ramp, and the step that played is put back in the same task, so each of several evaluations in a row (a Mixer
+ *   drag) ends on the step;
+ * - a program that states another tempo wins at once: its tempo stands and the ramp is canceled;
+ * - a program that states no tempo cancels the ramp, and the tempo stays where the ramp was.
+ * The program's tempo is still forwarded to the scheduler while the program runs: the pinned bundle's `.cpm(n)` reads the
+ * scheduler's cps once, while the program builds its patterns, so a program that sets its tempo first must see it.
+ * The guard takes it back at the end of the same evaluation, in the same task, which a scheduler tick cannot see.
  */
-export function createTempoGuard(scheduler) {
+export function createTempoGuard(scheduler, { glide = null } = {}) {
   const originalSetCps = scheduler.setCps;
   if (typeof originalSetCps !== 'function') {
     throw new Error('Moontide: the scheduler of the pinned @strudel/repl 1.3.0 has no setCps function.');
@@ -39,6 +55,11 @@ export function createTempoGuard(scheduler) {
   if (typeof scheduler.cps !== 'number') {
     throw new Error('Moontide: the scheduler of the pinned @strudel/repl 1.3.0 has no numeric cps, so the tempo that plays cannot be read.');
   }
+  if (glide !== null) {
+    for (const name of ['running', 'targetCps', 'cancel']) {
+      if (typeof glide[name] !== 'function') throw new Error(`Moontide: the tempo ramp given to the tempo guard has no ${name} function.`);
+    }
+  }
   let open = null; // { before, requested } while an evaluation runs; requested stays undefined until setCps is called
   scheduler.setCps = function (cps) {
     if (open !== null) open.requested = cps;
@@ -48,20 +69,51 @@ export function createTempoGuard(scheduler) {
     begin() {
       open = { before: scheduler.cps, requested: undefined };
     },
-    end(failed, { hold = false } = {}) {
+    end(failed, { hold = false, startsGlide = false } = {}) {
       const finished = open;
       open = null;
-      if (finished === null || finished.requested === undefined) return { requested: undefined };
+      if (finished === null) return { requested: undefined, glide: 'none' };
+      const rampRuns = glide !== null && glide.running();
+      // The ramp's target is read before anything is restored or canceled.
+      const target = rampRuns ? glide.targetCps() : null;
+      if (finished.requested === undefined) {
+        // No setCps call: nothing to restore. A step applied during the evaluation already stands.
+        if (!rampRuns) return { requested: undefined, glide: 'none' };
+        if (failed || hold || startsGlide) return { requested: undefined, glide: 'kept' };
+        glide.cancel('no-tempo');
+        return { requested: undefined, glide: 'no-tempo' };
+      }
       // The tempo the program asked for is read before any restore; it also covers a tempo set another way.
       // An apply during the evaluation is not the program's own tempo, so then the last setCps value stands.
       const requested = failed ? undefined : finished.applied ? finished.requested : scheduler.cps;
       // `before` is the tempo that plays when the evaluation ends: an apply during it (a waiting change reaching its
       // line) moved it to the applied tempo, so a failed or held evaluation restores that one, never the older one.
-      if (failed || hold) originalSetCps.call(scheduler, finished.before);
+      if (failed || hold || startsGlide) {
+        originalSetCps.call(scheduler, finished.before);
+        return { requested, glide: rampRuns ? 'kept' : 'none' };
+      }
+      if (rampRuns && requested === target) {
+        // The same target again: the ramp goes on and the step that played is put back in this task.
+        if (scheduler.cps !== finished.before) originalSetCps.call(scheduler, finished.before);
+        return { requested, glide: 'kept' };
+      }
       // An immediate success whose program set its own tempo before an apply: the program's tempo is the one that
       // plays and the one the reply reports, so it is put back over the applied one.
-      else if (finished.applied && scheduler.cps !== finished.requested) originalSetCps.call(scheduler, finished.requested);
-      return { requested };
+      if (finished.applied && scheduler.cps !== finished.requested) originalSetCps.call(scheduler, finished.requested);
+      if (rampRuns) {
+        // Another tempo written in the code always wins; the cancel reads the tempo that plays after it.
+        glide.cancel('other-tempo');
+        return { requested, glide: 'other-tempo' };
+      }
+      return { requested, glide: 'none' };
+    },
+    /**
+     * The tempo the open evaluation's program has asked for so far, or undefined when no evaluation is open or the program
+     * has not called setCps yet. The page reads it at the moment a pattern is handed over, to refuse a ramp with no tempo
+     * to ramp to or one that would not move.
+     */
+    requestedSoFar() {
+      return open !== null ? open.requested : undefined;
     },
     /**
      * The tempo that plays: while an evaluation is open the scheduler's cps already holds the tempo the program set