@onjmin/koe 1.0.8 → 1.0.9

package/dist/index.js

@@ -1759,10 +1759,18 @@ var Worldline = class _Worldline {
    *          {@link MIN_WORLDLINE_SAMPLES} (too short for stable F0 analysis).
    */
   renderPhrase(params) {
-    const { units, pitch, gender = 0.5, tension = 0.5, breathiness = 0.5, voicing = 1, tempo = 120 } = params;
+    const {
+      units,
+      pitch,
+      gender = 0.5,
+      tension = 0.5,
+      breathiness = 0.5,
+      voicing = 1,
+      tempo = 120
+    } = params;
     if (units.length === 0) return null;
     const WL = this.wasm;
-    const FS = WORLDLINE_SAMPLE_RATE;
+    const FS2 = WORLDLINE_SAMPLE_RATE;
     let totalMs = 0;
     for (const u of units) {
       const endMs = u.posMs + u.lengthMs;
@@ -1781,19 +1789,19 @@ var Worldline = class _Worldline {
       pointersToFree.push(samplePtr);
       WL.HEAPF64.set(u.pcm, samplePtr >> 3);
       const sv = (off, val, type) => WL.setValue(reqPtr + off, val, type);
-      sv(0, FS, "i32");
+      sv(0, FS2, "i32");
       sv(4, u.pcm.length, "i32");
       sv(8, samplePtr, "*");
       sv(12, 0, "i32");
       sv(16, 0, "*");
-      sv(20, 69, "i32");
+      sv(20, u.tone ?? 69, "i32");
       sv(24, 100, "double");
       sv(32, 0, "double");
-      sv(40, u.lengthMs, "double");
+      sv(40, u.requiredLengthMs ?? u.lengthMs, "double");
       sv(48, u.consonantMs, "double");
       const cutMs = u.cutMs ?? WL_FRAME_MS * 2;
       sv(56, cutMs, "double");
-      sv(64, 100, "double");
+      sv(64, u.volume ?? 100, "double");
       sv(72, 0, "double");
       sv(80, tempo, "double");
       sv(88, 0, "i32");
@@ -1804,7 +1812,16 @@ var Worldline = class _Worldline {
       sv(108, 0, "i32");
       sv(112, 0, "i32");
       sv(116, 100, "i32");
-      WL._PhraseSynthAddRequest(ps, reqPtr, u.posMs, u.skipMs, u.lengthMs, u.fadeInMs, u.fadeOutMs, 0);
+      WL._PhraseSynthAddRequest(
+        ps,
+        reqPtr,
+        u.posMs,
+        u.skipMs,
+        u.lengthMs,
+        u.fadeInMs,
+        u.fadeOutMs,
+        0
+      );
     }
     totalMs += WL_FRAME_MS * 2;
     const nFrames = Math.ceil(totalMs / WL_FRAME_MS) + 4;
@@ -1832,7 +1849,16 @@ var Worldline = class _Worldline {
       WL.HEAPF64.set(tArr, tPtr >> 3);
       WL.HEAPF64.set(bArr, bPtr >> 3);
       WL.HEAPF64.set(vArr, vPtr >> 3);
-      WL._PhraseSynthSetCurves(ps, f0Ptr, gPtr, tPtr, bPtr, vPtr, nFrames, WL_FRAME_MS);
+      WL._PhraseSynthSetCurves(
+        ps,
+        f0Ptr,
+        gPtr,
+        tPtr,
+        bPtr,
+        vPtr,
+        nFrames,
+        WL_FRAME_MS
+      );
     }
     if (f0Ptr) WL._free(f0Ptr);
     if (gPtr) WL._free(gPtr);
@@ -1871,8 +1897,12 @@ var Worldline = class _Worldline {
     } = params;
     if (!pcm || pcm.length < MIN_WORLDLINE_SAMPLES) return null;
     const WL = this.wasm;
-    const FS = WORLDLINE_SAMPLE_RATE;
-    const basePitch = sampleCurve(preMs + durationMs / 2, pitch, preMs + durationMs);
+    const FS2 = WORLDLINE_SAMPLE_RATE;
+    const basePitch = sampleCurve(
+      preMs + durationMs / 2,
+      pitch,
+      preMs + durationMs
+    );
     const midiNote = Math.round(69 + 12 * Math.log2(basePitch / 440));
     const posMs = 0;
     const reqLen = preMs + durationMs;
@@ -1892,7 +1922,7 @@ var Worldline = class _Worldline {
     }
     WL.HEAPF64.set(pcm, samplePtr >> 3);
     const sv = (off, val, type) => WL.setValue(reqPtr + off, val, type);
-    sv(0, FS, "i32");
+    sv(0, FS2, "i32");
     sv(4, pcm.length, "i32");
     sv(8, samplePtr, "*");
     sv(12, 0, "i32");
@@ -3147,119 +3177,846 @@ function encodeOto(entries) {
   return encodeShiftJis(formatOto(entries));
 }
 
+// src/utautts/assets.ts
+var DEFAULT_CACHE = "koe-tts-assets-v1";
+async function openCache(name) {
+  if (name === null) return null;
+  try {
+    if (typeof caches === "undefined") return null;
+    return await caches.open(name ?? DEFAULT_CACHE);
+  } catch {
+    return null;
+  }
+}
+async function cachedCopyIsCurrent(url, cached, signal) {
+  let head;
+  try {
+    head = await fetch(url, { method: "HEAD", signal, cache: "no-cache" });
+  } catch {
+    return true;
+  }
+  if (!head.ok) return true;
+  for (const name of ["etag", "last-modified", "content-length"]) {
+    const remote = head.headers.get(name);
+    const local = cached.headers.get(name);
+    if (remote && local) return remote === local;
+  }
+  return true;
+}
+async function fetchAsset(url, options = {}) {
+  const { onProgress, signal, revalidate = true } = options;
+  const cache = await openCache(options.cacheName);
+  if (cache) {
+    try {
+      const hit = await cache.match(url);
+      if (hit && (!revalidate || await cachedCopyIsCurrent(url, hit, signal))) {
+        const total2 = Number(hit.headers.get("content-length")) || 0;
+        onProgress?.({ url, loaded: total2, total: total2, fromCache: true });
+        return hit;
+      }
+    } catch {
+    }
+  }
+  const response = await fetch(url, { signal });
+  if (!response.ok) {
+    throw new Error(`fetch ${url}: HTTP ${response.status}`);
+  }
+  const total = Number(response.headers.get("content-length")) || 0;
+  let body;
+  if (response.body && onProgress) {
+    const reader = response.body.getReader();
+    const parts = [];
+    let loaded = 0;
+    onProgress({ url, loaded, total, fromCache: false });
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      parts.push(value);
+      loaded += value.byteLength;
+      onProgress({ url, loaded, total, fromCache: false });
+    }
+    body = new Uint8Array(new ArrayBuffer(loaded));
+    let offset = 0;
+    for (const part of parts) {
+      body.set(part, offset);
+      offset += part.byteLength;
+    }
+  } else {
+    body = new Uint8Array(await response.arrayBuffer());
+    onProgress?.({
+      url,
+      loaded: body.byteLength,
+      total: total || body.byteLength,
+      fromCache: false
+    });
+  }
+  const headers = new Headers();
+  for (const name of ["content-type", "etag", "last-modified"]) {
+    const value = response.headers.get(name);
+    if (value) headers.set(name, value);
+  }
+  headers.set("content-length", String(body.byteLength));
+  const buffered = new Response(body, { status: 200, headers });
+  if (cache) {
+    try {
+      await cache.put(url, buffered.clone());
+    } catch {
+    }
+  }
+  return buffered;
+}
+async function fetchAssetBytes(url, options) {
+  return new Uint8Array(await (await fetchAsset(url, options)).arrayBuffer());
+}
+async function fetchAssetText(url, options) {
+  return (await fetchAsset(url, options)).text();
+}
+var NAIST_JDIC_FILES = [
+  "metadata.json",
+  "char_def.bin",
+  "matrix.mtx",
+  "dict.da",
+  "dict.vals",
+  "unk.bin",
+  "dict.wordsidx",
+  "dict.words"
+];
+async function inflate(bytes) {
+  if (typeof DecompressionStream === "undefined") {
+    throw new Error(
+      "DecompressionStream is not available; serve the dictionary uncompressed"
+    );
+  }
+  const stream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream("gzip"));
+  return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+async function loadNaistJdic(baseUrl, options = {}) {
+  const { compressed = true, ...fetchOptions } = options;
+  const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  const entries = await Promise.all(
+    NAIST_JDIC_FILES.map(async (name) => {
+      const raw = await fetchAssetBytes(
+        `${base}${name}${compressed ? ".gz" : ""}`,
+        fetchOptions
+      );
+      return [name, compressed ? await inflate(raw) : raw];
+    })
+  );
+  return Object.fromEntries(entries);
+}
+function initJpreprocessDictionary(module, data) {
+  module.init_dictionary(
+    data["metadata.json"],
+    data["char_def.bin"],
+    data["matrix.mtx"],
+    data["dict.da"],
+    data["dict.vals"],
+    data["unk.bin"],
+    data["dict.wordsidx"],
+    data["dict.words"]
+  );
+}
+
+// src/utautts/hts.ts
+var NUCLEUS = /* @__PURE__ */ new Set([
+  "a",
+  "i",
+  "u",
+  "e",
+  "o",
+  "A",
+  "I",
+  "U",
+  "E",
+  "O",
+  "N",
+  "cl"
+]);
+function softLimit(value, knee, max2) {
+  const magnitude = Math.abs(value);
+  const limited = magnitude <= knee ? magnitude : knee + (magnitude - knee) * 0.5;
+  return Math.sign(value) * Math.min(max2, limited);
+}
+var DEVOICED = /* @__PURE__ */ new Set(["A", "I", "U", "E", "O"]);
+function segmentPhonemes(phonemes) {
+  const segments = [];
+  let openStart = null;
+  for (let i = 0; i < phonemes.length; i++) {
+    const { phone, start_ms, duration_ms } = phonemes[i];
+    if (phone === "sil" || phone === "pau") {
+      if (openStart !== null) {
+        segments.push({
+          pause: false,
+          startMs: openStart,
+          durationMs: start_ms - openStart,
+          devoiced: false
+        });
+        openStart = null;
+      }
+      if (i === 0) continue;
+      segments.push({
+        pause: true,
+        startMs: start_ms,
+        durationMs: duration_ms,
+        devoiced: false
+      });
+      continue;
+    }
+    if (openStart === null) openStart = start_ms;
+    if (NUCLEUS.has(phone)) {
+      segments.push({
+        pause: false,
+        startMs: openStart,
+        durationMs: start_ms + duration_ms - openStart,
+        devoiced: DEVOICED.has(phone)
+      });
+      openStart = null;
+    }
+  }
+  if (openStart !== null) {
+    const last = phonemes[phonemes.length - 1];
+    segments.push({
+      pause: false,
+      startMs: openStart,
+      durationMs: last.start_ms + last.duration_ms - openStart,
+      devoiced: false
+    });
+  }
+  return segments;
+}
+function alignHtsProsody(frames, features, options = {}) {
+  const {
+    intonationStrength = 1,
+    frameMs = 10,
+    fallbackPauseMs = 150,
+    kneeCents = 400,
+    maxCents = 700
+  } = options;
+  const segments = segmentPhonemes(frames.phonemes);
+  const durations = new Array(features.length).fill(0);
+  const htsStart = new Array(features.length).fill(null);
+  const devoiced = 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;
+      }
+      continue;
+    }
+    if (!segment) return null;
+    durations[f2] = segment.durationMs;
+    htsStart[f2] = segment.startMs;
+    devoiced[f2] = segment.devoiced;
+    s++;
+  }
+  if (segments.slice(s).some((segment) => !segment.pause)) return null;
+  const f0 = frames.f0_hz;
+  const logF0 = new Float64Array(f0.length);
+  const voiced = [];
+  for (let i = 0; i < f0.length; i++) if (f0[i] > 0) voiced.push(i);
+  if (voiced.length === 0) return null;
+  const sorted = voiced.map((i) => f0[i]).sort((a, b) => a - b);
+  const medianHz = sorted[Math.floor(sorted.length / 2)];
+  for (let i = 0, v = 0; i < f0.length; i++) {
+    if (f0[i] > 0) {
+      logF0[i] = Math.log2(f0[i]);
+      continue;
+    }
+    while (v < voiced.length && voiced[v] < i) v++;
+    const right = voiced[v];
+    const left = v > 0 ? voiced[v - 1] : void 0;
+    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);
+      logF0[i] = Math.log2(f0[left]) * (1 - t) + Math.log2(f0[right]) * t;
+    }
+  }
+  const logMedian = Math.log2(medianHz);
+  const htsCentsAt = (tMs) => {
+    const position = Math.max(0, tMs) / frames.frame_ms;
+    const left = Math.min(logF0.length - 1, Math.floor(position));
+    const right = Math.min(logF0.length - 1, left + 1);
+    const t = position - Math.floor(position);
+    return (logF0[left] * (1 - t) + logF0[right] * t - logMedian) * 1200;
+  };
+  const planStart = [];
+  let cursor = 0;
+  for (let f2 = 0; f2 < features.length; f2++) {
+    planStart.push(cursor);
+    cursor += durations[f2];
+  }
+  const durationMs = cursor;
+  const count = Math.max(2, Math.ceil(durationMs / frameMs) + 2);
+  const cents = new Array(count);
+  let f = 0;
+  for (let frame = 0; frame < count; frame++) {
+    const tMs = frame * frameMs;
+    while (f + 1 < features.length && tMs >= planStart[f + 1]) f++;
+    const start = htsStart[f];
+    let htsMs;
+    if (start !== null) htsMs = start + (tMs - planStart[f]);
+    else {
+      const next = htsStart.slice(f + 1).find((value) => value !== null);
+      htsMs = next ?? frames.phonemes.at(-1)?.start_ms ?? 0;
+    }
+    cents[frame] = softLimit(
+      htsCentsAt(htsMs) * intonationStrength,
+      kneeCents,
+      maxCents
+    );
+  }
+  return {
+    moraDurationsMs: durations,
+    pitchCurve: { frame_ms: frameMs, cents },
+    medianHz,
+    durationMs,
+    devoiced
+  };
+}
+
+// src/utautts/openjtalk_features.ts
+var PUNCTUATION = /* @__PURE__ */ new Set(["\u3001", "\u3002", "\uFF1F", "\uFF01", ",", ".", "?", "!"]);
+var SMALL_KANA = /* @__PURE__ */ new Set(["\u3041", "\u3043", "\u3045", "\u3047", "\u3049", "\u3083", "\u3085", "\u3087", "\u308E", "\u3095", "\u3096"]);
+function toHiragana2(character) {
+  const code = character.charCodeAt(0);
+  if (12449 <= code && code <= 12534) {
+    return String.fromCharCode(code - 96);
+  }
+  return character;
+}
+function splitMorae(reading) {
+  const result = [];
+  const normalized = reading.normalize("NFC").replace(/'/g, "").replace(/’/g, "");
+  for (const character of normalized) {
+    if (/\s/.test(character) || PUNCTUATION.has(character)) {
+      if (result.length > 0 && !result[result.length - 1].pause) {
+        result.push({ mora: "", pause: true });
+      }
+      continue;
+    }
+    const mora = toHiragana2(character);
+    if (SMALL_KANA.has(mora) && result.length > 0 && !result[result.length - 1].pause) {
+      result[result.length - 1].mora += mora;
+    } else {
+      result.push({ mora, pause: false });
+    }
+  }
+  return result;
+}
+function isHigh(position, accent) {
+  if (accent === 1) return position === 1;
+  if (accent > 1) return 2 <= position && position <= accent;
+  return position >= 2;
+}
+function analyze2(nodes) {
+  const reading_parts = [];
+  const result = [];
+  let index = 0;
+  while (index < nodes.length) {
+    const node = nodes[index];
+    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 });
+      }
+      index++;
+      continue;
+    }
+    const phrase_nodes = [];
+    while (index < nodes.length) {
+      const current = nodes[index];
+      if (current.mora_size === 0 || PUNCTUATION.has(current.string)) {
+        break;
+      }
+      if (phrase_nodes.length > 0 && current.chain_flag !== 1) {
+        break;
+      }
+      const current_pronunciation = (current.pron || "").replace(/'/g, "").replace(/’/g, "");
+      const morae = splitMorae(current_pronunciation).filter((item) => !item.pause);
+      phrase_nodes.push({ current, morae });
+      reading_parts.push(current_pronunciation);
+      index++;
+    }
+    const phrase_length = phrase_nodes.reduce((sum, item) => sum + item.morae.length, 0);
+    const accent = phrase_nodes[0].current.acc || 0;
+    let phrase_position = 0;
+    for (const { current, morae } of phrase_nodes) {
+      for (let word_position = 1; word_position <= morae.length; word_position++) {
+        phrase_position++;
+        result.push({
+          mora: morae[word_position - 1].mora,
+          pause: false,
+          accent_phrase_position: phrase_position,
+          accent_phrase_length: phrase_length,
+          accent_nucleus: accent,
+          accent_high: isHigh(phrase_position, accent),
+          accent_phrase_start: phrase_position === 1,
+          accent_phrase_end: phrase_position === phrase_length,
+          word_start: word_position === 1,
+          word_end: word_position === morae.length,
+          pos: current.pos || "*",
+          pos_group1: current.pos_group1 || "*"
+        });
+      }
+    }
+  }
+  return { reading: reading_parts.join(""), features: result };
+}
+function sparse_features(token) {
+  if (token.pause || token.accent_phrase_position === void 0 || token.accent_phrase_length === void 0 || token.accent_nucleus === void 0) {
+    return {};
+  }
+  const phrase_length = Math.max(1, token.accent_phrase_length);
+  const phrase_position = token.accent_phrase_position;
+  const nucleus = token.accent_nucleus;
+  const result = {
+    "accent_position": phrase_position / phrase_length,
+    "accent_from_end": (phrase_length - phrase_position) / phrase_length,
+    "accent_nucleus_position": nucleus / phrase_length,
+    "accent_high": token.accent_high ? 1 : 0,
+    "accent_phrase_start": token.accent_phrase_start ? 1 : 0,
+    "accent_phrase_end": token.accent_phrase_end ? 1 : 0,
+    "word_start": token.word_start ? 1 : 0,
+    "word_end": token.word_end ? 1 : 0
+  };
+  result[`pos=${token.pos || "*"}`] = 1;
+  result[`pos_group1=${token.pos_group1 || "*"}`] = 1;
+  if (nucleus === 0) {
+    result["accent_type=heiban"] = 1;
+  } else if (phrase_position < nucleus) {
+    result["accent_type=before"] = 1;
+  } else if (phrase_position === nucleus) {
+    result["accent_type=nucleus"] = 1;
+  } else {
+    result["accent_type=after"] = 1;
+  }
+  return result;
+}
+
+// src/utautts/prosody_rules.ts
+var TRAILING = /[\s」』）)〕】＞>"'”’]+$/u;
+function isQuestion(text) {
+  return /[？?]$/u.test(text.replace(TRAILING, ""));
+}
+function smoothstep(t) {
+  const x = Math.min(1, Math.max(0, t));
+  return x * x * (3 - 2 * x);
+}
+function shapeProsody(prosody, features, options = {}) {
+  const {
+    question = false,
+    questionRiseCents = 350,
+    energyDbPerSemitone = 0.5,
+    devoicedGain = 0.5,
+    minGain = 0.35,
+    maxGain = 1.8
+  } = options;
+  const { frame_ms: frameMs } = prosody.pitchCurve;
+  const cents = prosody.pitchCurve.cents.slice();
+  const count = Math.min(features.length, prosody.moraDurationsMs.length);
+  const startFrame = [];
+  const endFrame = [];
+  let cursor = 0;
+  for (let f = 0; f < count; f++) {
+    startFrame.push(cursor / frameMs);
+    cursor += prosody.moraDurationsMs[f];
+    endFrame.push(cursor / frameMs);
+  }
+  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])))
+  ];
+  if (question && questionRiseCents > 0) {
+    let last = -1;
+    for (let f = count - 1; f >= 0; f--) {
+      if (!features[f].pause) {
+        last = f;
+        break;
+      }
+    }
+    if (last >= 0) {
+      const [from, to] = frameRange(last);
+      if (to > from) {
+        const existing = cents[to - 1] - cents[from];
+        const shortfall = questionRiseCents - existing;
+        if (shortfall > 0) {
+          for (let frame = from; frame < cents.length; frame++) {
+            const t = (frame - from) / (to - from);
+            cents[frame] += shortfall * smoothstep((t - 0.25) / 0.75);
+          }
+        }
+      }
+    }
+  }
+  const moraGains = new Array(features.length).fill(1);
+  for (let f = 0; f < count; f++) {
+    if (features[f].pause) continue;
+    let gainDb = 0;
+    if (energyDbPerSemitone !== 0) {
+      const [from, to] = frameRange(f);
+      if (to > from) {
+        let sum = 0;
+        for (let frame = from; frame < to; frame++) sum += cents[frame];
+        gainDb += sum / (to - from) / 100 * energyDbPerSemitone;
+      }
+    }
+    let gain = 10 ** (gainDb / 20);
+    if (prosody.devoiced[f]) gain *= devoicedGain;
+    moraGains[f] = Math.min(maxGain, Math.max(minGain, gain));
+  }
+  return {
+    ...prosody,
+    pitchCurve: { frame_ms: frameMs, cents },
+    moraGains
+  };
+}
+
 // src/utautts/UtauTTSAdapter.ts
-var UtauTTSAdapter = class {
-  worldline;
+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 f0At(timeline, tMs) {
+  const curve = timeline.f0_curve;
+  if (curve.length === 0) return timeline.reference_hz || 220;
+  const position = Math.max(0, tMs) / timeline.frame_ms;
+  const left = Math.floor(position);
+  if (left >= curve.length - 1) return curve[curve.length - 1];
+  const progress = position - left;
+  return curve[left] * (1 - progress) + curve[left + 1] * progress;
+}
+function applyMoraGains(plan, gains) {
+  const morae = plan.morae ?? [];
+  const timings = plan.mora_timings ?? [];
+  const byIndex = morae.length === gains.length;
+  const moraAt = (unit) => {
+    if (byIndex) return unit.position;
+    let found = -1;
+    for (let i = 0; i < timings.length && i < gains.length; i++) {
+      if (timings[i].StartMS <= unit.note_start_ms + 1e-6) found = i;
+      else break;
+    }
+    return found;
+  };
+  for (const unit of plan.timeline.units) {
+    const index = moraAt(unit);
+    const gain = gains[index];
+    if (index < 0 || gain === void 0 || !Number.isFinite(gain)) continue;
+    unit.volume *= gain;
+  }
+}
+function planChunks(units, firstChunkUnits, chunkUnits) {
+  const ranges = [];
+  if (units.length === 0) return ranges;
+  let start = 0;
+  let coveredEndMs = units[0].position_ms + units[0].length_ms;
+  let headSeam = false;
+  for (let i = 1; i <= units.length; i++) {
+    const limit = ranges.length === 0 ? firstChunkUnits : chunkUnits;
+    const atEnd = i === units.length;
+    const clean = !atEnd && units[i].position_ms >= coveredEndMs - 1e-6;
+    const full = !atEnd && i - start >= limit;
+    if (atEnd || clean || full) {
+      const tailSeam = !atEnd && !clean;
+      ranges.push({ start, end: i, headSeam, tailSeam });
+      start = i;
+      headSeam = tailSeam;
+      if (!atEnd) coveredEndMs = units[i].position_ms + units[i].length_ms;
+      continue;
+    }
+    coveredEndMs = Math.max(
+      coveredEndMs,
+      units[i].position_ms + units[i].length_ms
+    );
+  }
+  return ranges;
+}
+function seamTimeMs(next, crossfadeMs) {
+  const earliest = next.position_ms + next.fade_in_ms + crossfadeMs / 2;
+  const latest = next.position_ms + next.length_ms - crossfadeMs / 2;
+  return Math.min(
+    earliest,
+    Math.max(next.position_ms + crossfadeMs / 2, latest)
+  );
+}
+function applyFade(pcm, fromSample, samples, fadeIn) {
+  const n = Math.max(1, Math.min(samples, pcm.length - fromSample));
+  for (let k = 0; k < n; k++) {
+    const t = (k + 0.5) / n;
+    const gain = fadeIn ? Math.sin(Math.PI / 2 * t) : Math.cos(Math.PI / 2 * t);
+    pcm[fromSample + k] *= gain;
+  }
+}
+var UtauTTSAdapter = class _UtauTTSAdapter {
   constructor(worldline) {
     this.worldline = worldline;
   }
+  worldline;
+  static modelId = null;
+  bankAliases = /* @__PURE__ */ new WeakMap();
+  currentBank = null;
+  pcmCache = /* @__PURE__ */ new Map();
   /**
-   * Wasmモジュールを初期化します。
+   * Load the UtauTTS Go wasm. `wasm_exec.js` must already be on the page.
+   * Pass `fetch` (e.g. koe's `fetchAsset`) to stream from the Cache API.
    */
-  static async initializeWasm(wasmUrl = "utautts.wasm") {
+  static async initializeWasm(wasmUrl = "utautts.wasm", options = {}) {
+    if (typeof utautts_plan === "function") return;
     if (typeof Go === "undefined") {
-      throw new Error("wasm_exec.js must be loaded before calling initializeWasm.");
+      throw new Error(
+        "wasm_exec.js must be loaded before calling initializeWasm."
+      );
     }
     const go = new Go();
-    const response = await fetch(wasmUrl);
-    const buffer = await response.arrayBuffer();
-    const result = await WebAssembly.instantiate(buffer, go.importObject);
-    go.run(result.instance);
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    const responsePromise = (options.fetch ?? fetch)(wasmUrl);
+    let instance;
+    try {
+      instance = (await WebAssembly.instantiateStreaming(responsePromise, go.importObject)).instance;
+    } catch {
+      const bytes = await (await (options.fetch ?? fetch)(wasmUrl)).arrayBuffer();
+      instance = (await WebAssembly.instantiate(bytes, go.importObject)).instance;
+    }
+    void go.run(instance);
+    for (let attempt = 0; attempt < 100 && typeof utautts_plan !== "function"; attempt++) {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
     if (typeof utautts_plan !== "function") {
       throw new Error("utautts_plan failed to initialize in global scope.");
     }
   }
+  static get ready() {
+    return typeof utautts_plan === "function";
+  }
+  /** Parse and cache a prosody model (e.g. `frame-intonation-v8.json`) inside the wasm. */
+  static setModel(modelJSON) {
+    _UtauTTSAdapter.assertReady();
+    const result = utautts_set_model(modelJSON);
+    if (!result.success)
+      throw new Error(`UtauTTS model error: ${result.error}`);
+    _UtauTTSAdapter.modelId = result.id ?? null;
+    return _UtauTTSAdapter.modelId;
+  }
+  static get currentModelId() {
+    return _UtauTTSAdapter.modelId;
+  }
+  static assertReady() {
+    if (typeof utautts_plan !== "function") {
+      throw new Error(
+        "UtauTTS wasm is not initialized; call UtauTTSAdapter.initializeWasm() first."
+      );
+    }
+  }
   /**
-   * koe の VoiceBank から、UtauTTS Wasm に渡すための仮想 oto.ini 辞書を構築します。
+   * Register a koe voice bank with the planner: the manifest becomes a virtual
+   * oto.ini (koe PCM is pre-trimmed, so offset is 0) plus each sample's
+   * recorded pitch. Called automatically by {@link plan}; cheap when unchanged.
    */
-  buildOtoEntriesFromKoe(bank) {
+  setBank(bank) {
+    _UtauTTSAdapter.assertReady();
+    if (this.currentBank === bank && this.bankAliases.has(bank)) return;
     const entries = {};
-    const manifest = bank.manifest;
-    for (const [alias, phoneme] of Object.entries(manifest.phonemes)) {
-      entries[alias] = [{
-        Filename: `v_${alias}.wav`,
-        // Wasm内での識別用ダミーファイル名
-        Alias: alias,
-        Offset: 0,
-        // koe は事前にトリミング済みのため常に0
-        Fixed: phoneme.consonant / 48,
-        Preutterance: phoneme.pre / 48,
-        Overlap: phoneme.overlap / 48,
-        SourceGroup: "koe-bank"
-      }];
-    }
-    return entries;
+    const pitch = {};
+    for (const [alias, phoneme] of Object.entries(bank.manifest.phonemes)) {
+      entries[alias] = [
+        {
+          Filename: `koe:${alias}`,
+          Alias: alias,
+          Offset: 0,
+          Fixed: phoneme.consonant / 48,
+          Blank: 0,
+          Preutterance: phoneme.pre / 48,
+          Overlap: phoneme.overlap / 48,
+          SourceGroup: "koe"
+        }
+      ];
+      if (phoneme.pitch > 0) pitch[alias] = phoneme.pitch;
+    }
+    const result = utautts_set_bank(
+      JSON.stringify({
+        name: "koe",
+        oto_entries: entries,
+        source_pitch_hz: pitch
+      })
+    );
+    if (!result.success) throw new Error(`UtauTTS bank error: ${result.error}`);
+    this.bankAliases.set(bank, result.aliases ?? 0);
+    this.currentBank = bank;
+    this.pcmCache.clear();
   }
   /**
-   * 指定したテキストを合成するための Plan (発話計画) と音声を生成します。
+   * Plan an utterance: unit selection, timing, pitch contour and worldline
+   * placement. `features` are the mora-level frames from `openjtalkAnalyze`
+   * (pauses included); the kana reading is derived from them.
    */
-  async synthesizeText(bank, text, tone = "C4") {
-    const otoEntries = this.buildOtoEntriesFromKoe(bank);
+  plan(bank, text, features, options = {}) {
+    this.setBank(bank);
     const request = {
       text,
-      oto_entries: otoEntries,
-      tone,
-      duration_ms: 0
-      // UtauTTS側に自動計算させる
+      reading: readingFromFeatures(features),
+      frames: features.map((frame) => sparse_features(frame)),
+      tone: options.tone ?? "C4",
+      mora_duration_ms: options.moraDurationMs ?? 0,
+      pause_duration_ms: options.pauseDurationMs ?? 0,
+      release_ms: options.releaseMs ?? 20,
+      leading_preutterance_ms: options.leadingPreutteranceMs ?? 0,
+      apply_pitch: options.applyPitch ?? true,
+      intonation_strength: options.intonationStrength ?? 1,
+      speech_timing: options.speechTiming ?? false,
+      word_boundary_envelope: options.wordBoundaryEnvelope ?? false,
+      mora_durations_ms: options.prosody?.moraDurationsMs,
+      pitch_curve: options.prosody?.pitchCurve
     };
     const response = utautts_plan(JSON.stringify(request));
-    if (!response.success) {
-      throw new Error(`UtauTTS Error: ${response.error}`);
+    if (!response.success || !response.plan) {
+      throw new Error(`UtauTTS error: ${response.error ?? "no plan"}`);
     }
     const plan = JSON.parse(response.plan);
-    console.log("Generated TTS Plan:", plan);
-    const phraseUnits = [];
-    let currentPosMs = 0;
-    for (const unit of plan.units) {
-      const pcm = await bank.getPcm(unit.alias);
-      if (!pcm) {
-        console.warn(`PCM not found for alias: ${unit.alias}`);
-        continue;
+    const gains = options.prosody?.moraGains;
+    if (gains) applyMoraGains(plan, gains);
+    return plan;
+  }
+  getPcm(bank, alias) {
+    let cached = this.pcmCache.get(alias);
+    if (!cached) {
+      cached = bank.getPcm(alias);
+      this.pcmCache.set(alias, cached);
+    }
+    return cached;
+  }
+  /**
+   * Render a plan chunk by chunk. Each chunk is independent audio positioned
+   * at `startMs`; schedule them as they arrive (see the demo) or sum them.
+   *
+   * Chunk breaks fall on pauses when possible. Inside a phrase a break renders
+   * one neighbouring unit of context on each side so the unit crossfade stays
+   * WORLD's spectral one, then the two renders are joined with a short
+   * equal-power crossfade in the following vowel.
+   */
+  async *renderChunks(bank, plan, options = {}) {
+    const {
+      firstChunkUnits = 3,
+      chunkUnits = 6,
+      seamCrossfadeMs = 20,
+      signal
+    } = options;
+    const timeline = plan.timeline;
+    const units = timeline.units.filter((unit) => unit.length_ms > 0);
+    const ranges = planChunks(
+      units,
+      Math.max(1, firstChunkUnits),
+      Math.max(1, chunkUnits)
+    );
+    const crossfadeSamples = Math.max(2, msToSamples2(seamCrossfadeMs));
+    for (let index = 0; index < ranges.length; index++) {
+      if (signal?.aborted) return;
+      const range = ranges[index];
+      const renderStart = range.headSeam ? range.start - 1 : range.start;
+      const renderEnd = range.tailSeam ? range.end + 1 : range.end;
+      const rendered = units.slice(renderStart, renderEnd);
+      const baseMs = Math.min(...rendered.map((unit) => unit.position_ms));
+      const phraseUnits = [];
+      for (const unit of rendered) {
+        const pcm2 = await this.getPcm(bank, unit.alias);
+        if (!pcm2 || pcm2.length < MIN_WORLDLINE_SAMPLES) {
+          console.warn(
+            `[utautts] no usable PCM for alias "${unit.alias}"; skipped`
+          );
+          continue;
+        }
+        phraseUnits.push({
+          pcm: pcm2,
+          posMs: unit.position_ms - baseMs,
+          skipMs: unit.skip_ms,
+          lengthMs: unit.length_ms,
+          fadeInMs: unit.fade_in_ms,
+          fadeOutMs: unit.fade_out_ms,
+          consonantMs: unit.consonant_ms,
+          requiredLengthMs: unit.required_length_ms,
+          volume: unit.volume,
+          tone: unit.tone
+        });
       }
-      phraseUnits.push({
-        pcm,
-        posMs: currentPosMs,
-        skipMs: unit.offset_ms,
-        lengthMs: unit.duration_ms,
-        fadeInMs: unit.overlap_ms,
-        fadeOutMs: unit.overlap_ms,
-        // 次ノートとのクロスフェードとして設定
-        consonantMs: unit.consonant_ms
+      if (signal?.aborted) return;
+      if (phraseUnits.length === 0) continue;
+      const audio = this.worldline.renderPhrase({
+        units: phraseUnits,
+        pitch: (tMs) => f0At(timeline, baseMs + tMs),
+        gender: options.gender,
+        tension: options.tension,
+        breathiness: options.breathiness,
+        voicing: options.voicing
       });
-      currentPosMs += unit.duration_ms;
-    }
-    const baseHz = 261.63;
-    let pitchInput = baseHz;
-    if (plan.pitch_cents && plan.pitch_frame_ms) {
-      const frameMs = plan.pitch_frame_ms;
-      const centsArr = plan.pitch_cents;
-      pitchInput = (tMs, totalMs) => {
-        const frameIndex = Math.floor(tMs / frameMs);
-        if (frameIndex < 0 || frameIndex >= centsArr.length) return baseHz;
-        const centsOffset = centsArr[frameIndex];
-        return baseHz * Math.pow(2, centsOffset / 1200);
-      };
-    }
-    const outPcm = this.worldline.renderPhrase({
-      units: phraseUnits,
-      pitch: pitchInput
-    });
-    if (outPcm) {
-      console.log(`Successfully generated audio: ${outPcm.length} samples.`);
-    } else {
-      console.error("Audio generation failed.");
+      if (!audio || audio.length === 0) continue;
+      let fromSample = 0;
+      let toSample = audio.length;
+      let startMs = baseMs;
+      if (range.headSeam) {
+        const seamMs = seamTimeMs(units[range.start], seamCrossfadeMs);
+        fromSample = Math.max(
+          0,
+          msToSamples2(seamMs - baseMs) - crossfadeSamples / 2
+        );
+        startMs = baseMs + fromSample / FS * 1e3;
+      }
+      if (range.tailSeam) {
+        const seamMs = seamTimeMs(units[range.end], seamCrossfadeMs);
+        toSample = Math.min(
+          audio.length,
+          msToSamples2(seamMs - baseMs) + crossfadeSamples / 2
+        );
+      }
+      if (toSample <= fromSample) continue;
+      const pcm = audio.slice(fromSample, toSample);
+      if (range.headSeam) applyFade(pcm, 0, crossfadeSamples, true);
+      if (range.tailSeam)
+        applyFade(
+          pcm,
+          Math.max(0, pcm.length - crossfadeSamples),
+          crossfadeSamples,
+          false
+        );
+      yield { pcm, startMs, index, units: units.slice(range.start, range.end) };
+      await new Promise((resolve) => setTimeout(resolve, 0));
     }
-    return outPcm;
+  }
+  /**
+   * Plan + render an utterance into one buffer (Float32, 48 kHz) covering the
+   * whole timeline. Use {@link plan} + {@link renderChunks} for streaming.
+   */
+  async synthesizeText(bank, text, features, options = {}) {
+    const plan = this.plan(bank, text, features, options);
+    const total = msToSamples2(plan.timeline.duration_ms) + msToSamples2(200);
+    const out = new Float32Array(total);
+    let any = false;
+    for await (const chunk of this.renderChunks(bank, plan, options)) {
+      any = true;
+      const offset = msToSamples2(chunk.startMs);
+      const n = Math.min(chunk.pcm.length, out.length - offset);
+      for (let k = 0; k < n; k++) out[offset + k] += chunk.pcm[k];
+    }
+    return any ? out : null;
   }
 };
 export {
   KoeEngine,
   MIN_WORLDLINE_SAMPLES,
+  NAIST_JDIC_FILES,
   UtauTTSAdapter,
   VoiceBank,
   WORLDLINE_SAMPLE_RATE,
   Worldline,
+  alignHtsProsody,
   analyze,
   analyzeWav,
   detectF0,
@@ -3269,15 +4026,22 @@ export {
   estimateSequence,
   estimateSolo,
   estimateVowelJoin,
+  fetchAsset,
+  fetchAssetBytes,
+  fetchAssetText,
   formatOto,
   frqAverageF0InRange,
   frqFileName,
   generateOto,
   generateOtoForFile,
+  initJpreprocessDictionary,
+  isQuestion,
   leadInFromEntry,
+  loadNaistJdic,
   locateMora,
   normalizePcm,
   noteNameToHz,
+  analyze2 as openjtalkAnalyze,
   otoRegion,
   pack,
   packKoe,
@@ -3289,8 +4053,11 @@ export {
   pcmBase,
   pitchFromAliasSuffix,
   readWavPcm48k,
+  readingFromFeatures,
   resample,
   samplesToMs,
+  shapeProsody,
+  sparse_features,
   splitKana,
   suffixFromFolderName,
   summarise,