@onjmin/dtm 2.1.12 → 2.1.14

package/dist/voice-worker.js

@@ -1,6 +1,6 @@
 "use strict";
 (() => {
-  // node_modules/.pnpm/@onjmin+koe@1.0.5/node_modules/@onjmin/koe/dist/index.js
+  // node_modules/.pnpm/@onjmin+koe@1.0.10/node_modules/@onjmin/koe/dist/index.js
   var u8 = Uint8Array;
   var u16 = Uint16Array;
   var i32 = Int32Array;
@@ -388,6 +388,130 @@
      * @returns Float32 PCM, or null when `pcm` is shorter than
      *          {@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;
+      if (units.length === 0) return null;
+      const WL = this.wasm;
+      const FS2 = WORLDLINE_SAMPLE_RATE;
+      let totalMs = 0;
+      for (const u of units) {
+        const endMs = u.posMs + u.lengthMs;
+        if (endMs > totalMs) totalMs = endMs;
+      }
+      const ps = WL._PhraseSynthNew();
+      if (!ps) return null;
+      const pointersToFree = [];
+      for (const u of units) {
+        if (!u.pcm || u.pcm.length < MIN_WORLDLINE_SAMPLES) continue;
+        const reqPtr = WL._malloc(SYNTH_REQ_SIZE);
+        if (!reqPtr) continue;
+        pointersToFree.push(reqPtr);
+        const samplePtr = WL._malloc(u.pcm.length * 8);
+        if (!samplePtr) continue;
+        pointersToFree.push(samplePtr);
+        WL.HEAPF64.set(u.pcm, samplePtr >> 3);
+        const sv = (off, val, type) => WL.setValue(reqPtr + off, val, type);
+        sv(0, FS2, "i32");
+        sv(4, u.pcm.length, "i32");
+        sv(8, samplePtr, "*");
+        sv(12, 0, "i32");
+        sv(16, 0, "*");
+        sv(20, u.tone ?? 69, "i32");
+        sv(24, 100, "double");
+        sv(32, 0, "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, u.volume ?? 100, "double");
+        sv(72, 0, "double");
+        sv(80, tempo, "double");
+        sv(88, 0, "i32");
+        sv(92, 0, "*");
+        sv(96, 0, "i32");
+        sv(100, 0, "i32");
+        sv(104, 100, "i32");
+        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
+        );
+      }
+      totalMs += WL_FRAME_MS * 2;
+      const nFrames = Math.ceil(totalMs / WL_FRAME_MS) + 4;
+      const f0Arr = new Float64Array(nFrames);
+      const gArr = new Float64Array(nFrames);
+      const tArr = new Float64Array(nFrames);
+      const bArr = new Float64Array(nFrames);
+      const vArr = new Float64Array(nFrames);
+      for (let i2 = 0; i2 < nFrames; i2++) {
+        const tMs = i2 * WL_FRAME_MS;
+        f0Arr[i2] = sampleCurve(tMs, pitch, totalMs);
+        gArr[i2] = sampleCurve(tMs, gender, totalMs);
+        tArr[i2] = sampleCurve(tMs, tension, totalMs);
+        bArr[i2] = sampleCurve(tMs, breathiness, totalMs);
+        vArr[i2] = sampleCurve(tMs, voicing, totalMs);
+      }
+      const f0Ptr = WL._malloc(nFrames * 8);
+      const gPtr = WL._malloc(nFrames * 8);
+      const tPtr = WL._malloc(nFrames * 8);
+      const bPtr = WL._malloc(nFrames * 8);
+      const vPtr = WL._malloc(nFrames * 8);
+      if (f0Ptr && gPtr && tPtr && bPtr && vPtr) {
+        WL.HEAPF64.set(f0Arr, f0Ptr >> 3);
+        WL.HEAPF64.set(gArr, gPtr >> 3);
+        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
+        );
+      }
+      if (f0Ptr) WL._free(f0Ptr);
+      if (gPtr) WL._free(gPtr);
+      if (tPtr) WL._free(tPtr);
+      if (bPtr) WL._free(bPtr);
+      if (vPtr) WL._free(vPtr);
+      const yPtrPtr = WL._malloc(4);
+      let audio = null;
+      if (yPtrPtr) {
+        const outLen = WL._PhraseSynthSynth(ps, yPtrPtr, 0);
+        const yPtr = WL.getValue(yPtrPtr, "*");
+        if (outLen > 0 && yPtr) {
+          audio = new Float32Array(WL.HEAPF32.buffer, yPtr, outLen).slice();
+          WL._free(yPtr);
+        }
+        WL._free(yPtrPtr);
+      }
+      for (const ptr of pointersToFree) {
+        WL._free(ptr);
+      }
+      WL._PhraseSynthDelete(ps);
+      return audio;
+    }
     renderNote(params) {
       const {
         pcm,
@@ -403,8 +527,12 @@
       } = 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;
@@ -424,7 +552,7 @@
       }
       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");
@@ -512,6 +640,370 @@
       return audio;
     }
   };
+  var RATE = 16e3;
+  var HOP_MS = 2;
+  var HOP = RATE * HOP_MS / 1e3;
+  var FFT_SIZE = 512;
+  var BINS = FFT_SIZE / 2;
+  var PITCH_DECIM = 2;
+  var PITCH_RATE = RATE / PITCH_DECIM;
+  var WINDOW_CENTRE_MS = FFT_SIZE / 2 / RATE * 1e3;
+  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;
+  }
+  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 i2 = 0; i2 < timings.length && i2 < gains.length; i2++) {
+        if (timings[i2].StartMS <= unit.note_start_ms + 1e-6) found = i2;
+        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 i2 = 1; i2 <= units.length; i2++) {
+      const limit = ranges.length === 0 ? firstChunkUnits : chunkUnits;
+      const atEnd = i2 === units.length;
+      const clean = !atEnd && units[i2].position_ms >= coveredEndMs - 1e-6;
+      const full = !atEnd && i2 - start >= limit;
+      if (atEnd || clean || full) {
+        const tailSeam = !atEnd && !clean;
+        ranges.push({ start, end: i2, headSeam, tailSeam });
+        start = i2;
+        headSeam = tailSeam;
+        if (!atEnd) coveredEndMs = units[i2].position_ms + units[i2].length_ms;
+        continue;
+      }
+      coveredEndMs = Math.max(
+        coveredEndMs,
+        units[i2].position_ms + units[i2].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(worldline2) {
+      this.worldline = worldline2;
+    }
+    worldline;
+    static modelId = null;
+    bankAliases = /* @__PURE__ */ new WeakMap();
+    currentBank = null;
+    pcmCache = /* @__PURE__ */ new Map();
+    /**
+     * 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", options = {}) {
+      if (typeof utautts_plan === "function") return;
+      if (typeof Go === "undefined") {
+        throw new Error(
+          "wasm_exec.js must be loaded before calling initializeWasm."
+        );
+      }
+      const go = new Go();
+      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."
+        );
+      }
+    }
+    /**
+     * 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.
+     */
+    setBank(bank2) {
+      _UtauTTSAdapter.assertReady();
+      if (this.currentBank === bank2 && this.bankAliases.has(bank2)) return;
+      const entries = {};
+      const pitch = {};
+      for (const [alias, phoneme] of Object.entries(bank2.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(bank2, result.aliases ?? 0);
+      this.currentBank = bank2;
+      this.pcmCache.clear();
+    }
+    /**
+     * 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.
+     */
+    plan(bank2, text, features, options = {}) {
+      this.setBank(bank2);
+      const request = {
+        text,
+        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 || !response.plan) {
+        throw new Error(`UtauTTS error: ${response.error ?? "no plan"}`);
+      }
+      const plan = JSON.parse(response.plan);
+      const gains = options.prosody?.moraGains;
+      if (gains) applyMoraGains(plan, gains);
+      return plan;
+    }
+    getPcm(bank2, alias) {
+      let cached = this.pcmCache.get(alias);
+      if (!cached) {
+        cached = bank2.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(bank2, 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(bank2, 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
+          });
+        }
+        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
+        });
+        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));
+      }
+    }
+    /**
+     * Plan + render an utterance into one buffer (Float32, 48 kHz) covering the
+     * whole timeline. Use {@link plan} + {@link renderChunks} for streaming.
+     */
+    async synthesizeText(bank2, text, features, options = {}) {
+      const plan = this.plan(bank2, 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(bank2, 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;
+    }
+  };
 
   // src/vibrato.ts
   var VIBRATO_RATE_HZ = 5.5;
@@ -589,6 +1081,8 @@
   var wself = globalThis;
   var bank = null;
   var worldline = null;
+  var speechAdapter = null;
+  var speechAborts = /* @__PURE__ */ new Map();
   var pcmCache = /* @__PURE__ */ new Map();
   var getPcm = (alias) => {
     let p = pcmCache.get(alias);
@@ -701,7 +1195,8 @@
         );
         wself.postMessage({
           type: "ready",
-          aliases: Object.keys(bank.manifest.phonemes)
+          aliases: Object.keys(bank.manifest.phonemes),
+          phonemes: bank.manifest.phonemes
         });
       } catch (err) {
         wself.postMessage({
@@ -751,6 +1246,53 @@
       } catch {
         wself.postMessage({ type: "rendered", id, pcm: null });
       }
+      return;
+    }
+    if (msg.type === "speak-abort") {
+      speechAborts.get(msg.id)?.abort();
+      return;
+    }
+    if (msg.type === "speak") {
+      const { id, plan, gender, breathiness, tension } = msg;
+      if (!bank || !worldline) {
+        wself.postMessage({
+          type: "speech-end",
+          id,
+          error: "speech needs worldline (not available in lightweight mode)"
+        });
+        return;
+      }
+      const abort = new AbortController();
+      speechAborts.set(id, abort);
+      try {
+        speechAdapter ??= new UtauTTSAdapter(worldline);
+        for await (const chunk of speechAdapter.renderChunks(bank, plan, {
+          signal: abort.signal,
+          gender,
+          breathiness,
+          tension
+        })) {
+          wself.postMessage(
+            {
+              type: "speech-chunk",
+              id,
+              pcm: chunk.pcm,
+              startMs: chunk.startMs,
+              index: chunk.index
+            },
+            [chunk.pcm.buffer]
+          );
+        }
+        wself.postMessage({ type: "speech-end", id });
+      } catch (err) {
+        wself.postMessage({
+          type: "speech-end",
+          id,
+          error: String(err?.message ?? err)
+        });
+      } finally {
+        speechAborts.delete(id);
+      }
     }
   };
 })();

package/package.json

@@ -2,7 +2,7 @@
   "author": "onjmin",
   "license": "MIT",
   "name": "@onjmin/dtm",
-  "version": "2.1.12",
+  "version": "2.1.14",
   "description": "MMLを中間言語に用いた、モバイルファーストなDAW / ピアノロール打ち込みコンポーネント",
   "homepage": "https://onjmin.github.io/dtm",
   "repository": {
@@ -56,14 +56,15 @@
   },
   "dependencies": {
     "@onjmin/chord-parser": "1.1.1",
-    "@onjmin/koe": "1.0.5",
+    "@onjmin/koe": "1.0.10",
     "midi-json-parser": "8.1.74"
   },
   "scripts": {
     "dev": "rimraf dist && tsup && biome format src --write && tsx demo/server.ts",
     "build": "rimraf dist && tsup && biome format src --write",
     "check": "biome check src --write",
-    "test": "tsx scripts/check-version.ts && tsx scripts/check-compose.ts && tsx scripts/check-registers.ts && tsx scripts/check-tracks.ts && tsx scripts/check-lyrics-fade.ts && tsx scripts/check-pitch-glide.ts && tsx scripts/check-ust.ts && tsx scripts/check-musicxml.ts && tsx scripts/check-backing-audio.ts",
+    "version": "tsx scripts/sync-version.ts && git add src/version.ts docs/dataset-provenance.md",
+    "test": "tsx scripts/check-version.ts && tsx scripts/check-compose.ts && tsx scripts/check-registers.ts && tsx scripts/check-tracks.ts && tsx scripts/check-lyrics-fade.ts && tsx scripts/check-speech-lyrics.ts && tsx scripts/check-pitch-glide.ts && tsx scripts/check-ust.ts && tsx scripts/check-musicxml.ts && tsx scripts/check-backing-audio.ts && tsx scripts/check-mml-meta.ts && tsx scripts/check-macro-state.ts",
     "patch": "pnpm version patch",
     "minor": "pnpm version minor",
     "major": "pnpm version major",