@k-l-lambda/lilylet 0.1.70 → 0.1.72

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;

package/lib/lilylet/staffLayout.js

@@ -200,6 +200,68 @@ export class StaffLayout {
     }
 }
 export const parseStaffLayout = (code) => new StaffLayout(tokenize(code));
+// ── Staff-layout serialization (inverse of parseStaffLayout) ──
+// Reconstruct a layout string from a parsed StaffLayout by walking the group tree,
+// so every staff slot and conjunction is preserved structurally (a regex strip of the
+// ids would drop a BARE anonymous leaf — its empty token gets swallowed by whitespace).
+//
+// `anonymous` emits empty ids (the parser re-auto-names slots "1","2",… by position).
+// `idMap` optionally overrides individual staff ids by their original id.
+//
+// Conjunction rendering: Solid → "-", Dashed → ".", Blank → " " ONLY when both sides
+// are bracketed groups (the brackets self-delimit the slots); otherwise Blank → ","
+// so an adjacent empty/bare leaf still tokenizes as its own slot.
+const CONJ_CHAR = {
+    [StaffConjunctionType.Solid]: "-",
+    [StaffConjunctionType.Dashed]: ".",
+    [StaffConjunctionType.Blank]: ",",
+};
+export const serializeStaffLayout = (layout, options = {}) => {
+    const { anonymous = false, idMap } = options;
+    const isGrouped = (group) => group.type !== StaffGroupType.Default && !!group.subs;
+    const leafText = (id) => (anonymous ? "" : idMap ? idMap(id) : id);
+    // flat leaf index of a group's first / last staff (for the inter-child conjunction).
+    const firstLeafIndex = (group) => layout.staffIds.indexOf(groupHead(group));
+    const lastLeafIndex = (group) => layout.staffIds.indexOf(groupTail(group));
+    const sep = (conj, left, right) => {
+        if (conj !== StaffConjunctionType.Blank)
+            return CONJ_CHAR[conj];
+        // Blank: a space is safe only when both neighbours are bracketed (self-delimiting).
+        return isGrouped(left) && isGrouped(right) ? " " : ",";
+    };
+    const emit = (group) => {
+        if (!group.subs)
+            return leafText(group.staff); // Default leaf
+        const open = group.type === StaffGroupType.Brace ? "{" : group.type === StaffGroupType.Bracket ? "<" : group.type === StaffGroupType.Square ? "[" : "";
+        const close = group.type === StaffGroupType.Brace ? "}" : group.type === StaffGroupType.Bracket ? ">" : group.type === StaffGroupType.Square ? "]" : "";
+        let inner = "";
+        group.subs.forEach((sub, i) => {
+            inner += emit(sub);
+            if (i < group.subs.length - 1) {
+                const next = group.subs[i + 1];
+                const conj = layout.conjunctions[lastLeafIndex(sub)] ?? StaffConjunctionType.Blank;
+                inner += sep(conj, sub, next);
+                void firstLeafIndex; // (lastLeafIndex(sub) === firstLeafIndex(next) - 1)
+            }
+        });
+        return open + inner + close;
+    };
+    let out = emit(layout.group);
+    // A TRAILING bare anonymous leaf emits "" with nothing after it to delimit the slot
+    // (a leaf before a closing bracket is fine — the bracket gives it bounds; an internal
+    // one is flushed by the next separator). The tokenizer only flushes a final empty item
+    // if it carries bounds, so append one "," to materialize that last empty slot. This only
+    // arises when the OUTERMOST container is the Default sequence (no enclosing bracket) and
+    // its last child is a bare leaf; if the whole layout is wrapped in a bracket, the closing
+    // bracket already delimits the final leaf. The trailing conjunction is dropped on re-parse
+    // (conjunctions = items[0..n-1]), so it is harmless. Anonymous output only.
+    if (anonymous && layout.group.type === StaffGroupType.Default && layout.group.subs) {
+        const lastTop = layout.group.subs[layout.group.subs.length - 1];
+        if (!lastTop.subs && lastTop.staff !== undefined)
+            out += ",";
+    }
+    return out;
+};
 // ── MEI staffGrp encoding (ported from FindLab staffLayout/encoding.js encodeMEI) ──
 // Recursively emit nested <staffGrp> with symbol (brace/bracket/square) and bar.thru,
 // with <staffDef n="..."> leaves keyed by staff index. nameDict maps a group key to a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k-l-lambda/lilylet",
-  "version": "0.1.70",
+  "version": "0.1.72",
   "description": "Lilylet is a lilyopnd-like sheet music language designed for Markdown rendering and symbolic music representation in AIGC applications.",
   "type": "module",
   "main": "lib/index.js",
@@ -14,6 +14,10 @@
       "types": "./lib/browser.d.ts",
       "default": "./lib/browser.js"
     },
+    "./highlight": {
+      "types": "./lib/lilylet/highlight.d.ts",
+      "default": "./lib/lilylet/highlight.js"
+    },
     "./lib/lilypondDecoder.js": {
       "types": "./lib/lilypondDecoder.d.ts",
       "default": "./lib/lilypondDecoder.js"
@@ -25,7 +29,8 @@
   ],
   "scripts": {
     "build": "tsc -p tsconfig.build.json && node tools/convertGrammarToESM.cjs && node tools/fixEsmExtensions.cjs",
-    "build:grammar": "npx tsx ./tools/buildJisonParser.ts && node tools/convertGrammarToESM.cjs",
+    "build:grammar": "npx tsx ./tools/buildJisonParser.ts && node tools/convertGrammarToESM.cjs && npm run build:highlight",
+    "build:highlight": "npx tsx ./tools/buildHighlight.ts",
     "prepublishOnly": "npm run build:grammar && npm run build",
     "test": "tsx ./tests/parser.ts",
     "test:mei": "tsx ./tests/mei.ts",
@@ -37,6 +42,7 @@
     "test:abc-svg": "tsx ./tests/abc-abcjs-svg.ts",
     "train:bpe": "tsx ./tools/trainBpeTokenizer.ts",
     "build:manual-tokenizer": "tsx ./tools/buildManualTokenizer.ts",
+    "build:browser-bundle": "esbuild tools/browserBundle.ts --bundle --format=iife --platform=browser --minify --outfile=dist/lilylet.bundle.js",
     "test:bpe": "tsx ./tests/unit/bpeTokenizer.test.ts",
     "build:tests": "tsc -p tsconfig.tests.json; cp source/lilylet/grammar.jison.js lib-tests/source/lilylet/ && cp source/abc/grammar.jison.js lib-tests/source/abc/ && node tools/fixEsmExtensions.cjs lib-tests && ln -sfn ../../tests/assets lib-tests/tests/assets",
     "test:roundtrip:compiled": "node lib-tests/tests/lilypond-roundtrip.js",

package/source/lilylet/abcDecoder.ts

@@ -580,27 +580,34 @@ const abcLayoutToStaves = (layout: ABC.StaffGroup[]): string | null => {
 		return (node.items || []).every(isStaffLeaf);
 	};
 
-	const emit = (node: ABC.StaffGroup | string): string => {
+	// 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: ABC.StaffGroup | string, nested: boolean): string => {
 		if (isStaffLeaf(node)) return firstVoice(node) || "";
 
 		const group = node as ABC.StaffGroup;
-		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 as ABC.StaffGroup).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 as ABC.StaffGroup).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 };