aurasu 0.0.1

package/src/main.js

@@ -0,0 +1,2235 @@
+// aurasu
+//
+// A hit-circle rhythm prototype inspired by Aurasu-style gameplay:
+// - timed circles
+// - approach rings
+// - timing windows + combo scoring
+// - health and accuracy-based results
+
+const APPROACH_TIME = 1.1;
+const HIT_RADIUS = 38;
+const HIT_PICK_RADIUS = 68;
+const EARLY_ASSIST = 0.03;
+const TIMING_OFFSET = -0.012;
+const PRESS_BUFFER = 0.09;
+const DRAG_PICK_RADIUS = 92;
+const DRAG_CHAIN_GRACE = 0.34;
+const DRAG_CHAIN_BEAT_FACTOR = 0.62;
+const DRAG_EARLY_ASSIST = 0.055;
+const BONK_EARLY_MAX = 0.36;
+const BONK_CURSOR_RADIUS = 86;
+
+const WINDOW_PERFECT = 0.045;
+const WINDOW_GOOD = 0.09;
+const WINDOW_OK = 0.14;
+const WINDOW_MISS = 0.18;
+
+const HEALTH_MAX = 100;
+
+const JUDGEMENT_POINTS = {
+  perfect: 300,
+  good: 100,
+  ok: 50,
+  miss: 0,
+};
+
+const BACKGROUND_LAYERS = 18;
+const GRID_COLS = 12;
+const GRID_ROWS = 8;
+const CURSOR_TRAIL_LIFE = 0.18;
+const FEVER_COMBO_THRESHOLD = 24;
+const FEVER_MULTIPLIER = 1.25;
+const BGM_ASSET_PATH = 'Aurasu.wav';
+const BACKGROUND_ASSET_PATH = 'aurasu.jpg';
+const BGM_VOLUME = 1.0;
+const BACKGROUND_IMAGE_ALPHA = 0.13;
+const VIS_OVERLAY_DARKNESS = 0.992;
+const VIS_HIT_FLASH_GAIN = 2.0;
+const VIS_NOTE_POP_SCALE = 0.34;
+const VIS_CIRCLE_SOLID_MIN_ALPHA = 1.0;
+const CIRCLE_SPRITE_INSET = 2;
+const CIRCLE_SPRITE_FRAME = 512 - (CIRCLE_SPRITE_INSET * 2);
+const BACKGROUND_DARK_OVERLAY_ALPHA = VIS_OVERLAY_DARKNESS;
+const BACKGROUND_LAYER_ALPHA_WITH_IMAGE = 0.1;
+const BACKGROUND_VIGNETTE_ALPHA = 0.68;
+const ANALYZED_TRACK_DURATION = 193.747302;
+const ANALYZED_BPM = 130;
+const ANALYZED_FIRST_BEAT = 0.441;
+const ANALYZED_BEAT = 60 / ANALYZED_BPM;
+const MAP_LEAD_IN_BEATS = 4;
+const MAP_START_TIME = ANALYZED_FIRST_BEAT + (ANALYZED_BEAT * MAP_LEAD_IN_BEATS);
+const MAP_MAIN_BEATS = 190;
+const DIFFICULTY_PRESETS = [
+  {
+    id: 'easy',
+    label: 'EASY',
+    subtitle: 'relaxed timing',
+    timingScale: 1.24,
+    approachScale: 1.2,
+    beatScale: 0.72,
+    dragScale: 0.9,
+    pickScale: 1.14,
+    accent: [0.38, 0.95, 1.0],
+    minJump: 2,
+    burstInterval: 16,
+    burstChance: 0.4,
+    burstSecondary: false,
+    tripleStartBeat: 150,
+    tripleChance: 0.2,
+    tripleCount: 1,
+    offbeatChance: 0.03,
+    offbeatOffset: 0.5,
+    dragLinkChance: 0.52,
+    densityLevel: 0,
+  },
+  {
+    id: 'normal',
+    label: 'NORMAL',
+    subtitle: 'balanced',
+    timingScale: 1.0,
+    approachScale: 1.0,
+    beatScale: 1.0,
+    dragScale: 1.0,
+    pickScale: 1.0,
+    accent: [0.76, 1.0, 0.26],
+    minJump: 3,
+    burstInterval: 12,
+    burstChance: 0.72,
+    burstSecondary: true,
+    tripleStartBeat: 120,
+    tripleChance: 0.38,
+    tripleCount: 2,
+    offbeatChance: 0.12,
+    offbeatOffset: 0.5,
+    dragLinkChance: 0.72,
+    densityLevel: 1,
+  },
+  {
+    id: 'hard',
+    label: 'HARD',
+    subtitle: 'dense chains',
+    timingScale: 0.86,
+    approachScale: 0.86,
+    beatScale: 1.44,
+    dragScale: 1.08,
+    pickScale: 0.94,
+    accent: [1.0, 0.48, 0.72],
+    minJump: 4,
+    burstInterval: 7,
+    burstChance: 1.0,
+    burstSecondary: true,
+    tripleStartBeat: 70,
+    tripleChance: 0.8,
+    tripleCount: 3,
+    offbeatChance: 0.5,
+    offbeatOffset: 0.25,
+    dragLinkChance: 0.9,
+    densityLevel: 2,
+  },
+  {
+    id: 'aura',
+    label: 'AURA+',
+    subtitle: 'overdrive',
+    timingScale: 0.76,
+    approachScale: 0.74,
+    beatScale: 1.95,
+    dragScale: 1.14,
+    pickScale: 0.9,
+    accent: [0.98, 0.3, 0.96],
+    minJump: 5,
+    burstInterval: 6,
+    burstChance: 1.0,
+    burstSecondary: true,
+    tripleStartBeat: 40,
+    tripleChance: 1.0,
+    tripleCount: 4,
+    offbeatChance: 0.72,
+    offbeatOffset: 0.25,
+    dragLinkChance: 0.98,
+    densityLevel: 3,
+  },
+];
+const SKIN_ASSET_PATHS = {
+  approachcircle: 'approachcircle.png',
+  hitcircle: 'hitcircle.png',
+  hitcircleoverlay: 'hitcircleoverlay.png',
+  sliderball: 'sliderball.png',
+  sliderfollowcircle: 'sliderfollowcircle.png',
+  followpoint: 'followpoint.png',
+  cursor: 'cursor.png',
+  cursortrail: 'cursortrail.png',
+  judgement300: 'judgement-300.png',
+  judgement100: 'judgement-100.png',
+  judgement50: 'judgement-50.png',
+  judgementMiss: 'judgement-miss.png',
+  hitburstSheet: 'hitburst_sheet.png',
+};
+const SFX_PATHS = {
+  normal: 'hit-normal.wav',
+  clap: 'hit-clap.wav',
+  finish: 'hit-finish.wav',
+  whistle: 'hit-whistle.wav',
+  sliderStart: 'slider-start.wav',
+  sliderTick: 'slider-tick.wav',
+  sliderEnd: 'slider-end.wav',
+  miss: 'hit-miss.wav',
+  comboBreak: 'combo-break.wav',
+  uiStart: 'ui-start.wav',
+  uiBack: 'ui-back.wav',
+  uiPause: 'ui-pause.wav',
+};
+const SFX_VOLUME = {
+  normal: 0.58,
+  clap: 0.62,
+  finish: 0.72,
+  whistle: 0.55,
+  sliderStart: 0.52,
+  sliderTick: 0.42,
+  sliderEnd: 0.58,
+  miss: 0.58,
+  comboBreak: 0.64,
+  uiStart: 0.46,
+  uiBack: 0.4,
+  uiPause: 0.38,
+};
+const SFX_MIN_INTERVAL = {
+  normal: 0.028,
+  clap: 0.028,
+  finish: 0.04,
+  whistle: 0.034,
+  sliderStart: 0.03,
+  sliderTick: 0.022,
+  sliderEnd: 0.034,
+  miss: 0.08,
+  comboBreak: 0.12,
+  uiStart: 0.16,
+  uiBack: 0.16,
+  uiPause: 0.16,
+};
+
+let worldWidth = 1280;
+let worldHeight = 720;
+let playX = 130;
+let playY = 76;
+let playW = 1020;
+let playH = 568;
+
+let notes = [];
+let currentTime = 0;
+let lastNoteTime = 0;
+
+let state = 'title'; // title | playing | results
+let failed = false;
+
+let score = 0;
+let combo = 0;
+let maxCombo = 0;
+let hits = 0;
+let misses = 0;
+let totalJudged = 0;
+let totalPointValue = 0;
+let achievedPoints = 0;
+let health = HEALTH_MAX;
+
+let perfectCount = 0;
+let goodCount = 0;
+let okCount = 0;
+
+let bursts = [];
+let judgementPop = null;
+let pulseTime = 0;
+let frameDt = 1 / 60;
+let beatGlow = 0;
+let comboFlash = 0;
+let screenShake = 0;
+let cursorTrail = [];
+let flowMeter = 0;
+let hitBufferTimer = 0;
+let dragChainTimer = 0;
+let dragExpectedIndex = -1;
+let mouseHoldActive = false;
+let keyHoldActive = false;
+let hitPressedThisFrame = false;
+let k1Down = false;
+let k2Down = false;
+let k1Pulse = 0;
+let k2Pulse = 0;
+let k1Flash = 0;
+let k2Flash = 0;
+let bgmLoaded = false;
+let bgmLoadAttempted = false;
+let bgmHandle = -1;
+let bgmMuted = false;
+let bgmLastError = '';
+let backgroundLoaded = false;
+let backgroundLoadAttempted = false;
+let skinLoadAttempted = false;
+const skinLoaded = new Set();
+let sfxLoadAttempted = false;
+let sfxMuted = false;
+const sfxLoaded = new Set();
+const sfxLastPlay = new Map();
+let selectedDifficultyIndex = 1;
+let titleDifficultyBoxes = [];
+let activeDifficulty = DIFFICULTY_PRESETS[selectedDifficultyIndex];
+let activeApproachTime = APPROACH_TIME;
+let activeWindowPerfect = WINDOW_PERFECT;
+let activeWindowGood = WINDOW_GOOD;
+let activeWindowOk = WINDOW_OK;
+let activeWindowMiss = WINDOW_MISS;
+let activeMainBeats = MAP_MAIN_BEATS;
+let activeDragChainBeatFactor = DRAG_CHAIN_BEAT_FACTOR;
+let activeHitPickRadius = HIT_PICK_RADIUS;
+let activeDragPickRadius = DRAG_PICK_RADIUS;
+let activeEarlyAssist = EARLY_ASSIST;
+let activeDragEarlyAssist = DRAG_EARLY_ASSIST;
+let activePressBuffer = PRESS_BUFFER;
+let activeBonkEarlyMax = BONK_EARLY_MAX;
+
+const pressLatch = new Map();
+
+const PALETTE = [
+  [0.0, 0.95, 1.0],
+  [1.0, 0.2, 0.75],
+  [0.7, 1.0, 0.15],
+  [1.0, 0.55, 0.1],
+  [0.62, 0.35, 1.0],
+];
+
+function hasMethod(obj, name) {
+  return Boolean(obj) && typeof obj[name] === 'function';
+}
+
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+function normalizeDifficultyIndex(index) {
+  const len = DIFFICULTY_PRESETS.length;
+  if (len <= 0) return 0;
+  return ((index % len) + len) % len;
+}
+
+function getSelectedDifficulty() {
+  return DIFFICULTY_PRESETS[normalizeDifficultyIndex(selectedDifficultyIndex)] || DIFFICULTY_PRESETS[0];
+}
+
+function applyDifficultySettings() {
+  const d = getSelectedDifficulty();
+  activeDifficulty = d;
+  activeApproachTime = APPROACH_TIME * d.approachScale;
+  activeWindowPerfect = WINDOW_PERFECT * d.timingScale;
+  activeWindowGood = WINDOW_GOOD * d.timingScale;
+  activeWindowOk = WINDOW_OK * d.timingScale;
+  activeWindowMiss = WINDOW_MISS * d.timingScale;
+  activeMainBeats = Math.max(48, Math.floor(MAP_MAIN_BEATS * d.beatScale));
+  activeDragChainBeatFactor = DRAG_CHAIN_BEAT_FACTOR * d.dragScale;
+  activeHitPickRadius = HIT_PICK_RADIUS * d.pickScale;
+  activeDragPickRadius = DRAG_PICK_RADIUS * d.pickScale;
+  activeEarlyAssist = EARLY_ASSIST * d.timingScale;
+  activeDragEarlyAssist = DRAG_EARLY_ASSIST * d.timingScale;
+  activePressBuffer = PRESS_BUFFER * clamp((d.timingScale * 0.86) + (d.pickScale * 0.14), 0.76, 1.35);
+  activeBonkEarlyMax = BONK_EARLY_MAX * clamp(d.timingScale, 0.72, 1.3);
+}
+
+function setDifficultyIndex(index) {
+  const next = normalizeDifficultyIndex(index);
+  if (next === selectedDifficultyIndex) return false;
+  selectedDifficultyIndex = next;
+  applyDifficultySettings();
+  return true;
+}
+
+function cycleDifficulty(step) {
+  return setDifficultyIndex(selectedDifficultyIndex + step);
+}
+
+function rgb(r, g, b) {
+  if (typeof aura.rgb === 'function') return aura.rgb(r, g, b);
+  return { r, g, b, a: 1 };
+}
+
+function rgba(r, g, b, a) {
+  if (typeof aura.rgba === 'function') return aura.rgba(r, g, b, a);
+  return { r, g, b, a };
+}
+
+function white() {
+  if (aura.Color && aura.Color.WHITE) return aura.Color.WHITE;
+  return rgba(1, 1, 1, 1);
+}
+
+function canUseAssetRuntime() {
+  return Boolean(aura.assets) && hasMethod(aura.assets, 'load');
+}
+
+function canUseAudioRuntime() {
+  return Boolean(aura.audio)
+    && hasMethod(aura.audio, 'play')
+    && hasMethod(aura.audio, 'stop');
+}
+
+function canUseSpriteRuntime() {
+  return Boolean(aura.draw2d)
+    && (hasMethod(aura.draw2d, 'sprite') || hasMethod(aura.draw2d, 'image'));
+}
+
+async function loadAssetIfPossible(path) {
+  if (!canUseAssetRuntime()) return false;
+  try {
+    await aura.assets.load(path);
+    return true;
+  } catch {}
+
+  try {
+    await aura.assets.load([path]);
+    return true;
+  } catch {}
+
+  return false;
+}
+
+async function loadBgmAsset() {
+  if (bgmLoadAttempted) return bgmLoaded;
+  bgmLoadAttempted = true;
+  bgmLoaded = await loadAssetIfPossible(BGM_ASSET_PATH);
+  return bgmLoaded;
+}
+
+async function loadBackgroundAsset() {
+  if (backgroundLoadAttempted) return backgroundLoaded;
+  backgroundLoadAttempted = true;
+  backgroundLoaded = await loadAssetIfPossible(BACKGROUND_ASSET_PATH);
+  return backgroundLoaded;
+}
+
+async function loadSkinAssets() {
+  if (skinLoadAttempted) return skinLoaded.size > 0;
+  skinLoadAttempted = true;
+  const names = Object.keys(SKIN_ASSET_PATHS);
+  const paths = names.map((name) => SKIN_ASSET_PATHS[name]);
+  const loaded = await Promise.all(paths.map((path) => loadAssetIfPossible(path)));
+  for (let i = 0; i < names.length; i += 1) {
+    if (loaded[i]) skinLoaded.add(names[i]);
+  }
+  return skinLoaded.size > 0;
+}
+
+async function loadSfxAssets() {
+  if (sfxLoadAttempted) return sfxLoaded.size > 0;
+  sfxLoadAttempted = true;
+  const names = Object.keys(SFX_PATHS);
+  const files = names.map((name) => SFX_PATHS[name]);
+  const loaded = await Promise.all(files.map((path) => loadAssetIfPossible(path)));
+  for (let i = 0; i < names.length; i += 1) {
+    if (loaded[i]) sfxLoaded.add(names[i]);
+  }
+  return sfxLoaded.size > 0;
+}
+
+function playSfx(name, volumeScale = 1) {
+  if (sfxMuted) return;
+  if (!canUseAudioRuntime()) return;
+  if (!sfxLoaded.has(name)) return;
+  const now = pulseTime;
+  const minInterval = Number.isFinite(SFX_MIN_INTERVAL[name]) ? SFX_MIN_INTERVAL[name] : 0;
+  const last = sfxLastPlay.has(name) ? sfxLastPlay.get(name) : -999;
+  if ((now - last) < minInterval) return;
+  sfxLastPlay.set(name, now);
+
+  const base = Number.isFinite(SFX_VOLUME[name]) ? SFX_VOLUME[name] : 0.5;
+  const volume = clamp(base * volumeScale, 0, 1);
+  try {
+    aura.audio.play(SFX_PATHS[name], {
+      loop: false,
+      volume,
+    });
+  } catch {}
+}
+
+function toggleSfxMute() {
+  const next = !sfxMuted;
+  if (!next) {
+    playSfx('uiPause');
+  }
+  sfxMuted = next;
+}
+
+function accentForNoteTime(noteTime, mapStart, beat) {
+  const beatPos = (noteTime - mapStart) / beat;
+  const nearestBeat = Math.round(beatPos);
+  const beatErr = Math.abs(beatPos - nearestBeat);
+  if (beatErr <= 0.08) {
+    const mod16 = ((nearestBeat % 16) + 16) % 16;
+    const mod4 = ((nearestBeat % 4) + 4) % 4;
+    if (mod16 === 0) return 'finish';
+    if (mod4 === 1 || mod4 === 3) return 'clap';
+    return 'normal';
+  }
+
+  const nearestHalf = Math.round(beatPos * 2) / 2;
+  const halfErr = Math.abs(beatPos - nearestHalf);
+  if (halfErr <= 0.08 && (Math.abs(nearestHalf % 1) > 0.001)) {
+    return 'whistle';
+  }
+  return 'normal';
+}
+
+function playNoteHitsound(note, judgement) {
+  if (!note || judgement === 'miss') return;
+
+  const hasPrev = note.dragPrevIndex !== null && note.dragPrevIndex !== undefined;
+  const hasNext = note.dragNextIndex !== null && note.dragNextIndex !== undefined;
+
+  if (hasPrev && hasNext) {
+    playSfx('sliderTick');
+    return;
+  }
+  if (!hasPrev && hasNext) {
+    playSfx('sliderStart');
+    if (note.hitsound === 'clap') playSfx('clap', 0.65);
+    else if (note.hitsound === 'finish') playSfx('finish', 0.68);
+    else if (note.hitsound === 'whistle') playSfx('whistle', 0.62);
+    return;
+  }
+  if (hasPrev && !hasNext) {
+    playSfx('sliderEnd');
+    return;
+  }
+
+  const accent = typeof note.hitsound === 'string' ? note.hitsound : 'normal';
+  if (accent === 'clap') {
+    playSfx('clap');
+  } else if (accent === 'finish') {
+    playSfx('finish');
+  } else if (accent === 'whistle') {
+    playSfx('whistle');
+  } else {
+    playSfx('normal');
+  }
+}
+
+function stopBgm() {
+  if (bgmHandle < 0) return;
+  if (!canUseAudioRuntime()) {
+    bgmHandle = -1;
+    return;
+  }
+  try {
+    aura.audio.stop(bgmHandle);
+  } catch {}
+  bgmHandle = -1;
+}
+
+function applyBgmVolume() {
+  if (!canUseAudioRuntime()) return;
+  const target = bgmMuted ? 0 : 1;
+  if (hasMethod(aura.audio, 'setMasterVolume')) {
+    try {
+      aura.audio.setMasterVolume(1);
+    } catch {}
+  }
+  if (bgmHandle >= 0 && hasMethod(aura.audio, 'setVolume')) {
+    try {
+      aura.audio.setVolume(bgmHandle, target);
+    } catch {}
+  }
+}
+
+function startBgm(restart = false) {
+  if (!canUseAudioRuntime() || !bgmLoaded) return;
+  if (restart) stopBgm();
+  if (bgmHandle >= 0) return;
+
+  try {
+    const handle = aura.audio.play(BGM_ASSET_PATH, {
+      loop: true,
+      volume: BGM_VOLUME,
+    });
+    if (Number.isFinite(handle) && handle >= 0) {
+      bgmHandle = Math.floor(handle);
+      applyBgmVolume();
+      bgmLastError = '';
+    } else {
+      bgmHandle = -1;
+      bgmLastError = 'play() returned invalid handle';
+    }
+  } catch (error) {
+    bgmHandle = -1;
+    bgmLastError = String(error);
+  }
+}
+
+function beginPlayingRun() {
+  playSfx('uiStart');
+  applyDifficultySettings();
+  resetRun();
+  state = 'playing';
+  startBgm(false);
+}
+
+function toggleBgmMute() {
+  bgmMuted = !bgmMuted;
+  applyBgmVolume();
+  playSfx('uiPause', 0.9);
+}
+
+function keyPressedLatch(keys) {
+  let pressed = false;
+  for (const key of keys) {
+    const down = aura.input.isKeyDown(key);
+    const was = pressLatch.get(key) === true;
+    if (down && !was) pressed = true;
+    pressLatch.set(key, down);
+  }
+  return pressed;
+}
+
+function primePressLatch() {
+  for (const key of ['enter', 'space', 'escape', 'z', 'x', 'm', 'n', 'h', 'up', 'down', 'w', 's', '1', '2', '3', '4']) {
+    pressLatch.set(key, aura.input.isKeyDown(key));
+  }
+}
+
+function inputPressed(keys) {
+  if (hasMethod(aura.input, 'isKeyPressed')) {
+    for (const key of keys) {
+      if (aura.input.isKeyPressed(key)) return true;
+    }
+    return false;
+  }
+  return keyPressedLatch(keys);
+}
+
+function mouseHitPressed() {
+  if (hasMethod(aura.input, 'isMousePressed') && aura.input.isMousePressed(0)) {
+    return true;
+  }
+  return false;
+}
+
+function mouseHitDown() {
+  if (hasMethod(aura.input, 'isMouseDown')) {
+    return aura.input.isMouseDown(0);
+  }
+  return false;
+}
+
+function keyboardHitPressed() {
+  return keyboardK1Pressed() || keyboardK2Pressed();
+}
+
+function keyboardHitDown() {
+  return keyboardK1Down() || keyboardK2Down();
+}
+
+function keyboardK1Pressed() {
+  return inputPressed(['z']);
+}
+
+function keyboardK2Pressed() {
+  return inputPressed(['x', 'space']);
+}
+
+function keyboardK1Down() {
+  return aura.input.isKeyDown('z');
+}
+
+function keyboardK2Down() {
+  return aura.input.isKeyDown('x') || aura.input.isKeyDown('space');
+}
+
+function startPressed() {
+  return inputPressed(['enter', 'space']);
+}
+
+function escapePressed() {
+  return inputPressed(['escape']);
+}
+
+function pointInRect(px, py, x, y, w, h) {
+  return px >= x && py >= y && px <= (x + w) && py <= (y + h);
+}
+
+function handleTitleDifficultyInput() {
+  let changed = false;
+
+  if (inputPressed(['up', 'w'])) changed = cycleDifficulty(-1) || changed;
+  if (inputPressed(['down', 's'])) changed = cycleDifficulty(1) || changed;
+
+  if (inputPressed(['1'])) changed = setDifficultyIndex(0) || changed;
+  if (inputPressed(['2'])) changed = setDifficultyIndex(1) || changed;
+  if (inputPressed(['3'])) changed = setDifficultyIndex(2) || changed;
+  if (inputPressed(['4'])) changed = setDifficultyIndex(3) || changed;
+
+  if (mouseHitPressed()) {
+    const mouse = getMouse();
+    for (const chip of titleDifficultyBoxes) {
+      if (!pointInRect(mouse.x, mouse.y, chip.x, chip.y, chip.w, chip.h)) continue;
+      changed = setDifficultyIndex(chip.index) || changed;
+      break;
+    }
+  }
+
+  if (changed) {
+    playSfx('uiPause', 0.82);
+  }
+}
+
+function getMouse() {
+  if (!hasMethod(aura.input, 'getMousePosition')) {
+    return { x: playX + (playW * 0.5), y: playY + (playH * 0.5) };
+  }
+
+  const pos = aura.input.getMousePosition();
+  const x = Number.isFinite(pos?.x) ? pos.x : playX + (playW * 0.5);
+  const y = Number.isFinite(pos?.y) ? pos.y : playY + (playH * 0.5);
+  return { x, y };
+}
+
+function notePosition(note) {
+  return {
+    x: playX + (note.nx * playW),
+    y: playY + (note.ny * playH),
+  };
+}
+
+function evaluateTimingDelta(delta) {
+  const adjusted = delta - TIMING_OFFSET;
+  const ad = Math.abs(adjusted);
+  if (ad <= activeWindowPerfect) return 'perfect';
+  if (ad <= activeWindowGood) return 'good';
+  if (ad <= activeWindowOk) return 'ok';
+  if (ad <= activeWindowMiss) return 'miss';
+  return null;
+}
+
+function applyJudgement(judgement, hitPos, options = {}) {
+  const viaDrag = options.viaDrag === true;
+  const comboBefore = combo;
+  const base = JUDGEMENT_POINTS[judgement];
+  const comboBonus = judgement === 'miss' ? 0 : Math.floor(base * clamp(combo * 0.075, 0, 2.5));
+  const feverActive = combo >= FEVER_COMBO_THRESHOLD;
+  const feverMult = feverActive ? FEVER_MULTIPLIER : 1;
+
+  achievedPoints += base;
+  totalJudged += 1;
+
+  if (judgement === 'perfect') {
+    combo += 1;
+    perfectCount += 1;
+    hits += 1;
+    health = clamp(health + 3.4, 0, HEALTH_MAX);
+    score += Math.floor((base + comboBonus) * feverMult);
+    beatGlow = Math.max(beatGlow, 0.18);
+    comboFlash = Math.max(comboFlash, 0.24);
+    screenShake = Math.max(screenShake, 0.05);
+    if (viaDrag) {
+      score += 35;
+      flowMeter = clamp(flowMeter + 0.13, 0, 1);
+      comboFlash = Math.max(comboFlash, 0.28);
+    }
+  } else if (judgement === 'good') {
+    combo += 1;
+    goodCount += 1;
+    hits += 1;
+    health = clamp(health + 1.7, 0, HEALTH_MAX);
+    score += Math.floor((base + comboBonus) * feverMult);
+    beatGlow = Math.max(beatGlow, 0.11);
+    comboFlash = Math.max(comboFlash, 0.18);
+    if (viaDrag) {
+      score += 20;
+      flowMeter = clamp(flowMeter + 0.1, 0, 1);
+      comboFlash = Math.max(comboFlash, 0.22);
+    }
+  } else if (judgement === 'ok') {
+    combo += 1;
+    okCount += 1;
+    hits += 1;
+    health = clamp(health + 0.6, 0, HEALTH_MAX);
+    score += Math.floor((base + comboBonus) * feverMult);
+    comboFlash = Math.max(comboFlash, 0.12);
+    if (viaDrag) {
+      score += 10;
+      flowMeter = clamp(flowMeter + 0.06, 0, 1);
+    }
+  } else {
+    combo = 0;
+    misses += 1;
+    health = clamp(health - 10.5, 0, HEALTH_MAX);
+    beatGlow = Math.max(beatGlow, 0.14);
+    screenShake = Math.max(screenShake, 0.23);
+    flowMeter = Math.max(0, flowMeter - 0.2);
+    playSfx('miss');
+    if (comboBefore >= 18) {
+      playSfx('comboBreak');
+    }
+  }
+
+  if (combo > maxCombo) maxCombo = combo;
+
+  const color = judgement === 'perfect'
+    ? rgba(0.43, 1.0, 0.64, 1)
+    : judgement === 'good'
+      ? rgba(0.47, 0.86, 1.0, 1)
+      : judgement === 'ok'
+        ? rgba(1.0, 0.88, 0.42, 1)
+        : rgba(1.0, 0.36, 0.38, 1);
+  const burstImpact = judgement === 'perfect'
+    ? 1.06
+    : judgement === 'good'
+      ? 0.92
+      : judgement === 'ok'
+        ? 0.78
+        : 0.68;
+
+  judgementPop = {
+    text: viaDrag && judgement !== 'miss' ? `DRAG ${judgement.toUpperCase()}` : judgement.toUpperCase(),
+    age: 0,
+    x: hitPos.x,
+    y: hitPos.y,
+    color,
+  };
+
+  bursts.push({
+    x: hitPos.x,
+    y: hitPos.y,
+    age: 0,
+    color,
+    judgement,
+    impact: viaDrag && judgement !== 'miss' ? burstImpact + 0.08 : burstImpact,
+  });
+
+  if (combo > 0 && combo % 25 === 0) {
+    judgementPop = {
+      text: `STREAK x${combo}`,
+      age: -0.1,
+      x: playX + (playW * 0.5),
+      y: playY + 42,
+      color: rgba(1.0, 0.9, 0.38, 1),
+    };
+  }
+}
+
+function mapPoint(idx) {
+  // A hand-tuned 4x3-ish distribution that feels close to rhythm-map spacing.
+  const points = [
+    [0.12, 0.15], [0.35, 0.13], [0.58, 0.14], [0.83, 0.17],
+    [0.16, 0.36], [0.39, 0.34], [0.62, 0.33], [0.84, 0.38],
+    [0.11, 0.57], [0.34, 0.56], [0.6, 0.55], [0.86, 0.58],
+    [0.17, 0.79], [0.41, 0.78], [0.64, 0.77], [0.87, 0.8],
+  ];
+  return points[idx % points.length];
+}
+
+function createBeatmap() {
+  const map = [];
+  const beat = ANALYZED_BEAT;
+  const start = MAP_START_TIME;
+  const mainBeats = activeMainBeats;
+  const d = activeDifficulty;
+  const minJump = Math.max(1, Math.floor(Number.isFinite(d.minJump) ? d.minJump : 3));
+  const burstInterval = Math.max(6, Math.floor(Number.isFinite(d.burstInterval) ? d.burstInterval : 12));
+  const burstPrimaryBeat = Math.max(1, Math.floor(burstInterval * 0.42));
+  const burstSecondaryBeat = Math.max(burstPrimaryBeat + 1, Math.floor(burstInterval * 0.75));
+  const burstChance = clamp(Number.isFinite(d.burstChance) ? d.burstChance : 0.72, 0, 1);
+  const allowBurstSecondary = d.burstSecondary !== false;
+  const tripleStartBeat = Math.max(8, Math.floor(Number.isFinite(d.tripleStartBeat) ? d.tripleStartBeat : 120));
+  const tripleChance = clamp(Number.isFinite(d.tripleChance) ? d.tripleChance : 0.38, 0, 1);
+  const tripleCount = Math.max(1, Math.floor(Number.isFinite(d.tripleCount) ? d.tripleCount : 2));
+  const offbeatChance = clamp(Number.isFinite(d.offbeatChance) ? d.offbeatChance : 0.12, 0, 1);
+  const offbeatOffset = clamp(Number.isFinite(d.offbeatOffset) ? d.offbeatOffset : 0.5, 0.2, 0.75);
+  const tripleModulo = Math.max(9, burstInterval + 5);
+  const triplePhase = tripleModulo - 2;
+  const dragLinkChance = clamp(Number.isFinite(d.dragLinkChance) ? d.dragLinkChance : 0.72, 0, 1);
+  const densityLevel = clamp(Math.floor(Number.isFinite(d.densityLevel) ? d.densityLevel : 1), 0, 3);
+  const extraAttemptsByDensity = [0, 1, 2, 3];
+  const extraChanceByDensity = [0.0, 0.28, 0.62, 0.92];
+  const extraOffsetPoolByDensity = [
+    [],
+    [0.25, 0.75],
+    [0.25, 0.5, 0.75, 0.125, 0.625],
+    [0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875],
+  ];
+  const extraAttempts = extraAttemptsByDensity[densityLevel];
+  const extraChance = extraChanceByDensity[densityLevel];
+  const extraOffsetPool = extraOffsetPoolByDensity[densityLevel];
+
+  let seed = 0xC0FFEE;
+  let lastIdx = 5;
+
+  function rand() {
+    seed = ((seed * 1664525) + 1013904223) >>> 0;
+    return seed / 4294967296;
+  }
+
+  function pickIndex() {
+    let idx = Math.floor(rand() * 16);
+    // Encourage jumpy motion and avoid accidental stacks.
+    for (let i = 0; i < 6; i += 1) {
+      if (Math.abs(idx - lastIdx) >= minJump) break;
+      idx = Math.floor(rand() * 16);
+    }
+    lastIdx = idx;
+    return idx;
+  }
+
+  for (let i = 0; i < mainBeats; i += 1) {
+    const t = start + (i * beat);
+    const idx = pickIndex();
+    const p = mapPoint(idx);
+    let addedHalfBeat = false;
+    const occupiedOffsets = new Set([0]);
+    map.push({
+      time: t,
+      nx: p[0],
+      ny: p[1],
+      judged: false,
+      judgement: null,
+      colorIndex: i % PALETTE.length,
+    });
+
+    // Controlled bursts for higher density sections.
+    const burstSlot = i % burstInterval;
+    if ((burstSlot === burstPrimaryBeat || (allowBurstSecondary && burstSlot === burstSecondaryBeat))
+      && rand() <= burstChance) {
+      const burstIdx = (idx + 5 + Math.floor(rand() * 5)) % 16;
+      const b = mapPoint(burstIdx);
+      map.push({
+        time: t + (beat * 0.5),
+        nx: b[0],
+        ny: b[1],
+        judged: false,
+        judgement: null,
+        colorIndex: (i + 1) % PALETTE.length,
+      });
+      addedHalfBeat = true;
+      occupiedOffsets.add(0.5);
+    }
+
+    // Extra off-beat taps appear earlier on higher difficulties.
+    if (offbeatChance > 0 && i > 6 && rand() < offbeatChance) {
+      const offIdx = (idx + 3 + Math.floor(rand() * 9)) % 16;
+      const off = mapPoint(offIdx);
+      const offset = addedHalfBeat && offbeatOffset >= 0.49 ? 0.25 : offbeatOffset;
+      occupiedOffsets.add(offset);
+      map.push({
+        time: t + (beat * offset),
+        nx: off[0],
+        ny: off[1],
+        judged: false,
+        judgement: null,
+        colorIndex: (i + 2) % PALETTE.length,
+      });
+    }
+
+    // Additional density layer for harder difficulties.
+    if (extraAttempts > 0 && extraOffsetPool.length > 0 && i > 4) {
+      for (let e = 0; e < extraAttempts; e += 1) {
+        if (rand() > extraChance) continue;
+        const available = extraOffsetPool.filter((offset) => !occupiedOffsets.has(offset));
+        if (available.length <= 0) break;
+        const offset = available[Math.floor(rand() * available.length)];
+        occupiedOffsets.add(offset);
+
+        const exIdx = (idx + 2 + Math.floor(rand() * 12)) % 16;
+        const ex = mapPoint(exIdx);
+        map.push({
+          time: t + (beat * offset),
+          nx: ex[0],
+          ny: ex[1],
+          judged: false,
+          judgement: null,
+          colorIndex: (i + 3 + e) % PALETTE.length,
+        });
+      }
+    }
+
+    // End sections with short triples.
+    if (i > tripleStartBeat && i % tripleModulo === triplePhase && rand() < tripleChance) {
+      for (let j = 1; j <= tripleCount; j += 1) {
+        const sIdx = (idx + (j * 3) + Math.floor(rand() * 2)) % 16;
+        const s = mapPoint(sIdx);
+        map.push({
+          time: t + (beat * (0.25 * j)),
+          nx: s[0],
+          ny: s[1],
+          judged: false,
+          judgement: null,
+          colorIndex: (i + j) % PALETTE.length,
+        });
+      }
+    }
+  }
+
+  map.sort((a, b) => a.time - b.time);
+
+  for (let i = 0; i < map.length; i += 1) {
+    map[i].index = i;
+    map[i].dragPrevIndex = null;
+    map[i].dragNextIndex = null;
+    map[i].hitsound = accentForNoteTime(map[i].time, start, beat);
+  }
+
+  for (let i = 0; i < map.length - 1; i += 1) {
+    const curr = map[i];
+    const next = map[i + 1];
+    const gap = next.time - curr.time;
+    if (gap <= (beat * activeDragChainBeatFactor)
+      && rand() <= dragLinkChance
+      && ((i + (i >> 1)) % 5 !== 0)) {
+      curr.dragNextIndex = next.index;
+      next.dragPrevIndex = curr.index;
+      next.colorIndex = curr.colorIndex;
+    }
+  }
+
+  // Smooth drag chain positions so sliders follow natural arcs
+  for (let i = 0; i < map.length; i += 1) {
+    if (map[i].dragNextIndex === null || map[i].dragNextIndex === undefined) continue;
+    if (map[i].dragPrevIndex !== null && map[i].dragPrevIndex !== undefined) continue;
+    // Start of a drag chain - collect all notes in the chain
+    const chain = [map[i]];
+    let cur = map[i];
+    while (cur.dragNextIndex !== null && cur.dragNextIndex !== undefined) {
+      cur = map[cur.dragNextIndex];
+      chain.push(cur);
+    }
+    if (chain.length < 2) continue;
+    // Interpolate intermediate notes along a smooth arc
+    const sx = chain[0].nx;
+    const sy = chain[0].ny;
+    const ex = chain[chain.length - 1].nx;
+    const ey = chain[chain.length - 1].ny;
+    const drift = 0.1 + (((chain[0].index * 7) % 11) / 11) * 0.14;
+    const perpX = -(ey - sy);
+    const perpY = ex - sx;
+    const sign = chain[0].index % 2 === 0 ? 1 : -1;
+    for (let j = 1; j < chain.length; j += 1) {
+      const frac = j / (chain.length - 1);
+      const arc = Math.sin(frac * Math.PI) * drift * sign;
+      chain[j].nx = clamp(sx + ((ex - sx) * frac) + (perpX * arc), 0.06, 0.94);
+      chain[j].ny = clamp(sy + ((ey - sy) * frac) + (perpY * arc), 0.06, 0.94);
+    }
+    // Skip to end of chain
+    i = chain[chain.length - 1].index;
+  }
+
+  return map;
+}
+
+function resetRun() {
+  applyDifficultySettings();
+  notes = createBeatmap();
+  currentTime = 0;
+  lastNoteTime = notes.length > 0 ? notes[notes.length - 1].time : 0;
+
+  score = 0;
+  combo = 0;
+  maxCombo = 0;
+  hits = 0;
+  misses = 0;
+  totalJudged = 0;
+  totalPointValue = notes.length * JUDGEMENT_POINTS.perfect;
+  achievedPoints = 0;
+  health = HEALTH_MAX;
+
+  perfectCount = 0;
+  goodCount = 0;
+  okCount = 0;
+
+  bursts = [];
+  judgementPop = null;
+  failed = false;
+  beatGlow = 0;
+  comboFlash = 0;
+  screenShake = 0;
+  cursorTrail = [];
+  flowMeter = 0;
+  hitBufferTimer = 0;
+  dragChainTimer = 0;
+  dragExpectedIndex = -1;
+  mouseHoldActive = false;
+  keyHoldActive = false;
+  hitPressedThisFrame = false;
+  k1Down = false;
+  k2Down = false;
+  k1Pulse = 0;
+  k2Pulse = 0;
+  k1Flash = 0;
+  k2Flash = 0;
+}
+
+function accuracyPercent() {
+  if (totalPointValue <= 0) return 0;
+  return (achievedPoints / totalPointValue) * 100;
+}
+
+function gradeForResults() {
+  const acc = accuracyPercent();
+  if (failed) return 'F';
+  if (acc >= 98 && misses === 0) return 'SS';
+  if (acc >= 93) return 'S';
+  if (acc >= 86) return 'A';
+  if (acc >= 75) return 'B';
+  if (acc >= 62) return 'C';
+  return 'D';
+}
+
+function assertRuntimeCapabilities() {
+  const missing = [];
+
+  if (!hasMethod(aura.draw2d, 'clear')) missing.push('aura.draw2d.clear');
+  if (!hasMethod(aura.draw2d, 'rectFill')) missing.push('aura.draw2d.rectFill');
+  if (!hasMethod(aura.draw2d, 'circle')) missing.push('aura.draw2d.circle');
+  if (!hasMethod(aura.draw2d, 'circleFill')) missing.push('aura.draw2d.circleFill');
+  if (!hasMethod(aura.draw2d, 'line')) missing.push('aura.draw2d.line');
+  if (!hasMethod(aura.draw2d, 'text')) missing.push('aura.draw2d.text');
+  if (!hasMethod(aura.draw2d, 'measureText')) missing.push('aura.draw2d.measureText');
+
+  if (!hasMethod(aura.input, 'isKeyDown')) missing.push('aura.input.isKeyDown');
+  if (!hasMethod(aura.input, 'getMousePosition')) missing.push('aura.input.getMousePosition');
+  if (!hasMethod(aura.input, 'isMousePressed')) missing.push('aura.input.isMousePressed');
+  if (!hasMethod(aura.window, 'getSize')) missing.push('aura.window.getSize');
+
+  if (missing.length > 0) {
+    throw new Error(`[aurasu] runtime missing required APIs: ${missing.join(', ')}`);
+  }
+
+  const small = aura.draw2d.measureText('Probe', { size: 8 });
+  const large = aura.draw2d.measureText('Probe', { size: 24 });
+  if (!Number.isFinite(small.width) || !Number.isFinite(large.width) || large.width <= small.width) {
+    throw new Error('[aurasu] draw2d.measureText appears to be placeholder behavior.');
+  }
+}
+
+function syncLayoutFromWindow() {
+  const size = aura.window.getSize();
+  if (!size || !Number.isFinite(size.width) || !Number.isFinite(size.height)) return;
+
+  worldWidth = size.width;
+  worldHeight = size.height;
+
+  const marginX = clamp(worldWidth * 0.09, 70, 180);
+  const marginY = clamp(worldHeight * 0.1, 60, 120);
+  playX = marginX;
+  playY = marginY;
+  playW = worldWidth - (marginX * 2);
+  playH = worldHeight - (marginY * 2);
+}
+
+function drawCentered(text, y, size, color) {
+  const m = aura.draw2d.measureText(text, { size });
+  const x = (worldWidth * 0.5) - (m.width * 0.5);
+  aura.draw2d.text(text, x, y, { size, color });
+}
+
+function hasSkinAsset(name) {
+  return skinLoaded.has(name) && typeof SKIN_ASSET_PATHS[name] === 'string';
+}
+
+function drawSkinSprite(name, x, y, options = {}) {
+  if (!canUseSpriteRuntime()) return false;
+  if (!hasSkinAsset(name)) return false;
+  const path = SKIN_ASSET_PATHS[name];
+  const drawOptions = { ...options };
+  const pixelSnap = drawOptions.pixelSnap === true;
+  delete drawOptions.pixelSnap;
+  let width = Number.isFinite(drawOptions.width) ? drawOptions.width : null;
+  let height = Number.isFinite(drawOptions.height) ? drawOptions.height : null;
+  const ox = Number.isFinite(drawOptions.originX) ? drawOptions.originX : 0;
+  const oy = Number.isFinite(drawOptions.originY) ? drawOptions.originY : 0;
+  let drawX = width !== null ? x - (width * ox) : x;
+  let drawY = height !== null ? y - (height * oy) : y;
+  if (pixelSnap) {
+    if (width !== null) {
+      width = Math.max(1, Math.round(width));
+      drawOptions.width = width;
+    }
+    if (height !== null) {
+      height = Math.max(1, Math.round(height));
+      drawOptions.height = height;
+    }
+    drawX = Math.round(drawX);
+    drawY = Math.round(drawY);
+  }
+  delete drawOptions.originX;
+  delete drawOptions.originY;
+  try {
+    if (hasMethod(aura.draw2d, 'sprite')) {
+      aura.draw2d.sprite(path, drawX, drawY, drawOptions);
+    } else {
+      aura.draw2d.image(path, drawX, drawY, drawOptions);
+    }
+    return true;
+  } catch {}
+  return false;
+}
+
+function drawBackground() {
+  aura.draw2d.clear(rgba(0.01, 0.015, 0.05, 1));
+
+  if (backgroundLoaded && canUseSpriteRuntime()) {
+    if (hasMethod(aura.draw2d, 'sprite')) {
+      aura.draw2d.sprite(BACKGROUND_ASSET_PATH, 0, 0, {
+        width: worldWidth,
+        height: worldHeight,
+        alpha: BACKGROUND_IMAGE_ALPHA,
+      });
+    } else {
+      aura.draw2d.image(BACKGROUND_ASSET_PATH, 0, 0, {
+        width: worldWidth,
+        height: worldHeight,
+        alpha: BACKGROUND_IMAGE_ALPHA,
+      });
+    }
+    aura.draw2d.rectFill(0, 0, worldWidth, worldHeight, rgba(0.02, 0.03, 0.08, BACKGROUND_DARK_OVERLAY_ALPHA));
+  }
+
+  for (let i = 0; i < BACKGROUND_LAYERS; i += 1) {
+    const t = i / (BACKGROUND_LAYERS - 1);
+    const r = 0.07 + (t * 0.06);
+    const g = 0.08 + (t * 0.08);
+    const b = 0.14 + (t * 0.16);
+    const y = Math.floor((i / BACKGROUND_LAYERS) * worldHeight);
+    const h = Math.ceil(worldHeight / BACKGROUND_LAYERS);
+    aura.draw2d.rectFill(0, y, worldWidth, h, rgba(r, g, b, backgroundLoaded ? BACKGROUND_LAYER_ALPHA_WITH_IMAGE : 1));
+  }
+
+  aura.draw2d.rectFill(0, 0, worldWidth, worldHeight, rgba(0, 0, 0, 0.5));
+
+  const vignetteBands = 7;
+  for (let i = 0; i < vignetteBands; i += 1) {
+    const pad = i * 24;
+    const alpha = BACKGROUND_VIGNETTE_ALPHA * (1 - (i / vignetteBands));
+    aura.draw2d.rect(
+      pad,
+      pad,
+      worldWidth - (pad * 2),
+      worldHeight - (pad * 2),
+      rgba(0.01, 0.015, 0.03, alpha)
+    );
+  }
+
+  aura.draw2d.rectFill(playX - 6, playY - 6, playW + 12, playH + 12, rgba(0.01, 0.02, 0.05, 0.86));
+  aura.draw2d.rectFill(playX, playY, playW, playH, rgba(0.01, 0.02, 0.05, 0.98));
+
+  for (let c = 0; c <= GRID_COLS; c += 1) {
+    const x = playX + ((c / GRID_COLS) * playW);
+    aura.draw2d.line(x, playY, x, playY + playH, rgba(1, 1, 1, 0.03), 1);
+  }
+  for (let r = 0; r <= GRID_ROWS; r += 1) {
+    const y = playY + ((r / GRID_ROWS) * playH);
+    aura.draw2d.line(playX, y, playX + playW, y, rgba(1, 1, 1, 0.03), 1);
+  }
+
+  aura.draw2d.rect(playX - 2, playY - 2, playW + 4, playH + 4, rgba(0.5, 0.76, 1, 0.34));
+  aura.draw2d.rect(playX, playY, playW, playH, rgba(0.88, 0.94, 1, 0.58));
+
+  if (beatGlow > 0) {
+    aura.draw2d.rectFill(0, 0, worldWidth, worldHeight, rgba(0.45, 0.78, 1.0, beatGlow));
+  }
+}
+
+function drawHitBursts(dt) {
+  for (const burst of bursts) {
+    burst.age += dt;
+    const impact = Number.isFinite(burst.impact) ? burst.impact : 0.8;
+    const flashGain = VIS_HIT_FLASH_GAIN;
+    const ttl = 0.46 + (impact * 0.1);
+    const life = clamp(1 - (burst.age / ttl), 0, 1);
+    if (life <= 0) continue;
+
+    const r = burst.color.r;
+    const g = burst.color.g;
+    const b = burst.color.b;
+    const shockT = 1 - life;
+
+    // Expanding colored shockwave rings
+    const ringR = (HIT_RADIUS * (0.95 + (impact * 0.08))) + (shockT * (170 + (impact * 100) * flashGain));
+    aura.draw2d.circle(burst.x, burst.y, ringR, rgba(r, g, b, clamp((0.78 + (impact * 0.24)) * life * flashGain, 0, 1)));
+    aura.draw2d.circle(burst.x, burst.y, ringR * 0.78, rgba(1, 1, 1, clamp((0.18 + (impact * 0.28)) * life * flashGain, 0, 1)));
+    aura.draw2d.circle(burst.x, burst.y, ringR * 0.58, rgba(r, g, b, clamp((0.16 + (impact * 0.2)) * life * flashGain, 0, 1)));
+
+    // White additive flash core
+    const flashR = (HIT_RADIUS * (1.35 + (impact * 0.2))) * (1 + ((flashGain - 1) * 0.45)) * clamp(1.5 - (burst.age * 4.5), 0, 1.5);
+    if (flashR > 0.5) {
+      aura.draw2d.circleFill(burst.x, burst.y, flashR, rgba(1, 1, 1, clamp((0.42 + (impact * 0.24)) * life * flashGain, 0, 1)));
+      aura.draw2d.circleFill(burst.x, burst.y, flashR * 0.54, rgba(r, g, b, clamp((0.3 + (impact * 0.25)) * life * flashGain, 0, 1)));
+    }
+    const coreR = HIT_RADIUS * clamp(1.15 - (burst.age * 2.7), 0, 1.15);
+    if (coreR > 0.5) {
+      aura.draw2d.circleFill(
+        burst.x,
+        burst.y,
+        coreR,
+        rgba((r * 0.85) + 0.15, (g * 0.85) + 0.15, (b * 0.85) + 0.15, 0.34 * life)
+      );
+    }
+
+    // Score value popup (300 / 100 / 50)
+    if (burst.judgement !== 'miss' && burst.judgement !== 'bonk') {
+      const pts = burst.judgement === 'perfect' ? '300' : burst.judgement === 'good' ? '100' : '50';
+      const ptsSize = 22 + (life * (6 + (impact * 2)));
+      const ptsY = burst.y - 26 - (burst.age * 65);
+      const m = aura.draw2d.measureText(pts, { size: ptsSize });
+      aura.draw2d.text(pts, burst.x - (m.width * 0.5) + 1, ptsY + 1, { size: ptsSize, color: rgba(0, 0, 0, 0.4 * life) });
+      aura.draw2d.text(pts, burst.x - (m.width * 0.5), ptsY, { size: ptsSize, color: rgba(r, g, b, 0.9 * life) });
+    }
+  }
+  bursts = bursts.filter((burst) => {
+    const impact = Number.isFinite(burst.impact) ? burst.impact : 0.8;
+    return burst.age < (0.46 + (impact * 0.1));
+  });
+}
+
+function drawJudgementPopup(dt) {
+  if (!judgementPop) return;
+  judgementPop.age += dt;
+  const life = clamp(1 - (judgementPop.age / 0.45), 0, 1);
+  if (life <= 0) {
+    judgementPop = null;
+    return;
+  }
+
+  const y = judgementPop.y - 18 - (judgementPop.age * 52);
+  const size = 26 + (life * 8);
+  const col = rgba(judgementPop.color.r, judgementPop.color.g, judgementPop.color.b, 0.95 * life);
+  const textUpper = judgementPop.text.toUpperCase();
+  let judgementSprite = null;
+  if (textUpper.includes('PERFECT')) judgementSprite = 'judgement300';
+  else if (textUpper.includes('GOOD')) judgementSprite = 'judgement100';
+  else if (textUpper.includes('OK')) judgementSprite = 'judgement50';
+  else if (textUpper.includes('MISS')) judgementSprite = 'judgementMiss';
+
+  if (judgementSprite) {
+    const w = 220 + (life * 44);
+    const h = w * 0.5;
+    aura.draw2d.circleFill(judgementPop.x, y + 10, w * 0.28, rgba(col.r, col.g, col.b, 0.08 * life));
+    const drew = drawSkinSprite(judgementSprite, judgementPop.x, y + 10, {
+      width: w,
+      height: h,
+      originX: 0.5,
+      originY: 0.5,
+      alpha: 0.95 * life,
+    });
+    if (drew) return;
+  }
+
+  const m = aura.draw2d.measureText(judgementPop.text, { size });
+  aura.draw2d.text(judgementPop.text, judgementPop.x - (m.width * 0.5), y, { size, color: col });
+}
+
+function drawSliderBody(startPos, endPos, activeLink, colorIndex, seed, progress) {
+  const dx = endPos.x - startPos.x;
+  const dy = endPos.y - startPos.y;
+  const len = Math.hypot(dx, dy);
+  if (len <= 0.001) return;
+
+  const perpX = -dy / len;
+  const perpY = dx / len;
+  const bendDir = seed % 2 === 0 ? 1 : -1;
+  const bend = clamp(len * 0.24, 22, 90) * bendDir;
+  const cpx = ((startPos.x + endPos.x) * 0.5) + (perpX * bend);
+  const cpy = ((startPos.y + endPos.y) * 0.5) + (perpY * bend);
+
+  const base = PALETTE[colorIndex % PALETTE.length];
+  const steps = Math.max(22, Math.ceil(len / 6));
+  const bodyR = HIT_RADIUS - 2;
+
+  // Pass 1: white border
+  for (let i = 0; i <= steps; i += 1) {
+    const t = i / steps;
+    const u = 1 - t;
+    const px = (u * u * startPos.x) + (2 * u * t * cpx) + (t * t * endPos.x);
+    const py = (u * u * startPos.y) + (2 * u * t * cpy) + (t * t * endPos.y);
+    aura.draw2d.circleFill(px, py, bodyR + 4, rgba(1, 1, 1, 0.48));
+  }
+
+  // Pass 2: colored body fill
+  for (let i = 0; i <= steps; i += 1) {
+    const t = i / steps;
+    const u = 1 - t;
+    const px = (u * u * startPos.x) + (2 * u * t * cpx) + (t * t * endPos.x);
+    const py = (u * u * startPos.y) + (2 * u * t * cpy) + (t * t * endPos.y);
+    aura.draw2d.circleFill(px, py, bodyR, rgba(base[0] * 0.3, base[1] * 0.3, base[2] * 0.3, 0.9));
+  }
+
+  // Pass 3: inner highlight
+  for (let i = 0; i <= steps; i += 1) {
+    const t = i / steps;
+    const u = 1 - t;
+    const px = (u * u * startPos.x) + (2 * u * t * cpx) + (t * t * endPos.x);
+    const py = (u * u * startPos.y) + (2 * u * t * cpy) + (t * t * endPos.y);
+    aura.draw2d.circleFill(px, py, bodyR * 0.55, rgba(base[0] * 0.15 + 0.06, base[1] * 0.15 + 0.06, base[2] * 0.15 + 0.06, 0.45));
+  }
+
+  // End circle
+  aura.draw2d.circleFill(endPos.x, endPos.y, bodyR - 4, rgba(base[0] * 0.4, base[1] * 0.4, base[2] * 0.4, 0.72));
+  aura.draw2d.circle(endPos.x, endPos.y, bodyR - 4, rgba(1, 1, 1, 0.58));
+
+  // Tick marks along slider path
+  const tickSpacing = 54;
+  const tickCount = Math.max(1, Math.floor(len / tickSpacing));
+  for (let i = 1; i < tickCount; i += 1) {
+    const t = i / tickCount;
+    const u = 1 - t;
+    const tx = (u * u * startPos.x) + (2 * u * t * cpx) + (t * t * endPos.x);
+    const ty = (u * u * startPos.y) + (2 * u * t * cpy) + (t * t * endPos.y);
+    const tickPulse = 0.65 + (Math.sin((pulseTime * 7.4) + (t * 8.0) + seed) * 0.35);
+    const tickAlpha = 0.22 + (tickPulse * 0.5);
+    if (!drawSkinSprite('followpoint', tx, ty, {
+      width: 10,
+      height: 10,
+      originX: 0.5,
+      originY: 0.5,
+      alpha: tickAlpha,
+    })) {
+      aura.draw2d.circleFill(tx, ty, 4, rgba(1, 1, 1, 0.26 + (tickPulse * 0.3)));
+    }
+  }
+
+  // Slider ball motion
+  if (progress >= 0) {
+    const t = clamp(progress, 0, 1);
+    const u = 1 - t;
+    const bx = (u * u * startPos.x) + (2 * u * t * cpx) + (t * t * endPos.x);
+    const by = (u * u * startPos.y) + (2 * u * t * cpy) + (t * t * endPos.y);
+    const motionGlow = 0.35 + (Math.sin((pulseTime * 12) + (seed * 0.9)) * 0.18);
+
+    // Follow circle
+    if (activeLink) {
+      const followDrew = drawSkinSprite('sliderfollowcircle', bx, by, {
+        width: (bodyR + 11) * 2,
+        height: (bodyR + 11) * 2,
+        originX: 0.5,
+        originY: 0.5,
+        alpha: 0.72 + (motionGlow * 0.2),
+      });
+      if (!followDrew) {
+        aura.draw2d.circleFill(bx, by, bodyR + 10, rgba(1, 1, 1, 0.12 + (motionGlow * 0.06)));
+        aura.draw2d.circle(bx, by, bodyR + 10, rgba(1, 1, 1, 0.62 + (motionGlow * 0.1)));
+      }
+    }
+
+    // Ball
+    const ballDrew = drawSkinSprite('sliderball', bx, by, {
+      width: 26,
+      height: 26,
+      originX: 0.5,
+      originY: 0.5,
+      alpha: activeLink ? 0.96 : 0.88,
+      tint: rgb(base[0], base[1], base[2]),
+    });
+    if (!ballDrew) {
+      aura.draw2d.circleFill(bx, by, 12, rgba(base[0], base[1], base[2], activeLink ? 0.94 : 0.86));
+      aura.draw2d.circle(bx, by, 12, rgba(1, 1, 1, activeLink ? 0.86 : 0.72));
+      aura.draw2d.circleFill(bx, by, 5, rgba(1, 1, 1, activeLink ? 0.68 : 0.58));
+    }
+
+    // Motion aura
+    aura.draw2d.circle(bx, by, 16 + (motionGlow * 4), rgba(base[0], base[1], base[2], activeLink ? 0.45 : 0.24));
+  }
+}
+
+function drawNotes() {
+  let upcoming = null;
+  let minAhead = Infinity;
+
+  // Pass 1: draw all visible slider bodies (behind circles)
+  for (const note of notes) {
+    if (note.dragNextIndex === null || note.dragNextIndex === undefined) continue;
+    const next = notes[note.dragNextIndex];
+    if (!next || next.judged) continue;
+
+    const tNote = note.time - currentTime;
+    const tNext = next.time - currentTime;
+    if (tNote > activeApproachTime + 0.5 && tNext > activeApproachTime + 0.5) continue;
+    if (tNote < -(activeWindowMiss * 3) && tNext < -(activeWindowMiss * 3)) continue;
+
+    const pos = notePosition(note);
+    const nextPos = notePosition(next);
+    const isActive = dragExpectedIndex === next.index;
+    let sliderProgress = -1;
+    const dur = next.time - note.time;
+    if (dur > 0) {
+      const preRoll = 0.16;
+      const postRoll = 0.08;
+      if (currentTime >= (note.time - preRoll) && currentTime <= (next.time + postRoll)) {
+        sliderProgress = clamp((currentTime - note.time) / dur, 0, 1);
+      }
+      if (!note.judged && isActive) {
+        sliderProgress = clamp((currentTime - note.time) / dur, 0, 1);
+      }
+    }
+    drawSliderBody(pos, nextPos, isActive, note.colorIndex, note.index, sliderProgress);
+  }
+
+  // Pass 2: draw hit circles
+  for (const note of notes) {
+    if (note.judged) continue;
+    const timeUntil = note.time - currentTime;
+    if (timeUntil < -activeWindowMiss || timeUntil > activeApproachTime) continue;
+
+    if (timeUntil >= 0 && timeUntil < minAhead) {
+      minAhead = timeUntil;
+      upcoming = note;
+    }
+
+    const pos = notePosition(note);
+    const pal = PALETTE[note.colorIndex % PALETTE.length];
+    const approachT = clamp(timeUntil / activeApproachTime, 0, 1);
+    const alphaScale = clamp(1 - ((-timeUntil) / activeWindowMiss), 0.3, 1);
+    const fadeIn = clamp(1 - approachT + 0.15, 0, 1);
+    const approachAlpha = fadeIn * alphaScale;
+    const lateFade = clamp(Math.max(0, -timeUntil) / activeWindowMiss, 0, 1);
+    const circleAlpha = clamp(1 - (lateFade * 0.08), VIS_CIRCLE_SOLID_MIN_ALPHA, 1);
+    const spawnAge = activeApproachTime - timeUntil;
+    const spawnPulse = spawnAge >= 0 && spawnAge <= 0.2
+      ? 1 - (spawnAge / 0.2)
+      : 0;
+    const noteScale = 1 + (spawnPulse * VIS_NOTE_POP_SCALE);
+    const noteRadius = HIT_RADIUS * noteScale;
+    const noteSpriteRadius = Math.max(8, Math.round(noteRadius));
+
+    // High-contrast approach ring with thicker layered stroke.
+    if (timeUntil > 0) {
+      const aR = noteRadius * (1 + (approachT * 2.35));
+      const approachSpriteRadius = Math.max(2, Math.round(aR));
+      const ringPulse = 0.88 + (Math.sin((pulseTime * 14) + (note.index * 0.72)) * 0.12);
+      const ringAlpha = clamp((0.52 + (approachT * 0.98)) * approachAlpha * ringPulse, 0, 1);
+      const approachColor = rgb(pal[0], pal[1], pal[2]);
+      const drewFar = drawSkinSprite('approachcircle', pos.x, pos.y, {
+        width: (approachSpriteRadius + 8) * 2,
+        height: (approachSpriteRadius + 8) * 2,
+        originX: 0.5,
+        originY: 0.5,
+        frameX: CIRCLE_SPRITE_INSET,
+        frameY: CIRCLE_SPRITE_INSET,
+        frameW: CIRCLE_SPRITE_FRAME,
+        frameH: CIRCLE_SPRITE_FRAME,
+        pixelSnap: true,
+        alpha: 0.2 * ringAlpha,
+        tint: approachColor,
+      });
+      const drewOuter = drawSkinSprite('approachcircle', pos.x, pos.y, {
+        width: (approachSpriteRadius + 3) * 2,
+        height: (approachSpriteRadius + 3) * 2,
+        originX: 0.5,
+        originY: 0.5,
+        frameX: CIRCLE_SPRITE_INSET,
+        frameY: CIRCLE_SPRITE_INSET,
+        frameW: CIRCLE_SPRITE_FRAME,
+        frameH: CIRCLE_SPRITE_FRAME,
+        pixelSnap: true,
+        alpha: 0.42 * ringAlpha,
+        tint: approachColor,
+      });
+      const drewInner = drawSkinSprite('approachcircle', pos.x, pos.y, {
+        width: approachSpriteRadius * 2,
+        height: approachSpriteRadius * 2,
+        originX: 0.5,
+        originY: 0.5,
+        frameX: CIRCLE_SPRITE_INSET,
+        frameY: CIRCLE_SPRITE_INSET,
+        frameW: CIRCLE_SPRITE_FRAME,
+        frameH: CIRCLE_SPRITE_FRAME,
+        pixelSnap: true,
+        alpha: clamp((1.02 * ringAlpha) + 0.08, 0, 1),
+        tint: approachColor,
+      });
+      if (!drewFar && !drewOuter && !drewInner) {
+        aura.draw2d.circle(pos.x, pos.y, aR + 7, rgba(pal[0], pal[1], pal[2], 0.2 * ringAlpha));
+        aura.draw2d.circle(pos.x, pos.y, aR + 2.5, rgba(pal[0], pal[1], pal[2], 0.42 * ringAlpha));
+        aura.draw2d.circle(pos.x, pos.y, aR, rgba(pal[0], pal[1], pal[2], 1.0 * ringAlpha));
+        aura.draw2d.circle(pos.x, pos.y, Math.max(2, aR - 3), rgba(1, 1, 1, 0.68 * ringAlpha));
+      }
+    }
+
+    // Spawn pop + shockwave as notes enter the play window.
+    if (spawnPulse > 0) {
+      const spawnShockR = noteRadius + ((1 - spawnPulse) * 54);
+      const spawnAlpha = 0.42 * spawnPulse * circleAlpha;
+      aura.draw2d.circle(pos.x, pos.y, spawnShockR, rgba(pal[0], pal[1], pal[2], spawnAlpha));
+      aura.draw2d.circle(pos.x, pos.y, Math.max(2, spawnShockR - 3), rgba(1, 1, 1, spawnAlpha * 0.52));
+    }
+
+    // Outer glow behind skinned circle.
+    const glowR = noteRadius + 10 + (spawnPulse * 10);
+    aura.draw2d.circleFill(pos.x, pos.y, glowR, rgba(pal[0], pal[1], pal[2], (0.24 + (spawnPulse * 0.28)) * circleAlpha));
+
+    // Circle body + overlay (skin assets with fallback).
+    const bodyBaseAlpha = clamp(0.97 + (spawnPulse * 0.03), 0, 1);
+    aura.draw2d.circleFill(pos.x, pos.y, noteRadius * 0.98, rgba(pal[0] * 0.62, pal[1] * 0.62, pal[2] * 0.62, bodyBaseAlpha));
+    const drewBase = drawSkinSprite('hitcircle', pos.x, pos.y, {
+      width: noteSpriteRadius * 2,
+      height: noteSpriteRadius * 2,
+      originX: 0.5,
+      originY: 0.5,
+      frameX: CIRCLE_SPRITE_INSET,
+      frameY: CIRCLE_SPRITE_INSET,
+      frameW: CIRCLE_SPRITE_FRAME,
+      frameH: CIRCLE_SPRITE_FRAME,
+      pixelSnap: true,
+      alpha: 0.99 * circleAlpha,
+    });
+    const drewOverlay = drawSkinSprite('hitcircleoverlay', pos.x, pos.y, {
+      width: noteSpriteRadius * 2,
+      height: noteSpriteRadius * 2,
+      originX: 0.5,
+      originY: 0.5,
+      frameX: CIRCLE_SPRITE_INSET,
+      frameY: CIRCLE_SPRITE_INSET,
+      frameW: CIRCLE_SPRITE_FRAME,
+      frameH: CIRCLE_SPRITE_FRAME,
+      pixelSnap: true,
+      alpha: (0.94 + (spawnPulse * 0.06)) * circleAlpha,
+    });
+    if (!drewBase && !drewOverlay) {
+      aura.draw2d.circleFill(pos.x, pos.y, noteRadius, rgba(pal[0] * 0.56, pal[1] * 0.56, pal[2] * 0.56, 0.98 * circleAlpha));
+      aura.draw2d.circle(pos.x, pos.y, noteRadius, rgba(1, 1, 1, (0.95 + (spawnPulse * 0.05)) * circleAlpha));
+      aura.draw2d.circle(pos.x, pos.y, noteRadius - 3, rgba(1, 1, 1, (0.32 + (spawnPulse * 0.18)) * circleAlpha));
+      aura.draw2d.circleFill(pos.x, pos.y, noteRadius * 0.54, rgba(0.02, 0.02, 0.05, 0.72 * circleAlpha));
+      aura.draw2d.circleFill(
+        pos.x - (noteRadius * 0.2),
+        pos.y - (noteRadius * 0.22),
+        noteRadius * 0.22,
+        rgba(1, 1, 1, 0.15 * circleAlpha * (0.5 + (spawnPulse * 0.5)))
+      );
+    }
+
+    const edgePulse = 0.84 + (Math.sin((pulseTime * 18) + (note.index * 0.37)) * 0.16);
+    aura.draw2d.circle(pos.x, pos.y, noteRadius + 1.5, rgba(1, 1, 1, (0.42 + (spawnPulse * 0.24)) * circleAlpha * edgePulse));
+    aura.draw2d.circle(pos.x, pos.y, noteRadius - 3, rgba(pal[0], pal[1], pal[2], (0.5 + (spawnPulse * 0.3)) * circleAlpha));
+
+    // Combo number
+    const numStr = String((note.index % 9) + 1);
+    const numSz = clamp(32 * noteScale, 28, 44);
+    const numMet = aura.draw2d.measureText(numStr, { size: numSz });
+    const numX = pos.x - (numMet.width * 0.5);
+    const numY = pos.y - (numSz * 0.36);
+    aura.draw2d.text(numStr, numX + 1.5, numY + 1.5, { size: numSz, color: rgba(0, 0, 0, 0.58 * circleAlpha) });
+    aura.draw2d.text(numStr, numX, numY, { size: numSz, color: rgba(1, 1, 1, 0.98 * circleAlpha) });
+
+    // Active drag target indicator
+    if (dragExpectedIndex === note.index) {
+      const s = 1 + (Math.sin(pulseTime * 14) * 0.08);
+      aura.draw2d.circle(pos.x, pos.y, (noteRadius + 12) * s, rgba(0.49, 1.0, 0.72, 0.82));
+      aura.draw2d.circle(pos.x, pos.y, (noteRadius + 18) * s, rgba(1, 1, 1, 0.24));
+    }
+  }
+
+  // Subtle highlight on next note
+  if (upcoming) {
+    const p = notePosition(upcoming);
+    aura.draw2d.circle(p.x, p.y, HIT_RADIUS + 16, rgba(1, 1, 1, 0.18));
+    aura.draw2d.circle(p.x, p.y, HIT_RADIUS + 22, rgba(0.45, 0.9, 1.0, 0.14));
+  }
+}
+
+function drawCursor() {
+  for (const trail of cursorTrail) {
+    const t = clamp(1 - (trail.age / CURSOR_TRAIL_LIFE), 0, 1);
+    const trailDrew = drawSkinSprite('cursortrail', trail.x, trail.y, {
+      width: 24 + (t * 18),
+      height: 24 + (t * 18),
+      originX: 0.5,
+      originY: 0.5,
+      alpha: 0.36 * t,
+      tint: rgb(0.42, 0.9, 1.0),
+    });
+    if (!trailDrew) {
+      aura.draw2d.circleFill(trail.x, trail.y, 4 + (t * 10), rgba(0.42, 0.9, 1.0, 0.2 * t));
+    }
+  }
+
+  const m = getMouse();
+  if (dragExpectedIndex >= 0 && (mouseHoldActive || keyHoldActive)) {
+    const followDrew = drawSkinSprite('sliderfollowcircle', m.x, m.y, {
+      width: 44,
+      height: 44,
+      originX: 0.5,
+      originY: 0.5,
+      alpha: 0.62,
+    });
+    if (!followDrew) {
+      aura.draw2d.circle(m.x, m.y, 22, rgba(0.52, 1.0, 0.72, 0.75));
+    }
+  }
+
+  const cursorDrew = drawSkinSprite('cursor', m.x, m.y, {
+    width: 34,
+    height: 34,
+    originX: 0.5,
+    originY: 0.5,
+    alpha: 0.95,
+  });
+  if (!cursorDrew) {
+    aura.draw2d.circle(m.x, m.y, 15, rgba(1, 1, 1, 0.8));
+    aura.draw2d.circle(m.x, m.y, 8, rgba(0.3, 0.95, 1, 0.95));
+    aura.draw2d.line(m.x - 22, m.y, m.x + 22, m.y, rgba(1, 1, 1, 0.32), 1);
+    aura.draw2d.line(m.x, m.y - 22, m.x, m.y + 22, rgba(1, 1, 1, 0.32), 1);
+    return;
+  }
+  aura.draw2d.circle(m.x, m.y, 17, rgba(1, 1, 1, 0.3));
+}
+
+function drawHud() {
+  const acc = accuracyPercent();
+  const timeLeft = Math.max(0, lastNoteTime - currentTime);
+  const feverActive = combo >= FEVER_COMBO_THRESHOLD;
+  const feverFill = feverActive ? rgba(1.0, 0.86, 0.36, 0.16 + (comboFlash * 0.35)) : rgba(0, 0, 0, 0);
+  const diff = getSelectedDifficulty();
+
+  aura.draw2d.rectFill(14, 14, 420, 114, rgba(0.03, 0.04, 0.07, 0.72));
+  if (feverActive) {
+    aura.draw2d.rectFill(14, 14, 420, 114, feverFill);
+  }
+  aura.draw2d.text(`SCORE ${score}`, 28, 32, { size: 26, color: white() });
+  aura.draw2d.text(`COMBO x${combo}`, 28, 60, { size: 18, color: rgba(0.95, 0.97, 1, 1) });
+  aura.draw2d.text(`ACC ${acc.toFixed(2)}%`, 28, 82, { size: 18, color: rgba(0.56, 0.96, 1, 1) });
+  aura.draw2d.text(`LEFT ${timeLeft.toFixed(1)}s`, 28, 103, { size: 14, color: rgba(0.82, 0.88, 1, 0.95) });
+  aura.draw2d.text(`DIFF ${diff.label}`, 250, 82, { size: 14, color: rgba(diff.accent[0], diff.accent[1], diff.accent[2], 0.95) });
+  if (feverActive) {
+    aura.draw2d.text(`FEVER x${FEVER_MULTIPLIER.toFixed(2)}`, 250, 103, { size: 14, color: rgba(1.0, 0.9, 0.36, 1) });
+  }
+
+  const flowX = 248;
+  const flowY = 58;
+  const flowW = 166;
+  aura.draw2d.rectFill(flowX, flowY, flowW, 10, rgba(0.02, 0.03, 0.05, 0.65));
+  aura.draw2d.rectFill(flowX + 1, flowY + 1, (flowW - 2) * flowMeter, 8, rgba(0.44, 0.95, 1.0, 0.85));
+  aura.draw2d.text('FLOW', flowX, flowY - 4, { size: 11, color: rgba(0.8, 0.94, 1, 0.92) });
+
+  const barX = worldWidth - 374;
+  const barY = 30;
+  const barW = 340;
+  const barH = 26;
+  const hpT = clamp(health / HEALTH_MAX, 0, 1);
+  const hpColor = hpT > 0.65
+    ? rgba(0.32, 1, 0.58, 0.95)
+    : hpT > 0.35
+      ? rgba(1, 0.84, 0.34, 0.95)
+      : rgba(1, 0.35, 0.35, 0.95);
+  aura.draw2d.rectFill(barX, barY, barW, barH, rgba(0.02, 0.02, 0.05, 0.75));
+  aura.draw2d.rectFill(barX + 2, barY + 2, (barW - 4) * hpT, barH - 4, hpColor);
+  aura.draw2d.rect(barX, barY, barW, barH, rgba(1, 1, 1, 0.4));
+  aura.draw2d.text('HEALTH', barX + 6, barY + 18, { size: 12, color: rgba(1, 1, 1, 0.75) });
+
+  const progress = clamp(currentTime / Math.max(lastNoteTime, 0.001), 0, 1);
+  const pX = 14;
+  const pY = worldHeight - 26;
+  const pW = worldWidth - 28;
+  aura.draw2d.rectFill(pX, pY, pW, 10, rgba(0.02, 0.03, 0.05, 0.8));
+  aura.draw2d.rectFill(pX + 1, pY + 1, (pW - 2) * progress, 8, rgba(0.45, 0.9, 1.0, 0.8));
+
+  // Round key indicators (osu!-style)
+  const keyR = 30;
+  const keyGap = 22;
+  const keyCy = worldHeight - 78;
+  const k1cx = (worldWidth * 0.5) - keyR - (keyGap * 0.5);
+  const k2cx = (worldWidth * 0.5) + keyR + (keyGap * 0.5);
+  const k1G = clamp((k1Down ? 0.8 : 0) + (k1Pulse * 0.9), 0, 1);
+  const k2G = clamp((k2Down ? 0.8 : 0) + (k2Pulse * 0.9), 0, 1);
+  const k1FT = clamp(k1Flash, 0, 1);
+  const k2FT = clamp(k2Flash, 0, 1);
+
+  // K1 flash ring
+  if (k1FT > 0) {
+    const k1PulseR = keyR + 22 + ((1 - k1FT) * 34);
+    aura.draw2d.circle(k1cx, keyCy, k1PulseR, rgba(0.34, 0.88, 1.0, 0.92 * k1FT));
+    aura.draw2d.circle(k1cx, keyCy, k1PulseR - 6, rgba(1, 1, 1, 0.46 * k1FT));
+    aura.draw2d.circleFill(k1cx, keyCy, keyR + 12 + (k1FT * 9), rgba(0.34, 0.88, 1.0, 0.08 * k1FT));
+  }
+  // K2 flash ring
+  if (k2FT > 0) {
+    const k2PulseR = keyR + 22 + ((1 - k2FT) * 34);
+    aura.draw2d.circle(k2cx, keyCy, k2PulseR, rgba(1.0, 0.48, 0.72, 0.92 * k2FT));
+    aura.draw2d.circle(k2cx, keyCy, k2PulseR - 6, rgba(1, 1, 1, 0.46 * k2FT));
+    aura.draw2d.circleFill(k2cx, keyCy, keyR + 12 + (k2FT * 9), rgba(1.0, 0.48, 0.72, 0.08 * k2FT));
+  }
+
+  // K1 glow + body
+  aura.draw2d.circleFill(k1cx, keyCy, keyR + 8 + (k1G * 10), rgba(0.34, 0.88, 1.0, 0.1 + (k1G * 0.28)));
+  aura.draw2d.circleFill(k1cx, keyCy, keyR, rgba(0.08, 0.2, 0.34, 0.66 + (k1G * 0.34)));
+  aura.draw2d.circle(k1cx, keyCy, keyR, rgba(0.34, 0.88, 1.0, 0.56 + (k1G * 0.44)));
+  aura.draw2d.circleFill(k1cx, keyCy, keyR * 0.5, rgba(1, 1, 1, 0.05 + (k1G * 0.2)));
+  const k1m = aura.draw2d.measureText('K1', { size: 18 });
+  aura.draw2d.text('K1', k1cx - (k1m.width * 0.5), keyCy - 5, { size: 18, color: rgba(1, 1, 1, 0.82 + (k1G * 0.18)) });
+  aura.draw2d.text('Z', k1cx - 3, keyCy + 14, { size: 10, color: rgba(0.7, 0.9, 1.0, 0.65) });
+
+  // K2 glow + body
+  aura.draw2d.circleFill(k2cx, keyCy, keyR + 8 + (k2G * 10), rgba(1.0, 0.48, 0.72, 0.1 + (k2G * 0.28)));
+  aura.draw2d.circleFill(k2cx, keyCy, keyR, rgba(0.34, 0.08, 0.2, 0.66 + (k2G * 0.34)));
+  aura.draw2d.circle(k2cx, keyCy, keyR, rgba(1.0, 0.48, 0.72, 0.56 + (k2G * 0.44)));
+  aura.draw2d.circleFill(k2cx, keyCy, keyR * 0.5, rgba(1, 1, 1, 0.05 + (k2G * 0.2)));
+  const k2m = aura.draw2d.measureText('K2', { size: 18 });
+  aura.draw2d.text('K2', k2cx - (k2m.width * 0.5), keyCy - 5, { size: 18, color: rgba(1, 1, 1, 0.82 + (k2G * 0.18)) });
+  aura.draw2d.text('X', k2cx - 3, keyCy + 14, { size: 10, color: rgba(1.0, 0.8, 0.9, 0.65) });
+
+  const bgmState = !bgmLoaded
+    ? 'BGM loading...'
+    : bgmHandle >= 0
+      ? (bgmMuted ? 'BGM muted (M)' : 'BGM on (M mute, N restart)')
+      : (state === 'title' ? 'BGM ready (press start)' : 'BGM unavailable');
+  const sfxState = sfxMuted ? 'SFX muted (H)' : 'SFX on (H mute)';
+  aura.draw2d.text(`${bgmState}  |  ${sfxState}`, worldWidth - 430, worldHeight - 38, {
+    size: 13,
+    color: (bgmHandle >= 0 || state === 'title')
+      ? rgba(0.66, 0.98, 0.74, 0.96)
+      : rgba(1.0, 0.64, 0.5, 0.96),
+  });
+  if (bgmLastError && bgmHandle < 0 && state !== 'title') {
+    aura.draw2d.text('audio error in terminal logs', worldWidth - 260, worldHeight - 20, {
+      size: 11,
+      color: rgba(1.0, 0.56, 0.5, 0.9),
+    });
+  }
+}
+
+function drawTitle() {
+  const pulse = 0.76 + (Math.sin(pulseTime * 4.2) * 0.24);
+  const cx = worldWidth * 0.5;
+  const cy = worldHeight * 0.32;
+  const mouse = getMouse();
+  const selected = getSelectedDifficulty();
+
+  // Decorative pulsing rings
+  const ringPulse = 1 + (Math.sin(pulseTime * 2.0) * 0.04);
+  aura.draw2d.circle(cx, cy, 130 * ringPulse, rgba(0.28, 0.83, 1.0, 0.1));
+  aura.draw2d.circle(cx, cy, 95 * ringPulse, rgba(0.28, 0.83, 1.0, 0.15));
+  aura.draw2d.circleFill(cx, cy, 60, rgba(0.28, 0.83, 1.0, 0.04));
+
+  drawCentered('AURASU', Math.floor(worldHeight * 0.2), 72, rgba(1, 1, 1, 0.98));
+  drawCentered('TAP CIRCLES  |  FOLLOW SLIDERS  |  CATCH THE BEAT', Math.floor(worldHeight * 0.32), 19, rgba(0.74, 0.93, 1, 0.92));
+  drawCentered('CLICK / Z / X TO HIT', Math.floor(worldHeight * 0.39), 17, rgba(1, 1, 1, 0.8));
+  drawCentered('PICK DIFFICULTY', Math.floor(worldHeight * 0.47), 18, rgba(0.86, 0.97, 1.0, 0.88));
+
+  const chipCount = DIFFICULTY_PRESETS.length;
+  const rowGap = 7;
+  const rowW = 280;
+  const rowH = 36;
+  const totalH = (rowH * chipCount) + (rowGap * (chipCount - 1));
+  const rowX = Math.floor((worldWidth - rowW) * 0.5);
+  const rowY0 = Math.floor(worldHeight * 0.505);
+  titleDifficultyBoxes = [];
+
+  for (let i = 0; i < chipCount; i += 1) {
+    const diff = DIFFICULTY_PRESETS[i];
+    const x = rowX;
+    const y = rowY0 + (i * (rowH + rowGap));
+    const isSelected = i === selectedDifficultyIndex;
+    const hover = pointInRect(mouse.x, mouse.y, x, y, rowW, rowH);
+    const labelColor = isSelected
+      ? rgba(1, 1, 1, 1)
+      : hover
+        ? rgba(0.9, 0.94, 1.0, 0.9)
+        : rgba(0.78, 0.84, 0.92, 0.72);
+    if (isSelected) {
+      aura.draw2d.text('▶', x - 22, y + 25, {
+        size: 18,
+        color: rgba(1, 1, 1, 0.98),
+      });
+      aura.draw2d.line(x - 6, y + 5, x - 6, y + rowH - 4, rgba(1, 1, 1, 0.65), 2);
+    }
+    aura.draw2d.text(`${i + 1}. ${diff.label}`, x, y + 24, {
+      size: 28,
+      color: labelColor,
+    });
+    aura.draw2d.text(diff.subtitle, x + 140, y + 24, {
+      size: 12,
+      color: isSelected ? rgba(0.86, 0.9, 0.98, 0.95) : rgba(0.72, 0.8, 0.9, 0.62),
+    });
+    titleDifficultyBoxes.push({ index: i, x: x - 26, y, w: rowW + 32, h: rowH });
+  }
+
+  const menuBottom = rowY0 + totalH;
+  const hintY = Math.min(worldHeight - 88, menuBottom + 18);
+  const startY = Math.min(worldHeight - 58, hintY + 30);
+  const timingY = Math.min(worldHeight - 34, startY + 26);
+  const controlsY = Math.min(worldHeight - 16, timingY + 18);
+  drawCentered(`SELECTED: ${selected.label}  |  UP/DOWN OR W/S OR 1-${chipCount}`, hintY, 14, rgba(0.82, 0.95, 1.0, 0.86));
+  drawCentered('PRESS ENTER OR SPACE TO START', startY, 28, rgba(1, 0.9, 0.42, pulse));
+  drawCentered(`TIMING ${ANALYZED_BPM} BPM  |  GRID ${ANALYZED_FIRST_BEAT.toFixed(3)}s  |  LEN ${ANALYZED_TRACK_DURATION.toFixed(1)}s`, timingY, 14, rgba(0.82, 0.95, 1.0, 0.78));
+  drawCentered('M = BGM MUTE  |  H = SFX MUTE  |  N = RESTART MUSIC  |  ESC = QUIT', controlsY, 13, rgba(0.8, 0.94, 1.0, 0.7));
+}
+
+function drawResults() {
+  aura.draw2d.rectFill(0, 0, worldWidth, worldHeight, rgba(0, 0, 0, 0.4));
+
+  const grade = gradeForResults();
+  const acc = accuracyPercent();
+  const diff = getSelectedDifficulty();
+
+  drawCentered(failed ? 'FAILED' : 'RESULTS', Math.floor(worldHeight * 0.16), 56, failed ? rgba(1, 0.35, 0.35, 1) : rgba(0.84, 0.96, 1, 1));
+  drawCentered(`GRADE ${grade}`, Math.floor(worldHeight * 0.26), 52, rgba(1, 0.9, 0.48, 1));
+  drawCentered(`DIFFICULTY ${diff.label}`, Math.floor(worldHeight * 0.32), 18, rgba(0.82, 0.95, 1.0, 0.92));
+
+  const left = Math.floor(worldWidth * 0.28);
+  const top = Math.floor(worldHeight * 0.38);
+  const line = 36;
+  aura.draw2d.text(`SCORE      ${score}`, left, top + (line * 0), { size: 28, color: white() });
+  aura.draw2d.text(`ACCURACY   ${acc.toFixed(2)}%`, left, top + (line * 1), { size: 28, color: white() });
+  aura.draw2d.text(`MAX COMBO  x${maxCombo}`, left, top + (line * 2), { size: 28, color: white() });
+  aura.draw2d.text(`PERFECT    ${perfectCount}`, left, top + (line * 3), { size: 24, color: rgba(0.43, 1.0, 0.64, 1) });
+  aura.draw2d.text(`GOOD       ${goodCount}`, left, top + (line * 4), { size: 24, color: rgba(0.47, 0.86, 1.0, 1) });
+  aura.draw2d.text(`OK         ${okCount}`, left, top + (line * 5), { size: 24, color: rgba(1.0, 0.88, 0.42, 1) });
+  aura.draw2d.text(`MISS       ${misses}`, left, top + (line * 6), { size: 24, color: rgba(1.0, 0.36, 0.38, 1) });
+
+  drawCentered('ENTER/SPACE = RESTART   |   ESC = TITLE', Math.floor(worldHeight * 0.9), 20, rgba(1, 1, 1, 0.92));
+}
+
+function chooseHitTarget(cursorX, cursorY, options = {}) {
+  const pickRadius = Number.isFinite(options.pickRadius) ? options.pickRadius : activeHitPickRadius;
+  const timingPad = Number.isFinite(options.timingPad) ? options.timingPad : activeEarlyAssist;
+  const onlyIndex = Number.isInteger(options.onlyIndex) ? options.onlyIndex : null;
+  let best = null;
+  let bestScore = Infinity;
+
+  for (const note of notes) {
+    if (note.judged) continue;
+    if (onlyIndex !== null && note.index !== onlyIndex) continue;
+    const rawDt = currentTime - note.time;
+    const adjusted = rawDt - TIMING_OFFSET;
+    if (Math.abs(adjusted) > (activeWindowMiss + timingPad)) continue;
+
+    const pos = notePosition(note);
+    const dx = cursorX - pos.x;
+    const dy = cursorY - pos.y;
+    const dist = Math.hypot(dx, dy);
+    if (dist > pickRadius) continue;
+
+    const rank = (Math.abs(adjusted) * 1000) + (dist * 0.6);
+    if (rank < bestScore) {
+      bestScore = rank;
+      best = { note, pos, dt: rawDt };
+    }
+  }
+
+  return best;
+}
+
+function chooseKeyboardTarget(options = {}) {
+  const timingPad = Number.isFinite(options.timingPad) ? options.timingPad : activeEarlyAssist;
+  const onlyIndex = Number.isInteger(options.onlyIndex) ? options.onlyIndex : null;
+  let best = null;
+  let bestScore = Infinity;
+
+  for (const note of notes) {
+    if (note.judged) continue;
+    if (onlyIndex !== null && note.index !== onlyIndex) continue;
+    const rawDt = currentTime - note.time;
+    const adjusted = rawDt - TIMING_OFFSET;
+    if (Math.abs(adjusted) > (activeWindowMiss + timingPad)) continue;
+    const rank = Math.abs(adjusted);
+    if (rank < bestScore) {
+      bestScore = rank;
+      best = {
+        note,
+        pos: notePosition(note),
+        dt: rawDt,
+      };
+    }
+  }
+
+  return best;
+}
+
+function chooseEarlyBonkTarget(cursorX, cursorY, allowDistanceBypass) {
+  let best = null;
+  let bestRank = Infinity;
+  const minEarly = activeWindowMiss + activeEarlyAssist;
+
+  for (const note of notes) {
+    if (note.judged) continue;
+    const rawDt = currentTime - note.time;
+    const adjusted = rawDt - TIMING_OFFSET;
+
+    if (adjusted > -minEarly || adjusted < -activeBonkEarlyMax) continue;
+
+    const pos = notePosition(note);
+    const dist = Math.hypot(cursorX - pos.x, cursorY - pos.y);
+    if (!allowDistanceBypass && dist > BONK_CURSOR_RADIUS) continue;
+
+    const rank = Math.abs(adjusted) + (dist * 0.001);
+    if (rank < bestRank) {
+      bestRank = rank;
+      best = { note, pos, dt: rawDt };
+    }
+  }
+
+  return best;
+}
+
+function applyEarlyBonk(hitPos) {
+  playSfx('miss', 0.65);
+  judgementPop = {
+    text: 'BONKED EARLY',
+    age: 0,
+    x: hitPos.x,
+    y: hitPos.y,
+    color: rgba(1.0, 0.55, 0.34, 1),
+  };
+  bursts.push({
+    x: hitPos.x,
+    y: hitPos.y,
+    age: 0,
+    color: rgba(1.0, 0.55, 0.34, 1),
+    judgement: 'bonk',
+    impact: 0.64,
+  });
+  screenShake = Math.max(screenShake, 0.08);
+  beatGlow = Math.max(beatGlow, 0.06);
+  flowMeter = Math.max(0, flowMeter - 0.03);
+  health = clamp(health - 0.35, 0, HEALTH_MAX);
+}
+
+function updateInputIntent(dt) {
+  const mousePress = mouseHitPressed();
+  const mouseDown = mouseHitDown();
+  const k1KeyPress = keyboardK1Pressed();
+  const k2KeyPress = keyboardK2Pressed();
+  const k1KeyDown = keyboardK1Down();
+  const k2KeyDown = keyboardK2Down();
+
+  const k1Press = mousePress || k1KeyPress;
+  const k2Press = k2KeyPress;
+
+  hitPressedThisFrame = k1Press || k2Press;
+  mouseHoldActive = mouseDown;
+  keyHoldActive = keyboardHitDown();
+  k1Down = mouseDown || k1KeyDown;
+  k2Down = k2KeyDown;
+
+  if (k1Press) {
+    k1Pulse = 1;
+    k1Flash = 1;
+  }
+  if (k2Press) {
+    k2Pulse = 1;
+    k2Flash = 1;
+  }
+
+  if (hitPressedThisFrame) {
+    hitBufferTimer = activePressBuffer;
+  } else {
+    hitBufferTimer = Math.max(0, hitBufferTimer - dt);
+  }
+
+  if (!mouseHoldActive && !keyHoldActive && dragChainTimer <= 0 && hitBufferTimer <= 0) {
+    dragExpectedIndex = -1;
+  }
+}
+
+function processHitInput() {
+  const holdActive = mouseHoldActive || keyHoldActive;
+  const bufferedTap = hitBufferTimer > 0;
+  if (!holdActive && !bufferedTap) return;
+
+  if (holdActive && dragExpectedIndex >= 0 && dragChainTimer <= 0) {
+    dragExpectedIndex = -1;
+  }
+
+  const mouse = getMouse();
+  let target = null;
+  let viaDrag = false;
+
+  if (holdActive && dragExpectedIndex >= 0 && dragChainTimer > 0) {
+    target = chooseHitTarget(mouse.x, mouse.y, {
+      onlyIndex: dragExpectedIndex,
+      pickRadius: activeDragPickRadius,
+      timingPad: activeDragEarlyAssist,
+    });
+    if (!target && keyHoldActive) {
+      target = chooseKeyboardTarget({
+        onlyIndex: dragExpectedIndex,
+        timingPad: activeDragEarlyAssist,
+      });
+    }
+    viaDrag = Boolean(target);
+  }
+
+  if (!target && bufferedTap) {
+    target = chooseHitTarget(mouse.x, mouse.y, {
+      pickRadius: activeHitPickRadius + 8,
+      timingPad: activeEarlyAssist + 0.018,
+    });
+    if (!target) {
+      target = chooseKeyboardTarget({
+        timingPad: activeEarlyAssist + 0.02,
+      });
+    }
+  }
+
+  if (!target) {
+    if (hitPressedThisFrame) {
+      const bonk = chooseEarlyBonkTarget(mouse.x, mouse.y, keyHoldActive);
+      if (bonk) {
+        applyEarlyBonk(bonk.pos);
+        hitBufferTimer = 0;
+      }
+    }
+    return;
+  }
+
+  const judgement = evaluateTimingDelta(target.dt);
+  if (!judgement) return;
+
+  target.note.judged = true;
+  target.note.judgement = judgement;
+  applyJudgement(judgement, target.pos, { viaDrag });
+  playNoteHitsound(target.note, judgement);
+  hitBufferTimer = 0;
+
+  if (judgement === 'miss') {
+    dragExpectedIndex = -1;
+    return;
+  }
+
+  if ((target.note.dragNextIndex !== null && target.note.dragNextIndex !== undefined)
+    && (holdActive || bufferedTap)) {
+    dragExpectedIndex = target.note.dragNextIndex;
+    dragChainTimer = DRAG_CHAIN_GRACE;
+  } else {
+    dragChainTimer = 0;
+    dragExpectedIndex = -1;
+  }
+}
+
+function markExpiredMisses() {
+  for (const note of notes) {
+    if (note.judged) continue;
+    if (currentTime <= note.time + activeWindowMiss) continue;
+
+    note.judged = true;
+    note.judgement = 'miss';
+    const pos = notePosition(note);
+    applyJudgement('miss', pos);
+    if (note.index === dragExpectedIndex) {
+      dragExpectedIndex = -1;
+      dragChainTimer = 0;
+    }
+  }
+}
+
+function maybeCompleteRun() {
+  if (health <= 0 && !failed) {
+    failed = true;
+    state = 'results';
+    stopBgm();
+    return;
+  }
+
+  if (currentTime < lastNoteTime + 1.6) return;
+  for (const note of notes) {
+    if (!note.judged) return;
+  }
+  state = 'results';
+  stopBgm();
+}
+
+function updateEffects(dt) {
+  beatGlow = Math.max(0, beatGlow - (dt * 1.7));
+  comboFlash = Math.max(0, comboFlash - (dt * 2.6));
+  screenShake = Math.max(0, screenShake - (dt * 2.4));
+  flowMeter = Math.max(0, flowMeter - (dt * 0.05));
+  dragChainTimer = Math.max(0, dragChainTimer - dt);
+  k1Pulse = Math.max(0, k1Pulse - (dt * 4.8));
+  k2Pulse = Math.max(0, k2Pulse - (dt * 4.8));
+  k1Flash = Math.max(0, k1Flash - (dt * 8.2));
+  k2Flash = Math.max(0, k2Flash - (dt * 8.2));
+
+  const mouse = getMouse();
+  const last = cursorTrail.length > 0 ? cursorTrail[cursorTrail.length - 1] : null;
+  if (!last || Math.hypot(last.x - mouse.x, last.y - mouse.y) > 2.5) {
+    cursorTrail.push({ x: mouse.x, y: mouse.y, age: 0 });
+  }
+  for (const p of cursorTrail) {
+    p.age += dt;
+  }
+  cursorTrail = cursorTrail.filter((p) => p.age < CURSOR_TRAIL_LIFE);
+}
+
+aura.setup = async function () {
+  assertRuntimeCapabilities();
+  syncLayoutFromWindow();
+  await loadBackgroundAsset();
+  await loadSkinAssets();
+  await loadBgmAsset();
+  await loadSfxAssets();
+  resetRun();
+  state = 'title';
+  bgmMuted = false;
+  sfxMuted = false;
+  sfxLastPlay.clear();
+  bgmLastError = '';
+  stopBgm();
+  primePressLatch();
+};
+
+aura.update = function (dt) {
+  syncLayoutFromWindow();
+  pulseTime += dt;
+  frameDt = dt;
+  updateEffects(dt);
+  if (inputPressed(['m'])) {
+    toggleBgmMute();
+  }
+  if (inputPressed(['h'])) {
+    toggleSfxMute();
+  }
+  if (state === 'playing' && inputPressed(['n'])) {
+    startBgm(true);
+    applyBgmVolume();
+  }
+
+  if (escapePressed()) {
+    if (state !== 'title') {
+      playSfx('uiBack');
+    }
+    state = 'title';
+    resetRun();
+    stopBgm();
+    return;
+  }
+
+  if (state === 'title') {
+    handleTitleDifficultyInput();
+    if (startPressed()) {
+      beginPlayingRun();
+    }
+    return;
+  }
+
+  if (state === 'results') {
+    if (startPressed()) {
+      beginPlayingRun();
+    }
+    return;
+  }
+
+  updateInputIntent(dt);
+  currentTime += dt;
+  processHitInput();
+  markExpiredMisses();
+  maybeCompleteRun();
+};
+
+aura.draw = function () {
+  drawBackground();
+
+  if (state === 'playing' || state === 'results') {
+    drawNotes();
+  }
+
+  drawHitBursts(frameDt);
+  drawJudgementPopup(frameDt);
+  drawHud();
+  drawCursor();
+
+  if (state === 'title') {
+    drawTitle();
+  } else if (state === 'results') {
+    drawResults();
+  }
+};