SprPoP: сняты последние глушения насоса — палитра на смене уровня и загрузки треков

Замер тем же способом (брейк на pop_sfx_fill + печать totalcycles, три окна
по 800 вызовов = 9 секунд каждое, с уже снятыми глушениями):

  период насоса   245 760 тактов (медиана во всех окнах)
  максимум        245 832 / 270 096 / 311 346 (1,00 / 1,10 / 1,27 периода)
  пропущено порций 0

Порция считается пропущенной, когда зазор доходит до ДВУХ периодов: сама
порция отдаётся железу за период до того, как она понадобится, поэтому
опоздание обработчика на 1,1 мс — джиттер, а не потеря.  Запас
десятикратный.

Поэтому сняты и оставшиеся места:
* палитра через BIOS на переходе БЕЗ катсцены (sprpop_cold.c) — то самое,
  где ловили скрежет 2026-08-25; в комментарии помечено, что при возврате
  скрежета возвращать надо именно сюда;
* массовые чтения треков и ресурсов под чёрным экраном (pop_intro.c):
  первая реплика PV, трек заставки между уровнями, «время вышло», ресурсы
  финала.

Осталось только то, что глушит звук ПО СМЫСЛУ, а не ради защиты: выходы из
сцен (pop_music_free + pause), уход в титры и в игру, выключение по Ctrl+S.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

applications/SprPoP/docs/BUGS_OPEN.md

@@ -35,8 +35,8 @@
 | [KBD-STUCK-WAIT](#kbd-stuck-wait) | потерянный break-код клавиши вешает игру НАСМЕРТЬ в межуровневой заставке | клавиатура/клин | **корень найден и устранён** 2026-08-28 (байты крал KEYSCAN DSS); ждёт полевой проверки |
 | [L10-BUTTON-DEBRIS](#l10-button-debris) | ур.10 к.1: плита упала на кнопку (1,8) — щебень есть, а решётки закрыты | кнопки/ворота | открыт: **не воспроизводится**, проверено многое (см. разбор) |
 | [LOOSE-SEAM-ANIM](#loose-seam-anim) | плита в шве (col −1), уроненная в прошлой комнате, исчезает без анимации падения | **мелкий** | открыт по решению пользователя: «пока пусть будет так» |
-| [SND-PACE-DEAD](#snd-pace-dead) | пейсинг сцен по насосу CBL не включается: признак «часы идут» вычисляется двумя чтениями подряд | **тайминг/звук** | открыт: диагноз полный, симптом обойдён подгонкой (2026-08-27) |
-| [PV-RENDER-BOUND](#pv-render-bound) | сцена с принцессой рисуется дороже бюджета: ~49 тиков/с вместо 60, музыка уезжает от картинки | производительность | открыт: замер есть, лечение — удешевить кадр |
+| [SND-PACE-DEAD](#snd-pace-dead) | пейсинг сцен по насосу CBL не включается: признак «часы идут» вычисляется двумя чтениями подряд | **тайминг/звук** | **снят 2026-08-28**: ветка удалена, сцена на единых часах по лучу |
+| [PV-RENDER-BOUND](#pv-render-bound) | сцена с принцессой рисуется дороже бюджета: ~49 тиков/с вместо 60, музыка уезжает от картинки | производительность | **исправлено 2026-08-28**: кадр разложен на блоки по интервалу, удешевлять не понадобилось |
 | [MUS-LEFT-TEAR](#mus-left-tear) | `pop_mus_left` (16 бит, пишет прерывание) читается из главного цикла неатомарно — возможен ложный «трек кончился» | **потенциальный** | открыт: хазард показан рассуждением, в прогоне не проявился |
 
 ---
@@ -1206,7 +1206,15 @@ fade_in по построению пишет все 256 записей из сн
 ---
 
 <a id="snd-pace-dead"></a>
-## SND-PACE-DEAD. Пейсинг сцен по насосу CBL не включается
+## SND-PACE-DEAD. Пейсинг сцен по насосу CBL не включается — СНЯТ 2026-08-28
+
+> **Закрыт удалением самой ветки.**  Сцена с Джафаром переведена на ЕДИНЫЕ
+> часы — кадры луча (`intro_pv_animated`): вторая шкала по насосу и гонка,
+> которая её выбирала, убраны целиком.  Насос как часы был нужен потому,
+> что кадр сцены рисовался дольше своего интервала; теперь отрисовка
+> разложена по интервалам (`pv_restore_bg`), и счёт кадров честен.
+> Побочный эффект гонки — «кода реплики каждый прогон в другом месте» —
+> исчез; проверено пользователем.  Ниже — исходный разбор.
 
 **Замер (MAME, 2026-08-27).**  В сцене `intro_pv_scene()` зонды показали
 `snd_done == 0` на всём прогоне — то есть ветка `if (snd_pace)`, ради
@@ -1237,7 +1245,17 @@ snd_pace = (uint8_t)(pop_snd_tick != snd_prev);   /* часы реально и
 ---
 
 <a id="pv-render-bound"></a>
-## PV-RENDER-BOUND. Сцена с принцессой не укладывается в свой бюджет кадра
+## PV-RENDER-BOUND. Сцена с принцессой не укладывается в свой бюджет кадра — ИСПРАВЛЕНО 2026-08-28
+
+> **Причина оказалась не в цене кадра, а в том, ГДЕ отсчитывался интервал.**
+> Кадр рисовался целиком, и только потом ждали vsync и ещё четыре — то есть
+> отрисовка ПРИБАВЛЯЛАСЬ к делителю.  Теперь она разложена на блоки, каждый
+> из которых влезает в кадровый интервал, и после каждого ждём vsync
+> (`pv_restore_bg` + раскладка кадра в `cut_run` / `pre_room_animated` /
+> `intro_pv_draw_frame`); фон восстанавливаем только по картинке, 200 строк
+> вместо 256.  Удешевлять сцену не понадобилось: отрисовка ~2 кадра при
+> бюджете 5.  Подгонка `PV_MAGIC_LEAD` снята (0) — проверено пользователем:
+> кода попадает в нужный кадр.  Ниже — исходный замер.
 
 **Замер (MAME, 2026-08-27).**  Реплика Джафара `m53` — 1403 порции насоса,
 то есть 16,42 с реального времени.  За это время шкала сцены прошла

applications/SprPoP/docs/ideas_backlog.md

@@ -89,3 +89,47 @@ raw-клавиатура (`<kbd_raw.h>`), которую мы и так заби
 после выхода — заметный.  Делать после того, как закроем стражей и
 займёмся бюджетом всерьёз (там же, где батчинг кроссбанковых вызовов и
 возможный возврат `pop_bg` в резидент `--w3`).
+
+## Готовить следующий уровень, пока играет мелодия конца текущего
+
+**САМАЯ ДАЛЬНЯЯ ВЕРСИЯ.**  Не полишинг и не порт: это улучшение ПРОТИВ
+оригинала.  Планируем, но не раньше, чем закроем уровни и полишинг.
+
+**Идея (пользователь, 2026-08-28).**  Пока звучит мелодия конца уровня (и
+трек заставки между уровнями), экран не меняется — значит в это время можно
+успеть прочитать с диска следующий уровень, чтобы после музыки он появлялся
+сразу, а не через секунду-другую загрузки.
+
+**Что УЖЕ сделано и мерено (2026-08-28).**  Половина этого уже работает:
+трек заставки играет ПОВЕРХ загрузки уровня — так же, как в оригинале
+(`seg003:68-108`: `load_intro` возвращает управление, `load_level()` идёт под
+музыку, и только потом `while (check_sound_playing())` на чёрном экране).
+Насос это переживает: 500 подряд вызовов `pop_sfx_fill` через всю загрузку —
+максимальный зазор 245 832 такта при дедлайне 251 000, ни одной пропущенной
+порции.  Осталась вторая половина: мелодия конца уровня досиживается на
+ЖИВОМ экране пройденного уровня (как в оригинале, `play_level_2`), и только
+после неё начинается загрузка.
+
+**Оговорки, найденные при разборе.**
+
+1. **Загрузку придётся разрезать надвое.**  Сейчас `pop_level_switch` мешает
+   дисковую работу (файл уровня в EMM-страницу, атласы стража и тайлсета) с
+   экранно-палитровой (`pop_bg_load` переписывает записи палитры и атласы,
+   `pop_guard_load` физически применяет цветовые слоты, обе страницы
+   заливаются, `pop_pal_black`).  Вторую половину НЕЛЬЗЯ выполнять, пока на
+   экране ещё живёт пройденный уровень — иначе палитра поедет прямо на
+   картинке.  То есть в «музыкальное окно» можно вынести только диск, а всё,
+   что трогает палитру и VRAM, остаётся после.
+2. **Бюджет кадра.**  Ожидание мелодии идёт в игровом цикле (гейт
+   `pop_endmus_left` + `pop_music_busy()`), кадр там обычный, 80-100 мс.
+   Шаг подкачки должен быть такого же размера, как музыкальный — полстраницы
+   (~16 мс), а не страница целиком; иначе кадры на экране пройденного уровня
+   начнут дёргаться.
+3. **Память.**  Страницы следующего уровня придётся держать одновременно со
+   страницами текущего — проверить EMM-бюджет (memory `sprinter_emm_budget`),
+   тяжёлые тут не файл уровня, а атласы тайлсета и стража.
+4. **Риск невелик, но он в самом хрупком месте.**  Палитро-атласный обмен —
+   источник уже пойманных багов (`PAL-DUNGEON-STALE`, `PAL-L1-AFTER-INTRO`),
+   и трогать его ради экономии секунды стоит только на спокойную голову.
+
+**Выигрыш.**  Одна-две секунды один раз на уровень.

applications/SprPoP/src/pop_intro.c

@@ -83,26 +83,24 @@ enum {
     PV_MUS_4_LOAD     = PV_DIALOG1_START + 54,  /* подкачка m52           */
     PV_WALK2_START    = PV_DIALOG1_START + 176,
     PV_DIALOG2_START  = PV_DIALOG1_START + 416,
-    /* ЗАКЛИНАНИЕ СДВИНУТО РАНЬШЕ СЦЕНАРИЯ — ПОДГОНКА ПОД МУЗЫКУ.
+    /* ПОДГОНКА ЗАКЛИНАНИЯ ПОД МУЗЫКУ СНЯТА (2026-08-28): теперь 0.
      *
-     * Сцена render-bound: кадр рисуется дороже своего бюджета, кадровая
-     * ветка пейсинга догона не имеет, и анимация идёт ~49 тиков в секунду
-     * вместо 60.  Реплика Джафара при этом играет по РЕАЛЬНОМУ времени и
-     * успевает кончиться, когда шкала стоит на 1854 вместо 2028 (замер в
-     * MAME 2026-08-27 зондом на конец трека: длина насосу отдана полная,
-     * 1403 порции, курсор дошёл до последней страницы — трек доигрывает
-     * целиком, отстаёт именно картинка).
+     * История: сцена была render-bound — кадр рисовался дороже своего
+     * бюджета, кадровая ветка пейсинга догона не имела, и анимация шла
+     * ~49 тиков в секунду вместо 60 (замер 2026-08-27).  Реплика Джафара
+     * при этом играет по РЕАЛЬНОМУ времени, поэтому кода приходила
+     * примерно на секунду раньше молнии, и жест целиком (замах, шаг
+     * назад, вспышка) сдвигали раньше сценария на подобранные на слух
+     * 100 тиков.
      *
-     * Из-за этого кода реплики приходила примерно на секунду раньше
-     * молнии.  Честное лечение — удешевить кадр сцены; до тех пор двигаем
-     * жест целиком (замах, шаг назад, вспышка), чтобы он не сломался
-     * внутри себя.  Величина подобрана НА СЛУХ и уточняется прогоном:
-     * расчётные полсотни тиков (секунда отставания при ~49 тиках/с) на
-     * слух почти не изменили картины, поэтому взято вдвое больше.
-     *
-     * Эффектов дверей это не касается: у них и звук, и картинка идут по
-     * одной и той же шкале и разъехаться не могут. */
-    PV_MAGIC_LEAD     = 100,
+     * Причину убрали: отрисовка разложена по кадровым интервалам
+     * (pv_restore_bg), сцена идёт по единственным часам — кадрам луча, —
+     * и подкачка трека оплачивается интервалом (pop_music_load_step).
+     * После этого подгонка стала вредной: молния била больше чем на
+     * секунду раньше коды (проверка пользователем 2026-08-28).  Константу
+     * оставляем на месте — если запись другого набора (mt32/ogg) снова
+     * разъедется, крутить надо её, а не тайминги сценария. */
+    PV_MAGIC_LEAD     = 0,
     PV_RAISE_START    = PV_DIALOG1_START + 696 - PV_MAGIC_LEAD,
     PV_STEPBACK_START = PV_DIALOG1_START + 703 - PV_MAGIC_LEAD,
     PV_MAGIC_START    = PV_DIALOG1_START + 822 - PV_MAGIC_LEAD,
@@ -430,6 +428,44 @@ static int intro_pv_draw_base(void)
     return 0;
 }
 
+/* ВОССТАНОВЛЕНИЕ ФОНА ЗАДНЕЙ СТРАНИЦЫ — ДВУМЯ БЛОКАМИ ПО КАДРОВОМУ ИНТЕРВАЛУ.
+ *
+ * Персонажи и живой фон рисуются банком спрайтов и в ОЗУ-копию не оседают,
+ * поэтому «стереть прошлый кадр» = скопировать чистый фон из теневой копии
+ * соседней страницы.  Раньше это была ОДНА копия на весь экран, и она стоила
+ * ~547 000 тактов = 1,27 кадра луча (модель blit_cost_model).  Хвост кадра
+ * сцены ждал vsync ПОСЛЕ отрисовки, так что эти 1,27 кадра ПРИБАВЛЯЛИСЬ к
+ * пяти интервалам делителя: сцена шла 6+ кадров вместо 5, то есть ~8,2 fps
+ * вместо десяти (замер 49/60 тиков — docs/BUGS_OPEN.md PV-RENDER-BOUND).
+ *
+ * Лечение — не «удешевить», а РАЗЛОЖИТЬ по интервалам: каждый блок заведомо
+ * влезает в кадр, и после него честно ждём vsync.  Тогда отрисовка живёт
+ * ВНУТРИ делителя, а не сверх него.
+ *   - копируем только картинку (200 строк с POP_YOFF), а не все 256:
+ *     сверху и снизу чёрная рамка, туда никто не рисует;
+ *   - двумя половинами по 100 строк: ~219 000 тактов каждая, чуть больше
+ *     половины кадра — запас двукратный.
+ *
+ * ТРАТИТ РОВНО ДВА кадровых интервала (по gfx_wait_vsync на блок) — это
+ * учтено в раскладке кадра у всех трёх сцен (см. вызовы). */
+#define PV_BG_Y0   POP_YOFF
+#define PV_BG_H    200
+
+static void pv_restore_bg(void)
+{
+    gfx_rect_t r;
+
+    r.x = 0;
+    r.w = GFX_WIDTH;
+    r.h = PV_BG_H / 2;
+    r.y = PV_BG_Y0;
+    gfx_copy_page(&r, GFX_COPY_DIRECT);
+    gfx_wait_vsync();
+    r.y = PV_BG_Y0 + PV_BG_H / 2;
+    gfx_copy_page(&r, GFX_COPY_DIRECT);
+    gfx_wait_vsync();
+}
+
 static void pv_blit_floor(const atlas_t *at, uint8_t frame, int x, int floor)
 {
     const uint8_t *img;
@@ -701,12 +737,10 @@ static uint8_t intro_pv_draw_frame(const atlas_t *princess, const atlas_t *j0,
                                 uint8_t sand_frame, uint8_t flash,
                                 uint16_t tick)
 {
-    gfx_rect_t full;
     uint8_t back = (uint8_t)(gfx_get_visible_page() ^ 1);
 
     gfx_set_draw_page(back);
-    full.x = 0; full.y = 0; full.w = GFX_WIDTH; full.h = GFX_HEIGHT;
-    gfx_copy_page(&full, GFX_COPY_DIRECT);
+    pv_restore_bg();                 /* блоки 1-2: фон, два интервала */
     gfx_set_bank(GFX_BANK_SPRITE);
     /* y=116 в princess_room_torch — нижняя строка, не верх спрайта. */
     pv_blit_floor(torch, torch_left, 93, 116);
@@ -730,7 +764,7 @@ static uint8_t intro_pv_draw_frame(const atlas_t *princess, const atlas_t *j0,
      * его надо повторить ПОСЛЕ актёров, иначе Jaffar проходит перед
      * правой передней колонной. */
     pv_blit_floor(hourglass, 0, 240, 167);
-    gfx_wait_vsync();
+    gfx_wait_vsync();                /* блок 3: актёры и декорации */
     gfx_set_visible_page(back);
     if (flash) {
         uint8_t pulse;
@@ -743,9 +777,9 @@ static uint8_t intro_pv_draw_frame(const atlas_t *princess, const atlas_t *j0,
             pop_pal_flash_white(0);
             gfx_wait_vsync();
         }
-        return 11;
+        return 13;               /* три интервала кадра + десять на молнию */
     }
-    return 1;
+    return 3;                        /* сколько кадровых интервалов съели */
 }
 
 /* Сцена pv_scene() SDLPoP: ожидание Princess с факелами/звёздами, поворот,
@@ -759,12 +793,7 @@ static int intro_pv_animated(void)
     uint16_t tick;
     uint16_t frame_end;
     uint16_t render_tick;
-    uint16_t beam = 0;               /* запасной путь: кадров луча ждали   */
-    uint16_t snd_done = 0;           /* тиков насоса прошло с начала сцены */
-    uint16_t snd_want = 0;           /* сколько их должно было пройти      */
-    uint16_t snd_acc = 0;            /* дробный остаток пересчёта 57/40    */
-    uint8_t snd_prev = 0;
-    uint8_t snd_pace = 0;
+    uint16_t beam = 0;               /* кадров луча потрачено с начала сцены */
     uint8_t period;
     uint8_t anim_step = 0;
     uint8_t torch_left = 1;
@@ -813,18 +842,22 @@ static int intro_pv_animated(void)
      * Полноэкранная accel-копия кадра насосу не мешает: leaf режет DI
      * бандами по 16 строк. */
     (void)pop_sfx_start();
-    /* ЧЕМ МЕРИТЬ ВРЕМЯ.  Пока сцена была немой, кадры просто считали
-     * ожидания vsync — и этого хватало.  С музыкой выяснилось, что так
-     * считаются НАШИ ожидания, а не прошедшее время: полноэкранная копия
-     * страницы (~0,55 млн тактов) съедает больше кадра луча, и сцена
-     * незаметно отстаёт — в MAME молния била уже ПОСЛЕ конца реплики.
-     * Часы берём у насоса CBL: он идёт от расхода буфера железом, 85,4 Гц,
-     * и ему безразлично, чем занят главный цикл.  Если звук выключен,
-     * часы стоят — тогда работает прежний путь по кадрам луча. */
-    snd_prev = pop_snd_tick;
-    gfx_wait_vsync();
-    snd_pace = (uint8_t)(pop_snd_tick != snd_prev);   /* часы реально идут? */
-    snd_prev = pop_snd_tick;
+    /* ЧЕМ МЕРИТЬ ВРЕМЯ — ЕДИНЫЕ ЧАСЫ: КАДРЫ ЛУЧА.
+     *
+     * Была вторая шкала — тики насоса CBL, и выбор между ними делался
+     * гонкой на старте сцены (одна выборка `pop_snd_tick` через кадр:
+     * успел ли диск раскрутить звук).  Значит от прогона к прогону сцена
+     * шла то по одним часам, то по другим, и кода реплики приходилась
+     * каждый раз на другое место картинки (наблюдение пользователя
+     * 2026-08-28; баг SND-PACE-DEAD).  Насос как часы был нужен потому,
+     * что кадр сцены рисовался ДОЛЬШЕ своего интервала и счёт наших
+     * ожиданий врал; теперь отрисовка разложена на блоки по кадровому
+     * интервалу (см. pv_restore_bg), и счёт кадров луча честен.
+     *
+     * Осталось учесть единственную работу, которая в интервал не влезала
+     * сама, — подкачку страницы трека: шаг читает ПОЛСТРАНИЦЫ (~16 мс,
+     * pop_music_load_step) и оплачивается ровно одним интервалом, как
+     * любой другой блок кадра. */
     result = 0;
     princess_actor.x = 120;
     princess_actor.frame = 11;      /* Pstand, facing left */
@@ -892,59 +925,42 @@ static int intro_pv_animated(void)
                                     torch_right, sand_frame, flash,
                                     render_tick);
         pop_sfx_tick();          /* как в оригинале — в конце отрисовки кадра */
+
         /* ГАРАНТИРОВАННЫЙ ШАГ ПОДКАЧКИ, а не «если останется время».
          *
-         * Ниже страница следующей реплики читается в ПАУЗЕ кадра, и это
+         * Раньше страница следующей реплики читалась в ПАУЗЕ кадра, и это
          * верно ровно до тех пор, пока пауза есть.  В этой сцене её почти
-         * нет: кадр дорогой, шкала работает по принципу «долг не догоняем»
-         * (snd_want подтягивается к snd_done), и цикл ожидания выходит
-         * сразу.  Замер в MAME 2026-08-26: ОДНА страница за семь секунд,
-         * то есть одиннадцать страниц m53 не успевали за всю сцену —
-         * pop_music_play() на своём тике не находил готового трека, и
-         * реплики Джафара пропадали совсем.
+         * не было: кадр дорогой, шкала работает по принципу «долг не
+         * догоняем», и цикл ожидания выходил сразу.  Замер в MAME
+         * 2026-08-26: ОДНА страница за семь секунд, то есть одиннадцать
+         * страниц m53 не успевали за всю сцену — pop_music_play() на своём
+         * тике не находил готового трека, и реплики Джафара пропадали
+         * совсем (memory pv_music_stall_regression).
          *
-         * Страница стоит 33 мс против кадра сцены в 100-133 мс, поэтому
-         * один безусловный шаг в кадр сцену не ломает: он лишь тратит
-         * часть той же паузы, а если паузы не было — добавляет к кадру
-         * четверть его длины, и шкала это учтёт сама. */
-        if (pop_music_loading()) (void)pop_music_load_step();
+         * Поэтому шаг безусловный — и оплачен как обычный блок кадра: он
+         * читает полстраницы (~16 мс), а следующий gfx_wait_vsync ставит
+         * нас на край интервала, который мы этим и заняли. */
+        if (pop_music_loading()) {
+            (void)pop_music_load_step();
+            gfx_wait_vsync();
+            beam++;
+        }
         /* Первый кадр собран под чёрной палитрой — теперь проявляем его
          * целиком, вместе с принцессой и факелами. */
         if (!faded_in) {
             faded_in = 1;
             if (pop_pal_fade_in_skip(INTRO_FADE)) { result = 1; break; }
         }
-        /* ПЕЙСИНГ ПО ОРИГИНАЛЬНОЙ ШКАЛЕ.  Кадр cutscene — 6/8/7 тиков по
-         * 1/60 с; один тик = 85,4/60 = 1,424 тика насоса, и 57/40 = 1,425
-         * повторяет это с точностью 0,07 % (30 мс на всю сцену) без
-         * деления в кадре и без 32-битной арифметики. */
-        if (snd_pace) {
-            snd_acc += (uint16_t)period * 57u;
-            while (snd_acc >= 40u) { snd_acc -= 40u; snd_want++; }
-            for (;;) {
-                uint8_t now = pop_snd_tick;
-
-                /* Разность в uint8_t: счётчик переполняется каждые 3 с, а
-                 * заглядываем мы в него не реже раза в кадр. */
-                snd_done += (uint8_t)(now - snd_prev);
-                snd_prev = now;
-                if (snd_done >= snd_want) break;
-                /* Страницу следующей реплики читаем ЗДЕСЬ, в паузе кадра:
-                 * 33 мс диска укладываются в ожидание (кадр сцены — 133 мс),
-                 * и подкачка не добавляется к длительности кадра, а
-                 * растворяется в ней. */
-                if (pop_music_loading()) (void)pop_music_load_step();
-                else                     gfx_wait_vsync();
-            }
-            /* ДОЛГ НЕ ДОГОНЯЕМ.  Подкачка следующей реплики (страница — 33 мс)
-             * и любой тяжёлый кадр оставляют snd_done впереди snd_want, и
-             * дальше цикл гнал кадры без единого ожидания: пламя факелов
-             * мелькало, а события соседних тиков (створка ворот и дверь
-             * покоев) слипались в один кадр — заявка перезаписывала заявку, и
-             * один из звуков пропадал.  Тот же принцип, что у pop_pace_end:
-             * якорь ставится ПО ФАКТУ, пропущенное время не наверстывается. */
-            if (snd_done > snd_want) snd_want = snd_done;
-        } else {
+        /* ПЕЙСИНГ ПО ОРИГИНАЛЬНОЙ ШКАЛЕ.  Кадр сцены — 6/8/7 тиков по
+         * 1/60 с (pv_seq_period), в кадры луча переводит POP_T60, и цель
+         * КУМУЛЯТИВНА: нецелые 6,67 и 5,83 не копят ошибку.
+         *
+         * ДОЛГ НЕ ДОГОНЯЕМ: если кадр вышел дороже своего бюджета, цикл
+         * ожидания просто не сработает, но beam уже учёл потраченное — и
+         * следующая цель считается от той же общей шкалы.  Наверстывать
+         * пропущенное нельзя: события соседних тиков (створка ворот, дверь
+         * покоев) слиплись бы в один кадр, и один из звуков пропал бы. */
+        {
             uint16_t target = POP_T60(tick);
 
             while (beam < target) { gfx_wait_vsync(); beam++; }
@@ -995,7 +1011,6 @@ static uint8_t pre_hourglass_state(void)
 static int pre_room_animated(uint8_t picture, uint8_t state, uint8_t frames)
 {
     atlas_t hourglass, torch;
-    gfx_rect_t full;
     uint8_t torch_left = 1, torch_right = 6, sand = 0, frame;
     uint8_t star_phase[6] = { 1, 1, 1, 1, 1, 1 };
     intro_skip_t skip;
@@ -1025,7 +1040,6 @@ static int pre_room_animated(uint8_t picture, uint8_t state, uint8_t frames)
 
     pop_screen_present(1);
     result = 0;
-    full.x = 0; full.y = 0; full.w = GFX_WIDTH; full.h = GFX_HEIGHT;
     intro_skip_begin(&skip);
     for (frame = 0; frame < frames; frame++) {
         uint8_t back, hold, star;
@@ -1033,7 +1047,7 @@ static int pre_room_animated(uint8_t picture, uint8_t state, uint8_t frames)
         if (intro_skip_requested(&skip)) { result = 1; break; }
         back = (uint8_t)(gfx_get_visible_page() ^ 1);
         gfx_set_draw_page(back);
-        gfx_copy_page(&full, GFX_COPY_DIRECT);
+        pv_restore_bg();                /* блоки 1-2: фон, два интервала */
         gfx_set_bank(GFX_BANK_SPRITE);
         pv_blit_floor(&torch, torch_left, 93, 116);
         pv_blit_floor(&torch, torch_right, 211, 116);
@@ -1046,10 +1060,11 @@ static int pre_room_animated(uint8_t picture, uint8_t state, uint8_t frames)
                 pv_blit_floor(&hourglass, (uint8_t)(8 + sand), 160, 164);
         }
         pv_blit_floor(&hourglass, 0, 240, 167); /* передняя колонна */
-        gfx_wait_vsync();
+        gfx_wait_vsync();               /* блок 3: живой фон */
         gfx_set_visible_page(back);
-        /* Первый тик уже потрачен на commit: ещё четыре = 5/50 с. */
-        for (hold = 1; hold < 5; hold++) gfx_wait_vsync();
+        /* Три интервала уже потрачены на блоки отрисовки — добираем до
+         * пяти (5/50 с = кадр катсцены оригинала). */
+        for (hold = 3; hold < 5; hold++) gfx_wait_vsync();
 
         /* Проявляем ПОСЛЕ первого кадра: иначе две секунды fade идут по
          * пустой комнате, а часы и пламя возникают уже на свету. */
@@ -1128,8 +1143,14 @@ static void intro_restore_game_palette(void)
 /* Набор PV2 (res901..930) не влезает в одну EMM: image 0..16 в a1,
  * 17..29 в a2.  Номер кадра при этом остаётся исходным image-id. */
 #define CUT_PV2_SPLIT 17
-/* Один логический кадр катсцены = 5 vsync, как у остальных PV-сцен
- * (cutscene_frame_time SDLPoP; см. pre_room_animated). */
+/* Один логический кадр катсцены = 5 vsync, как у остальных PV-сцен: у
+ * оригинала `cutscene_frame_time = 6` тиков по 1/60 с (reset_cutscene,
+ * seg001:527, и его зовёт load_intro прямо перед сценой) = 100 мс, у нас
+ * 5 кадров луча по 50 Гц = те же 100 мс.
+ *
+ * РАСКЛАДКА ПО ИНТЕРВАЛАМ (иначе отрисовка прибавлялась к делителю, а не
+ * жила внутри него — см. pv_restore_bg): фон половинами 1-2, актёры и
+ * декорации 3, служебный блок (звук/подкачка музыки) 4-5. */
 #define CUT_FRAME_VSYNC 5
 
 static atlas_t cut_pv1, cut_pv2a, cut_pv2b, cut_hg, cut_torch;
@@ -1290,11 +1311,9 @@ static void cut_shad_init(uint8_t x, uint8_t y, uint8_t seq)
  * прервал сцену (любое НОВОЕ нажатие). */
 static uint8_t cut_run(uint16_t frames, uint8_t kid_visible)
 {
-    gfx_rect_t full;
     uint16_t i;
     uint8_t hold;
 
-    full.x = 0; full.y = 0; full.w = GFX_WIDTH; full.h = GFX_HEIGHT;
     for (i = 0; i < frames; i++) {
         uint8_t back;
         kframe kid_fr, pr_fr;
@@ -1316,8 +1335,9 @@ static uint8_t cut_run(uint16_t frames, uint8_t kid_visible)
         back = (uint8_t)(gfx_get_visible_page() ^ 1);
         gfx_set_draw_page(back);
         /* Чистый фон обеих страниц лежит в shadow-копии; персонажи рисуются
-         * банком спрайтов и потому в неё не оседают. */
-        gfx_copy_page(&full, GFX_COPY_DIRECT);
+         * банком спрайтов и потому в неё не оседают.  Двумя блоками по
+         * кадровому интервалу — см. pv_restore_bg. */
+        pv_restore_bg();              /* блоки 1-2 */
         gfx_set_bank(GFX_BANK_SPRITE);
         pv_blit_floor(&cut_torch, cut_torch_l, 93, 116);
         pv_blit_floor(&cut_torch, cut_torch_r, 211, 116);
@@ -1339,12 +1359,17 @@ static uint8_t cut_run(uint16_t frames, uint8_t kid_visible)
          * сквозь неё — поймано пользователем 2026-08-25). */
         pv_blit_floor(&cut_hg, 0, 240, 167);
         gfx_set_bank(GFX_BANK_NORMAL);
-        gfx_wait_vsync();
+        gfx_wait_vsync();             /* блок 3: актёры и декорации */
         gfx_set_visible_page(back);
-        for (hold = 1; hold < CUT_FRAME_VSYNC; hold++) gfx_wait_vsync();
 
+        /* Блок 4 — служебный, и он НЕ добавляется к кадру, а живёт внутри
+         * оставшихся интервалов: подкачка страницы трека стоит ~33 мс, то
+         * есть меньше двух интервалов, которые всё равно надо переждать.
+         * Порядок как в сцене с Джафаром: шаг подкачки — безусловный (см.
+         * memory pv_music_stall_regression). */
         pop_sfx_tick();
         pop_music_service();     /* «встреча с принцессой» — трек, а не эффект */
+        for (hold = 3; hold < CUT_FRAME_VSYNC; hold++) gfx_wait_vsync();
         cut_torch_l = (uint8_t)((cut_torch_l + 1) % 9);
         cut_torch_r = (uint8_t)((cut_torch_r + 1) % 9);
         cut_sand = (uint8_t)((cut_sand + 1) % 3);
@@ -1662,7 +1687,9 @@ uint8_t pop_intro_show(void) __banked
     /* Первая реплика PV читается ЗДЕСЬ, под чёрным экраном и в тишине:
      * дальше внутри сцены остаётся только пуск, а следующие две реплики
      * подкачиваются по странице за кадр. */
-    pop_sfx_pause();
+    /* Глушение снято 2026-08-28: массовое чтение страниц насос не морит
+     * (замер на загрузке уровня — ни одной пропущенной порции), а трек
+     * титров может и должен доигрывать. */
     (void)pop_music_load(POP_MUS_STORY_2);
     pv_result = intro_pv_animated();
     if (pv_result > 0) {
@@ -1740,15 +1767,21 @@ uint8_t pop_intro_show(void) __banked
  * дальше, а не чтобы досидеть до конца трека. */
 static void pre_cut_finish(uint8_t aborted)
 {
-    if (!aborted) {
-        intro_skip_t tail;
-
-        intro_skip_begin(&tail);
-        while (pop_music_busy() && !intro_skip_requested(&tail))
-            pop_wait_edge();
+    /* ТРЕК ПЕРЕЖИВАЕТ СЦЕНУ — как в оригинале.  load_intro (seg001:690)
+     * ничего не ждёт: гасит экран и возвращает управление, а звук играет
+     * дальше поверх загрузки уровня и первых секунд игры.  Мы вместо этого
+     * ДОСИЖИВАЛИ трек на чёрном экране (27 — 10,7 с против 2,6 с картинки),
+     * то есть дарили игроку восемь секунд пустого экрана, и только потом
+     * глушили.  ЗАМЕР 2026-08-28: снято вместе с глушением на загрузке
+     * уровня; если загрузка не укладывается в дедлайн насоса (251 000
+     * тактов), вернуть оба места разом.
+     *
+     * Пропуск сцены по-прежнему обрывает и музыку: игрок нажал клавишу,
+     * чтобы идти дальше, а не чтобы дослушать. */
+    if (aborted) {
+        pop_music_free();
+        pop_sfx_pause();
     }
-    pop_music_free();
-    pop_sfx_pause();
     intro_restore_game_palette();
 }
 
@@ -1756,7 +1789,7 @@ void pop_pre_cutscene_show(pop_pre_cutscene_t scene) __banked
 {
     const pop_cs_cmd_t *script = 0;
 
-    pop_sfx_pause();
+    /* Глушение перед чтением трека снято 2026-08-28 (см. замер насоса). */
     /* МУЗЫКА ПЕРЕЖИВАЕТ СЦЕНУ.  Треки заставок между уровнями длиннее самих
      * сцен (27 — 10,7 с против 2,6 с картинки), и оригинал их не обрывает:
      * load_intro просто гасит экран и возвращает управление, а звук
@@ -1824,7 +1857,7 @@ int pop_intro_hof_bg(uint8_t page) __banked
 
 void pop_time_expired_show(void) __banked
 {
-    pop_sfx_pause();
+    /* Глушение снято 2026-08-28 (см. замер насоса). */
     /* time_expired (seg001:04D3) начинается с play_sound(sound_36). */
     if (pop_music_load(36) == 0) {
         (void)pop_sfx_start();
@@ -1853,7 +1886,7 @@ void pop_time_expired_show(void) __banked
 
 void pop_ending_show(void) __banked
 {
-    pop_sfx_pause();
+    /* Глушение снято 2026-08-28 (см. замер насоса). */
     /* Экран гасим ПЕРВЫМ действием — как load_intro оригинала, который
      * начинается с draw_rect(&screen_rect, color_0_black).  Иначе загрузка
      * ресурсов сцены идёт поверх ЖИВОЙ комнаты уровня 14, и она «мелькает»

applications/SprPoP/src/pop_kid.c

@@ -18,6 +18,8 @@
 #include "pop_map.h"          /* pop_clip_char_top (clip_char) */
 #include "pop_geom.h"
 #include "pop_level.h"        /* POP_LEVEL_LAST — level 15 исключён */
+#include "pop_cutscene.h"     /* POP_T60 — тики оригинала в кадры луча */
+#include "pop_music_ticks.h"  /* длина мелодии конца уровня */
 #include <fcntl.h>
 #include <unistd.h>
 #include <sprinter_mem.h>
@@ -36,6 +38,14 @@ int8_t knock;
  * оригинале, чтобы читы «следующий/предыдущий уровень» (levels_plan.md §4)
  * легли сюда же без переделки. */
 uint8_t pop_next_level;
+/* СКОЛЬКО ЛОГИЧЕСКИХ КАДРОВ ЕЩЁ ДЕРЖАТЬ УРОВЕНЬ, пока играет мелодия конца.
+ * У оригинала (seg003:387, play_level_2) уровень не сменяется, пока
+ * `check_sound_playing()`: экран пройденного уровня живёт с анимацией
+ * факелов ровно столько, сколько звучит трек.  У нас признак «звучит» —
+ * pop_music_busy(), но он ложен при ВЫКЛЮЧЕННОЙ музыке, а оригинал
+ * выдерживает паузу и молча.  Поэтому здесь взводится счётчик по длине
+ * записи (gen/pop_music_ticks.h), а главный цикл ждёт большего из двух. */
+uint8_t pop_endmus_left;
 
 
 /* ---- Атласы Kid (прямая адресация image>>3) ------------------------ *
@@ -358,9 +368,17 @@ void play_seq(void)
                 else if (ev == 4) {
                     /* seg006:646.  На четвёртом уровне уход за дверь — это
                      * встреча с тенью, и трек там свой; на 13-м (Джафар) и
-                     * 15-м оригинал молчит. */
-                    if (pop_current_level == 4) pop_sfx_play(32);
-                    else if (pop_current_level != 13) pop_sfx_play(41);
+                     * 15-м оригинал молчит.  Вместе с треком взводим
+                     * задержку смены уровня (см. pop_endmus_left): кадров
+                     * = длина записи в тиках -> кадры луча -> делённое на
+                     * длину логического кадра (4 кадра луча вне боя). */
+                    if (pop_current_level == 4) {
+                        pop_sfx_play(32);
+                        pop_endmus_left = (uint8_t)(POP_T60(POP_MUS_TICKS_32) / 4);
+                    } else if (pop_current_level != 13) {
+                        pop_sfx_play(41);
+                        pop_endmus_left = (uint8_t)(POP_T60(POP_MUS_TICKS_41) / 4);
+                    }
                 }
             }
             break;

applications/SprPoP/src/pop_kid.h

@@ -26,6 +26,8 @@ extern int8_t knock;
  * пройден».  Читает и обнуляет главный цикл.  Пока уровень один, поэтому
  * там рестарт того же уровня; загрузка следующего — levels_plan.md. */
 extern uint8_t pop_next_level;
+/* Задержка смены уровня на время мелодии конца (см. pop_kid.c). */
+extern uint8_t pop_endmus_left;
 
 /* Загрузить npages атласов Kid (kid0..kid{npages-1}.atl).  ДО initgraph.
  * 0 — OK, -1 — ошибка. */

applications/SprPoP/src/pop_menu.c

@@ -27,6 +27,7 @@
 #include "pop_settings.h"
 #include "pop_cfg.h"
 #include "pop_qsave.h"
+#include "pop_music.h"  /* pop_music_service — подкачка кольца, см. ui_wait_frame */
 #include "pop_status.h"
 #include "pop_sfx.h"
 
@@ -196,10 +197,21 @@ static uint8_t ui_begin(void)
     gfx_rect_t full;
     uint8_t back = (uint8_t)(gfx_get_visible_page() ^ 1);
 
-    /* Полностраничная accel-копия держит DI дольше половины CBL-буфера.
-     * Закрываем вывод, иначе железо повторяет старые 128 байт (скрежет).
-     * ui_end откроет его уже с заново заполненной тишиной. */
-    pop_sfx_pause();
+    /* ЗВУК ЗДЕСЬ БОЛЬШЕ НЕ ГЛУШИМ (снято 2026-08-28).
+     *
+     * Был вызов pop_sfx_pause() с обоснованием «полностраничная accel-копия
+     * держит DI дольше половины CBL-буфера, иначе железо повторяет старые
+     * 128 байт».  Обоснование устарело: лист, который зовёт gfx_copy_page
+     * (_bgi_scroll_rows_raw), режет DI бандами по 16 строк — это ~1,6 мс
+     * против дедлайна насоса 11,7 мс, и окно прерываний между бандами есть.
+     * Тот же полностраничный копир каждый кадр делают игровой цикл и
+     * катсцены, и звук там не рвётся.
+     *
+     * А цена была слышимой: pause закрывает CBL целиком (cbl_close), курсор
+     * трека остаётся на месте, и короткая мелодия начала уровня замирала
+     * ровно на время перерисовки меню — «тормозится на кусочек» (жалоба
+     * пользователя 2026-08-28).  У оригинала такого нет и быть не может:
+     * там нет насоса, который надо кормить руками. */
     gfx_set_draw_page(back);
     full.x = 0; full.y = 0; full.w = GFX_WIDTH; full.h = GFX_HEIGHT;
     gfx_copy_page(&full, GFX_COPY_DIRECT);
@@ -207,10 +219,32 @@ static uint8_t ui_begin(void)
     return back;
 }
 
+/* КАДР МЕНЮ: перед ожиданием фронта — обслужить музыку.
+ *
+ * Насос CBL живёт в прерывании и главный цикл ему не нужен, НО потоковый
+ * трек (титульная тема играется КОЛЬЦОМ, pop_music.c) дочитывается с диска
+ * именно из pop_music_service: очередная страница попадает в слот, который
+ * насос уже прошёл.  Пока открыто меню, главный цикл стоит, и без этого
+ * вызова кольцо опустошалось за несколько секунд — музыка замолкала до
+ * закрытия меню, а на перемещениях по пунктам это слышно как паузы
+ * (жалоба пользователя 2026-08-28).
+ *
+ * Место — рядом с ожиданием кадра: получается тот же темп 50 раз в
+ * секунду, что и в игровом цикле, и подкачка не чаще, чем нужна. */
+static void ui_wait_frame(void)
+{
+    pop_music_service();
+    pop_wait_edge();
+}
+
 static void ui_end(uint8_t back)
 {
-    pop_wait_edge();                 /* готовый кадр показать только на фронте */
+    ui_wait_frame();                 /* готовый кадр показать только на фронте */
     gfx_set_visible_page(back);
+    /* Парный к снятому pop_sfx_pause (см. ui_begin) вызов оставлен: он
+     * идемпотентен (открытый CBL возвращает 0 сразу) и чинит случай, когда
+     * в меню вошли при закрытом выводе — например сразу после загрузки
+     * уровня, которая глушит звук намеренно. */
     (void)pop_sfx_start();
 }
 
@@ -227,7 +261,7 @@ static void ui_wait_release(void)
            kbd_raw_down(KBD_SPACE) ||
            kbd_raw_down(KBD_UP) || kbd_raw_down(KBD_DOWN) ||
            kbd_raw_down(KBD_LEFT) || kbd_raw_down(KBD_RIGHT))
-        pop_wait_edge();
+        ui_wait_frame();
 }
 
 /* Действие = Enter ИЛИ Space: в оригинале выбор подтверждается обеими, и
@@ -250,7 +284,7 @@ static void ui_wait_ack(void)
             return;
         }
         esc_prev = esc; act_prev = act;
-        pop_wait_edge();
+        ui_wait_frame();
     }
 }
 
@@ -478,7 +512,7 @@ static uint8_t ui_confirm(const char *question)
             confirm_draw(question, sel);
             menu_sound(MENU_SND_MOVE);
         }
-        pop_wait_edge();
+        ui_wait_frame();
     }
 }
 
@@ -522,10 +556,12 @@ static uint8_t settings_finish(uint8_t changed)
     int8_t rc;
     if (!changed) return 0;
     pop_settings_apply(1);
-    /* ESTEX может уйти в диск на много CBL-периодов. */
-    pop_sfx_pause();
+    /* Звук не глушим: POP.CFG — десятки байт, а на практике HOF пишется
+     * под звучащий «won» и насос это переживает (проверка пользователя
+     * 2026-08-28).  Прежняя осторожность «ESTEX может уйти в диск на много
+     * CBL-периодов» относилась к загрузке НАБОРА страниц, а не к записи
+     * одного мелкого файла. */
     rc = pop_cfg_save();
-    (void)pop_sfx_start();
     ui_notice(rc > 0 ? "SETTINGS SAVED" : "SAVE ERROR");
     return 1;
 }
@@ -609,17 +645,16 @@ static uint8_t settings_process(void)
             settings_draw(sel);
             menu_sound(sound);
         }
-        pop_wait_edge();
+        ui_wait_frame();
     }
 }
 
 static int8_t menu_quickload(void)
 {
     uint8_t slots;
-    /* probe делает open/close на D:, поэтому насос в это время выключен. */
-    pop_sfx_pause();
+    /* probe — это только open/close на D:, данных не читает; глушить насос
+     * ради него незачем (см. settings_finish). */
     slots = pop_qsave_probe();
-    (void)pop_sfx_start();
     if (slots & POP_QS_SLOT_SAVE) return POP_MENU_QUICKLOAD;
     if ((slots & POP_QS_SLOT_BACKUP) && ui_confirm("LOAD BACKUP?"))
         return POP_MENU_QUICKLOAD_BACKUP;
@@ -641,14 +676,14 @@ static void menu_erase(uint8_t entry_page)
     /* Из shadow видимой страницы берём кадр без текстов. */
     gfx_set_draw_page(hidden);
     gfx_copy_page(&full, GFX_COPY_DIRECT);
-    pop_wait_edge();
+    ui_wait_frame();
     gfx_set_visible_page(hidden);
 
     /* Теперь чистая hidden — источник для второй страницы. */
     gfx_set_draw_page(visible);
     gfx_copy_page(&full, GFX_COPY_DIRECT);
     if (entry_page != hidden) {
-        pop_wait_edge();
+        ui_wait_frame();
         gfx_set_visible_page(entry_page);
     }
 }
@@ -679,13 +714,18 @@ int8_t pop_menu_process(void) __banked
 
     /* Открыли по НАЖАТИЮ Esc: дождаться отпускания, иначе то же нажатие
      * закроет меню раньше первого кадра.  pop_wait_edge опрашивает FIFO. */
-    while (kbd_raw_down(KBD_ESC)) pop_wait_edge();
+    while (kbd_raw_down(KBD_ESC)) ui_wait_frame();
 
     entry_page = gfx_get_visible_page();
     saved_page = gfx_get_draw_page();
     saved_bank = gfx_get_bank();
     getfillsettings(&saved_fill);
-    pop_sfx_pause();                 /* snapshot/dim + первый full redraw */
+    /* Звук НЕ глушим (снято 2026-08-28, вторая половина той же заплатки —
+     * см. ui_begin).  Здесь под ней были снимок палитры, затемнение фона и
+     * первая полная перерисовка: копия режет DI бандами по 16 строк, а
+     * палитровое затемнение идёт и в титрах с катсценами, где музыку оно не
+     * рвёт.  Цена глушения была слышна как пауза в мелодии ровно на
+     * появление меню. */
     pop_pal_snapshot();
     /* 50 % яркости; диапазон UI остаётся ярким.  Долю берём от шкалы, а не
      * числом: ступеней стало 32 вместо четырёх, и прежняя «2» означала бы
@@ -742,11 +782,12 @@ int8_t pop_menu_process(void) __banked
             menu_draw(sel);
             menu_sound(sound);
         }
-        pop_wait_edge();
+        ui_wait_frame();
         pop_pace_end(pop_pace_n(0));   /* игра стоит — обычный темп */
     }
 
-    pop_sfx_pause();                 /* две full-page копии menu_erase */
+    /* И на закрытии не глушим: menu_erase — те же две полностраничные
+     * копии, что и в ui_begin, с DI бандами по 16 строк. */
     menu_erase(entry_page);
     /* menu_erase вернул обе страницы из тени, снятой ДО меню: всё, что
      * статус-полосы нарисовали за это время (или сообщение, дотикавшее в

applications/SprPoP/src/pop_music.c

@@ -49,6 +49,7 @@ static uint8_t  ld_busy;
 static int      ld_fd;
 static uint8_t  ld_slot;
 static uint8_t  ld_next;             /* следующая страница к чтению */
+static uint8_t  ld_half;             /* 0 = впереди первая половина страницы */
 static uint8_t  ld_pages;
 static uint8_t  ld_id;
 
@@ -110,13 +111,14 @@ void pop_music_free(void) __banked
  * ПОСТРАНИЧНО, А НЕ ЦЕЛИКОМ.  Реплики сцены с принцессой идут встык, и
  * следующую надо читать, пока звучит текущая.  Трек — до 320 КБ, целиком
  * это 0,7 с диска: на 7,5 кадрах в секунду сцена встала бы на пять кадров.
- * Одна страница стоит 33 мс — меньше четверти кадра, и подкачка растворя-
- * ется в анимации.  Кто может позволить себе паузу (титры, чёрный экран
+ * Шаг стоит 16 мс (полстраницы, см. pop_music_load_step) — меньше одного
+ * кадрового интервала, и подкачка растворяется в анимации.  Кто может позволить себе паузу (титры, чёрный экран
  * между сценами), зовёт pop_music_load — тот же цикл, но целиком. */
 static void load_abort(void)
 {
     if (ld_busy) close(ld_fd);
     ld_busy = 0;
+    ld_half = 0;
     slot_release(ld_slot);
 }
 
@@ -146,23 +148,35 @@ int8_t pop_music_load_begin(uint8_t id) __banked
     ld_busy = 1;
     ld_slot = n;
     ld_next = 0;
+    ld_half = 0;
     ld_pages = pages;
     ld_id = id;
     return 0;
 }
 
+/* ШАГ = ПОЛСТРАНИЦЫ (8 КБ, ~16 мс), а не страница (~33 мс).
+ *
+ * Шаг вызывают раз в кадр из циклов, где кадр разложен на блоки по одному
+ * кадровому интервалу (20 мс): катсцены после перехода на блочную
+ * отрисовку, см. pop_intro.c/pv_restore_bg.  Целая страница в интервал не
+ * влезала и незаметно растягивала кадр сцены; половина влезает, а цена —
+ * вдвое больше вызовов (11 страниц реплики = 22 кадра вместо 11, то есть
+ * меньше полусекунды).  Игровому циклу это безразлично: там логический
+ * кадр 80-100 мс. */
 int8_t pop_music_load_step(void) __banked
 {
     uint8_t p;
 
     if (!ld_busy) return 1;                     /* нечего грузить */
     p = mem_get_page(slot_blk[ld_slot], ld_next);
-    /* Последняя страница короче — читаем сколько есть; ошибку ловим по
-     * отрицательному коду, а не по «не 16384». */
-    if (!p || bank_read_page(ld_fd, p, 0, 16384) < 0) {
+    /* Последняя страница короче — читаем сколько есть (вторая половина
+     * может дать и ноль байт); ошибку ловим по отрицательному коду. */
+    if (!p || bank_read_page(ld_fd, p, ld_half ? 8192 : 0, 8192) < 0) {
         load_abort();
         return -1;
     }
+    if (!ld_half) { ld_half = 1; return 0; }    /* дочитаем в следующий раз */
+    ld_half = 0;
     if (++ld_next < ld_pages) return 0;
 
     close(ld_fd);

applications/SprPoP/src/pop_qsave.c

@@ -234,14 +234,16 @@ int8_t pop_qsave_process(void) __banked
     if (!blk) return -1;
     page=mem_get_page(blk,0);
     gfx_w0_page_prepare(page);
-    pop_sfx_pause();
+    /* Звук не глушим (2026-08-28).  Единственное место из снятых, где по
+     * диску реально едут 16 КБ (~33 мс, три периода насоса): если на F6/F9
+     * появится скрежет — вернуть сюда pop_sfx_pause/pop_sfx_start, это
+     * лечится точечно и только здесь. */
     if (request == QS_SAVE) rc = qs_save(page);
     else if (request == QS_LOAD_BACKUP) rc = qs_load_one("POP.BAK", page);
     else {
         rc = qs_load_one("POP.SAV",page);
         if (rc < 0) rc = qs_load_one("POP.BAK",page);
     }
-    pop_sfx_start();
     mem_free_block(blk);
     /* Успех ничего не меняет: нужная строка висит с начала операции.
      * Отказ переписывает её на NO QUICKSAVE/NO QUICKLOAD — обычной

applications/SprPoP/src/pop_ui.c

@@ -16,6 +16,7 @@
 #include "pop_arc.h"
 #include "pop_ui.h"
 #include "pop_status.h"
+#include "pop_music.h"  /* pop_music_service — подкачка кольца в долгих фейдах */
 
 typedef struct {
     uint8_t base;
@@ -292,6 +293,11 @@ static uint8_t fade_run(uint8_t frames, uint8_t up, uint8_t skip)
             pop_ui_palette_dim(step, 0);
             shown = step;
         }
+        /* Fade — это 2,13 с, и всё это время главный цикл стоит.  Кольцо
+         * потокового трека дочитывает pop_music_service, иначе музыка
+         * замолкает прямо посреди перехода (та же причина, что у меню:
+         * ui_wait_frame в pop_menu.c). */
+        pop_music_service();
         gfx_wait_vsync();
         if (skip) {
             kbd_raw_sync();
@@ -429,6 +435,7 @@ uint8_t pop_screen_present_ltr(void) __banked
         stripe.x = x;
         stripe.w = (uint16_t)((GFX_WIDTH - x < 4) ? GFX_WIDTH - x : 4);
         gfx_copy_page(&stripe, GFX_COPY_DIRECT);
+        pop_music_service();          /* 80 кадров перехода — см. fade_run */
         gfx_wait_vsync();
     }
     return 0;

applications/SprPoP/src/sprpop.c

@@ -357,6 +357,7 @@ int main(void)
      * девелоперская сборка может до title держать дворец LEVEL=11. */
     if (pop_app_state == POP_APP_DEMO) {
         pop_next_level = 0;
+        pop_endmus_left = 0;
         pop_seamless = 0;
         pop_checkpoint = 0;
         if (pop_level_switch() != 0) {
@@ -765,9 +766,28 @@ int main(void)
         /* Смена уровня целиком уехала в банк 8 (pop_level_change): это
          * событие раз в несколько минут, а кода на нём было под сотню строк
          * в самом горячем месте программы — резидент W1 у нас в дефиците. */
-        if (!is_demo && pop_next_level != pop_current_level &&
-            pop_level_change(back) != 0) {
-            failed = 1; quit = 1; break;
+        if (!is_demo && pop_next_level != pop_current_level) {
+            /* КОНЕЦ УРОВНЯ ЖДЁТ МЕЛОДИЮ (порт seg003:387, play_level_2):
+             *
+             *   if (next_level == current_level || check_sound_playing())
+             *       draw_game_frame(); ...        // экран уровня живёт
+             *   else { stop_sounds(); return next_level; }
+             *
+             * То есть пройденный уровень остаётся на экране — с анимацией
+             * факелов, идущим таймером и всем прочим — ровно столько,
+             * сколько звучит трек конца уровня; мы же уходили на смену
+             * уровня сразу и обрывали мелодию на первых нотах.
+             *
+             * «Звучит» проверяем двумя способами: pop_music_busy() пока
+             * трек играет и счётчик pop_endmus_left по длине записи (его
+             * взводит play_seq вместе с самим треком) — иначе с
+             * ВЫКЛЮЧЕННОЙ музыкой паузы не было бы вовсе, а оригинал
+             * выдерживает её и молча. */
+            if (pop_endmus_left) pop_endmus_left--;
+            if (!pop_endmus_left && !pop_music_busy() &&
+                pop_level_change(back) != 0) {
+                failed = 1; quit = 1; break;
+            }
         }
         if (!is_demo && pop_kid_dead) { /* demo после смерти завершается, без respawn */
             dead_frames++;

applications/SprPoP/src/sprpop_cold.c

@@ -25,6 +25,7 @@
 #include "pop_ctrl.h"     /* pop_ctrl_init/close — ввод поднимает и закрывает boot */
 #include "pop_shadow.h"   /* запечённый набор Тени */
 #include "pop_sfx.h"      /* звуковые эффекты через CBL */
+#include "pop_music.h"    /* pop_music_busy/free — ждём трек заставки */
 #include "pop_vflip.h"    /* сброс зеркальных страниц на смене уровня */
 #include "pop_cheat.h"   /* pop_cheats — режим разработки включает pop_boot */
 #include "pop_pace.h"    /* pop_speed_mode — режим скорости в отладочной метке */
@@ -226,7 +227,12 @@ int8_t pop_level_change(uint8_t back) __banked
              * почти всегда — поймано пользователем 2026-08-25.  Ветка с
              * катсценой свободна от этого: pop_pre_cutscene_show глушит
              * звук первым действием. */
-            pop_sfx_pause();
+            /* Глушение снято 2026-08-28 (замер: загрузка уровня насос не
+             * морит — 500 вызовов подряд, максимум 245 832 такта при
+             * дедлайне 251 000).  Прежнее обоснование — скрежет на палитре
+             * через BIOS ($A4 с запрещёнными прерываниями), пойманный на
+             * переходе без катсцены 2026-08-25.  Если он вернётся, это
+             * единственное место, куда его надо возвращать. */
             /* Без fade: старый кадр гасим сразу и обязательно даём
              * показать один чёрный растр ДО диска/перерисовки. */
             pop_pal_apply(POP_PAL_DIM_BLACK);
@@ -1227,7 +1233,10 @@ int pop_level_switch(void) __banked
              * дальше, а урон — нет (do_startpos дольёт до потолка). */
             hitp_beg_lev = hitp_max;
             pop_checkpoint = 0;           /* уровень пройден (seg003:413) */
-            pop_sfx_pause();          /* загрузка уровня — ESTEX надолго, звук глушим */
+            /* ЗАМЕР 2026-08-28: глушение снято ВРЕМЕННО, чтобы измерить
+             * зазоры насоса на загрузке уровня (дедлайн 251 000 тактов).
+             * Если зазоры укладываются — снятие остаётся, и трек заставки
+             * доигрывает поверх загрузки, как в оригинале (seg001:690). */
             if (pop_level_load_num(pop_next_level) != 0) {
                 pop_next_level = pop_current_level;   /* файла нет — остаёмся */
             } else {
@@ -1294,6 +1303,34 @@ int pop_level_switch(void) __banked
                 /* Атомарный commit на границе растра: впервые показать
                  * готовую комнату уже с окончательной палитрой уровня.
                  * Вторую страницу синхронизировать аппаратной копией. */
+                /* ЖДЁМ КОНЦА ТРЕКА ЗАСТАВКИ НА ЧЁРНОМ ЭКРАНЕ — порт
+                 * seg003:107:
+                 *     while (check_sound_playing() && !do_paused()) idle();
+                 *     stop_sounds();
+                 *     draw_level_first();
+                 * Порядок оригинала важен: загрузка уровня идёт ПОД
+                 * звучащий трек, и только потом чернота до его конца.  Тогда
+                 * общее время черноты = max(трек, загрузка), а не их сумма,
+                 * и трек не обрывается на полуслове.  Раньше у нас было
+                 * наоборот: pre_cut_finish досиживал трек, потом глушил
+                 * насос и грузил уровень.
+                 *
+                 * ЗАМЕР 2026-08-28: 500 подряд вызовов насоса через всю
+                 * загрузку — максимальный зазор 245 832 такта при дедлайне
+                 * 251 000, ни одной пропущенной порции.  Поэтому глушение на
+                 * загрузке снято и музыка её переживает.
+                 *
+                 * Счётчик — страховка от вечного ожидания (потоковый трек,
+                 * который никогда не кончится): ~20 с и идём дальше. */
+                {
+                    uint16_t mus_guard = 1000;
+
+                    while (pop_music_busy() && mus_guard) {
+                        mus_guard--;
+                        pop_wait_edge();
+                    }
+                    pop_music_free();          /* порт stop_sounds() */
+                }
                 pop_wait_edge();
                 gfx_set_visible_page(level_prepared_page);
                 gfx_set_draw_page(old_page);