@k-l-lambda/lilylet 0.1.80 → 0.1.81

package/lib/lilylet/measureLayoutFromXml.js

@@ -163,7 +163,11 @@ const renderRepeatSpan = (infos, lo, hi) => {
         return rangeCode(lo, hi);
     }
     const endInfo = repeatEnds[0];
-    const startIdx = span.find(i => i.repeatStart)?.index ?? lo;
+    // The repeat-start for THIS end is the latest repeat-start at or before it; a
+    // repeat-start sitting AFTER the end (e.g. the second half of a ":|:"/"::" that
+    // opens the next section) belongs to a following span, not this one. Falling
+    // back to `lo` models the implicit "repeat from the start of the span".
+    const startIdx = span.filter(i => i.repeatStart && i.index <= endInfo.index).map(i => i.index).sort((a, b) => b - a)[0] ?? lo;
     const times = endInfo.repeatTimes ?? 2;
     const endingStarts = span.filter(i => i.endingStart !== undefined).map(i => i.index).sort((a, b) => a - b);
     if (endingStarts.length === 0) {
@@ -301,9 +305,14 @@ const buildDaCapoABA = (infos, dcIdx) => {
     const restCode = renderRepeatSections(infos, restLo, dcIdx);
     if (mainCode === null || restCode === null)
         return null;
-    // main wraps in [..] only when it is a comma-separated sequence (so the ABA
-    // parser reads it as one block); a single token (e.g. "2*[..]") needs no bracket.
-    const main = /,/.test(mainCode) ? `[${mainCode}]` : mainCode;
+    // `main` is parsed by the ABA grammar as ONE item (parseItem). It needs wrapping
+    // in [..] when it is a comma sequence ("1, 2*[..]") or a BARE range ("1..37",
+    // which parseItem stops at the first number). A lone number, or a single
+    // already-structured token ("2*[..]" / "2*[..]{..}" / "[..]"), parses as one item
+    // and needs no extra bracket. `rest` is parsed as a sequence, so it only needs
+    // bracketing to group a comma sequence — a range there is fine.
+    const isSingleToken = /^\d+$/.test(mainCode) || /^\d+\*\[/.test(mainCode) || /^\[/.test(mainCode);
+    const main = isSingleToken ? mainCode : `[${mainCode}]`;
     const rest = /,/.test(restCode) ? `[${restCode}]` : restCode;
     return `<${main}, ${rest}>`;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k-l-lambda/lilylet",
-  "version": "0.1.80",
+  "version": "0.1.81",
   "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",

package/source/lilylet/measureLayoutFromXml.ts

@@ -174,7 +174,11 @@ const renderRepeatSpan = (infos: MeasureRepeatInfo[], lo: number, hi: number): s
 	}
 
 	const endInfo = repeatEnds[0];
-	const startIdx = span.find(i => i.repeatStart)?.index ?? lo;
+	// The repeat-start for THIS end is the latest repeat-start at or before it; a
+	// repeat-start sitting AFTER the end (e.g. the second half of a ":|:"/"::" that
+	// opens the next section) belongs to a following span, not this one. Falling
+	// back to `lo` models the implicit "repeat from the start of the span".
+	const startIdx = span.filter(i => i.repeatStart && i.index <= endInfo.index).map(i => i.index).sort((a, b) => b - a)[0] ?? lo;
 	const times = endInfo.repeatTimes ?? 2;
 	const endingStarts = span.filter(i => i.endingStart !== undefined).map(i => i.index).sort((a, b) => a - b);
 
@@ -312,9 +316,14 @@ const buildDaCapoABA = (infos: MeasureRepeatInfo[], dcIdx: number): string | nul
 	const restCode = renderRepeatSections(infos, restLo, dcIdx);
 	if (mainCode === null || restCode === null) return null;
 
-	// main wraps in [..] only when it is a comma-separated sequence (so the ABA
-	// parser reads it as one block); a single token (e.g. "2*[..]") needs no bracket.
-	const main = /,/.test(mainCode) ? `[${mainCode}]` : mainCode;
+	// `main` is parsed by the ABA grammar as ONE item (parseItem). It needs wrapping
+	// in [..] when it is a comma sequence ("1, 2*[..]") or a BARE range ("1..37",
+	// which parseItem stops at the first number). A lone number, or a single
+	// already-structured token ("2*[..]" / "2*[..]{..}" / "[..]"), parses as one item
+	// and needs no extra bracket. `rest` is parsed as a sequence, so it only needs
+	// bracketing to group a comma sequence — a range there is fine.
+	const isSingleToken = /^\d+$/.test(mainCode) || /^\d+\*\[/.test(mainCode) || /^\[/.test(mainCode);
+	const main = isSingleToken ? mainCode : `[${mainCode}]`;
 	const rest = /,/.test(restCode) ? `[${restCode}]` : restCode;
 	return `<${main}, ${rest}>`;
 };