@k-l-lambda/lilylet 0.1.70 → 0.1.71

package/lib/gmInstruments.d.ts

@@ -0,0 +1 @@
+export * from "./lilylet/gmInstruments.js";

package/lib/gmInstruments.js

@@ -0,0 +1 @@
+export * from "./lilylet/gmInstruments.js";

package/lib/lilylet/abcDecoder.js

@@ -498,25 +498,34 @@ const abcLayoutToStaves = (layout) => {
         // arc or unbounded: a staff only if every descendant is too (no nested groups)
         return (node.items || []).every(isStaffLeaf);
     };
-    const emit = (node) => {
+    // A square group maps to lilylet Bracket `<>` at the TOP level, but to lilylet Square
+    // `[]` when nested inside another group — e.g. ABC `[[1 2] 3 | 4]` → `<[1,2]3-4>`.
+    // A curly group always maps to Brace `{}`. `nested` is false for a top-level entry.
+    const emit = (node, nested) => {
         if (isStaffLeaf(node))
             return firstVoice(node) || "";
         const group = node;
-        const open = group.bound === "curly" ? "{" : "<"; // square → bracket <>, curly → brace {}
-        const close = group.bound === "curly" ? "}" : ">";
+        const open = group.bound === "curly" ? "{" : (group.bound === "square" && nested) ? "[" : "<";
+        const close = group.bound === "curly" ? "}" : (group.bound === "square" && nested) ? "]" : ">";
         const items = group.items || [];
         let inner = "";
         items.forEach((item, i) => {
-            inner += emit(item);
+            inner += emit(item, true);
             if (i < items.length - 1) {
-                const conj = item.barThruAfter ? "-" : ",";
-                inner += conj;
+                // A Blank separator (',') is only needed between two bare staff leaves; a
+                // grouped neighbour's bracket already delimits the slot, so suppress it there
+                // (giving `[1,2]3` not `[1,2],3`). A Solid join ('-', barThru) is always kept.
+                const next = items[i + 1];
+                if (item.barThruAfter)
+                    inner += "-";
+                else if (isStaffLeaf(item) && isStaffLeaf(next))
+                    inner += ",";
             }
         });
         return `${open}${inner}${close}`;
     };
     const tops = layout.map((top, i) => {
-        let s = emit(top);
+        let s = emit(top, false);
         // A bare top-level staff leaf (e.g. the `9` in `[ … ] 9 [ … ]`) still occupies a slot;
         // emit() already yields its id with no wrapper, which is the desired output.
         return { s, barThru: !!top.barThruAfter, isLast: i === layout.length - 1 };

package/lib/lilylet/gmInstruments.d.ts

@@ -0,0 +1 @@
+export declare const gmProgramOf: (name: string | undefined | null) => number | undefined;

package/lib/lilylet/gmInstruments.js

@@ -0,0 +1,295 @@
+// General MIDI program lookup: instrument name → GM program number (0–127).
+//
+// Verovio's MIDI export honors ONLY the numeric `@midi.instrnum` on an MEI
+// <instrDef> (the GM-name attribute `@midi.instrname` is parsed but never used
+// for MIDI). lilylet already carries human instrument names (from ABC voice
+// names, MusicXML part names, etc.) in metadata.instruments; this table maps
+// those names to GM programs so the MEI encoder can emit <instrDef midi.instrnum>
+// and multi-instrument scores get distinct timbres instead of all-piano.
+//
+// The name set is seeded from the notagen dataset (Piano, Violins, Viola,
+// Violoncellos, Oboe, Horn, Flute, Clarinet, Bassoon, Violin, Trombone,
+// Timpani, Voice, Bass, Trumpet, Harp, Contrabasses, Vocal, Organ, …) plus
+// common GM aliases, then matched through a normalizer that handles plurals
+// ("Violins" → violin) and trailing part numbers ("Violin I", "Horn 2").
+// Normalized name → GM program (0-based). Keys are lowercase, singular,
+// whitespace-collapsed. Plural/number variants are resolved by the normalizer.
+const GM_PROGRAMS = {
+    // Piano (0–7)
+    "piano": 0,
+    "acoustic grand piano": 0,
+    "grand piano": 0,
+    "bright acoustic piano": 1,
+    "electric piano": 4,
+    "harpsichord": 6,
+    "clavichord": 7,
+    "clavi": 7,
+    // Chromatic percussion (8–15)
+    "celesta": 8,
+    "glockenspiel": 9,
+    "music box": 10,
+    "vibraphone": 11,
+    "marimba": 12,
+    "xylophone": 13,
+    "tubular bells": 14,
+    "dulcimer": 15,
+    // Organ (16–23)
+    "organ": 19,
+    "hammond organ": 16,
+    "percussive organ": 17,
+    "rock organ": 18,
+    "church organ": 19,
+    "pipe organ": 19,
+    "reed organ": 20,
+    "accordion": 21,
+    "harmonica": 22,
+    // Guitar (24–31)
+    "guitar": 24,
+    "acoustic guitar": 24,
+    "nylon guitar": 24,
+    "steel guitar": 25,
+    "electric guitar": 27,
+    "guitarre": 24, // fr./de. guitar
+    "gitarre": 24, // de.
+    "chitarra": 24, // it.
+    // Bass (32–39) — orchestral "Bass" means double bass (Contrabass, 43); the
+    // electric/acoustic bass-guitar programs live here but are not the default.
+    "acoustic bass": 32,
+    "electric bass": 33,
+    "fretless bass": 35,
+    "basso": 43, // it. bass → double bass
+    "basse": 43, // fr.
+    "bassi": 43, // it. pl.
+    "bas": 43, // de./nl. abbrev
+    // Strings (40–47)
+    "violin": 40,
+    "viola": 41,
+    "cello": 42,
+    "violoncello": 42,
+    "contrabass": 43,
+    "double bass": 43,
+    "bass": 43,
+    "tremolo strings": 44,
+    "pizzicato strings": 45,
+    "harp": 46,
+    "orchestral harp": 46,
+    "timpani": 47,
+    // Ensemble (48–55)
+    "strings": 48,
+    "string ensemble": 48,
+    "string orchestra": 48,
+    "synth strings": 50,
+    "voice": 52,
+    "vocal": 52,
+    "voices": 52,
+    "choir": 52,
+    "choir aahs": 52,
+    "soprano": 52,
+    "alto": 52,
+    "tenor": 52,
+    "bass voice": 52,
+    "orchestra hit": 55,
+    // Brass (56–63)
+    "trumpet": 56,
+    "trombone": 57,
+    "tuba": 58,
+    "muted trumpet": 59,
+    "horn": 60,
+    "french horn": 60,
+    "brass": 61,
+    "brass section": 61,
+    // Reed (64–71)
+    "soprano sax": 64,
+    "alto sax": 65,
+    "tenor sax": 66,
+    "baritone sax": 67,
+    "saxophone": 66,
+    "sax": 66,
+    "oboe": 68,
+    "english horn": 69,
+    "cor anglais": 69,
+    "bassoon": 70,
+    "clarinet": 71,
+    // Pipe (72–79)
+    "piccolo": 72,
+    "flute": 73,
+    "recorder": 74,
+    "pan flute": 75,
+    // --- Foreign-language names, abbreviations and common spelling variants,
+    // harvested from the notagen corpus. Mapped to the nearest GM program.
+    // Keyboard
+    "pianoforte": 0,
+    "fortepiano": 0,
+    "klavier": 0,
+    "keyboard": 0,
+    "cembalo": 6, // it. harpsichord
+    "clavicembalo": 6,
+    "harpichord": 6, // misspelling
+    "organo": 19, // it. organ
+    "orgel": 19, // de. organ
+    // Strings (it./de./fr./variants)
+    "violino": 40,
+    "violini": 40,
+    "violine": 40, // de.
+    "violinen": 40,
+    "violon": 40, // fr.
+    "violons": 40,
+    "violn": 40, // abbrev/OCR variant
+    "violno": 40, // OCR variant
+    "viole": 41, // it. violas (also fr. "viole")
+    "bratsche": 41, // de. viola
+    "celli": 42,
+    "violoncelli": 42,
+    "violoncelle": 42, // fr.
+    "violoncelles": 42,
+    "violonchelo": 42, // es.
+    "soloncello": 42, // OCR variant of violoncello
+    "gambe": 42, // fr. viola da gamba
+    "gamba": 42, // viola da gamba ≈ cello
+    "viola da gamba": 42,
+    "contrabasso": 43, // it.
+    "contrabassi": 43,
+    "contrabbasso": 43, // it.
+    "contra-basso": 43,
+    "contrabajo": 43, // es.
+    "kontrabass": 43, // de.
+    "kontrabasse": 43, // de. pl.
+    "kontrabasso": 43,
+    "contrebasse": 43, // fr.
+    "violone": 43, // large bass viol ≈ contrabass
+    "arpa": 46, // it./es. harp
+    "harfe": 46, // de. harp
+    "pauken": 47, // de. timpani
+    // Voice (it./de./fr.)
+    "canto": 52, // it.
+    "coro": 52, // it. choir
+    "chorus": 52,
+    "chorale": 52,
+    "sopran": 52, // de.
+    "contralto": 52, // it. alto
+    "tenore": 52, // it.
+    "tenori": 52,
+    "gesang": 52, // de. voice
+    "singstimme": 52, // de. voice
+    "voce": 52, // it.
+    "voix": 52, // fr.
+    "chanto": 52, // OCR variant of canto
+    "women": 52, // women's voices
+    "contra-fagotto": 70, // hyphenated contrabassoon ≈ bassoon
+    // Brass
+    "tromboni": 57, // it. trombones
+    "posaune": 57, // de. trombone
+    "posaunen": 57,
+    "trombe": 56, // it. trumpets
+    "tromba": 56, // it. trumpet
+    "trompete": 56, // de. trumpet
+    "trompeten": 56,
+    "trompette": 56, // fr. trumpet
+    "cornetto": 56, // historical cornett ≈ trumpet
+    "cornettino": 56,
+    "corno": 60, // it. horn
+    "corni": 60, // it. horns
+    // Reed (it./de./fr.)
+    "oboi": 68, // it. oboes
+    "oboen": 68, // de.
+    "hautbois": 68, // fr. oboe
+    "corno inglese": 69, // it. english horn
+    "inglese": 69, // "corno inglese" trailing word fallback also covers it
+    "ingles": 69, // es. variant
+    "fagotto": 70, // it. bassoon
+    "fagotti": 70,
+    "fagott": 70, // de.
+    "fagotte": 70, // de. pl.
+    "fagot": 70, // es.
+    "basson": 70, // fr. bassoon
+    "bassons": 70,
+    "contrafagotto": 70, // it. contrabassoon ≈ bassoon timbre
+    "contrabassoon": 70,
+    "klarinette": 71, // de. clarinet
+    "clarinetto": 71, // it.
+    "clarinetti": 71,
+    "clarinette": 71, // fr.
+    // Pipe (it./de.)
+    "flauto": 73, // it. flute
+    "flauti": 73, // it. flutes
+    "flote": 73, // de. Flöte (diacritics stripped by the normalizer)
+    "floten": 73, // de. Flöten
+    "traverso": 73, // baroque transverse flute
+    "flauto traverso": 73,
+};
+// Normalize an instrument name for lookup: lowercase, turn literal "\n" escapes
+// and real newlines into spaces, strip diacritics (Flöte→flote, Hautböis→...),
+// drop a trailing part designator (roman numeral or arabic number — "Violin I",
+// "Horn 2", "Oboe II"), collapse whitespace.
+const normalizeInstrumentName = (raw) => {
+    let s = raw.toLowerCase().trim();
+    s = s.replace(/\\n/g, " "); // literal backslash-n escape → space
+    s = s.normalize("NFD").replace(/[̀-ͯ]/g, ""); // strip diacritics
+    s = s.replace(/\s+/g, " ").trim();
+    s = s.replace(/\s+(?:[ivx]+|\d+)\.?$/i, "").trim();
+    return s;
+};
+// Choral single-letter voice-part abbreviations → "Voice" (GM 52). Matched ONLY
+// against the whole name, never per-word: a bare "S"/"A"/"T"/"B" staff label in a
+// chorale means Soprano/Alto/Tenor/Bass, but the same letters appear as key
+// designators in "Clarinet in B", "Horn in F", "Trumpet in C" — so these must not
+// enter GM_PROGRAMS where the word-scan would misread them.
+const SATB_VOICE = {
+    "s": 52,
+    "a": 52,
+    "t": 52,
+    "b": 52,
+};
+// Look up a single normalized name: exact match, else de-pluralized
+// ("violins"→violin, "violoncellos"→violoncello, "contrabasses"→contrabass),
+// else with a trailing attached part-number stripped ("violin1"→violin,
+// "violino2"→violino).
+const lookupNormalized = (norm) => {
+    if (norm in GM_PROGRAMS)
+        return GM_PROGRAMS[norm];
+    // Try "-es" before "-s".
+    if (norm.endsWith("es")) {
+        const sing = norm.slice(0, -2);
+        if (sing in GM_PROGRAMS)
+            return GM_PROGRAMS[sing];
+    }
+    if (norm.endsWith("s")) {
+        const sing = norm.slice(0, -1);
+        if (sing in GM_PROGRAMS)
+            return GM_PROGRAMS[sing];
+    }
+    // Attached trailing digits ("violin1", "violino2"): strip and retry.
+    const deNum = norm.replace(/\d+$/, "");
+    if (deNum !== norm && deNum in GM_PROGRAMS)
+        return GM_PROGRAMS[deNum];
+    return undefined;
+};
+// Resolve an instrument name to a GM program number (0–127), or undefined if no
+// confident match (caller then omits <instrDef>, leaving Verovio's default).
+//
+// Match priority: the full normalized string first (including the SATB
+// single-letter voice abbreviations), then individual words from the last toward
+// the first. Multi-word names ("Singstimme Voice", "First Violins", "Solo Flute")
+// usually put the instrument at the end, so the trailing word is tried before
+// earlier qualifier words. Each word attempt runs through the de-plural path
+// (lookupNormalized); SATB letters are intentionally NOT part of the word scan.
+export const gmProgramOf = (name) => {
+    if (!name)
+        return undefined;
+    const norm = normalizeInstrumentName(name);
+    const direct = lookupNormalized(norm);
+    if (direct !== undefined)
+        return direct;
+    // Whole-name-only: a lone S/A/T/B is a chorale voice part.
+    if (norm in SATB_VOICE)
+        return SATB_VOICE[norm];
+    const words = norm.split(" ");
+    if (words.length > 1) {
+        for (let i = words.length - 1; i >= 0; i--) {
+            const hit = lookupNormalized(words[i]);
+            if (hit !== undefined)
+                return hit;
+        }
+    }
+    return undefined;
+};

package/lib/lilylet/meiEncoder.js

@@ -1,5 +1,6 @@
 import { Clef, Accidental, OrnamentType, StemDirection, HairpinType, PedalType, } from "./types.js";
 import { parseStaffLayout, StaffGroupType } from "./staffLayout.js";
+import { gmProgramOf } from "./gmInstruments.js";
 // MEI key signatures: positive = sharps, negative = flats
 const KEY_SIGS = {
     0: "0",
@@ -81,12 +82,22 @@ const resolveClef = (clefStr) => {
 };
 // Attributes for a standalone <clef> element (mid-measure clef change).
 // A mid-measure <clef> cannot carry att.transposition (that is a staff-level
-// property on <staffDef>); a mid-piece change of transposition would require a
-// new <staffDef>, which is out of scope here. So only shape/line are emitted.
+// property Verovio only reads from <staffDef>); the visible clef shape/line is
+// emitted here, and a sounding-pitch transposition change is mirrored by a
+// between-measure <scoreDef>/<staffDef trans.*> emitted in the measure loop
+// (see emitClefTranspositionScoreDef). So only shape/line are emitted here.
 const clefElementAttrs = (clefStr) => {
     const c = resolveClef(clefStr);
     return `shape="${c.shape}" line="${c.line}"`;
 };
+// The written→sounding transposition a clef declares, as {diat, semi}; {0,0}
+// when the clef declares none. Used to detect mid-piece transposition changes
+// and to emit the resetting <staffDef> when a transposing clef is replaced by a
+// plain one (Verovio retains a prior trans.* until an explicit 0/0 overrides it).
+const clefTransOf = (clefStr) => {
+    const c = resolveClef(clefStr);
+    return c.trans || { diat: 0, semi: 0 };
+};
 // Attributes for a <staffDef> clef (clef.* namespace), plus att.transposition
 // (trans.diat / trans.semi) when the clef declares a transposition.
 const staffDefClefAttrs = (clefStr) => {
@@ -1386,6 +1397,36 @@ const generateTempoElement = (tempo, indent, staff = 1) => {
     }
     return `${indent}<tempo ${attrs} />\n`;
 };
+// The clef governing a measure's sounding pitch on one global staff: the clef
+// carried in from the previous measure, overridden by a leading clef change that
+// appears before the first note/rest in the measure (the normal boundary-change
+// case). A clef change occurring *after* notes does not retune this measure — it
+// becomes the carried clef for the next measure via clefState. This per-measure
+// granularity matches what Verovio honors for MIDI: a transposition change takes
+// effect only via a between-measure <scoreDef>/<staffDef trans.*>, never from a
+// mid-measure <clef> element.
+const measureStartClef = (measure, globalStaff, partInfos, carriedClef) => {
+    let active = carriedClef;
+    for (let pi = 0; pi < measure.parts.length; pi++) {
+        const partOffset = partInfos[pi]?.staffOffset || 0;
+        for (const voice of measure.parts[pi].voices) {
+            if ((partOffset + (voice.staff || 1)) !== globalStaff)
+                continue;
+            for (const event of voice.events) {
+                if (event.type === 'note' || event.type === 'rest' ||
+                    event.type === 'tuplet' || event.type === 'times' || event.type === 'tremolo') {
+                    break; // notes have started; a later clef change governs the next measure
+                }
+                if (event.type === 'context') {
+                    const ctx = event;
+                    if (ctx.clef)
+                        active = ctx.clef;
+                }
+            }
+        }
+    }
+    return active;
+};
 // Barline style to MEI @right attribute mapping
 const BARLINE_TO_MEI = {
     '|': 'single',
@@ -1642,14 +1683,40 @@ const analyzePartStructure = (doc) => {
 };
 // MEI staffGrp @symbol for a layout group type (Default → none; Square → bracketsq).
 const LAYOUT_SYMBOL = [null, "brace", "bracket", "bracketsq"];
+const newChannelAllocator = () => ({ byProgram: new Map(), nextChannel: 0 });
+// Channel for a program: reuse the channel already assigned to that program,
+// else take the next free channel (skipping 9). Wraps past 16 as graceful
+// degradation for scores with more than 15 distinct timbres.
+const allocChannel = (alloc, program) => {
+    const existing = alloc.byProgram.get(program);
+    if (existing !== undefined)
+        return existing;
+    let ch = alloc.nextChannel;
+    if (ch % 16 === 9)
+        ch++; // skip GM drum channel
+    const assigned = ch % 16;
+    alloc.byProgram.set(program, assigned);
+    alloc.nextChannel = ch + 1;
+    return assigned;
+};
 // Build <label>/<labelAbbr> child XML for an instrument entry, or "" if none.
-const instrumentLabelXML = (instr, indent) => {
+// When the instrument name resolves to a General MIDI program, also emit an
+// <instrDef midi.instrnum midi.channel> sibling so Verovio's MIDI export assigns
+// that timbre (it honors only the numeric @midi.instrnum) on its own channel
+// (@midi.channel, else all instruments collide on channel 0). Unknown names emit
+// just the label, leaving Verovio's default program (0 = piano).
+const instrumentLabelXML = (instr, indent, channels) => {
     if (!instr)
         return "";
     let xml = `${indent}<label>${escapeXml(instr.name)}</label>\n`;
     if (instr.shortName !== undefined) {
         xml += `${indent}<labelAbbr>${escapeXml(instr.shortName)}</labelAbbr>\n`;
     }
+    const program = gmProgramOf(instr.name);
+    if (program !== undefined) {
+        const chanAttr = channels ? ` midi.channel="${allocChannel(channels, program)}"` : "";
+        xml += `${indent}<instrDef xml:id="${generateId("instrdef")}" midi.instrnum="${program}"${chanAttr} />\n`;
+    }
     return xml;
 };
 // Recursively emit a <staffGrp>/<staffDef> tree from a parsed [staves] layout group.
@@ -1658,47 +1725,50 @@ const instrumentLabelXML = (instr, indent) => {
 // key (staffLayout's groupKey: a staff id or range) to its instrument name; matching
 // names are emitted as <label>/<labelAbbr> on the staffGrp (groups) or staffDef (leaves).
 // bar.thru reflects the group's conjunction (Solid).
-const layoutGroupToMEI = (group, staffDefAttrs, leafCounter, indent, instruments) => {
+const layoutGroupToMEI = (group, staffDefAttrs, leafCounter, indent, instruments, channels) => {
     const isLeaf = !!group.staff && (!group.subs || group.subs.length === 0);
     const instr = group.key !== undefined ? instruments[group.key] : undefined;
     // A leaf with no grouping symbol (Default) emits just the next staffDef (with label).
     if (isLeaf && (group.type === StaffGroupType.Default || !LAYOUT_SYMBOL[group.type])) {
-        return staffDefWithLabel(staffDefAttrs[leafCounter.i++], instr, indent);
+        return staffDefWithLabel(staffDefAttrs[leafCounter.i++], instr, indent, channels);
     }
     const symbol = LAYOUT_SYMBOL[group.type] ? ` symbol="${LAYOUT_SYMBOL[group.type]}"` : "";
     const barThru = (group.bar ?? 0) > 1 ? ' bar.thru="true"' : '';
     let xml = `${indent}<staffGrp xml:id="${generateId("staffgrp")}"${symbol}${barThru}>\n`;
     // A multi-staff group's instrument name labels the whole group.
     if (!isLeaf)
-        xml += instrumentLabelXML(instr, indent + "    ");
+        xml += instrumentLabelXML(instr, indent + "    ", channels);
     if (isLeaf) {
         // A single staff that still carries a grouping bracket (e.g. "<b>"): MEI allows
         // a staffGrp wrapping one staffDef. The instrument names the lone staff, so the
         // label goes on the staffDef inside.
-        xml += staffDefWithLabel(staffDefAttrs[leafCounter.i++], instr, indent + "    ");
+        xml += staffDefWithLabel(staffDefAttrs[leafCounter.i++], instr, indent + "    ", channels);
     }
     else {
         for (const sub of group.subs || []) {
-            xml += layoutGroupToMEI(sub, staffDefAttrs, leafCounter, indent + "    ", instruments);
+            xml += layoutGroupToMEI(sub, staffDefAttrs, leafCounter, indent + "    ", instruments, channels);
         }
     }
     xml += `${indent}</staffGrp>\n`;
     return xml;
 };
 // Emit a <staffDef> from its attribute string, with optional instrument <label> children.
-const staffDefWithLabel = (attrs, instr, indent) => {
+const staffDefWithLabel = (attrs, instr, indent, channels) => {
     if (attrs === undefined)
         return "";
     if (!instr)
         return `${indent}<staffDef ${attrs} />\n`;
     let xml = `${indent}<staffDef ${attrs}>\n`;
-    xml += instrumentLabelXML(instr, indent + "    ");
+    xml += instrumentLabelXML(instr, indent + "    ", channels);
     xml += `${indent}</staffDef>\n`;
     return xml;
 };
 // Encode scoreDef with part groups
 const encodeScoreDef = (keySig, timeNum, timeDen, partInfos, indent, meterSymbol, stavesCode, instruments = {}) => {
     const scoreDefId = generateId("scoredef");
+    // One MIDI channel allocator per score: assigns a distinct channel per GM
+    // program so instruments don't collide on channel 0 (see allocChannel).
+    const channels = newChannelAllocator();
     // Build meter attributes
     const meterSymAttr = meterSymbol ? ` meter.sym="${meterSymbol}"` : '';
     let xml = `${indent}<scoreDef xml:id="${scoreDefId}" key.sig="${keySig}"${meterSymAttr} meter.count="${timeNum}" meter.unit="${timeDen}">\n`;
@@ -1717,7 +1787,7 @@ const encodeScoreDef = (keySig, timeNum, timeDen, partInfos, indent, meterSymbol
         const layout = parseStaffLayout(stavesCode);
         if (layout.stavesCount === flatStaves.length) {
             const staffDefAttrs = flatStaves.map(s => `xml:id="${generateId('staffdef')}" n="${s.n}" lines="5" ${staffDefClefAttrs(s.clef)}`);
-            xml += layoutGroupToMEI(layout.group, staffDefAttrs, { i: 0 }, `${indent}    `, instruments);
+            xml += layoutGroupToMEI(layout.group, staffDefAttrs, { i: 0 }, `${indent}    `, instruments, channels);
             layoutUsed = true;
         }
     }
@@ -1733,13 +1803,13 @@ const encodeScoreDef = (keySig, timeNum, timeDen, partInfos, indent, meterSymbol
                 const last = info.staffOffset + info.maxStaff;
                 const instr = instruments[`${first}-${last}`];
                 xml += `${indent}        <staffGrp xml:id="${generateId("staffgrp")}" symbol="brace" bar.thru="true">\n`;
-                xml += instrumentLabelXML(instr, `${indent}            `);
+                xml += instrumentLabelXML(instr, `${indent}            `, channels);
                 for (let ls = 1; ls <= info.maxStaff; ls++) {
                     const globalStaff = info.staffOffset + ls;
                     const clef = info.clefs[ls] || Clef.treble;
                     const leafInstr = instruments[`${globalStaff}`];
                     const attrs = `xml:id="${generateId('staffdef')}" n="${globalStaff}" lines="5" ${staffDefClefAttrs(clef)}`;
-                    xml += staffDefWithLabel(attrs, leafInstr, `${indent}            `);
+                    xml += staffDefWithLabel(attrs, leafInstr, `${indent}            `, channels);
                 }
                 xml += `${indent}        </staffGrp>\n`;
             }
@@ -1749,7 +1819,7 @@ const encodeScoreDef = (keySig, timeNum, timeDen, partInfos, indent, meterSymbol
                 const clef = info.clefs[1] || Clef.treble;
                 const leafInstr = instruments[`${globalStaff}`];
                 const attrs = `xml:id="${generateId('staffdef')}" n="${globalStaff}" lines="5" ${staffDefClefAttrs(clef)}`;
-                xml += staffDefWithLabel(attrs, leafInstr, `${indent}        `);
+                xml += staffDefWithLabel(attrs, leafInstr, `${indent}        `, channels);
             }
         }
         xml += `${indent}    </staffGrp>\n`;
@@ -2101,11 +2171,18 @@ const encode = (doc, options = {}) => {
     const octaveEndReplacements = {};
     // Initialize clef state from partInfos (convert local staff to global staff)
     const clefState = {};
+    // Running written→sounding transposition per global staff, as the verbatim
+    // "diat,semi" key. Seeded from the initial clefs (which the leading <scoreDef>
+    // already encoded via staffDefClefAttrs), then advanced whenever a measure
+    // starts under a clef with a different transposition.
+    const transState = {};
     for (let pi = 0; pi < partInfos.length; pi++) {
         const partInfo = partInfos[pi];
         for (const [localStaffStr, clef] of Object.entries(partInfo.clefs)) {
             const globalStaff = partInfo.staffOffset + parseInt(localStaffStr);
             clefState[globalStaff] = clef;
+            const t = clefTransOf(clef);
+            transState[globalStaff] = `${t.diat},${t.semi}`;
         }
     }
     // Helper to check if a measure has any musical content
@@ -2154,6 +2231,41 @@ const encode = (doc, options = {}) => {
                 mei += `${indent}${indent}${indent}${indent}${indent}${indent}<scoreDef xml:id="${generateId('scoredef')}"${meterSymAttr} meter.count="${currentTimeNum}" meter.unit="${currentTimeDen}" />\n`;
             }
         }
+        // Check for a written→sounding transposition change at this measure
+        // boundary and mirror it into MIDI. Verovio applies att.transposition only
+        // from <staffDef>, never from a mid-measure <clef>, so a change of
+        // transposing clef must be re-declared via a between-measure <scoreDef>.
+        // We emit only the staves whose transposition actually changed (a partial
+        // <staffGrp> leaves the others' state intact), using explicit "0,0" to
+        // clear a prior transposition when a transposing clef is replaced by a
+        // plain one. mi === 0 is already covered by the leading <scoreDef>.
+        if (mi > 0) {
+            const changed = [];
+            for (let si = 1; si <= totalStaves; si++) {
+                const startClef = measureStartClef(measure, si, partInfos, clefState[si]);
+                if (startClef === undefined)
+                    continue;
+                const t = clefTransOf(startClef);
+                const key = `${t.diat},${t.semi}`;
+                if (transState[si] === undefined) {
+                    transState[si] = key;
+                    continue;
+                }
+                if (key !== transState[si]) {
+                    transState[si] = key;
+                    const c = resolveClef(startClef);
+                    changed.push(`${indent}${indent}${indent}${indent}${indent}${indent}${indent}${indent}<staffDef xml:id="${generateId('staffdef')}" n="${si}" lines="5" clef.shape="${c.shape}" clef.line="${c.line}" trans.diat="${t.diat}" trans.semi="${t.semi}" />`);
+                }
+            }
+            if (changed.length > 0) {
+                const sd = `${indent}${indent}${indent}${indent}${indent}${indent}`;
+                mei += `${sd}<scoreDef xml:id="${generateId('scoredef')}">\n`;
+                mei += `${sd}${indent}<staffGrp xml:id="${generateId('staffgrp')}">\n`;
+                mei += changed.join("\n") + "\n";
+                mei += `${sd}${indent}</staffGrp>\n`;
+                mei += `${sd}</scoreDef>\n`;
+            }
+        }
         mei += encodeMeasure(measure, mi + 1, `${indent}${indent}${indent}${indent}${indent}${indent}`, totalStaves, tieState, slurState, hairpinState, ottavaState, currentKey, partInfos, clefState, octaveEndReplacements);
     });
     mei += `${indent}${indent}${indent}${indent}${indent}</section>\n`;

package/lib/lilylet/staffLayout.d.ts

@@ -52,6 +52,11 @@ export declare class StaffLayout {
     get stavesCount(): number;
 }
 export declare const parseStaffLayout: (code: string) => StaffLayout;
+export interface SerializeStaffLayoutOptions {
+    anonymous?: boolean;
+    idMap?: (originalId: string) => string;
+}
+export declare const serializeStaffLayout: (layout: StaffLayout, options?: SerializeStaffLayoutOptions) => string;
 export declare const encodeStaffLayoutMEI: (layout: StaffLayout, nameDict?: {
     [key: string]: string;
 }, indent?: number, tab?: string) => string;