@viritura/score-engine 0.1.1-next.25 → 0.1.1-next.28

package/dist/index.js

@@ -582,6 +582,230 @@ function parseChordSymbolText(input, position) {
   return (!parsedQuality || parsedQuality.modifiers) && (chord.kindText = match[4]), parsedQuality?.extension !== void 0 && (chord.extension = parsedQuality.extension), match[5] && (chord.bass = parseRoot(match[5], match[6] ?? "")), chord;
 }
 
+// packages/core/src/operations/lyricExtenders.ts
+init_define_import_meta_env();
+function durationBeats(duration) {
+  let base = DURATION_BEATS[duration.base], dots = 1;
+  for (let index = 0; index < (duration.dots ?? 0); index++) dots += 0.5 ** (index + 1);
+  return base * dots;
+}
+function quantityBeats(quantity) {
+  return durationBeats(quantity.duration) * quantity.multiple;
+}
+function walkTimedContent(content, startBeat, scale, partIndex, sequenceIndex, voice, staff, measureIndex, output, ordinal) {
+  let cursor = startBeat;
+  for (let item of content) {
+    if (item.type === "event") {
+      let duration = durationBeats(item.duration) * scale;
+      output.push({
+        event: item,
+        partIndex,
+        sequenceIndex,
+        voice,
+        staff,
+        measureIndex,
+        startBeat: cursor,
+        durationBeats: duration,
+        rest: isRest(item),
+        ordinal: ordinal.value++
+      }), cursor += duration;
+      continue;
+    }
+    if (item.type === "space") {
+      cursor += 4 * item.duration[0] / item.duration[1] * scale;
+      continue;
+    }
+    if (item.type === "grace") {
+      for (let event of item.content)
+        output.push({
+          event,
+          partIndex,
+          sequenceIndex,
+          voice,
+          staff,
+          measureIndex,
+          startBeat: cursor,
+          durationBeats: 0,
+          rest: isRest(event),
+          ordinal: ordinal.value++
+        });
+      continue;
+    }
+    if (item.type === "tuplet") {
+      let inner = quantityBeats(item.inner), ratio = inner > 0 ? quantityBeats(item.outer) / inner : 1;
+      cursor = walkTimedContent(
+        item.content,
+        cursor,
+        scale * ratio,
+        partIndex,
+        sequenceIndex,
+        voice,
+        staff,
+        measureIndex,
+        output,
+        ordinal
+      );
+      continue;
+    }
+    let subdivision = item.content.length ? quantityBeats(item.outer) * scale / item.content.length : 0;
+    for (let event of item.content)
+      output.push({
+        event,
+        partIndex,
+        sequenceIndex,
+        voice,
+        staff,
+        measureIndex,
+        startBeat: cursor,
+        durationBeats: subdivision,
+        rest: isRest(event),
+        ordinal: ordinal.value++
+      }), cursor += subdivision;
+  }
+  return cursor;
+}
+function collectEvents(score) {
+  let offsets = [], measureOffset = 0, measureCount = Math.max(score.global.measures.length, ...score.parts.map((part) => part.measures.length)), activeMeter = { count: 4, unit: 4 }, meters = [];
+  for (let index = 0; index < measureCount; index++) {
+    let measure = score.global.measures[index];
+    measure?.time && (activeMeter = measure.time), meters.push(activeMeter), offsets.push(measureOffset), measureOffset += measureBeats(activeMeter);
+  }
+  let events = [], writtenSpans = Array(measureCount).fill(0), ordinal = { value: 0 };
+  for (let partIndex = 0; partIndex < score.parts.length; partIndex++) {
+    let part = score.parts[partIndex], { table } = resolveStaffMeterTimeline(
+      part.measures.map((measure) => measure.staffMeters),
+      meters
+    );
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      let measure = part.measures[measureIndex], start = offsets[measureIndex] ?? measureIndex * 4;
+      measure.sequences.forEach((sequence, sequenceIndex) => {
+        if (sequence.fullMeasure) {
+          events.push({
+            event: { type: "event", duration: sequence.fullMeasure.visualDuration, rest: {} },
+            partIndex,
+            sequenceIndex,
+            voice: sequence.voice,
+            staff: sequence.staff ?? 1,
+            measureIndex,
+            startBeat: start,
+            durationBeats: measureBeats(meters[measureIndex]),
+            rest: !0,
+            ordinal: ordinal.value++
+          });
+          return;
+        }
+        let end = walkTimedContent(
+          sequence.content,
+          start,
+          table[measureIndex]?.get(sequence.staff ?? 1) ? ratioToNumber(table[measureIndex].get(sequence.staff ?? 1).ratioToGlobal) : 1,
+          partIndex,
+          sequenceIndex,
+          sequence.voice,
+          sequence.staff ?? 1,
+          measureIndex,
+          events,
+          ordinal
+        );
+        sequence.fullMeasure || (writtenSpans[measureIndex] = Math.max(writtenSpans[measureIndex], end - start));
+      });
+    }
+  }
+  let correction = 0, corrections = [];
+  for (let index = 0; index < measureCount; index++) {
+    let nominal = measureBeats(meters[index]), measure = score.global.measures[index], written = writtenSpans[index];
+    corrections.push(correction), index === 0 && measure?.number === 0 && written > 0 ? correction += written - nominal : measure?.time?.display === "senzaMisura" && (correction += Math.max(nominal, written) - nominal);
+  }
+  for (let event of events) event.startBeat += corrections[event.measureIndex];
+  return events;
+}
+function hasLyrics(event, lineId) {
+  return event.event.lyrics?.lines?.[lineId] !== void 0;
+}
+function isEligibleSyllable(line) {
+  return line.type !== "start" && line.type !== "middle";
+}
+function sameLyricVoice(source, candidate) {
+  return source.partIndex === candidate.partIndex && source.staff === candidate.staff && (source.voice !== void 0 ? source.voice === candidate.voice : candidate.voice === void 0 && source.sequenceIndex === candidate.sequenceIndex);
+}
+function inferredTarget(source, lineId, events) {
+  let continuation = events.filter((event) => sameLyricVoice(source, event) && event.ordinal > source.ordinal).sort((left, right) => left.ordinal - right.ordinal), target;
+  for (let event of continuation) {
+    if (hasLyrics(event, lineId) || event.rest) break;
+    target = event;
+  }
+  return target;
+}
+function crossesLaterSyllable(source, target, lineId, events) {
+  return events.some(
+    (candidate) => sameLyricVoice(source, candidate) && candidate.ordinal > source.ordinal && candidate.startBeat <= target.startBeat + 1e-9 && candidate.ordinal !== target.ordinal && hasLyrics(candidate, lineId)
+  );
+}
+function resolveLyricExtenders(score) {
+  let events = collectEvents(score), byId = /* @__PURE__ */ new Map();
+  for (let event of events)
+    event.event.id && !byId.has(event.event.id) && byId.set(event.event.id, event);
+  let extenders = [], diagnostics = [], explicitPolicy = score.mnx.support?.useLyricExtenders === !0;
+  for (let source of events)
+    for (let [lineId, line] of Object.entries(source.event.lyrics?.lines ?? {})) {
+      let explicit = line.extender !== void 0;
+      if (line.extender?.show === !1 || !explicit && explicitPolicy || !explicit && !isEligibleSyllable(line))
+        continue;
+      let target;
+      if (line.extender?.target !== void 0) {
+        if (target = byId.get(line.extender.target), !target) {
+          diagnostics.push({
+            code: "missing-target",
+            sourceEventId: source.event.id,
+            lineId,
+            targetEventId: line.extender.target,
+            partIndex: source.partIndex,
+            measureIndex: source.measureIndex,
+            sequenceIndex: source.sequenceIndex
+          });
+          continue;
+        }
+        if (target.startBeat < source.startBeat - 1e-9) {
+          diagnostics.push({
+            code: "backward-target",
+            sourceEventId: source.event.id,
+            lineId,
+            targetEventId: line.extender.target,
+            partIndex: source.partIndex,
+            measureIndex: source.measureIndex,
+            sequenceIndex: source.sequenceIndex
+          });
+          continue;
+        }
+        if (target.ordinal !== source.ordinal && hasLyrics(target, lineId) || crossesLaterSyllable(source, target, lineId, events)) {
+          diagnostics.push({
+            code: "conflicting-target",
+            sourceEventId: source.event.id,
+            lineId,
+            targetEventId: line.extender.target,
+            partIndex: source.partIndex,
+            measureIndex: source.measureIndex,
+            sequenceIndex: source.sequenceIndex
+          });
+          continue;
+        }
+      } else
+        target = inferredTarget(source, lineId, events);
+      target && extenders.push({
+        sourceEventId: source.event.id,
+        targetEventId: target.event.id,
+        partIndex: source.partIndex,
+        sequenceIndex: source.sequenceIndex,
+        lineId,
+        startMeasure: source.measureIndex,
+        endMeasure: target.measureIndex,
+        startBeat: source.startBeat,
+        endBeat: target.startBeat + target.durationBeats,
+        explicit
+      });
+    }
+  return { extenders, diagnostics };
+}
+
 // packages/core/src/diagnostics.ts
 init_define_import_meta_env();
 var DiagnosticCollector = class {
@@ -1989,9 +2213,9 @@ function interpolateBeatAnchors(bounds, beat, endX) {
 
 // packages/score-engine/src/buildInfo.ts
 init_define_import_meta_env();
-var PACKAGE_VERSION = "0.1.1-next.25", BUNDLE_WORKER_FILE = "score-engine.worker.js";
+var PACKAGE_VERSION = "0.1.1-next.28", BUNDLE_WORKER_FILE = "score-engine.worker.js";
 function buildCommit() {
-  return "0b5cb2f4831eae5eb94161655beb44209649557c";
+  return "29a9ddc177a7341276fc760a1004f0dd17bfcbb2";
 }
 function bundledAssetBase() {
   let moduleUrl = import.meta.url;
@@ -15105,7 +15329,7 @@ function parseLyrics(raw) {
     let linesObj = raw.lines, lines = {};
     for (let key of Object.keys(linesObj)) {
       let lineRaw = linesObj[key], line = { text: lineRaw.text };
-      lineRaw.type !== void 0 && (line.type = lineRaw.type), lines[key] = line;
+      lineRaw.type !== void 0 && (line.type = lineRaw.type), lineRaw.extender !== void 0 && (line.extender = lineRaw.extender), lines[key] = line;
     }
     lyrics.lines = lines;
   }
@@ -15471,6 +15695,127 @@ function parseSystemDefinition(raw) {
 // packages/format/src/mnx/diagnostics.ts
 init_define_import_meta_env();
 
+// packages/format/src/mnx/knownFields.ts
+init_define_import_meta_env();
+var KEYS = {
+  root: /* @__PURE__ */ new Set(["mnx", "global", "parts", "layouts", "scores", "_x"]),
+  mnxMeta: /* @__PURE__ */ new Set(["version", "support"]),
+  support: /* @__PURE__ */ new Set(["useAccidentalDisplay", "useBeams", "useLyricExtenders"]),
+  global: /* @__PURE__ */ new Set(["measures", "lyrics"]),
+  globalLyrics: /* @__PURE__ */ new Set(["lineMetadata", "lineOrder"]),
+  globalMeasure: /* @__PURE__ */ new Set([
+    "id",
+    "number",
+    "time",
+    "key",
+    "barline",
+    "repeatStart",
+    "repeatEnd",
+    "ending",
+    "tempos",
+    "segno",
+    "fine",
+    "jump",
+    "_x"
+  ]),
+  time: /* @__PURE__ */ new Set(["count", "unit", "display", "_x"]),
+  key: /* @__PURE__ */ new Set(["fifths", "color", "_x"]),
+  barline: /* @__PURE__ */ new Set(["type"]),
+  ending: /* @__PURE__ */ new Set(["duration", "numbers", "open", "color"]),
+  tempo: /* @__PURE__ */ new Set(["bpm", "value", "location", "_x"]),
+  tempoNoteValue: /* @__PURE__ */ new Set(["base", "dots"]),
+  rhythmicPosition: /* @__PURE__ */ new Set(["fraction"]),
+  segno: /* @__PURE__ */ new Set(["location", "glyph", "color"]),
+  fine: /* @__PURE__ */ new Set(["location", "color"]),
+  jump: /* @__PURE__ */ new Set(["type", "location"]),
+  part: /* @__PURE__ */ new Set(["id", "name", "shortName", "staves", "transposition", "measures", "_x"]),
+  transposition: /* @__PURE__ */ new Set(["interval", "keyFifthsFlipAt", "prefersWrittenPitches"]),
+  partMeasure: /* @__PURE__ */ new Set([
+    "sequences",
+    "clefs",
+    "staffConfigs",
+    "arpeggios",
+    "nonArpeggios",
+    "beams",
+    "dynamics",
+    "ottavas",
+    "measureRepeat",
+    "_x"
+  ]),
+  positionedStaffConfig: /* @__PURE__ */ new Set(["config", "position", "staff", "id", "_c", "_x"]),
+  staffConfig: /* @__PURE__ */ new Set(["lines", "id", "_c", "_x"]),
+  measureRepeat: /* @__PURE__ */ new Set(["number", "counter", "displayNumber", "staffPosition", "_c", "_x"]),
+  measureRepeatCounter: /* @__PURE__ */ new Set(["count", "placement", "_c", "_x"]),
+  arpeggio: /* @__PURE__ */ new Set(["id", "position", "span", "direction", "arrow", "_c", "_x"]),
+  nonArpeggio: /* @__PURE__ */ new Set(["id", "position", "span", "_c", "_x"]),
+  idPair: /* @__PURE__ */ new Set(["start", "end"]),
+  positionedClef: /* @__PURE__ */ new Set(["clef", "position", "staff"]),
+  clef: /* @__PURE__ */ new Set(["sign", "staffPosition", "color", "glyph", "octave", "showOctave", "hide"]),
+  beam: /* @__PURE__ */ new Set(["events", "beams", "direction"]),
+  dynamic: /* @__PURE__ */ new Set(["position", "value", "glyph", "staff", "voice"]),
+  ottava: /* @__PURE__ */ new Set(["position", "end", "value", "staff", "voice"]),
+  measureRhythmicPosition: /* @__PURE__ */ new Set(["measure", "position"]),
+  sequence: /* @__PURE__ */ new Set(["content", "fullMeasure", "staff", "voice", "directionHint"]),
+  fullMeasure: /* @__PURE__ */ new Set(["visualDuration", "staffPosition"]),
+  duration: /* @__PURE__ */ new Set(["base", "dots"]),
+  event: /* @__PURE__ */ new Set([
+    "type",
+    "id",
+    "duration",
+    "staff",
+    "rest",
+    "notes",
+    "slurs",
+    "markings",
+    "fermata",
+    "lyrics",
+    "stemDirection",
+    "smufl",
+    "_x"
+  ]),
+  eventLyrics: /* @__PURE__ */ new Set(["lines"]),
+  eventLyricLine: /* @__PURE__ */ new Set(["type", "text", "extender"]),
+  eventLyricLineExtender: /* @__PURE__ */ new Set(["show", "target", "id"]),
+  rest: /* @__PURE__ */ new Set(["staffPosition"]),
+  note: /* @__PURE__ */ new Set(["pitch", "id", "ties", "accidentalDisplay", "written"]),
+  pitch: /* @__PURE__ */ new Set(["step", "octave", "alter"]),
+  tie: /* @__PURE__ */ new Set(["target", "targetType", "side", "lv"]),
+  accidentalDisplay: /* @__PURE__ */ new Set(["show", "force", "enclosure"]),
+  accidentalEnclosure: /* @__PURE__ */ new Set(["symbol"]),
+  written: /* @__PURE__ */ new Set(["diatonicDelta"]),
+  slur: /* @__PURE__ */ new Set(["target", "side", "sideEnd", "lineType", "startNote", "endNote"]),
+  markings: /* @__PURE__ */ new Set([
+    "staccato",
+    "staccatissimo",
+    "spiccato",
+    "staccatissimoWedge",
+    "tenuto",
+    "accent",
+    "strongAccent",
+    "tremolo",
+    "softAccent",
+    "stress",
+    "unstress",
+    "breath",
+    "bowDirection",
+    "_x"
+  ]),
+  tuplet: /* @__PURE__ */ new Set(["type", "inner", "outer", "content", "bracket", "showNumber", "showValue", "placement"]),
+  tupletDuration: /* @__PURE__ */ new Set(["duration", "multiple"]),
+  grace: /* @__PURE__ */ new Set(["type", "content", "graceType", "slash", "color"]),
+  multiTremolo: /* @__PURE__ */ new Set(["type", "content", "marks", "outer"]),
+  space: /* @__PURE__ */ new Set(["type", "duration"]),
+  layoutDefinition: /* @__PURE__ */ new Set(["id", "content"]),
+  layoutGroup: /* @__PURE__ */ new Set(["type", "content", "symbol", "label", "barlineStyle"]),
+  layoutStaff: /* @__PURE__ */ new Set(["type", "sources", "label", "labelref"]),
+  layoutSource: /* @__PURE__ */ new Set(["part", "staff", "stem", "voice", "labelref"]),
+  scoreDefinition: /* @__PURE__ */ new Set(["name", "layout", "multimeasureRests", "pages", "useWritten", "_x"]),
+  multimeasureRest: /* @__PURE__ */ new Set(["start", "duration"]),
+  page: /* @__PURE__ */ new Set(["systems"]),
+  system: /* @__PURE__ */ new Set(["measure", "layout", "layoutChanges"]),
+  layoutChange: /* @__PURE__ */ new Set(["layout", "location"])
+};
+
 // packages/format/src/mnx/parserCore.ts
 function parseMnxUnvalidated(json) {
   return parseMnxInternal(json, new DiagnosticCollector());
@@ -15478,7 +15823,7 @@ function parseMnxUnvalidated(json) {
 function parseSupport(supportObj) {
   if (!supportObj) return;
   let support = {};
-  return typeof supportObj.useAccidentalDisplay == "boolean" && (support.useAccidentalDisplay = supportObj.useAccidentalDisplay), typeof supportObj.useBeams == "boolean" && (support.useBeams = supportObj.useBeams), support;
+  return typeof supportObj.useAccidentalDisplay == "boolean" && (support.useAccidentalDisplay = supportObj.useAccidentalDisplay), typeof supportObj.useBeams == "boolean" && (support.useBeams = supportObj.useBeams), typeof supportObj.useLyricExtenders == "boolean" && (support.useLyricExtenders = supportObj.useLyricExtenders), support;
 }
 function parseRootMetadata(rootX) {
   let m = rootX?.viritura?.metadata;
@@ -15646,7 +15991,16 @@ function parseMnxInternal(json, diagnostics) {
     },
     parts: parseParts(partsArr)
   };
-  return globalObj?.lyrics && (score.global.lyrics = parseGlobalLyrics(globalObj.lyrics)), globalObj?.sounds && (score.global.sounds = parseGlobalSounds(globalObj.sounds)), layoutsArr && layoutsArr.length > 0 && (score.layouts = layoutsArr.map((l) => parseLayoutDefinition(l))), scoresArr && scoresArr.length > 0 && (score.scores = scoresArr.map((s) => parseScoreDefinition(s))), applyRootExtensions(score, obj._x), assignMissingIds(score), validateSupportConsistency(score, support, diagnostics), scanUnknownFields(obj, diagnostics), score;
+  globalObj?.lyrics && (score.global.lyrics = parseGlobalLyrics(globalObj.lyrics)), globalObj?.sounds && (score.global.sounds = parseGlobalSounds(globalObj.sounds)), layoutsArr && layoutsArr.length > 0 && (score.layouts = layoutsArr.map((l) => parseLayoutDefinition(l))), scoresArr && scoresArr.length > 0 && (score.scores = scoresArr.map((s) => parseScoreDefinition(s))), applyRootExtensions(score, obj._x), assignMissingIds(score), validateSupportConsistency(score, support, diagnostics);
+  for (let issue of resolveLyricExtenders(score).diagnostics) {
+    let source = issue.sourceEventId ? ` on event "${issue.sourceEventId}"` : "", message = issue.code === "missing-target" ? `Lyric extender${source} targets missing event "${issue.targetEventId}"` : issue.code === "backward-target" ? `Lyric extender${source} targets earlier event "${issue.targetEventId}"` : `Lyric extender${source} ends on an event with another syllable in lyric line "${issue.lineId}"`;
+    diagnostics.warn(
+      ptr("parts", "?", "measures", "?", "sequences", "?", "content", "?", "lyrics", "lines", issue.lineId, "extender"),
+      message,
+      "lyric-extender-reference"
+    );
+  }
+  return scanUnknownFields(obj, diagnostics), score;
 }
 function applyRootExtensions(score, rootX) {
   let metadata = parseRootMetadata(rootX);
@@ -15709,121 +16063,6 @@ function processEventIds(event, usedIds, collectOnly) {
     for (let n of event.notes)
       n.id || (n.id = mintId(usedIds));
 }
-var KEYS = {
-  root: /* @__PURE__ */ new Set(["mnx", "global", "parts", "layouts", "scores", "_x"]),
-  mnxMeta: /* @__PURE__ */ new Set(["version", "support"]),
-  support: /* @__PURE__ */ new Set(["useAccidentalDisplay", "useBeams"]),
-  global: /* @__PURE__ */ new Set(["measures", "lyrics"]),
-  globalLyrics: /* @__PURE__ */ new Set(["lineMetadata", "lineOrder"]),
-  globalMeasure: /* @__PURE__ */ new Set([
-    "id",
-    "number",
-    "time",
-    "key",
-    "barline",
-    "repeatStart",
-    "repeatEnd",
-    "ending",
-    "tempos",
-    "segno",
-    "fine",
-    "jump",
-    "_x"
-  ]),
-  time: /* @__PURE__ */ new Set(["count", "unit", "display", "_x"]),
-  key: /* @__PURE__ */ new Set(["fifths", "color", "_x"]),
-  barline: /* @__PURE__ */ new Set(["type"]),
-  ending: /* @__PURE__ */ new Set(["duration", "numbers", "open", "color"]),
-  tempo: /* @__PURE__ */ new Set(["bpm", "value", "location", "_x"]),
-  tempoNoteValue: /* @__PURE__ */ new Set(["base", "dots"]),
-  rhythmicPosition: /* @__PURE__ */ new Set(["fraction"]),
-  segno: /* @__PURE__ */ new Set(["location", "glyph", "color"]),
-  fine: /* @__PURE__ */ new Set(["location", "color"]),
-  jump: /* @__PURE__ */ new Set(["type", "location"]),
-  part: /* @__PURE__ */ new Set(["id", "name", "shortName", "staves", "transposition", "measures", "_x"]),
-  transposition: /* @__PURE__ */ new Set(["interval", "keyFifthsFlipAt", "prefersWrittenPitches"]),
-  partMeasure: /* @__PURE__ */ new Set([
-    "sequences",
-    "clefs",
-    "staffConfigs",
-    "arpeggios",
-    "nonArpeggios",
-    "beams",
-    "dynamics",
-    "ottavas",
-    "measureRepeat",
-    "_x"
-  ]),
-  positionedStaffConfig: /* @__PURE__ */ new Set(["config", "position", "staff", "id", "_c", "_x"]),
-  staffConfig: /* @__PURE__ */ new Set(["lines", "id", "_c", "_x"]),
-  measureRepeat: /* @__PURE__ */ new Set(["number", "counter", "displayNumber", "staffPosition", "_c", "_x"]),
-  measureRepeatCounter: /* @__PURE__ */ new Set(["count", "placement", "_c", "_x"]),
-  arpeggio: /* @__PURE__ */ new Set(["id", "position", "span", "direction", "arrow", "_c", "_x"]),
-  nonArpeggio: /* @__PURE__ */ new Set(["id", "position", "span", "_c", "_x"]),
-  idPair: /* @__PURE__ */ new Set(["start", "end"]),
-  positionedClef: /* @__PURE__ */ new Set(["clef", "position", "staff"]),
-  clef: /* @__PURE__ */ new Set(["sign", "staffPosition", "color", "glyph", "octave", "showOctave", "hide"]),
-  beam: /* @__PURE__ */ new Set(["events", "beams", "direction"]),
-  dynamic: /* @__PURE__ */ new Set(["position", "value", "glyph", "staff", "voice"]),
-  ottava: /* @__PURE__ */ new Set(["position", "end", "value", "staff", "voice"]),
-  measureRhythmicPosition: /* @__PURE__ */ new Set(["measure", "position"]),
-  sequence: /* @__PURE__ */ new Set(["content", "fullMeasure", "staff", "voice", "directionHint"]),
-  fullMeasure: /* @__PURE__ */ new Set(["visualDuration", "staffPosition"]),
-  duration: /* @__PURE__ */ new Set(["base", "dots"]),
-  event: /* @__PURE__ */ new Set([
-    "type",
-    "id",
-    "duration",
-    "staff",
-    "rest",
-    "notes",
-    "slurs",
-    "markings",
-    "fermata",
-    "lyrics",
-    "stemDirection",
-    "smufl",
-    "_x"
-  ]),
-  rest: /* @__PURE__ */ new Set(["staffPosition"]),
-  note: /* @__PURE__ */ new Set(["pitch", "id", "ties", "accidentalDisplay", "written"]),
-  pitch: /* @__PURE__ */ new Set(["step", "octave", "alter"]),
-  tie: /* @__PURE__ */ new Set(["target", "targetType", "side", "lv"]),
-  accidentalDisplay: /* @__PURE__ */ new Set(["show", "force", "enclosure"]),
-  accidentalEnclosure: /* @__PURE__ */ new Set(["symbol"]),
-  written: /* @__PURE__ */ new Set(["diatonicDelta"]),
-  slur: /* @__PURE__ */ new Set(["target", "side", "sideEnd", "lineType", "startNote", "endNote"]),
-  markings: /* @__PURE__ */ new Set([
-    "staccato",
-    "staccatissimo",
-    "spiccato",
-    "staccatissimoWedge",
-    "tenuto",
-    "accent",
-    "strongAccent",
-    "tremolo",
-    "softAccent",
-    "stress",
-    "unstress",
-    "breath",
-    "bowDirection",
-    "_x"
-  ]),
-  tuplet: /* @__PURE__ */ new Set(["type", "inner", "outer", "content", "bracket", "showNumber", "showValue", "placement"]),
-  tupletDuration: /* @__PURE__ */ new Set(["duration", "multiple"]),
-  grace: /* @__PURE__ */ new Set(["type", "content", "graceType", "slash", "color"]),
-  multiTremolo: /* @__PURE__ */ new Set(["type", "content", "marks", "outer"]),
-  space: /* @__PURE__ */ new Set(["type", "duration"]),
-  layoutDefinition: /* @__PURE__ */ new Set(["id", "content"]),
-  layoutGroup: /* @__PURE__ */ new Set(["type", "content", "symbol", "label", "barlineStyle"]),
-  layoutStaff: /* @__PURE__ */ new Set(["type", "sources", "label", "labelref"]),
-  layoutSource: /* @__PURE__ */ new Set(["part", "staff", "stem", "voice", "labelref"]),
-  scoreDefinition: /* @__PURE__ */ new Set(["name", "layout", "multimeasureRests", "pages", "useWritten", "_x"]),
-  multimeasureRest: /* @__PURE__ */ new Set(["start", "duration"]),
-  page: /* @__PURE__ */ new Set(["systems"]),
-  system: /* @__PURE__ */ new Set(["measure", "layout", "layoutChanges"]),
-  layoutChange: /* @__PURE__ */ new Set(["layout", "location"])
-};
 function scanUnknownFields(json, dx) {
   if (!json || typeof json != "object") return;
   let root = json;
@@ -15937,6 +16176,19 @@ function scanContentItem(c, p, dx) {
   let type = c.type ?? "event";
   if (type === "event") {
     emitUnknown(c, KEYS.event, p, dx);
+    let lyrics = c.lyrics;
+    if (lyrics) {
+      emitUnknown(lyrics, KEYS.eventLyrics, p + ptr("lyrics"), dx);
+      let lines = lyrics.lines;
+      if (lines && typeof lines == "object")
+        for (let [lineId, line] of Object.entries(lines)) {
+          if (!line || typeof line != "object") continue;
+          let linePath = p + ptr("lyrics", "lines", lineId);
+          emitUnknown(line, KEYS.eventLyricLine, linePath, dx);
+          let extender = line.extender;
+          extender && emitUnknown(extender, KEYS.eventLyricLineExtender, linePath + ptr("extender"), dx);
+        }
+    }
     let notes = c.notes;
     Array.isArray(notes) && notes.forEach((n, i) => {
       n && typeof n == "object" && emitUnknown(n, KEYS.note, p + ptr("notes", i), dx);
@@ -16419,7 +16671,7 @@ function fermataMultiplier(fermata) {
 function caesuraBeats(style) {
   return style === "short" ? CAESURA_SHORT_BEATS : CAESURA_BEATS;
 }
-function durationBeats(d) {
+function durationBeats2(d) {
   let base = DURATION_BEATS[d.base] ?? 1;
   return d.dots ? base * (2 - Math.pow(2, -d.dots)) : base;
 }
@@ -16437,16 +16689,16 @@ function collectFromContent(content, startBeat, ratio, spans, caesuraByBeat) {
   let cursor = startBeat;
   for (let item of content)
     if (item.type === "event") {
-      let dur = durationBeats(item.duration) * ratio, endBeat = cursor + dur;
+      let dur = durationBeats2(item.duration) * ratio, endBeat = cursor + dur;
       if (item.fermata && item.fermata.duration !== "none") {
         let mult = fermataMultiplier(item.fermata);
         dur > 0 && mult > 1 && spans.push({ onset: cursor, end: endBeat, duration: dur, multiplier: mult });
       }
       item.markings?.caesura && mergeMax(caesuraByBeat, endBeat, caesuraBeats(item.markings.caesura.style)), cursor = endBeat;
     } else if (item.type === "tuplet") {
-      let outerBeats = durationBeats(item.outer.duration) * item.outer.multiple, innerBeats = durationBeats(item.inner.duration) * item.inner.multiple, childRatio = innerBeats > 0 ? outerBeats / innerBeats * ratio : ratio;
+      let outerBeats = durationBeats2(item.outer.duration) * item.outer.multiple, innerBeats = durationBeats2(item.inner.duration) * item.inner.multiple, childRatio = innerBeats > 0 ? outerBeats / innerBeats * ratio : ratio;
       collectFromContent(item.content, cursor, childRatio, spans, caesuraByBeat), cursor += outerBeats * ratio;
-    } else item.type === "tremolo" ? cursor += durationBeats(item.outer.duration) * item.outer.multiple * ratio : item.type === "space" && (cursor += item.duration[0] / item.duration[1] * 4 * ratio);
+    } else item.type === "tremolo" ? cursor += durationBeats2(item.outer.duration) * item.outer.multiple * ratio : item.type === "space" && (cursor += item.duration[0] / item.duration[1] * 4 * ratio);
   return cursor - startBeat;
 }
 function collectPartMeasureHolds(partMeasure, originalMeasureIndex, staffMeterTable, spans, caesuraByBeat) {
@@ -16509,21 +16761,21 @@ function contentBeats(content) {
   for (let item of content)
     switch (item.type) {
       case "event":
-        beats += durationBeats2(item.duration.base, item.duration.dots);
+        beats += durationBeats3(item.duration.base, item.duration.dots);
         break;
       case "space":
         beats += item.duration[0] / item.duration[1] * 4;
         break;
       case "tuplet":
       case "tremolo":
-        beats += durationBeats2(item.outer.duration.base, item.outer.duration.dots) * item.outer.multiple;
+        beats += durationBeats3(item.outer.duration.base, item.outer.duration.dots) * item.outer.multiple;
         break;
       case "grace":
         break;
     }
   return beats;
 }
-function durationBeats2(base, dots) {
+function durationBeats3(base, dots) {
   let beats = DURATION_BEATS[base];
   return dots ? beats * (2 - Math.pow(2, -dots)) : beats;
 }
@@ -17610,7 +17862,7 @@ function kitNoteToMidi(kn, kitMidiMap) {
   return kitMidiMap.get(kn.kitComponent) ?? -1;
 }
 var GRACE_NOTE_BEATS = 0.125;
-function durationBeats3(d) {
+function durationBeats4(d) {
   let base = DURATION_BEATS[d.base] ?? 1;
   return d.dots ? base * (2 - Math.pow(2, -d.dots)) : base;
 }
@@ -17927,7 +18179,7 @@ function tryProcessSpecialEvent(ctx, event, measureStartTime, beatOffset, baseVe
 }
 function processNoteEvent(ctx, event, measureStartTime, beatOffset, baseVelocity, tupletRatio) {
   ctx.gmProgram = ctx.instrumentAtBeatOffset?.(beatOffset * ctx.staffMeterRatio).program ?? ctx.gmProgram;
-  let { partIndex, channel, tieTargets, out, timeSig, kitMidiMap, kitAltProgramMap } = ctx, beats = durationBeats3(event.duration) * tupletRatio;
+  let { partIndex, channel, tieTargets, out, timeSig, kitMidiMap, kitAltProgramMap } = ctx, beats = durationBeats4(event.duration) * tupletRatio;
   if (isRest(event))
     return flushVoiceLegato(ctx.pendingLegato, ctx.voiceKey, ctx.out), beats;
   resolveVoiceLegato({
@@ -18240,30 +18492,30 @@ function processGrace(ctx, grace, measureStartTime, beatOffset, tupletRatio) {
   if (grace.graceType === "stealFollowing") {
     let cursor2 = beatOffset;
     for (let evt of events) {
-      let ratio = graceBeats / durationBeats3(evt.duration);
+      let ratio = graceBeats / durationBeats4(evt.duration);
       processScopedNoteEvent(ctx, evt, measureStartTime, cursor2, ratio), cursor2 += graceBeats;
     }
     return totalGraceBeats;
   }
   let cursor = beatOffset - totalGraceBeats;
   for (let evt of events) {
-    let ratio = graceBeats / durationBeats3(evt.duration);
+    let ratio = graceBeats / durationBeats4(evt.duration);
     processScopedNoteEvent(ctx, evt, measureStartTime, cursor, ratio), cursor += graceBeats;
   }
   return 0;
 }
 function processTuplet(ctx, tuplet, measureStartTime, beatOffset, parentTupletRatio) {
-  let outerBeats = durationBeats3(tuplet.outer.duration) * tuplet.outer.multiple, innerBeats = durationBeats3(tuplet.inner.duration) * tuplet.inner.multiple, ratio = outerBeats / innerBeats * parentTupletRatio, cursor = beatOffset;
+  let outerBeats = durationBeats4(tuplet.outer.duration) * tuplet.outer.multiple, innerBeats = durationBeats4(tuplet.inner.duration) * tuplet.inner.multiple, ratio = outerBeats / innerBeats * parentTupletRatio, cursor = beatOffset;
   for (let item of tuplet.content)
     cursor += processContentItem(ctx, item, measureStartTime, cursor, ratio);
   return outerBeats * parentTupletRatio;
 }
 function processTremolo(ctx, tremolo, measureStartTime, beatOffset, tupletRatio) {
-  let outerBeats = durationBeats3(tremolo.outer.duration) * tremolo.outer.multiple * tupletRatio;
+  let outerBeats = durationBeats4(tremolo.outer.duration) * tremolo.outer.multiple * tupletRatio;
   if (tremolo.content.length < 2) return outerBeats;
   let subdivisions = Math.pow(2, tremolo.marks), subdivBeats = outerBeats / subdivisions;
   for (let s = 0; s < subdivisions; s++) {
-    let noteEvent = tremolo.content[s % 2], subBeatOffset = beatOffset + s * subdivBeats, subRatio = subdivBeats / durationBeats3(noteEvent.duration);
+    let noteEvent = tremolo.content[s % 2], subBeatOffset = beatOffset + s * subdivBeats, subRatio = subdivBeats / durationBeats4(noteEvent.duration);
     processScopedNoteEvent(ctx, noteEvent, measureStartTime, subBeatOffset, subRatio);
   }
   return outerBeats;