@viritura/score-engine 0.1.1-next.7 → 0.1.1-next.9

package/dist/index.js

@@ -53,6 +53,44 @@ function plainTextContent(content) {
   return content.map((chunk) => "text" in chunk ? chunk.text : "").join("");
 }
 
+// packages/core/src/model/instrumentChange.ts
+init_define_import_meta_env();
+var MEASURE_START = [0, 1];
+function comparePositions(a, b) {
+  return a[0] * b[1] - b[0] * a[1];
+}
+function changePosition(change) {
+  return change.position?.fraction ?? MEASURE_START;
+}
+function initialInstrumentState(part) {
+  let ext = part._x?.viritura, instrumentKey = ext?.initialInstrument, instrument = instrumentKey !== void 0 && ext?.instruments && Object.hasOwn(ext.instruments, instrumentKey) ? ext.instruments[instrumentKey] : void 0, transposition = part.transposition ?? instrument?.transposition;
+  return {
+    ...instrumentKey !== void 0 ? { instrumentKey } : {},
+    ...instrument ? { instrument } : {},
+    ...transposition ? { transposition } : {}
+  };
+}
+function applyChange(part, state, change) {
+  if (change.instrument === void 0)
+    return { ...state, ...change.transposition ? { transposition: change.transposition } : {} };
+  let instruments = part._x?.viritura?.instruments, instrument = instruments && Object.hasOwn(instruments, change.instrument) ? instruments[change.instrument] : void 0, transposition = change.transposition ?? instrument?.transposition;
+  return {
+    instrumentKey: change.instrument,
+    ...instrument ? { instrument } : {},
+    ...transposition ? { transposition } : {}
+  };
+}
+function listInstrumentChanges(part) {
+  let located = [], state = initialInstrumentState(part);
+  return part.measures.forEach((measure, measureIndex) => {
+    let ordered = [...measure.instrumentChanges ?? []].sort(
+      (a, b) => comparePositions(changePosition(a), changePosition(b))
+    );
+    for (let change of ordered)
+      state = applyChange(part, state, change), located.push({ measureIndex, position: changePosition(change), change, state });
+  }), located;
+}
+
 // packages/core/src/model/event.ts
 init_define_import_meta_env();
 function isRest(event) {
@@ -1870,9 +1908,9 @@ function interpolateBeatAnchors(bounds, beat, endX) {
 
 // packages/score-engine/src/buildInfo.ts
 init_define_import_meta_env();
-var PACKAGE_VERSION = "0.1.1-next.7", BUNDLE_WORKER_FILE = "score-engine.worker.js";
+var PACKAGE_VERSION = "0.1.1-next.9", BUNDLE_WORKER_FILE = "score-engine.worker.js";
 function buildCommit() {
-  return "5f67e97a568c1617adbc7221871d70f7cb1fa821";
+  return "8f2a6533eef0ec77252c76925031cfbc732e3271";
 }
 function bundledAssetBase() {
   let moduleUrl = import.meta.url;
@@ -2764,26 +2802,36 @@ function parsePart(raw) {
     name: raw.name ?? "",
     measures: parsePartMeasures(raw.measures)
   };
-  if (raw.id && (part.id = raw.id), raw.shortName !== void 0 && (part.shortName = raw.shortName), raw.staves !== void 0 && (part.staves = raw.staves), raw.transposition) {
-    let t = raw.transposition;
-    part.transposition = {
-      interval: {
-        halfSteps: t.interval.halfSteps,
-        staffDistance: t.interval.staffDistance
-      }
-    }, t.keyFifthsFlipAt !== void 0 && (part.transposition.keyFifthsFlipAt = t.keyFifthsFlipAt), t.prefersWrittenPitches !== void 0 && (part.transposition.prefersWrittenPitches = t.prefersWrittenPitches);
-  }
-  raw.kit && (part.kit = parseKit(raw.kit));
+  raw.id && (part.id = raw.id), raw.shortName !== void 0 && (part.shortName = raw.shortName), raw.staves !== void 0 && (part.staves = raw.staves), raw.transposition && (part.transposition = parseTransposition(raw.transposition)), raw.kit && (part.kit = parseKit(raw.kit));
   let viritura = raw._x?.viritura;
   if (viritura) {
     viritura.chordSymbolVisibility !== void 0 && (part.chordSymbolVisibility = viritura.chordSymbolVisibility);
     let ext = {};
     typeof viritura.instrumentId == "string" && (ext.instrumentId = viritura.instrumentId), typeof viritura.midiProgram == "number" && (ext.midiProgram = viritura.midiProgram), typeof viritura.family == "string" && (ext.family = viritura.family);
     let sp = viritura.spatial;
-    sp && typeof sp.x == "number" && typeof sp.y == "number" && (ext.spatial = { x: sp.x, y: sp.y }), Object.keys(ext).length > 0 && (part._x = { viritura: ext });
+    sp && typeof sp.x == "number" && typeof sp.y == "number" && (ext.spatial = { x: sp.x, y: sp.y }), viritura.instruments && (ext.instruments = Object.fromEntries(
+      Object.entries(viritura.instruments).map(([key, instrument]) => [key, parseInstrumentDefinition(instrument)])
+    )), viritura.initialInstrument !== void 0 && (ext.initialInstrument = viritura.initialInstrument), Object.keys(ext).length > 0 && (part._x = { viritura: ext });
   }
   return part;
 }
+function parseTransposition(t) {
+  let transposition = {
+    interval: {
+      halfSteps: t.interval.halfSteps,
+      staffDistance: t.interval.staffDistance
+    }
+  };
+  return t.keyFifthsFlipAt !== void 0 && (transposition.keyFifthsFlipAt = t.keyFifthsFlipAt), t.prefersWrittenPitches !== void 0 && (transposition.prefersWrittenPitches = t.prefersWrittenPitches), transposition;
+}
+function parseInstrumentDefinition(raw) {
+  let instrument = { instrumentId: raw.instrumentId };
+  return raw.name !== void 0 && (instrument.name = raw.name), raw.shortName !== void 0 && (instrument.shortName = raw.shortName), raw.transposition && (instrument.transposition = parseTransposition(raw.transposition)), raw.midiProgram !== void 0 && (instrument.midiProgram = raw.midiProgram), instrument;
+}
+function parseInstrumentChange(raw) {
+  let change = {};
+  return raw.position && (change.position = parseRhythmicPosition(raw.position)), raw.instrument !== void 0 && (change.instrument = raw.instrument), raw.transposition && (change.transposition = parseTransposition(raw.transposition)), raw.instruction && (change.instruction = {}, raw.instruction.text !== void 0 && (change.instruction.text = raw.instruction.text), raw.instruction.hidden !== void 0 && (change.instruction.hidden = raw.instruction.hidden)), raw.reminder && (change.reminder = {}, raw.reminder.text !== void 0 && (change.reminder.text = raw.reminder.text), raw.reminder.hidden !== void 0 && (change.reminder.hidden = raw.reminder.hidden)), change;
+}
 function parseKit(raw) {
   let result = {};
   for (let [id, value] of Object.entries(raw))
@@ -2812,7 +2860,7 @@ function parsePartMeasure(raw) {
   return viritura && (viritura.pedals && (pm.pedals = viritura.pedals.map(parsePedal)), viritura.expressions && (pm.expressions = viritura.expressions.map(parseTextExpression)), viritura.condensingOverride && (pm.condensingOverride = viritura.condensingOverride), viritura.groupingDisplayOverrides && viritura.groupingDisplayOverrides.length > 0 && (pm.groupingDisplayOverrides = viritura.groupingDisplayOverrides.map((override) => ({
     staff: override.staff,
     groupingDisplay: override.groupingDisplay
-  }))), viritura.staffMeters && viritura.staffMeters.length > 0 && (pm.staffMeters = viritura.staffMeters.map(parseStaffMeterChange))), pm;
+  }))), viritura.staffMeters && viritura.staffMeters.length > 0 && (pm.staffMeters = viritura.staffMeters.map(parseStaffMeterChange)), viritura.instrumentChanges && viritura.instrumentChanges.length > 0 && (pm.instrumentChanges = viritura.instrumentChanges.map(parseInstrumentChange))), pm;
 }
 function parseStaffMeterChange(raw) {
   if ("useGlobal" in raw)
@@ -2876,6 +2924,17 @@ function parsePositionedStaffConfig(raw) {
   return raw.id !== void 0 && (positioned.id = raw.id), raw._c !== void 0 && (positioned._c = raw._c), raw._x !== void 0 && (positioned._x = raw._x), raw.position && (positioned.position = parseRhythmicPosition(raw.position)), raw.staff !== void 0 && (positioned.staff = raw.staff), positioned;
 }
 
+// packages/format/src/mnx/parseInstrumentChangeStyle.ts
+init_define_import_meta_env();
+function parseRootInstrumentChangeStyle(rootX) {
+  let raw = rootX?.viritura?.instrumentChangeStyle;
+  if (raw)
+    return {
+      ...typeof raw.showChangeLabel == "boolean" ? { showChangeLabel: raw.showChangeLabel } : {},
+      ...typeof raw.showAdvanceReminder == "boolean" ? { showAdvanceReminder: raw.showAdvanceReminder } : {}
+    };
+}
+
 // packages/format/src/mnx/parseLayout.ts
 init_define_import_meta_env();
 function parseLayoutDefinition(raw) {
@@ -3184,6 +3243,8 @@ function applyRootExtensions(score, rootX) {
   timeSignatures && (score.timeSignatures = timeSignatures);
   let chordSymbolStyle = parseRootChordSymbolStyle(rootX);
   chordSymbolStyle && (score.chordSymbolStyle = chordSymbolStyle);
+  let instrumentChangeStyle = parseRootInstrumentChangeStyle(rootX);
+  instrumentChangeStyle && (score.instrumentChangeStyle = instrumentChangeStyle);
   let soundProfile = parseRootSoundProfile(rootX);
   soundProfile && (score.soundProfile = soundProfile);
   let videoSync = parseRootVideoSync(rootX);
@@ -4250,11 +4311,13 @@ function applyMeasureTechniques(expressions, ctx, state, caps, ratioForStaff = (
   let marks = expressions.map((e) => ({
     action: classifyTechniqueText(plainTextContent(e.text)),
     beat: fractionToBeats(e.position.fraction) * ratioForStaff(e.staff)
-  })).filter((m) => m.action !== null).sort((a, b) => a.beat - b.beat), { program, muted } = state;
+  })).filter((m) => m.action !== null).sort((a, b) => a.beat - b.beat), { program, muted } = state, instrumentKey = state.instrumentKey ?? ctx.instrumentAtBeatOffset?.(0).key;
   for (let mark of marks) {
-    let time = ctx.model.timeAtBeat(ctx.measureStartBeat + mark.beat);
-    if (mark.action.kind === "bow" && caps.bow) {
-      let target = mark.action.pizz ? GM_PIZZICATO_STRINGS : ctx.gmProgram;
+    let instrument = ctx.instrumentAtBeatOffset?.(mark.beat), baselineProgram = instrument?.program ?? ctx.gmProgram;
+    instrument && instrument.key !== instrumentKey && (program = baselineProgram, muted = !1, instrumentKey = instrument.key);
+    let bowCapable = instrument ? ARCO_CAPABLE_PROGRAMS.has(baselineProgram) : caps.bow, muteFamily = instrument ? muteFamilyForProgram(baselineProgram) : caps.mute, time = ctx.model.timeAtBeat(ctx.measureStartBeat + mark.beat);
+    if (mark.action.kind === "bow" && bowCapable) {
+      let target = mark.action.pizz ? GM_PIZZICATO_STRINGS : baselineProgram;
       if (target === program) continue;
       program = target, ctx.out.push({
         type: "programChange",
@@ -4265,14 +4328,136 @@ function applyMeasureTechniques(expressions, ctx, state, caps, ratioForStaff = (
         channel: ctx.channel,
         program: target
       });
-    } else if (mark.action.kind === "mute" && caps.mute) {
+    } else if (mark.action.kind === "mute" && muteFamily) {
       if (mark.action.muted === muted) continue;
       muted = mark.action.muted;
-      let curve = muted ? MUTE_CURVES[caps.mute] : OPEN_CURVE;
+      let curve = muted ? MUTE_CURVES[muteFamily] : OPEN_CURVE;
       emitCc(ctx, time, CC_BRIGHTNESS, curve.brightness), emitCc(ctx, time, CC_RESONANCE, curve.resonance);
     }
   }
-  return { program, muted };
+  return { program, muted, ...instrumentKey === void 0 ? {} : { instrumentKey } };
+}
+
+// packages/midi/src/instrumentPlayback/index.ts
+init_define_import_meta_env();
+function instrumentPart(part, instrument) {
+  return instrument ? {
+    ...part,
+    name: instrument.name ?? part.name,
+    _x: {
+      ...part._x,
+      viritura: {
+        ...part._x?.viritura,
+        instrumentId: instrument.instrumentId,
+        midiProgram: instrument.midiProgram,
+        initialInstrument: void 0,
+        instruments: void 0
+      }
+    }
+  } : part;
+}
+function playbackInstruments(part) {
+  let initial = initialInstrumentState(part);
+  if (initial.instrumentKey !== void 0 && !initial.instrument)
+    throw new Error(`Unknown initial instrument "${initial.instrumentKey}" in "${part.name}".`);
+  let result = [{ key: "initial", part: instrumentPart(part, initial.instrument) }], seen = /* @__PURE__ */ new Set();
+  for (let located of listInstrumentChanges(part)) {
+    let [numerator, denominator] = located.position;
+    if (denominator <= 0 || numerator < 0) throw new Error(`Invalid instrument-change position in "${part.name}".`);
+    let key = located.change.instrument;
+    if (!(key === void 0 || seen.has(key))) {
+      if (!located.state.instrument) throw new Error(`Unknown instrument "${key}" in "${part.name}".`);
+      seen.add(key), result.push({ key: `instrument:${key}`, part: instrumentPart(part, located.state.instrument) });
+    }
+  }
+  return result;
+}
+function playbackInstrumentKeyAt(part, measureIndex, beatOffset = 0) {
+  let key = "initial";
+  for (let located of listInstrumentChanges(part)) {
+    if (located.measureIndex > measureIndex || located.measureIndex === measureIndex && located.position[0] / located.position[1] * 4 > beatOffset) break;
+    located.change.instrument !== void 0 && (key = `instrument:${located.change.instrument}`);
+  }
+  return key;
+}
+function boundariesForPart(part, timing, programs, initialProgram) {
+  let instruments = playbackInstruments(part), definitions = new Map(instruments.map((instrument) => [instrument.key, instrument.part])), changes = listInstrumentChanges(part).filter((located) => located.change.instrument !== void 0), boundaries = [], add = (beat, key) => {
+    let program = programs?.get(key) ?? (key === "initial" ? initialProgram : void 0) ?? definitions.get(key)?._x?.viritura?.midiProgram;
+    boundaries.push({
+      beat,
+      time: timing.model.timeAtBeat(beat),
+      key,
+      program: typeof program == "number" && Number.isInteger(program) && program >= 0 && program <= 127 ? program : void 0
+    });
+  };
+  return timing.measureOrder.forEach((measureIndex, expandedIndex) => {
+    let start = timing.measureStartBeats[expandedIndex];
+    add(start, playbackInstrumentKeyAt(part, measureIndex));
+    for (let located of changes) {
+      if (located.measureIndex !== measureIndex || located.position[0] === 0) continue;
+      let [numerator, denominator] = located.position;
+      if (denominator <= 0 || numerator < 0) throw new Error(`Invalid instrument-change position in "${part.name}".`);
+      add(start + numerator / denominator * 4, `instrument:${located.change.instrument}`);
+    }
+  }), boundaries;
+}
+function applyInstrumentPlayback(score, events, timing, programs, initialPrograms) {
+  let diagnostics = [];
+  return score.parts.forEach((part, partIndex) => {
+    if (playbackInstruments(part).length === 1) return;
+    let boundaries = boundariesForPart(part, timing, programs?.get(partIndex), initialPrograms?.[partIndex]), partEvents = events.filter((event) => event.partIndex === partIndex), lanes = new Set(partEvents.flatMap((event) => event.playbackLaneId ? [event.playbackLaneId] : []));
+    lanes.size === 0 && lanes.add(`part:${partIndex}`);
+    let missingPrograms = [
+      ...new Set(boundaries.filter((boundary) => boundary.program === void 0).map((boundary) => boundary.key))
+    ];
+    missingPrograms.length > 0 && diagnostics.push({
+      code: "instrument-program-unavailable",
+      message: `Physical MIDI cannot select ${missingPrograms.join(", ")} in "${part.name}"; provide resolved instrumentPrograms or a MIDI program fallback.`,
+      playbackLaneIds: [...lanes]
+    });
+    for (let event of [...partEvents]) {
+      if (event.playbackLaneId) continue;
+      let [first, ...others] = lanes;
+      event.playbackLaneId = first;
+      for (let lane of others) {
+        let scoped = { ...event, playbackLaneId: lane };
+        events.push(scoped), partEvents.push(scoped);
+      }
+    }
+    let attackDelays = /* @__PURE__ */ new Map(), attackKey = (event) => JSON.stringify([event.playbackLaneId, event.channel, event.midiNote, event.scoreBeat, event.scoreEventId]);
+    for (let event of partEvents) {
+      if (event.type === "controlChange" && event.cc !== 74 && event.cc !== 71) continue;
+      let beat = event.scoreBeat ?? timing.model.beatAtTime(event.time), instrument = "initial", instrumentStart = 0;
+      for (let boundary of boundaries) {
+        if (boundary.beat > beat + 1e-9) break;
+        instrument = boundary.key, instrumentStart = boundary.time;
+      }
+      if (event.type === "noteOn") {
+        let delay = Math.max(0, instrumentStart - event.time);
+        attackDelays.set(attackKey(event), delay), event.time = Math.max(event.time, instrumentStart);
+      }
+      event.playbackInstrumentKey = instrument;
+    }
+    for (let event of partEvents)
+      event.type === "noteOff" && (event.time += attackDelays.get(attackKey(event)) ?? 0);
+    for (let lane of lanes) {
+      let previous;
+      for (let boundary of boundaries)
+        boundary.key !== previous && (previous = boundary.key, events.push({
+          type: "programChange",
+          time: boundary.time,
+          scoreBeat: boundary.beat,
+          midiNote: 0,
+          velocity: 0,
+          partIndex,
+          playbackLaneId: lane,
+          channel: partEvents.find((event) => event.playbackLaneId === lane)?.channel ?? 0,
+          playbackInstrumentKey: boundary.key,
+          instrumentChange: !0,
+          program: boundary.program
+        }));
+    }
+  }), diagnostics;
 }
 
 // packages/midi/src/tempoMap.ts
@@ -5058,12 +5243,20 @@ function generateTimeline(inputScore, options) {
     );
   if (chords)
     for (let event of chordMidiEvents(chords, measureOrder, tempoBuild)) allEvents.push(event);
-  let diagnostics = assignPhysicalMidiChannels(allEvents, score), EVENT_TYPE_ORDER = { noteOff: 0, programChange: 1, controlChange: 1, noteOn: 2 };
-  allEvents.sort((a, b) => {
+  let EVENT_TYPE_ORDER = { noteOff: 0, programChange: 1, controlChange: 1, noteOn: 2 }, compareEvents = (a, b) => {
     if (Math.abs(a.time - b.time) > 1e-9) return a.time - b.time;
     let aOrder = EVENT_TYPE_ORDER[a.type] ?? 1, bOrder = EVENT_TYPE_ORDER[b.type] ?? 1;
-    return aOrder !== bOrder ? aOrder - bOrder : a.midiNote - b.midiNote;
-  });
+    return aOrder !== bOrder ? aOrder - bOrder : a.instrumentChange !== b.instrumentChange ? a.instrumentChange ? -1 : 1 : a.midiNote - b.midiNote;
+  };
+  allEvents.sort(compareEvents);
+  let instrumentDiagnostics = applyInstrumentPlayback(
+    score,
+    allEvents,
+    { model, measureStartBeats, measureOrder },
+    options?.instrumentPrograms,
+    options?.partPrograms
+  ), diagnostics = [...assignPhysicalMidiChannels(allEvents, score), ...instrumentDiagnostics];
+  allEvents.sort(compareEvents);
   let duration = model.timeAtBeat(tempoBuild.totalBeats), measureTimeSignatures = measureOrder.map((origIdx) => {
     let ts = resolveActiveTime(globalMeasures, origIdx);
     return { count: ts.count, unit: ts.unit };
@@ -5179,11 +5372,13 @@ function processPart(score, partIdx, options, partChannels, timing, measureOrder
   );
   for (let lane of dynamicProgram.lanes.values())
     emitDynamicsCc11(lane.envelope, partIdx, channel, allEvents, lane.id);
-  let bowCapable = ARCO_CAPABLE_PROGRAMS.has(gmProgram), muteFamily = muteFamilyForProgram(gmProgram), techniqueEnabled = bowCapable || muteFamily !== null, techniqueState = { program: gmProgram, muted: !1 };
+  let techniqueState = { program: gmProgram, muted: !1, instrumentKey: "initial" }, instruments = new Map(playbackInstruments(part).map(({ key, part: instrumentPart2 }) => [key, instrumentPart2])), programForInstrument = (key) => key === "initial" ? gmProgram : options?.instrumentPrograms?.get(partIdx)?.get(key) ?? instruments.get(key)?._x?.viritura?.midiProgram ?? -1;
   for (let expandedIdx = 0; expandedIdx < measureOrder.length; expandedIdx++) {
     let origMeasureIdx = measureOrder[expandedIdx], partMeasure = part.measures[origMeasureIdx];
     if (!partMeasure) continue;
-    let measureStartTime = measureStartTimes[expandedIdx], measureStartBeat = measureStartBeats[expandedIdx], activeTime = resolveActiveTime(globalMeasures, origMeasureIdx), activeKeyFifths = resolveActiveKeyFifths(globalMeasures, origMeasureIdx), measureHolds = holdSchedule[expandedIdx] ?? [], measureSpq = model.spbAtBeat(measureStartBeat), fermataGroups = measureHolds.filter((h) => h.kind === "fermata").map((h) => ({
+    let measureStartTime = measureStartTimes[expandedIdx], measureStartBeat = measureStartBeats[expandedIdx], instrumentKey = playbackInstrumentKeyAt(part, origMeasureIdx), activeProgram = programForInstrument(instrumentKey), bowCapable = ARCO_CAPABLE_PROGRAMS.has(activeProgram), muteFamily = muteFamilyForProgram(activeProgram), techniqueEnabled = bowCapable || muteFamily !== null;
+    instrumentKey !== techniqueState.instrumentKey && (techniqueState = { program: activeProgram, muted: !1, instrumentKey });
+    let activeTime = resolveActiveTime(globalMeasures, origMeasureIdx), activeKeyFifths = resolveActiveKeyFifths(globalMeasures, origMeasureIdx), measureHolds = holdSchedule[expandedIdx] ?? [], measureSpq = model.spbAtBeat(measureStartBeat), fermataGroups = measureHolds.filter((h) => h.kind === "fermata").map((h) => ({
       startBeat: h.startBeat ?? h.atBeat,
       spanEndBeat: h.spanEndBeat ?? h.atBeat,
       insertBeat: h.atBeat
@@ -5199,7 +5394,11 @@ function processPart(score, partIdx, options, partChannels, timing, measureOrder
       pendingLegato,
       voiceKey: "",
       out: allEvents,
-      gmProgram,
+      gmProgram: activeProgram,
+      instrumentAtBeatOffset: instruments.size > 1 ? (offset) => {
+        let key = playbackInstrumentKeyAt(part, origMeasureIdx, offset);
+        return { key, program: programForInstrument(key) };
+      } : void 0,
       timeSig: activeTime,
       staffMeterRatio: 1,
       keyFifths: activeKeyFifths,
@@ -5213,7 +5412,7 @@ function processPart(score, partIdx, options, partChannels, timing, measureOrder
       measureSpq,
       fermataGroups
     };
-    techniqueEnabled && (techniqueState = applyMeasureTechniques(
+    (techniqueEnabled || instruments.size > 1) && (techniqueState = applyMeasureTechniques(
       partMeasure.expressions,
       ctx,
       techniqueState,
@@ -5313,6 +5512,7 @@ function tryProcessSpecialEvent(ctx, event, measureStartTime, beatOffset, baseVe
   return tremoloMarks && tremoloMarks >= 1 && tremoloMarks <= 3 ? processSingleNoteTremolo(ctx, event, measureStartTime, beatOffset, baseVelocity, beats, tremoloMarks) : event.markings?.trill && tryProcessTrill(ctx, event, measureStartTime, beatOffset, baseVelocity, beats) ? beats : null;
 }
 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;
   if (isRest(event))
     return flushVoiceLegato(ctx.pendingLegato, ctx.voiceKey, ctx.out), beats;
@@ -5386,7 +5586,8 @@ function processNoteEvent(ctx, event, measureStartTime, beatOffset, baseVelocity
         velocity: 0,
         partIndex,
         channel,
-        drumKitProgram
+        drumKitProgram,
+        ...ctx.instrumentAtBeatOffset ? { scoreBeat: ctx.measureStartBeat + beatOffset * ctx.staffMeterRatio } : {}
       });
     }
   }
@@ -5421,7 +5622,8 @@ function emitFreshNote(ctx, midiNote, startTime, timingOffset, durationSec, dura
       midiNote,
       velocity: 0,
       partIndex,
-      channel
+      channel,
+      ...ctx.instrumentAtBeatOffset ? metadata : {}
     });
   } else {
     let off = {
@@ -5430,7 +5632,8 @@ function emitFreshNote(ctx, midiNote, startTime, timingOffset, durationSec, dura
       midiNote,
       velocity: 0,
       partIndex,
-      channel
+      channel,
+      ...ctx.instrumentAtBeatOffset ? metadata : {}
     };
     legatoOut ? pushVoiceLegato(ctx.pendingLegato, ctx.voiceKey, off) : out.push(off);
   }
@@ -5478,7 +5681,8 @@ function processKitRoll(ctx, event, measureStartTime, beatOffset, baseVelocity,
       velocity: 0,
       partIndex,
       channel,
-      drumKitProgram
+      drumKitProgram,
+      ...ctx.instrumentAtBeatOffset ? { scoreBeat: ctx.measureStartBeat + beatOffset * ctx.staffMeterRatio } : {}
     });
   }
   return beats;
@@ -5515,7 +5719,15 @@ function processSingleNoteTremolo(ctx, event, measureStartTime, beatOffset, base
         scoreBeat: ctx.measureStartBeat + beatOffset * ctx.staffMeterRatio,
         scoreDurationBeats: totalBeats * ctx.staffMeterRatio,
         scoreEventId: event.id
-      }), out.push({ type: "noteOff", time: jitteredTremStart + durationSec, midiNote, velocity: 0, partIndex, channel }));
+      }), out.push({
+        type: "noteOff",
+        time: jitteredTremStart + durationSec,
+        midiNote,
+        velocity: 0,
+        partIndex,
+        channel,
+        ...ctx.instrumentAtBeatOffset ? { scoreBeat: ctx.measureStartBeat + beatOffset * ctx.staffMeterRatio } : {}
+      }));
     }
     return out.push({
       type: "programChange",
@@ -5548,7 +5760,8 @@ function processSingleNoteTremolo(ctx, event, measureStartTime, beatOffset, base
         midiNote,
         velocity: 0,
         partIndex,
-        channel
+        channel,
+        ...ctx.instrumentAtBeatOffset ? { scoreBeat: ctx.measureStartBeat + subBeatOffset * ctx.staffMeterRatio } : {}
       }));
     }
   }
@@ -5599,7 +5812,8 @@ function tryProcessTrill(ctx, event, measureStartTime, beatOffset, baseVelocity,
         midiNote,
         velocity: 0,
         partIndex,
-        channel
+        channel,
+        ...ctx.instrumentAtBeatOffset ? { scoreBeat: ctx.measureStartBeat + subBeatOffset * ctx.staffMeterRatio } : {}
       });
     }
   }