Replace synthesized hits with a licensed sampled arcade kit

README.md

@@ -29,9 +29,11 @@ The Space uses Gradio Server mode with a fully custom, responsive interface.
 Upload a song, pick a difficulty, and get a full-song mel/plan preview, a
 full TJA chart image, a `.tja` playable in TJAPlayer3 / OpenTaiko, and a
 synchronized WAV mix that lets you hear the generated chart performed over
-the source music immediately. The original, arcade-tuned wadaiko kit is
-synthesized by SoftChart and does not contain audio taken from a commercial
-game.
+the source music immediately. The original, arcade-tuned kit is built from
+hash-pinned CC0 head and rim recordings from the
+[Chinese Bass Drum Dagu Oneshots](https://freesound.org/people/sazanami12/packs/45781/)
+pack. SoftChart transforms those recordings offline and does not contain audio
+taken from a commercial game.
 
 The generation API streams the real processing stages to the interface:
 audio analysis, beat-grid fitting, song-level planning, note generation,

softchart/assets/taiko/README.md

@@ -0,0 +1,16 @@
+# SoftChart Arcade Taiko Kit
+
+These one-shots are original SoftChart transformations of the **Chinese Bass
+Drum Dagu Oneshots** pack recorded in Taipei by `sazanami12`:
+
+- Source: https://freesound.org/people/sazanami12/packs/45781/
+- License: CC0 1.0 — https://creativecommons.org/publicdomain/zero/1.0/
+- Build recipe: `scripts/build_taiko_bank.py`
+- Exact source and output hashes: `manifest.json`
+
+The source instrument is a Chinese Huapengu / Dagu, selected as a
+redistributable large East-Asian barrel-drum recording with isolated head and
+rim articulations. It is not represented as a Japanese wadaiko recording.
+
+No audio from Taiko no Tatsujin or any other commercial game is included,
+transformed, embedded, or required by the build.

softchart/assets/taiko/manifest.json

@@ -0,0 +1,328 @@
+{
+  "schema_version": 1,
+  "kit_id": "softchart-arcade-taiko-cc0",
+  "license": "CC0-1.0",
+  "license_url": "https://creativecommons.org/publicdomain/zero/1.0/",
+  "source_pack_url": "https://freesound.org/people/sazanami12/packs/45781/",
+  "source_creator": "sazanami12",
+  "source_instrument": "Chinese Huapengu / Dagu recorded in Taipei, Taiwan",
+  "source_encoding": "public Freesound HQ OGG preview of the CC0 original WAV",
+  "sources": [
+    {
+      "sound_id": 856549,
+      "label": "center-loud",
+      "sha256": "26d230aff7bb043fc88e823d7eecf00f807208f4c1d4d27c2cc1a7a2773b9d87",
+      "preview_url": "https://cdn.freesound.org/previews/856/856549_17110092-hq.ogg"
+    },
+    {
+      "sound_id": 856550,
+      "label": "center-soft",
+      "sha256": "78ed9dea56102480811e90a9653c08fe20a0eca5793c9c936f1c2592042b9a46",
+      "preview_url": "https://cdn.freesound.org/previews/856/856550_17110092-hq.ogg"
+    },
+    {
+      "sound_id": 856551,
+      "label": "edge-loud",
+      "sha256": "85ff2986eb902296e541a9d44b21bb61b9c2b8a05b5510be2fac9fbc99738399",
+      "preview_url": "https://cdn.freesound.org/previews/856/856551_17110092-hq.ogg"
+    },
+    {
+      "sound_id": 856552,
+      "label": "edge-soft",
+      "sha256": "85600ed1ddfab1c56fe07268f5fd68073706da8cd9a2f0cf7f16bde30bb8bb3e",
+      "preview_url": "https://cdn.freesound.org/previews/856/856552_17110092-hq.ogg"
+    },
+    {
+      "sound_id": 856557,
+      "label": "rim-right",
+      "sha256": "6c24ee738d5995121fa85a432223a2afadb585f2a67b253747e2db0b3796bca0",
+      "preview_url": "https://cdn.freesound.org/previews/856/856557_17110092-hq.ogg"
+    },
+    {
+      "sound_id": 856558,
+      "label": "rim-left",
+      "sha256": "5ac219e4254f27c4a3b5b581f5c67e7c72fe91fa3d0fb2e03d021793febc1872",
+      "preview_url": "https://cdn.freesound.org/previews/856/856558_17110092-hq.ogg"
+    },
+    {
+      "sound_id": 856559,
+      "label": "rim-both-loud",
+      "sha256": "840a559e5d979e483cec2afb64e4f71a27d31c753c1bb138395303c5bd0d8253",
+      "preview_url": "https://cdn.freesound.org/previews/856/856559_17110092-hq.ogg"
+    },
+    {
+      "sound_id": 856560,
+      "label": "rim-both-soft",
+      "sha256": "4d66f33d35d2fe160da02c9a310231cdd6f2e8724dcfa7706de9c8409b5b7f97",
+      "preview_url": "https://cdn.freesound.org/previews/856/856560_17110092-hq.ogg"
+    }
+  ],
+  "files": [
+    {
+      "filename": "balloon-01.wav",
+      "kind": "balloon",
+      "round_robin": 1,
+      "sha256": "241042aeb27bf7ca310c65fb1130554c3f5501b735d4178c9a65227a3c3962b7",
+      "pcm_sha256": "d86c418410b1f009dbc0a1f1cbc81dbe6ac52b1707002f7595c48c973fd309c0",
+      "sample_rate": 44100,
+      "channels": 1,
+      "frames": 5954,
+      "anchor_frame": 0,
+      "source_sound_ids": [
+        856552,
+        856559
+      ],
+      "profile": {
+        "centroid_hz": 144.684,
+        "attack_centroid_hz": 2085.291,
+        "t90_seconds": 0.088254,
+        "t99_seconds": 0.101973,
+        "crest_db": 10.255
+      }
+    },
+    {
+      "filename": "balloon-02.wav",
+      "kind": "balloon",
+      "round_robin": 2,
+      "sha256": "9e9b9ae2067e3b8c35d4bef011aea160ac6b2c955b861b48fcdd977e9784a96e",
+      "pcm_sha256": "90a5802c2b25e55fdfd39b394f505e302aa13e4435418c494aff807a51bdfefd",
+      "sample_rate": 44100,
+      "channels": 1,
+      "frames": 5954,
+      "anchor_frame": 0,
+      "source_sound_ids": [
+        856550,
+        856559
+      ],
+      "profile": {
+        "centroid_hz": 154.871,
+        "attack_centroid_hz": 2160.392,
+        "t90_seconds": 0.087846,
+        "t99_seconds": 0.101927,
+        "crest_db": 11.393
+      }
+    },
+    {
+      "filename": "don-01.wav",
+      "kind": "don",
+      "round_robin": 1,
+      "sha256": "b0ae8c300223ca2092da3ebac7d5318978926935cc5f5de63339ca06e4552c94",
+      "pcm_sha256": "2fcc51eed16cf540288ad5b99153afea9f4ba599dc4921595852792cd4ee2163",
+      "sample_rate": 44100,
+      "channels": 1,
+      "frames": 36603,
+      "anchor_frame": 0,
+      "source_sound_ids": [
+        856552,
+        856559
+      ],
+      "profile": {
+        "centroid_hz": 106.922,
+        "attack_centroid_hz": 2085.291,
+        "t90_seconds": 0.279342,
+        "t99_seconds": 0.424104,
+        "crest_db": 13.942
+      }
+    },
+    {
+      "filename": "don-02.wav",
+      "kind": "don",
+      "round_robin": 2,
+      "sha256": "668748702af4b40922954685d4b416f6402c905f1ef7e9172f13d1a201f05c14",
+      "pcm_sha256": "5116770059c6891ce90b2f0eb39e15ee9cc37a851d9df10165c9e15638f18ad7",
+      "sample_rate": 44100,
+      "channels": 1,
+      "frames": 36603,
+      "anchor_frame": 0,
+      "source_sound_ids": [
+        856550,
+        856559
+      ],
+      "profile": {
+        "centroid_hz": 113.558,
+        "attack_centroid_hz": 2160.392,
+        "t90_seconds": 0.286984,
+        "t99_seconds": 0.403673,
+        "crest_db": 14.121
+      }
+    },
+    {
+      "filename": "don-big.wav",
+      "kind": "don_big",
+      "round_robin": 1,
+      "sha256": "38d7bee2a772c45fe935bab378f7aedaf73746fb78972fc538cf37d8c81c20cd",
+      "pcm_sha256": "29823b5ff47f93217360db5019f2c805bf5e36c0658b7fb8bdf9fec051636ecf",
+      "sample_rate": 44100,
+      "channels": 1,
+      "frames": 39470,
+      "anchor_frame": 0,
+      "source_sound_ids": [
+        856550,
+        856559
+      ],
+      "profile": {
+        "centroid_hz": 105.346,
+        "attack_centroid_hz": 2440.045,
+        "t90_seconds": 0.379365,
+        "t99_seconds": 0.557619,
+        "crest_db": 13.246
+      }
+    },
+    {
+      "filename": "ka-01.wav",
+      "kind": "ka",
+      "round_robin": 1,
+      "sha256": "7091db93a0d8bcb9a58d08e00c1052c9c057784a72ed7a445e7e04e1fb854192",
+      "pcm_sha256": "c7d95d820c95ecaa955b0a47739b1c7ab025b4a99f9c076bbef7a1b18f30215d",
+      "sample_rate": 44100,
+      "channels": 1,
+      "frames": 17949,
+      "anchor_frame": 0,
+      "source_sound_ids": [
+        856559,
+        856557
+      ],
+      "profile": {
+        "centroid_hz": 2083.859,
+        "attack_centroid_hz": 4187.299,
+        "t90_seconds": 0.061202,
+        "t99_seconds": 0.123469,
+        "crest_db": 20.018
+      }
+    },
+    {
+      "filename": "ka-02.wav",
+      "kind": "ka",
+      "round_robin": 2,
+      "sha256": "6dfcaad357908e139e98e62d748659ef0484337b7f04b66db6a4f4c4071120a8",
+      "pcm_sha256": "b8d50d62a9a71db0effbb34421958aa40776e44f0573baa271f32cb6881e96ce",
+      "sample_rate": 44100,
+      "channels": 1,
+      "frames": 17949,
+      "anchor_frame": 0,
+      "source_sound_ids": [
+        856557,
+        856558
+      ],
+      "profile": {
+        "centroid_hz": 1926.337,
+        "attack_centroid_hz": 3862.82,
+        "t90_seconds": 0.058141,
+        "t99_seconds": 0.107732,
+        "crest_db": 22.327
+      }
+    },
+    {
+      "filename": "ka-big.wav",
+      "kind": "ka_big",
+      "round_robin": 1,
+      "sha256": "dd72eb84c579eaa9ec2f04fe1e78f1cc497b5bf425b32a75788398379b1f2964",
+      "pcm_sha256": "40e876586926aecc06b91bfc60a1d00d33832fd34f334799d7c46e16921a6ea4",
+      "sample_rate": 44100,
+      "channels": 1,
+      "frames": 17949,
+      "anchor_frame": 0,
+      "source_sound_ids": [
+        856559,
+        856557,
+        856558
+      ],
+      "profile": {
+        "centroid_hz": 1986.528,
+        "attack_centroid_hz": 4484.582,
+        "t90_seconds": 0.061224,
+        "t99_seconds": 0.125624,
+        "crest_db": 19.782
+      }
+    },
+    {
+      "filename": "roll-01.wav",
+      "kind": "roll",
+      "round_robin": 1,
+      "sha256": "12bdee9caf1c8b17f2c56cce90078f25837a9670c939ceaabdd4cc524ebd9100",
+      "pcm_sha256": "19c20b070f3f23eab146d1a3b864a5827e68afe52224ccd3d7b23a2413f242a6",
+      "sample_rate": 44100,
+      "channels": 1,
+      "frames": 6615,
+      "anchor_frame": 0,
+      "source_sound_ids": [
+        856552,
+        856559
+      ],
+      "profile": {
+        "centroid_hz": 139.363,
+        "attack_centroid_hz": 2085.291,
+        "t90_seconds": 0.094785,
+        "t99_seconds": 0.113311,
+        "crest_db": 9.782
+      }
+    },
+    {
+      "filename": "roll-02.wav",
+      "kind": "roll",
+      "round_robin": 2,
+      "sha256": "2abd129bdb4e8c73aa44d071c386a8fc643f613c9b0cec1c84a339073e8bc681",
+      "pcm_sha256": "d4f9ca68263e903188eed4844a70041c38bb8f1c026331c28802771de606274b",
+      "sample_rate": 44100,
+      "channels": 1,
+      "frames": 6615,
+      "anchor_frame": 0,
+      "source_sound_ids": [
+        856550,
+        856559
+      ],
+      "profile": {
+        "centroid_hz": 154.227,
+        "attack_centroid_hz": 2160.392,
+        "t90_seconds": 0.096259,
+        "t99_seconds": 0.114195,
+        "crest_db": 11.106
+      }
+    },
+    {
+      "filename": "roll-big-01.wav",
+      "kind": "roll_big",
+      "round_robin": 1,
+      "sha256": "23fea6acc0d2c554353af445ea8aa887555ce2df3268540256922f695158909a",
+      "pcm_sha256": "7d3c290e8c18c786dd46633483d03c7ae3b83dfd83410c1262bd3e2d4dd8e82e",
+      "sample_rate": 44100,
+      "channels": 1,
+      "frames": 7717,
+      "anchor_frame": 0,
+      "source_sound_ids": [
+        856550,
+        856559
+      ],
+      "profile": {
+        "centroid_hz": 157.954,
+        "attack_centroid_hz": 2440.045,
+        "t90_seconds": 0.100317,
+        "t99_seconds": 0.129501,
+        "crest_db": 9.349
+      }
+    },
+    {
+      "filename": "roll-big-02.wav",
+      "kind": "roll_big",
+      "round_robin": 2,
+      "sha256": "edfd7d6225ac7e14d554b7ec946455d1d942f87c00e370d0cae2b3e62a22e2fd",
+      "pcm_sha256": "20289804cdb38f0b6dc6e300e7e8b0b7f32c7cc485e990db4a0a53a0055c47e5",
+      "sample_rate": 44100,
+      "channels": 1,
+      "frames": 7717,
+      "anchor_frame": 0,
+      "source_sound_ids": [
+        856550,
+        856552,
+        856559
+      ],
+      "profile": {
+        "centroid_hz": 153.15,
+        "attack_centroid_hz": 2438.852,
+        "t90_seconds": 0.094399,
+        "t99_seconds": 0.125283,
+        "crest_db": 9.633
+      }
+    }
+  ]
+}

softchart/preview_audio.py

@@ -1,28 +1,31 @@
-"""Deterministic game-style wadaiko preview synthesis.
+"""Deterministic sample-based arcade Taiko preview mixing.
 
 The chart is the timing authority: :func:`parse_tja_events` converts the
 repo-emitted TJA subset to audio-clock events, including OFFSET, measure-local
-subdivisions, and piecewise BPM changes.  Drum timbres are synthesized from
-membrane/rim resonances and filtered noise; no recorded or proprietary game
-assets are used.
+subdivisions, and piecewise BPM changes. Drum timbres come from a bundled,
+hash-validated CC0 large barrel-drum kit; no commercial-game audio is used.
 """
 
 from __future__ import annotations
 
+import hashlib
+import json
 import math
 import os
 import wave
 from dataclasses import dataclass
 from fractions import Fraction
+from pathlib import Path
 
 import numpy as np
-from scipy.signal import butter, resample_poly, sosfilt
+from scipy.signal import resample_poly
 
 
 _HIT_KIND = {"1": "don", "2": "ka", "3": "don_big", "4": "ka_big"}
 _SPAN_KIND = {"5": "roll", "6": "roll_big", "7": "balloon"}
 _ALLOWED_COMMANDS = {"#GOGOSTART", "#GOGOEND"}
 _PCM16_CEILING = int(math.floor(32767 * 10.0 ** (-1.0 / 20.0)))
+_ASSET_DIR = Path(__file__).with_name("assets") / "taiko"
 
 
 @dataclass(frozen=True)
@@ -56,6 +59,12 @@ class _Strike:
     autoplay: bool
 
 
+@dataclass(frozen=True)
+class _Voice:
+    samples: np.ndarray
+    anchor_frame: int
+
+
 def _finite_float(value: str, field: str) -> float:
     try:
         result = float(value)
@@ -217,140 +226,92 @@ def parse_tja_events(tja_text: str) -> list[TaikoEvent]:
     return sorted(events, key=lambda event: event.time)
 
 
-def _filtered_noise(rng: np.random.Generator, length: int, sample_rate: int,
-                    low_hz: float, high_hz: float) -> np.ndarray:
-    nyquist = sample_rate / 2.0
-    low = max(20.0, min(low_hz, nyquist * 0.90))
-    high = max(low + 20.0, min(high_hz, nyquist * 0.97))
-    sos = butter(3, (low, high), btype="bandpass", fs=sample_rate, output="sos")
-    noise = sosfilt(sos, rng.standard_normal(length)).astype(np.float64)
-    rms = float(np.sqrt(np.mean(noise * noise)))
-    return noise / max(rms, 1e-12)
-
-
-def _falling_mode(t: np.ndarray, start_hz: float, end_hz: float,
-                  pitch_tau: float, decay: float) -> np.ndarray:
-    phase = 2.0 * np.pi * (
-        end_hz * t + (start_hz - end_hz) * pitch_tau * (1.0 - np.exp(-t / pitch_tau))
-    )
-    return np.sin(phase) * np.exp(-t / decay)
-
-
-def _highpass(signal: np.ndarray, sample_rate: int, cutoff_hz: float) -> np.ndarray:
-    sos = butter(2, cutoff_hz, btype="highpass", fs=sample_rate, output="sos")
-    return sosfilt(sos, signal).astype(np.float64)
-
-
-def _soft_clip(signal: np.ndarray, drive: float) -> np.ndarray:
-    """Compress peaks while keeping the small-signal gain at unity."""
-
-    return np.tanh(signal * drive) / drive
-
-
-def _make_don(sample_rate: int, variant: int, big: bool = False,
-              tap: bool = False) -> np.ndarray:
-    # Compact arcade feedback needs the mid-bass membrane cluster and bachi
-    # attack to survive small speakers.  The frequencies are based on measured
-    # wadaiko mode relationships, deliberately omitting kick-like sub-bass and
-    # the large downward pitch sweep used by the previous voice.
-    duration = 0.105 if tap else (0.29 if big else 0.27)
-    n = int(round(duration * sample_rate))
-    t = np.arange(n, dtype=np.float64) / sample_rate
-    rng = np.random.default_rng(12_710 + 101 * variant + 1_009 * int(big) + 7_003 * int(tap))
-    pitch = (0.982, 0.994, 1.008, 1.019)[variant % 4]
-    attack = 1.0 - np.exp(-t / 0.00024)
-
-    modes = np.zeros(n, dtype=np.float64)
-    frequencies = (255.0, 295.0, 560.0, 690.0, 1_015.0)
-    weights = (0.82, 1.00, 0.47, 0.32, 0.17)
-    decays = (0.185, 0.165, 0.095, 0.068, 0.040)
-    decay_scale = 0.31 if tap else (1.06 if big else 1.0)
-    for frequency, weight, decay in zip(frequencies, weights, decays):
-        end_hz = frequency * pitch
-        modes += weight * _falling_mode(
-            t, end_hz * (1.012 + 0.002 * variant), end_hz,
-            0.009, decay * decay_scale,
-        )
-
-    skin = _filtered_noise(rng, n, sample_rate, 380.0, 5_400.0)
-    skin *= np.exp(-t / (0.0042 if tap else 0.0075))
-    stick = _filtered_noise(rng, n, sample_rate, 1_300.0, 9_500.0)
-    stick *= np.exp(-t / 0.0018)
-    signal = (
-        attack * modes
-        + (0.30 if tap else 0.20) * skin
-        + (0.17 if tap else 0.105) * stick
-    )
-    signal = _highpass(signal, sample_rate, 115.0 if tap else 62.0)
-    signal = _soft_clip(signal, 1.42)
-    signal *= np.exp(-np.maximum(t - duration * 0.72, 0.0) / 0.018)
-    target = 0.59 if tap else (0.90 if big else 0.84)
-    signal *= target / max(float(np.max(np.abs(signal))), 1e-12)
-    return signal.astype(np.float32)
-
-
-def _make_ka(sample_rate: int, variant: int, big: bool = False) -> np.ndarray:
-    # Ka is a dry wooden rim crack: a millisecond-scale excitation followed by
-    # short, irregular high modes.  Broadband noise is only the bachi contact,
-    # not the body of the sound.
-    duration = 0.16 if big else 0.14
-    n = int(round(duration * sample_rate))
-    t = np.arange(n, dtype=np.float64) / sample_rate
-    rng = np.random.default_rng(37_901 + 131 * variant + 2_003 * int(big))
-    pitch = (0.981, 0.995, 1.009, 1.021)[variant % 4]
-    attack = 1.0 - np.exp(-t / 0.00016)
-
-    rim = _filtered_noise(rng, n, sample_rate, 1_200.0, 10_500.0)
-    rim *= np.exp(-t / 0.0028)
-    modes = np.zeros(n, dtype=np.float64)
-    for frequency, weight, decay in (
-        (650.0, 0.42, 0.064), (1_050.0, 1.00, 0.048),
-        (1_700.0, 0.63, 0.034), (2_700.0, 0.35, 0.022),
-        (4_200.0, 0.19, 0.012),
-    ):
-        phase = 2.0 * np.pi * frequency * pitch * t + variant * 0.31
-        modes += weight * np.sin(phase) * np.exp(-t / (decay * (1.04 if big else 1.0)))
-    signal = 0.22 * rim + attack * modes
-    signal = _highpass(signal, sample_rate, 390.0)
-    signal = _soft_clip(signal, 1.28)
-    signal *= np.exp(-np.maximum(t - duration * 0.68, 0.0) / 0.012)
-    target = 0.91 if big else 0.79
-    signal *= target / max(float(np.max(np.abs(signal))), 1e-12)
-    return signal.astype(np.float32)
-
-
-_BANKS: dict[int, dict[str, tuple[np.ndarray, ...]]] = {}
-
-
-def _sample_bank(sample_rate: int) -> dict[str, tuple[np.ndarray, ...]]:
+_BANKS: dict[int, dict[str, tuple[_Voice, ...]]] = {}
+_REQUIRED_VOICES = {
+    "don": 2,
+    "ka": 2,
+    "don_big": 1,
+    "ka_big": 1,
+    "roll": 2,
+    "roll_big": 2,
+    "balloon": 2,
+}
+
+
+def _load_pcm16_voice(path: Path, anchor_frame: int,
+                      sample_rate: int) -> _Voice:
+    with wave.open(str(path), "rb") as source:
+        if source.getnchannels() != 1 or source.getsampwidth() != 2:
+            raise ValueError(f"Taiko asset must be mono PCM16: {path.name}")
+        source_rate = source.getframerate()
+        pcm = np.frombuffer(source.readframes(source.getnframes()), dtype="<i2")
+    if source_rate != 44_100:
+        raise ValueError(f"Taiko asset must be 44.1 kHz: {path.name}")
+    samples = pcm.astype(np.float32) / 32767.0
+    if sample_rate != source_rate:
+        ratio = Fraction(sample_rate, source_rate).limit_denominator()
+        samples = resample_poly(samples, ratio.numerator, ratio.denominator).astype(np.float32)
+        anchor_frame = int(round(anchor_frame * sample_rate / source_rate))
+    if not 0 <= anchor_frame < len(samples):
+        raise ValueError(f"Taiko asset anchor is outside the sample: {path.name}")
+    return _Voice(np.ascontiguousarray(samples), anchor_frame)
+
+
+def _sample_bank(sample_rate: int) -> dict[str, tuple[_Voice, ...]]:
     bank = _BANKS.get(sample_rate)
-    if bank is None:
-        bank = {
-            "don": tuple(_make_don(sample_rate, i) for i in range(4)),
-            "ka": tuple(_make_ka(sample_rate, i) for i in range(4)),
-            "don_big": tuple(_make_don(sample_rate, i, big=True) for i in range(4)),
-            "ka_big": tuple(_make_ka(sample_rate, i, big=True) for i in range(4)),
-            "roll": tuple(_make_don(sample_rate, i, tap=True) for i in range(4)),
-            "roll_big": tuple(_make_don(sample_rate, i, big=True, tap=True) for i in range(4)),
-            "balloon": tuple(_make_don(sample_rate, i, tap=True) for i in range(4)),
-        }
-        _BANKS[sample_rate] = bank
+    if bank is not None:
+        return bank
+
+    manifest_path = _ASSET_DIR / "manifest.json"
+    if not manifest_path.is_file():
+        raise FileNotFoundError(f"Taiko asset manifest is missing: {manifest_path}")
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    if manifest.get("schema_version") != 1 or manifest.get("license") != "CC0-1.0":
+        raise ValueError("Taiko asset manifest must be schema 1 and CC0-1.0")
+
+    grouped: dict[str, list[tuple[int, _Voice]]] = {kind: [] for kind in _REQUIRED_VOICES}
+    for item in manifest.get("files", []):
+        kind = item.get("kind")
+        if kind not in grouped:
+            raise ValueError(f"unsupported Taiko asset kind in manifest: {kind!r}")
+        filename = item.get("filename")
+        if not isinstance(filename, str) or Path(filename).name != filename:
+            raise ValueError("Taiko asset filename must be a plain basename")
+        path = _ASSET_DIR / filename
+        if not path.is_file():
+            raise FileNotFoundError(f"Taiko asset is missing: {path}")
+        file_hash = hashlib.sha256(path.read_bytes()).hexdigest()
+        if file_hash != item.get("sha256"):
+            raise ValueError(f"Taiko asset hash mismatch: {filename}")
+        voice = _load_pcm16_voice(path, int(item["anchor_frame"]), sample_rate)
+        grouped[kind].append((int(item["round_robin"]), voice))
+
+    bank = {}
+    for kind, expected_count in _REQUIRED_VOICES.items():
+        entries = sorted(grouped[kind], key=lambda entry: entry[0])
+        if len(entries) != expected_count:
+            raise ValueError(
+                f"Taiko kit requires {expected_count} {kind} voice(s), got {len(entries)}"
+            )
+        if [index for index, _ in entries] != list(range(1, expected_count + 1)):
+            raise ValueError(f"Taiko {kind} round-robin indices must be contiguous from 1")
+        bank[kind] = tuple(voice for _, voice in entries)
+    _BANKS[sample_rate] = bank
     return bank
 
 
+_DEFAULT_BANK = _sample_bank(44_100)
+
+
 def _expand_strikes(events: list[TaikoEvent]) -> tuple[list[_Strike], int]:
     strikes: list[_Strike] = []
     autoplay_count = 0
     ordinary_index = 0
     for event in events:
         if event.kind in {"don", "ka", "don_big", "ka_big"}:
-            if event.kind.endswith("_big"):
-                pan = -0.35 if ordinary_index % 2 == 0 else 0.35
-            elif event.kind == "ka":
-                pan = -0.14 if ordinary_index % 2 == 0 else 0.14
-            else:
-                pan = -0.02 if ordinary_index % 2 == 0 else 0.02
-            depth = 0.30 if event.kind.endswith("_big") else 0.22
+            pan_width = 0.08 if event.kind in {"ka", "ka_big"} else 0.015
+            pan = -pan_width if ordinary_index % 2 == 0 else pan_width
+            depth = 0.26 if event.kind.endswith("_big") else 0.22
             strikes.append(_Strike(event.time, event.kind, pan, depth, False))
             ordinary_index += 1
             continue
@@ -371,7 +332,7 @@ def _expand_strikes(events: list[TaikoEvent]) -> tuple[list[_Strike], int]:
             kind = event.kind
             depth = 0.085 if event.kind == "roll_big" else 0.060
         for index, time in enumerate(times):
-            pan_width = 0.24 if kind == "roll_big" else 0.18
+            pan_width = 0.10 if kind == "roll_big" else 0.06
             pan = -pan_width if index % 2 == 0 else pan_width
             strikes.append(_Strike(float(time), kind, pan, depth, True))
             autoplay_count += 1
@@ -412,9 +373,10 @@ def _load_stereo_audio(audio_path: str, sample_rate: int) -> np.ndarray:
     return np.ascontiguousarray(audio, dtype=np.float32)
 
 
-def _place_strike(drums: np.ndarray, sample: np.ndarray, strike: _Strike,
-                  sample_rate: int, layered_sample: np.ndarray | None = None) -> bool:
-    start = int(round(strike.time * sample_rate))
+def _place_strike(drums: np.ndarray, voice: _Voice, strike: _Strike,
+                  sample_rate: int) -> bool:
+    sample = voice.samples
+    start = int(round(strike.time * sample_rate)) - voice.anchor_frame
     sample_start = max(0, -start)
     output_start = max(0, start)
     count = min(len(sample) - sample_start, len(drums) - output_start)
@@ -426,23 +388,6 @@ def _place_strike(drums: np.ndarray, sample: np.ndarray, strike: _Strike,
     segment = sample[sample_start:sample_start + count]
     drums[output_start:output_start + count, 0] += segment * left_gain
     drums[output_start:output_start + count, 1] += segment * right_gain
-
-    # A big note represents both hands, not a lower-pitched or longer drum.
-    # Layer an independently synthesized variant on the opposite side a few
-    # milliseconds later while keeping the first transient exactly on-grid.
-    if layered_sample is not None:
-        layer_delay = int(round(0.0018 * sample_rate))
-        layer_start = output_start + layer_delay
-        layer_source_start = sample_start
-        layer_count = min(
-            len(layered_sample) - layer_source_start,
-            len(drums) - layer_start,
-        )
-        if layer_count > 0:
-            layer = layered_sample[layer_source_start:layer_source_start + layer_count]
-            layer_gain = 0.72 if strike.kind == "roll_big" else 0.92
-            drums[layer_start:layer_start + layer_count, 0] += layer * right_gain * layer_gain
-            drums[layer_start:layer_start + layer_count, 1] += layer * left_gain * layer_gain
     return True
 
 
@@ -519,14 +464,15 @@ def synthesize_taiko_preview(
     events = parse_tja_events(tja_text)
     music = _load_stereo_audio(audio_path, sample_rate)
     strikes, autoplay_count = _expand_strikes(events)
-    bank = _sample_bank(sample_rate)
+    bank = _DEFAULT_BANK if sample_rate == 44_100 else _sample_bank(sample_rate)
     source_frames = len(music)
     output_frames = source_frames
     for index, strike in enumerate(strikes):
-        sample = bank[strike.kind][index % len(bank[strike.kind])]
+        voice = bank[strike.kind][index % len(bank[strike.kind])]
+        start = int(round(strike.time * sample_rate)) - voice.anchor_frame
         output_frames = max(
             output_frames,
-            max(0, int(round(strike.time * sample_rate)) + len(sample)),
+            max(0, start + len(voice.samples)),
         )
     if output_frames > source_frames:
         music = np.pad(music, ((0, output_frames - source_frames), (0, 0)))
@@ -534,17 +480,11 @@ def synthesize_taiko_preview(
     audible_strikes: list[_Strike] = []
 
     for index, strike in enumerate(strikes):
-        samples = bank[strike.kind]
-        sample = samples[index % len(samples)]
-        layered_sample = None
-        if strike.kind in {"don_big", "ka_big", "roll_big"}:
-            layered_sample = samples[(index + 1) % len(samples)]
-        if _place_strike(
-            drums, sample, strike, sample_rate, layered_sample=layered_sample,
-        ):
+        voices = bank[strike.kind]
+        voice = voices[index % len(voices)]
+        if _place_strike(drums, voice, strike, sample_rate):
             audible_strikes.append(strike)
 
-    drums = _soft_clip(drums, 1.10).astype(np.float32)
     duck_gain, max_duck_db = _duck_envelope(
         len(music), audible_strikes, sample_rate, drum_gain,
     )