audio-mixer-ui 0.5.1 → 0.5.3

package/dist/audio-mixer-ui.js

@@ -1,12 +1,12 @@
-import { ref as x, watch as v, unref as r, onScopeDispose as UU, readonly as yl, mergeModels as il, useCssVars as $, computed as u, useTemplateRef as O, useModel as _, createElementBlock as Y, openBlock as X, normalizeClass as L, createElementVNode as h, createCommentVNode as f, Fragment as al, renderList as Sl, normalizeStyle as Il, renderSlot as Vl, toDisplayString as K, onUnmounted as cl, watchEffect as El, onMounted as el, createVNode as C, withCtx as D, createTextVNode as ol, withDirectives as vl, withKeys as FU, vModelText as Kl, withModifiers as kl, createBlock as nl } from "vue";
+import { ref as x, watch as v, unref as r, onScopeDispose as UU, readonly as yl, mergeModels as il, useCssVars as $, computed as G, useTemplateRef as O, useModel as _, createElementBlock as Y, openBlock as X, normalizeClass as L, createElementVNode as h, createCommentVNode as f, Fragment as al, renderList as Sl, normalizeStyle as Il, renderSlot as Vl, toDisplayString as K, onUnmounted as cl, watchEffect as El, onMounted as el, createVNode as C, withCtx as D, createTextVNode as ol, withDirectives as vl, withKeys as FU, vModelText as Kl, withModifiers as kl, createBlock as nl } from "vue";
 import { defineStore as sl } from "pinia";
 var gl = function() {
   if (typeof Map < "u")
     return Map;
-  function d(l, U) {
+  function Z(l, U) {
     var F = -1;
-    return l.some(function(Z, V) {
-      return Z[0] === U ? (F = V, !0) : !1;
+    return l.some(function(d, Q) {
+      return d[0] === U ? (F = Q, !0) : !1;
     }), F;
   }
   return (
@@ -25,204 +25,204 @@ var gl = function() {
         enumerable: !0,
         configurable: !0
       }), l.prototype.get = function(U) {
-        var F = d(this.__entries__, U), Z = this.__entries__[F];
-        return Z && Z[1];
+        var F = Z(this.__entries__, U), d = this.__entries__[F];
+        return d && d[1];
       }, l.prototype.set = function(U, F) {
-        var Z = d(this.__entries__, U);
-        ~Z ? this.__entries__[Z][1] = F : this.__entries__.push([U, F]);
+        var d = Z(this.__entries__, U);
+        ~d ? this.__entries__[d][1] = F : this.__entries__.push([U, F]);
       }, l.prototype.delete = function(U) {
-        var F = this.__entries__, Z = d(F, U);
-        ~Z && F.splice(Z, 1);
+        var F = this.__entries__, d = Z(F, U);
+        ~d && F.splice(d, 1);
       }, l.prototype.has = function(U) {
-        return !!~d(this.__entries__, U);
+        return !!~Z(this.__entries__, U);
       }, l.prototype.clear = function() {
         this.__entries__.splice(0);
       }, l.prototype.forEach = function(U, F) {
         F === void 0 && (F = null);
-        for (var Z = 0, V = this.__entries__; Z < V.length; Z++) {
-          var Q = V[Z];
-          U.call(F, Q[1], Q[0]);
+        for (var d = 0, Q = this.__entries__; d < Q.length; d++) {
+          var V = Q[d];
+          U.call(F, V[1], V[0]);
         }
       }, l;
     }()
   );
-}(), Gl = typeof window < "u" && typeof document < "u" && window.document === document, ml = function() {
+}(), ul = typeof window < "u" && typeof document < "u" && window.document === document, ml = function() {
   return typeof global < "u" && global.Math === Math ? global : typeof self < "u" && self.Math === Math ? self : typeof window < "u" && window.Math === Math ? window : Function("return this")();
 }(), dU = function() {
-  return typeof requestAnimationFrame == "function" ? requestAnimationFrame.bind(ml) : function(d) {
+  return typeof requestAnimationFrame == "function" ? requestAnimationFrame.bind(ml) : function(Z) {
     return setTimeout(function() {
-      return d(Date.now());
+      return Z(Date.now());
     }, 1e3 / 60);
   };
 }(), ZU = 2;
-function QU(d, l) {
-  var U = !1, F = !1, Z = 0;
-  function V() {
-    U && (U = !1, d()), F && t();
-  }
+function QU(Z, l) {
+  var U = !1, F = !1, d = 0;
   function Q() {
-    dU(V);
+    U && (U = !1, Z()), F && t();
+  }
+  function V() {
+    dU(Q);
   }
   function t() {
     var R = Date.now();
     if (U) {
-      if (R - Z < ZU)
+      if (R - d < ZU)
         return;
       F = !0;
     } else
-      U = !0, F = !1, setTimeout(Q, l);
-    Z = R;
+      U = !0, F = !1, setTimeout(V, l);
+    d = R;
   }
   return t;
 }
 var VU = 20, tU = ["top", "right", "bottom", "left", "width", "height", "size", "weight"], RU = typeof MutationObserver < "u", aU = (
   /** @class */
   function() {
-    function d() {
+    function Z() {
       this.connected_ = !1, this.mutationEventsAdded_ = !1, this.mutationsObserver_ = null, this.observers_ = [], this.onTransitionEnd_ = this.onTransitionEnd_.bind(this), this.refresh = QU(this.refresh.bind(this), VU);
     }
-    return d.prototype.addObserver = function(l) {
+    return Z.prototype.addObserver = function(l) {
       ~this.observers_.indexOf(l) || this.observers_.push(l), this.connected_ || this.connect_();
-    }, d.prototype.removeObserver = function(l) {
+    }, Z.prototype.removeObserver = function(l) {
       var U = this.observers_, F = U.indexOf(l);
       ~F && U.splice(F, 1), !U.length && this.connected_ && this.disconnect_();
-    }, d.prototype.refresh = function() {
+    }, Z.prototype.refresh = function() {
       var l = this.updateObservers_();
       l && this.refresh();
-    }, d.prototype.updateObservers_ = function() {
+    }, Z.prototype.updateObservers_ = function() {
       var l = this.observers_.filter(function(U) {
         return U.gatherActive(), U.hasActive();
       });
       return l.forEach(function(U) {
         return U.broadcastActive();
       }), l.length > 0;
-    }, d.prototype.connect_ = function() {
-      !Gl || this.connected_ || (document.addEventListener("transitionend", this.onTransitionEnd_), window.addEventListener("resize", this.refresh), RU ? (this.mutationsObserver_ = new MutationObserver(this.refresh), this.mutationsObserver_.observe(document, {
+    }, Z.prototype.connect_ = function() {
+      !ul || this.connected_ || (document.addEventListener("transitionend", this.onTransitionEnd_), window.addEventListener("resize", this.refresh), RU ? (this.mutationsObserver_ = new MutationObserver(this.refresh), this.mutationsObserver_.observe(document, {
         attributes: !0,
         childList: !0,
         characterData: !0,
         subtree: !0
       })) : (document.addEventListener("DOMSubtreeModified", this.refresh), this.mutationEventsAdded_ = !0), this.connected_ = !0);
-    }, d.prototype.disconnect_ = function() {
-      !Gl || !this.connected_ || (document.removeEventListener("transitionend", this.onTransitionEnd_), window.removeEventListener("resize", this.refresh), this.mutationsObserver_ && this.mutationsObserver_.disconnect(), this.mutationEventsAdded_ && document.removeEventListener("DOMSubtreeModified", this.refresh), this.mutationsObserver_ = null, this.mutationEventsAdded_ = !1, this.connected_ = !1);
-    }, d.prototype.onTransitionEnd_ = function(l) {
-      var U = l.propertyName, F = U === void 0 ? "" : U, Z = tU.some(function(V) {
-        return !!~F.indexOf(V);
+    }, Z.prototype.disconnect_ = function() {
+      !ul || !this.connected_ || (document.removeEventListener("transitionend", this.onTransitionEnd_), window.removeEventListener("resize", this.refresh), this.mutationsObserver_ && this.mutationsObserver_.disconnect(), this.mutationEventsAdded_ && document.removeEventListener("DOMSubtreeModified", this.refresh), this.mutationsObserver_ = null, this.mutationEventsAdded_ = !1, this.connected_ = !1);
+    }, Z.prototype.onTransitionEnd_ = function(l) {
+      var U = l.propertyName, F = U === void 0 ? "" : U, d = tU.some(function(Q) {
+        return !!~F.indexOf(Q);
       });
-      Z && this.refresh();
-    }, d.getInstance = function() {
-      return this.instance_ || (this.instance_ = new d()), this.instance_;
-    }, d.instance_ = null, d;
+      d && this.refresh();
+    }, Z.getInstance = function() {
+      return this.instance_ || (this.instance_ = new Z()), this.instance_;
+    }, Z.instance_ = null, Z;
   }()
-), Hl = function(d, l) {
+), Hl = function(Z, l) {
   for (var U = 0, F = Object.keys(l); U < F.length; U++) {
-    var Z = F[U];
-    Object.defineProperty(d, Z, {
-      value: l[Z],
+    var d = F[U];
+    Object.defineProperty(Z, d, {
+      value: l[d],
       enumerable: !1,
       writable: !1,
       configurable: !0
     });
   }
-  return d;
-}, dl = function(d) {
-  var l = d && d.ownerDocument && d.ownerDocument.defaultView;
+  return Z;
+}, dl = function(Z) {
+  var l = Z && Z.ownerDocument && Z.ownerDocument.defaultView;
   return l || ml;
 }, Dl = hl(0, 0, 0, 0);
-function Wl(d) {
-  return parseFloat(d) || 0;
+function Wl(Z) {
+  return parseFloat(Z) || 0;
 }
-function Tl(d) {
+function Tl(Z) {
   for (var l = [], U = 1; U < arguments.length; U++)
     l[U - 1] = arguments[U];
-  return l.reduce(function(F, Z) {
-    var V = d["border-" + Z + "-width"];
-    return F + Wl(V);
+  return l.reduce(function(F, d) {
+    var Q = Z["border-" + d + "-width"];
+    return F + Wl(Q);
   }, 0);
 }
-function nU(d) {
-  for (var l = ["top", "right", "bottom", "left"], U = {}, F = 0, Z = l; F < Z.length; F++) {
-    var V = Z[F], Q = d["padding-" + V];
-    U[V] = Wl(Q);
+function nU(Z) {
+  for (var l = ["top", "right", "bottom", "left"], U = {}, F = 0, d = l; F < d.length; F++) {
+    var Q = d[F], V = Z["padding-" + Q];
+    U[Q] = Wl(V);
   }
   return U;
 }
-function mU(d) {
-  var l = d.getBBox();
+function mU(Z) {
+  var l = Z.getBBox();
   return hl(0, 0, l.width, l.height);
 }
-function WU(d) {
-  var l = d.clientWidth, U = d.clientHeight;
+function WU(Z) {
+  var l = Z.clientWidth, U = Z.clientHeight;
   if (!l && !U)
     return Dl;
-  var F = dl(d).getComputedStyle(d), Z = nU(F), V = Z.left + Z.right, Q = Z.top + Z.bottom, t = Wl(F.width), R = Wl(F.height);
-  if (F.boxSizing === "border-box" && (Math.round(t + V) !== l && (t -= Tl(F, "left", "right") + V), Math.round(R + Q) !== U && (R -= Tl(F, "top", "bottom") + Q)), !cU(d)) {
-    var a = Math.round(t + V) - l, n = Math.round(R + Q) - U;
+  var F = dl(Z).getComputedStyle(Z), d = nU(F), Q = d.left + d.right, V = d.top + d.bottom, t = Wl(F.width), R = Wl(F.height);
+  if (F.boxSizing === "border-box" && (Math.round(t + Q) !== l && (t -= Tl(F, "left", "right") + Q), Math.round(R + V) !== U && (R -= Tl(F, "top", "bottom") + V)), !cU(Z)) {
+    var a = Math.round(t + Q) - l, n = Math.round(R + V) - U;
     Math.abs(a) !== 1 && (t -= a), Math.abs(n) !== 1 && (R -= n);
   }
-  return hl(Z.left, Z.top, t, R);
+  return hl(d.left, d.top, t, R);
 }
 var bU = /* @__PURE__ */ function() {
-  return typeof SVGGraphicsElement < "u" ? function(d) {
-    return d instanceof dl(d).SVGGraphicsElement;
-  } : function(d) {
-    return d instanceof dl(d).SVGElement && typeof d.getBBox == "function";
+  return typeof SVGGraphicsElement < "u" ? function(Z) {
+    return Z instanceof dl(Z).SVGGraphicsElement;
+  } : function(Z) {
+    return Z instanceof dl(Z).SVGElement && typeof Z.getBBox == "function";
   };
 }();
-function cU(d) {
-  return d === dl(d).document.documentElement;
+function cU(Z) {
+  return Z === dl(Z).document.documentElement;
 }
-function eU(d) {
-  return Gl ? bU(d) ? mU(d) : WU(d) : Dl;
+function eU(Z) {
+  return ul ? bU(Z) ? mU(Z) : WU(Z) : Dl;
 }
-function sU(d) {
-  var l = d.x, U = d.y, F = d.width, Z = d.height, V = typeof DOMRectReadOnly < "u" ? DOMRectReadOnly : Object, Q = Object.create(V.prototype);
-  return Hl(Q, {
+function sU(Z) {
+  var l = Z.x, U = Z.y, F = Z.width, d = Z.height, Q = typeof DOMRectReadOnly < "u" ? DOMRectReadOnly : Object, V = Object.create(Q.prototype);
+  return Hl(V, {
     x: l,
     y: U,
     width: F,
-    height: Z,
+    height: d,
     top: U,
     right: l + F,
-    bottom: Z + U,
+    bottom: d + U,
     left: l
-  }), Q;
+  }), V;
 }
-function hl(d, l, U, F) {
-  return { x: d, y: l, width: U, height: F };
+function hl(Z, l, U, F) {
+  return { x: Z, y: l, width: U, height: F };
 }
 var hU = (
   /** @class */
   function() {
-    function d(l) {
+    function Z(l) {
       this.broadcastWidth = 0, this.broadcastHeight = 0, this.contentRect_ = hl(0, 0, 0, 0), this.target = l;
     }
-    return d.prototype.isActive = function() {
+    return Z.prototype.isActive = function() {
       var l = eU(this.target);
       return this.contentRect_ = l, l.width !== this.broadcastWidth || l.height !== this.broadcastHeight;
-    }, d.prototype.broadcastRect = function() {
+    }, Z.prototype.broadcastRect = function() {
       var l = this.contentRect_;
       return this.broadcastWidth = l.width, this.broadcastHeight = l.height, l;
-    }, d;
+    }, Z;
   }()
 ), BU = (
   /** @class */
   /* @__PURE__ */ function() {
-    function d(l, U) {
+    function Z(l, U) {
       var F = sU(U);
       Hl(this, { target: l, contentRect: F });
     }
-    return d;
+    return Z;
   }()
 ), JU = (
   /** @class */
   function() {
-    function d(l, U, F) {
+    function Z(l, U, F) {
       if (this.activeObservations_ = [], this.observations_ = new gl(), typeof l != "function")
         throw new TypeError("The callback provided as parameter 1 is not a function.");
       this.callback_ = l, this.controller_ = U, this.callbackCtx_ = F;
     }
-    return d.prototype.observe = function(l) {
+    return Z.prototype.observe = function(l) {
       if (!arguments.length)
         throw new TypeError("1 argument required, but only 0 present.");
       if (!(typeof Element > "u" || !(Element instanceof Object))) {
@@ -231,7 +231,7 @@ var hU = (
         var U = this.observations_;
         U.has(l) || (U.set(l, new hU(l)), this.controller_.addObserver(this), this.controller_.refresh());
       }
-    }, d.prototype.unobserve = function(l) {
+    }, Z.prototype.unobserve = function(l) {
       if (!arguments.length)
         throw new TypeError("1 argument required, but only 0 present.");
       if (!(typeof Element > "u" || !(Element instanceof Object))) {
@@ -240,80 +240,80 @@ var hU = (
         var U = this.observations_;
         U.has(l) && (U.delete(l), U.size || this.controller_.removeObserver(this));
       }
-    }, d.prototype.disconnect = function() {
+    }, Z.prototype.disconnect = function() {
       this.clearActive(), this.observations_.clear(), this.controller_.removeObserver(this);
-    }, d.prototype.gatherActive = function() {
+    }, Z.prototype.gatherActive = function() {
       var l = this;
       this.clearActive(), this.observations_.forEach(function(U) {
         U.isActive() && l.activeObservations_.push(U);
       });
-    }, d.prototype.broadcastActive = function() {
+    }, Z.prototype.broadcastActive = function() {
       if (this.hasActive()) {
         var l = this.callbackCtx_, U = this.activeObservations_.map(function(F) {
           return new BU(F.target, F.broadcastRect());
         });
         this.callback_.call(l, U, l), this.clearActive();
       }
-    }, d.prototype.clearActive = function() {
+    }, Z.prototype.clearActive = function() {
       this.activeObservations_.splice(0);
-    }, d.prototype.hasActive = function() {
+    }, Z.prototype.hasActive = function() {
       return this.activeObservations_.length > 0;
-    }, d;
+    }, Z;
   }()
 ), jl = typeof WeakMap < "u" ? /* @__PURE__ */ new WeakMap() : new gl(), Pl = (
   /** @class */
   /* @__PURE__ */ function() {
-    function d(l) {
-      if (!(this instanceof d))
+    function Z(l) {
+      if (!(this instanceof Z))
         throw new TypeError("Cannot call a class as a function.");
       if (!arguments.length)
         throw new TypeError("1 argument required, but only 0 present.");
       var U = aU.getInstance(), F = new JU(l, U, this);
       jl.set(this, F);
     }
-    return d;
+    return Z;
   }()
 );
 [
   "observe",
   "unobserve",
   "disconnect"
-].forEach(function(d) {
-  Pl.prototype[d] = function() {
+].forEach(function(Z) {
+  Pl.prototype[Z] = function() {
     var l;
-    return (l = jl.get(this))[d].apply(l, arguments);
+    return (l = jl.get(this))[Z].apply(l, arguments);
   };
 });
-var GU = function() {
+var uU = function() {
   return typeof ml.ResizeObserver < "u" ? ml.ResizeObserver : Pl;
 }();
-function ll(d) {
+function ll(Z) {
   const l = x(0), U = x(0);
   let F = null;
-  const Z = () => {
+  const d = () => {
     F && (F.disconnect(), F = null);
   };
-  return v(() => r(d), () => {
-    Z();
-    const Q = r(d);
-    if (!Q) return;
-    F = new GU((R) => {
+  return v(() => r(Z), () => {
+    d();
+    const V = r(Z);
+    if (!V) return;
+    F = new uU((R) => {
       const a = R[0];
       a && (l.value = a.contentRect.width, U.value = a.contentRect.height);
-    }), F.observe(Q);
-    const t = Q.getBoundingClientRect();
+    }), F.observe(V);
+    const t = V.getBoundingClientRect();
     l.value = t.width, U.value = t.height;
-  }, { immediate: !0 }), UU(Z), {
+  }, { immediate: !0 }), UU(d), {
     width: yl(l),
     height: yl(U)
   };
 }
-const g = (d, l) => {
-  const U = d.__vccOpts || d;
-  for (const [F, Z] of l)
-    U[F] = Z;
+const g = (Z, l) => {
+  const U = Z.__vccOpts || Z;
+  for (const [F, d] of l)
+    U[F] = d;
   return U;
-}, uU = {
+}, GU = {
   key: 0,
   class: "level"
 }, iU = {
@@ -332,15 +332,15 @@ const g = (d, l) => {
     valueModifiers: {}
   }),
   emits: ["update:value"],
-  setup(d) {
+  setup(Z) {
     $((i) => ({
       "083f3e45": c.value,
-      d4833630: b.value,
+      d4833630: W.value,
       d6eaa016: J.value,
       12894835: s.value,
       "3e9a6a44": N.value
     }));
-    const l = d, U = O("root"), { width: F, height: Z } = ll(U), V = u(() => Math.min(F.value, Z.value)), Q = u(() => Math.max(F.value, Z.value)), t = u(() => F.value > Z.value), R = u(() => t.value ? "h-slide" : "v-slide"), a = _(d, "value"), n = u(() => V.value * 0.8), m = u(() => V.value * l.thumbLength * 0.8), b = u(() => (t.value ? m : n).value + "px"), c = u(() => (t.value ? n : m).value + "px"), s = u(() => V.value * 0.1 + "px"), N = u(() => (Q.value - m.value) * (a.value - l.min) / (l.max - l.min) + "px"), J = u(() => t.value ? "90deg" : "0deg"), p = x(!1), M = x(0), y = (i) => {
+    const l = Z, U = O("root"), { width: F, height: d } = ll(U), Q = G(() => Math.min(F.value, d.value)), V = G(() => Math.max(F.value, d.value)), t = G(() => F.value > d.value), R = G(() => t.value ? "h-slide" : "v-slide"), a = _(Z, "value"), n = G(() => Q.value * 0.8), m = G(() => Q.value * l.thumbLength * 0.8), W = G(() => (t.value ? m : n).value + "px"), c = G(() => (t.value ? n : m).value + "px"), s = G(() => Q.value * 0.1 + "px"), N = G(() => (V.value - m.value) * (a.value - l.min) / (l.max - l.min) + "px"), J = G(() => t.value ? "90deg" : "0deg"), p = x(!1), M = x(0), y = (i) => {
       if (!U.value) return a.value;
       const z = U.value.getBoundingClientRect(), P = i.touches ? i.touches[0].clientX : i.clientX, B = i.touches ? i.touches[0].clientY : i.clientY;
       let S;
@@ -353,7 +353,7 @@ const g = (d, l) => {
       }
       const T = l.min + S * (l.max - l.min);
       return l.step > 0 ? Math.round(T / l.step) * l.step : T;
-    }, G = (i) => {
+    }, u = (i) => {
       i.preventDefault(), p.value = !0, M.value = a.value, a.value = y(i), U.value && U.value.setPointerCapture && U.value.setPointerCapture(i.pointerId), document.addEventListener("mousemove", k), document.addEventListener("mouseup", E);
     }, k = (i) => {
       p.value && (i.preventDefault(), a.value = y(i));
@@ -377,12 +377,12 @@ const g = (d, l) => {
       class: L(R.value),
       ref_key: "root",
       ref: U,
-      onMousedown: G,
+      onMousedown: u,
       onTouchstart: H,
       style: { userSelect: "none", touchAction: "none" }
     }, [
       z[0] || (z[0] = h("div", { class: "track" }, null, -1)),
-      d.showLevel ? (X(), Y("div", uU, [
+      Z.showLevel ? (X(), Y("div", GU, [
         (X(), Y(al, null, Sl(10, (P) => h("div", {
           class: L(["led", "led" + P])
         }, [
@@ -393,7 +393,7 @@ const g = (d, l) => {
         ], 2)), 64))
       ])) : f("", !0),
       h("div", {
-        class: L(["thumb", { dragging: p.value, [d.colour]: !0, [d.style]: !0 }])
+        class: L(["thumb", { dragging: p.value, [Z.colour]: !0, [Z.style]: !0 }])
       }, null, 2)
     ], 34));
   }
@@ -405,18 +405,18 @@ const g = (d, l) => {
       default: "left"
     }
   },
-  setup(d) {
+  setup(Z) {
     $((t) => ({
-      "5fddb56d": Q.value
+      "5fddb56d": V.value
     }));
-    const l = O("el"), { width: U, height: F } = ll(l), Z = u(() => Math.min(U.value, F.value)), V = u(() => U.value > F.value ? "h-text" : "v-text"), Q = u(() => Z.value * 3 / 4 + "px");
+    const l = O("el"), { width: U, height: F } = ll(l), d = G(() => Math.min(U.value, F.value)), Q = G(() => U.value > F.value ? "h-text" : "v-text"), V = G(() => d.value * 3 / 4 + "px");
     return (t, R) => (X(), Y("div", {
       ref_key: "el",
       ref: l,
       class: "outer"
     }, [
       h("div", {
-        class: L({ [V.value]: !0, [d.align]: !0 })
+        class: L({ [Q.value]: !0, [Z.align]: !0 })
       }, [
         Vl(t.$slots, "default", {}, void 0, !0)
       ], 2)
@@ -431,8 +431,8 @@ const g = (d, l) => {
     soloModifiers: {}
   },
   emits: ["update:mute", "update:solo"],
-  setup(d) {
-    const l = _(d, "mute"), U = _(d, "solo"), F = O("outer"), { width: Z, height: V } = ll(F), Q = u(() => Z.value > V.value * 1.9);
+  setup(Z) {
+    const l = _(Z, "mute"), U = _(Z, "solo"), F = O("outer"), { width: d, height: Q } = ll(F), V = G(() => d.value > Q.value * 1.9);
     function t() {
       l.value = !l.value, U.value = !1;
     }
@@ -451,7 +451,7 @@ const g = (d, l) => {
       h("div", {
         class: "s-label",
         onClick: R
-      }, K(Q.value ? "SOLO" : "S"), 1),
+      }, K(V.value ? "SOLO" : "S"), 1),
       h("div", {
         class: L(["mute", { on: l.value }]),
         onClick: t
@@ -459,10 +459,10 @@ const g = (d, l) => {
       h("div", {
         class: "m-label",
         onClick: t
-      }, K(Q.value ? "MUTE" : "M"), 1)
+      }, K(V.value ? "MUTE" : "M"), 1)
     ], 512));
   }
-}, XU = /* @__PURE__ */ g(oU, [["__scopeId", "data-v-143eade0"]]), ul = {
+}, XU = /* @__PURE__ */ g(oU, [["__scopeId", "data-v-143eade0"]]), Gl = {
   // Enable development UI features (animations, random data, etc.)
   enabled: !1,
   // Specific feature flags
@@ -474,7 +474,7 @@ const g = (d, l) => {
     // Enable other debug/dev features as needed
     debugMode: !1
   }
-}, kF = () => ul.enabled, Ol = (d) => ul.enabled && ul.features[d], Ul = sl("audioState", {
+}, kF = () => Gl.enabled, Ol = (Z) => Gl.enabled && Gl.features[Z], Ul = sl("audioState", {
   state: () => ({
     // Playback state
     isPlaying: !1,
@@ -502,78 +502,78 @@ const g = (d, l) => {
   }),
   getters: {
     // Format current time as MM:SS
-    formattedTime: (d) => {
-      const l = Math.floor(d.currentTime / 60), U = Math.floor(d.currentTime % 60);
+    formattedTime: (Z) => {
+      const l = Math.floor(Z.currentTime / 60), U = Math.floor(Z.currentTime % 60);
       return `${l}:${U.toString().padStart(2, "0")}`;
     },
     // Get volume for a specific part
-    getPartVolume: (d) => (l) => d.partVolumes[l] ?? 0.75,
+    getPartVolume: (Z) => (l) => Z.partVolumes[l] ?? 0.75,
     // Check if part is muted
-    isPartMuted: (d) => (l) => d.partMuted[l] ?? !1,
+    isPartMuted: (Z) => (l) => Z.partMuted[l] ?? !1,
     // Check if part is solo
-    isPartSolo: (d) => (l) => d.partSolo[l] ?? !1,
+    isPartSolo: (Z) => (l) => Z.partSolo[l] ?? !1,
     // Check if any part has solo enabled (global solo state)
-    isAnySolo: (d) => Object.values(d.partSolo).some((l) => l === !0),
+    isAnySolo: (Z) => Object.values(Z.partSolo).some((l) => l === !0),
     // Current musical position as string
-    currentPosition: (d) => {
-      let l = `${d.currentBar}.${d.currentBeat}`;
-      return d.currentRepeat > 0 && (l += ` (R${d.currentRepeat})`), l;
+    currentPosition: (Z) => {
+      let l = `${Z.currentBar}.${Z.currentBeat}`;
+      return Z.currentRepeat > 0 && (l += ` (R${Z.currentRepeat})`), l;
     }
   },
   actions: {
     // Playback state updates
-    setPlaybackState(d) {
-      this.isPlaying = d;
+    setPlaybackState(Z) {
+      this.isPlaying = Z;
     },
-    setCurrentTime(d) {
-      this.currentTime = d;
+    setCurrentTime(Z) {
+      this.currentTime = Z;
     },
-    setPlaybackSpeed(d) {
-      this.playbackSpeed = d;
+    setPlaybackSpeed(Z) {
+      this.playbackSpeed = Z;
     },
     // Musical position updates
-    setCurrentBar(d, l = 1, U = 0) {
-      typeof d == "number" && (this.currentBar = d), typeof l == "number" && (this.currentBeat = l), typeof U == "number" && (this.currentRepeat = U);
+    setCurrentBar(Z, l = 1, U = 0) {
+      typeof Z == "number" && (this.currentBar = Z), typeof l == "number" && (this.currentBeat = l), typeof U == "number" && (this.currentRepeat = U);
     },
     // Volume controls
-    setMasterVolume(d) {
-      this.masterVolume = Math.max(0, Math.min(1, d));
+    setMasterVolume(Z) {
+      this.masterVolume = Math.max(0, Math.min(1, Z));
     },
-    setMetronomeVolume(d) {
-      this.metronomeVolume = Math.max(0, Math.min(1, d));
+    setMetronomeVolume(Z) {
+      this.metronomeVolume = Math.max(0, Math.min(1, Z));
     },
-    setPartVolume(d, l) {
-      this.partVolumes[d] = Math.max(0, Math.min(1, l));
+    setPartVolume(Z, l) {
+      this.partVolumes[Z] = Math.max(0, Math.min(1, l));
     },
-    setPartMuted(d, l) {
-      this.partMuted[d] = l;
+    setPartMuted(Z, l) {
+      this.partMuted[Z] = l;
     },
-    setPartSolo(d, l) {
-      this.partSolo[d] = l;
+    setPartSolo(Z, l) {
+      this.partSolo[Z] = l;
     },
     // Transport features
-    setLeadInActive(d, l = 1) {
-      this.isLeadInActive = d, this.leadInBars = l;
+    setLeadInActive(Z, l = 1) {
+      this.isLeadInActive = Z, this.leadInBars = l;
     },
-    setStartingNotesActive(d) {
-      this.isStartingNotesActive = d;
+    setStartingNotesActive(Z) {
+      this.isStartingNotesActive = Z;
     },
     // Feature toggles
-    setMetronomeEnabled(d) {
-      this.metronomeEnabled = d;
+    setMetronomeEnabled(Z) {
+      this.metronomeEnabled = Z;
     },
-    setLeadInEnabled(d) {
-      this.leadInEnabled = d;
+    setLeadInEnabled(Z) {
+      this.leadInEnabled = Z;
     },
     // Initialize part states
-    initializeParts(d) {
-      this.partVolumes = {}, this.partMuted = {}, this.partSolo = {}, d.forEach((l) => {
+    initializeParts(Z) {
+      this.partVolumes = {}, this.partMuted = {}, this.partSolo = {}, Z.forEach((l) => {
         this.partVolumes[l.name] = l.volume || 0.75, this.partMuted[l.name] = !1, this.partSolo[l.name] = !1;
       });
     },
     // Initialization state (for blur overlay)
-    setLoaded(d) {
-      this.isLoaded = d;
+    setLoaded(Z) {
+      this.isLoaded = Z;
     }
   }
 }), tl = sl("musicData", {
@@ -592,30 +592,30 @@ const g = (d, l) => {
   }),
   getters: {
     // Get practice mark letters as array
-    practiceMarkLetters: (d) => Object.keys(d.practiceMarks).sort(),
+    practiceMarkLetters: (Z) => Object.keys(Z.practiceMarks).sort(),
     // Get bar number for practice mark
-    getBarForMark: (d) => (l) => d.practiceMarks[l],
+    getBarForMark: (Z) => (l) => Z.practiceMarks[l],
     // Get all unique bar numbers
-    allBars: (d) => {
+    allBars: (Z) => {
       const l = /* @__PURE__ */ new Set();
-      return d.beats.forEach((U) => {
+      return Z.beats.forEach((U) => {
         U.beat === 1 && l.add(U.bar);
       }), Array.from(l).sort((U, F) => U - F);
     },
     // Check if a bar has repeats
-    hasRepeats: (d) => (l) => d.beats.some((U) => U.bar === l && U.repeat > 0),
+    hasRepeats: (Z) => (l) => Z.beats.some((U) => U.bar === l && U.repeat > 0),
     // Get the number of repeats for a specific bar
-    getRepeatCountForBar: (d) => (l) => {
+    getRepeatCountForBar: (Z) => (l) => {
       const U = /* @__PURE__ */ new Set();
-      return d.beats.forEach((F) => {
+      return Z.beats.forEach((F) => {
         F.bar === l && U.add(F.repeat);
       }), U.size;
     }
   },
   actions: {
     // Load musical data
-    loadMusicData(d) {
-      this.title = d.title || "Untitled", this.beats = d.beats || [], this.practiceMarks = d.practiceMarks || d.marks || {}, this.parts = (d.parts || []).map((l) => ({
+    loadMusicData(Z) {
+      this.title = Z.title || "Untitled", this.beats = Z.beats || [], this.practiceMarks = Z.practiceMarks || Z.marks || {}, this.parts = (Z.parts || []).map((l) => ({
         ...l,
         solo: l.solo || !1,
         mute: l.mute || !1
@@ -623,38 +623,38 @@ const g = (d, l) => {
     },
     // Calculate total duration from beats
     calculateDuration() {
-      this.beats.length > 0 && (this.totalDuration = Math.max(...this.beats.map((d) => d.time)));
+      this.beats.length > 0 && (this.totalDuration = Math.max(...this.beats.map((Z) => Z.time)));
     },
     // Find the highest bar number
     calculateMaxBar() {
-      this.beats.length > 0 && (this.maxBar = Math.max(...this.beats.map((d) => d.bar)));
+      this.beats.length > 0 && (this.maxBar = Math.max(...this.beats.map((Z) => Z.bar)));
     },
     // Extract time signature from first beat
     extractTimeSignature() {
       this.beats.length > 0 && this.beats[0].timeSig && (this.timeSignature = this.beats[0].timeSig), this.beats.length > 0 && this.beats[0].tempo && (this.baseTempo = this.beats[0].tempo);
     },
     // Update practice marks
-    setPracticeMark(d, l) {
-      this.practiceMarks[d] = l;
+    setPracticeMark(Z, l) {
+      this.practiceMarks[Z] = l;
     },
-    removePracticeMark(d) {
-      delete this.practiceMarks[d];
+    removePracticeMark(Z) {
+      delete this.practiceMarks[Z];
     },
     // Update beats data (for when MIDI parser provides new beat information)
-    updateBeats(d) {
-      console.log("Updating beats in music data store"), this.beats = d, this.calculateDuration(), this.calculateMaxBar(), this.extractTimeSignature();
+    updateBeats(Z) {
+      console.log("Updating beats in music data store"), this.beats = Z, this.calculateDuration(), this.calculateMaxBar(), this.extractTimeSignature();
     },
     // Update total duration (for when audio engine provides actual duration)
-    setTotalDuration(d) {
-      console.log("Setting total duration in music data store to:", d), this.totalDuration = d;
+    setTotalDuration(Z) {
+      console.log("Setting total duration in music data store to:", Z), this.totalDuration = Z;
     },
     // Validate bar number
-    isValidBar(d, l = 0) {
-      return this.beats.some((U) => U.bar === d && U.repeat === l);
+    isValidBar(Z, l = 0) {
+      return this.beats.some((U) => U.bar === Z && U.repeat === l);
     },
     // Update parts (for when audio engine discovers parts from MIDI)
-    setParts(d) {
-      this.parts = d.map((l) => ({
+    setParts(Z) {
+      this.parts = Z.map((l) => ({
         name: l.name,
         volume: l.volume || 0.75,
         solo: l.solo || !1,
@@ -691,20 +691,20 @@ const g = (d, l) => {
   }),
   getters: {
     // Check if currently playing
-    isPlaying: (d) => d.transportState === "playing",
+    isPlaying: (Z) => Z.transportState === "playing",
     // Check if paused
-    isPaused: (d) => d.transportState === "paused",
+    isPaused: (Z) => Z.transportState === "paused",
     // Check if stopped
-    isStopped: (d) => d.transportState === "stopped",
+    isStopped: (Z) => Z.transportState === "stopped",
     // Check if loop is configured
-    isLoopConfigured: (d) => d.loopEnabled && d.loopStart && d.loopEnd && d.loopEnd > d.loopStart,
+    isLoopConfigured: (Z) => Z.loopEnabled && Z.loopStart && Z.loopEnd && Z.loopEnd > Z.loopStart,
     // Get loop range as string
-    loopRange: (d) => !d.loopEnabled || !d.loopStart || !d.loopEnd ? null : `${d.loopStart}-${d.loopEnd}`
+    loopRange: (Z) => !Z.loopEnabled || !Z.loopStart || !Z.loopEnd ? null : `${Z.loopStart}-${Z.loopEnd}`
   },
   actions: {
     // Transport controls
-    setTransportState(d) {
-      ["stopped", "playing", "paused"].includes(d) && (this.transportState = d);
+    setTransportState(Z) {
+      ["stopped", "playing", "paused"].includes(Z) && (this.transportState = Z);
     },
     play() {
       this.setTransportState("playing");
@@ -716,55 +716,55 @@ const g = (d, l) => {
       this.setTransportState("stopped");
     },
     // Navigation settings
-    setAutoPlay(d) {
-      this.autoPlay = d;
+    setAutoPlay(Z) {
+      this.autoPlay = Z;
     },
-    setLoop(d, l = null, U = null) {
-      this.loopEnabled = d, l !== null && (this.loopStart = l), U !== null && (this.loopEnd = U);
+    setLoop(Z, l = null, U = null) {
+      this.loopEnabled = Z, l !== null && (this.loopStart = l), U !== null && (this.loopEnd = U);
     },
-    setLoopStart(d) {
-      this.loopStart = d, this.loopEnd && this.loopEnd <= d && (this.loopEnd = d + 4);
+    setLoopStart(Z) {
+      this.loopStart = Z, this.loopEnd && this.loopEnd <= Z && (this.loopEnd = Z + 4);
     },
-    setLoopEnd(d) {
-      this.loopEnd = d, this.loopStart && this.loopStart >= d && (this.loopStart = Math.max(1, d - 4));
+    setLoopEnd(Z) {
+      this.loopEnd = Z, this.loopStart && this.loopStart >= Z && (this.loopStart = Math.max(1, Z - 4));
     },
     // Lead-in settings
-    setLeadInEnabled(d) {
-      this.leadInEnabled = d;
+    setLeadInEnabled(Z) {
+      this.leadInEnabled = Z;
     },
-    setLeadInBars(d) {
-      this.leadInBars = Math.max(1, Math.min(4, d));
+    setLeadInBars(Z) {
+      this.leadInBars = Math.max(1, Math.min(4, Z));
     },
     // Starting notes settings
-    setStartingNotesEnabled(d) {
-      this.startingNotesEnabled = d;
+    setStartingNotesEnabled(Z) {
+      this.startingNotesEnabled = Z;
     },
-    setStartingNotesSequential(d) {
-      this.startingNotesSequential = d;
+    setStartingNotesSequential(Z) {
+      this.startingNotesSequential = Z;
     },
     // Metronome settings
-    setMetronomeEnabled(d) {
-      this.metronomeEnabled = d;
+    setMetronomeEnabled(Z) {
+      this.metronomeEnabled = Z;
     },
-    setMetronomeVolume(d) {
-      this.metronomeVolume = Math.max(0, Math.min(1, d));
+    setMetronomeVolume(Z) {
+      this.metronomeVolume = Math.max(0, Math.min(1, Z));
     },
     // UI visibility controls
-    setTransportControlsVisible(d) {
-      this.showTransportControls = d;
+    setTransportControlsVisible(Z) {
+      this.showTransportControls = Z;
     },
-    setPartControlsVisible(d) {
-      this.showPartControls = d;
+    setPartControlsVisible(Z) {
+      this.showPartControls = Z;
     },
-    setNavigationControlsVisible(d) {
-      this.showNavigationControls = d;
+    setNavigationControlsVisible(Z) {
+      this.showNavigationControls = Z;
     },
     // Position tracking
-    updateLastBarPosition(d) {
-      this.lastBarPosition = d;
+    updateLastBarPosition(Z) {
+      this.lastBarPosition = Z;
     },
-    updateLastPracticeMarkUsed(d) {
-      this.lastPracticeMarkUsed = d;
+    updateLastPracticeMarkUsed(Z) {
+      this.lastPracticeMarkUsed = Z;
     },
     // Reset to defaults
     resetToDefaults() {
@@ -772,35 +772,35 @@ const g = (d, l) => {
     }
   }
 });
-function fl(d) {
-  return { all: d = d || /* @__PURE__ */ new Map(), on: function(l, U) {
-    var F = d.get(l);
-    F ? F.push(U) : d.set(l, [U]);
+function fl(Z) {
+  return { all: Z = Z || /* @__PURE__ */ new Map(), on: function(l, U) {
+    var F = Z.get(l);
+    F ? F.push(U) : Z.set(l, [U]);
   }, off: function(l, U) {
-    var F = d.get(l);
-    F && (U ? F.splice(F.indexOf(U) >>> 0, 1) : d.set(l, []));
+    var F = Z.get(l);
+    F && (U ? F.splice(F.indexOf(U) >>> 0, 1) : Z.set(l, []));
   }, emit: function(l, U) {
-    var F = d.get(l);
-    F && F.slice().map(function(Z) {
-      Z(U);
-    }), (F = d.get("*")) && F.slice().map(function(Z) {
-      Z(l, U);
+    var F = Z.get(l);
+    F && F.slice().map(function(d) {
+      d(U);
+    }), (F = Z.get("*")) && F.slice().map(function(d) {
+      d(l, U);
     });
   } };
 }
-function Xl(d) {
-  return { all: d = d || /* @__PURE__ */ new Map(), on: function(l, U) {
-    var F = d.get(l);
-    F ? F.push(U) : d.set(l, [U]);
+function Xl(Z) {
+  return { all: Z = Z || /* @__PURE__ */ new Map(), on: function(l, U) {
+    var F = Z.get(l);
+    F ? F.push(U) : Z.set(l, [U]);
   }, off: function(l, U) {
-    var F = d.get(l);
-    F && (U ? F.splice(F.indexOf(U) >>> 0, 1) : d.set(l, []));
+    var F = Z.get(l);
+    F && (U ? F.splice(F.indexOf(U) >>> 0, 1) : Z.set(l, []));
   }, emit: function(l, U) {
-    var F = d.get(l);
-    F && F.slice().map(function(Z) {
-      Z(U);
-    }), (F = d.get("*")) && F.slice().map(function(Z) {
-      Z(l, U);
+    var F = Z.get(l);
+    F && F.slice().map(function(d) {
+      d(U);
+    }), (F = Z.get("*")) && F.slice().map(function(d) {
+      d(l, U);
     });
   } };
 }
@@ -840,8 +840,8 @@ class Nl {
    * @protected
    */
   _emitProgress(l, U, F = null) {
-    const Z = { stage: l, message: U };
-    F !== null && (Z.progress = Math.max(0, Math.min(1, F))), this.eventBus.emit("initProgress", Z);
+    const d = { stage: l, message: U };
+    F !== null && (d.progress = Math.max(0, Math.min(1, F))), this.eventBus.emit("initProgress", d);
   }
   /**
    * Initialize the audio engine - load soundfont and set up synthesis
@@ -878,21 +878,21 @@ class Nl {
   async playMetronomeTick(l, U, F) {
     try {
       await this._ensureMetronomeBuffersLoaded();
-      const Z = U ? this.accentTickBuffer : this.regularTickBuffer;
-      if (!Z) {
+      const d = U ? this.accentTickBuffer : this.regularTickBuffer;
+      if (!d) {
         console.warn("Metronome buffer not available");
         return;
       }
-      const V = this.audioContext.createBufferSource();
-      V.buffer = Z;
-      const Q = this.audioContext.createGain();
-      Q.gain.value = F, V.connect(Q);
+      const Q = this.audioContext.createBufferSource();
+      Q.buffer = d;
+      const V = this.audioContext.createGain();
+      V.gain.value = F, Q.connect(V);
       const t = this.getMetronomeOutput();
-      t ? Q.connect(t) : Q.connect(this.audioContext.destination);
+      t ? V.connect(t) : V.connect(this.audioContext.destination);
       const R = Math.max(l, this.audioContext.currentTime);
-      V.start(R);
-    } catch (Z) {
-      console.warn("Buffer metronome playback failed:", Z);
+      Q.start(R);
+    } catch (d) {
+      console.warn("Buffer metronome playback failed:", d);
     }
   }
   /**
@@ -914,14 +914,14 @@ class Nl {
           const [l, U] = await Promise.all([
             fetch(pU),
             fetch(YU)
-          ]), [F, Z] = await Promise.all([
+          ]), [F, d] = await Promise.all([
             l.arrayBuffer(),
             U.arrayBuffer()
-          ]), [V, Q] = await Promise.all([
+          ]), [Q, V] = await Promise.all([
             this.audioContext.decodeAudioData(F),
-            this.audioContext.decodeAudioData(Z)
+            this.audioContext.decodeAudioData(d)
           ]);
-          this.regularTickBuffer = V, this.accentTickBuffer = Q;
+          this.regularTickBuffer = Q, this.accentTickBuffer = V;
           return;
         }
       } catch (l) {
@@ -1012,22 +1012,22 @@ class pl {
    * @param {number} duration - Note duration in seconds
    * @returns {string} Event ID for cancellation
    */
-  playNote(l, U, F, Z) {
+  playNote(l, U, F, d) {
     this._validateActive();
-    const V = this.engine.audioContext.currentTime, Q = `${this.partId}_${l}_${U}_${Date.now()}`;
-    let t = l, R = Z;
-    if (l < V) {
-      const c = V - l;
-      t = V, R = Math.max(0, Z - c);
+    const Q = this.engine.audioContext.currentTime, V = `${this.partId}_${l}_${U}_${Date.now()}`;
+    let t = l, R = d;
+    if (l < Q) {
+      const c = Q - l;
+      t = Q, R = Math.max(0, d - c);
     }
     if (R <= 0)
-      return Q;
-    const a = Math.max(0, (t - V) * 1e3), n = setTimeout(() => {
-      this.noteOn(U, F), this.scheduledEvents.delete(`${Q}_on`);
-    }, a), m = a + R * 1e3, b = setTimeout(() => {
-      this.noteOff(U), this.scheduledEvents.delete(`${Q}_off`);
+      return V;
+    const a = Math.max(0, (t - Q) * 1e3), n = setTimeout(() => {
+      this.noteOn(U, F), this.scheduledEvents.delete(`${V}_on`);
+    }, a), m = a + R * 1e3, W = setTimeout(() => {
+      this.noteOff(U), this.scheduledEvents.delete(`${V}_off`);
     }, m);
-    return this.scheduledEvents.set(`${Q}_on`, n), this.scheduledEvents.set(`${Q}_off`, b), Q;
+    return this.scheduledEvents.set(`${V}_on`, n), this.scheduledEvents.set(`${V}_off`, W), V;
   }
   /**
    * Play a preview note (for pitch reference before singing)
@@ -1040,11 +1040,11 @@ class pl {
    */
   playPreviewNote(l, U = {}) {
     this._validateActive();
-    const F = U.startTime ?? this.engine.audioContext.currentTime + 0.01, Z = U.duration ?? 0.5, V = U.velocity ?? 100;
-    let Q = null;
-    U.instrument !== void 0 && (Q = this.getInstrument(), this.setInstrument(U.instrument)), this.playNote(F, l, V, Z), Q !== null && setTimeout(() => {
-      this.isDestroyed || this.setInstrument(Q);
-    }, (Z + 0.1) * 1e3);
+    const F = U.startTime ?? this.engine.audioContext.currentTime + 0.01, d = U.duration ?? 0.5, Q = U.velocity ?? 100;
+    let V = null;
+    U.instrument !== void 0 && (V = this.getInstrument(), this.setInstrument(U.instrument)), this.playNote(F, l, Q, d), V !== null && setTimeout(() => {
+      this.isDestroyed || this.setInstrument(V);
+    }, (d + 0.1) * 1e3);
   }
   /**
    * Stop all notes on this channel
@@ -1288,7 +1288,7 @@ const Al = {
   helicopter: 125,
   applause: 126,
   gunshot: 127
-}, yU = Object.entries(Al).reduce((d, [l, U]) => (d[U] = l, d), {});
+}, yU = Object.entries(Al).reduce((Z, [l, U]) => (Z[U] = l, Z), {});
 class EU {
   /**
    * Map common instrument names to MIDI program numbers
@@ -1320,8 +1320,8 @@ class EU {
   }
 }
 class kU extends pl {
-  constructor(l, U, F, Z = {}) {
-    super(l, U, Z), this.midiChannel = F, this.currentVolume = Z.initialVolume || 1, this.currentInstrument = Z.instrument || "piano", this.outputGain = null, this._setupOutputNode(), this.setVolume(this.currentVolume), Z.instrument && this.setInstrument(Z.instrument);
+  constructor(l, U, F, d = {}) {
+    super(l, U, d), this.midiChannel = F, this.currentVolume = d.initialVolume || 1, this.currentInstrument = d.instrument || "piano", this.outputGain = null, this._setupOutputNode(), this.setVolume(this.currentVolume), d.instrument && this.setInstrument(d.instrument);
   }
   getOutputNode() {
     return this.outputGain;
@@ -1335,8 +1335,8 @@ class kU extends pl {
   _actualNoteOn(l, U) {
     const F = this.engine._getSynthesizer();
     if (F && F.noteOn) {
-      const Z = Math.round(U * this.currentVolume);
-      F.noteOn(this.midiChannel, l, Z);
+      const d = Math.round(U * this.currentVolume);
+      F.noteOn(this.midiChannel, l, d);
     }
   }
   /**
@@ -1388,12 +1388,12 @@ class kU extends pl {
    * @param {number} duration - Note duration in seconds
    * @returns {string} Event ID for compatibility
    */
-  playNote(l, U, F, Z) {
+  playNote(l, U, F, d) {
     this._validateActive();
-    const V = `${this.partId}_${l}_${U}_${Date.now()}`, Q = this.engine._getSynthesizer();
-    if (Q && Q.post) {
+    const Q = `${this.partId}_${l}_${U}_${Date.now()}`, V = this.engine._getSynthesizer();
+    if (V && V.post) {
       const t = Math.round(F * this.currentVolume);
-      Q.post({
+      V.post({
         channelNumber: this.midiChannel,
         type: "midiMessage",
         data: {
@@ -1405,7 +1405,7 @@ class kU extends pl {
             // SpessaSynth will schedule this precisely!
           }
         }
-      }), Q.post({
+      }), V.post({
         channelNumber: this.midiChannel,
         type: "midiMessage",
         data: {
@@ -1413,14 +1413,14 @@ class kU extends pl {
           channelOffset: 0,
           force: !1,
           options: {
-            time: l + Z
+            time: l + d
             // Precise note-off timing!
           }
         }
       });
     } else
-      return super.playNote(l, U, F, Z);
-    return V;
+      return super.playNote(l, U, F, d);
+    return Q;
   }
   /**
    * Override allNotesOff to use SpessaSynth messaging system
@@ -1475,7 +1475,7 @@ class rU extends Nl {
       this._emitProgress("loading-soundfont", "Soundfont provided"), F = l;
     else
       throw new Error("Invalid soundfont data type. Expected string path or ArrayBuffer.");
-    this._emitProgress("loading-worklet", "Loading audio worklet processor..."), await this._loadAudioWorkletSafely(), console.log("AudioWorklet loaded. Note: Worklet processor may persist across page reloads."), this._emitProgress("creating-synth", "Setting up audio channels..."), this._setupIndividualOutputs(), this.dummyTarget = this.audioContext.createGain(), await new Promise((Z) => setTimeout(Z, 50)), this._emitProgress("creating-synth", "Initializing synthesizer..."), this.synthesizer = new U(this.audioContext), this._emitProgress("loading-soundbank", "Loading soundbank into synthesizer..."), await this.synthesizer.soundBankManager.addSoundBank(F, "main"), await this.synthesizer.isReady, this._emitProgress("finalizing", "Finalizing audio setup..."), this._connectIndividualOutputs(), this._initializeMetronomeChannel(), this._emitProgress("ready", "Audio engine ready"), this.isInitialized = !0;
+    this._emitProgress("loading-worklet", "Loading audio worklet processor..."), await this._loadAudioWorkletSafely(), console.log("AudioWorklet loaded. Note: Worklet processor may persist across page reloads."), this._emitProgress("creating-synth", "Setting up audio channels..."), this._setupIndividualOutputs(), this.dummyTarget = this.audioContext.createGain(), await new Promise((d) => setTimeout(d, 50)), this._emitProgress("creating-synth", "Initializing synthesizer..."), this.synthesizer = new U(this.audioContext), this._emitProgress("loading-soundbank", "Loading soundbank into synthesizer..."), await this.synthesizer.soundBankManager.addSoundBank(F, "main"), await this.synthesizer.isReady, this._emitProgress("finalizing", "Finalizing audio setup..."), this._connectIndividualOutputs(), this._initializeMetronomeChannel(), this._emitProgress("ready", "Audio engine ready"), this.isInitialized = !0;
   }
   createChannel(l, U = {}) {
     if (this._validateInitialized(), this.partToMidiChannel.has(l))
@@ -1484,13 +1484,13 @@ class rU extends Nl {
     if (F >= 15)
       throw new Error("Maximum number of musical part channels (15) exceeded. Channel 15 is reserved for metronome.");
     this.channelCounter++, this.partToMidiChannel.set(l, F), this.midiChannelToPart.set(F, l);
-    const Z = new kU(
+    const d = new kU(
       this,
       l,
       F,
       U
     );
-    return this._registerChannel(Z), U.instrument && Z.setInstrument(U.instrument), Z;
+    return this._registerChannel(d), U.instrument && d.setInstrument(U.instrument), d;
   }
   allSoundsOff() {
     if (this.synthesizer) {
@@ -1588,24 +1588,24 @@ class rU extends Nl {
     const U = await fetch(l);
     if (!U.ok)
       throw new Error(`Failed to load soundfont: ${U.status} ${U.statusText}`);
-    const F = U.headers.get("content-length"), Z = F ? parseInt(F, 10) : null;
-    if (!Z || !U.body)
+    const F = U.headers.get("content-length"), d = F ? parseInt(F, 10) : null;
+    if (!d || !U.body)
       return await U.arrayBuffer();
-    const V = U.body.getReader();
-    let Q = 0;
+    const Q = U.body.getReader();
+    let V = 0;
     const t = [];
     for (; ; ) {
-      const { done: n, value: m } = await V.read();
+      const { done: n, value: m } = await Q.read();
       if (n) break;
-      t.push(m), Q += m.length;
-      const b = Q / Z, c = Math.round(b * 100);
+      t.push(m), V += m.length;
+      const W = V / d, c = Math.round(W * 100);
       this._emitProgress(
         "loading-soundfont",
-        `Downloading soundfont: ${c}% (${Math.round(Q / 1024)} KB / ${Math.round(Z / 1024)} KB)`,
-        b
+        `Downloading soundfont: ${c}% (${Math.round(V / 1024)} KB / ${Math.round(d / 1024)} KB)`,
+        W
       );
     }
-    const R = new Uint8Array(Q);
+    const R = new Uint8Array(V);
     let a = 0;
     for (const n of t)
       R.set(n, a), a += n.length;
@@ -1624,7 +1624,7 @@ class rU extends Nl {
         if (console.warn(`AudioWorklet loading failed (attempt ${l}/5):`, U.message), l === 5)
           throw new Error(`AudioWorklet failed after 5 attempts: ${U.message}`);
         const F = l * 500;
-        await new Promise((Z) => setTimeout(Z, F));
+        await new Promise((d) => setTimeout(d, F));
       }
   }
   /**
@@ -1653,15 +1653,15 @@ class rU extends Nl {
    */
   async playMetronomeTick(l, U, F) {
     try {
-      const Z = this.getMetronomeChannel(), V = this._getSynthesizer();
-      if (!Z || !V)
+      const d = this.getMetronomeChannel(), Q = this._getSynthesizer();
+      if (!d || !Q)
         return super.playMetronomeTick(l, U, F);
-      const Q = 15, t = U ? 86 : 60, R = Math.round(Math.min(127, Math.max(0, F * (U ? 127 : 100)))), a = this.audioContext.currentTime, n = Math.max(l, a), m = n - a;
-      V.post ? (V.post({
-        channelNumber: Q,
+      const V = 15, t = U ? 86 : 60, R = Math.round(Math.min(127, Math.max(0, F * (U ? 127 : 100)))), a = this.audioContext.currentTime, n = Math.max(l, a), m = n - a;
+      Q.post ? (Q.post({
+        channelNumber: V,
         type: "midiMessage",
         data: {
-          messageData: [144 | Q, t, R],
+          messageData: [144 | V, t, R],
           channelOffset: 0,
           force: !1,
           options: {
@@ -1669,11 +1669,11 @@ class rU extends Nl {
             // Sample-accurate metronome timing!
           }
         }
-      }), V.post({
-        channelNumber: Q,
+      }), Q.post({
+        channelNumber: V,
         type: "midiMessage",
         data: {
-          messageData: [128 | Q, t, 0],
+          messageData: [128 | V, t, 0],
           channelOffset: 0,
           force: !1,
           options: {
@@ -1681,15 +1681,15 @@ class rU extends Nl {
             // Precise tick duration!
           }
         }
-      })) : m <= 0.01 ? (V.noteOn && V.noteOn(Q, t, R), setTimeout(() => {
-        V.noteOff && V.noteOff(Q, t);
+      })) : m <= 0.01 ? (Q.noteOn && Q.noteOn(V, t, R), setTimeout(() => {
+        Q.noteOff && Q.noteOff(V, t);
       }, 100)) : setTimeout(() => {
-        V.noteOn && V.noteOn(Q, t, R), setTimeout(() => {
-          V.noteOff && V.noteOff(Q, t);
+        Q.noteOn && Q.noteOn(V, t, R), setTimeout(() => {
+          Q.noteOff && Q.noteOff(V, t);
         }, 100);
       }, m * 1e3);
-    } catch (Z) {
-      return console.warn("MIDI metronome failed, falling back to buffers:", Z), super.playMetronomeTick(l, U, F);
+    } catch (d) {
+      return console.warn("MIDI metronome failed, falling back to buffers:", d), super.playMetronomeTick(l, U, F);
     }
   }
   /**
@@ -1768,19 +1768,15 @@ class LU {
    * Parses URL query parameters (track, prog) from legacy format
    * @private
    * @param {Array} legacyParts - Array of part objects with url, name, volume
-   * @returns {Object} Parts object with trackIndex and instrument
+   * @returns {Object} Parts object with channel and instrument
    */
   _convertLegacyParts(l) {
     const U = {};
     for (const F of l) {
       if (!F.name || !F.url)
         continue;
-      const Z = F.name.toLowerCase(), V = this._parseUrlParams(F.url), Q = {};
-      if (V.track !== void 0 && (Q.trackIndex = parseInt(V.track, 10)), V.prog !== void 0) {
-        const t = parseInt(V.prog, 10);
-        t !== 0 && (Q.instrument = t);
-      }
-      Q.trackIndex !== void 0 && (U[Z] = Q);
+      const d = F.name.toLowerCase(), Q = this._parseUrlParams(F.url), V = {};
+      Q.track !== void 0 && (V.channel = parseInt(Q.track, 10)), Q.prog !== void 0 && (V.instrument = parseInt(Q.prog, 10)), V.channel !== void 0 && (U[d] = V);
     }
     return U;
   }
@@ -1794,10 +1790,10 @@ class LU {
     const U = {}, F = l.indexOf("?");
     if (F === -1)
       return U;
-    const Z = l.substring(F + 1).split("&");
-    for (const V of Z) {
-      const [Q, t] = V.split("=");
-      Q && t !== void 0 && (U[Q] = t);
+    const d = l.substring(F + 1).split("&");
+    for (const Q of d) {
+      const [V, t] = Q.split("=");
+      V && t !== void 0 && (U[V] = t);
     }
     return U;
   }
@@ -1809,16 +1805,16 @@ class LU {
     const U = new Uint8Array(l);
     if (!(U[0] === 77 && U[1] === 84 && U[2] === 104 && U[3] === 100))
       throw new Error("Not a valid MIDI file");
-    const F = this._bytesToNumber(U.slice(4, 8)), Z = this._bytesToNumber(U.slice(8, 10)), V = this._bytesToNumber(U.slice(10, 12)), Q = this._bytesToNumber(U.slice(12, 14)), t = Q & 32768 ? null : Q, R = {
-      format: Z,
+    const F = this._bytesToNumber(U.slice(4, 8)), d = this._bytesToNumber(U.slice(8, 10)), Q = this._bytesToNumber(U.slice(10, 12)), V = this._bytesToNumber(U.slice(12, 14)), t = V & 32768 ? null : V, R = {
+      format: d,
       ticksPerBeat: t,
       tracks: [],
       duration: 0
     };
     let a = 8 + F;
-    for (let n = 0; n < V; n++)
+    for (let n = 0; n < Q; n++)
       if (U[a] === 77 && U[a + 1] === 84 && U[a + 2] === 114 && U[a + 3] === 107) {
-        const m = this._bytesToNumber(U.slice(a + 4, a + 8)), b = U.slice(a + 8, a + 8 + m), c = this._parseTrack(b);
+        const m = this._bytesToNumber(U.slice(a + 4, a + 8)), W = U.slice(a + 8, a + 8 + m), c = this._parseTrack(W);
         R.tracks.push(c), a += 8 + m;
       } else
         throw new Error(`Invalid track header at position ${a}`);
@@ -1836,20 +1832,20 @@ class LU {
       events: [],
       duration: 0
     };
-    let F = 0, Z = 0, V = null;
+    let F = 0, d = 0, Q = null;
     for (; F < l.length; ) {
-      let Q = 0, t = 0;
+      let V = 0, t = 0;
       do
-        t = l[F++], Q = Q << 7 | t & 127;
+        t = l[F++], V = V << 7 | t & 127;
       while (t & 128);
-      Z += Q, t = l[F++];
+      d += V, t = l[F++];
       let R = t;
       if (t & 128)
-        V = R;
+        Q = R;
       else {
-        if (V === null)
+        if (Q === null)
           throw new Error("Running status byte encountered before status byte");
-        R = V, F--;
+        R = Q, F--;
       }
       if (R === 255) {
         const a = l[F++], n = this._readVariableLengthValue(l, F);
@@ -1863,21 +1859,21 @@ class LU {
             U.events.push({
               type: "text",
               text: this._bytesToString(m),
-              tick: Z
+              tick: d
             });
             break;
           case 5:
             U.lyrics.push({
               text: this._bytesToString(m),
-              tick: Z
+              tick: d
             });
             break;
           case 81:
-            const b = this._bytesToNumber(m), c = Math.round(6e7 / b);
+            const W = this._bytesToNumber(m), c = Math.round(6e7 / W);
             U.events.push({
               type: "tempo",
               bpm: c,
-              tick: Z
+              tick: d
             });
             break;
           case 88:
@@ -1885,11 +1881,11 @@ class LU {
               type: "timeSignature",
               numerator: m[0],
               denominator: Math.pow(2, m[1]),
-              tick: Z
+              tick: d
             });
             break;
           case 47:
-            U.duration = Z;
+            U.duration = d;
             break;
         }
       } else if ((R & 240) === 144) {
@@ -1898,12 +1894,12 @@ class LU {
           type: "noteOn",
           noteNumber: n,
           velocity: m,
-          tick: Z,
+          tick: d,
           channel: a
         }) : U.notes.push({
           type: "noteOff",
           noteNumber: n,
-          tick: Z,
+          tick: d,
           channel: a
         });
       } else if ((R & 240) === 128) {
@@ -1911,7 +1907,7 @@ class LU {
         l[F++], U.notes.push({
           type: "noteOff",
           noteNumber: n,
-          tick: Z,
+          tick: d,
           channel: a
         });
       } else if (R === 240 || R === 247) {
@@ -1924,7 +1920,7 @@ class LU {
           controllerNumber: n,
           value: m,
           channel: a,
-          tick: Z
+          tick: d
         });
       } else if ((R & 240) === 192) {
         const a = R & 15, n = l[F++];
@@ -1932,7 +1928,7 @@ class LU {
           type: "programChange",
           programNumber: n,
           channel: a,
-          tick: Z
+          tick: d
         });
       } else if ((R & 240) === 208) {
         const a = R & 15, n = l[F++];
@@ -1940,7 +1936,7 @@ class LU {
           type: "channelAftertouch",
           pressure: n,
           channel: a,
-          tick: Z
+          tick: d
         });
       } else if ((R & 240) === 224) {
         const a = R & 15, n = l[F++], m = (l[F++] << 7 | n) - 8192;
@@ -1948,7 +1944,7 @@ class LU {
           type: "pitchBend",
           value: m,
           channel: a,
-          tick: Z
+          tick: d
         });
       } else if ((R & 240) === 160) {
         const a = R & 15, n = l[F++], m = l[F++];
@@ -1957,7 +1953,7 @@ class LU {
           noteNumber: n,
           pressure: m,
           channel: a,
-          tick: Z
+          tick: d
         });
       } else
         console.warn(`Unknown event type: ${R.toString(16)} at position ${F - 1}`), F++;
@@ -1976,16 +1972,16 @@ class LU {
       format: l.format,
       ticksPerBeat: l.ticksPerBeat
     };
-    l.tracks.forEach((F, Z) => {
-      if (F.name && !U.title && (U.title = F.name), F.events.filter((V) => V.type === "text").forEach((V) => {
-        const Q = V.text.toLowerCase();
-        (Q.includes("compos") || Q.includes("by")) && !U.composer && (U.composer = V.text);
+    l.tracks.forEach((F, d) => {
+      if (F.name && !U.title && (U.title = F.name), F.events.filter((Q) => Q.type === "text").forEach((Q) => {
+        const V = Q.text.toLowerCase();
+        (V.includes("compos") || V.includes("by")) && !U.composer && (U.composer = Q.text);
       }), F.name) {
-        const V = F.name.toLowerCase();
-        for (const Q of this.partNames)
-          if (V.includes(Q)) {
+        const Q = F.name.toLowerCase();
+        for (const V of this.partNames)
+          if (Q.includes(V)) {
             U.partNames.push({
-              index: Z,
+              index: d,
               name: F.name
             });
             break;
@@ -2007,30 +2003,30 @@ class LU {
         (m.type === "timeSignature" || m.type === "tempo") && F.push(m);
       });
     }), F.sort((n, m) => n.tick - m.tick);
-    let Z = 0;
+    let d = 0;
     l.tracks.forEach((n) => {
       n.notes && n.notes.forEach((m) => {
-        m.type === "noteOff" && m.tick > Z && (Z = m.tick);
+        m.type === "noteOff" && m.tick > d && (d = m.tick);
       });
-    }), Z === 0 && (Z = U * 8);
-    const V = [], Q = F.filter((n) => n.type === "timeSignature").sort((n, m) => n.tick - m.tick);
+    }), d === 0 && (d = U * 8);
+    const Q = [], V = F.filter((n) => n.type === "timeSignature").sort((n, m) => n.tick - m.tick);
     let t = { numerator: 4, denominator: 4 }, R = 0, a = 0;
-    for (; R < Z; ) {
-      for (; a < Q.length && Q[a].tick <= R; )
-        t = Q[a], a++;
+    for (; R < d; ) {
+      for (; a < V.length && V[a].tick <= R; )
+        t = V[a], a++;
       let n;
       n = R + U * 4 * t.numerator / t.denominator;
-      const m = t.numerator, b = [], c = U * (4 / t.denominator);
+      const m = t.numerator, W = [], c = U * (4 / t.denominator);
       for (let s = 0; s < m; s++) {
         const N = R + s * c, J = this._ticksToTime(N, l);
-        b.push(J);
+        W.push(J);
       }
-      V.push({
+      Q.push({
         sig: [t.numerator, t.denominator],
-        beats: b
+        beats: W
       }), R = n;
     }
-    this.parsedData.barStructure = V;
+    this.parsedData.barStructure = Q;
   }
   /**
    * Extract notes for each voice part
@@ -2039,87 +2035,172 @@ class LU {
   _extractParts(l) {
     const U = {}, F = l.ticksPerBeat;
     if (this.metadataOverrides.parts)
-      for (const [Z, V] of Object.entries(this.metadataOverrides.parts)) {
-        if (!V.trackIndex && V.trackIndex !== 0 && !V.trackName)
-          continue;
-        let Q = null, t = null;
-        if (V.trackIndex !== void 0 && V.trackIndex !== null)
-          t = V.trackIndex, t >= 0 && t < l.tracks.length && (Q = l.tracks[t]);
-        else if (V.trackName) {
-          const a = l.tracks.findIndex((n) => n.name === V.trackName);
-          a !== -1 && (Q = l.tracks[a], t = a);
+      for (const [d, Q] of Object.entries(this.metadataOverrides.parts)) {
+        if (Q.channel !== void 0 && Q.channel !== null) {
+          if (Q.channel === 15) {
+            console.error(`Part "${d}" uses channel 15 which is reserved for metronome. Skipping.`);
+            continue;
+          }
+          if (Q.channel === 9 && console.warn(`Part "${d}" uses channel 9 (drums/percussion). This may not be appropriate for vocal parts.`), Q.channel < 0 || Q.channel > 15) {
+            console.error(`Part "${d}" has invalid channel ${Q.channel}. MIDI channels must be 0-15. Skipping.`);
+            continue;
+          }
         }
-        if (!Q)
+        if (Q.channel === void 0 && !Q.trackIndex && Q.trackIndex !== 0 && !Q.trackName)
           continue;
-        const R = this._extractPartDataFromTrack(Q, t, l, F);
-        V.instrument !== void 0 && V.instrument !== null && (R.defaultInstrument = this._resolveInstrument(V.instrument)), U[Z] = R;
+        let V;
+        if (Q.channel !== void 0 && Q.channel !== null) {
+          if (V = this._extractPartDataByChannel(Q.channel, l, F), !V || V.notes.length === 0) {
+            console.warn(`Part "${d}" specified channel ${Q.channel} but no notes found on that channel. Skipping.`);
+            continue;
+          }
+        } else if (Q.trackIndex !== void 0 && Q.trackIndex !== null) {
+          const t = Q.trackIndex;
+          if (t >= 0 && t < l.tracks.length) {
+            const R = l.tracks[t];
+            V = this._extractPartDataFromTrack(R, t, l, F);
+          } else {
+            console.warn(`Part "${d}" specified trackIndex ${t} but track not found. Skipping.`);
+            continue;
+          }
+        } else if (Q.trackName) {
+          const t = l.tracks.findIndex((R) => R.name === Q.trackName);
+          if (t !== -1) {
+            const R = l.tracks[t];
+            V = this._extractPartDataFromTrack(R, t, l, F);
+          } else {
+            console.warn(`Part "${d}" specified trackName "${Q.trackName}" but track not found. Skipping.`);
+            continue;
+          }
+        }
+        V && (Q.instrument !== void 0 && Q.instrument !== null && (V.defaultInstrument = this._resolveInstrument(Q.instrument), V.programChanges = []), U[d] = V);
       }
     else
-      l.tracks.forEach((Z, V) => {
-        if (!Z.notes.length) return;
-        let Q = null;
-        if (Z.name) {
-          const a = Z.name.toLowerCase();
+      l.tracks.forEach((d, Q) => {
+        if (!d.notes.length) return;
+        let V = null;
+        if (d.name) {
+          const a = d.name.toLowerCase();
           for (const n of this.partNames)
             if (n.length === 1) {
               if (a === n) {
-                Q = n;
+                V = n;
                 break;
               }
             } else if (a.includes(n)) {
-              Q = n;
+              V = n;
               break;
             }
         }
-        Q || (Q = Z.name || `Track ${V + 1}`), Q === "s" && (Q = "soprano"), Q === "a" && (Q = "alto"), Q === "t" && (Q = "tenor"), Q === "b" && (Q = "bass");
-        let t = Q, R = 2;
+        V || (V = d.name || `Track ${Q + 1}`), V === "s" && (V = "soprano"), V === "a" && (V = "alto"), V === "t" && (V = "tenor"), V === "b" && (V = "bass");
+        let t = V, R = 2;
         for (; U[t]; )
-          t = `${Q} ${R}`, R++;
-        Q = t, U[Q] = this._extractPartDataFromTrack(Z, V, l, F);
+          t = `${V} ${R}`, R++;
+        V = t, U[V] = this._extractPartDataFromTrack(d, Q, l, F);
       });
     this.parsedData.parts = U;
   }
+  /**
+   * Extract part data by MIDI channel (merges notes from all tracks using this channel)
+   * @private
+   */
+  _extractPartDataByChannel(l, U, F) {
+    const d = [], Q = [], V = [], t = [];
+    U.tracks.forEach((a, n) => {
+      const m = {};
+      a.notes.forEach((W) => {
+        if (W.channel === l) {
+          if (W.type === "noteOn")
+            m[W.noteNumber] = {
+              tick: W.tick,
+              velocity: W.velocity
+            };
+          else if (W.type === "noteOff" && m[W.noteNumber]) {
+            const c = m[W.noteNumber], s = W.tick - c.tick;
+            d.push({
+              pitch: W.noteNumber,
+              name: this._midiNoteToName(W.noteNumber),
+              startTick: c.tick,
+              endTick: W.tick,
+              duration: s,
+              startTime: this._ticksToTime(c.tick, U),
+              endTime: this._ticksToTime(W.tick, U),
+              velocity: c.velocity,
+              channel: l,
+              sourceTrackIndex: n
+            }), delete m[W.noteNumber];
+          }
+        }
+      }), a.lyrics.forEach((W) => {
+        Q.push({
+          text: W.text,
+          tick: W.tick,
+          time: W.tick / F
+        });
+      }), a.events.filter((W) => W.type === "programChange" && W.channel === l).forEach((W) => {
+        V.push({
+          programNumber: W.programNumber,
+          tick: W.tick,
+          time: this._ticksToTime(W.tick, U),
+          sourceTrackIndex: n
+        });
+      }), a.notes.some((W) => W.channel === l) && t.push(n);
+    }), d.sort((a, n) => a.startTick - n.startTick), Q.sort((a, n) => a.tick - n.tick), V.sort((a, n) => a.tick - n.tick);
+    const R = V.length > 0 ? V[0].programNumber : 0;
+    return {
+      notes: d,
+      lyrics: Q,
+      channel: l,
+      trackIndices: t,
+      // All track indices that contributed
+      programChanges: V,
+      defaultInstrument: R
+    };
+  }
   /**
    * Extract part data from a MIDI track
    * @private
    */
-  _extractPartDataFromTrack(l, U, F, Z) {
-    const V = [], Q = {};
+  _extractPartDataFromTrack(l, U, F, d) {
+    const Q = [], V = {};
     l.notes.forEach((n) => {
       if (n.type === "noteOn")
-        Q[n.noteNumber] = {
+        V[n.noteNumber] = {
           tick: n.tick,
-          velocity: n.velocity
+          velocity: n.velocity,
+          channel: n.channel
         };
-      else if (n.type === "noteOff" && Q[n.noteNumber]) {
-        const m = Q[n.noteNumber], b = n.tick - m.tick;
-        V.push({
+      else if (n.type === "noteOff" && V[n.noteNumber]) {
+        const m = V[n.noteNumber], W = n.tick - m.tick;
+        Q.push({
           pitch: n.noteNumber,
           name: this._midiNoteToName(n.noteNumber),
           startTick: m.tick,
           endTick: n.tick,
-          duration: b,
+          duration: W,
           // Convert ticks to actual time considering tempo changes
           startTime: this._ticksToTime(m.tick, F),
           endTime: this._ticksToTime(n.tick, F),
-          velocity: m.velocity
-        }), delete Q[n.noteNumber];
+          velocity: m.velocity,
+          channel: m.channel,
+          sourceTrackIndex: U
+        }), delete V[n.noteNumber];
       }
     });
     const t = l.lyrics.map((n) => ({
       text: n.text,
       tick: n.tick,
-      time: n.tick / Z
+      time: n.tick / d
       // Time in quarter notes
     }));
-    V.sort((n, m) => n.startTick - m.startTick);
+    Q.sort((n, m) => n.startTick - m.startTick);
     const R = l.events.filter((n) => n.type === "programChange").map((n) => ({
       programNumber: n.programNumber,
       tick: n.tick,
       time: this._ticksToTime(n.tick, F)
     })).sort((n, m) => n.tick - m.tick), a = R.length > 0 ? R[0].programNumber : 0;
     return {
-      notes: V,
+      notes: Q,
       lyrics: t,
       trackIndex: U,
       programChanges: R,
@@ -2181,37 +2262,37 @@ class LU {
    * @private
    */
   _readVariableLengthValue(l, U) {
-    let F = 0, Z, V = 0;
+    let F = 0, d, Q = 0;
     do
-      Z = l[U + V++], F = F << 7 | Z & 127;
-    while (Z & 128);
-    return { value: F, bytesRead: V };
+      d = l[U + Q++], F = F << 7 | d & 127;
+    while (d & 128);
+    return { value: F, bytesRead: Q };
   }
   /**
    * Convert ticks to time in seconds considering tempo changes within bars
    * @private
    */
   _ticksToTime(l, U) {
-    const F = U.ticksPerBeat || 480, Z = [];
+    const F = U.ticksPerBeat || 480, d = [];
     U.tracks.forEach((R) => {
       R.events.forEach((a) => {
-        a.type === "tempo" && Z.push(a);
+        a.type === "tempo" && d.push(a);
       });
-    }), Z.sort((R, a) => R.tick - a.tick);
-    let V = 0, Q = 0, t = 120;
-    for (const R of Z) {
+    }), d.sort((R, a) => R.tick - a.tick);
+    let Q = 0, V = 0, t = 120;
+    for (const R of d) {
       if (R.tick > l) break;
-      if (R.tick > Q) {
-        const a = (R.tick - Q) / F * (60 / t);
-        V += a, Q = R.tick;
+      if (R.tick > V) {
+        const a = (R.tick - V) / F * (60 / t);
+        Q += a, V = R.tick;
       }
       t = R.bpm;
     }
-    if (l > Q) {
-      const R = (l - Q) / F * (60 / t);
-      V += R;
+    if (l > V) {
+      const R = (l - V) / F * (60 / t);
+      Q += R;
     }
-    return V;
+    return Q;
   }
 }
 class CU {
@@ -2238,19 +2319,19 @@ class CU {
    * @returns {Array} Bar order with bar numbers and repeat counts
    */
   generateBarOrder(l, U) {
-    const F = [], Z = {};
-    for (const V of U) {
-      const Q = l[V.section];
-      if (!Q)
-        throw new Error(`Invalid section index: ${V.section}`);
-      const t = V.section;
-      Z[t] || (Z[t] = 0), Z[t]++;
-      const R = Z[t], a = V.from !== void 0 ? V.from : this._getSectionStartBar(l, V.section), n = V.to !== void 0 ? V.to : Q.to, m = V.as || 1;
-      for (let b = a; b <= n; b++)
-        this._shouldPlayBar(Q, b, m) && F.push({
-          barNumber: b,
+    const F = [], d = {};
+    for (const Q of U) {
+      const V = l[Q.section];
+      if (!V)
+        throw new Error(`Invalid section index: ${Q.section}`);
+      const t = Q.section;
+      d[t] || (d[t] = 0), d[t]++;
+      const R = d[t], a = Q.from !== void 0 ? Q.from : this._getSectionStartBar(l, Q.section), n = Q.to !== void 0 ? Q.to : V.to, m = Q.as || 1;
+      for (let W = a; W <= n; W++)
+        this._shouldPlayBar(V, W, m) && F.push({
+          barNumber: W,
           repeat: R,
-          sectionIndex: V.section,
+          sectionIndex: Q.section,
           voltaTime: m
         });
     }
@@ -2264,25 +2345,25 @@ class CU {
    */
   generateBarOrderFromLegacyBars(l, U) {
     const F = [];
-    let Z = 1, V = 0, Q;
+    let d = 1, Q = 0, V;
     for (const t of l) {
-      t.from !== void 0 && (Z = t.from === -1 ? 0 : t.from, V = 0), t.timeSig !== void 0 && (Q = t.timeSig);
+      t.from !== void 0 && (d = t.from === -1 ? 0 : t.from, Q = 0), t.timeSig !== void 0 && (V = t.timeSig);
       const R = t.repeat || 1;
       let a = t.beats;
       for (; a > 0; ) {
-        const n = (Q !== void 0 ? Q : this._getBeatsPerBar(Z, U)) - V;
+        const n = (V !== void 0 ? V : this._getBeatsPerBar(d, U)) - Q;
         a >= n ? (F.push({
-          barNumber: Z,
+          barNumber: d,
           repeat: R,
           sectionIndex: 0,
           // Legacy format doesn't have sections
           voltaTime: 1
           // Legacy format doesn't have voltas
-        }), a -= n, V = 0, Z === 0 ? Z = 1 : Z++) : (V += a, a = 0);
+        }), a -= n, Q = 0, d === 0 ? d = 1 : d++) : (Q += a, a = 0);
       }
     }
-    return V > 0 && F.push({
-      barNumber: Z,
+    return Q > 0 && F.push({
+      barNumber: d,
       repeat: 1,
       sectionIndex: 0,
       voltaTime: 1
@@ -2312,11 +2393,11 @@ class CU {
    */
   _getBeatsPerBar(l, U) {
     const F = U.length > 0 && U[0].sig && U[0].sig[0] <= 2;
-    let Z;
-    if (F ? Z = l : Z = l - 1, Z < 0 || Z >= U.length)
+    let d;
+    if (F ? d = l : d = l - 1, d < 0 || d >= U.length)
       return 4;
-    const V = U[Z];
-    return V.sig ? V.sig[0] : 4;
+    const Q = U[d];
+    return Q.sig ? Q.sig[0] : 4;
   }
   /**
    * Generate beat table from bar order and MIDI bar structure
@@ -2326,21 +2407,21 @@ class CU {
    * @returns {Array} Beat table with time, repeat, bar, and beat information
    */
   generateBeatTable(l, U) {
-    const F = [], Z = {};
-    let V = 0, Q = 0;
+    const F = [], d = {};
+    let Q = 0, V = 0;
     const t = [...U];
-    for (; Q < l.length && V < t.length; ) {
-      const R = l[Q], a = R.barNumber;
-      if (Z[a] === void 0) {
-        const c = t[V];
+    for (; V < l.length && Q < t.length; ) {
+      const R = l[V], a = R.barNumber;
+      if (d[a] === void 0) {
+        const c = t[Q];
         if (!c || !c.sig)
-          throw new Error(`Invalid MIDI bar structure at index ${V}`);
-        Z[a] = c.sig[0];
+          throw new Error(`Invalid MIDI bar structure at index ${Q}`);
+        d[a] = c.sig[0];
       }
-      const n = Z[a];
-      let m = t[V], b = m.sig[0];
-      for (; b < n && V + 1 < t.length; ) {
-        const c = t[V + 1], s = [
+      const n = d[a];
+      let m = t[Q], W = m.sig[0];
+      for (; W < n && Q + 1 < t.length; ) {
+        const c = t[Q + 1], s = [
           m.sig[0] + c.sig[0],
           // Total beats
           m.sig[1]
@@ -2352,31 +2433,31 @@ class CU {
         m = {
           sig: s,
           beats: N
-        }, t[V] = m, t.splice(V + 1, 1), b = s[0];
+        }, t[Q] = m, t.splice(Q + 1, 1), W = s[0];
       }
-      if (b > n) {
-        const c = n, s = b - n, N = m.beats ? m.beats.slice(0, c) : [], J = m.beats ? m.beats.slice(c) : [], p = {
+      if (W > n) {
+        const c = n, s = W - n, N = m.beats ? m.beats.slice(0, c) : [], J = m.beats ? m.beats.slice(c) : [], p = {
           sig: [c, m.sig[1]],
           beats: N
         }, M = {
           sig: [s, m.sig[1]],
           beats: J
         };
-        t[V] = p, t.splice(V + 1, 0, M), m = p;
+        t[Q] = p, t.splice(Q + 1, 0, M), m = p;
       }
-      this._generateBeatsForBar(F, R, m, n), V++, Q++;
+      this._generateBeatsForBar(F, R, m, n), Q++, V++;
     }
-    if (Q < l.length) {
+    if (V < l.length) {
       const R = F.length > 0 ? F[F.length - 1] : null;
       let a = 0.5;
       if (F.length >= 2) {
-        const m = Math.min(8, F.length), b = F[F.length - m];
-        a = (F[F.length - 1].time - b.time) / (m - 1);
+        const m = Math.min(8, F.length), W = F[F.length - m];
+        a = (F[F.length - 1].time - W.time) / (m - 1);
       }
       let n = R ? R.time + a : 0;
-      for (; Q < l.length; ) {
-        const m = l[Q], b = m.barNumber, c = Z[b] !== void 0 ? Z[b] : 4;
-        Z[b] === void 0 && (Z[b] = c);
+      for (; V < l.length; ) {
+        const m = l[V], W = m.barNumber, c = d[W] !== void 0 ? d[W] : 4;
+        d[W] === void 0 && (d[W] = c);
         const s = [];
         for (let J = 0; J < c; J++)
           s.push(n), n += a;
@@ -2385,7 +2466,7 @@ class CU {
           // Default to quarter notes
           beats: s
         };
-        this._generateBeatsForBar(F, m, N, c), Q++;
+        this._generateBeatsForBar(F, m, N, c), V++;
       }
     }
     return F;
@@ -2394,18 +2475,18 @@ class CU {
    * Generate beat entries for a single bar
    * @private
    */
-  _generateBeatsForBar(l, U, F, Z) {
-    const { beats: V } = F;
-    if (!V || !Array.isArray(V))
+  _generateBeatsForBar(l, U, F, d) {
+    const { beats: Q } = F;
+    if (!Q || !Array.isArray(Q))
       throw new Error(`Invalid MIDI bar: missing beats array. Got: ${JSON.stringify(F)}`);
-    const Q = V.slice(0, Z);
-    for (let t = 1; t <= Z; t++) {
+    const V = Q.slice(0, d);
+    for (let t = 1; t <= d; t++) {
       const R = {
-        time: Q[t - 1],
+        time: V[t - 1],
         repeat: U.repeat,
         bar: U.barNumber,
         beat: t,
-        timeSig: Z
+        timeSig: d
       };
       l.push(R);
     }
@@ -2424,8 +2505,8 @@ class CU {
   _shouldPlayBar(l, U, F) {
     if (!l.voltas)
       return !0;
-    const Z = l.voltas.indexOf(U);
-    return Z === -1 ? !0 : Z + 1 === F;
+    const d = l.voltas.indexOf(U);
+    return d === -1 ? !0 : d + 1 === F;
   }
 }
 class Jl {
@@ -2436,12 +2517,12 @@ class Jl {
    * @param {Object} instrumentMap - Mapping of part names to instrument configurations
    * @param {Object} [structureMetadata] - Optional score structure for beat mapping
    */
-  constructor(l = null, U, F = null, Z = null) {
+  constructor(l = null, U, F = null, d = null) {
     if (!U)
       throw new Error("Parsed MIDI data is required");
-    this.audioEngine = l, this._audioEngineReady = !!(l && l.isInitialized), this.instrumentMap = F || {}, this.parsedData = U, this._isPlaying = !1, this._currentTime = 0, this._totalDuration = 0, this.playbackSpeed = 1, this.partChannels = /* @__PURE__ */ new Map(), this.partOutputs = /* @__PURE__ */ new Map(), this.playbackStartTime = 0, this.lookAheadTime = 0.05, this.scheduleInterval = null, this.partNotePointers = /* @__PURE__ */ new Map(), this.partProgramPointers = /* @__PURE__ */ new Map(), this.eventBus = Xl(), this.beatMapper = new CU(), this.beats = [], this.structureMetadata = Z, this._calculateTotalDuration();
-    const V = Z || this._createDefaultStructureMetadata();
-    this.beats = this.beatMapper.mapBeats(U, V), this._audioEngineReady && (this._setupPartChannels(), this._resetNotePointers(), this._resetProgramPointers());
+    this.audioEngine = l, this._audioEngineReady = !!(l && l.isInitialized), this.instrumentMap = F || {}, this.parsedData = U, this._isPlaying = !1, this._currentTime = 0, this._totalDuration = 0, this.playbackSpeed = 1, this.partChannels = /* @__PURE__ */ new Map(), this.partOutputs = /* @__PURE__ */ new Map(), this.playbackStartTime = 0, this.lookAheadTime = 0.05, this.scheduleInterval = null, this.partNotePointers = /* @__PURE__ */ new Map(), this.partProgramPointers = /* @__PURE__ */ new Map(), this.eventBus = Xl(), this.beatMapper = new CU(), this.beats = [], this.structureMetadata = d, this._calculateTotalDuration();
+    const Q = d || this._createDefaultStructureMetadata();
+    this.beats = this.beatMapper.mapBeats(U, Q), this._audioEngineReady && (this._setupPartChannels(), this._resetNotePointers(), this._resetProgramPointers());
   }
   // ========================================
   // PUBLIC API - Initialization Methods
@@ -2514,8 +2595,8 @@ class Jl {
       throw new Error("Playback speed must be greater than 0");
     const F = U && this._isPlaying;
     F && this.pause();
-    const Z = (this.audioEngine.audioContext.currentTime - this.playbackStartTime) * this.playbackSpeed;
-    this.playbackSpeed = l, F ? this.play() : this.playbackStartTime = this.audioEngine.audioContext.currentTime - Z / this.playbackSpeed;
+    const d = (this.audioEngine.audioContext.currentTime - this.playbackStartTime) * this.playbackSpeed;
+    this.playbackSpeed = l, F ? this.play() : this.playbackStartTime = this.audioEngine.audioContext.currentTime - d / this.playbackSpeed;
   }
   /**
    * Navigate to a specific bar position
@@ -2535,7 +2616,7 @@ class Jl {
   getTimeFromBar(l, U = 0) {
     U || (U = 1);
     const F = this.beats.find(
-      (Z) => Z.bar === l && Z.beat === 1 && Z.repeat === U
+      (d) => d.bar === l && d.beat === 1 && d.repeat === U
     );
     return F ? F.time : null;
   }
@@ -2625,11 +2706,11 @@ class Jl {
    */
   getAllNextNotes(l) {
     const U = l ?? this.getCurrentTime(), F = {};
-    for (const [Z, V] of Object.entries(this.parsedData.parts)) {
-      const Q = V.notes.find((t) => t.startTime >= U);
-      F[Z] = Q ? {
-        pitch: Q.pitch,
-        startTime: Q.startTime
+    for (const [d, Q] of Object.entries(this.parsedData.parts)) {
+      const V = Q.notes.find((t) => t.startTime >= U);
+      F[d] = V ? {
+        pitch: V.pitch,
+        startTime: V.startTime
       } : null;
     }
     return F;
@@ -2668,19 +2749,19 @@ class Jl {
    */
   _setupPartChannels() {
     Object.keys(this.parsedData.parts).forEach((l) => {
-      const U = this.parsedData.parts[l], F = this.instrumentMap[l] || {}, Z = F.instrument !== void 0 ? F.instrument : U.defaultInstrument !== void 0 ? U.defaultInstrument : 0;
+      const U = this.parsedData.parts[l], F = this.instrumentMap[l] || {}, d = F.instrument !== void 0 ? F.instrument : U.defaultInstrument !== void 0 ? U.defaultInstrument : 0;
       try {
-        const V = this.audioEngine.createChannel(l, {
-          instrument: Z,
+        const Q = this.audioEngine.createChannel(l, {
+          instrument: d,
           initialVolume: F.volume || 1
         });
-        this.partChannels.set(l, V);
-        const Q = this.audioEngine.audioContext.createGain();
-        Q.gain.value = 1;
-        const t = V.getOutputNode();
-        t && t.connect(Q), this.partOutputs.set(l, Q);
-      } catch (V) {
-        console.error(`Failed to create channel for part '${l}':`, V), this._emitEvent("error", V);
+        this.partChannels.set(l, Q);
+        const V = this.audioEngine.audioContext.createGain();
+        V.gain.value = 1;
+        const t = Q.getOutputNode();
+        t && t.connect(V), this.partOutputs.set(l, V);
+      } catch (Q) {
+        console.error(`Failed to create channel for part '${l}':`, Q), this._emitEvent("error", Q);
       }
     });
   }
@@ -2711,34 +2792,34 @@ class Jl {
     this.scheduleInterval || (this.scheduleInterval = setInterval(() => {
       if (!this._isPlaying) return;
       const l = (this.audioEngine.audioContext.currentTime - this.playbackStartTime) * this.playbackSpeed, U = l + this.lookAheadTime;
-      for (const [F, Z] of this.partChannels) {
-        const V = this.parsedData.parts[F];
-        if (V) {
-          if (V.programChanges && V.programChanges.length > 0) {
-            let Q = this.partProgramPointers.get(F) || 0;
-            const t = V.programChanges;
-            for (; Q < t.length && t[Q].time < l; )
-              Q++;
-            for (; Q < t.length && t[Q].time <= U; ) {
-              const R = t[Q];
-              Z.setInstrument(R.programNumber), Q++;
+      for (const [F, d] of this.partChannels) {
+        const Q = this.parsedData.parts[F];
+        if (Q) {
+          if (Q.programChanges && Q.programChanges.length > 0) {
+            let V = this.partProgramPointers.get(F) || 0;
+            const t = Q.programChanges;
+            for (; V < t.length && t[V].time < l; )
+              V++;
+            for (; V < t.length && t[V].time <= U; ) {
+              const R = t[V];
+              d.setInstrument(R.programNumber), V++;
             }
-            this.partProgramPointers.set(F, Q);
+            this.partProgramPointers.set(F, V);
           }
-          if (V.notes) {
-            let Q = this.partNotePointers.get(F) || 0;
-            const t = V.notes;
-            for (; Q < t.length && t[Q].endTime < l; )
-              Q++;
-            for (; Q < t.length && t[Q].startTime <= U; ) {
-              const R = t[Q];
+          if (Q.notes) {
+            let V = this.partNotePointers.get(F) || 0;
+            const t = Q.notes;
+            for (; V < t.length && t[V].endTime < l; )
+              V++;
+            for (; V < t.length && t[V].startTime <= U; ) {
+              const R = t[V];
               if (R.endTime - R.startTime >= 0.01) {
                 const a = this.playbackStartTime + R.startTime / this.playbackSpeed, n = (R.endTime - R.startTime) / this.playbackSpeed;
-                Z.playNote(a, R.pitch, R.velocity, n);
+                d.playNote(a, R.pitch, R.velocity, n);
               }
-              Q++;
+              V++;
             }
-            this.partNotePointers.set(F, Q);
+            this.partNotePointers.set(F, V);
           }
         }
       }
@@ -2753,10 +2834,10 @@ class Jl {
     for (const [U] of this.partChannels) {
       const F = this.parsedData.parts[U];
       if (!F || !F.notes) continue;
-      let Z = 0;
-      for (; Z < F.notes.length && F.notes[Z].endTime < l; )
-        Z++;
-      this.partNotePointers.set(U, Z);
+      let d = 0;
+      for (; d < F.notes.length && F.notes[d].endTime < l; )
+        d++;
+      this.partNotePointers.set(U, d);
     }
   }
   /**
@@ -2766,15 +2847,15 @@ class Jl {
   _resetProgramPointers() {
     const l = this._currentTime;
     for (const [U, F] of this.partChannels) {
-      const Z = this.parsedData.parts[U];
-      if (!Z || !Z.programChanges) {
+      const d = this.parsedData.parts[U];
+      if (!d || !d.programChanges) {
         this.partProgramPointers.set(U, 0);
         continue;
       }
-      let V = 0, Q = Z.defaultInstrument;
-      for (; V < Z.programChanges.length && Z.programChanges[V].time <= l; )
-        Q = Z.programChanges[V].programNumber, V++;
-      F.setInstrument(Q), this.partProgramPointers.set(U, V);
+      let Q = 0, V = d.defaultInstrument;
+      for (; Q < d.programChanges.length && d.programChanges[Q].time <= l; )
+        V = d.programChanges[Q].programNumber, Q++;
+      F.setInstrument(V), this.partProgramPointers.set(U, Q);
     }
   }
   /**
@@ -2815,8 +2896,8 @@ class Jl {
     (this.eventBus.all.get(l) || []).forEach((F) => {
       try {
         F(U);
-      } catch (Z) {
-        console.error(`Error in ${l} event listener:`, Z);
+      } catch (d) {
+        console.error(`Error in ${l} event listener:`, d);
       }
     });
   }
@@ -3225,15 +3306,15 @@ class xU {
       throw new Error("Audio engine not ready. Call setAudioEngine() first.");
     if (this.isCalibrating)
       throw new Error("Calibration already in progress");
-    const U = l.measurements || 5, F = l.sampleIntervalMs || 10, Z = l.threshold || 0.01, V = l.timeout || 3e3, Q = l.silent !== void 0 ? l.silent : !0, t = l.updateBaseline !== void 0 ? l.updateBaseline : !0;
+    const U = l.measurements || 5, F = l.sampleIntervalMs || 10, d = l.threshold || 0.01, Q = l.timeout || 3e3, V = l.silent !== void 0 ? l.silent : !0, t = l.updateBaseline !== void 0 ? l.updateBaseline : !0;
     this.isCalibrating = !0;
     try {
-      Q && await this._setupSilentCalibration();
+      V && await this._setupSilentCalibration();
       const R = await this._performLatencyMeasurement(
         U,
         F,
-        Z,
-        V
+        d,
+        Q
       );
       this.measuredLatencyMs = R, t && await this._updateBaselineLatency(R);
       const a = this.hasLatencyDrift();
@@ -3249,7 +3330,7 @@ class xU {
         driftMs: R - this.baselineLatencyMs
       })), R;
     } finally {
-      Q && this._teardownSilentCalibration(), this.isCalibrating = !1;
+      V && this._teardownSilentCalibration(), this.isCalibrating = !1;
     }
   }
   /**
@@ -3342,19 +3423,19 @@ class xU {
   previewNextNotes(l = {}) {
     if (!this.midiPlayer)
       throw new Error("No MIDI data loaded");
-    const U = l.delayBetweenParts ?? 0.3, F = l.duration ?? 0.5, Z = l.velocity ?? 100, V = this.midiPlayer.getAllNextNotes(), Q = l.partOrder ?? this.getPartNames();
+    const U = l.delayBetweenParts ?? 0.3, F = l.duration ?? 0.5, d = l.velocity ?? 100, Q = this.midiPlayer.getAllNextNotes(), V = l.partOrder ?? this.getPartNames();
     let t = this.audioEngine.audioContext.currentTime + 0.01;
     const R = [];
-    for (const a of Q) {
-      const n = V[a];
+    for (const a of V) {
+      const n = Q[a];
       if (!n) continue;
       const m = this.midiPlayer.getPartChannel(a);
       if (!m) continue;
-      const b = this.midiPlayer.getPartOutput(a);
-      b && b.gain.value === 0 || (m.playPreviewNote(n.pitch, {
+      const W = this.midiPlayer.getPartOutput(a);
+      W && W.gain.value === 0 || (m.playPreviewNote(n.pitch, {
         startTime: t,
         duration: F,
-        velocity: Z,
+        velocity: d,
         instrument: l.instrument
       }), R.push({
         partName: a,
@@ -3483,17 +3564,17 @@ class xU {
         startBeat: { bar: 1, beat: 1, timeSig: 4 }
       };
     const l = this.midiPlayer.beats, U = this.frozenTime, F = this.leadInConfig.bars;
-    let Z = l.length - 1, V = 0.5;
-    for (; l[Z].time > U; ) Z--;
-    const Q = l[Z], t = l[Z + 1];
-    t ? V = t.time - Q.time : Z > 0 && (V = Q.time - l[Z - 1].time);
-    const R = this.midiPlayer && this.midiPlayer.playbackSpeed || 1, a = V / R, n = Q.timeSig === 1, m = n && t ? t.timeSig : Q.timeSig, b = n ? m - 1 : Q.beat > 1 ? Q.beat - 1 : 0, c = F * m + b;
+    let d = l.length - 1, Q = 0.5;
+    for (; l[d].time > U; ) d--;
+    const V = l[d], t = l[d + 1];
+    t ? Q = t.time - V.time : d > 0 && (Q = V.time - l[d - 1].time);
+    const R = this.midiPlayer && this.midiPlayer.playbackSpeed || 1, a = Q / R, n = V.timeSig === 1, m = n && t ? t.timeSig : V.timeSig, W = n ? m - 1 : V.beat > 1 ? V.beat - 1 : 0, c = F * m + W;
     return {
       totalBeats: c,
       duration: c * a,
       beatSequence: this._generateBeatSequence(c, a, m),
       beatsPerBar: m,
-      startBeat: Q
+      startBeat: V
     };
   }
   /**
@@ -3505,19 +3586,19 @@ class xU {
    * @private
    */
   _generateBeatSequence(l, U, F) {
-    const Z = [];
-    for (let V = 0; V < l; V++) {
-      const Q = V % F + 1;
-      Z.push({
-        beat: Q,
-        isAccent: Q === 1,
-        time: V * U,
+    const d = [];
+    for (let Q = 0; Q < l; Q++) {
+      const V = Q % F + 1;
+      d.push({
+        beat: V,
+        isAccent: V === 1,
+        time: Q * U,
         // Relative time from start of lead-in playback
-        absoluteTime: this.leadInStartTime + V * U
+        absoluteTime: this.leadInStartTime + Q * U
         // Absolute time (includes startup delay)
       });
     }
-    return Z;
+    return d;
   }
   /**
    * Start lead-in tick scheduling using beat-index approach
@@ -3528,20 +3609,20 @@ class xU {
     this.leadInBeatIndex = 0, this.leadInScheduledBeats = /* @__PURE__ */ new Set();
     const U = this.leadInData.beatSequence, F = 10;
     this.leadInStartTime = this.audioEngine.audioContext.currentTime, this.leadInInterval = setInterval(() => {
-      const Z = this.audioEngine.audioContext.currentTime - this.leadInStartTime;
-      for (this.leadInProgress = Math.min(1, Z / this.leadInData.duration); this.leadInBeatIndex < U.length; ) {
-        const V = U[this.leadInBeatIndex], Q = V.time - Z;
-        if (Q > 0.05)
+      const d = this.audioEngine.audioContext.currentTime - this.leadInStartTime;
+      for (this.leadInProgress = Math.min(1, d / this.leadInData.duration); this.leadInBeatIndex < U.length; ) {
+        const Q = U[this.leadInBeatIndex], V = Q.time - d;
+        if (V > 0.05)
           break;
-        if (!this.leadInScheduledBeats.has(this.leadInBeatIndex) && Q >= -0.05 && Q <= 0.05) {
-          const t = Q <= 0 ? this.audioEngine.audioContext.currentTime + 0.01 : (
+        if (!this.leadInScheduledBeats.has(this.leadInBeatIndex) && V >= -0.05 && V <= 0.05) {
+          const t = V <= 0 ? this.audioEngine.audioContext.currentTime + 0.01 : (
             // Add small offset for immediate beats
-            this.audioEngine.audioContext.currentTime + Q
+            this.audioEngine.audioContext.currentTime + V
           );
-          this._scheduleTickAtTime(t, V.isAccent);
+          this._scheduleTickAtTime(t, Q.isAccent);
           const R = {
             bar: Math.floor(this.leadInBeatIndex / this.leadInData.beatsPerBar) + 1,
-            beat: V.beat,
+            beat: Q.beat,
             repeat: 1,
             time: this.frozenTime,
             isLeadIn: !0
@@ -3586,15 +3667,15 @@ class xU {
     this.state = "playing", this._resetMetronomeBeatTracking(), U && this._emitEvent("playbackStarted", {
       startupDelayMs: F ? 0 : this.startupConfig.delayMs
     });
-    const Z = () => {
+    const d = () => {
       if (this.state === "playing")
         try {
           this.midiPlayer.play(), l && this._startMetronome();
-        } catch (V) {
-          this.state = "stopped", this._emitEvent("error", V);
+        } catch (Q) {
+          this.state = "stopped", this._emitEvent("error", Q);
         }
     };
-    F ? Z() : setTimeout(Z, this.startupConfig.delayMs), this.timeUpdateInterval || this._startTimeUpdateLoop();
+    F ? d() : setTimeout(d, this.startupConfig.delayMs), this.timeUpdateInterval || this._startTimeUpdateLoop();
   }
   /**
    * Start metronome during MIDI playback
@@ -3633,14 +3714,14 @@ class xU {
     const U = this.midiPlayer.beats;
     if (!U || U.length === 0)
       return;
-    const F = this.midiPlayer.getCurrentTime(), Z = 0.1;
-    for (let V = this.nextBeatIndex; V < U.length; V++) {
-      const Q = U[V], t = this.midiPlayer.playbackSpeed || 1, R = l + (Q.time - F) / t;
-      if (R > this.audioEngine.audioContext.currentTime + Z)
+    const F = this.midiPlayer.getCurrentTime(), d = 0.1;
+    for (let Q = this.nextBeatIndex; Q < U.length; Q++) {
+      const V = U[Q], t = this.midiPlayer.playbackSpeed || 1, R = l + (V.time - F) / t;
+      if (R > this.audioEngine.audioContext.currentTime + d)
         break;
       if (R >= this.audioEngine.audioContext.currentTime - 0.01) {
-        const a = Math.max(R, this.audioEngine.audioContext.currentTime + 1e-3), n = Q.isDownbeat || Q.beat === 1;
-        this._scheduleTickAtTime(a, n), this.nextBeatIndex = V + 1;
+        const a = Math.max(R, this.audioEngine.audioContext.currentTime + 1e-3), n = V.isDownbeat || V.beat === 1;
+        this._scheduleTickAtTime(a, n), this.nextBeatIndex = Q + 1;
       }
     }
   }
@@ -3657,11 +3738,11 @@ class xU {
       this.nextBeatIndex++;
     const F = l + 0.15;
     for (; this.nextBeatIndex < U.length; ) {
-      const Z = U[this.nextBeatIndex], V = Z.time - l;
-      if (Z.time > F)
+      const d = U[this.nextBeatIndex], Q = d.time - l;
+      if (d.time > F)
         break;
-      if (V >= -0.025 && V <= 0.15) {
-        const Q = this.audioEngine.audioContext.currentTime + 5e-3, t = this.audioEngine.audioContext.currentTime + Math.max(V, 5e-3), R = Math.max(Q, t), a = Z.beat === 1;
+      if (Q >= -0.025 && Q <= 0.15) {
+        const V = this.audioEngine.audioContext.currentTime + 5e-3, t = this.audioEngine.audioContext.currentTime + Math.max(Q, 5e-3), R = Math.max(V, t), a = d.beat === 1;
         this._scheduleTickAtTime(R, a);
       }
       this.nextBeatIndex++;
@@ -3766,8 +3847,8 @@ class xU {
     (this.eventBus.all.get(l) || []).forEach((F) => {
       try {
         F(U);
-      } catch (Z) {
-        console.error(`Error in ${l} event listener:`, Z);
+      } catch (d) {
+        console.error(`Error in ${l} event listener:`, d);
       }
     });
   }
@@ -3836,7 +3917,10 @@ class xU {
    * @private
    */
   _completeMidiPlayerSetup() {
-    this._partOutputsMap.clear(), Object.keys(this.midiPlayer.parsedData.parts).forEach((l) => {
+    this._partOutputsMap.clear(), Object.keys(this.midiPlayer.parsedData.parts).sort((l, U) => {
+      const F = this.midiPlayer.parsedData.parts[l], d = this.midiPlayer.parsedData.parts[U], Q = F.channel !== void 0 ? F.channel : F.trackIndex, V = d.channel !== void 0 ? d.channel : d.trackIndex;
+      return Q - V;
+    }).forEach((l) => {
       const U = this.midiPlayer.getPartOutput(l);
       U && this._partOutputsMap.set(l, U);
     }), this._setupEventDelegation(), this.state = "ready";
@@ -3859,12 +3943,20 @@ class xU {
       flute: { instrument: "flute", volume: 0.8 },
       trumpet: { instrument: "trumpet", volume: 0.7 }
     };
-    return Object.keys(l).forEach((Z) => {
-      const V = Z.toLowerCase(), Q = F[V] || F.piano;
-      U[Z] = {
-        instrument: Q.instrument,
-        volume: Q.volume
-      };
+    return Object.keys(l).forEach((d) => {
+      const Q = l[d];
+      if (Q.defaultInstrument !== void 0)
+        U[d] = {
+          instrument: Q.defaultInstrument,
+          volume: 1
+        };
+      else {
+        const V = d.toLowerCase(), t = F[V] || F.piano;
+        U[d] = {
+          instrument: t.instrument,
+          volume: t.volume
+        };
+      }
     }), U;
   }
   // ========================================
@@ -3884,19 +3976,19 @@ class xU {
     const U = this.audioEngine.getMetronomeAnalyser();
     if (!U)
       throw new Error("Metronome analyser not available for signal capture");
-    const F = l.sampleIntervalMs || 2, Z = l.captureDurationMs || 1500, V = this.audioEngine.audioContext.currentTime + 0.1;
-    await this.audioEngine.playMetronomeTick(V, !0, 1);
-    const Q = await this._captureAnalyserTimeSeries(
+    const F = l.sampleIntervalMs || 2, d = l.captureDurationMs || 1500, Q = this.audioEngine.audioContext.currentTime + 0.1;
+    await this.audioEngine.playMetronomeTick(Q, !0, 1);
+    const V = await this._captureAnalyserTimeSeries(
       U,
-      V,
+      Q,
       F,
-      Z
+      d
     );
     return {
-      scheduledTime: V,
-      samples: Q,
+      scheduledTime: Q,
+      samples: V,
       sampleIntervalMs: F,
-      captureDurationMs: Z
+      captureDurationMs: d
     };
   }
   /**
@@ -3908,21 +4000,21 @@ class xU {
    * @returns {Promise<number>} Average latency in milliseconds
    * @private
    */
-  async _performLatencyMeasurement(l, U, F, Z) {
-    const V = this.audioEngine.getMetronomeAnalyser();
-    if (!V)
+  async _performLatencyMeasurement(l, U, F, d) {
+    const Q = this.audioEngine.getMetronomeAnalyser();
+    if (!Q)
       throw new Error("Metronome analyser not available for latency measurement");
-    const Q = this.audioEngine.audioContext, t = [];
+    const V = this.audioEngine.audioContext, t = [];
     console.log(`Starting calibration: ${l} measurements, ${U}ms sampling, ${F} threshold`);
     for (let m = 0; m < l; m++) {
-      const b = Q.currentTime + 0.15;
-      await this.audioEngine.playMetronomeTick(b, !0, 1);
+      const W = V.currentTime + 0.15;
+      await this.audioEngine.playMetronomeTick(W, !0, 1);
       const c = await this._detectOnsetByThreshold(
-        V,
-        b,
+        Q,
+        W,
         U,
         F,
-        Z
+        d
       );
       if (c) {
         const s = c.latencyMs;
@@ -3935,7 +4027,7 @@ class xU {
       throw new Error(`Failed to detect any metronome onsets. Try lowering threshold (current: ${F}) or check audio routing.`);
     let R = t;
     if (t.length >= 5) {
-      const m = [...t].sort((b, c) => b - c);
+      const m = [...t].sort((W, c) => W - c);
       R = m.slice(
         Math.floor(m.length * 0.2),
         // Remove bottom 20%
@@ -3943,8 +4035,8 @@ class xU {
         // Remove top 20%
       ), console.log(`Discarded ${t.length - R.length} outliers`);
     }
-    const a = R.reduce((m, b) => m + b, 0) / R.length, n = Math.sqrt(
-      R.reduce((m, b) => m + Math.pow(b - a, 2), 0) / R.length
+    const a = R.reduce((m, W) => m + W, 0) / R.length, n = Math.sqrt(
+      R.reduce((m, W) => m + Math.pow(W - a, 2), 0) / R.length
     );
     return console.log(`Average latency: ${a.toFixed(1)}ms ± ${n.toFixed(1)}ms (n=${R.length})`), Math.round(a);
   }
@@ -3959,14 +4051,14 @@ class xU {
    * @returns {Promise<Object|null>} Detection result {latencyMs, rms, peak} or null if timeout
    * @private
    */
-  async _detectOnsetByThreshold(l, U, F, Z, V) {
-    const Q = this.audioEngine.audioContext, t = l.fftSize, R = new Float32Array(t), a = Math.max(0, (U - Q.currentTime) * 1e3 - 20);
+  async _detectOnsetByThreshold(l, U, F, d, Q) {
+    const V = this.audioEngine.audioContext, t = l.fftSize, R = new Float32Array(t), a = Math.max(0, (U - V.currentTime) * 1e3 - 20);
     await new Promise((m) => setTimeout(m, a));
     const n = performance.now();
     return new Promise((m) => {
-      const b = setInterval(() => {
-        if (performance.now() - n > V) {
-          clearInterval(b), m(null);
+      const W = setInterval(() => {
+        if (performance.now() - n > Q) {
+          clearInterval(W), m(null);
           return;
         }
         l.getFloatTimeDomainData(R);
@@ -3976,9 +4068,9 @@ class xU {
           c += R[J] * R[J], p > s && (s = p);
         }
         const N = Math.sqrt(c / t);
-        if (N >= Z) {
-          clearInterval(b);
-          const J = Q.currentTime, p = (J - U) * 1e3;
+        if (N >= d) {
+          clearInterval(W);
+          const J = V.currentTime, p = (J - U) * 1e3;
           m({
             latencyMs: p,
             rms: N,
@@ -3998,21 +4090,21 @@ class xU {
    * @returns {Promise<Array>} Array of samples {time, rms, peak, relativeTime}
    * @private
    */
-  async _captureAnalyserTimeSeries(l, U, F, Z) {
-    const V = this.audioEngine.audioContext, Q = l.fftSize, t = new Float32Array(Q), R = [], a = performance.now(), n = Math.max(0, (U - V.currentTime) * 1e3 - 20);
+  async _captureAnalyserTimeSeries(l, U, F, d) {
+    const Q = this.audioEngine.audioContext, V = l.fftSize, t = new Float32Array(V), R = [], a = performance.now(), n = Math.max(0, (U - Q.currentTime) * 1e3 - 20);
     return await new Promise((m) => setTimeout(m, n)), new Promise((m) => {
-      const b = setInterval(() => {
-        if (performance.now() - a - n >= Z) {
-          clearInterval(b), m(R);
+      const W = setInterval(() => {
+        if (performance.now() - a - n >= d) {
+          clearInterval(W), m(R);
           return;
         }
         l.getFloatTimeDomainData(t);
         let c = 0, s = 0;
-        for (let p = 0; p < Q; p++) {
+        for (let p = 0; p < V; p++) {
           const M = Math.abs(t[p]);
           c += t[p] * t[p], M > s && (s = M);
         }
-        const N = Math.sqrt(c / Q), J = V.currentTime;
+        const N = Math.sqrt(c / V), J = Q.currentTime;
         R.push({
           time: J,
           relativeTime: (J - U) * 1e3,
@@ -4036,8 +4128,8 @@ class MU {
   // Initialize audio system
   async initializeAudioSystem() {
     if (this.isInitialized) return;
-    this.audioContext = new (window.AudioContext || window.webkitAudioContext)(), this.audioContext.state === "suspended" && await this.audioContext.resume(), this.audioEngine = new rU(this.audioContext), this.audioEngine.on("initProgress", (Z) => {
-      this.eventBus.emit("initProgress", Z);
+    this.audioContext = new (window.AudioContext || window.webkitAudioContext)(), this.audioContext.state === "suspended" && await this.audioContext.resume(), this.audioEngine = new rU(this.audioContext), this.audioEngine.on("initProgress", (d) => {
+      this.eventBus.emit("initProgress", d);
     });
     const l = [
       "/FluidR3Mono_GM.sf3",
@@ -4045,20 +4137,20 @@ class MU {
       "/soundfont.sf2"
     ];
     let U = !1, F = null;
-    for (const Z of l)
+    for (const d of l)
       try {
-        await this.audioEngine.initialize(Z), console.log(`Loaded soundfont: ${Z}`), U = !0;
+        await this.audioEngine.initialize(d), console.log(`Loaded soundfont: ${d}`), U = !0;
         break;
-      } catch (V) {
-        console.warn(`Failed to load soundfont ${Z}:`, V.message), F = V;
+      } catch (Q) {
+        console.warn(`Failed to load soundfont ${d}:`, Q.message), F = Q;
       }
     if (!U) {
-      const Z = "No soundfont could be loaded";
+      const d = "No soundfont could be loaded";
       throw this.eventBus.emit("initProgress", {
         stage: "error",
-        message: Z,
+        message: d,
         error: F
-      }), new Error(Z);
+      }), new Error(d);
     }
     this.setupMasterAudioGraph(), this.isInitialized = !0, console.log("AudioEngineService initialized successfully");
   }
@@ -4073,7 +4165,7 @@ class MU {
     else {
       if (this.beats = l.beats || [], this.practiceMarks = l.marks || l.practiceMarks || {}, this.beats.length > 0) {
         const U = this.beats[this.beats.length - 1], F = U.tempo > 0 ? 60 / U.tempo : 0.75;
-        this.songDuration = U.time + F, this.maxBar = Math.max(...this.beats.map((Z) => Z.bar));
+        this.songDuration = U.time + F, this.maxBar = Math.max(...this.beats.map((d) => d.bar));
       } else
         this.songDuration = 0, this.maxBar = 0;
       this.setupLegacyParts(l.parts || []), this.eventBus.emit("initialized", { parts: Array.from(this.parts.values()) });
@@ -4111,8 +4203,8 @@ class MU {
         // Silent calibration
       });
       console.log(`Measured audio latency: ${F} ms`), this.setupPlaybackManagerEventDelegation(), await this.playbackManager.load(l, U);
-      const Z = this.playbackManager.getPartNames();
-      this.setupMidiParts(Z), this.eventBus.emit("initialized", { parts: Array.from(this.parts.values()) }), await this.setupPartAudioRouting(Z), this.setupMetronomeAudioRouting(), this.extractMusicDataFromPlayer(), this.updateSongDurationFromPlayer(), console.log("MIDI playback with PlaybackManager setup complete");
+      const d = this.playbackManager.getPartNames();
+      this.setupMidiParts(d), this.eventBus.emit("initialized", { parts: Array.from(this.parts.values()) }), await this.setupPartAudioRouting(d), this.setupMetronomeAudioRouting(), this.extractMusicDataFromPlayer(), this.updateSongDurationFromPlayer(), console.log("MIDI playback with PlaybackManager setup complete");
     } catch (F) {
       throw console.error("Failed to setup MIDI playback:", F), F;
     }
@@ -4138,10 +4230,10 @@ class MU {
     for (const [l, U] of this.playbackManager.getPartOutputs()) {
       const F = this.audioContext.createGain();
       F.gain.value = 1;
-      const Z = this.audioContext.createAnalyser();
-      Z.fftSize = 256, Z.smoothingTimeConstant = 0.3, U.connect(F), F.connect(Z), Z.connect(this.masterGain);
-      const V = this.sanitizePartName(l);
-      this.partGainNodes.set(V, F), this.partAnalyserNodes.set(V, Z), console.log(`Audio routing established for part: ${l}`);
+      const d = this.audioContext.createAnalyser();
+      d.fftSize = 256, d.smoothingTimeConstant = 0.3, U.connect(F), F.connect(d), d.connect(this.masterGain);
+      const Q = this.sanitizePartName(l);
+      this.partGainNodes.set(Q, F), this.partAnalyserNodes.set(Q, d), console.log(`Audio routing established for part: ${l}`);
     }
   }
   // Set up metronome audio routing (separate from parts)
@@ -4189,8 +4281,8 @@ class MU {
   setupPlaybackManagerEventDelegation() {
     this.playbackManager.on("timeupdate", ({ audioTime: l, leadInProgress: U }) => {
       this.currentTime = l, this.eventBus.emit("timeChanged", { currentTime: l, leadInProgress: U });
-    }), this.playbackManager.on("beatAudible", ({ bar: l, beat: U, isLeadIn: F, repeat: Z, time: V }) => {
-      this.eventBus.emit("barChanged", { bar: l, beat: U, repeat: Z, time: V, isLeadIn: F });
+    }), this.playbackManager.on("beatAudible", ({ bar: l, beat: U, isLeadIn: F, repeat: d, time: Q }) => {
+      this.eventBus.emit("barChanged", { bar: l, beat: U, repeat: d, time: Q, isLeadIn: F });
     }), this.playbackManager.on("leadInStarted", ({ totalBeats: l, duration: U, bars: F }) => {
       this.eventBus.emit("leadInStarted", { bars: F, totalBeats: l, duration: U });
     }), this.playbackManager.on("leadInEnded", () => {
@@ -4301,28 +4393,28 @@ class MU {
     return this.metronomeVolume || 0.7;
   }
   setPartVolume(l, U) {
-    const F = this.sanitizePartName(l), Z = this.parts.get(F);
-    Z ? (Z.volume = Math.max(0, Math.min(1, U)), this.updatePartAudioState(F), this.eventBus.emit("partVolumeChanged", { partName: l, volume: U })) : (console.log(`Part not found: "${l}" (sanitized: "${F}")`), console.log("Available parts:", [...this.parts.keys()]));
+    const F = this.sanitizePartName(l), d = this.parts.get(F);
+    d ? (d.volume = Math.max(0, Math.min(1, U)), this.updatePartAudioState(F), this.eventBus.emit("partVolumeChanged", { partName: l, volume: U })) : (console.log(`Part not found: "${l}" (sanitized: "${F}")`), console.log("Available parts:", [...this.parts.keys()]));
   }
   setPartMuted(l, U) {
-    const F = this.sanitizePartName(l), Z = this.parts.get(F);
-    Z && (Z.muted = U, this.updatePartAudioState(F), this.eventBus.emit("partMutedChanged", { partName: l, muted: U }));
+    const F = this.sanitizePartName(l), d = this.parts.get(F);
+    d && (d.muted = U, this.updatePartAudioState(F), this.eventBus.emit("partMutedChanged", { partName: l, muted: U }));
   }
   setPartSolo(l, U) {
-    const F = this.sanitizePartName(l), Z = this.parts.get(F);
-    Z && (Z.solo = U, this.updateAllPartsAudioState(), this.eventBus.emit("partSoloChanged", { partName: l, solo: U }));
+    const F = this.sanitizePartName(l), d = this.parts.get(F);
+    d && (d.solo = U, this.updateAllPartsAudioState(), this.eventBus.emit("partSoloChanged", { partName: l, solo: U }));
   }
   // Helper method to determine if a part should be effectively muted
   isPartEffectivelyMuted(l) {
     const U = this.sanitizePartName(l), F = this.parts.get(U);
-    return !F || F.muted ? !0 : Array.from(this.parts.values()).some((V) => V.solo) && !F.solo;
+    return !F || F.muted ? !0 : Array.from(this.parts.values()).some((Q) => Q.solo) && !F.solo;
   }
   // Update audio state for a specific part
   updatePartAudioState(l) {
     const U = this.parts.get(l), F = this.partGainNodes.get(l);
     if (U && F) {
-      const Z = this.isPartEffectivelyMuted(U.name);
-      F.gain.value = Z ? 0 : U.volume;
+      const d = this.isPartEffectivelyMuted(U.name);
+      F.gain.value = d ? 0 : U.volume;
     }
   }
   // Update audio state for all parts (needed when solo state changes)
@@ -4339,17 +4431,17 @@ class MU {
     if (!F)
       return 0;
     try {
-      const Z = F.frequencyBinCount, V = new Uint8Array(Z);
-      F.getByteFrequencyData(V);
-      let Q = 0;
-      for (let R = 0; R < Z; R++) {
-        const a = V[R] / 255;
-        Q += a * a;
+      const d = F.frequencyBinCount, Q = new Uint8Array(d);
+      F.getByteFrequencyData(Q);
+      let V = 0;
+      for (let R = 0; R < d; R++) {
+        const a = Q[R] / 255;
+        V += a * a;
       }
-      const t = Math.sqrt(Q / Z);
+      const t = Math.sqrt(V / d);
       return Math.min(1, Math.pow(t * 2, 0.7));
-    } catch (Z) {
-      return console.warn(`Failed to get level for part ${l}:`, Z), 0;
+    } catch (d) {
+      return console.warn(`Failed to get level for part ${l}:`, d), 0;
     }
   }
   // Special features (maintain DummyAudioEngine interface)
@@ -4358,7 +4450,7 @@ class MU {
   }
   playStartingNotes() {
     console.log(this.parts);
-    const l = [...this.parts.values()], U = l.some((Z) => Z.solo), F = l.filter((Z) => U ? Z.solo : !Z.muted).map((Z) => Z.name);
+    const l = [...this.parts.values()], U = l.some((d) => d.solo), F = l.filter((d) => U ? d.solo : !d.muted).map((d) => d.name);
     console.log(l, U, F), this.playbackManager.previewNextNotes({
       instrument: "piano",
       // Use piano for clear pitch reference
@@ -4428,77 +4520,71 @@ class MU {
 }
 const e = new MU();
 function Rl() {
-  const d = Ul(), l = tl(), U = NU(), F = ({ currentTime: W }) => {
-    d.setCurrentTime(W);
-  }, Z = ({ isPlaying: W }) => {
-    d.setPlaybackState(W), U.setTransportState(W ? "playing" : "stopped");
-  }, V = (W) => {
-    W && (d.isLeadInActive ? W.isLeadIn && W.beat !== void 0 && d.setCurrentBar(null, W.beat, null) : (d.setCurrentBar(W.bar, W.beat, W.repeat), U.updateLastBarPosition(W.bar)));
-  }, Q = ({ speed: W }) => {
-    d.setPlaybackSpeed(W);
-  }, t = ({ volume: W }) => {
-    d.setMasterVolume(W);
-  }, R = ({ partName: W, volume: o }) => {
-    d.setPartVolume(W, o);
-  }, a = ({ partName: W, muted: o }) => {
-    d.setPartMuted(W, o);
-  }, n = ({ partName: W, solo: o }) => {
-    d.setPartSolo(W, o);
-  }, m = ({ bars: W }) => {
-    d.setLeadInActive(!0, W);
-  }, b = () => {
-    d.setLeadInActive(!1);
+  const Z = Ul(), l = tl(), U = NU(), F = ({ currentTime: b }) => {
+    Z.setCurrentTime(b);
+  }, d = ({ isPlaying: b }) => {
+    Z.setPlaybackState(b), U.setTransportState(b ? "playing" : "stopped");
+  }, Q = (b) => {
+    b && (Z.isLeadInActive ? b.isLeadIn && b.beat !== void 0 && Z.setCurrentBar(null, b.beat, null) : (Z.setCurrentBar(b.bar, b.beat, b.repeat), U.updateLastBarPosition(b.bar)));
+  }, V = ({ speed: b }) => {
+    Z.setPlaybackSpeed(b);
+  }, t = ({ volume: b }) => {
+    Z.setMasterVolume(b);
+  }, R = ({ partName: b, volume: o }) => {
+    Z.setPartVolume(b, o);
+  }, a = ({ partName: b, muted: o }) => {
+    Z.setPartMuted(b, o);
+  }, n = ({ partName: b, solo: o }) => {
+    Z.setPartSolo(b, o);
+  }, m = ({ bars: b }) => {
+    Z.setLeadInActive(!0, b);
+  }, W = () => {
+    Z.setLeadInActive(!1);
   }, c = () => {
-    d.setStartingNotesActive(!0);
+    Z.setStartingNotesActive(!0);
   }, s = () => {
-    d.setStartingNotesActive(!1);
-  }, N = ({ mark: W }) => {
-    U.updateLastPracticeMarkUsed(W);
-  }, J = ({ parts: W }) => {
-    d.initializeParts(W), l.setParts(W);
-  }, p = ({ finalTime: W }) => {
-    d.setPlaybackState(!1), U.setTransportState("stopped"), console.log(`Song ended at time: ${W}`);
-  }, M = ({ duration: W }) => {
-    console.log("Updating total duration in store to:", W), l.setTotalDuration(W);
-  }, y = ({ beats: W, practiceMarks: o, maxBar: q }) => {
-    console.log(`Updating music data store with ${W.length} beats and ${Object.keys(o).length} practice marks`), l.updateBeats(W), l.practiceMarks = o, l.maxBar = q;
-  }, G = () => {
-    e.on("timeChanged", F), e.on("playbackStateChanged", Z), e.on("barChanged", V), e.on("speedChanged", Q), e.on("masterVolumeChanged", t), e.on("partVolumeChanged", R), e.on("partMutedChanged", a), e.on("partSoloChanged", n), e.on("leadInStarted", m), e.on("leadInCompleted", b), e.on("startingNotesStarted", c), e.on("startingNotesCompleted", s), e.on("practiceMarkChanged", N), e.on("initialized", J), e.on("songEnded", p), e.on("durationUpdated", M), e.on("musicDataExtracted", y);
+    Z.setStartingNotesActive(!1);
+  }, N = ({ mark: b }) => {
+    U.updateLastPracticeMarkUsed(b);
+  }, J = ({ parts: b }) => {
+    Z.initializeParts(b), l.setParts(b);
+  }, p = ({ finalTime: b }) => {
+    Z.setPlaybackState(!1), U.setTransportState("stopped"), console.log(`Song ended at time: ${b}`);
+  }, M = ({ duration: b }) => {
+    console.log("Updating total duration in store to:", b), l.setTotalDuration(b);
+  }, y = ({ beats: b, practiceMarks: o, maxBar: q }) => {
+    console.log(`Updating music data store with ${b.length} beats and ${Object.keys(o).length} practice marks`), l.updateBeats(b), l.practiceMarks = o, l.maxBar = q;
+  }, u = () => {
+    e.on("timeChanged", F), e.on("playbackStateChanged", d), e.on("barChanged", Q), e.on("speedChanged", V), e.on("masterVolumeChanged", t), e.on("partVolumeChanged", R), e.on("partMutedChanged", a), e.on("partSoloChanged", n), e.on("leadInStarted", m), e.on("leadInCompleted", W), e.on("startingNotesStarted", c), e.on("startingNotesCompleted", s), e.on("practiceMarkChanged", N), e.on("initialized", J), e.on("songEnded", p), e.on("durationUpdated", M), e.on("musicDataExtracted", y);
   }, k = () => {
-    e.off("timeChanged", F), e.off("playbackStateChanged", Z), e.off("barChanged", V), e.off("speedChanged", Q), e.off("masterVolumeChanged", t), e.off("partVolumeChanged", R), e.off("partMutedChanged", a), e.off("partSoloChanged", n), e.off("leadInStarted", m), e.off("leadInCompleted", b), e.off("startingNotesStarted", c), e.off("startingNotesCompleted", s), e.off("practiceMarkChanged", N), e.off("initialized", J), e.off("songEnded", p), e.off("durationUpdated", M), e.off("musicDataExtracted", y);
+    e.off("timeChanged", F), e.off("playbackStateChanged", d), e.off("barChanged", Q), e.off("speedChanged", V), e.off("masterVolumeChanged", t), e.off("partVolumeChanged", R), e.off("partMutedChanged", a), e.off("partSoloChanged", n), e.off("leadInStarted", m), e.off("leadInCompleted", W), e.off("startingNotesStarted", c), e.off("startingNotesCompleted", s), e.off("practiceMarkChanged", N), e.off("initialized", J), e.off("songEnded", p), e.off("durationUpdated", M), e.off("musicDataExtracted", y);
   };
   (() => {
     El(() => {
-      const W = d.masterVolume;
+      const b = Z.masterVolume;
       try {
-        e.getMasterVolume() !== W && e.setMasterVolume(W);
+        e.getMasterVolume() !== b && e.setMasterVolume(b);
       } catch (o) {
         console.warn("Master volume sync skipped during initialization:", o.message);
       }
     }), El(() => {
-      const W = d.metronomeVolume;
+      const b = Z.metronomeVolume;
       try {
-        e.getMetronomeVolume() !== W && e.setMetronomeVolume(W);
+        e.getMetronomeVolume() !== b && e.setMetronomeVolume(b);
       } catch (o) {
         console.warn("Metronome volume sync skipped during initialization:", o.message);
       }
     });
   })();
-  const H = async (W) => {
+  const H = async (b) => {
     try {
-      if (d.setLoaded(!1), G(), l.loadMusicData(W), W.midiData)
-        await e.initialize(W);
-      else if (await e.initialize({
-        beats: W.beats,
-        practiceMarks: W.marks || W.practiceMarks,
-        parts: W.parts
-      }), W.beats && W.beats.length > 0) {
-        const o = W.beats[0];
-        d.setCurrentBar(o.bar, o.beat, o.repeat), e.setTime(o.time);
+      if (Z.setLoaded(!1), u(), l.loadMusicData(b), await e.initialize(b), !b.midiData && b.beats && b.beats.length > 0) {
+        const o = b.beats[0];
+        Z.setCurrentBar(o.bar, o.beat, o.repeat), e.setTime(o.time);
       }
-      e.updateToggleStates(d.metronomeEnabled, d.leadInEnabled), d.setLoaded(!0);
+      e.updateToggleStates(Z.metronomeEnabled, Z.leadInEnabled), Z.setLoaded(!0);
     } catch (o) {
-      throw console.error("Failed to initialize audio engine:", o), d.setLoaded(!1), o;
+      throw console.error("Failed to initialize audio engine:", o), Z.setLoaded(!1), o;
     }
   }, A = () => {
     e.play();
@@ -4506,37 +4592,37 @@ function Rl() {
     e.stop();
   }, Zl = () => {
     e.pause();
-  }, i = (W) => {
-    e.setTime(W);
-  }, z = (W, o = 0) => {
-    e.setBar(W, o);
-  }, P = (W) => {
-    e.goToPracticeMark(W);
-  }, B = (W) => {
-    e.setPlaybackSpeed(W);
-  }, S = (W) => {
-    e.setMasterVolume(W);
-  }, T = (W, o) => {
-    e.setPartVolume(W, o);
-  }, I = (W, o) => {
-    e.setPartMuted(W, o);
-  }, w = (W, o) => {
-    e.setPartSolo(W, o);
-  }, Ql = (W = 1) => {
-    e.playLeadIn(W);
+  }, i = (b) => {
+    e.setTime(b);
+  }, z = (b, o = 0) => {
+    e.setBar(b, o);
+  }, P = (b) => {
+    e.goToPracticeMark(b);
+  }, B = (b) => {
+    e.setPlaybackSpeed(b);
+  }, S = (b) => {
+    e.setMasterVolume(b);
+  }, T = (b, o) => {
+    e.setPartVolume(b, o);
+  }, I = (b, o) => {
+    e.setPartMuted(b, o);
+  }, w = (b, o) => {
+    e.setPartSolo(b, o);
+  }, Ql = (b = 1) => {
+    e.playLeadIn(b);
   }, Bl = () => {
     e.playStartingNotes();
-  }, Yl = (W, o = !0, q = 0) => {
-    o && U.leadInEnabled ? (z(W, q), Ql(U.leadInBars)) : (z(W, q), A());
-  }, _l = (W, o = !0) => {
-    const q = l.getBarForMark(W);
+  }, Yl = (b, o = !0, q = 0) => {
+    o && U.leadInEnabled ? (z(b, q), Ql(U.leadInBars)) : (z(b, q), A());
+  }, _l = (b, o = !0) => {
+    const q = l.getBarForMark(b);
     q && Yl(q, o);
   }, $l = () => {
-    const W = !d.metronomeEnabled;
-    return d.setMetronomeEnabled(W), e.setMetronomeEnabled(W), W;
+    const b = !Z.metronomeEnabled;
+    return Z.setMetronomeEnabled(b), e.setMetronomeEnabled(b), b;
   }, lU = () => {
-    const W = !d.leadInEnabled;
-    return d.setLeadInEnabled(W), e.updateToggleStates(d.metronomeEnabled, W), W;
+    const b = !Z.leadInEnabled;
+    return Z.setLeadInEnabled(b), e.updateToggleStates(Z.metronomeEnabled, b), b;
   };
   return cl(() => {
     k();
@@ -4558,21 +4644,21 @@ function Rl() {
     setPartVolume: T,
     setPartMuted: I,
     setPartSolo: w,
-    getPartLevel: (W) => e.getPartLevel(W),
+    getPartLevel: (b) => e.getPartLevel(b),
     // Special features
     playLeadIn: Ql,
     playStartingNotes: Bl,
     // Feature toggles
     toggleMetronome: $l,
     toggleLeadIn: lU,
-    setMetronomeEnabled: (W) => {
-      d.setMetronomeEnabled(W), e.setMetronomeEnabled(W);
+    setMetronomeEnabled: (b) => {
+      Z.setMetronomeEnabled(b), e.setMetronomeEnabled(b);
     },
     // Complex operations
     playFromBar: Yl,
     playFromMark: _l,
     // Access to stores for components
-    audioState: d,
+    audioState: Z,
     musicData: l,
     playbackState: U,
     // Direct access to engine for advanced use
@@ -4589,7 +4675,7 @@ const zU = {
     level: {
       type: Number,
       default: 0,
-      validator: (d) => d >= 0 && d <= 1
+      validator: (Z) => Z >= 0 && Z <= 1
     }
   }, {
     volume: { default: 0.75 },
@@ -4600,61 +4686,61 @@ const zU = {
     soloModifiers: {}
   }),
   emits: ["update:volume", "update:mute", "update:solo"],
-  setup(d) {
+  setup(Z) {
     $((c) => ({
       "746d5fc3": a.value
     }));
-    const l = d;
+    const l = Z;
     Ul();
-    const U = Rl(), F = _(d, "volume"), Z = _(d, "mute"), V = _(d, "solo");
+    const U = Rl(), F = _(Z, "volume"), d = _(Z, "mute"), Q = _(Z, "solo");
     v(F, (c) => {
       U.setPartVolume(l.name, c);
-    }), v(Z, (c) => {
+    }), v(d, (c) => {
       U.setPartMuted(l.name, c);
-    }), v(V, (c) => {
+    }), v(Q, (c) => {
       U.setPartSolo(l.name, c);
     });
-    const Q = O("el"), { width: t, height: R } = ll(Q), a = u(() => Math.min(t.value, R.value) + "px"), n = u(
+    const V = O("el"), { width: t, height: R } = ll(V), a = G(() => Math.min(t.value, R.value) + "px"), n = G(
       () => t.value > R.value ? "mobile" : t.value < 60 ? "tablet" : "desktop"
     );
     let m = null;
-    const b = x(0);
+    const W = x(0);
     return el(() => {
       m = setInterval(() => {
-        if (Z.value)
-          b.value = 0;
+        if (d.value)
+          W.value = 0;
         else
           try {
-            b.value = U.getPartLevel(l.name);
+            W.value = U.getPartLevel(l.name);
           } catch {
-            Ol("randomLevelIndicators") ? b.value = Math.random() * F.value : b.value = 0;
+            Ol("randomLevelIndicators") ? W.value = Math.random() * F.value : W.value = 0;
           }
       }, 16);
     }), cl(() => {
       m && (clearInterval(m), m = null);
     }), (c, s) => (X(), Y("div", {
       ref_key: "el",
-      ref: Q,
+      ref: V,
       class: L([n.value, "part"])
     }, [
       C(XU, {
         class: "tri",
-        mute: Z.value,
-        "onUpdate:mute": s[0] || (s[0] = (N) => Z.value = N),
-        solo: V.value,
-        "onUpdate:solo": s[1] || (s[1] = (N) => V.value = N)
+        mute: d.value,
+        "onUpdate:mute": s[0] || (s[0] = (N) => d.value = N),
+        solo: Q.value,
+        "onUpdate:solo": s[1] || (s[1] = (N) => Q.value = N)
       }, null, 8, ["mute", "solo"]),
       C(wl, {
         align: "left",
         class: "name"
       }, {
         default: D(() => [
-          ol(K(d.name), 1)
+          ol(K(Z.name), 1)
         ]),
         _: 1
       }),
       C(bl, {
-        level: b.value,
+        level: W.value,
         "show-level": !0,
         class: "vol",
         value: F.value,
@@ -4667,34 +4753,34 @@ const zU = {
   class: "mark-grid-container"
 }, jU = { class: "mark-grid" }, PU = ["onClick"], wU = {
   __name: "BarInput",
-  setup(d) {
+  setup(Z) {
     $((B) => ({
       b117cda6: p.value,
       "7cd7b1c8": M.value
     }));
-    const l = O("el"), U = O("rpt"), { width: F, height: Z } = ll(l), V = tl(), Q = Ul(), t = Rl(), R = x("1"), a = x("A"), n = x(0), m = x(2), b = x(!1), c = x(!1), s = x(!1), N = x(!0);
+    const l = O("el"), U = O("rpt"), { width: F, height: d } = ll(l), Q = tl(), V = Ul(), t = Rl(), R = x("1"), a = x("A"), n = x(0), m = x(2), W = x(!1), c = x(!1), s = x(!1), N = x(!0);
     let J = null;
     v(() => {
       var B;
-      return ((B = V.beats) == null ? void 0 : B.length) > 0;
+      return ((B = Q.beats) == null ? void 0 : B.length) > 0;
     }, (B) => {
-      console.log(B), B && !b.value && (R.value = Q.currentBar.toString(), n.value = Q.currentRepeat, m.value = V.getRepeatCountForBar(Q.currentBar), k(Q.currentBar), b.value = !0);
-    }), v(() => Q.currentBar, (B) => {
-      m.value = V.getRepeatCountForBar(B);
+      console.log(B), B && !W.value && (R.value = V.currentBar.toString(), n.value = V.currentRepeat, m.value = Q.getRepeatCountForBar(V.currentBar), k(V.currentBar), W.value = !0);
+    }), v(() => V.currentBar, (B) => {
+      m.value = Q.getRepeatCountForBar(B);
     }), v(R, () => {
       R.value = R.value.replace(/\D/g, ""), R.value.length > 3 && (R.value = R.value.slice(0, 3));
-    }), v(() => Q.currentBar, (B) => {
+    }), v(() => V.currentBar, (B) => {
       R.value = B.toString(), k(B);
-    }), v(() => Q.currentBeat, () => {
+    }), v(() => V.currentBeat, () => {
       N.value = !0, setTimeout(() => {
         N.value = !1;
       }, 50);
     }), v(c, () => {
       c.value && P();
     });
-    const p = u(() => Math.min(Z.value / 2.25, F.value / 4.5) + "px"), M = u(() => Math.min(F.value / 15, Z.value / 6.4) + "px"), y = u(() => Object.keys(V.practiceMarks).sort()), G = u(() => y.value.length > 0);
+    const p = G(() => Math.min(d.value / 2.25, F.value / 4.5) + "px"), M = G(() => Math.min(F.value / 15, d.value / 6.4) + "px"), y = G(() => Object.keys(Q.practiceMarks).sort()), u = G(() => y.value.length > 0);
     function k(B) {
-      const S = Object.keys(V.practiceMarks).filter((T) => V.practiceMarks[T] <= B).sort((T, I) => V.practiceMarks[I] - V.practiceMarks[T]);
+      const S = Object.keys(Q.practiceMarks).filter((T) => Q.practiceMarks[T] <= B).sort((T, I) => Q.practiceMarks[I] - Q.practiceMarks[T]);
       S.length > 0 && (a.value = S[0]);
     }
     function E() {
@@ -4708,13 +4794,13 @@ const zU = {
       S && S.stopPropagation(), a.value = B, c.value = !1, t.goToPracticeMark(B);
     }
     function j() {
-      m.value > 1 && (s.value = !0), Q.currentRepeat < m.value && t.setBar(Q.currentBar, Q.currentRepeat + 1);
+      m.value > 1 && (s.value = !0), V.currentRepeat < m.value && t.setBar(V.currentBar, V.currentRepeat + 1);
     }
     function Zl() {
-      m.value > 1 && (s.value = !0), Q.currentRepeat > 1 && t.setBar(Q.currentBar, Q.currentRepeat - 1);
+      m.value > 1 && (s.value = !0), V.currentRepeat > 1 && t.setBar(V.currentBar, V.currentRepeat - 1);
     }
     function i(B) {
-      G.value && (B.stopPropagation(), s.value = !1, c.value = !c.value);
+      u.value && (B.stopPropagation(), s.value = !1, c.value = !c.value);
     }
     function z(B) {
       var S, T;
@@ -4732,8 +4818,8 @@ const zU = {
     }
     return el(() => {
       document.addEventListener("click", z), Ol("beatAnimation") && (J = setInterval(() => {
-        const B = Q.currentBeat % V.timeSignature + 1;
-        Q.setCurrentBar(Q.currentBar, B, Q.currentRepeat);
+        const B = V.currentBeat % Q.timeSignature + 1;
+        V.setCurrentBar(V.currentBar, B, V.currentRepeat);
       }, 800));
     }), cl(() => {
       document.removeEventListener("click", z), J && (clearInterval(J), J = null);
@@ -4744,10 +4830,10 @@ const zU = {
     }, [
       S[6] || (S[6] = h("div", { class: "frame" }, null, -1)),
       h("div", {
-        class: L(["mark-input", { empty: !a.value, edit: c.value, disabled: !G.value }]),
+        class: L(["mark-input", { empty: !a.value, edit: c.value, disabled: !u.value }]),
         onClick: i
       }, [
-        h("div", vU, K(G.value ? a.value : "-"), 1)
+        h("div", vU, K(u.value ? a.value : "-"), 1)
       ], 2),
       S[7] || (S[7] = h("div", { class: "mark-title" }, "Mark", -1)),
       c.value ? f("", !0) : (X(), Y(al, { key: 0 }, [
@@ -4768,16 +4854,16 @@ const zU = {
           ref: U,
           class: L(["rpt-input", { edit: s.value, available: m.value > 1 }])
         }, [
-          h("div", KU, K(r(Q).currentRepeat || "-"), 1),
+          h("div", KU, K(r(V).currentRepeat || "-"), 1),
           (X(), Y("svg", {
-            class: L(["inc", { disabled: r(Q).currentRepeat >= m.value }]),
+            class: L(["inc", { disabled: r(V).currentRepeat >= m.value }]),
             viewBox: "0 -100 100 100",
             onClick: kl(j, ["prevent"])
           }, S[1] || (S[1] = [
             h("path", { d: "m10-20 40-60 40 60H10Z" }, null, -1)
           ]), 2)),
           (X(), Y("svg", {
-            class: L(["dec", { disabled: r(Q).currentRepeat <= 1 }]),
+            class: L(["dec", { disabled: r(V).currentRepeat <= 1 }]),
             viewBox: "0 -100 100 100",
             onClick: kl(Zl, ["prevent"])
           }, S[2] || (S[2] = [
@@ -4786,7 +4872,7 @@ const zU = {
         ], 2),
         S[4] || (S[4] = h("div", { class: "rpt-title" }, "Rpt", -1)),
         h("div", gU, [
-          h("div", HU, K(r(Q).currentBeat), 1)
+          h("div", HU, K(r(V).currentBeat), 1)
         ]),
         S[5] || (S[5] = h("div", { class: "beat-title" }, "Beat", -1))
       ], 64)),
@@ -4838,23 +4924,23 @@ const zU = {
     },
     formatValue: {
       type: Function,
-      default: (d) => d.toString()
+      default: (Z) => Z.toString()
     },
     parseValue: {
       type: Function,
-      default: (d) => parseFloat(d)
+      default: (Z) => parseFloat(Z)
     },
     validateInput: {
       type: Function,
-      default: (d) => d.replace(/[^0-9.]/g, "")
+      default: (Z) => Z.replace(/[^0-9.]/g, "")
     },
     transformSliderToDisplay: {
       type: Function,
-      default: (d) => d
+      default: (Z) => Z
     },
     transformDisplayToSlider: {
       type: Function,
-      default: (d) => d
+      default: (Z) => Z
     },
     maxChars: {
       type: Number,
@@ -4865,26 +4951,26 @@ const zU = {
     valueModifiers: {}
   }),
   emits: ["update:value"],
-  setup(d) {
+  setup(Z) {
     $((n) => ({
-      "0d0963e0": d.textColor,
-      "4ad34b2f": d.backgroundColor,
-      "02156786": d.color,
+      "0d0963e0": Z.textColor,
+      "4ad34b2f": Z.backgroundColor,
+      "02156786": Z.color,
       "715a9528": R.value,
       "30d64f7d": t.value,
-      b8fbe65e: d.focusColor
+      b8fbe65e: Z.focusColor
     }));
-    const l = d, U = O("el"), { width: F, height: Z } = ll(U), V = _(d, "value"), Q = x(l.formatValue(l.transformSliderToDisplay(V.value)));
-    v(V, () => {
-      const n = l.transformSliderToDisplay(V.value);
-      Q.value = l.formatValue(n);
-    }), v(Q, () => {
-      Q.value = l.validateInput(Q.value), l.maxChars && Q.value.length > l.maxChars && (Q.value = Q.value.slice(0, l.maxChars));
+    const l = Z, U = O("el"), { width: F, height: d } = ll(U), Q = _(Z, "value"), V = x(l.formatValue(l.transformSliderToDisplay(Q.value)));
+    v(Q, () => {
+      const n = l.transformSliderToDisplay(Q.value);
+      V.value = l.formatValue(n);
+    }), v(V, () => {
+      V.value = l.validateInput(V.value), l.maxChars && V.value.length > l.maxChars && (V.value = V.value.slice(0, l.maxChars));
     });
-    const t = u(() => Math.min(Z.value / 2.25, F.value / 2.2) + "px"), R = u(() => Math.min(F.value / 3, Z.value / 6.4) + "px");
+    const t = G(() => Math.min(d.value / 2.25, F.value / 2.2) + "px"), R = G(() => Math.min(F.value / 3, d.value / 6.4) + "px");
     function a() {
-      const n = l.parseValue(Q.value), m = l.transformDisplayToSlider(n);
-      V.value = Math.min(Math.max(m, l.sliderMin), l.sliderMax);
+      const n = l.parseValue(V.value), m = l.transformDisplayToSlider(n);
+      Q.value = Math.min(Math.max(m, l.sliderMin), l.sliderMax);
     }
     return (n, m) => (X(), Y("div", {
       class: "outer",
@@ -4895,34 +4981,34 @@ const zU = {
       vl(h("input", {
         type: "text",
         class: "input",
-        "onUpdate:modelValue": m[0] || (m[0] = (b) => Q.value = b),
+        "onUpdate:modelValue": m[0] || (m[0] = (W) => V.value = W),
         inputmode: "decimal",
         pattern: "\\d*",
         onChange: a
       }, null, 544), [
-        [Kl, Q.value]
+        [Kl, V.value]
       ]),
-      h("div", fU, K(d.title), 1),
+      h("div", fU, K(Z.title), 1),
       C(bl, {
         class: "slider",
-        value: V.value,
-        "onUpdate:value": m[1] || (m[1] = (b) => V.value = b),
-        "thumb-length": d.thumbLength,
-        max: d.sliderMax,
-        min: d.sliderMin
+        value: Q.value,
+        "onUpdate:value": m[1] || (m[1] = (W) => Q.value = W),
+        "thumb-length": Z.thumbLength,
+        max: Z.sliderMax,
+        min: Z.sliderMin
       }, null, 8, ["value", "thumb-length", "max", "min"])
     ], 512));
   }
 }, ql = /* @__PURE__ */ g(AU, [["__scopeId", "data-v-79c7a539"]]), qU = {
   __name: "SpeedInput",
-  setup(d) {
-    const l = Ul(), U = Rl(), F = u({
+  setup(Z) {
+    const l = Ul(), U = Rl(), F = G({
       get: () => Math.log2(l.playbackSpeed) * 0.5 + 0.5,
       set: (a) => {
         const n = Math.pow(2, a * 2 - 1);
         U.setPlaybackSpeed(n);
       }
-    }), Z = (a) => Math.floor(Math.pow(2, a * 2 - 1) * 100 + 0.5) + "", V = (a) => parseFloat(a), Q = (a) => a.replace(/\D/g, ""), t = (a) => a, R = (a) => {
+    }), d = (a) => Math.floor(Math.pow(2, a * 2 - 1) * 100 + 0.5) + "", Q = (a) => parseFloat(a), V = (a) => a.replace(/\D/g, ""), t = (a) => a, R = (a) => {
       const n = Math.log2(a / 100) * 0.5 + 0.5;
       return Math.min(Math.max(n, 0), 1);
     };
@@ -4932,9 +5018,9 @@ const zU = {
       title: "Speed",
       color: "#336",
       "text-color": "#aad",
-      "format-value": Z,
-      "parse-value": V,
-      "validate-input": Q,
+      "format-value": d,
+      "parse-value": Q,
+      "validate-input": V,
       "transform-slider-to-display": t,
       "transform-display-to-slider": R,
       "thumb-length": 2,
@@ -4943,8 +5029,8 @@ const zU = {
   }
 }, _U = {
   __name: "TimeInput",
-  setup(d) {
-    const l = Ul(), U = tl(), F = Rl(), Z = (a) => a.toFixed(1), V = (a) => parseFloat(a), Q = (a) => a.replace(/[^0-9.]/g, ""), t = (a) => a, R = (a) => a;
+  setup(Z) {
+    const l = Ul(), U = tl(), F = Rl(), d = (a) => a.toFixed(1), Q = (a) => parseFloat(a), V = (a) => a.replace(/[^0-9.]/g, ""), t = (a) => a, R = (a) => a;
     return (a, n) => (X(), nl(ql, {
       value: r(l).currentTime,
       "onUpdate:value": [
@@ -4958,9 +5044,9 @@ const zU = {
       "background-color": "#111117",
       "slider-max": r(U).totalDuration,
       "slider-min": 0,
-      "format-value": Z,
-      "parse-value": V,
-      "validate-input": Q,
+      "format-value": d,
+      "parse-value": Q,
+      "validate-input": V,
       "transform-slider-to-display": t,
       "transform-display-to-slider": R,
       "thumb-length": 2
@@ -4968,16 +5054,16 @@ const zU = {
   }
 }, $U = { class: "inner" }, lF = {
   __name: "AudioButton",
-  setup(d) {
+  setup(Z) {
     const l = x(!1), U = () => l.value = !0, F = () => l.value = !1;
-    return (Z, V) => (X(), Y("div", {
+    return (d, Q) => (X(), Y("div", {
       class: L(["button-outer", { down: l.value }]),
       onPointerdown: U,
       onPointerup: F,
       onPointerleave: F
     }, [
       h("div", $U, [
-        Vl(Z.$slots, "default", {}, void 0, !0)
+        Vl(d.$slots, "default", {}, void 0, !0)
       ])
     ], 34));
   }
@@ -4986,27 +5072,27 @@ const zU = {
   viewBox: "0 0 48 48"
 }, QF = ["d"], VF = {
   __name: "MixerControls",
-  setup(d) {
+  setup(Z) {
     const l = tl(), U = Ul(), F = Rl();
-    function Z() {
+    function d() {
       U.isPlaying ? F.stop() : F.play();
     }
-    function V() {
-      const y = U.currentTime, G = l.beats.filter((E) => E.beat === 1).sort((E, H) => E.time - H.time);
+    function Q() {
+      const y = U.currentTime, u = l.beats.filter((E) => E.beat === 1).sort((E, H) => E.time - H.time);
       let k = null;
-      for (let E = G.length - 1; E >= 0; E--)
-        if (G[E].time < y) {
-          k = G[E];
+      for (let E = u.length - 1; E >= 0; E--)
+        if (u[E].time < y) {
+          k = u[E];
           break;
         }
       k && F.setBar(k.bar, k.repeat);
     }
-    function Q() {
-      const y = U.currentTime, G = l.beats.filter((E) => E.beat === 1).sort((E, H) => E.time - H.time);
+    function V() {
+      const y = U.currentTime, u = l.beats.filter((E) => E.beat === 1).sort((E, H) => E.time - H.time);
       let k = null;
-      for (let E = 0; E < G.length; E++)
-        if (G[E].time > y) {
-          k = G[E];
+      for (let E = 0; E < u.length; E++)
+        if (u[E].time > y) {
+          k = u[E];
           break;
         }
       k && F.setBar(k.bar, k.repeat);
@@ -5014,8 +5100,8 @@ const zU = {
     function t() {
       F.playStartingNotes();
     }
-    const R = u(() => U.metronomeEnabled), a = u(() => U.leadInEnabled), n = x(!1), m = x(null);
-    function b() {
+    const R = G(() => U.metronomeEnabled), a = G(() => U.leadInEnabled), n = x(!1), m = x(null);
+    function W() {
       n.value = !n.value, n.value && F.audioEngine.initializeAudioSystem().catch((y) => {
         console.warn("Audio system pre-initialization failed:", y);
       });
@@ -5037,14 +5123,14 @@ const zU = {
     function J() {
       F.toggleLeadIn();
     }
-    const p = u({
+    const p = G({
       get: () => U.masterVolume,
       set: (y) => U.setMasterVolume(y)
-    }), M = u({
+    }), M = G({
       get: () => U.metronomeVolume,
       set: (y) => U.setMetronomeVolume(y)
     });
-    return (y, G) => (X(), Y("div", UF, [
+    return (y, u) => (X(), Y("div", UF, [
       h("div", FF, [
         C(wl, {
           class: "text",
@@ -5063,8 +5149,8 @@ const zU = {
           (X(), Y("svg", {
             class: "menu",
             viewBox: "0 -960 960 960",
-            onClick: b
-          }, G[2] || (G[2] = [
+            onClick: W
+          }, u[2] || (u[2] = [
             h("path", { d: "M120-240v-80h720v80H120Zm0-200v-80h720v80H120Zm0-200v-80h720v80H120Z" }, null, -1)
           ]))),
           n.value && y.$slots.menu ? (X(), Y("div", {
@@ -5080,25 +5166,25 @@ const zU = {
         class: "main",
         colour: "red",
         value: p.value,
-        "onUpdate:value": G[0] || (G[0] = (k) => p.value = k)
+        "onUpdate:value": u[0] || (u[0] = (k) => p.value = k)
       }, null, 8, ["value"]),
       C(bl, {
         class: "tick",
         colour: "blue",
         value: M.value,
-        "onUpdate:value": G[1] || (G[1] = (k) => M.value = k)
+        "onUpdate:value": u[1] || (u[1] = (k) => M.value = k)
       }, null, 8, ["value"]),
-      G[8] || (G[8] = h("div", { class: "main-t" }, "Main", -1)),
-      G[9] || (G[9] = h("div", { class: "tick-t" }, "Tick", -1)),
+      u[8] || (u[8] = h("div", { class: "main-t" }, "Main", -1)),
+      u[9] || (u[9] = h("div", { class: "tick-t" }, "Tick", -1)),
       C(OU, { class: "bar" }),
       C(_U, { class: "time" }),
       C(qU, { class: "speed" }),
       h("div", dF, [
         C(Fl, {
           class: "button",
-          onClick: V
+          onClick: Q
         }, {
-          default: D(() => G[3] || (G[3] = [
+          default: D(() => u[3] || (u[3] = [
             h("svg", {
               class: "icon",
               viewBox: "0 0 48 48"
@@ -5111,7 +5197,7 @@ const zU = {
         }),
         C(Fl, {
           class: "button",
-          onClick: Z
+          onClick: d
         }, {
           default: D(() => [
             (X(), Y("svg", ZF, [
@@ -5124,9 +5210,9 @@ const zU = {
         }),
         C(Fl, {
           class: "button",
-          onClick: Q
+          onClick: V
         }, {
-          default: D(() => G[4] || (G[4] = [
+          default: D(() => u[4] || (u[4] = [
             h("svg", {
               class: "icon",
               viewBox: "0 0 48 48"
@@ -5145,7 +5231,7 @@ const zU = {
             (X(), Y("svg", {
               class: L(["icon", R.value ? "on" : "off"]),
               viewBox: "-128 -128 768 768"
-            }, G[5] || (G[5] = [
+            }, u[5] || (u[5] = [
               h("path", { d: "m 463.84136,154.89339 c -6.42,-6.42 -16.83,-6.42 -23.251,0 -71.31197,70.35135 -136.61146,132.25426 -208.741,199.7 h -105.82 c 23.35495,-140.1063 67.13099,-217.59716 120.727,-318.357996 0.86,-0.803 2.209,-0.801 3.067,-10e-4 20.50653,37.383983 48.51152,88.812606 72.26194,147.190756 1.186,9.002 12.2214,17.4338 23.3242,11.71391 9.002,-1.186 11.1594,-12.2324 9.9724,-21.2344 -21.69905,-53.89113 -30.43965,-85.078342 -83.11454,-161.702266 -13.446,-12.55299965 -34.508,-12.55699965 -47.954,10e-4 C 126.80877,149.30021 96.099465,324.74626 77.091365,474.25139 c -2.829,21.473 13.907,40.535 35.543995,40.535 h 271.311 c 21.661,0 38.373,-19.087 35.544,-40.535 -8.26237,-52.34207 -14.88466,-100.7074 -24.7871,-157.02622 -6.40949,-11.78839 -8.3911,-14.9907 -17.4031,-13.8037 -9.002,1.186 -13.59751,8.0528 -12.41051,17.0548 l 5.66371,34.11712 h -83.159 c 64.35441,-63.86663 129.29308,-130.29894 176.448,-176.449 6.42,-6.42 6.42,-16.83 -10e-4,-23.251 z m -88.956,232.582 12.004,91.074 c 0.112,0.846 -0.148,1.701 -0.708,2.341 -0.566,0.645 -1.38,1.014 -2.235,1.014 h -271.311 c -0.855,0 -1.668,-0.369 -2.231,-1.011 -0.564,-0.643 -0.824,-1.499 -0.712,-2.347 l 12.003,-91.072 h 253.19 z" }, null, -1)
             ]), 2))
           ]),
@@ -5159,7 +5245,7 @@ const zU = {
             (X(), Y("svg", {
               class: L(["icon", a.value ? "on" : "off"]),
               viewBox: "-2 -2 28 28"
-            }, G[6] || (G[6] = [
+            }, u[6] || (u[6] = [
               h("path", { d: "m 8.9838564,1.5166215 v 2 h 5.9999996 v -2 z m 2.9999996,3 c -4.9699996,0 -8.9999996,4.0299999 -8.9999996,8.9999995 0,4.97 4.02,9 8.9999996,9 4.98,0 9,-4.03 9,-9 0,-2.12 -0.740703,-4.0693745 -1.970703,-5.6093745 l 1.419922,-1.421875 c -0.43,-0.51 -0.900156,-0.9882031 -1.410156,-1.4082031 l -1.419922,1.4199219 c -1.55,-1.24 -3.499141,-1.9804688 -5.619141,-1.9804688 z m -1.789062,4.7480469 6,4.4999996 -6,4.5 z" }, null, -1)
             ]), 2))
           ]),
@@ -5169,7 +5255,7 @@ const zU = {
           class: "button",
           onClick: t
         }, {
-          default: D(() => G[7] || (G[7] = [
+          default: D(() => u[7] || (u[7] = [
             h("svg", {
               class: "icon",
               viewBox: "0 -960 960 960"
@@ -5216,9 +5302,9 @@ const zU = {
       default: null
     }
   },
-  setup(d) {
-    const l = d, U = u(() => l.progress !== null), F = u(() => l.progress === null ? 0 : Math.max(0, Math.min(100, l.progress * 100))), Z = u(() => l.hasError ? l.errorMessage : l.message);
-    return (V, Q) => (X(), Y("div", RF, [
+  setup(Z) {
+    const l = Z, U = G(() => l.progress !== null), F = G(() => l.progress === null ? 0 : Math.max(0, Math.min(100, l.progress * 100))), d = G(() => l.hasError ? l.errorMessage : l.message);
+    return (Q, V) => (X(), Y("div", RF, [
       U.value ? (X(), Y("div", aF, [
         h("div", {
           class: "progress-fill",
@@ -5227,8 +5313,8 @@ const zU = {
       ])) : f("", !0),
       h("div", nF, [
         h("div", {
-          class: L(["message", { error: d.hasError }])
-        }, K(Z.value), 3)
+          class: L(["message", { error: Z.hasError }])
+        }, K(d.value), 3)
       ])
     ]));
   }
@@ -5256,15 +5342,15 @@ const zU = {
      * @param {string} event.message - Human-readable message
      * @param {number} [event.progress] - Optional progress (0-1)
      */
-    updateProgress(d) {
-      this.currentStage = d.stage, this.message = d.message, this.progress = d.progress ?? null, d.stage === "ready" ? (this.isInitializing = !1, this.isReady = !0) : (this.isInitializing = !0, this.isReady = !1), this.hasError = !1, this.errorMessage = null;
+    updateProgress(Z) {
+      this.currentStage = Z.stage, this.message = Z.message, this.progress = Z.progress ?? null, Z.stage === "ready" ? (this.isInitializing = !1, this.isReady = !0) : (this.isInitializing = !0, this.isReady = !1), this.hasError = !1, this.errorMessage = null;
     },
     /**
      * Set error state
      * @param {string} message - Error message
      */
-    setError(d) {
-      this.hasError = !0, this.errorMessage = d, this.isInitializing = !1, this.isReady = !1;
+    setError(Z) {
+      this.hasError = !0, this.errorMessage = Z, this.isInitializing = !1, this.isReady = !1;
     },
     /**
      * Reset initialization state
@@ -5277,8 +5363,8 @@ const zU = {
      * Should be called once during app startup
      */
     initializeListeners() {
-      e.on("initProgress", (d) => {
-        this.updateProgress(d);
+      e.on("initProgress", (Z) => {
+        this.updateProgress(Z);
       });
     }
   },
@@ -5286,17 +5372,17 @@ const zU = {
     /**
      * Whether to show the progress indicator
      */
-    shouldShowProgress: (d) => d.isInitializing || d.hasError,
+    shouldShowProgress: (Z) => Z.isInitializing || Z.hasError,
     /**
      * Whether the progress bar should be visible
      * Only show for stages that have progress data
      */
-    hasProgressBar: (d) => d.progress !== null
+    hasProgressBar: (Z) => Z.progress !== null
   }
 }), cF = { class: "container" }, eF = { class: "panel" }, sF = {
   key: 0,
   class: "blur"
-}, rl = 40, Ll = 40, Cl = 100, hF = 50, xl = 400, Ml = 570, zl = 570, BF = 350, JF = 330, GF = 360, uF = 360, iF = {
+}, rl = 40, Ll = 40, Cl = 100, hF = 50, xl = 400, Ml = 570, zl = 570, BF = 350, JF = 330, uF = 360, GF = 360, iF = {
   __name: "MixerLayout",
   props: {
     /** Whether to show initialization progress (default: true) */
@@ -5305,31 +5391,31 @@ const zU = {
       default: !0
     }
   },
-  setup(d) {
-    $((b) => ({
+  setup(Z) {
+    $((W) => ({
       "53ffcc08": a.value,
       "53f8f922": n.value,
       "2b0b3d37": m.value
     }));
-    const l = d, U = tl(), F = Ul(), Z = bF();
+    const l = Z, U = tl(), F = Ul(), d = bF();
     el(() => {
-      Z.initializeListeners();
+      d.initializeListeners();
     });
-    const V = O("container"), { width: Q } = ll(V), t = u(() => F.isLoaded), R = u(() => {
-      const b = Q.value, c = U.parts.length;
-      return b < 640 || b < rl * c + xl ? 0 : b < Ll * c + Ml ? 1 : b < Cl * c + zl ? 2 : 3;
-    }), a = u(() => {
+    const Q = O("container"), { width: V } = ll(Q), t = G(() => F.isLoaded), R = G(() => {
+      const W = V.value, c = U.parts.length;
+      return W < 640 || W < rl * c + xl ? 0 : W < Ll * c + Ml ? 1 : W < Cl * c + zl ? 2 : 3;
+    }), a = G(() => {
       switch (R.value) {
         case 0:
           return `${BF}px ` + `${hF}px `.repeat(U.parts.length);
         case 1:
           return `${JF}px`;
         case 2:
-          return `${GF}px`;
-        default:
           return `${uF}px`;
+        default:
+          return `${GF}px`;
       }
-    }), n = u(() => {
+    }), n = G(() => {
       switch (R.value) {
         case 0:
           return "100vw";
@@ -5340,14 +5426,14 @@ const zU = {
         default:
           return `${Cl}px `.repeat(U.parts.length) + `${zl}px`;
       }
-    }), m = u(() => {
-      const b = [...U.parts.keys()];
-      return R.value > 0 ? '"' + b.map((c) => "part" + c).join(" ") + ' controls"' : '"controls" ' + b.map((c) => '"part' + c + '"').join(" ");
+    }), m = G(() => {
+      const W = [...U.parts.keys()];
+      return R.value > 0 ? '"' + W.map((c) => "part" + c).join(" ") + ' controls"' : '"controls" ' + W.map((c) => '"part' + c + '"').join(" ");
     });
-    return (b, c) => (X(), Y("div", {
+    return (W, c) => (X(), Y("div", {
       class: "outer",
       ref_key: "container",
-      ref: V
+      ref: Q
     }, [
       h("div", cF, [
         h("div", eF, [
@@ -5369,18 +5455,18 @@ const zU = {
             class: "controls"
           }, {
             menu: D(() => [
-              Vl(b.$slots, "menu", {}, void 0, !0)
+              Vl(W.$slots, "menu", {}, void 0, !0)
             ]),
             _: 3
           }, 8, ["title"]),
           t.value ? f("", !0) : (X(), Y("div", sF)),
-          l.showInitProgress && r(Z).shouldShowProgress ? (X(), nl(WF, {
+          l.showInitProgress && r(d).shouldShowProgress ? (X(), nl(WF, {
             key: 1,
-            stage: r(Z).currentStage,
-            message: r(Z).message,
-            progress: r(Z).progress,
-            "has-error": r(Z).hasError,
-            "error-message": r(Z).errorMessage
+            stage: r(d).currentStage,
+            message: r(d).message,
+            progress: r(d).progress,
+            "has-error": r(d).hasError,
+            "error-message": r(d).errorMessage
           }, null, 8, ["stage", "message", "progress", "has-error", "error-message"])) : f("", !0)
         ])
       ])
@@ -5401,14 +5487,14 @@ const zU = {
       default: ""
     }
   },
-  setup(d) {
+  setup(Z) {
     return $((l) => ({
-      "66bea586": d.colour
+      "66bea586": Z.colour
     })), (l, U) => (X(), Y("div", SF, [
       h("div", oF, [
         h("div", XF, [
-          d.text || l.$slots.default ? (X(), Y("div", NF, [
-            ol(K(d.text) + " ", 1),
+          Z.text || l.$slots.default ? (X(), Y("div", NF, [
+            ol(K(Z.text) + " ", 1),
             Vl(l.$slots, "default", {}, void 0, !0)
           ])) : f("", !0)
         ])
@@ -5424,7 +5510,7 @@ class YF {
   initialize(l) {
     if (this.musicData = l, this.beats = l.beats || [], this.practiceMarks = l.practiceMarks || {}, this.beats.length > 0) {
       const U = this.beats[this.beats.length - 1], F = U.tempo > 0 ? 60 / U.tempo : 0.75;
-      this.songDuration = U.time + F, this.maxBar = Math.max(...this.beats.map((Z) => Z.bar));
+      this.songDuration = U.time + F, this.maxBar = Math.max(...this.beats.map((d) => d.bar));
     } else
       this.songDuration = 0, this.maxBar = 0;
     l.parts && l.parts.forEach((U) => {
@@ -5522,8 +5608,8 @@ class YF {
         return;
       }
       this.eventBus.emit("timeChanged", { currentTime: this.currentTime });
-      const Z = this.getBarFromTime(this.currentTime);
-      if (Z && (this.eventBus.emit("barChanged", Z), this.maxBar > 0 && Z.bar > this.maxBar)) {
+      const d = this.getBarFromTime(this.currentTime);
+      if (d && (this.eventBus.emit("barChanged", d), this.maxBar > 0 && d.bar > this.maxBar)) {
         this.stop(), this.eventBus.emit("songEnded", { finalTime: this.currentTime });
         return;
       }
@@ -5552,10 +5638,10 @@ class YF {
   getTimeFromBar(l, U = 0) {
     if (!this.beats || this.beats.length === 0) return null;
     let F = this.beats.find(
-      (Z) => Z.bar === l && Z.beat === 1 && Z.repeat === U
+      (d) => d.bar === l && d.beat === 1 && d.repeat === U
     );
     return F || (F = this.beats.find(
-      (Z) => Z.bar === l && Z.beat === 1
+      (d) => d.bar === l && d.beat === 1
     )), F ? F.time : null;
   }
   destroy() {
@@ -5568,7 +5654,7 @@ export {
   bl as AudioSlider,
   OU as BarInput,
   ql as BaseNumericInput,
-  ul as DEV_MODE,
+  Gl as DEV_MODE,
   YF as DummyAudioEngine,
   WF as InitializationProgress,
   tF as MixerControls,