@onjmin/koe 1.0.10 → 1.0.11

package/dist/index.js

@@ -2100,7 +2100,7 @@ function analyze(wav) {
   const mono = resample(toMono(wav), RATE);
   const x = mono.samples;
   const n = Math.max(1, Math.floor((x.length - FFT_SIZE) / HOP) + 1);
-  const rmsDb = new Float32Array(n);
+  const rmsDb2 = new Float32Array(n);
   const highRatio = new Float32Array(n);
   const highDb = new Float32Array(n);
   const flux = new Float32Array(n);
@@ -2123,7 +2123,7 @@ function analyze(wav) {
       re[i] = s * window[i];
       im[i] = 0;
     }
-    rmsDb[t] = 10 * Math.log10(energy / FFT_SIZE + 1e-12);
+    rmsDb2[t] = 10 * Math.log10(energy / FFT_SIZE + 1e-12);
     fft(re, im);
     let lowSum = 0;
     let highSum = 0;
@@ -2141,7 +2141,7 @@ function analyze(wav) {
     highDb[t] = 20 * Math.log10(highSum / BINS + 1e-9);
     flux[t] = t === 0 ? 0 : fluxSum;
   }
-  const smoothDb = smooth(rmsDb, Math.round(30 / HOP_MS));
+  const smoothDb = smooth(rmsDb2, Math.round(30 / HOP_MS));
   const smoothHighDb = smooth(highDb, Math.round(20 / HOP_MS));
   const highFloorDb = quietestWindow(smoothHighDb);
   const floorDb = percentile(smoothDb, 0.1);
@@ -2197,7 +2197,7 @@ function analyze(wav) {
   return {
     n,
     durationMs: x.length / RATE * 1e3,
-    rmsDb,
+    rmsDb: rmsDb2,
     smoothDb,
     voiced,
     highRatio,
@@ -3338,9 +3338,25 @@ function softLimit(value, knee, max2) {
   return Math.sign(value) * Math.min(max2, limited);
 }
 var DEVOICED = /* @__PURE__ */ new Set(["A", "I", "U", "E", "O"]);
+var UNVOICED_ONSET = /* @__PURE__ */ new Set([
+  "k",
+  "ky",
+  "s",
+  "sh",
+  "t",
+  "ty",
+  "ch",
+  "ts",
+  "h",
+  "hy",
+  "f",
+  "p",
+  "py"
+]);
 function segmentPhonemes(phonemes) {
   const segments = [];
   let openStart = null;
+  let openOnset = "";
   for (let i = 0; i < phonemes.length; i++) {
     const { phone, start_ms, duration_ms } = phonemes[i];
     if (phone === "sil" || phone === "pau") {
@@ -3348,8 +3364,10 @@ function segmentPhonemes(phonemes) {
         segments.push({
           pause: false,
           startMs: openStart,
-          durationMs: start_ms - openStart,
-          devoiced: false
+          nucleusMs: openStart,
+          endMs: start_ms,
+          devoiced: false,
+          onset: openOnset
         });
         openStart = null;
       }
@@ -3357,18 +3375,25 @@ function segmentPhonemes(phonemes) {
       segments.push({
         pause: true,
         startMs: start_ms,
-        durationMs: duration_ms,
-        devoiced: false
+        nucleusMs: start_ms,
+        endMs: start_ms + duration_ms,
+        devoiced: false,
+        onset: ""
       });
       continue;
     }
-    if (openStart === null) openStart = start_ms;
+    if (openStart === null) {
+      openStart = start_ms;
+      openOnset = NUCLEUS.has(phone) ? "" : phone;
+    }
     if (NUCLEUS.has(phone)) {
       segments.push({
         pause: false,
         startMs: openStart,
-        durationMs: start_ms + duration_ms - openStart,
-        devoiced: DEVOICED.has(phone)
+        nucleusMs: start_ms,
+        endMs: start_ms + duration_ms,
+        devoiced: DEVOICED.has(phone),
+        onset: openOnset
       });
       openStart = null;
     }
@@ -3378,47 +3403,79 @@ function segmentPhonemes(phonemes) {
     segments.push({
       pause: false,
       startMs: openStart,
-      durationMs: last.start_ms + last.duration_ms - openStart,
+      nucleusMs: openStart,
+      endMs: last.start_ms + last.duration_ms,
+      onset: openOnset,
       devoiced: false
     });
   }
   return segments;
 }
+function anchorMs(segment) {
+  return segment.pause ? segment.startMs : segment.nucleusMs;
+}
 function alignHtsProsody(frames, features, options = {}) {
   const {
     intonationStrength = 1,
     frameMs = 10,
     fallbackPauseMs = 150,
     kneeCents = 400,
-    maxCents = 700
+    maxCents = 700,
+    unvoicedBridgeMs = 120
   } = options;
   const segments = segmentPhonemes(frames.phonemes);
-  const durations = new Array(features.length).fill(0);
-  const htsStart = new Array(features.length).fill(null);
+  const matched = new Array(features.length).fill(null);
   const devoiced = new Array(features.length).fill(false);
+  const consonantMs = new Array(features.length).fill(0);
+  const unvoicedOnset = new Array(features.length).fill(false);
   let s = 0;
   for (let f2 = 0; f2 < features.length; f2++) {
     const feature = features[f2];
     while (s < segments.length && segments[s].pause && !feature.pause) s++;
     const segment = segments[s];
     if (feature.pause) {
-      if (segment?.pause) {
-        durations[f2] = segment.durationMs;
-        htsStart[f2] = segment.startMs;
-        s++;
-      } else {
-        durations[f2] = fallbackPauseMs;
-      }
+      if (segment?.pause) matched[f2] = s++;
       continue;
     }
     if (!segment) return null;
-    durations[f2] = segment.durationMs;
-    htsStart[f2] = segment.startMs;
+    matched[f2] = s++;
     devoiced[f2] = segment.devoiced;
-    s++;
+    consonantMs[f2] = Math.max(0, segment.nucleusMs - segment.startMs);
+    unvoicedOnset[f2] = UNVOICED_ONSET.has(segment.onset);
   }
   if (segments.slice(s).some((segment) => !segment.pause)) return null;
-  const f0 = frames.f0_hz;
+  const durations = new Array(features.length).fill(0);
+  const htsStart = new Array(features.length).fill(null);
+  for (let f2 = 0; f2 < features.length; f2++) {
+    const index = matched[f2];
+    if (index === null) {
+      durations[f2] = fallbackPauseMs;
+      continue;
+    }
+    const here = anchorMs(segments[index]);
+    let next = f2 + 1;
+    while (next < features.length && matched[next] === null) next++;
+    let end = segments[index].endMs;
+    if (next < features.length) {
+      const nextIndex = matched[next];
+      end = anchorMs(segments[nextIndex]);
+      for (let k = index + 1; k < nextIndex; k++) {
+        if (segments[k].pause) end -= segments[k].endMs - segments[k].startMs;
+      }
+    }
+    durations[f2] = Math.max(0, end - here);
+    htsStart[f2] = here;
+  }
+  const f0 = frames.f0_hz.slice();
+  for (const phoneme of frames.phonemes) {
+    if (!UNVOICED_ONSET.has(phoneme.phone) && phoneme.phone !== "cl") continue;
+    const from = Math.max(0, Math.round(phoneme.start_ms / frames.frame_ms));
+    const to = Math.min(
+      f0.length,
+      Math.round((phoneme.start_ms + phoneme.duration_ms) / frames.frame_ms)
+    );
+    for (let i = from; i < to; i++) f0[i] = 0;
+  }
   const logF0 = new Float64Array(f0.length);
   const voiced = [];
   for (let i = 0; i < f0.length; i++) if (f0[i] > 0) voiced.push(i);
@@ -3436,7 +3493,18 @@ function alignHtsProsody(frames, features, options = {}) {
     if (left === void 0) logF0[i] = Math.log2(f0[right]);
     else if (right === void 0) logF0[i] = Math.log2(f0[left]);
     else {
-      const t = (i - left) / (right - left);
+      if ((right - left) * frames.frame_ms > unvoicedBridgeMs) {
+        logF0[i] = Math.log2(
+          i - left <= (right - left) / 2 ? f0[left] : f0[right]
+        );
+        continue;
+      }
+      const rampStart = Math.max(left, right - Math.ceil(20 / frames.frame_ms));
+      if (i <= rampStart) {
+        logF0[i] = Math.log2(f0[left]);
+        continue;
+      }
+      const t = (i - rampStart) / (right - rampStart);
       logF0[i] = Math.log2(f0[left]) * (1 - t) + Math.log2(f0[right]) * t;
     }
   }
@@ -3479,7 +3547,9 @@ function alignHtsProsody(frames, features, options = {}) {
     pitchCurve: { frame_ms: frameMs, cents },
     medianHz,
     durationMs,
-    devoiced
+    devoiced,
+    consonantMs,
+    unvoicedOnset
   };
 }
 
@@ -3517,6 +3587,25 @@ function isHigh(position, accent) {
   if (accent > 1) return 2 <= position && position <= accent;
   return position >= 2;
 }
+var SENTENCE_END = /[。．！？!?.]/u;
+var CLAUSE = /[、，,]/u;
+function pauseKind(punctuation) {
+  if (punctuation === void 0) return "clause";
+  if (SENTENCE_END.test(punctuation)) return "sentence";
+  if (CLAUSE.test(punctuation)) return "clause";
+  return "space";
+}
+function pauseRank(punctuation) {
+  if (punctuation === void 0) return 0;
+  switch (pauseKind(punctuation)) {
+    case "sentence":
+      return 3;
+    case "clause":
+      return 2;
+    default:
+      return 1;
+  }
+}
 function analyze2(nodes) {
   const reading_parts = [];
   const result = [];
@@ -3526,8 +3615,11 @@ function analyze2(nodes) {
     const pronunciation = (node.pron || "").replace(/'/g, "").replace(/’/g, "");
     if (node.mora_size === 0 || PUNCTUATION.has(node.string)) {
       reading_parts.push(node.string || "\u3001");
-      if (result.length > 0 && !result[result.length - 1].pause) {
-        result.push({ mora: "", pause: true });
+      const last = result[result.length - 1];
+      if (result.length > 0 && !last.pause) {
+        result.push({ mora: "", pause: true, punctuation: node.string || "\u3001" });
+      } else if (last?.pause && pauseRank(node.string) > pauseRank(last.punctuation)) {
+        last.punctuation = node.string;
       }
       index++;
       continue;
@@ -3612,26 +3704,113 @@ function smoothstep(t) {
   const x = Math.min(1, Math.max(0, t));
   return x * x * (3 - 2 * x);
 }
+var DEFAULT_PAUSE_MS = {
+  sentence: 650,
+  clause: 380,
+  space: 500
+};
+function shapeDurations(durations, features, options = {}) {
+  const {
+    pauseMs = DEFAULT_PAUSE_MS,
+    durationContrast = 1.3,
+    minMoraMs = 60,
+    minShrink = 0.85
+  } = options;
+  const count = Math.min(features.length, durations.length);
+  let sum = 0;
+  let spoken = 0;
+  for (let f = 0; f < count; f++) {
+    if (features[f].pause) continue;
+    sum += durations[f];
+    spoken++;
+  }
+  const mean = spoken > 0 ? sum / spoken : 0;
+  const result = durations.slice();
+  let changed = false;
+  for (let f = 0; f < count; f++) {
+    const feature = features[f];
+    let next = durations[f];
+    if (feature.pause) {
+      if (pauseMs && f < count - 1) {
+        const kind = pauseKind(feature.punctuation);
+        next = Math.max(next, pauseMs[kind] ?? DEFAULT_PAUSE_MS[kind]);
+      }
+    } else if (durationContrast !== 1 && next > 0) {
+      next = Math.max(
+        Math.min(next, minMoraMs),
+        next * minShrink,
+        mean + (next - mean) * durationContrast
+      );
+    }
+    if (next !== durations[f]) {
+      result[f] = next;
+      changed = true;
+    }
+  }
+  return changed ? result : durations;
+}
+function warpPitchCurve(cents, frameMs, from, to) {
+  const count = Math.min(from.length, to.length);
+  const fromStart = [];
+  const toStart = [];
+  let a = 0;
+  let b = 0;
+  for (let f2 = 0; f2 < count; f2++) {
+    fromStart.push(a);
+    toStart.push(b);
+    a += from[f2];
+    b += to[f2];
+  }
+  const frames = Math.max(2, Math.ceil(b / frameMs) + 2);
+  const result = new Array(frames);
+  const last = cents.length - 1;
+  if (last < 0) return result.fill(0);
+  let f = 0;
+  for (let frame = 0; frame < frames; frame++) {
+    const tMs = frame * frameMs;
+    while (f + 1 < count && tMs >= toStart[f + 1]) f++;
+    const progress = to[f] > 0 ? (tMs - toStart[f]) / to[f] : 0;
+    const source = (fromStart[f] + progress * from[f]) / frameMs;
+    const left = Math.min(last, Math.max(0, Math.floor(source)));
+    const right = Math.min(last, left + 1);
+    const t = Math.min(1, Math.max(0, source - Math.floor(source)));
+    result[frame] = cents[left] * (1 - t) + cents[right] * t;
+  }
+  return result;
+}
 function shapeProsody(prosody, features, options = {}) {
   const {
     question = false,
     questionRiseCents = 350,
-    energyDbPerSemitone = 0.5,
-    devoicedGain = 0.5,
+    energyDbPerSemitone = 0,
+    devoicedGain = 1,
     minGain = 0.35,
-    maxGain = 1.8
+    maxGain = 1.8,
+    pitchShiftCents = 0
   } = options;
   const { frame_ms: frameMs } = prosody.pitchCurve;
-  const cents = prosody.pitchCurve.cents.slice();
-  const count = Math.min(features.length, prosody.moraDurationsMs.length);
+  const durations = shapeDurations(prosody.moraDurationsMs, features, options);
+  const cents = durations === prosody.moraDurationsMs ? prosody.pitchCurve.cents.slice() : warpPitchCurve(
+    prosody.pitchCurve.cents,
+    frameMs,
+    prosody.moraDurationsMs,
+    durations
+  );
+  const count = Math.min(features.length, durations.length);
   const startFrame = [];
   const endFrame = [];
   let cursor = 0;
   for (let f = 0; f < count; f++) {
     startFrame.push(cursor / frameMs);
-    cursor += prosody.moraDurationsMs[f];
+    cursor += durations[f];
     endFrame.push(cursor / frameMs);
   }
+  for (let f = count; f < durations.length; f++) cursor += durations[f];
+  const durationMs = cursor;
+  if (pitchShiftCents !== 0) {
+    for (let frame = 0; frame < cents.length; frame++)
+      cents[frame] += pitchShiftCents;
+  }
   const frameRange = (f) => [
     Math.max(0, Math.min(cents.length, Math.round(startFrame[f]))),
     Math.max(0, Math.min(cents.length, Math.round(endFrame[f])))
@@ -3676,17 +3855,100 @@ function shapeProsody(prosody, features, options = {}) {
   }
   return {
     ...prosody,
+    moraDurationsMs: durations,
+    durationMs,
     pitchCurve: { frame_ms: frameMs, cents },
     moraGains
   };
 }
 
+// src/utautts/style.ts
+var SPEAKING_STYLES = {
+  neutral: {
+    speed: 1,
+    intonation: 1,
+    pitchShiftCents: 0,
+    pauseScale: 1,
+    durationContrast: 1.3,
+    energyDbPerSemitone: 0.8
+  },
+  calm: {
+    speed: 0.9,
+    intonation: 0.9,
+    pitchShiftCents: -100,
+    pauseScale: 1.4,
+    durationContrast: 1.2,
+    energyDbPerSemitone: 0.6
+  },
+  lively: {
+    speed: 1.08,
+    intonation: 1.3,
+    pitchShiftCents: 100,
+    pauseScale: 0.85,
+    durationContrast: 1.4,
+    energyDbPerSemitone: 1
+  }
+};
+var BASE_PAUSE_MS = { sentence: 650, clause: 380, space: 500 };
+function resolveSpeakingStyle(input = "neutral") {
+  if (typeof input === "string") return { ...SPEAKING_STYLES[input] };
+  const { preset = "neutral", ...overrides } = input;
+  return { ...SPEAKING_STYLES[preset], ...overrides };
+}
+function styleAlignOptions(style) {
+  return { intonationStrength: style.intonation };
+}
+function styleShapeOptions(style) {
+  return {
+    pauseMs: {
+      sentence: BASE_PAUSE_MS.sentence * style.pauseScale,
+      clause: BASE_PAUSE_MS.clause * style.pauseScale,
+      space: BASE_PAUSE_MS.space * style.pauseScale
+    },
+    durationContrast: style.durationContrast,
+    pitchShiftCents: style.pitchShiftCents
+  };
+}
+function styleRenderOptions(style) {
+  return { energyDbPerSemitone: style.energyDbPerSemitone };
+}
+
 // src/utautts/UtauTTSAdapter.ts
 function readingFromFeatures(features) {
   return features.map((frame) => frame.pause ? "\u3001" : frame.mora).join("");
 }
 var FS = WORLDLINE_SAMPLE_RATE;
 var msToSamples2 = (ms) => Math.round(ms / 1e3 * FS);
+function rmsDb(pcm, from, to) {
+  const a = Math.max(0, from);
+  const b = Math.min(pcm.length, to);
+  if (b <= a) return Number.NaN;
+  let sum = 0;
+  for (let k = a; k < b; k++) sum += pcm[k] * pcm[k];
+  return 10 * Math.log10(sum / (b - a) + 1e-12);
+}
+function applyGainFrames(pcm, framesDb, frameSamples) {
+  const last = framesDb.length - 1;
+  if (last < 0) return;
+  for (let k = 0; k < pcm.length; k++) {
+    const position = k / frameSamples - 0.5;
+    const left = Math.min(last, Math.max(0, Math.floor(position)));
+    const right = Math.min(last, left + 1);
+    const t = Math.min(1, Math.max(0, position - left));
+    pcm[k] *= 10 ** ((framesDb[left] * (1 - t) + framesDb[right] * t) / 20);
+  }
+}
+function softLimit2(pcm, threshold) {
+  const range = 1 - threshold;
+  if (range <= 0) return;
+  for (let k = 0; k < pcm.length; k++) {
+    const x = pcm[k];
+    const a = Math.abs(x);
+    if (a <= threshold) continue;
+    const y = threshold + range * Math.tanh((a - threshold) / range);
+    pcm[k] = x < 0 ? -y : y;
+  }
+}
 function f0At(timeline, tMs) {
   const curve = timeline.f0_curve;
   if (curve.length === 0) return timeline.reference_hz || 220;
@@ -3716,6 +3978,30 @@ function applyMoraGains(plan, gains) {
     unit.volume *= gain;
   }
 }
+function applyConsonantGaps(plan, prosody) {
+  const { consonantMs, unvoicedOnset } = prosody;
+  if (!consonantMs || !unvoicedOnset) return;
+  if (consonantMs.length !== (plan.morae?.length ?? -1)) return;
+  const leading = plan.timeline.leading_ms;
+  const units = plan.timeline.units;
+  for (let i = 0; i + 1 < units.length; i++) {
+    const unit = units[i];
+    const next = units[i + 1];
+    if (next.position !== unit.position + 1) continue;
+    if (!unvoicedOnset[next.position]) continue;
+    const consonant = consonantMs[next.position];
+    if (!(consonant > 0)) continue;
+    const gapStart = next.note_start_ms + leading - consonant;
+    const currentEnd = unit.position_ms + unit.length_ms;
+    if (gapStart >= currentEnd) continue;
+    const minimumLength = Math.max(
+      40,
+      unit.fade_in_ms + unit.fade_out_ms + 10,
+      unit.note_start_ms + leading - unit.position_ms + 30
+    );
+    unit.length_ms = Math.max(minimumLength, gapStart - unit.position_ms);
+  }
+}
 function planChunks(units, firstChunkUnits, chunkUnits) {
   const ranges = [];
   if (units.length === 0) return ranges;
@@ -3758,6 +4044,93 @@ function applyFade(pcm, fromSample, samples, fadeIn) {
     pcm[fromSample + k] *= gain;
   }
 }
+function median(values) {
+  const sorted = values.slice().sort((a, b) => a - b);
+  return sorted[Math.floor(sorted.length / 2)];
+}
+function shapeLoudness(audio, units, timeline, baseMs, options) {
+  const frameMs = timeline.frame_ms > 0 ? timeline.frame_ms : 10;
+  const frameSamples = Math.max(1, msToSamples2(frameMs));
+  const frames = Math.ceil(audio.length / frameSamples) + 1;
+  const curve = new Float64Array(frames);
+  if (options.equalize) {
+    const anchors = [];
+    const measured = [];
+    for (const unit of units) {
+      if (!(unit.volume > 0) || unit.duration_ms < 30) continue;
+      const start = unit.note_start_ms + timeline.leading_ms - baseMs;
+      const soundEnd = unit.position_ms - baseMs + unit.length_ms - unit.fade_out_ms;
+      const from = msToSamples2(start + unit.duration_ms * 0.35);
+      const to = msToSamples2(
+        Math.min(start + unit.duration_ms * 0.9, soundEnd)
+      );
+      if (to - from < msToSamples2(20)) continue;
+      const db = rmsDb(audio, from, to);
+      if (!Number.isFinite(db) || db < -70) continue;
+      measured.push({
+        frame: (start + unit.duration_ms * 0.6) / frameMs,
+        intrinsicDb: db - 20 * Math.log10(unit.volume / 100)
+      });
+    }
+    if (measured.length > 0) {
+      const reference = options.targetDb;
+      for (const m of measured) {
+        anchors.push({
+          frame: m.frame,
+          db: Math.max(
+            -options.maxDb,
+            Math.min(options.maxDb, reference - m.intrinsicDb)
+          )
+        });
+      }
+      let a = 0;
+      for (let frame = 0; frame < frames; frame++) {
+        while (a + 1 < anchors.length && frame >= anchors[a + 1].frame) a++;
+        const left = anchors[a];
+        const right = anchors[Math.min(anchors.length - 1, a + 1)];
+        if (frame <= left.frame || right === left) curve[frame] = left.db;
+        else if (frame >= right.frame) curve[frame] = right.db;
+        else {
+          const t = (frame - left.frame) / (right.frame - left.frame);
+          curve[frame] = left.db * (1 - t) + right.db * t;
+        }
+      }
+    }
+  }
+  if (options.energyDbPerSemitone !== 0 && options.referenceHz > 0) {
+    for (let frame = 0; frame < frames; frame++) {
+      const f0 = f0At(timeline, baseMs + frame * frameMs);
+      if (!(f0 > 0)) continue;
+      const semitones = 12 * Math.log2(f0 / options.referenceHz);
+      curve[frame] += Math.max(
+        -options.energyMaxDb,
+        Math.min(options.energyMaxDb, semitones * options.energyDbPerSemitone)
+      );
+    }
+  }
+  if (options.devoicedDb < 0) {
+    const rampFrames = Math.max(1, Math.round(20 / frameMs));
+    for (let i = 0; i < units.length; i++) {
+      const unit = units[i];
+      if (!unit.devoiced) continue;
+      const start = unit.note_start_ms + timeline.leading_ms - baseMs;
+      let endMs = start + unit.duration_ms;
+      const next = units[i + 1];
+      if (next) endMs = Math.min(endMs, next.position_ms - baseMs);
+      const from = start / frameMs;
+      const to = endMs / frameMs;
+      for (let frame = Math.max(0, Math.floor(from)); frame < frames && frame < to + rampFrames; frame++) {
+        const fadeIn = Math.min(1, Math.max(0, (frame - from) / rampFrames));
+        const fadeOut = Math.min(
+          1,
+          Math.max(0, (to + rampFrames - frame) / rampFrames)
+        );
+        curve[frame] += options.devoicedDb * Math.min(fadeIn, fadeOut);
+      }
+    }
+  }
+  applyGainFrames(audio, curve, frameSamples);
+}
 var UtauTTSAdapter = class _UtauTTSAdapter {
   constructor(worldline) {
     this.worldline = worldline;
@@ -3884,6 +4257,13 @@ var UtauTTSAdapter = class _UtauTTSAdapter {
     const plan = JSON.parse(response.plan);
     const gains = options.prosody?.moraGains;
     if (gains) applyMoraGains(plan, gains);
+    const devoiced = options.prosody?.devoiced;
+    if (devoiced && devoiced.length === (plan.morae?.length ?? -1)) {
+      for (const unit of plan.timeline.units) {
+        if (devoiced[unit.position]) unit.devoiced = true;
+      }
+    }
+    if (options.prosody) applyConsonantGaps(plan, options.prosody);
     return plan;
   }
   getPcm(bank, alias) {
@@ -3908,10 +4288,19 @@ var UtauTTSAdapter = class _UtauTTSAdapter {
       firstChunkUnits = 3,
       chunkUnits = 6,
       seamCrossfadeMs = 20,
+      normalizeUnitLoudness = true,
+      unitLoudnessDb = -16,
+      unitLoudnessMaxDb = 6,
+      energyDbPerSemitone = 0.8,
+      energyMaxDb = 6,
+      devoicedDb = -9,
+      outputLimit = 0.8,
       signal
     } = options;
     const timeline = plan.timeline;
     const units = timeline.units.filter((unit) => unit.length_ms > 0);
+    const voicedF0 = timeline.f0_curve.filter((hz) => hz > 0);
+    const referenceHz = voicedF0.length > 0 ? median(voicedF0) : 0;
     const ranges = planChunks(
       units,
       Math.max(1, firstChunkUnits),
@@ -3958,6 +4347,17 @@ var UtauTTSAdapter = class _UtauTTSAdapter {
         voicing: options.voicing
       });
       if (!audio || audio.length === 0) continue;
+      if (normalizeUnitLoudness || energyDbPerSemitone !== 0 || devoicedDb < 0) {
+        shapeLoudness(audio, rendered, timeline, baseMs, {
+          equalize: normalizeUnitLoudness,
+          targetDb: unitLoudnessDb,
+          maxDb: unitLoudnessMaxDb,
+          energyDbPerSemitone,
+          energyMaxDb,
+          devoicedDb,
+          referenceHz
+        });
+      }
       let fromSample = 0;
       let toSample = audio.length;
       let startMs = baseMs;
@@ -3978,6 +4378,7 @@ var UtauTTSAdapter = class _UtauTTSAdapter {
       }
       if (toSample <= fromSample) continue;
       const pcm = audio.slice(fromSample, toSample);
+      if (outputLimit > 0) softLimit2(pcm, outputLimit);
       if (range.headSeam) applyFade(pcm, 0, crossfadeSamples, true);
       if (range.tailSeam)
         applyFade(
@@ -4005,6 +4406,8 @@ var UtauTTSAdapter = class _UtauTTSAdapter {
       const n = Math.min(chunk.pcm.length, out.length - offset);
       for (let k = 0; k < n; k++) out[offset + k] += chunk.pcm[k];
     }
+    const limit = options.outputLimit ?? 0.8;
+    if (any && limit > 0) softLimit2(out, limit);
     return any ? out : null;
   }
 };
@@ -4012,6 +4415,7 @@ export {
   KoeEngine,
   MIN_WORLDLINE_SAMPLES,
   NAIST_JDIC_FILES,
+  SPEAKING_STYLES,
   UtauTTSAdapter,
   VoiceBank,
   WORLDLINE_SAMPLE_RATE,
@@ -4050,15 +4454,21 @@ export {
   parseKoeHeader,
   parseOto,
   parseWav,
+  pauseKind,
   pcmBase,
   pitchFromAliasSuffix,
   readWavPcm48k,
   readingFromFeatures,
   resample,
+  resolveSpeakingStyle,
   samplesToMs,
+  shapeDurations,
   shapeProsody,
   sparse_features,
   splitKana,
+  styleAlignOptions,
+  styleRenderOptions,
+  styleShapeOptions,
   suffixFromFolderName,
   summarise,
   toHiragana,
@@ -4067,6 +4477,7 @@ export {
   transcribe,
   trimToOto,
   unzipToFileMap,
+  warpPitchCurve,
   zipFiles
 };
 //# sourceMappingURL=index.js.map