fix(align): densify coarse fallback path; per-segment offset pooling; no degenerate first stretch

The coarse-path fallback now expands each 10 Hz step to five 50 Hz steps so its
diagonals still yield bar anchors; fine band widths are injectable to test it.
Offset pooling is clipped to the current segment, and auto anchors need
audioSec > 0 unless midiSec is 0. Tests: forced fallback, wrong manual anchor,
p90 bound; debug output gated behind ALIGN_DEBUG.

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

tests/align/auto.test.ts

@@ -26,6 +26,9 @@ function smfFrom(truth: TruthTrack[], programs: number[], bpm: number, map: (t:
 const rolesOf = (truth: TruthTrack[]): Record<string, Role | null> => Object.fromEntries(truth.map((t) => [t.name, t.role]));
 const durOf = (a: Audio) => a.channels[0]!.length / a.sampleRate;
 const median = (xs: number[]) => { const s = [...xs].sort((a, b) => a - b); return s[s.length >> 1]!; };
+const p90 = (xs: number[]) => { const s = [...xs].sort((a, b) => a - b); return s[Math.floor(s.length * 0.9)]!; };
+const debug = (msg: string) => { if (process.env.ALIGN_DEBUG) console.log(msg); };
+const strictlyMonotone = (A: Anchor[]) => A.every((a, k) => k === 0 || (a.midiSec > A[k - 1]!.midiSec && a.audioSec > A[k - 1]!.audioSec));
 
 /** Known distortion recording time -> MIDI time: +0.4 s, then bars 4–10 at ×1.06 tempo, then ≈ −0.8 s (continuous). */
 function distortion(bpm: number): Warp {
@@ -53,11 +56,13 @@ test("recovers a known piecewise warp: median error < 40 ms, fit match rate > 0.
   const { anchors, fit } = autoAlign(song.mix, smf, rolesOf(song.truth.tracks), [], SF2);
   const ms = performance.now() - t0;
   const err = recoveryErrors(smf, anchors, D.toMidi, durOf(song.mix));
-  console.log(`synthetic warp: ${anchors.length} anchors, median err ${(median(err) * 1000).toFixed(1)} ms, p90 ${(err.sort((a, b) => a - b)[Math.floor(err.length * 0.9)]! * 1000).toFixed(1)} ms, fit ${fit.matchRate?.toFixed(3)} / ${fit.medianResidualMs?.toFixed(1)} ms, ${ms.toFixed(0)} ms`);
+  debug(`synthetic warp: ${anchors.length} anchors, median err ${(median(err) * 1000).toFixed(1)} ms, p90 ${(p90(err) * 1000).toFixed(1)} ms, fit ${fit.matchRate?.toFixed(3)} / ${fit.medianResidualMs?.toFixed(1)} ms, ${ms.toFixed(0)} ms`);
   expect(anchors.every((a) => a.kind === "auto")).toBe(true);
   expect(median(err)).toBeLessThan(0.04);
+  expect(p90(err)).toBeLessThan(0.08);
   expect(fit.matchRate!).toBeGreaterThan(0.7);
   expect(fit.windows.length).toBe(2);
+  expect(anchors.every((a) => a.audioSec > 0 || a.midiSec === 0)).toBe(true);
 }, BIG);
 
 test("a correct manual anchor mid-song is honoured exactly", () => {
@@ -91,7 +96,7 @@ test("5-minute input aligns in < 15 s", () => {
   const t0 = performance.now();
   const { anchors, fit } = autoAlign(mix, smf, rolesOf(song.truth.tracks), [], SF2);
   const sec = (performance.now() - t0) / 1000;
-  console.log(`5-min (${durOf(mix).toFixed(0)} s) input: ${sec.toFixed(2)} s, ${anchors.length} anchors, fit ${fit.matchRate?.toFixed(3)}`);
+  debug(`5-min (${durOf(mix).toFixed(0)} s) input: ${sec.toFixed(2)} s, ${anchors.length} anchors, fit ${fit.matchRate?.toFixed(3)}`);
   expect(durOf(mix)).toBeGreaterThan(290);
   expect(sec).toBeLessThan(15);
   expect(fit.windows.length).toBe(10);
@@ -133,3 +138,34 @@ test("fit exposes a bad alignment instead of hiding it", () => {
   // unmapped tracks are excluded: with no scored roles there is nothing to measure
   expect(alignmentFit(song.mix, smf, Object.fromEntries(Object.keys(roles).map((k) => [k, null])), []).matchRate).toBeNull();
 }, BIG);
+
+test("a deliberately wrong manual anchor (+0.3 s) is kept exactly and the result stays monotonic", () => {
+  const D = distortion(song.song.bpm);
+  const smf = smfFrom(song.truth.tracks, song.song.tracks.map((t) => t.program), song.song.bpm, D.toAudio);
+  const manual: Anchor = { midiSec: D.toAudio(30), audioSec: 30.3, kind: "manual" };
+  const { anchors } = autoAlign(song.mix, smf, rolesOf(song.truth.tracks), [manual], SF2);
+  expect(anchors.filter((a) => a.kind === "manual")).toEqual([manual]);
+  expect(makeWarp(anchors).toAudio(manual.midiSec)).toBe(30.3);
+  expect(strictlyMonotone(anchors)).toBe(true);
+  expect(anchors.every((a) => a.audioSec > 0 || a.midiSec === 0)).toBe(true);
+  // away from the bad anchor (> 4 s), the autos still follow the truth
+  const far = anchors.filter((a) => a.kind === "auto" && Math.abs(a.audioSec - 30) > 4);
+  expect(far.length).toBeGreaterThan(5);
+  expect(median(far.map((a) => Math.abs(a.audioSec - D.toMidi(a.midiSec))))).toBeLessThan(0.04);
+}, BIG);
+
+test("when every fine band fails, the coarse-path fallback still yields auto anchors", () => {
+  const D = distortion(song.song.bpm);
+  const smf = smfFrom(song.truth.tracks, song.song.tracks.map((t) => t.program), song.song.bpm, D.toAudio);
+  const manual: Anchor = { midiSec: D.toAudio(30), audioSec: 30, kind: "manual" };
+  const { anchors, fit } = autoAlign(song.mix, smf, rolesOf(song.truth.tracks), [manual], SF2, { fineBandsSec: [] });
+  const autos = anchors.filter((a) => a.kind === "auto");
+  // both segments (before and after the manual anchor) get anchors
+  expect(autos.filter((a) => a.audioSec < 30).length).toBeGreaterThan(3);
+  expect(autos.filter((a) => a.audioSec > 30).length).toBeGreaterThan(3);
+  expect(strictlyMonotone(anchors)).toBe(true);
+  const err = recoveryErrors(smf, anchors, D.toMidi, durOf(song.mix));
+  debug(`coarse fallback: ${autos.length} autos, median err ${(median(err) * 1000).toFixed(1)} ms, p90 ${(p90(err) * 1000).toFixed(1)} ms, fit ${fit.matchRate?.toFixed(3)}`);
+  expect(median(err)).toBeLessThan(0.06); // 10 Hz resolution: coarser than the fine pass, still hand-correctable
+  expect(p90(err)).toBeLessThan(0.12);
+}, BIG);