@ugfoundation/swaralipi-js 0.12.0 → 0.13.1

package/dist/player/index.cjs

@@ -145,9 +145,305 @@ function rowLay(row) {
   return row.lay ?? printedLay(row.notes);
 }
 
-// src/player/schedule.ts
+// src/convert/codec.ts
+var LETTERS = {
+  s: { letter: "s" },
+  r: { letter: "r" },
+  g: { letter: "g" },
+  m: { letter: "m" },
+  p: { letter: "p" },
+  q: { letter: "d" },
+  // ধ — shuddha dha
+  n: { letter: "n" },
+  d: { letter: "d", komal: true },
+  // দ
+  t: { letter: "g", komal: true },
+  // জ্ঞ
+  k: { letter: "m", tivra: true },
+  // ক্ষ
+  u: { letter: "n", komal: true },
+  // ণ
+  v: { letter: "r", komal: true }
+  // ঋ
+};
+var STRUCTURALS = {
+  "%": () => ({ svara: ["madhyam", "s"] }),
+  // precomposed সা
+  "&": () => ({ svara: ["madhyam", "n"] })
+  // precomposed নি
+};
+var BAR_RUN_RE = /^(-)?([lLA[\]]+)$/;
+function decodeBarRun(body) {
+  const m = body.match(BAR_RUN_RE);
+  if (!m || !/[lLA]/.test(m[2])) return void 0;
+  const notes = [];
+  if (m[1]) notes.push({ sustain: true });
+  const run = m[2];
+  let i = 0;
+  while (i < run.length) {
+    const ch = run[i];
+    if (ch === "l" || ch === "L") {
+      let j = i;
+      while (j < run.length && run[j] === ch) j++;
+      const strokes = (j - i) * (ch === "L" ? 2 : 1);
+      notes.push({ bar: strokes >= 4 ? "quad" : strokes >= 2 ? "double" : "single" });
+      i = j;
+    } else if (ch === "A") {
+      notes.push({ bar: "dari" });
+      i++;
+    } else {
+      notes.push({ brackets: [{ kind: "alt", edge: ch === "[" ? "open" : "close" }] });
+      i++;
+    }
+  }
+  return notes;
+}
+var KNOWN_RAW_RE = [
+  /^[wxyjEJ$<>=_]+$/,
+  // arc & line drawing segments
+  /^\|+$/,
+  // thin yugal-dari stop mark
+  /^[0-9!@#]{1,2}[fF]?:?$/,
+  // beat-number labels incl. 10–16 (sam tick = f/F, e.g. 1f / 1F / 2:)
+  /^[oOe`+,.;:iI~^*bcBCWXYFHZz'"?]$/
+  // dots, ticks, duration marks, legacy forms
+];
+var OPEN_BRACKETS = {
+  "{": "repeat",
+  "(": "skip",
+  "[": "alt"
+};
+var CLOSE_BRACKETS = {
+  "}": "repeat",
+  ")": "skip",
+  "]": "alt"
+};
+function octaveOf(mark) {
+  if (mark === "f" || mark === "F") return "taar";
+  if (mark === "h" || mark === "H") return "mandra";
+  return "madhyam";
+}
+var BODY_RE = /^([0-9!@][fF]?)?([zj]*)(-)?([i:])?(?:([SRGMPQNDTKUV])([fFhH])?)?((?:[srgmpqndtkuv][fh]?[i:]?)+)?(a)?([fh])?([i:])?(?:([SRGMPQNDTKUV])([fFhH])?)?([0-9!@][fF]?)?(-)?$/;
+function decodeChunk(chunk) {
+  const opens = [];
+  const closes = [];
+  let body = chunk;
+  while (body.length > 0) {
+    const kind = OPEN_BRACKETS[body[0]];
+    if (kind === void 0) break;
+    opens.push(kind);
+    body = body.slice(1);
+  }
+  while (body.length > 0) {
+    const kind = CLOSE_BRACKETS[body[body.length - 1]];
+    if (kind === void 0) break;
+    closes.unshift(kind);
+    body = body.slice(0, -1);
+  }
+  const finish = (notes, kind) => {
+    if (notes.length === 0) notes.push({});
+    const first = notes[0];
+    const last = notes[notes.length - 1];
+    if (opens.length > 0) first.brackets = [...opens.map((kind_) => ({ kind: kind_, edge: "open" })), ...first.brackets ?? []];
+    if (closes.length > 0) last.brackets = [...last.brackets ?? [], ...closes.map((kind_) => ({ kind: kind_, edge: "close" }))];
+    return { notes, kind };
+  };
+  if (body === "") return finish([{}], "decoded");
+  const barRun = decodeBarRun(body);
+  if (barRun) return finish(barRun, "decoded");
+  const structural = STRUCTURALS[body];
+  if (structural) return finish([structural()], "decoded");
+  if (KNOWN_RAW_RE.some((re) => re.test(body))) return finish([{}], "known");
+  const m = body.match(BODY_RE);
+  if (m) {
+    const [, , , hyphen, , kanLetter, kanOct, unitsStr, aakar, postOct, , trailKan, trailKanOct] = m;
+    const attachKan = (note, letter, oct) => {
+      const def = LETTERS[letter.toLowerCase()];
+      note.kan = [octaveOf(oct?.toLowerCase()), def.letter];
+    };
+    if (unitsStr) {
+      const units = unitsStr.match(/[srgmpqndtkuv][fh]?/g) ?? [];
+      const notes = units.map((unit) => {
+        const def = LETTERS[unit[0]];
+        const note = { svara: [octaveOf(unit[1]), def.letter] };
+        if (def.komal) note.komal = true;
+        if (def.tivra) note.tivra = true;
+        if (units.length > 1) note.durationMatra = 1 / units.length;
+        return note;
+      });
+      const last = notes[notes.length - 1];
+      if (postOct && last.svara[0] === "madhyam") {
+        last.svara = [octaveOf(postOct), last.svara[1]];
+      }
+      if (hyphen) notes[0].sustain = true;
+      if (kanLetter) attachKan(notes[0], kanLetter, kanOct);
+      if (trailKan && last.kan === void 0) attachKan(last, trailKan, trailKanOct);
+      return finish(notes, "decoded");
+    }
+    if (aakar) {
+      const note = hyphen ? { sustain: true } : { rest: true };
+      if (trailKan) attachKan(note, trailKan, trailKanOct);
+      else if (kanLetter) attachKan(note, kanLetter, kanOct);
+      return finish([note], "decoded");
+    }
+    if (hyphen && !kanLetter && !trailKan) {
+      return finish([{ sustain: true }], "decoded");
+    }
+  }
+  return finish([{}], "unknown");
+}
+function decodeCell(text) {
+  const chunks = text.split(/\s+/).filter((c) => c.length > 0);
+  const out = { notes: [], unknownTokens: [], knownRawTokens: [], decoded: false };
+  for (const chunk of chunks) {
+    const { notes, kind } = decodeChunk(chunk);
+    notes[0].raw = chunk;
+    if (kind === "decoded") out.decoded = true;
+    else if (kind === "known") out.knownRawTokens.push(chunk);
+    else out.unknownTokens.push(chunk);
+    out.notes.push(...notes);
+  }
+  return out;
+}
+
+// src/player/repeats.ts
 var UNDECODED_CELL = /[srgmpqnvtduka]/i;
 var isSilent = (n) => n.svara === void 0 && n.rest !== true && n.sustain !== true && !(n.raw !== void 0 && UNDECODED_CELL.test(n.raw));
+var STOP_MARK = /^\|+$/;
+var EPS = 1e-6;
+var edges = (n, kind, edge) => n.brackets?.filter((b) => b.kind === kind && b.edge === edge).length ?? 0;
+var sounds = (n) => n.svara !== void 0 || n.rest === true || n.sustain === true;
+var matra = (notes) => notes.reduce((sum, n) => sum + (n.durationMatra ?? 1), 0);
+function playOrder(doc) {
+  const tokens = [];
+  doc.parts.forEach(
+    (part, p) => part.rows.forEach(
+      (row, r) => row.notes.forEach((note, i) => tokens.push({ p, r, i, note, timed: note.bar === void 0 && !isSilent(note) }))
+    )
+  );
+  const { asthayi, stop, returns } = form(tokens);
+  const changed = changedNotes(tokens);
+  const out = [];
+  let last = -1;
+  const sing = (lo, hi, useChanged) => {
+    const repeats = [];
+    let owed = 0;
+    for (let k = lo; k < hi; ) {
+      const t = tokens[k];
+      if (edges(t.note, "repeat", "open") > 0 && repeats.at(-1)?.open !== k) repeats.push({ open: k, again: false });
+      const again = repeats.at(-1)?.again === true;
+      const skipTo = again && edges(t.note, "skip", "open") > 0 ? skipEnd(tokens, k, hi) : -1;
+      if (skipTo >= 0) {
+        if (edges(tokens[skipTo].note, "repeat", "close") > 0) repeats.pop();
+        k = skipTo + 1;
+        owed = 0;
+        continue;
+      }
+      if (owed > EPS && t.timed) owed -= matra([t.note]);
+      else {
+        const sub = useChanged || again ? changed.get(k) : void 0;
+        const fits = sub !== void 0 && matra(sub) >= matra([t.note]) - EPS;
+        for (const note of fits ? sub : [t.note]) out.push({ p: t.p, r: t.r, i: t.i, note });
+        if (t.timed) last = k;
+        owed = fits ? matra(sub) - matra([t.note]) : 0;
+      }
+      const loop = edges(t.note, "repeat", "close") > 0 ? repeats.at(-1) : void 0;
+      if (loop !== void 0 && !loop.again) {
+        loop.again = true;
+        k = loop.open;
+        owed = 0;
+        continue;
+      }
+      if (loop !== void 0) repeats.pop();
+      k++;
+    }
+  };
+  let from = 0;
+  for (const ret of returns) {
+    sing(from, ret.resume, false);
+    if (last !== stop) sing(asthayi, stop + 1, ret.changed);
+    from = ret.resume;
+  }
+  sing(from, tokens.length, false);
+  return out;
+}
+function form(tokens) {
+  const first = /* @__PURE__ */ new Map();
+  const last = /* @__PURE__ */ new Map();
+  tokens.forEach((t, k) => {
+    if (!t.timed) return;
+    const row = `${t.p}.${t.r}`;
+    if (!first.has(row)) first.set(row, k);
+    last.set(row, k);
+  });
+  const opens = [];
+  let opening = false;
+  tokens.forEach((t, k) => {
+    if (t.note.bar !== "double") return;
+    const row = `${t.p}.${t.r}`;
+    const before = (first.get(row) ?? Infinity) < k;
+    const after = (last.get(row) ?? -1) > k;
+    opening = before !== after ? after : !opening;
+    if (opening) opens.push(k);
+  });
+  const returns = [];
+  for (let k = 0; k < tokens.length; k++) {
+    let at = -1;
+    let open = false;
+    let changed = false;
+    let end = false;
+    for (; k < tokens.length && !tokens[k].timed; k++) {
+      const n = tokens[k].note;
+      if (n.bar === "quad") end = true;
+      if (n.bar === "double" && !opens.includes(k)) at = k;
+      if (edges(n, "alt", "open") > 0) open = true;
+      if (open && edges(n, "alt", "close") > 0) {
+        at = k;
+        changed = true;
+      }
+    }
+    if (at >= 0 && !end) returns.push({ resume: at + 1, changed });
+  }
+  const top = opens[0];
+  const asthayi = top !== void 0 && top < (returns[0]?.resume ?? Infinity) ? top : 0;
+  const asthayiEnd = Math.min(returns[0]?.resume ?? Infinity, opens.find((k) => k > asthayi) ?? Infinity, tokens.length);
+  const lastSung = tokens.reduce((last2, t, k) => t.timed ? k : last2, -1);
+  const stop = tokens.findIndex(
+    (t, k) => k >= asthayi && k < asthayiEnd && k < lastSung && t.note.above?.some((a) => STOP_MARK.test(a.raw ?? "")) === true
+  );
+  return { asthayi, stop, returns: stop < 0 ? [] : returns };
+}
+function changedNotes(tokens) {
+  const out = /* @__PURE__ */ new Map();
+  let row = "";
+  let inside = false;
+  tokens.forEach((t, k) => {
+    if (row !== `${t.p}.${t.r}`) {
+      row = `${t.p}.${t.r}`;
+      inside = false;
+    }
+    const notes = [];
+    for (const above of t.note.above ?? []) {
+      const read = above.raw !== void 0 && !sounds(above) && above.brackets === void 0;
+      for (const a of read ? decodeCell(above.raw).notes : [above]) {
+        if (edges(a, "alt", "open") > 0) inside = true;
+        if (inside && sounds(a)) notes.push(a);
+        if (edges(a, "alt", "close") > 0) inside = false;
+      }
+    }
+    if (notes.length > 0) out.set(k, notes);
+  });
+  return out;
+}
+function skipEnd(tokens, k, hi) {
+  for (let depth = 0, j = k; j < hi; j++) {
+    depth += edges(tokens[j].note, "skip", "open") - edges(tokens[j].note, "skip", "close");
+    if (depth <= 0) return j;
+  }
+  return -1;
+}
+
+// src/player/schedule.ts
 var ARC_RAW_RE = /^[wWxXyYjJeEzZ$=_<>`\\]+$/;
 var isArcRaw = (raw) => raw !== void 0 && ARC_RAW_RE.test(raw);
 var MEEND_MARKS = { start: "w", end: "x", both: "xw" };
@@ -190,26 +486,45 @@ function graceTouches(ev) {
     ...ev.resh.map((midi, g) => ({ midi, beat: ev.beat + GRACE_STEP * (g + 1) }))
   ];
 }
-var rowOf = (path) => path.slice(0, path.lastIndexOf("."));
+var rowOf = (path) => path.split(".").slice(0, 2).join(".");
+var noteOf = (path) => Number(path.split(".")[2] ?? 0);
+var byRow = (a, b) => {
+  const [ap = 0, ar = 0] = a.split(".").map(Number);
+  const [bp = 0, br = 0] = b.split(".").map(Number);
+  return ap - bp || ar - br;
+};
 function scheduleLines(schedule) {
   const lines = [];
+  let note = Infinity;
   schedule.events.forEach((ev, i) => {
-    if (lines.at(-1)?.row !== rowOf(ev.path)) lines.push({ row: rowOf(ev.path), first: i, beat: ev.beat, endBeat: 0 });
+    const n = noteOf(ev.path);
+    if (lines.at(-1)?.row !== rowOf(ev.path) || n < note) lines.push({ row: rowOf(ev.path), first: i, beat: ev.beat, endBeat: 0 });
+    note = n;
   });
   lines.forEach((line, k) => line.endBeat = lines[k + 1]?.beat ?? schedule.totalBeats);
   return lines;
 }
-function eventAt(events, path) {
-  const [p = 0, r = 0, n = 0] = path.split(".").map(Number);
-  const inRow = (ev) => ev !== void 0 && rowOf(ev.path) === `${p}.${r}`;
-  let i = events.findIndex((ev) => {
-    const [ep = 0, er = 0, en = 0] = ev.path.split(".").map(Number);
-    return ep > p || ep === p && (er > r || er === r && en >= n);
+function lineAt(lines, i) {
+  let k = 0;
+  while (k + 1 < lines.length && lines[k + 1].first <= i) k++;
+  return k;
+}
+function lineFor(lines, path, near) {
+  let row;
+  for (const line of lines) if (byRow(line.row, rowOf(path)) >= 0 && (row === void 0 || byRow(line.row, row) < 0)) row = line.row;
+  let best = -1;
+  lines.forEach((line, k) => {
+    if (line.row === row && (best < 0 || Math.abs(k - near) < Math.abs(best - near))) best = k;
   });
-  if (!inRow(events[i])) {
-    const last = (i < 0 ? events.length : i) - 1;
-    if (inRow(events[last])) i = last;
-  }
+  return best;
+}
+function eventAt(events, path, near = -1) {
+  const lines = scheduleLines({ events, totalBeats: 0 });
+  const k = lineFor(lines, path, near < 0 ? -1 : lineAt(lines, near));
+  if (k < 0) return -1;
+  const end = lines[k + 1]?.first ?? events.length;
+  let i = lines[k].first;
+  if (lines[k].row === rowOf(path)) while (i < end - 1 && noteOf(events[i].path) < noteOf(path)) i++;
   while (i > 0 && events[i].glide === true) i--;
   return i;
 }
@@ -221,67 +536,76 @@ function buildSchedule(doc, opts = {}) {
   let cursor = 0;
   let lastPitched = -1;
   let samMatra;
-  let matra = 0;
+  let matra2 = 0;
   const speeds = resolveLaySpeeds(doc.meta.laySpeeds, opts.laySpeeds);
   const withLay = opts.lay !== false;
   const tempo = [{ beat: 0, endBeat: 0, scale: 1, lay: "drut", taal: doc.meta.taal }];
+  const rows = /* @__PURE__ */ new Map();
   let scale = 1;
+  let layNow = "drut";
   let taal = doc.meta.taal;
-  doc.parts.forEach((part, p) => {
-    part.rows.forEach((row, r) => {
+  doc.parts.forEach(
+    (part, p) => part.rows.forEach((row, r) => {
       const lay = withLay ? rowLay(row) : void 0;
-      const layChanged = lay !== void 0 && speeds[lay] !== scale;
-      const nextTaal = row.taal !== void 0 ? row.taal : taal;
-      if (layChanged || !sameTaal(nextTaal, taal)) {
-        if (layChanged) scale = speeds[lay];
-        taal = nextTaal;
-        const last = tempo[tempo.length - 1];
-        const seg = { beat: cursor, endBeat: cursor, scale, lay: layChanged ? lay : last.lay, taal };
+      if (lay !== void 0 && speeds[lay] !== scale) {
+        scale = speeds[lay];
+        layNow = lay;
+      }
+      if (row.taal !== void 0) taal = row.taal;
+      rows.set(`${p}.${r}`, { scale, lay: layNow, taal, glides: meendContinuations(row.notes) });
+    })
+  );
+  const visits = opts.repeats === true ? playOrder(doc) : doc.parts.flatMap((part, p) => part.rows.flatMap((row, r) => row.notes.map((note, i) => ({ p, r, i, note }))));
+  let rowNow = "";
+  for (const { p, r, i, note } of visits) {
+    const row = rows.get(`${p}.${r}`);
+    if (rowNow !== `${p}.${r}`) {
+      rowNow = `${p}.${r}`;
+      const last = tempo[tempo.length - 1];
+      if (row.scale !== last.scale || !sameTaal(row.taal, last.taal)) {
+        const seg = { beat: cursor, endBeat: cursor, scale: row.scale, lay: row.lay, taal: row.taal };
         if (last.beat === cursor) tempo[tempo.length - 1] = seg;
         else {
           last.endBeat = cursor;
           tempo.push(seg);
         }
       }
-      const glides = meendContinuations(row.notes);
-      row.notes.forEach((note, i) => {
-        if (samMatra === void 0 && note.above !== void 0) {
-          for (const a of note.above) {
-            if (a.raw !== void 0 && SAM_TICK.test(a.raw)) {
-              samMatra = matra;
-              break;
-            }
-          }
-        }
-        if (note.bar !== void 0 || isSilent(note)) return;
-        const path = `${p}.${r}.${i}`;
-        const written = note.durationMatra ?? 1;
-        const dur = written / scale;
-        const kan = graceMidis(note.kan, tonicPc, baseOctave);
-        const resh = graceMidis(note.resh, tonicPc, baseOctave);
-        if (note.svara !== void 0) {
-          events.push({
-            beat: cursor,
-            durationBeats: dur,
-            midi: svaraToMidi(note, tonicPc, baseOctave),
-            kan,
-            resh,
-            path,
-            kind: note.sustain === true ? "sustain" : "note",
-            ...glides.has(i) && lastPitched >= 0 ? { glide: true } : {}
-          });
-          lastPitched = events.length - 1;
-        } else if (note.sustain === true) {
-          if (lastPitched >= 0) events[lastPitched].durationBeats += dur;
-          events.push({ beat: cursor, durationBeats: dur, midi: null, kan, resh, path, kind: "sustain" });
-        } else {
-          events.push({ beat: cursor, durationBeats: dur, midi: null, kan, resh, path, kind: "rest" });
+    }
+    if (samMatra === void 0 && note.above !== void 0) {
+      for (const a of note.above) {
+        if (a.raw !== void 0 && SAM_TICK.test(a.raw)) {
+          samMatra = matra2;
+          break;
         }
-        cursor += dur;
-        matra += written;
+      }
+    }
+    if (note.bar !== void 0 || isSilent(note)) continue;
+    const path = `${p}.${r}.${i}`;
+    const written = note.durationMatra ?? 1;
+    const dur = written / row.scale;
+    const kan = graceMidis(note.kan, tonicPc, baseOctave);
+    const resh = graceMidis(note.resh, tonicPc, baseOctave);
+    if (note.svara !== void 0) {
+      events.push({
+        beat: cursor,
+        durationBeats: dur,
+        midi: svaraToMidi(note, tonicPc, baseOctave),
+        kan,
+        resh,
+        path,
+        kind: note.sustain === true ? "sustain" : "note",
+        ...row.glides.has(i) && lastPitched >= 0 ? { glide: true } : {}
       });
-    });
-  });
+      lastPitched = events.length - 1;
+    } else if (note.sustain === true) {
+      if (lastPitched >= 0) events[lastPitched].durationBeats += dur;
+      events.push({ beat: cursor, durationBeats: dur, midi: null, kan, resh, path, kind: "sustain" });
+    } else {
+      events.push({ beat: cursor, durationBeats: dur, midi: null, kan, resh, path, kind: "rest" });
+    }
+    cursor += dur;
+    matra2 += written;
+  }
   const numBeats = tempo[0].taal?.numBeats;
   const pickupMatra = samMatra !== void 0 && numBeats !== void 0 && numBeats > 0 ? (numBeats - samMatra % numBeats) % numBeats : 0;
   tempo[tempo.length - 1].endBeat = cursor;
@@ -589,14 +913,6 @@ var TAAL_MODE_TEMPO = [
   { beat: 0, endBeat: Infinity, scale: 1, lay: "drut" }
 ];
 var MEDIA_LEAD_SEC = 0.25;
-function lineOf(lines, path) {
-  const [p = 0, r = 0] = path.split(".").map(Number);
-  const k = lines.findIndex((line) => {
-    const [lp = 0, lr = 0] = line.row.split(".").map(Number);
-    return lp > p || lp === p && lr >= r;
-  });
-  return k < 0 ? lines.length - 1 : k;
-}
 var seekableGrain = (Tone) => class extends Tone.GrainPlayer {
   _start(time, offset, duration) {
     super._start(time, offset === void 0 ? offset : this.toSeconds(offset) * this.playbackRate, duration);
@@ -657,9 +973,13 @@ var SwaralipiPlayer = class {
   /* Practice: where the playhead is, what repeats, whose turn it is. */
   /** The last note played or sought — what "this line" means to the controls. */
   #cursor = null;
+  /** The cursor as an event index: which pass of a line sung more than once. */
+  #at = -1;
   /** Where the next fresh play() starts (a seek made while stopped). */
   #startAt = null;
   #loop = null;
+  /** The repeat as line indices, the passes it holds. */
+  #span = null;
   #echo = false;
   /** With echo on, every other pass is the learner's: the melody rests. */
   #turn = false;
@@ -685,6 +1005,7 @@ var SwaralipiPlayer = class {
       instruments: options.instruments ?? Object.keys(INSTRUMENTS),
       rhythm: options.rhythm ?? "tabla",
       tanpura: options.tanpura ?? true,
+      repeats: options.repeats ?? true,
       previewLimitSec: options.previewLimitSec ?? Infinity,
       onHighlight: options.onHighlight,
       onLoop: options.onLoop,
@@ -832,22 +1153,25 @@ var SwaralipiPlayer = class {
    */
   seek(path) {
     const plan = this.#plan();
-    const i = plan === void 0 ? -1 : eventAt(plan.schedule.events, path);
-    if (plan === void 0 || i < 0) return;
-    const { lines } = plan;
+    if (plan !== void 0) this.#seekTo(plan, eventAt(plan.schedule.events, path, this.#at));
+  }
+  /** seek(), by event index — the pass, not just the line. */
+  #seekTo(plan, i) {
+    if (i < 0) return;
     const at = plan.schedule.events[i].path;
     this.#cursor = at;
+    this.#at = i;
     this.#turn = false;
-    const k = lineOf(lines, at);
-    const [a, b] = this.#loopSpan(lines);
-    if (this.#loop !== null && (k < a || k > b)) this.#loop = { from: lines[k].row, to: lines[k].row };
+    const k = lineAt(plan.lines, i);
+    const [a, b] = this.#loopSpan();
+    if (this.#span !== null && (k < a || k > b)) this.#setSpan(plan.lines, k, k);
     this.#emitLoop();
     if (this.#timeline !== void 0 && (this.#state === "playing" || this.#state === "paused")) {
       this.#applyLoop();
       this.#jump(this.#eventSec(i));
       if (this.#state === "paused") this.#emitHighlight(at);
     } else {
-      this.#startAt = at;
+      this.#startAt = i;
       this.#emitHighlight(at);
     }
   }
@@ -860,20 +1184,41 @@ var SwaralipiPlayer = class {
   setLoop(from, to) {
     this.#turn = false;
     if (from === null) {
-      this.#loop = null;
+      this.#span = this.#loop = null;
       this.#echo = false;
-    } else {
-      const lines = this.#lines();
-      if (lines.length === 0) return;
-      const here = this.#cursor === null ? -1 : lineOf(lines, this.#cursor);
-      const a = from === void 0 ? Math.max(here, 0) : lineOf(lines, from);
-      const b = to === void 0 ? a : lineOf(lines, to);
-      this.#loop = { from: lines[Math.min(a, b)].row, to: lines[Math.max(a, b)].row };
-      if (here < Math.min(a, b) || here > Math.max(a, b)) return this.seek(this.#loop.from);
+      this.#applyLoop();
+      this.#emitLoop();
+      return;
     }
+    const plan = this.#plan();
+    if (plan === void 0 || plan.lines.length === 0) return;
+    const { lines } = plan;
+    const here = this.#at < 0 ? -1 : lineAt(lines, this.#at);
+    const a = from === void 0 ? Math.max(here, 0) : this.#lineOf(lines, from, here);
+    this.#repeat(plan, a, to === void 0 ? a : this.#lineOf(lines, to, a));
+  }
+  /** Repeat lines a..b (indices, either order); the playhead joins them. */
+  #repeat(plan, a, b) {
+    this.#setSpan(plan.lines, a, b);
+    const [lo, hi] = this.#loopSpan();
+    const here = this.#at < 0 ? -1 : lineAt(plan.lines, this.#at);
+    if (here < lo || here > hi) return this.#seekTo(plan, plan.lines[lo].first);
     this.#applyLoop();
     this.#emitLoop();
   }
+  /** The repeat's passes, and the rows they cover for the sheet's shading —
+   * written order, since a span can cross a jump back to an earlier row. */
+  #setSpan(lines, a, b) {
+    this.#span = [Math.min(a, b), Math.max(a, b)];
+    const rows = lines.slice(this.#span[0], this.#span[1] + 1).map((line) => line.row).sort(byRow);
+    this.#loop = { from: rows[0], to: rows.at(-1) };
+  }
+  /** The line `path` names, at its pass nearest line `near`; the last line
+   * when nothing sounds from there on. */
+  #lineOf(lines, path, near) {
+    const k = lineFor(lines, path, near);
+    return k < 0 ? lines.length - 1 : k;
+  }
   /**
    * Follow every pass of the repeat with a silent one: the tabla and tanpura
    * keep time and the highlight keeps moving, but the melody rests so the
@@ -895,22 +1240,22 @@ var SwaralipiPlayer = class {
     const plan = this.#plan();
     if (plan === void 0 || plan.lines.length === 0) return;
     const { lines, schedule } = plan;
-    const k = this.#cursor === null ? -1 : lineOf(lines, this.#cursor);
-    const into = k < 0 ? 0 : schedule.events[eventAt(schedule.events, this.#cursor)].beat - lines[k].beat;
+    const k = this.#at < 0 ? -1 : lineAt(lines, this.#at);
+    const into = k < 0 ? 0 : schedule.events[this.#at].beat - lines[k].beat;
     const step = delta < 0 && this.#state === "playing" && into > 1 ? delta + 1 : delta;
-    this.seek(lines[Math.min(Math.max(k + step, 0), lines.length - 1)].row);
+    this.#seekTo(plan, lines[Math.min(Math.max(k + step, 0), lines.length - 1)].first);
   }
   /** Move by single notes (rests and holds included — each is a column). */
   stepNote(delta) {
-    const events = this.#plan()?.schedule.events ?? [];
-    let i = this.#cursor === null ? -1 : eventAt(events, this.#cursor);
+    const plan = this.#plan();
+    const events = plan?.schedule.events ?? [];
+    let i = this.#at;
     for (let left = Math.abs(delta); left > 0; left--) {
       do
         i += Math.sign(delta);
       while (events[i]?.glide === true);
     }
-    const ev = events[Math.min(Math.max(i, 0), events.length - 1)];
-    if (ev !== void 0) this.seek(ev.path);
+    if (plan !== void 0 && events.length > 0) this.#seekTo(plan, Math.min(Math.max(i, 0), events.length - 1));
   }
   /**
    * Stop and rewind to the start. When sounding, the accompaniment (tabla /
@@ -1105,21 +1450,21 @@ var SwaralipiPlayer = class {
   }
   /** Grow the repeat (or start one from the current line) to take in `path`'s line. */
   #extendLoop(path) {
-    const lines = this.#lines();
-    if (lines.length === 0) return;
-    const k = lineOf(lines, path);
-    const here = this.#cursor === null ? k : lineOf(lines, this.#cursor);
-    const [a, b] = this.#loop === null ? [here, here] : this.#loopSpan(lines);
-    this.setLoop(lines[Math.min(a, k)].row, lines[Math.max(b, k)].row);
+    const plan = this.#plan();
+    if (plan === void 0 || plan.lines.length === 0) return;
+    const here = this.#at < 0 ? -1 : lineAt(plan.lines, this.#at);
+    const k = this.#lineOf(plan.lines, path, here);
+    const [a, b] = this.#span ?? (here < 0 ? [k, k] : [here, here]);
+    this.#repeat(plan, Math.min(a, k), Math.max(b, k));
   }
   /** Shift+↑/↓: one more line above / below the repeat. */
   #extendBy(delta) {
-    const lines = this.#lines();
-    if (lines.length === 0) return;
-    const here = this.#cursor === null ? 0 : lineOf(lines, this.#cursor);
-    const [a, b] = this.#loop === null ? [here, here] : this.#loopSpan(lines);
-    const k = Math.min(Math.max((delta < 0 ? a : b) + delta, 0), lines.length - 1);
-    this.#extendLoop(lines[k].row);
+    const plan = this.#plan();
+    if (plan === void 0 || plan.lines.length === 0) return;
+    const here = this.#at < 0 ? 0 : lineAt(plan.lines, this.#at);
+    const [a, b] = this.#span ?? [here, here];
+    const k = Math.min(Math.max((delta < 0 ? a : b) + delta, 0), plan.lines.length - 1);
+    this.#repeat(plan, Math.min(a, k), Math.max(b, k));
   }
   /**
    * Check whether an instrument's samples are reachable (its CDN is up / the
@@ -1179,7 +1524,8 @@ var SwaralipiPlayer = class {
   }
   /** A new document starts with nothing repeated, from the top. */
   #resetPractice() {
-    this.#cursor = this.#startAt = this.#loop = null;
+    this.#cursor = this.#startAt = this.#loop = this.#span = null;
+    this.#at = -1;
     this.#echo = this.#turn = false;
     this.#listened = 0;
     this.#emitLoop();
@@ -1193,12 +1539,9 @@ var SwaralipiPlayer = class {
     const schedule = buildSchedule(this.#doc, this.#scheduleOpts());
     return { schedule, lines: scheduleLines(schedule) };
   }
-  #lines() {
-    return this.#plan()?.lines ?? [];
-  }
   /** The repeat as line indices (`[0, -1]`, i.e. empty, when off). */
-  #loopSpan(lines) {
-    return this.#loop === null ? [0, -1] : [lineOf(lines, this.#loop.from), lineOf(lines, this.#loop.to)];
+  #loopSpan() {
+    return this.#span ?? [0, -1];
   }
   /** The repeat's lines on the arranged timeline, cached for the per-note
    * checks (#hears), which run on every note. */
@@ -1227,8 +1570,8 @@ var SwaralipiPlayer = class {
   #applyLoop() {
     const transport = this.#tone?.getTransport();
     if (transport === void 0 || this.#timeline === void 0) return;
-    this.#loopLines = this.#loopSpan(this.#timeline.lines);
-    if (this.#loop === null) {
+    this.#loopLines = this.#loopSpan();
+    if (this.#span === null) {
       transport.loop = false;
       return;
     }
@@ -1239,8 +1582,8 @@ var SwaralipiPlayer = class {
    * else the top. */
   #startSec() {
     const events = this.#timeline?.schedule.events ?? [];
-    if (this.#startAt !== null) return this.#eventSec(Math.max(eventAt(events, this.#startAt), 0));
-    return this.#loop === null ? 0 : this.#loopSec()[0];
+    if (this.#startAt !== null) return this.#eventSec(Math.min(this.#startAt, events.length - 1));
+    return this.#span === null ? 0 : this.#loopSec()[0];
   }
   /** Move the transport; notes still ringing from the old place are let go. */
   #jump(sec) {
@@ -1329,7 +1672,8 @@ var SwaralipiPlayer = class {
     return {
       tonic: this.#opts.tonic,
       baseOctave: this.#opts.baseOctave,
-      laySpeeds: this.#opts.laySpeeds
+      laySpeeds: this.#opts.laySpeeds,
+      repeats: this.#opts.repeats
     };
   }
   /** Effective tempo: snapped to the taal's available tabla tempos while a
@@ -1347,9 +1691,10 @@ var SwaralipiPlayer = class {
    * from the note it was on — slowing down a repeated line keeps repeating it. */
   #reapply() {
     if (this.#state !== "playing") return;
-    const at = this.#cursor;
+    const at = this.#at;
     this.#halt();
-    void this.play(at ?? void 0);
+    this.#startAt = at < 0 ? null : at;
+    void this.play();
   }
   /** The master bus everything routes through (created once, → destination). */
   #ensureMaster(Tone) {
@@ -1393,13 +1738,13 @@ var SwaralipiPlayer = class {
       while (lines[line + 1] !== void 0 && lines[line + 1].first <= i) line++;
       const k = line;
       const heard = (time) => time >= this.#fence && this.#hears(k);
-      const sounds = (time) => heard(time) && !this.#turn;
+      const sounds2 = (time) => heard(time) && !this.#turn;
       const at = ev.beat * spb + shift;
       if (ev.glide !== true) {
         for (const g of graceTouches(ev)) {
           const graceName = midiToSampleName(g.midi);
           transport.schedule((time) => {
-            if (sounds(time)) melody.triggerAttackRelease(graceName, spb * 0.4, time);
+            if (sounds2(time)) melody.triggerAttackRelease(graceName, spb * 0.4, time);
           }, Math.max(g.beat * spb + shift, 0));
         }
       }
@@ -1415,7 +1760,7 @@ var SwaralipiPlayer = class {
           ];
           const end = (last.beat + last.durationBeats - ev.beat) * spb;
           transport.schedule((time) => {
-            if (!sounds(time)) return;
+            if (!sounds2(time)) return;
             triggerGlide(
               Tone,
               glide.buffers,
@@ -1428,7 +1773,7 @@ var SwaralipiPlayer = class {
           }, at);
         } else {
           transport.schedule((time) => {
-            if (sounds(time)) melody.triggerAttackRelease(name, dur, time);
+            if (sounds2(time)) melody.triggerAttackRelease(name, dur, time);
           }, at);
         }
       }
@@ -1441,6 +1786,7 @@ var SwaralipiPlayer = class {
         if (!heard(time)) return;
         const turn = this.#turn;
         this.#cursor = ev.path;
+        this.#at = i;
         draw.schedule(() => this.#emitHighlight(ev.path, turn), time);
       }, at);
     });
@@ -1677,7 +2023,8 @@ async function exportAudio(doc, options = {}) {
   const schedule = buildSchedule(doc, {
     tonic: options.tonic,
     baseOctave: options.baseOctave,
-    laySpeeds: options.laySpeeds
+    laySpeeds: options.laySpeeds,
+    repeats: options.repeats ?? true
   });
   const range = midiRange2(schedule);
   const taalId = resolveTaal(doc, options.taal);
@@ -2050,7 +2397,8 @@ function exportMidi(doc, options = {}) {
   const schedule = buildSchedule(doc, {
     tonic: options.tonic,
     baseOctave: options.baseOctave,
-    laySpeeds: options.laySpeeds
+    laySpeeds: options.laySpeeds,
+    repeats: options.repeats ?? true
   });
   const bpm = options.bpm ?? doc.meta.bpm ?? 90;
   const drums = options.drums ? (seg) => {