@libraz/libcantus 0.9.4 → 0.9.5

package/dist/{chunk-ZEJR4TKL.cjs → chunk-357ZDPVU.cjs}

@@ -5,35 +5,30 @@
 
 
 
-var _chunkCAN76NCUcjs = require('./chunk-CAN76NCU.cjs');
+var _chunkKQN2ZYNDcjs = require('./chunk-KQN2ZYND.cjs');
 
 
 
 
 
-var _chunkFNDWXRRIcjs = require('./chunk-FNDWXRRI.cjs');
+var _chunkBSLTLGM3cjs = require('./chunk-BSLTLGM3.cjs');
 
 
-var _chunk7MGZ7D62cjs = require('./chunk-7MGZ7D62.cjs');
+var _chunkPI3UXRWKcjs = require('./chunk-PI3UXRWK.cjs');
 
 // src/generate/reharmony/index.ts
 function hasInterval(chord, semitone) {
-  return chord.intervals.some((iv) => _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, iv) === semitone);
+  return chord.intervals.some((iv) => _chunkPI3UXRWKcjs.pitchClassOf.call(void 0, iv) === semitone);
 }
 function isDominantType(chord) {
   return hasInterval(chord, 4) && hasInterval(chord, 10);
 }
-function isStableTarget(chord) {
-  const hasFifth = hasInterval(chord, 7);
-  const hasThird = hasInterval(chord, 3) || hasInterval(chord, 4);
-  return hasFifth && hasThird && !isDominantType(chord);
-}
 function commonToneCount(a, b) {
   const set = new Set(b);
   return a.filter((pc) => set.has(pc)).length;
 }
 function triadQualityOf(chord) {
-  const semis = new Set(chord.intervals.map((interval) => _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, interval)));
+  const semis = new Set(chord.intervals.map((interval) => _chunkPI3UXRWKcjs.pitchClassOf.call(void 0, interval)));
   const hasThird = semis.has(4) ? "maj" : semis.has(3) ? "min" : void 0;
   if (hasThird === void 0) {
     return chord.quality;
@@ -47,63 +42,57 @@ function triadQualityOf(chord) {
   return hasThird;
 }
 function diatonicTriadsOf(key) {
-  const degrees = _chunkFNDWXRRIcjs.scaleTonesInDegreeOrder.call(void 0, key).length;
+  const degrees = _chunkBSLTLGM3cjs.scaleTonesInDegreeOrder.call(void 0, key).length;
   const triads = [];
   for (let degree = 0; degree < degrees; degree += 1) {
-    triads.push(_chunkFNDWXRRIcjs.diatonicTriad.call(void 0, degree, key));
+    triads.push(_chunkBSLTLGM3cjs.diatonicTriad.call(void 0, degree, key));
   }
   return triads;
 }
 function sameChord(a, b) {
-  return _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, a.rootPc) === _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, b.rootPc) && a.quality === b.quality;
+  return _chunkPI3UXRWKcjs.pitchClassOf.call(void 0, a.rootPc) === _chunkPI3UXRWKcjs.pitchClassOf.call(void 0, b.rootPc) && a.quality === b.quality;
 }
 var THIRD_OFFSETS = [3, 4, 8, 9];
 function substituteChord(chord, key, opts) {
-  const originalTriad = _chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, _chunkFNDWXRRIcjs.makeChord.call(void 0, chord.rootPc, triadQualityOf(chord)));
+  const originalTriad = _chunkBSLTLGM3cjs.chordPitchClasses.call(void 0, _chunkBSLTLGM3cjs.makeChord.call(void 0, chord.rootPc, triadQualityOf(chord)));
   const candidates = [];
   if (isDominantType(chord)) {
-    candidates.push({ chord: _chunkFNDWXRRIcjs.makeChord.call(void 0, _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, chord.rootPc + 6), "dom7"), type: "tritone" });
-  }
-  if (isStableTarget(chord)) {
-    candidates.push({
-      chord: _chunkFNDWXRRIcjs.makeChord.call(void 0, _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, chord.rootPc + 7), "dom7"),
-      type: "secondaryDominant"
-    });
+    candidates.push({ chord: _chunkBSLTLGM3cjs.makeChord.call(void 0, _chunkPI3UXRWKcjs.pitchClassOf.call(void 0, chord.rootPc + 6), "dom7"), type: "tritone" });
   }
   for (const triad of diatonicTriadsOf(key)) {
-    const offset = _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, triad.rootPc - chord.rootPc);
-    if (THIRD_OFFSETS.includes(offset) && commonToneCount(originalTriad, _chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, triad)) === 2) {
+    const offset = _chunkPI3UXRWKcjs.pitchClassOf.call(void 0, triad.rootPc - chord.rootPc);
+    if (THIRD_OFFSETS.includes(offset) && commonToneCount(originalTriad, _chunkBSLTLGM3cjs.chordPitchClasses.call(void 0, triad)) === 2) {
       candidates.push({ chord: triad, type: "relative" });
     }
   }
-  const targetFunction = _chunkCAN76NCUcjs.functionOf.call(void 0, chord, key);
-  for (const triad of diatonicTriadsOf(_chunkCAN76NCUcjs.parallelKey.call(void 0, key))) {
-    if (_chunkCAN76NCUcjs.functionOf.call(void 0, triad, key) === targetFunction && !_chunkCAN76NCUcjs.isDiatonic.call(void 0, triad, key)) {
+  const targetFunction = _chunkKQN2ZYNDcjs.functionOf.call(void 0, chord, key);
+  for (const triad of diatonicTriadsOf(_chunkKQN2ZYNDcjs.parallelKey.call(void 0, key))) {
+    if (_chunkKQN2ZYNDcjs.functionOf.call(void 0, triad, key) === targetFunction && !_chunkKQN2ZYNDcjs.isDiatonic.call(void 0, triad, key)) {
       candidates.push({ chord: triad, type: "borrowed" });
     }
   }
   for (const offset of THIRD_OFFSETS) {
     for (const quality of ["maj", "min"]) {
-      const mediant = _chunkFNDWXRRIcjs.makeChord.call(void 0, _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, chord.rootPc + offset), quality);
-      if (commonToneCount(originalTriad, _chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, mediant)) === 1 && !_chunkCAN76NCUcjs.isDiatonic.call(void 0, mediant, key)) {
+      const mediant = _chunkBSLTLGM3cjs.makeChord.call(void 0, _chunkPI3UXRWKcjs.pitchClassOf.call(void 0, chord.rootPc + offset), quality);
+      if (commonToneCount(originalTriad, _chunkBSLTLGM3cjs.chordPitchClasses.call(void 0, mediant)) === 1 && !_chunkKQN2ZYNDcjs.isDiatonic.call(void 0, mediant, key)) {
         candidates.push({ chord: mediant, type: "chromaticMediant" });
       }
     }
   }
-  const melodyPcs = _optionalChain([opts, 'optionalAccess', _ => _.melodyPcs, 'optionalAccess', _2 => _2.map, 'call', _3 => _3(_chunk7MGZ7D62cjs.pitchClassOf)]);
+  const melodyPcs = _optionalChain([opts, 'optionalAccess', _ => _.melodyPcs, 'optionalAccess', _2 => _2.map, 'call', _3 => _3(_chunkPI3UXRWKcjs.pitchClassOf)]);
   const seen = /* @__PURE__ */ new Set();
   const results = [];
   for (const candidate of candidates) {
     if (sameChord(candidate.chord, chord)) {
       continue;
     }
-    const dedupeKey = `${_chunk7MGZ7D62cjs.pitchClassOf.call(void 0, candidate.chord.rootPc)}:${candidate.chord.quality}`;
+    const dedupeKey = `${_chunkPI3UXRWKcjs.pitchClassOf.call(void 0, candidate.chord.rootPc)}:${candidate.chord.quality}`;
     if (seen.has(dedupeKey)) {
       continue;
     }
     seen.add(dedupeKey);
     if (melodyPcs !== void 0) {
-      const pcs = new Set(_chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, candidate.chord));
+      const pcs = new Set(_chunkBSLTLGM3cjs.chordPitchClasses.call(void 0, candidate.chord));
       if (!melodyPcs.every((pc) => pcs.has(pc))) {
         continue;
       }
@@ -114,10 +103,10 @@ function substituteChord(chord, key, opts) {
       // A secondary dominant is named as the applied chord it is, so the
       // numeral re-parses to the chord that was proposed rather than to a
       // chromatic chord on the same root.
-      roman: _chunkCAN76NCUcjs.chordToRoman.call(void 0, candidate.chord, key, {
+      roman: _chunkKQN2ZYNDcjs.chordToRoman.call(void 0, candidate.chord, key, {
         applied: candidate.type === "secondaryDominant"
       }),
-      function: _chunkCAN76NCUcjs.functionOf.call(void 0, candidate.chord, key)
+      function: _chunkKQN2ZYNDcjs.functionOf.call(void 0, candidate.chord, key)
     });
   }
   return results;
@@ -126,43 +115,43 @@ function modalInterchangePalette(key) {
   const palette = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (chord) => {
-    const dedupeKey = `${_chunk7MGZ7D62cjs.pitchClassOf.call(void 0, chord.rootPc)}:${chord.quality}`;
+    const dedupeKey = `${_chunkPI3UXRWKcjs.pitchClassOf.call(void 0, chord.rootPc)}:${chord.quality}`;
     if (seen.has(dedupeKey)) {
       return;
     }
     seen.add(dedupeKey);
     palette.push({
       chord,
-      roman: _chunkCAN76NCUcjs.chordToRoman.call(void 0, chord, key),
-      source: _chunkCAN76NCUcjs.borrowedSource.call(void 0, chord, key)
+      roman: _chunkKQN2ZYNDcjs.chordToRoman.call(void 0, chord, key),
+      source: _chunkKQN2ZYNDcjs.borrowedSource.call(void 0, chord, key)
     });
   };
-  for (const triad of diatonicTriadsOf(_chunkCAN76NCUcjs.parallelKey.call(void 0, key))) {
-    if (!_chunkCAN76NCUcjs.isDiatonic.call(void 0, triad, key)) {
+  for (const triad of diatonicTriadsOf(_chunkKQN2ZYNDcjs.parallelKey.call(void 0, key))) {
+    if (!_chunkKQN2ZYNDcjs.isDiatonic.call(void 0, triad, key) && _chunkKQN2ZYNDcjs.borrowedSource.call(void 0, triad, key) !== null) {
       add(triad);
     }
   }
-  const neapolitan = _chunkFNDWXRRIcjs.makeChord.call(void 0, _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, key.rootPc + 1), "maj");
-  if (!_chunkCAN76NCUcjs.isDiatonic.call(void 0, neapolitan, key)) {
+  const neapolitan = _chunkBSLTLGM3cjs.makeChord.call(void 0, _chunkPI3UXRWKcjs.pitchClassOf.call(void 0, key.rootPc + 1), "maj");
+  if (!_chunkKQN2ZYNDcjs.isDiatonic.call(void 0, neapolitan, key)) {
     add(neapolitan);
   }
   return palette;
 }
 function negativeHarmonyMirror(chord, key) {
-  const tonic = _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, key.rootPc);
-  const mirror = (p) => _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, 2 * tonic + 7 - p);
-  const pcs = _chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, chord).map(mirror);
+  const tonic = _chunkPI3UXRWKcjs.pitchClassOf.call(void 0, key.rootPc);
+  const mirror = (p) => _chunkPI3UXRWKcjs.pitchClassOf.call(void 0, 2 * tonic + 7 - p);
+  const pcs = _chunkBSLTLGM3cjs.chordPitchClasses.call(void 0, chord).map(mirror);
   const bassPc = chord.bassPc !== void 0 ? mirror(chord.bassPc) : void 0;
   const pitches = bassPc !== void 0 ? [bassPc - 12, ...pcs] : pcs;
-  const detected = _chunkCAN76NCUcjs.detectChordBest.call(void 0, pitches);
+  const detected = _chunkKQN2ZYNDcjs.detectChordBest.call(void 0, pitches);
   if (detected) {
     if (bassPc === void 0 && detected.bassPc !== void 0) {
-      return _chunkFNDWXRRIcjs.makeChord.call(void 0, detected.rootPc, detected.quality);
+      return _chunkBSLTLGM3cjs.makeChord.call(void 0, detected.rootPc, detected.quality);
     }
     return detected;
   }
   const quality = chord.quality;
-  return _chunkFNDWXRRIcjs.makeChord.call(void 0, mirror(chord.rootPc), quality, bassPc);
+  return _chunkBSLTLGM3cjs.makeChord.call(void 0, mirror(chord.rootPc), quality, bassPc);
 }
 
 
@@ -170,4 +159,4 @@ function negativeHarmonyMirror(chord, key) {
 
 
 exports.substituteChord = substituteChord; exports.modalInterchangePalette = modalInterchangePalette; exports.negativeHarmonyMirror = negativeHarmonyMirror;
-//# sourceMappingURL=chunk-ZEJR4TKL.cjs.map
+//# sourceMappingURL=chunk-357ZDPVU.cjs.map

package/dist/chunk-357ZDPVU.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/libcantus/libcantus/dist/chunk-357ZDPVU.cjs","../src/generate/reharmony/index.ts"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACF,wDAA6B;AAC7B;AACA;ACmDA,SAAS,WAAA,CAAY,KAAA,EAAc,QAAA,EAA2B;AAC5D,EAAA,OAAO,KAAA,CAAM,SAAA,CAAU,IAAA,CAAK,CAAC,EAAA,EAAA,GAAO,4CAAA,EAAQ,EAAA,IAAM,QAAQ,CAAA;AAC5D;AAGA,SAAS,cAAA,CAAe,KAAA,EAAuB;AAC7C,EAAA,OAAO,WAAA,CAAY,KAAA,EAAO,CAAC,EAAA,GAAK,WAAA,CAAY,KAAA,EAAO,EAAE,CAAA;AACvD;AAGA,SAAS,eAAA,CAAgB,CAAA,EAAa,CAAA,EAAqB;AACzD,EAAA,MAAM,IAAA,EAAM,IAAI,GAAA,CAAI,CAAC,CAAA;AACrB,EAAA,OAAO,CAAA,CAAE,MAAA,CAAO,CAAC,EAAA,EAAA,GAAO,GAAA,CAAI,GAAA,CAAI,EAAE,CAAC,CAAA,CAAE,MAAA;AACvC;AAGA,SAAS,cAAA,CAAe,KAAA,EAA4B;AAClD,EAAA,MAAM,MAAA,EAAQ,IAAI,GAAA,CAAI,KAAA,CAAM,SAAA,CAAU,GAAA,CAAI,CAAC,QAAA,EAAA,GAAa,4CAAA,QAAc,CAAC,CAAC,CAAA;AACxE,EAAA,MAAM,SAAA,EAAW,KAAA,CAAM,GAAA,CAAI,CAAC,EAAA,EAAI,MAAA,EAAQ,KAAA,CAAM,GAAA,CAAI,CAAC,EAAA,EAAI,MAAA,EAAQ,KAAA,CAAA;AAC/D,EAAA,GAAA,CAAI,SAAA,IAAa,KAAA,CAAA,EAAW;AAC1B,IAAA,OAAO,KAAA,CAAM,OAAA;AAAA,EACf;AACA,EAAA,GAAA,CAAI,KAAA,CAAM,GAAA,CAAI,CAAC,EAAA,GAAK,CAAC,KAAA,CAAM,GAAA,CAAI,CAAC,CAAA,EAAG;AACjC,IAAA,OAAO,SAAA,IAAa,MAAA,EAAQ,MAAA,EAAQ,OAAA;AAAA,EACtC;AACA,EAAA,GAAA,CAAI,KAAA,CAAM,GAAA,CAAI,CAAC,EAAA,GAAK,CAAC,KAAA,CAAM,GAAA,CAAI,CAAC,CAAA,EAAG;AACjC,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,OAAO,QAAA;AACT;AAGA,SAAS,gBAAA,CAAiB,GAAA,EAAwB;AAChD,EAAA,MAAM,QAAA,EAAU,uDAAA,GAA2B,CAAA,CAAE,MAAA;AAC7C,EAAA,MAAM,OAAA,EAAkB,CAAC,CAAA;AACzB,EAAA,IAAA,CAAA,IAAS,OAAA,EAAS,CAAA,EAAG,OAAA,EAAS,OAAA,EAAS,OAAA,GAAU,CAAA,EAAG;AAClD,IAAA,MAAA,CAAO,IAAA,CAAK,6CAAA,MAAc,EAAQ,GAAG,CAAC,CAAA;AAAA,EACxC;AACA,EAAA,OAAO,MAAA;AACT;AAGA,SAAS,SAAA,CAAU,CAAA,EAAU,CAAA,EAAmB;AAC9C,EAAA,OAAO,4CAAA,CAAM,CAAE,MAAM,EAAA,IAAM,4CAAA,CAAM,CAAE,MAAM,EAAA,GAAK,CAAA,CAAE,QAAA,IAAY,CAAA,CAAE,OAAA;AAChE;AAGA,IAAM,cAAA,EAAgB,CAAC,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAC,CAAA;AA8B1B,SAAS,eAAA,CACd,KAAA,EACA,GAAA,EACA,IAAA,EACgB;AAKhB,EAAA,MAAM,cAAA,EAAgB,iDAAA,yCAAkB,KAAU,CAAM,MAAA,EAAQ,cAAA,CAAe,KAAK,CAAC,CAAC,CAAA;AACtF,EAAA,MAAM,WAAA,EAAyD,CAAC,CAAA;AAGhE,EAAA,GAAA,CAAI,cAAA,CAAe,KAAK,CAAA,EAAG;AACzB,IAAA,UAAA,CAAW,IAAA,CAAK,EAAE,KAAA,EAAO,yCAAA,4CAAU,KAAM,CAAM,OAAA,EAAS,CAAC,CAAA,EAAG,MAAM,CAAA,EAAG,IAAA,EAAM,UAAU,CAAC,CAAA;AAAA,EACxF;AAGA,EAAA,IAAA,CAAA,MAAW,MAAA,GAAS,gBAAA,CAAiB,GAAG,CAAA,EAAG;AACzC,IAAA,MAAM,OAAA,EAAS,4CAAA,KAAM,CAAM,OAAA,EAAS,KAAA,CAAM,MAAM,CAAA;AAChD,IAAA,GAAA,CACG,aAAA,CAAoC,QAAA,CAAS,MAAM,EAAA,GACpD,eAAA,CAAgB,aAAA,EAAe,iDAAA,KAAuB,CAAC,EAAA,IAAM,CAAA,EAC7D;AACA,MAAA,UAAA,CAAW,IAAA,CAAK,EAAE,KAAA,EAAO,KAAA,EAAO,IAAA,EAAM,WAAW,CAAC,CAAA;AAAA,IACpD;AAAA,EACF;AAGA,EAAA,MAAM,eAAA,EAAiB,0CAAA,KAAW,EAAO,GAAG,CAAA;AAC5C,EAAA,IAAA,CAAA,MAAW,MAAA,GAAS,gBAAA,CAAiB,2CAAA,GAAe,CAAC,CAAA,EAAG;AACtD,IAAA,GAAA,CAAI,0CAAA,KAAW,EAAO,GAAG,EAAA,IAAM,eAAA,GAAkB,CAAC,0CAAA,KAAW,EAAO,GAAG,CAAA,EAAG;AACxE,MAAA,UAAA,CAAW,IAAA,CAAK,EAAE,KAAA,EAAO,KAAA,EAAO,IAAA,EAAM,WAAW,CAAC,CAAA;AAAA,IACpD;AAAA,EACF;AAGA,EAAA,IAAA,CAAA,MAAW,OAAA,GAAU,aAAA,EAAe;AAClC,IAAA,IAAA,CAAA,MAAW,QAAA,GAAW,CAAC,KAAA,EAAO,KAAK,CAAA,EAAY;AAC7C,MAAA,MAAM,QAAA,EAAU,yCAAA,4CAAU,KAAM,CAAM,OAAA,EAAS,MAAM,CAAA,EAAG,OAAO,CAAA;AAC/D,MAAA,GAAA,CACE,eAAA,CAAgB,aAAA,EAAe,iDAAA,OAAyB,CAAC,EAAA,IAAM,EAAA,GAC/D,CAAC,0CAAA,OAAW,EAAS,GAAG,CAAA,EACxB;AACA,QAAA,UAAA,CAAW,IAAA,CAAK,EAAE,KAAA,EAAO,OAAA,EAAS,IAAA,EAAM,mBAAmB,CAAC,CAAA;AAAA,MAC9D;AAAA,IACF;AAAA,EACF;AAEA,EAAA,MAAM,UAAA,kBAAY,IAAA,2BAAM,SAAA,6BAAW,GAAA,mBAAI,8BAAK,GAAA;AAC5C,EAAA,MAAM,KAAA,kBAAO,IAAI,GAAA,CAAY,CAAA;AAC7B,EAAA,MAAM,QAAA,EAA0B,CAAC,CAAA;AACjC,EAAA,IAAA,CAAA,MAAW,UAAA,GAAa,UAAA,EAAY;AAClC,IAAA,GAAA,CAAI,SAAA,CAAU,SAAA,CAAU,KAAA,EAAO,KAAK,CAAA,EAAG;AACrC,MAAA,QAAA;AAAA,IACF;AACA,IAAA,MAAM,UAAA,EAAY,CAAA,EAAA;AACL,IAAA;AACX,MAAA;AACF,IAAA;AACkB,IAAA;AACA,IAAA;AACA,MAAA;AACD,MAAA;AACb,QAAA;AACF,MAAA;AACF,IAAA;AACa,IAAA;AACM,MAAA;AACD,MAAA;AAAA;AAAA;AAAA;AAIT,MAAA;AACI,QAAA;AACV,MAAA;AACS,MAAA;AACX,IAAA;AACH,EAAA;AACO,EAAA;AACT;AAyBgB;AACoB,EAAA;AACrB,EAAA;AACA,EAAA;AACO,IAAA;AACL,IAAA;AACX,MAAA;AACF,IAAA;AACkB,IAAA;AACL,IAAA;AACX,MAAA;AACO,MAAA;AACC,MAAA;AACT,IAAA;AACH,EAAA;AAEoB,EAAA;AACF,IAAA;AACL,MAAA;AACX,IAAA;AACF,EAAA;AAImB,EAAA;AACH,EAAA;AACA,IAAA;AAChB,EAAA;AACO,EAAA;AACT;AAsBgB;AACA,EAAA;AACE,EAAA;AACJ,EAAA;AACS,EAAA;AAGL,EAAA;AACC,EAAA;AACH,EAAA;AAIG,IAAA;AACI,MAAA;AACnB,IAAA;AACO,IAAA;AACT,EAAA;AAC8B,EAAA;AACb,EAAA;AACnB;ADvKuB;AACA;AACA;AACA;AACA;AACA","file":"/home/runner/work/libcantus/libcantus/dist/chunk-357ZDPVU.cjs","sourcesContent":[null,"/**\n * Reharmonization: chord substitution, modal-interchange palettes, and negative\n * harmony. These transforms take an existing chord (or a key) and propose\n * alternative harmonies that preserve a chosen relationship — a shared function,\n * a common tone, a tonicizing dominant, or a reflection across the key axis.\n *\n * Roots are pitch classes (0..11); no spelled key signature is required.\n */\n\nimport { detectChordBest } from '../../analyze/detect/index.js';\nimport {\n  type BorrowedSource,\n  borrowedSource,\n  chordToRoman,\n  functionOf,\n  type HarmonicFunction,\n  isDiatonic,\n  parallelKey,\n} from '../../analyze/functional/index.js';\nimport { pitchClassOf as mod12 } from '../../core/pitch/index.js';\nimport type { KeyScale } from '../../core/types.js';\nimport {\n  type Chord,\n  type ChordQuality,\n  chordPitchClasses,\n  diatonicTriad,\n  makeChord,\n} from '../../theory/chord/index.js';\nimport { scaleTonesInDegreeOrder } from '../../theory/scale/index.js';\n\n/**\n * The kind of substitution relationship a candidate realizes.\n *\n * @category Reharmonization\n */\nexport type SubstitutionType =\n  | 'tritone'\n  | 'relative'\n  | 'borrowed'\n  | 'chromaticMediant'\n  | 'secondaryDominant';\n\n/**\n * A proposed chord substitution with its relationship, numeral, and function.\n *\n * @category Reharmonization\n */\nexport type Substitution = {\n  chord: Chord;\n  type: SubstitutionType;\n  roman: string;\n  function: HarmonicFunction;\n};\n\n/**\n * Options controlling which substitutions {@link substituteChord} returns.\n *\n * @category Reharmonization\n */\nexport type SubstituteOptions = {\n  /**\n   * Melody pitch classes that must remain chord tones. When given, only\n   * substitutions whose pitch classes contain every listed pitch class are\n   * kept, so the melody stays consonant against the new harmony.\n   */\n  melodyPcs?: number[];\n};\n\n/** Whether the chord's template carries a given interval (mod 12). */\nfunction hasInterval(chord: Chord, semitone: number): boolean {\n  return chord.intervals.some((iv) => mod12(iv) === semitone);\n}\n\n/** Whether a chord is a dominant type: a major third with a minor seventh. */\nfunction isDominantType(chord: Chord): boolean {\n  return hasInterval(chord, 4) && hasInterval(chord, 10);\n}\n\n/** Count the pitch classes shared between two pitch-class sets. */\nfunction commonToneCount(a: number[], b: number[]): number {\n  const set = new Set(b);\n  return a.filter((pc) => set.has(pc)).length;\n}\n\n/** The plain triad quality underlying a chord's own quality. */\nfunction triadQualityOf(chord: Chord): ChordQuality {\n  const semis = new Set(chord.intervals.map((interval) => mod12(interval)));\n  const hasThird = semis.has(4) ? 'maj' : semis.has(3) ? 'min' : undefined;\n  if (hasThird === undefined) {\n    return chord.quality; // sus, power, and other non-tertian chords stand alone\n  }\n  if (semis.has(6) && !semis.has(7)) {\n    return hasThird === 'min' ? 'dim' : 'majb5';\n  }\n  if (semis.has(8) && !semis.has(7)) {\n    return 'aug';\n  }\n  return hasThird;\n}\n\n/** The diatonic triads of a key, one per scale degree. */\nfunction diatonicTriadsOf(key: KeyScale): Chord[] {\n  const degrees = scaleTonesInDegreeOrder(key).length;\n  const triads: Chord[] = [];\n  for (let degree = 0; degree < degrees; degree += 1) {\n    triads.push(diatonicTriad(degree, key));\n  }\n  return triads;\n}\n\n/** Whether two chords share the same root pitch class and quality. */\nfunction sameChord(a: Chord, b: Chord): boolean {\n  return mod12(a.rootPc) === mod12(b.rootPc) && a.quality === b.quality;\n}\n\n/** Root offsets (semitones) that form a third above or below a root. */\nconst THIRD_OFFSETS = [3, 4, 8, 9] as const;\n\n/**\n * Propose substitutions for a chord within a key.\n *\n * Candidates are generated by several relationships and deduplicated against the\n * original chord and each other:\n *\n * - `tritone`: for a dominant-type chord, the dominant seventh a tritone away.\n * - `relative`: a diatonic triad a third away that shares two common tones.\n * - `borrowed`: a triad from the parallel mode with the same harmonic function.\n * - `chromaticMediant`: a major/minor triad a third away sharing one common\n *   tone.\n *\n * Each result carries its Roman numeral and harmonic function in `key`. When\n * `opts.melodyPcs` is given, only substitutions whose pitch classes contain all\n * of those pitch classes are returned.\n *\n * @param chord The chord to reharmonize.\n * @param key The prevailing key.\n * @param opts Optional melody-preservation constraint.\n * @returns The deduplicated substitution candidates.\n * @example\n * ```ts\n * import { substituteChord, makeChord, majorKey } from '@libraz/libcantus';\n * const subs = substituteChord(makeChord(7, 'dom7'), majorKey(0));\n * // includes the tritone sub Db7 (rootPc 1, quality 'dom7')\n * ```\n * @category Reharmonization\n */\nexport function substituteChord(\n  chord: Chord,\n  key: KeyScale,\n  opts?: SubstituteOptions,\n): Substitution[] {\n  // The relative test counts common tones against the chord's triad, not its\n  // full pitch-class set: an exact count of two would otherwise be decided by\n  // how many tensions the input carries, so C proposes both Em and Am while\n  // Cmaj7 proposes only Am — penalising the candidate that overlaps *more*.\n  const originalTriad = chordPitchClasses(makeChord(chord.rootPc, triadQualityOf(chord)));\n  const candidates: { chord: Chord; type: SubstitutionType }[] = [];\n\n  // Tritone substitution: only for dominant-type chords.\n  if (isDominantType(chord)) {\n    candidates.push({ chord: makeChord(mod12(chord.rootPc + 6), 'dom7'), type: 'tritone' });\n  }\n\n  // Relative: a diatonic triad a third away sharing two common tones.\n  for (const triad of diatonicTriadsOf(key)) {\n    const offset = mod12(triad.rootPc - chord.rootPc);\n    if (\n      (THIRD_OFFSETS as readonly number[]).includes(offset) &&\n      commonToneCount(originalTriad, chordPitchClasses(triad)) === 2\n    ) {\n      candidates.push({ chord: triad, type: 'relative' });\n    }\n  }\n\n  // Borrowed: a parallel-mode triad sharing the original's harmonic function.\n  const targetFunction = functionOf(chord, key);\n  for (const triad of diatonicTriadsOf(parallelKey(key))) {\n    if (functionOf(triad, key) === targetFunction && !isDiatonic(triad, key)) {\n      candidates.push({ chord: triad, type: 'borrowed' });\n    }\n  }\n\n  // Chromatic mediants: major/minor triads a third away sharing one common tone.\n  for (const offset of THIRD_OFFSETS) {\n    for (const quality of ['maj', 'min'] as const) {\n      const mediant = makeChord(mod12(chord.rootPc + offset), quality);\n      if (\n        commonToneCount(originalTriad, chordPitchClasses(mediant)) === 1 &&\n        !isDiatonic(mediant, key)\n      ) {\n        candidates.push({ chord: mediant, type: 'chromaticMediant' });\n      }\n    }\n  }\n\n  const melodyPcs = opts?.melodyPcs?.map(mod12);\n  const seen = new Set<string>();\n  const results: Substitution[] = [];\n  for (const candidate of candidates) {\n    if (sameChord(candidate.chord, chord)) {\n      continue;\n    }\n    const dedupeKey = `${mod12(candidate.chord.rootPc)}:${candidate.chord.quality}`;\n    if (seen.has(dedupeKey)) {\n      continue;\n    }\n    seen.add(dedupeKey);\n    if (melodyPcs !== undefined) {\n      const pcs = new Set(chordPitchClasses(candidate.chord));\n      if (!melodyPcs.every((pc) => pcs.has(pc))) {\n        continue;\n      }\n    }\n    results.push({\n      chord: candidate.chord,\n      type: candidate.type,\n      // A secondary dominant is named as the applied chord it is, so the\n      // numeral re-parses to the chord that was proposed rather than to a\n      // chromatic chord on the same root.\n      roman: chordToRoman(candidate.chord, key, {\n        applied: candidate.type === 'secondaryDominant',\n      }),\n      function: functionOf(candidate.chord, key),\n    });\n  }\n  return results;\n}\n\n/**\n * A borrowed chord in the modal-interchange palette of a key.\n *\n * @category Reharmonization\n */\nexport type BorrowedChord = {\n  chord: Chord;\n  roman: string;\n  source: BorrowedSource;\n};\n\n/**\n * The modal-interchange palette of a key.\n *\n * Lists the diatonic triads of the {@link parallelKey} that are not diatonic to\n * `key` (the classic borrowed chords such as `iv`, `bVI`, and `bVII` in a major\n * key), plus the Neapolitan (a major triad on the flat second degree). Each\n * carries its Roman numeral and {@link borrowedSource} relative to `key`.\n *\n * @param key The prevailing key.\n * @returns The borrowed-chord palette.\n * @category Reharmonization\n */\nexport function modalInterchangePalette(key: KeyScale): BorrowedChord[] {\n  const palette: BorrowedChord[] = [];\n  const seen = new Set<string>();\n  const add = (chord: Chord) => {\n    const dedupeKey = `${mod12(chord.rootPc)}:${chord.quality}`;\n    if (seen.has(dedupeKey)) {\n      return;\n    }\n    seen.add(dedupeKey);\n    palette.push({\n      chord,\n      roman: chordToRoman(chord, key),\n      source: borrowedSource(chord, key),\n    });\n  };\n\n  for (const triad of diatonicTriadsOf(parallelKey(key))) {\n    if (!isDiatonic(triad, key) && borrowedSource(triad, key) !== null) {\n      add(triad);\n    }\n  }\n  // The Neapolitan (major triad on b2) sits outside both parallel modes, so it\n  // is added explicitly — unless b2 is already diatonic (e.g. in a Phrygian key,\n  // where it is a native chord rather than a borrowing).\n  const neapolitan = makeChord(mod12(key.rootPc + 1), 'maj');\n  if (!isDiatonic(neapolitan, key)) {\n    add(neapolitan);\n  }\n  return palette;\n}\n\n/**\n * Reflect a chord across the tonic–dominant axis of a key (negative harmony).\n *\n * Every pitch class `p` maps to `(2*T + 7 - p) mod 12`, where `T` is the key\n * tonic — the reflection that swaps the tonic with the dominant. The mirrored\n * pitch classes (including the bass, if set) are reassembled into a chord by\n * {@link detectChordBest}; when no chord is recognized, the mirrored root and\n * the original quality are used as a fallback.\n *\n * @param chord The chord to reflect.\n * @param key The prevailing key.\n * @returns The negative-harmony counterpart of the chord.\n * @example\n * ```ts\n * import { negativeHarmonyMirror, makeChord, majorKey } from '@libraz/libcantus';\n * negativeHarmonyMirror(makeChord(7, 'maj'), majorKey(0));\n * // G major reflected across C's axis => F minor (rootPc 5, quality 'min')\n * ```\n * @category Reharmonization\n */\nexport function negativeHarmonyMirror(chord: Chord, key: KeyScale): Chord {\n  const tonic = mod12(key.rootPc);\n  const mirror = (p: number) => mod12(2 * tonic + 7 - p);\n  const pcs = chordPitchClasses(chord).map(mirror);\n  const bassPc = chord.bassPc !== undefined ? mirror(chord.bassPc) : undefined;\n  // Place the mirrored bass an octave below so it is recognized as the lowest\n  // note and preserved through detection.\n  const pitches = bassPc !== undefined ? [bassPc - 12, ...pcs] : pcs;\n  const detected = detectChordBest(pitches);\n  if (detected) {\n    // Without an input bass the mirrored tones are octave-less, so detection may\n    // read the lowest pitch class as a slash bass and report a spurious\n    // inversion. Restore the recognized chord to root position in that case.\n    if (bassPc === undefined && detected.bassPc !== undefined) {\n      return makeChord(detected.rootPc, detected.quality);\n    }\n    return detected;\n  }\n  const quality: ChordQuality = chord.quality;\n  return makeChord(mirror(chord.rootPc), quality, bassPc);\n}\n"]}

package/dist/{chunk-EHVEBWM5.js → chunk-3KX76RLG.js}

@@ -1,6 +1,6 @@
 import {
   negativeHarmonyMirror
-} from "./chunk-GQSGS2N4.js";
+} from "./chunk-7JEP3MFY.js";
 import {
   analyzeChord,
   borrowedSource,
@@ -14,13 +14,14 @@ import {
   isBorrowedChord,
   isMinorKey,
   romanToChord
-} from "./chunk-KMHOICIY.js";
+} from "./chunk-NNB67XA2.js";
 import {
   availableTensions,
   avoidNotes,
   chordScales,
   formatChordSymbol,
   parseChordSymbol,
+  scalesForChanges,
   spellChord,
   spellChordFromRoot,
   spellPitchClass,
@@ -28,7 +29,7 @@ import {
   voiceChord,
   voiceChordStyled,
   voiceProgression
-} from "./chunk-RK35RIN7.js";
+} from "./chunk-7EONYVI5.js";
 import {
   chordFromDegree,
   chordPitchClasses,
@@ -41,10 +42,11 @@ import {
   scaleByName,
   scaleTonesInDegreeOrder,
   transposeChord
-} from "./chunk-D2FAJBYL.js";
+} from "./chunk-KBTTEX7Q.js";
 import {
   InvalidInputError,
   assertFiniteNumber,
+  assertInteger,
   formatNote,
   intervalSemitones,
   isConsonantInterval,
@@ -57,7 +59,7 @@ import {
   spelledInterval,
   transposeByInterval,
   transposeNote
-} from "./chunk-XEBG3G53.js";
+} from "./chunk-R2VVFAIN.js";
 
 // src/model/interval.ts
 var INVERSION_SUM = 9;
@@ -77,10 +79,12 @@ var Interval = class _Interval {
   #number;
   #quality;
   #semitones;
-  constructor(numberValue, quality, semitones) {
+  #descending;
+  constructor(numberValue, quality, semitones, descending = semitones < 0) {
     this.#number = numberValue;
     this.#quality = quality;
     this.#semitones = semitones;
+    this.#descending = descending;
   }
   /**
    * The spelled interval between two notes.
@@ -119,7 +123,12 @@ var Interval = class _Interval {
    * @returns The wrapped interval.
    */
   static fromData(data) {
-    return new _Interval(data.number, data.quality, data.semitones);
+    return new _Interval(
+      data.number,
+      data.quality,
+      data.semitones,
+      data.descending ?? data.semitones < 0
+    );
   }
   /**
    * Rebuild an interval from its {@link Interval.toJSON} output.
@@ -166,7 +175,7 @@ var Interval = class _Interval {
    * @returns The inverted interval, e.g. `M3` becomes `m6`.
    */
   invert() {
-    const simple = (this.#number - 1) % 7 + 1;
+    const simple = this.#number === 8 ? 8 : (this.#number - 1) % 7 + 1;
     const numberValue = INVERSION_SUM - simple;
     const quality = invertQuality(this.#quality);
     return _Interval.of(numberValue, quality, intervalSemitones(numberValue, quality));
@@ -191,7 +200,7 @@ var Interval = class _Interval {
    * @returns True when number, quality, and span all match.
    */
   equals(other) {
-    return this.#number === other.number && this.#quality === other.quality && this.#semitones === other.semitones;
+    return this.#number === other.number && this.#quality === other.quality && this.#semitones === other.semitones && this.#descending === other.#descending;
   }
   /**
    * The plain interval data, for JSON serialization.
@@ -202,7 +211,17 @@ var Interval = class _Interval {
    * @returns The diatonic number, quality, and semitone span.
    */
   toJSON() {
-    return { number: this.#number, quality: this.#quality, semitones: this.#semitones };
+    return this.#descending ? {
+      number: this.#number,
+      quality: this.#quality,
+      semitones: this.#semitones,
+      descending: true
+    } : this.#semitones < 0 ? {
+      number: this.#number,
+      quality: this.#quality,
+      semitones: this.#semitones,
+      descending: false
+    } : { number: this.#number, quality: this.#quality, semitones: this.#semitones };
   }
   /**
    * The interval's name, so a template literal or a log line reads as the
@@ -226,6 +245,7 @@ function copyNote(data) {
   if (data.octave !== void 0) {
     copy.octave = data.octave;
   }
+  noteToPitchClass(copy);
   return copy;
 }
 var Note = class _Note {
@@ -419,13 +439,20 @@ function bestTonicForScale(rootPc, scale) {
 var Key = class _Key {
   #scale;
   #tonic;
+  #variant;
   /**
    * Wrap a key/scale and its spelled tonic.
    *
    * @param scale The key/scale; its root is normalized to a pitch class.
    * @param tonic The spelled tonic anchoring letter-name spelling.
+   * @param variant Optional detected scale form retained for display.
    */
-  constructor(scale, tonic) {
+  constructor(scale, tonic, variant) {
+    assertInteger(scale.rootPc, "scale.rootPc");
+    assertInteger(scale.modeMask12, "scale.modeMask12", 1, 4095);
+    if ((scale.modeMask12 & 1) === 0) {
+      throw new InvalidInputError("scale.modeMask12 must include the tonic (bit 0)");
+    }
     const rootPc = pitchClassOf(scale.rootPc);
     if (tonic.pitchClass !== rootPc) {
       throw new InvalidInputError(
@@ -434,6 +461,16 @@ var Key = class _Key {
     }
     this.#scale = { rootPc, modeMask12: scale.modeMask12 };
     this.#tonic = tonic;
+    this.#variant = variant;
+  }
+  /** Preserve detection metadata while replacing its plain key with this API's Key. */
+  static #fromMatch(match) {
+    const key = new _Key(
+      match.key,
+      bestTonicForScale(pitchClassOf(match.key.rootPc), match.key),
+      match.variant
+    );
+    return { ...match, key };
   }
   /**
    * A major key.
@@ -521,7 +558,17 @@ var Key = class _Key {
    * @returns Ranked keys (may be empty).
    */
   static detect(pitches, opts) {
-    return detectKey(pitches, opts).map((match) => _Key.of(match.key));
+    return _Key.detectMatches(pitches, opts).map((match) => match.key);
+  }
+  /**
+   * Identify keys while retaining each candidate's score, fit, and scale form.
+   *
+   * @param pitches MIDI pitches or bare pitch classes.
+   * @param opts How to weigh the input; see {@link DetectKeyOptions}.
+   * @returns Ranked key matches (may be empty).
+   */
+  static detectMatches(pitches, opts) {
+    return detectKey(pitches, opts).map((match) => _Key.#fromMatch(match));
   }
   /**
    * The single best key interpretation of a pitch set.
@@ -537,7 +584,7 @@ var Key = class _Key {
    */
   static detectBest(pitches, opts) {
     const best = detectKeyBest(pitches, opts);
-    return best === null ? null : _Key.of(best.key);
+    return best === null ? null : _Key.#fromMatch(best).key;
   }
   /**
    * Whether another key has the same tonic pitch class and mode.
@@ -568,6 +615,10 @@ var Key = class _Key {
   get isMinor() {
     return isMinorKey(this.#scale);
   }
+  /** The detected scale form, when this key came from key detection. */
+  get variant() {
+    return this.#variant;
+  }
   /**
    * The scale's pitch classes in ascending scale-degree order (degree 0 first).
    *
@@ -594,7 +645,11 @@ var Key = class _Key {
   transpose(semitones) {
     assertFiniteNumber(semitones, "semitones");
     const rootPc = pitchClassOf(this.#scale.rootPc + Math.round(semitones));
-    return _Key.of({ rootPc, modeMask12: this.#scale.modeMask12 });
+    return new _Key(
+      { rootPc, modeMask12: this.#scale.modeMask12 },
+      this.#tonic.transpose(semitones),
+      this.#variant
+    );
   }
   /**
    * The spelled scale, one note per degree (e.g. C D E F G A B for C major).
@@ -696,12 +751,14 @@ var Key = class _Key {
   }
   /**
    * The key's tonic and mode, so a template literal or a log line reads as the
-   * key. Only the major/minor distinction is named, since a mask does not carry
-   * a scale name.
+   * key. Detected harmonic and melodic minor keys retain their scale form.
    *
    * @returns The name, e.g. `'C major'` or `'A minor'`.
    */
   toString() {
+    if (this.#variant === "harmonic" || this.#variant === "melodic") {
+      return `${this.#tonic.name} ${this.#variant} minor`;
+    }
     return `${this.#tonic.name} ${this.isMinor ? "minor" : "major"}`;
   }
 };
@@ -717,9 +774,13 @@ var Progression = class _Progression {
    * @param key Optional key context for analysis methods.
    */
   constructor(chords, key) {
-    this.#chords = Object.freeze([...chords]);
+    this.#chords = Object.freeze(_Progression.#attachKey(chords, key));
     this.#key = key;
   }
+  /** Attach a progression key to chord members that do not already carry one. */
+  static #attachKey(chords, key) {
+    return key === void 0 ? [...chords] : chords.map((chord) => chord.key === void 0 ? chord.withKey(key) : chord);
+  }
   /**
    * Build a progression from the {@link ChordSpan} records the generators
    * return, keeping their order.
@@ -740,11 +801,10 @@ var Progression = class _Progression {
    * ```
    */
   static fromSpans(spans, key) {
-    const chords = spans.map((span) => {
-      const chord = Chord.from(makeChord(span.rootPc, span.quality, span.bassPc));
-      return key === void 0 ? chord : chord.withKey(key);
-    });
-    return key === void 0 ? new _Progression(chords) : new _Progression(chords, key);
+    const chords = spans.map(
+      (span) => Chord.from(makeChord(span.rootPc, span.quality, span.bassPc))
+    );
+    return new _Progression(chords, key);
   }
   /**
    * Rebuild a progression from its {@link Progression.toJSON} output.
@@ -831,21 +891,23 @@ var Progression = class _Progression {
    * @throws If any chord admits no voicing within the given ranges.
    */
   voice(opts) {
+    const key = opts?.key ?? this.#key?.scale;
     return voiceProgression(
       this.#chords.map((chord) => chord.data),
-      opts
+      key === void 0 ? opts : { ...opts, key }
     );
   }
   /**
    * The Roman numeral of each chord in a key.
    *
    * @param key Key to analyze in; falls back to the carried context.
+   * @param opts Applied-numeral rendering options.
    * @returns One numeral per chord.
    * @throws If no key is given and none is carried.
    */
-  roman(key) {
+  roman(key, opts) {
     const resolved = this.#resolveKey(key);
-    return this.#chords.map((chord) => chord.roman(resolved));
+    return this.#chords.map((chord) => chord.roman(resolved, opts));
   }
   /**
    * The harmonic function of each chord in a key.
@@ -865,17 +927,26 @@ var Progression = class _Progression {
    * progression has fewer than two chords.
    *
    * @param key Key to analyze in; falls back to the carried context.
+   * @param opts Applied-numeral rendering options.
    * @returns Per-chord analyses and the closing cadence.
    * @throws If no key is given and none is carried.
    */
-  analyze(key) {
+  analyze(key, opts) {
     const resolved = this.#resolveKey(key);
-    const chords = this.#chords.map((chord) => chord.analyze(resolved));
+    const chords = this.#chords.map((chord) => chord.analyze(resolved, opts));
     const from = this.#chords[this.#chords.length - 2];
     const to = this.#chords[this.#chords.length - 1];
     const cadence = from !== void 0 && to !== void 0 ? detectCadence(from.data, to.data, resolved.scale) : null;
     return { chords, cadence };
   }
+  /**
+   * Choose one compatible scale for every chord, favoring smooth changes.
+   *
+   * @returns One scale choice per chord in this progression.
+   */
+  scales() {
+    return scalesForChanges(this.#chords.map((chord) => chord.data));
+  }
   /**
    * The plain progression data, for JSON serialization.
    *
@@ -905,7 +976,7 @@ var Progression = class _Progression {
       const moved = chord.transpose(semitones);
       return key !== void 0 && moved.key === void 0 ? moved.withKey(key) : moved;
     });
-    return key === void 0 ? new _Progression(chords) : new _Progression(chords, key);
+    return new _Progression(chords, key);
   }
   /**
    * The chord symbols separated by spaces, so a template literal or a log line
@@ -916,9 +987,17 @@ var Progression = class _Progression {
   toString() {
     return this.#chords.map((chord) => chord.symbol()).join(" ");
   }
+  /**
+   * The plain progression data, for JSON serialization.
+   *
+   * Private class fields do not serialize, so this preserves both the chord
+   * data and any carried key in `JSON.stringify(progression)`.
+   *
+   * @returns The chord data sequence and the carried key, if any.
+   */
   toJSON() {
     return {
-      chords: this.#chords.map((chord) => chord.data),
+      chords: this.#chords.map((chord) => chord.toJSON()),
       key: this.#key?.toJSON()
     };
   }
@@ -938,6 +1017,13 @@ var Progression = class _Progression {
 function hintMatches(hint, pc) {
   return hint !== void 0 && pc !== void 0 && pitchClassOf(noteToPitchClass(hint)) === pitchClassOf(pc);
 }
+function transposeHint(hint, semitones) {
+  if (hint === void 0) {
+    return void 0;
+  }
+  const moved = transposeNote(hint, semitones);
+  return { letter: moved.letter, alter: moved.alter };
+}
 function copyChord(data) {
   const copy = {
     rootPc: data.rootPc,
@@ -996,8 +1082,11 @@ var Chord = class _Chord {
    * first key's letters forever. A spelling the caller supplied always wins.
    */
   get #data() {
+    return this.#dataWithKey(this.#key);
+  }
+  /** Build a read view whose missing spellings are derived from `key`. */
+  #dataWithKey(key) {
     const out = copyChord(this.#given);
-    const key = this.#key;
     if (out.rootSpelling === void 0 && key !== void 0) {
       out.rootSpelling = spellPitchClass(out.rootPc, key.tonic.data, key.scale);
     }
@@ -1177,11 +1266,12 @@ var Chord = class _Chord {
    * The chord's Roman numeral in a key.
    *
    * @param key Key to analyze in; falls back to the carried context.
+   * @param opts Applied-numeral rendering options.
    * @returns The Roman numeral string.
    * @throws If no key is given and none is carried.
    */
-  roman(key) {
-    return chordToRoman(this.#data, this.#resolveKey(key).scale);
+  roman(key, opts) {
+    return chordToRoman(this.#data, this.#resolveKey(key).scale, opts);
   }
   /**
    * The chord's harmonic function (tonic / subdominant / dominant) in a key.
@@ -1197,11 +1287,12 @@ var Chord = class _Chord {
    * Full functional analysis: function, borrowing, and Roman numeral.
    *
    * @param key Key to analyze in; falls back to the carried context.
+   * @param opts Applied-numeral rendering options.
    * @returns The chord analysis.
    * @throws If no key is given and none is carried.
    */
-  analyze(key) {
-    return analyzeChord(this.#data, this.#resolveKey(key).scale);
+  analyze(key, opts) {
+    return analyzeChord(this.#data, this.#resolveKey(key).scale, opts);
   }
   /**
    * Whether the chord is borrowed from the parallel mode (modal interchange).
@@ -1315,6 +1406,14 @@ var Chord = class _Chord {
    */
   transpose(semitones) {
     const moved = transposeChord(this.#given, semitones);
+    const rootSpelling = transposeHint(this.#given.rootSpelling, semitones);
+    const bassSpelling = transposeHint(this.#given.bassSpelling, semitones);
+    if (rootSpelling !== void 0) {
+      moved.rootSpelling = rootSpelling;
+    }
+    if (bassSpelling !== void 0) {
+      moved.bassSpelling = bassSpelling;
+    }
     return new _Chord(moved, this.#key?.transpose(semitones));
   }
   /**
@@ -1368,8 +1467,8 @@ var Chord = class _Chord {
    *   spelling of its own.
    */
   spell(key) {
-    const data = this.#data;
     const resolved = key ?? this.#key;
+    const data = this.#dataWithKey(resolved);
     let tones;
     if (resolved === void 0) {
       const root = data.rootSpelling;
@@ -1417,7 +1516,7 @@ var Chord = class _Chord {
    * @returns A copy of the underlying plain chord object.
    */
   toJSON() {
-    return this.data;
+    return copyChord(this.#given);
   }
   /**
    * The chord symbol, so a template literal or a log line reads as the chord.
@@ -1446,4 +1545,4 @@ export {
   Progression,
   Chord
 };
-//# sourceMappingURL=chunk-EHVEBWM5.js.map
+//# sourceMappingURL=chunk-3KX76RLG.js.map