@libraz/libcantus 1.3.0 → 1.4.0

package/dist/{chunk-CGBADIO5.cjs → chunk-WOMCXN2W.cjs}

@@ -1,6 +1,7 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
 
+var _chunkKMYGRFZ6cjs = require('./chunk-KMYGRFZ6.cjs');
 
 
 
@@ -10,18 +11,22 @@
 
 
 
-var _chunkS5BKZZGMcjs = require('./chunk-S5BKZZGM.cjs');
+
+
+
+
+var _chunkS3QELJUEcjs = require('./chunk-S3QELJUE.cjs');
 
 // src/core/instrument/profile.ts
 var LIMBS = Object.freeze(["rightHand", "leftHand", "rightFoot", "leftFoot"]);
 function toInstrumentProfile(value, name = "instrument") {
   if (typeof value !== "object" || value === null) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name} must be an instrument profile; received ${typeof value}`);
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(`${name} must be an instrument profile; received ${typeof value}`);
   }
   const data = "toJSON" in value && typeof value.toJSON === "function" ? value.toJSON() : value;
   const kind = _optionalChain([data, 'optionalAccess', _2 => _2.kind]);
   if (kind !== "stringed" && kind !== "percussion") {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
       `${name} must be a stringed or percussion profile; received kind ${String(kind)}`
     );
   }
@@ -31,7 +36,7 @@ function toInstrumentProfile(value, name = "instrument") {
 function toStringedProfile(value, name = "instrument") {
   const profile = toInstrumentProfile(value, name);
   if (profile.kind !== "stringed") {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
       `${name} must be a stringed instrument; ${profile.name} has no strings`
     );
   }
@@ -41,50 +46,61 @@ var MAX_FRETS = 127;
 var MAX_POLYPHONY = 128;
 function assertProfile(profile) {
   if (typeof profile.name !== "string" || profile.name === "") {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
-      `instrument name must be a non-empty string; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, profile.name)}`
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
+      `instrument name must be a non-empty string; received ${_chunkS3QELJUEcjs.describeRejected.call(void 0, profile.name)}`
     );
   }
   if (!Array.isArray(profile.articulations)) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
-      `${profile.name} articulations must be an array; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, profile.articulations)}`
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
+      `${profile.name} articulations must be an array; received ${_chunkS3QELJUEcjs.describeRejected.call(void 0, profile.articulations)}`
     );
   }
   for (const [index, articulation] of profile.articulations.entries()) {
-    _chunkS5BKZZGMcjs.assertOneOf.call(void 0, articulation, _chunkS5BKZZGMcjs.ARTICULATIONS, `${profile.name} articulations[${index}]`);
+    _chunkS3QELJUEcjs.assertOneOf.call(void 0, articulation, _chunkS3QELJUEcjs.ARTICULATIONS, `${profile.name} articulations[${index}]`);
   }
-  _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, profile.polyphony, `${profile.name} polyphony`, MAX_POLYPHONY);
+  _chunkS3QELJUEcjs.assertPositiveInt.call(void 0, profile.polyphony, `${profile.name} polyphony`, MAX_POLYPHONY);
   if (profile.kind === "stringed") {
     if (!Array.isArray(profile.tuning) || profile.tuning.length === 0) {
-      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${profile.name} must have at least one string`);
+      throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(`${profile.name} must have at least one string`);
     }
     for (const [index, open] of profile.tuning.entries()) {
-      _chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, open, `${profile.name} tuning[${index}]`);
+      _chunkS3QELJUEcjs.assertMidiPitch.call(void 0, open, `${profile.name} tuning[${index}]`);
     }
-    _chunkS5BKZZGMcjs.assertInteger.call(void 0, profile.frets, `${profile.name} frets`, 0, MAX_FRETS);
-    _chunkS5BKZZGMcjs.assertInteger.call(void 0, profile.maxStretch, `${profile.name} maxStretch`, 0, MAX_FRETS);
+    _chunkS3QELJUEcjs.assertInteger.call(void 0, profile.frets, `${profile.name} frets`, 0, MAX_FRETS);
+    _chunkS3QELJUEcjs.assertInteger.call(void 0, profile.maxStretch, `${profile.name} maxStretch`, 0, MAX_FRETS);
     return;
   }
   if (!Array.isArray(profile.limbs) || profile.limbs.length === 0) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${profile.name} must have at least one limb`);
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(`${profile.name} must have at least one limb`);
   }
   for (const [index, limb] of profile.limbs.entries()) {
-    _chunkS5BKZZGMcjs.assertOneOf.call(void 0, limb, LIMBS, `${profile.name} limbs[${index}]`);
+    _chunkS3QELJUEcjs.assertOneOf.call(void 0, limb, LIMBS, `${profile.name} limbs[${index}]`);
   }
   if (typeof profile.reach !== "object" || profile.reach === null) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
-      `${profile.name} reach must be a table of limbs by voice; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, profile.reach)}`
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
+      `${profile.name} reach must be a table of limbs by voice; received ${_chunkS3QELJUEcjs.describeRejected.call(void 0, profile.reach)}`
     );
   }
   const voices = Object.keys(profile.reach);
   for (const key of voices) {
-    _chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, Number(key), `${profile.name} reach pitch`);
+    _chunkS3QELJUEcjs.assertMidiPitch.call(void 0, Number(key), `${profile.name} reach pitch`);
+  }
+  for (const key of voices) {
+    const label = `${profile.name} reach[${key}]`;
+    for (const [index, limb] of _chunkS3QELJUEcjs.assertArray.call(void 0, 
+      profile.reach[key],
+      label
+    ).entries()) {
+      _chunkS3QELJUEcjs.assertOneOf.call(void 0, limb, LIMBS, `${label}[${index}]`);
+    }
   }
   if (voices.every((key) => reachOf(profile, Number(key)).length === 0)) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${profile.name} must have at least one voice within reach`);
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(`${profile.name} must have at least one voice within reach`);
   }
-  for (const pitch of _nullishCoalesce(profile.overdub, () => ( []))) {
-    _chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, pitch, `${profile.name} overdub pitch`);
+  if (profile.overdub !== void 0) {
+    for (const pitch of _chunkS3QELJUEcjs.assertArray.call(void 0, profile.overdub, `${profile.name} overdub`)) {
+      _chunkS3QELJUEcjs.assertMidiPitch.call(void 0, pitch, `${profile.name} overdub pitch`);
+    }
   }
 }
 function reachOf(profile, pitch) {
@@ -120,7 +136,7 @@ function rangeIn(profile) {
 }
 function canSound(profile, pitch) {
   const resolved = toInstrumentProfile(profile, "instrument");
-  _chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, pitch, "pitch");
+  _chunkS3QELJUEcjs.assertMidiPitch.call(void 0, pitch, "pitch");
   return soundsIn(resolved, pitch);
 }
 function soundsIn(profile, pitch) {
@@ -131,7 +147,7 @@ function soundsIn(profile, pitch) {
 }
 function fingeringsFor(profile, pitch) {
   const stringed = toStringedProfile(profile, "instrument");
-  _chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, pitch, "pitch");
+  _chunkS3QELJUEcjs.assertMidiPitch.call(void 0, pitch, "pitch");
   return fingeringsIn(stringed, pitch);
 }
 function fingeringsIn(stringed, pitch) {
@@ -150,7 +166,7 @@ function fingeringsIn(stringed, pitch) {
 }
 function foldIntoRange(pitch, profile) {
   const resolved = toInstrumentProfile(profile, "instrument");
-  _chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, pitch, "pitch");
+  _chunkS3QELJUEcjs.assertMidiPitch.call(void 0, pitch, "pitch");
   return foldIn(pitch, resolved);
 }
 function foldIn(pitch, resolved) {
@@ -180,38 +196,32 @@ var MIN_DIFFICULTY = 1;
 var MAX_DIFFICULTY = 5;
 var STRING_CROSSING_COST = 2;
 var SIMULTANEITY_BEATS = 1 / 128;
+var LEGATO_OVERLAP_BEATS = 1 / 16;
 function playability(notes, profile, bpm) {
-  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, notes, "playability notes", { allowNonPositiveDuration: true });
+  _chunkS3QELJUEcjs.assertNoteEvents.call(void 0, notes, "playability notes", { allowNonPositiveDuration: true });
   if (bpm !== void 0) {
-    _chunkS5BKZZGMcjs.assertRange.call(void 0, bpm, Number.MIN_VALUE, 1e3, "playability bpm");
+    _chunkS3QELJUEcjs.assertRange.call(void 0, bpm, Number.MIN_VALUE, 1e3, "playability bpm");
   }
   const instrument = toInstrumentProfile(profile, "playability profile");
-  const order = notes.map((_, index) => index).sort((a, b) => {
-    const left = notes[a];
-    const right = notes[b];
-    if (!left || !right) {
-      return a - b;
-    }
-    return left.startBeat - right.startBeat || left.pitch - right.pitch || a - b;
-  });
   const state = {
     notes,
-    order,
+    order: _chunkKMYGRFZ6cjs.canonicalNoteOrder.call(void 0, notes),
     placements: notes.map((_, index) => ({ note: index })),
     issues: [],
     movement: 0,
     secondsPerBeat: bpm === void 0 ? void 0 : 60 / bpm
   };
+  const attacks = timelineOf(state);
   if (instrument.kind === "stringed") {
     checkExistence(state, instrument, (pitch) => soundsIn(instrument, pitch));
-    placeOnNeck(state, instrument);
+    placeOnNeck(state, instrument, attacks);
   } else {
     const kit = readKit(instrument);
     checkExistence(state, instrument, (pitch) => limbsFor(kit, pitch).length > 0);
-    placeOnKit(state, kit);
+    placeOnKit(state, kit, attacks);
   }
   return {
-    difficulty: difficultyOf(state, bpm),
+    difficulty: difficultyOf(state, attacks, bpm),
     issues: state.issues,
     placements: state.placements
   };
@@ -245,126 +255,248 @@ function checkExistence(state, profile, sounds) {
     }
   }
 }
-function isSimultaneous(anchorBeat, startBeat) {
-  return startBeat - anchorBeat <= SIMULTANEITY_BEATS + _chunkS5BKZZGMcjs.BEAT_EPS;
+function isReleased(endBeat, beat) {
+  return endBeat <= beat + LEGATO_OVERLAP_BEATS + _chunkS3QELJUEcjs.BEAT_EPS;
 }
-function soundingGroups(state) {
-  const groups = [];
+function timelineOf(state) {
+  const sounding = new Set(_chunkKMYGRFZ6cjs.soundingIndices.call(void 0, state.notes));
+  const attacks = [];
   let active = [];
-  let cursor = 0;
-  let anchor;
+  let current;
   for (const index of state.order) {
     const note = state.notes[index];
-    if (!note) {
+    if (!note || !sounding.has(index)) {
       continue;
     }
-    if (anchor !== void 0 && isSimultaneous(anchor, note.startBeat)) {
-      continue;
+    if (!current || note.startBeat - current.startBeat > SIMULTANEITY_BEATS + _chunkS3QELJUEcjs.BEAT_EPS) {
+      const at = note.startBeat;
+      active = active.filter((held) => !isReleased(held.endBeat, at));
+      current = { startBeat: at, members: [], held: [...active] };
+      attacks.push(current);
     }
-    const at = note.startBeat;
-    anchor = at;
-    active = active.filter((member) => {
-      const held = state.notes[member];
-      return held !== void 0 && held.startBeat + held.durationBeat > at + _chunkS5BKZZGMcjs.BEAT_EPS;
-    });
-    while (cursor < state.order.length) {
-      const candidateIndex = state.order[cursor];
-      const candidate = candidateIndex === void 0 ? void 0 : state.notes[candidateIndex];
-      if (!candidate || !isSimultaneous(at, candidate.startBeat)) {
-        break;
+    const timed = {
+      index,
+      startBeat: note.startBeat,
+      endBeat: note.startBeat + note.durationBeat,
+      attackBeat: current.startBeat
+    };
+    current.members.push(timed);
+    active.push(timed);
+  }
+  for (const attack of attacks) {
+    attack.members.sort(
+      (a, b) => (_nullishCoalesce(_optionalChain([state, 'access', _3 => _3.notes, 'access', _4 => _4[a.index], 'optionalAccess', _5 => _5.pitch]), () => ( 0))) - (_nullishCoalesce(_optionalChain([state, 'access', _6 => _6.notes, 'access', _7 => _7[b.index], 'optionalAccess', _8 => _8.pitch]), () => ( 0))) || a.index - b.index
+    );
+  }
+  return attacks;
+}
+var MAX_JOINT_PLACEMENT_NOTES = 12;
+var MAX_PLACEMENT_SEARCH_NODES = 2e4;
+function fitsHand(frets, maxStretch) {
+  let low = Number.POSITIVE_INFINITY;
+  let high = Number.NEGATIVE_INFINITY;
+  let count = 0;
+  for (const fret of frets) {
+    if (fret > 0) {
+      low = Math.min(low, fret);
+      high = Math.max(high, fret);
+      count += 1;
+    }
+  }
+  return count < 2 || high - low <= maxStretch;
+}
+function placeGreedily(members, previous, freeAt, heldBy) {
+  const free = [...freeAt];
+  const held = [...heldBy];
+  const picks = [];
+  const conflicts = [];
+  let from = previous;
+  for (const member of members) {
+    const open = member.candidates.filter(
+      (candidate) => isReleased(_nullishCoalesce(free[candidate.string], () => ( Number.NEGATIVE_INFINITY)), member.attackBeat)
+    );
+    if (open.length === 0) {
+      conflicts.push({
+        member,
+        blocked: member.candidates.map((candidate) => held[candidate.string]).filter((value) => value !== void 0)
+      });
+    }
+    const pool = open.length > 0 ? open : member.candidates;
+    const origin = from;
+    const chosen = pool.reduce(
+      (best, candidate) => fingeringCost(candidate, origin) < fingeringCost(best, origin) ? candidate : best
+    );
+    picks.push(chosen);
+    free[chosen.string] = Number.POSITIVE_INFINITY;
+    held[chosen.string] = member.index;
+    from = movedTo(from, chosen);
+  }
+  return { picks, conflicts };
+}
+function searchPlacement(members, previous, freeAt, heldFrets, maxStretch) {
+  const free = [...freeAt];
+  const frets = heldFrets === void 0 ? void 0 : [...heldFrets];
+  const picks = [];
+  let best;
+  let bestCost = Number.POSITIVE_INFINITY;
+  let nodes = 0;
+  const visit = (depth, from, cost) => {
+    if (cost >= bestCost || nodes >= MAX_PLACEMENT_SEARCH_NODES) {
+      return;
+    }
+    const member = members[depth];
+    if (member === void 0) {
+      best = [...picks];
+      bestCost = cost;
+      return;
+    }
+    for (const candidate of member.candidates) {
+      const previousFree = _nullishCoalesce(free[candidate.string], () => ( Number.NEGATIVE_INFINITY));
+      if (!isReleased(previousFree, member.attackBeat)) {
+        continue;
+      }
+      nodes += 1;
+      if (frets !== void 0) {
+        frets.push(candidate.fret);
+        if (!fitsHand(frets, maxStretch)) {
+          frets.pop();
+          continue;
+        }
       }
-      if (candidateIndex !== void 0 && candidate.startBeat + candidate.durationBeat > at + _chunkS5BKZZGMcjs.BEAT_EPS) {
-        active.push(candidateIndex);
+      free[candidate.string] = Number.POSITIVE_INFINITY;
+      picks.push(candidate);
+      visit(depth + 1, movedTo(from, candidate), cost + fingeringCost(candidate, from));
+      picks.pop();
+      free[candidate.string] = previousFree;
+      if (frets !== void 0) {
+        frets.pop();
       }
-      cursor += 1;
     }
-    groups.push({ startBeat: at, members: [...active] });
+  };
+  visit(0, previous, 0);
+  return best;
+}
+function placeAttack(members, previous, freeAt, heldBy, heldFrets, maxStretch) {
+  const greedy = placeGreedily(members, previous, freeAt, heldBy);
+  const soundingFrets = [...heldFrets, ...greedy.picks.map((pick) => pick.fret)];
+  if (greedy.conflicts.length === 0 && fitsHand(soundingFrets, maxStretch)) {
+    return greedy;
   }
-  return groups;
+  if (members.length > MAX_JOINT_PLACEMENT_NOTES) {
+    return greedy;
+  }
+  const fitted = searchPlacement(members, previous, freeAt, heldFrets, maxStretch);
+  if (fitted !== void 0) {
+    return { picks: fitted, conflicts: [] };
+  }
+  if (greedy.conflicts.length > 0) {
+    const loose = searchPlacement(members, previous, freeAt, void 0, maxStretch);
+    if (loose !== void 0) {
+      return { picks: loose, conflicts: [] };
+    }
+  }
+  return greedy;
 }
-function placeOnNeck(state, profile) {
+function placeOnNeck(state, profile, attacks) {
   const stringFreeAt = profile.tuning.map(() => Number.NEGATIVE_INFINITY);
   const stringHeldBy = profile.tuning.map(() => void 0);
-  let previous;
-  let previousIndex;
-  for (const index of state.order) {
-    const note = state.notes[index];
-    const placement = state.placements[index];
-    if (!note || !placement) {
-      continue;
-    }
-    const candidates = fingeringsIn(profile, note.pitch);
-    if (candidates.length === 0) {
-      continue;
-    }
-    const free = candidates.filter(
-      (candidate) => (_nullishCoalesce(stringFreeAt[candidate.string], () => ( 0))) <= note.startBeat + _chunkS5BKZZGMcjs.BEAT_EPS
-    );
-    if (free.length === 0) {
-      const blocked = candidates.map((candidate) => stringHeldBy[candidate.string]).filter((held) => held !== void 0);
-      state.issues.push({
-        type: "stringConflict",
-        layer: 2,
-        notes: [.../* @__PURE__ */ new Set([...blocked, index])].sort((a, b) => a - b),
-        startBeat: note.startBeat,
-        impossible: true,
-        message: `MIDI ${note.pitch} needs a string already sounding on ${profile.name}`
-      });
+  let origin = {};
+  let hand;
+  for (const attack of attacks) {
+    const members = [];
+    for (const timed of attack.members) {
+      const note = state.notes[timed.index];
+      const candidates = note === void 0 ? [] : fingeringsIn(profile, note.pitch);
+      if (candidates.length > 0) {
+        members.push({ ...timed, candidates });
+      }
     }
-    const pool = free.length > 0 ? free : candidates;
-    const chosen = pool.reduce(
-      (best, candidate) => fingeringCost(candidate, previous) < fingeringCost(best, previous) ? candidate : best
+    const heldFrets = attack.held.map((held) => _optionalChain([state, 'access', _9 => _9.placements, 'access', _10 => _10[held.index], 'optionalAccess', _11 => _11.fingering, 'optionalAccess', _12 => _12.fret])).filter((fret) => fret !== void 0);
+    const { picks, conflicts } = placeAttack(
+      members,
+      origin,
+      stringFreeAt,
+      stringHeldBy,
+      heldFrets,
+      profile.maxStretch
     );
-    placement.fingering = chosen;
-    stringFreeAt[chosen.string] = note.startBeat + note.durationBeat;
-    stringHeldBy[chosen.string] = index;
-    state.movement += 1;
-    if (previous) {
-      state.movement += Math.abs(chosen.fret - previous.fret) + Math.abs(chosen.string - previous.string);
-      checkShiftSpeed(state, profile, previousIndex, index, previous, chosen);
+    let shifted = hand;
+    members.forEach((member, k) => {
+      const chosen = picks[k];
+      const placement = state.placements[member.index];
+      if (!chosen || !placement) {
+        return;
+      }
+      const conflict = conflicts.find((entry) => entry.member === member);
+      const note = state.notes[member.index];
+      if (conflict && note) {
+        state.issues.push({
+          type: "stringConflict",
+          layer: 2,
+          notes: [.../* @__PURE__ */ new Set([...conflict.blocked, member.index])].sort((a, b) => a - b),
+          startBeat: member.startBeat,
+          impossible: true,
+          message: `MIDI ${note.pitch} needs a string already sounding on ${profile.name}`
+        });
+      }
+      placement.fingering = chosen;
+      stringFreeAt[chosen.string] = member.endBeat;
+      stringHeldBy[chosen.string] = member.index;
+      state.movement += 1;
+      if (origin.string !== void 0) {
+        state.movement += Math.abs(chosen.string - origin.string);
+      }
+      origin = movedTo(origin, chosen);
+      if (chosen.fret > 0) {
+        shifted = { note: member, fingering: chosen };
+      }
+    });
+    if (hand && shifted && shifted !== hand) {
+      state.movement += Math.abs(shifted.fingering.fret - hand.fingering.fret);
+      checkShiftSpeed(state, profile, hand, shifted);
     }
-    previous = chosen;
-    previousIndex = index;
+    hand = shifted;
   }
-  for (const group of soundingGroups(state)) {
-    checkStretch(state, profile, group);
-    checkPolyphony(state, profile, group);
+  for (const attack of attacks) {
+    checkStretch(state, profile, attack);
+    checkPolyphony(state, profile, { startBeat: attack.startBeat, members: soundingAt(attack) });
   }
 }
-function fingeringCost(candidate, previous) {
-  if (!previous) {
-    return candidate.fret + candidate.string / 100;
-  }
-  return Math.abs(candidate.fret - previous.fret) + STRING_CROSSING_COST * Math.abs(candidate.string - previous.string) + candidate.string / 100;
+function movedTo(origin, chosen) {
+  return { string: chosen.string, fret: chosen.fret > 0 ? chosen.fret : origin.fret };
+}
+function fingeringCost(candidate, origin) {
+  const stopped = candidate.fret === 0 ? 0 : origin.fret === void 0 ? candidate.fret : Math.abs(candidate.fret - origin.fret);
+  const crossing = origin.string === void 0 ? 0 : STRING_CROSSING_COST * Math.abs(candidate.string - origin.string);
+  return stopped + crossing + candidate.string / 100;
 }
-function checkShiftSpeed(state, profile, fromIndex, toIndex, from, to) {
+function checkShiftSpeed(state, profile, from, to) {
   const secondsPerBeat = state.secondsPerBeat;
-  if (secondsPerBeat === void 0 || fromIndex === void 0) {
-    return;
-  }
-  const previousNote = state.notes[fromIndex];
-  const note = state.notes[toIndex];
-  if (!previousNote || !note) {
+  if (secondsPerBeat === void 0) {
     return;
   }
-  const seconds = (note.startBeat - previousNote.startBeat) * secondsPerBeat;
-  const shift = Math.abs(to.fret - from.fret);
-  if (seconds <= _chunkS5BKZZGMcjs.BEAT_EPS || shift === 0) {
+  const seconds = (to.note.attackBeat - from.note.attackBeat) * secondsPerBeat;
+  const shift = Math.abs(to.fingering.fret - from.fingering.fret);
+  if (seconds <= _chunkS3QELJUEcjs.BEAT_EPS || shift === 0) {
     return;
   }
   if (shift / seconds > MAX_FRET_SHIFT_PER_SECOND) {
     state.issues.push({
       type: "tooFast",
       layer: 3,
-      notes: [fromIndex, toIndex].sort((a, b) => a - b),
-      startBeat: note.startBeat,
+      notes: [from.note.index, to.note.index].sort((a, b) => a - b),
+      startBeat: to.note.startBeat,
       impossible: false,
       message: `a ${shift}-fret shift in ${seconds.toFixed(3)}s is beyond ${profile.name}`
     });
   }
 }
-function checkStretch(state, profile, group) {
-  const frets = group.members.map((member) => _optionalChain([state, 'access', _3 => _3.placements, 'access', _4 => _4[member], 'optionalAccess', _5 => _5.fingering])).filter(
+function soundingAt(attack) {
+  return [...attack.held, ...attack.members].map((timed) => timed.index);
+}
+function checkStretch(state, profile, attack) {
+  const sounding = soundingAt(attack);
+  const frets = sounding.map((member) => _optionalChain([state, 'access', _13 => _13.placements, 'access', _14 => _14[member], 'optionalAccess', _15 => _15.fingering])).filter(
     (fingering) => fingering !== void 0 && fingering.fret > 0
   ).map((fingering) => fingering.fret);
   if (frets.length < 2) {
@@ -375,8 +507,8 @@ function checkStretch(state, profile, group) {
     state.issues.push({
       type: "stretchTooWide",
       layer: 2,
-      notes: [...group.members].sort((a, b) => a - b),
-      startBeat: group.startBeat,
+      notes: sounding.sort((a, b) => a - b),
+      startBeat: attack.startBeat,
       impossible: true,
       message: `a ${span}-fret stretch exceeds the ${profile.maxStretch} frets one hand spans on ${profile.name}`
     });
@@ -413,10 +545,10 @@ function limbsFor(kit, pitch) {
 function passesAt(state, kit, members) {
   const played = { id: "kit", members: [] };
   const overdubs = /* @__PURE__ */ new Map();
-  for (const index of members) {
-    const pitch = _optionalChain([state, 'access', _6 => _6.notes, 'access', _7 => _7[index], 'optionalAccess', _8 => _8.pitch]);
+  for (const member of members) {
+    const pitch = _optionalChain([state, 'access', _16 => _16.notes, 'access', _17 => _17[member.index], 'optionalAccess', _18 => _18.pitch]);
     if (pitch === void 0 || !kit.overdub.has(pitch)) {
-      played.members.push(index);
+      played.members.push(member);
       continue;
     }
     let pass = overdubs.get(pitch);
@@ -424,7 +556,7 @@ function passesAt(state, kit, members) {
       pass = { id: `overdub ${pitch}`, members: [] };
       overdubs.set(pitch, pass);
     }
-    pass.members.push(index);
+    pass.members.push(member);
   }
   return [played, ...overdubs.values()];
 }
@@ -432,13 +564,13 @@ function placePass(state, kit, pass, memory) {
   const taken = /* @__PURE__ */ new Set();
   let conflicted = false;
   const members = [...pass.members].sort((a, b) => {
-    const left = limbsFor(kit, _optionalChain([state, 'access', _9 => _9.notes, 'access', _10 => _10[a], 'optionalAccess', _11 => _11.pitch]));
-    const right = limbsFor(kit, _optionalChain([state, 'access', _12 => _12.notes, 'access', _13 => _13[b], 'optionalAccess', _14 => _14.pitch]));
-    return left.length - right.length || a - b;
+    const left = limbsFor(kit, _optionalChain([state, 'access', _19 => _19.notes, 'access', _20 => _20[a.index], 'optionalAccess', _21 => _21.pitch]));
+    const right = limbsFor(kit, _optionalChain([state, 'access', _22 => _22.notes, 'access', _23 => _23[b.index], 'optionalAccess', _24 => _24.pitch]));
+    return left.length - right.length || a.index - b.index;
   });
-  for (const index of members) {
-    const note = state.notes[index];
-    const placement = state.placements[index];
+  for (const member of members) {
+    const note = state.notes[member.index];
+    const placement = state.placements[member.index];
     if (!note || !placement) {
       continue;
     }
@@ -460,23 +592,24 @@ function placePass(state, kit, pass, memory) {
     memory.limbForVoice.set(note.pitch, chosen);
     state.movement += 1;
     const strokeKey = `${pass.id} ${chosen}`;
-    const previousIndex = memory.lastStroke.get(strokeKey);
-    if (previousIndex !== void 0) {
-      const previousNote = state.notes[previousIndex];
+    const previousStroke = memory.lastStroke.get(strokeKey);
+    if (previousStroke !== void 0) {
+      const previousNote = state.notes[previousStroke.index];
       if (previousNote && previousNote.pitch !== note.pitch) {
         state.movement += 1;
       }
-      checkStrokeSpeed(state, kit.profile, previousIndex, index, chosen);
+      checkStrokeSpeed(state, kit.profile, previousStroke, member, chosen);
     }
-    memory.lastStroke.set(strokeKey, index);
+    memory.lastStroke.set(strokeKey, member);
   }
   return conflicted;
 }
-function placeOnKit(state, kit) {
+function placeOnKit(state, kit, attacks) {
   const memory = { limbForVoice: /* @__PURE__ */ new Map(), lastStroke: /* @__PURE__ */ new Map() };
-  for (const group of onsetGroups(state)) {
+  for (const attack of attacks) {
+    const strokes = attack.members.map((member) => member.index);
     let conflicted = false;
-    for (const pass of passesAt(state, kit, group.members)) {
+    for (const pass of passesAt(state, kit, attack.members)) {
       if (!placePass(state, kit, pass, memory)) {
         continue;
       }
@@ -484,68 +617,46 @@ function placeOnKit(state, kit) {
       state.issues.push({
         type: "limbConflict",
         layer: 2,
-        notes: [...pass.members].sort((a, b) => a - b),
-        startBeat: group.startBeat,
+        notes: pass.members.map((member) => member.index).sort((a, b) => a - b),
+        startBeat: attack.startBeat,
         impossible: true,
         message: `${pass.members.length} simultaneous strokes cannot be shared among the limbs of ${kit.profile.name}`
       });
     }
     if (!conflicted) {
-      checkPolyphony(state, kit.profile, group);
+      checkPolyphony(state, kit.profile, { startBeat: attack.startBeat, members: strokes });
     }
   }
 }
-function checkStrokeSpeed(state, profile, fromIndex, toIndex, limb) {
+function checkStrokeSpeed(state, profile, from, to, limb) {
   const secondsPerBeat = state.secondsPerBeat;
   if (secondsPerBeat === void 0) {
     return;
   }
-  const previousNote = state.notes[fromIndex];
-  const note = state.notes[toIndex];
-  if (!previousNote || !note) {
-    return;
-  }
-  const seconds = (note.startBeat - previousNote.startBeat) * secondsPerBeat;
-  if (seconds <= _chunkS5BKZZGMcjs.BEAT_EPS || seconds >= MIN_LIMB_STROKE_SECONDS) {
+  const seconds = (to.attackBeat - from.attackBeat) * secondsPerBeat;
+  if (seconds <= _chunkS3QELJUEcjs.BEAT_EPS || seconds >= MIN_LIMB_STROKE_SECONDS) {
     return;
   }
   state.issues.push({
     type: "tooFast",
     layer: 3,
-    notes: [fromIndex, toIndex].sort((a, b) => a - b),
-    startBeat: note.startBeat,
+    notes: [from.index, to.index].sort((a, b) => a - b),
+    startBeat: to.startBeat,
     impossible: false,
     message: `${limb} strikes twice ${seconds.toFixed(3)}s apart on ${profile.name}`
   });
 }
-function onsetGroups(state) {
-  const groups = [];
-  let current;
-  for (const index of state.order) {
-    const note = state.notes[index];
-    if (!note || note.durationBeat <= 0) {
-      continue;
-    }
-    if (!current || !isSimultaneous(current.startBeat, note.startBeat)) {
-      current = { startBeat: note.startBeat, members: [] };
-      groups.push(current);
-    }
-    current.members.push(index);
-  }
-  return groups;
-}
-function difficultyOf(state, bpm) {
+function difficultyOf(state, attacks, bpm) {
   let first = Number.POSITIVE_INFINITY;
   let last = Number.NEGATIVE_INFINITY;
-  for (const note of state.notes) {
-    if (!note) {
-      continue;
+  for (const attack of attacks) {
+    for (const member of attack.members) {
+      first = Math.min(first, member.startBeat);
+      last = Math.max(last, member.endBeat);
     }
-    first = Math.min(first, note.startBeat);
-    last = Math.max(last, note.startBeat + Math.max(0, note.durationBeat));
   }
   const spanBeats = last - first;
-  if (!Number.isFinite(spanBeats) || spanBeats <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+  if (!Number.isFinite(spanBeats) || spanBeats <= _chunkS3QELJUEcjs.BEAT_EPS) {
     return MIN_DIFFICULTY;
   }
   const seconds = spanBeats * 60 / (_nullishCoalesce(bpm, () => ( REFERENCE_BPM)));
@@ -642,7 +753,7 @@ function absorbSegment(hash, segment, index) {
     return next;
   }
   if (typeof segment === "number") {
-    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, segment, `seed path segment ${index}`);
+    _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, segment, `seed path segment ${index}`);
     numberBytes.setFloat64(0, segment === 0 ? 0 : segment, true);
     let next = absorb(hash, TAG_NUMBER);
     for (let i = 0; i < 8; i += 1) {
@@ -650,7 +761,7 @@ function absorbSegment(hash, segment, index) {
     }
     return next;
   }
-  throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+  throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
     `seed path segment ${index} must be a string or a number; received ${typeof segment}`
   );
 }
@@ -660,7 +771,7 @@ function hashPath(domain, root, path) {
   for (let index = 0; index < path.length; index += 1) {
     const segment = path[index];
     if (segment === void 0) {
-      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
         `seed path segment ${index} must be a string or a number; received undefined`
       );
     }
@@ -668,26 +779,40 @@ function hashPath(domain, root, path) {
   }
   return fmix32(hash);
 }
+var stepBytes = new DataView(new ArrayBuffer(8));
+function scaleUnitDraw(unit, lo, hi) {
+  const value = lo + unit * (hi - lo);
+  if (value < hi || lo === hi) {
+    return value;
+  }
+  if (hi === 0) {
+    return -Number.MIN_VALUE;
+  }
+  stepBytes.setFloat64(0, hi);
+  const bits = stepBytes.getBigUint64(0);
+  stepBytes.setBigUint64(0, hi > 0 ? bits - 1n : bits + 1n);
+  return stepBytes.getFloat64(0);
+}
 
 // src/core/random/positional.ts
 function createPositionalRng(seed) {
-  _chunkS5BKZZGMcjs.assertInteger.call(void 0, seed, "seed", 0, 4294967295);
+  _chunkS3QELJUEcjs.assertInteger.call(void 0, seed, "seed", 0, 4294967295);
   return {
     at: (...path) => hashPath(DOMAIN_POSITION, seed, path) / UINT32_RANGE
   };
 }
 function includeAt(rng, complexity, ...path) {
-  _chunkS5BKZZGMcjs.assertRange.call(void 0, complexity, 0, 1, "complexity");
+  _chunkS3QELJUEcjs.assertRange.call(void 0, complexity, 0, 1, "complexity");
   const draw = rng.at(...path);
   if (!(draw >= 0 && draw < 1)) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`positional draw must be in [0, 1); received ${draw}`);
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(`positional draw must be in [0, 1); received ${draw}`);
   }
   return draw < complexity;
 }
 
 // src/core/random/seed.ts
 function deriveSeed(root, ...path) {
-  _chunkS5BKZZGMcjs.assertInteger.call(void 0, root, "root seed", 0, 4294967295);
+  _chunkS3QELJUEcjs.assertInteger.call(void 0, root, "root seed", 0, 4294967295);
   return hashPath(DOMAIN_SEED, root, path);
 }
 
@@ -698,9 +823,9 @@ function resolveAlgorithmVersion(requested) {
   if (requested === void 0) {
     return ALGORITHM_VERSION;
   }
-  _chunkS5BKZZGMcjs.assertInteger.call(void 0, requested, "algorithm version");
+  _chunkS3QELJUEcjs.assertInteger.call(void 0, requested, "algorithm version");
   if (requested < MIN_ALGORITHM_VERSION || requested > ALGORITHM_VERSION) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
       `algorithm version ${requested} is not produced by this build; supported versions are ${MIN_ALGORITHM_VERSION}..${ALGORITHM_VERSION}`
     );
   }
@@ -709,7 +834,7 @@ function resolveAlgorithmVersion(requested) {
 
 // src/core/random/index.ts
 function createRng(seed) {
-  _chunkS5BKZZGMcjs.assertInteger.call(void 0, seed, "seed", 0, 4294967295);
+  _chunkS3QELJUEcjs.assertInteger.call(void 0, seed, "seed", 0, 4294967295);
   let state = seed >>> 0;
   const next = () => {
     state = state + 1831565813 >>> 0;
@@ -721,30 +846,30 @@ function createRng(seed) {
   return {
     next,
     prob: (p) => {
-      _chunkS5BKZZGMcjs.assertRange.call(void 0, p, 0, 1, "probability");
+      _chunkS3QELJUEcjs.assertRange.call(void 0, p, 0, 1, "probability");
       return next() < p;
     },
     range: (lo, hi) => {
-      _chunkS5BKZZGMcjs.assertInteger.call(void 0, lo, "range lower bound");
-      _chunkS5BKZZGMcjs.assertInteger.call(void 0, hi, "range upper bound");
+      _chunkS3QELJUEcjs.assertInteger.call(void 0, lo, "range lower bound");
+      _chunkS3QELJUEcjs.assertInteger.call(void 0, hi, "range upper bound");
       if (lo > hi) {
-        throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+        throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
           `range lower bound must not exceed upper bound; received ${lo} > ${hi}`
         );
       }
-      _chunkS5BKZZGMcjs.assertInteger.call(void 0, hi - lo, "range span", 0);
+      _chunkS3QELJUEcjs.assertInteger.call(void 0, hi - lo, "range span", 0);
       return lo + Math.floor(next() * (hi - lo + 1));
     },
     float: (lo, hi) => {
-      _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, lo, "float lower bound");
-      _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, hi, "float upper bound");
+      _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, lo, "float lower bound");
+      _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, hi, "float upper bound");
       if (lo > hi) {
-        throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+        throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
           `float lower bound must not exceed upper bound; received ${lo} > ${hi}`
         );
       }
-      _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, hi - lo, "float span");
-      return lo + next() * (hi - lo);
+      _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, hi - lo, "float span");
+      return scaleUnitDraw(next(), lo, hi);
     }
   };
 }
@@ -773,5 +898,6 @@ function createRng(seed) {
 
 
 
-exports.LIMBS = LIMBS; exports.toInstrumentProfile = toInstrumentProfile; exports.toStringedProfile = toStringedProfile; exports.instrumentRange = instrumentRange; exports.rangeIn = rangeIn; exports.canSound = canSound; exports.soundsIn = soundsIn; exports.fingeringsFor = fingeringsFor; exports.fingeringsIn = fingeringsIn; exports.foldIntoRange = foldIntoRange; exports.foldIn = foldIn; exports.playability = playability; exports.BASS_4_STRING = BASS_4_STRING; exports.BASS_5_STRING = BASS_5_STRING; exports.GUITAR_STANDARD = GUITAR_STANDARD; exports.GUITAR_DROP_D = GUITAR_DROP_D; exports.createPositionalRng = createPositionalRng; exports.includeAt = includeAt; exports.deriveSeed = deriveSeed; exports.ALGORITHM_VERSION = ALGORITHM_VERSION; exports.MIN_ALGORITHM_VERSION = MIN_ALGORITHM_VERSION; exports.resolveAlgorithmVersion = resolveAlgorithmVersion; exports.createRng = createRng;
-//# sourceMappingURL=chunk-CGBADIO5.cjs.map
+
+exports.LIMBS = LIMBS; exports.toInstrumentProfile = toInstrumentProfile; exports.toStringedProfile = toStringedProfile; exports.instrumentRange = instrumentRange; exports.rangeIn = rangeIn; exports.canSound = canSound; exports.soundsIn = soundsIn; exports.fingeringsFor = fingeringsFor; exports.fingeringsIn = fingeringsIn; exports.foldIntoRange = foldIntoRange; exports.foldIn = foldIn; exports.playability = playability; exports.BASS_4_STRING = BASS_4_STRING; exports.BASS_5_STRING = BASS_5_STRING; exports.GUITAR_STANDARD = GUITAR_STANDARD; exports.GUITAR_DROP_D = GUITAR_DROP_D; exports.scaleUnitDraw = scaleUnitDraw; exports.createPositionalRng = createPositionalRng; exports.includeAt = includeAt; exports.deriveSeed = deriveSeed; exports.ALGORITHM_VERSION = ALGORITHM_VERSION; exports.MIN_ALGORITHM_VERSION = MIN_ALGORITHM_VERSION; exports.resolveAlgorithmVersion = resolveAlgorithmVersion; exports.createRng = createRng;
+//# sourceMappingURL=chunk-WOMCXN2W.cjs.map