@real-music-packages/web-core 0.35.0 → 0.36.0

package/dist/notationPlayer.js

@@ -0,0 +1,186 @@
+import {
+  getNotationEngraving,
+  measureColumnsFromLayout,
+  notationFactory,
+  scrollCursorFactory
+} from "./chunk-VPC2EKEY.js";
+import {
+  safeBox
+} from "./chunk-HXTRNE74.js";
+
+// src/notationPlayer.ts
+var DEFAULT_THEME = {
+  paper: "#faf7f0",
+  ink: "#1a1614",
+  accent: "#7b2436",
+  sepia: "#6d5d4d",
+  gold: "#c8a55b",
+  fontDisplay: "Georgia, serif",
+  fontBody: "Georgia, serif",
+  brand: ""
+};
+function scoreFromOnsets(onsetsMs) {
+  const notes = onsetsMs.map((onsetMs) => ({
+    pitchMidi: 60,
+    step: "C",
+    alter: 0,
+    octave: 4,
+    onsetMs,
+    durMs: 0,
+    staff: 0,
+    voice: 0,
+    hand: "R",
+    measure: 1
+  }));
+  const durationMs = onsetsMs.length ? Math.max(...onsetsMs) : 0;
+  return {
+    notes,
+    tempoMap: { source: "fallback", segments: [{ atMs: 0, bpm: 120 }] },
+    durationMs
+  };
+}
+function hitTestMeasureAt(layout, mx, my) {
+  if (!layout.measures.length) return null;
+  const indices = [...new Set(layout.measures.map((m) => m.index))].sort((a, b) => a - b);
+  const cols = measureColumnsFromLayout(layout.measures);
+  let nearest = null;
+  let nearestD = Infinity;
+  for (let i = 0; i < cols.length; i++) {
+    const b = cols[i];
+    if (mx >= b.x && mx <= b.x + b.w && my >= b.y && my <= b.y + b.h) return indices[i];
+    const cx = b.x + b.w / 2;
+    const cy = b.y + b.h / 2;
+    const d = (mx - cx) * (mx - cx) + (my - cy) * (my - cy);
+    if (d < nearestD) {
+      nearestD = d;
+      nearest = indices[i];
+    }
+  }
+  return nearest;
+}
+function createNotationPlayer(opts) {
+  const { host, musicXml, onsetsMs, noteCols, barDurMs, bars } = opts;
+  const mode = opts.mode ?? "vstack";
+  const theme = { ...DEFAULT_THEME, ...opts.theme };
+  const canvas = document.createElement("canvas");
+  canvas.style.display = "block";
+  canvas.style.width = "100%";
+  canvas.style.height = "100%";
+  host.appendChild(canvas);
+  const dpr = typeof window !== "undefined" && window.devicePixelRatio ? window.devicePixelRatio : 1;
+  function frameSize() {
+    if (opts.size) return opts.size;
+    const w = Math.max(1, Math.round((host.clientWidth || 1) * dpr));
+    const h = Math.max(1, Math.round((host.clientHeight || 1) * dpr));
+    return [w, h];
+  }
+  const [initW, initH] = frameSize();
+  canvas.width = initW;
+  canvas.height = initH;
+  const ctx2d = canvas.getContext("2d");
+  if (!ctx2d) throw new Error("createNotationPlayer: 2D canvas context unavailable");
+  let lastTMs = 0;
+  const audioClock = { nowMs: () => lastTMs };
+  const rctx = {
+    ctx2d,
+    W: initW,
+    H: initH,
+    score: scoreFromOnsets(onsetsMs),
+    audioClock,
+    theme,
+    safeBox: safeBox(initW, initH),
+    fps: 30
+  };
+  const notation = notationFactory.create();
+  const scrollCursor = scrollCursorFactory.create();
+  function notationProps(rendered) {
+    return {
+      ...rendered ? { rendered } : { xml: musicXml },
+      scrollMode: mode,
+      bars,
+      bandTop: opts.bandTop ?? 0,
+      bandHeight: opts.bandHeight ?? rctx.H
+    };
+  }
+  const scrollCursorProps = { scrollMode: mode, barDurMs, noteCols };
+  let renderedRn = null;
+  let destroyed = false;
+  const ready = (async () => {
+    await notation.init(rctx, notationProps(opts.rendered));
+    renderedRn = getNotationEngraving(rctx)?.rendered ?? null;
+    await scrollCursor.init(rctx, scrollCursorProps);
+  })();
+  function clear() {
+    ctx2d.save();
+    ctx2d.setTransform(1, 0, 0, 1, 0, 0);
+    ctx2d.fillStyle = theme.paper;
+    ctx2d.fillRect(0, 0, canvas.width, canvas.height);
+    ctx2d.restore();
+  }
+  function setTime(tMs) {
+    if (destroyed) return;
+    lastTMs = tMs;
+    clear();
+    notation.draw(rctx, tMs);
+    scrollCursor.draw(rctx, tMs);
+  }
+  async function performResize() {
+    const [w, h] = frameSize();
+    if (w === canvas.width && h === canvas.height) return;
+    canvas.width = w;
+    canvas.height = h;
+    rctx.W = w;
+    rctx.H = h;
+    rctx.safeBox = safeBox(w, h);
+    if (renderedRn) {
+      await notation.init(rctx, notationProps(renderedRn));
+      await scrollCursor.init(rctx, scrollCursorProps);
+    }
+    if (!destroyed) setTime(lastTMs);
+  }
+  function currentLayout() {
+    const eng = getNotationEngraving(rctx);
+    if (!eng) return null;
+    return eng.followLayoutAt ? eng.followLayoutAt(rctx, lastTMs) : eng.base;
+  }
+  const clickListeners = [];
+  function onCanvasClick(e) {
+    const rect = canvas.getBoundingClientRect();
+    if (!(rect.width > 0) || !(rect.height > 0)) return;
+    const mx = (e.clientX - rect.left) * (canvas.width / rect.width);
+    const my = (e.clientY - rect.top) * (canvas.height / rect.height);
+    const layout = currentLayout();
+    if (!layout) return;
+    const idx = hitTestMeasureAt(layout, mx, my);
+    if (idx != null) for (const cb of clickListeners) cb(idx);
+  }
+  canvas.addEventListener("click", onCanvasClick);
+  return {
+    ready,
+    setTime,
+    resize() {
+      void performResize();
+    },
+    onMeasureClick(cb) {
+      clickListeners.push(cb);
+      return () => {
+        const i = clickListeners.indexOf(cb);
+        if (i >= 0) clickListeners.splice(i, 1);
+      };
+    },
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      canvas.removeEventListener("click", onCanvasClick);
+      notation.dispose?.();
+      scrollCursor.dispose?.();
+      clickListeners.length = 0;
+      if (canvas.parentNode === host) host.removeChild(canvas);
+    }
+  };
+}
+export {
+  createNotationPlayer,
+  hitTestMeasureAt
+};
+//# sourceMappingURL=notationPlayer.js.map

package/dist/notationPlayer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/notationPlayer.ts"],"sourcesContent":["// createNotationPlayer — THE canonical notation-playback component: one\n// scrolling-notation-plus-gliding-playhead implementation, used for BOTH live\n// in-app players (this module's reason to exist) and the promo/video-recording\n// path (src/scene/layers/notation.ts + scrollCursor.ts, driven by the SceneSpec\n// runner for a fixed-duration capture). Both consume the SAME geometry —\n// `notationLayout`, `followBoxAt`/`vstackFollowBox`, `audioPlayheadLine`/\n// `vstackAudioPlayheadLine`, `measureColumnsFromLayout` — which still lives in\n// `src/scene/` (notationGeometry.ts, engravingStore.ts, layers/notation.ts,\n// layers/scrollCursor.ts) for now; this module is their canonical PUBLIC\n// surface for interactive, caller-driven playback. It does not reimplement or\n// fork any of that math — it just instantiates the two `Layer`s directly\n// (bypassing the SceneSpec/timeline runner, which is built for a fixed-length\n// recorded clip, not a live `setTime()`-driven widget) and adds the two things\n// a live player needs that a recorded promo never did: resize, and\n// measure-click hit-testing.\n//\n// WHY THIS EXISTS: a prior in-app player (stave-web-sightread's /bach/play)\n// hand-rolled its own playhead interpolation directly against OSMD's graphical\n// output instead of reusing this path, and the result was a janky cursor.\n// Hand-rolling notation/playhead geometry against OSMD is a KNOWN FAILURE MODE\n// — OSMD's rasterized bitmap does not scale by the naive `canvas.width / pageW`\n// whenever the engraving overflows the nominal page width (which the `hstack`\n// single-staffline layout does routinely), so a from-scratch cursor drifts\n// steadily off the noteheads over a piece. That exact bug was found and fixed\n// ONCE, here, in `extractGeometry` (src/promo.ts — `canvas.width /\n// (contentRight + contentLeft)`, not `/pageW`); every consumer of THIS module\n// inherits the fix for free. Don't re-derive playhead/scroll geometry against\n// OSMD anywhere else — wrap this component instead.\n//\n// Follow-up (noted, not done here): src/scene/layers/notation.ts +\n// scrollCursor.ts could themselves be rebuilt on top of this module instead of\n// duplicating the init/draw wiring; deferred to keep this change additive.\n//\n// IMPORT PATH: this module is SUBPATH-ONLY —\n// `import { createNotationPlayer } from '@real-music-packages/web-core/notationPlayer'`\n// — matching every other non-trivial module in this package (promo.ts,\n// video.ts, scene/, server.ts, streak.ts, playback.ts). It is intentionally\n// NOT re-exported from the root barrel (src/index.ts): the root barrel is\n// theory-only (notes/frequency/scales/intervals/chords/fretboard/shareCard,\n// all zero-dependency) so apps that only want pitch/theory helpers don't\n// statically pull in this module's scene/video runtime deps.\n\nimport { notationFactory, type NotationProps } from './scene/layers/notation';\nimport { scrollCursorFactory, type ScrollCursorProps } from './scene/layers/scrollCursor';\nimport { getNotationEngraving } from './scene/engravingStore';\nimport { measureColumnsFromLayout, type NotationLayout } from './scene/notationGeometry';\nimport type { AudioClock, RenderCtx } from './scene/layer';\nimport type { Score, ScoreNote } from './scene/score';\nimport type { RenderedNotation } from './promo';\nimport { safeBox, type PromoTheme } from './video';\n\n/**\n * Notation scroll/camera mode — forwarded verbatim to the underlying engraving\n * + follow-camera (see `RenderNotationOpts.scrollMode` in src/promo.ts and\n * `notationGeometry.ts`'s hstack/vstack follow functions). These are the ONLY\n * two modes the shared machinery implements; there is no third.\n *\n *   'vstack' (DEFAULT here) — classic stacked systems (page-wrap engraving).\n *     The follow camera frames one system at a time and scrolls vertically\n *     (with a \"carriage return\" playhead) as the piece crosses system breaks.\n *     This is the actively-exercised path (whozart's live player, the RSR/RET/\n *     RMT promo videos) and the one the memory note \"use vstack everywhere\"\n *     refers to — pick it unless you have a specific reason not to.\n *\n *   'hstack' — single horizontal staffline; the follow window pans purely\n *     left→right. The cursor is onset-locked here too (audioPlayheadLine, not\n *     a free-running sweep — that linear-sweep footgun was removed from the\n *     shared cursor entirely in web-core 0.22.0), and the earlier\n *     `canvas.width/pageW` scale bug that made hstack drift is fixed (0.30+\n *     `extractGeometry`, see the module doc above). It is still the LESS\n *     exercised of the two modes for live players (most real players show\n *     multi-line music, which needs vstack) — supported and correct today, but\n *     treat it as the less battle-tested choice.\n */\nexport type NotationPlayerMode = 'hstack' | 'vstack';\n\nexport interface NotationPlayerTheme extends Partial<PromoTheme> {}\n\nexport interface CreateNotationPlayerOpts {\n  /** Element the player's canvas is mounted into (fills it). */\n  host: HTMLElement;\n  /** MusicXML to engrave. */\n  musicXml: string;\n  /** Distinct note onsets (ms, sorted or not — de-duped/sorted internally via\n   *  the shared score model) the playhead locks to. One per played note (or\n   *  the caller's own onset schedule) — this IS the audio clock's timing. */\n  onsetsMs: number[];\n  /**\n   * Per-onset engraved column positions (`measureIndex + frac`), 1:1 with\n   * `onsetsMs`. Optional — falls back to the shared machinery's own\n   * time/ordinal-based placement when omitted (see `scroll-cursor`'s\n   * `noteCols`). Strongly recommended for anything beyond a demo: it is what\n   * lands the cursor on the actual notehead instead of a time-derived guess.\n   *\n   * GOTCHA (pre-existing in the wrapped machinery, not introduced here):\n   * internally the cursor works off `distinctOnsets(onsetsMs)` (deduped +\n   * sorted), so if `onsetsMs` contains duplicate onsets (simultaneous chord\n   * notes sharing one onset time — a legitimate input), the deduped length no\n   * longer matches `noteCols.length` and the `1:1` alignment silently breaks,\n   * degrading to the `barDurMs`/ordinal fallback with no warning. Build\n   * `noteCols` against the DEDUPED, sorted onset list, not the raw one.\n   */\n  noteCols?: number[];\n  /** Scroll/camera mode. Default 'vstack'. See `NotationPlayerMode`. Fixed for\n   *  the life of the instance — switching modes needs a fresh OSMD engrave\n   *  (different `RenderSingleHorizontalStaffline` layout), so it is NOT a\n   *  runtime-switchable option; create a new player if the mode must change\n   *  (noted as a follow-up, not built: nothing in the shared machinery makes a\n   *  live re-layout trivial). */\n  mode?: NotationPlayerMode;\n  /** Duration of one measure in ms — enables time-accurate cursor/window\n   *  placement when `noteCols` isn't supplied (see `scroll-cursor`'s\n   *  `barDurMs`). */\n  barDurMs?: number;\n  /** Bar range [from,to] forwarded to the engraver (renderNotation\n   *  bars/drawFrom-drawUpTo) — engrave an excerpt rather than the whole score. */\n  bars?: [number, number];\n  /** Top of the notation band, screen px. Default 0 (fills the host — this is\n   *  a UI widget, not a phone-safe video frame). */\n  bandTop?: number;\n  /** Height of the notation band, screen px. Default the full frame height. */\n  bandHeight?: number;\n  /** Theme tokens (colours/fonts) forwarded to the layers. Any field omitted\n   *  falls back to a neutral default. */\n  theme?: NotationPlayerTheme;\n  /** Explicit canvas size in device px. Default: host.clientWidth/clientHeight\n   *  × devicePixelRatio. Pass this in test/headless environments where the\n   *  host has no real layout (e.g. jsdom, where clientWidth is always 0). */\n  size?: [number, number];\n  /**\n   * Advanced / test seam: a pre-rasterized engraving, bypassing the browser\n   * OSMD raster (`musicXml` is still required by the type but is ignored when\n   * this is set). Mirrors `NotationProps.rendered` in\n   * `src/scene/layers/notation.ts` (\"test/headless injection\") — real OSMD\n   * *rendering* (as opposed to parsing) needs a real 2D canvas context (glyph\n   * metrics for its line-breaking pass) that headless/jsdom test contexts\n   * can't fully provide, so this is how this module (and the layer it wraps)\n   * stays unit-testable in Node. Not needed in a real browser host.\n   */\n  rendered?: RenderedNotation;\n}\n\nexport interface NotationPlayer {\n  /** Resolves once the engraving has been rasterized and is ready to draw.\n   *  `setTime`/click hit-testing are safe to call before this resolves — they\n   *  simply no-op (draw a blank frame / report no measure) until ready. */\n  readonly ready: Promise<void>;\n  /**\n   * Draw the frame for absolute playback time `tMs`. The caller owns the\n   * audio clock + the rAF loop — call this every frame with the current\n   * playback position; everything else (follow camera, onset-locked\n   * playhead) is a pure function of `tMs`, exactly as the promo/whozart path\n   * drives it.\n   */\n  setTime(tMs: number): void;\n  /** Re-measure the host and resize the canvas to match (device-px aware).\n   *  Cheap after the first draw — reuses the already-rasterized engraving\n   *  bitmap, it does not re-run OSMD. Call on host resize / orientation\n   *  change. Fire-and-forget (async internally; the next `setTime` reflects\n   *  the new size once it lands, typically within a microtask). */\n  resize(): void;\n  /** Register a measure-click handler: fires with the clicked measure's\n   *  engraved index (matching `ScoreNote.measure` numbering) when a click\n   *  lands on — or nearest to — a rendered measure column. Multiple handlers\n   *  may be registered (they all fire); returns an unsubscribe function for\n   *  that one handler. `destroy()` also clears every remaining listener. */\n  onMeasureClick(cb: (measureIndex: number) => void): () => void;\n  /** Tear down: removes the canvas from `host` and drops listeners/state. */\n  destroy(): void;\n}\n\nconst DEFAULT_THEME: PromoTheme = {\n  paper: '#faf7f0', ink: '#1a1614', accent: '#7b2436', sepia: '#6d5d4d', gold: '#c8a55b',\n  fontDisplay: 'Georgia, serif', fontBody: 'Georgia, serif', brand: '',\n};\n\n/** A minimal but valid `Score` carrying only the onset timings the shared\n *  scroll-cursor needs (`distinctOnsets(ctx.score.notes)`). Pitch/hand/measure\n *  fields are placeholders — the notation + scroll-cursor layers never read\n *  them (they read the RASTERIZED engraving's own geometry for position; the\n *  Score here only supplies the audio-onset clock). */\nfunction scoreFromOnsets(onsetsMs: number[]): Score {\n  const notes: ScoreNote[] = onsetsMs.map((onsetMs) => ({\n    pitchMidi: 60, step: 'C', alter: 0, octave: 4,\n    onsetMs, durMs: 0, staff: 0, voice: 0, hand: 'R', measure: 1,\n  }));\n  const durationMs = onsetsMs.length ? Math.max(...onsetsMs) : 0;\n  return {\n    notes,\n    tempoMap: { source: 'fallback', segments: [{ atMs: 0, bpm: 120 }] },\n    durationMs,\n  };\n}\n\n/**\n * Pure hit-test: which measure (by its engraved index) contains — or is\n * nearest to — point (mx, my) in a given followed layout. Reuses\n * `measureColumnsFromLayout` (the SAME per-measure union boxes the playhead\n * anchors to) for the boxes; only the index bookkeeping (matching each\n * returned box back to its measure index, which `measureColumnsFromLayout`\n * intentionally drops — the playhead has no use for it) is new here, and it\n * is pure array/index bookkeeping, not geometry math. Exported standalone so\n * it is unit-testable without a DOM/canvas.\n *\n * COORDINATE SPACE — read this before calling directly: (mx, my) MUST be in\n * the same DEST/DEVICE-PIXEL space `layout.measures[].box` is already mapped\n * into by `notationLayout()` (i.e. the player's own `<canvas>` device pixels,\n * origin top-left, NOT CSS px) — the same space this module's own\n * `onCanvasClick` computes via `(clientX - rect.left) * (canvas.width /\n * rect.width)`. It is NOT the raster/src space (`RenderedNotation.canvas`,\n * OSMD's own pre-map bitmap px) — passing src-space coordinates here is\n * exactly the \"classic scale gotcha\" (`extractGeometry`'s `canvas.width /\n * pageW` vs `/(contentRight+contentLeft)`, see the module doc) this component\n * exists to make impossible; don't reintroduce it at the call site.\n */\nexport function hitTestMeasureAt(layout: NotationLayout, mx: number, my: number): number | null {\n  if (!layout.measures.length) return null;\n  const indices = [...new Set(layout.measures.map((m) => m.index))].sort((a, b) => a - b);\n  const cols = measureColumnsFromLayout(layout.measures);\n  let nearest: number | null = null;\n  let nearestD = Infinity;\n  for (let i = 0; i < cols.length; i++) {\n    const b = cols[i];\n    if (mx >= b.x && mx <= b.x + b.w && my >= b.y && my <= b.y + b.h) return indices[i];\n    const cx = b.x + b.w / 2;\n    const cy = b.y + b.h / 2;\n    const d = (mx - cx) * (mx - cx) + (my - cy) * (my - cy);\n    if (d < nearestD) {\n      nearestD = d;\n      nearest = indices[i];\n    }\n  }\n  return nearest;\n}\n\n/**\n * Build a live, interactive notation player: a thin packaging of the SAME\n * working path whozart's live in-browser promo player uses (see the module\n * doc). Renders the engraving ONCE (OSMD raster, via the `notation` Layer),\n * then every `setTime(tMs)` call blits the current follow window (via\n * `followBoxAt`/`vstackFollowBox` → `notationLayout`) and draws the\n * onset-locked playhead (`audioPlayheadLine`/`vstackAudioPlayheadLine`) —\n * exactly the `notation` + `scroll-cursor` Layer pair the promo/video runner\n * uses, instantiated directly instead of through the SceneSpec/timeline\n * runner (which targets a fixed-duration recorded clip, not a live,\n * caller-driven widget).\n */\nexport function createNotationPlayer(opts: CreateNotationPlayerOpts): NotationPlayer {\n  const { host, musicXml, onsetsMs, noteCols, barDurMs, bars } = opts;\n  const mode: NotationPlayerMode = opts.mode ?? 'vstack';\n  const theme: PromoTheme = { ...DEFAULT_THEME, ...opts.theme };\n\n  const canvas = document.createElement('canvas');\n  canvas.style.display = 'block';\n  canvas.style.width = '100%';\n  canvas.style.height = '100%';\n  host.appendChild(canvas);\n\n  const dpr = typeof window !== 'undefined' && window.devicePixelRatio ? window.devicePixelRatio : 1;\n  function frameSize(): [number, number] {\n    if (opts.size) return opts.size;\n    const w = Math.max(1, Math.round((host.clientWidth || 1) * dpr));\n    const h = Math.max(1, Math.round((host.clientHeight || 1) * dpr));\n    return [w, h];\n  }\n\n  const [initW, initH] = frameSize();\n  canvas.width = initW;\n  canvas.height = initH;\n  const ctx2d = canvas.getContext('2d');\n  if (!ctx2d) throw new Error('createNotationPlayer: 2D canvas context unavailable');\n\n  let lastTMs = 0;\n  const audioClock: AudioClock = { nowMs: () => lastTMs };\n  const rctx: RenderCtx = {\n    ctx2d, W: initW, H: initH,\n    score: scoreFromOnsets(onsetsMs),\n    audioClock, theme, safeBox: safeBox(initW, initH), fps: 30,\n  };\n\n  const notation = notationFactory.create();\n  const scrollCursor = scrollCursorFactory.create();\n\n  function notationProps(rendered?: RenderedNotation): NotationProps {\n    return {\n      ...(rendered ? { rendered } : { xml: musicXml }),\n      scrollMode: mode,\n      bars,\n      bandTop: opts.bandTop ?? 0,\n      bandHeight: opts.bandHeight ?? rctx.H,\n    };\n  }\n  const scrollCursorProps: ScrollCursorProps = { scrollMode: mode, barDurMs, noteCols };\n\n  let renderedRn: RenderedNotation | null = null;\n  let destroyed = false;\n\n  const ready = (async () => {\n    await notation.init(rctx, notationProps(opts.rendered));\n    renderedRn = getNotationEngraving(rctx)?.rendered ?? null;\n    await scrollCursor.init(rctx, scrollCursorProps);\n  })();\n\n  function clear(): void {\n    ctx2d!.save();\n    ctx2d!.setTransform(1, 0, 0, 1, 0, 0);\n    ctx2d!.fillStyle = theme.paper;\n    ctx2d!.fillRect(0, 0, canvas.width, canvas.height);\n    ctx2d!.restore();\n  }\n\n  function setTime(tMs: number): void {\n    if (destroyed) return;\n    lastTMs = tMs;\n    clear();\n    notation.draw(rctx, tMs);\n    scrollCursor.draw(rctx, tMs);\n  }\n\n  async function performResize(): Promise<void> {\n    const [w, h] = frameSize();\n    if (w === canvas.width && h === canvas.height) return;\n    canvas.width = w;\n    canvas.height = h;\n    rctx.W = w;\n    rctx.H = h;\n    rctx.safeBox = safeBox(w, h);\n    if (renderedRn) {\n      // Cheap re-layout: reuses the already-rasterized bitmap (no OSMD re-run).\n      await notation.init(rctx, notationProps(renderedRn));\n      await scrollCursor.init(rctx, scrollCursorProps);\n    }\n    if (!destroyed) setTime(lastTMs);\n  }\n\n  function currentLayout(): NotationLayout | null {\n    const eng = getNotationEngraving(rctx);\n    if (!eng) return null;\n    return eng.followLayoutAt ? eng.followLayoutAt(rctx, lastTMs) : eng.base;\n  }\n\n  const clickListeners: Array<(measureIndex: number) => void> = [];\n  function onCanvasClick(e: MouseEvent): void {\n    const rect = canvas.getBoundingClientRect();\n    if (!(rect.width > 0) || !(rect.height > 0)) return;\n    const mx = (e.clientX - rect.left) * (canvas.width / rect.width);\n    const my = (e.clientY - rect.top) * (canvas.height / rect.height);\n    const layout = currentLayout();\n    if (!layout) return;\n    const idx = hitTestMeasureAt(layout, mx, my);\n    if (idx != null) for (const cb of clickListeners) cb(idx);\n  }\n  canvas.addEventListener('click', onCanvasClick);\n\n  return {\n    ready,\n    setTime,\n    resize(): void {\n      void performResize();\n    },\n    onMeasureClick(cb: (measureIndex: number) => void): () => void {\n      clickListeners.push(cb);\n      return () => {\n        const i = clickListeners.indexOf(cb);\n        if (i >= 0) clickListeners.splice(i, 1);\n      };\n    },\n    destroy(): void {\n      if (destroyed) return;\n      destroyed = true;\n      canvas.removeEventListener('click', onCanvasClick);\n      notation.dispose?.();\n      scrollCursor.dispose?.();\n      clickListeners.length = 0;\n      if (canvas.parentNode === host) host.removeChild(canvas);\n    },\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/scene/index.d.ts

@@ -1,7 +1,9 @@
 import { A as AudioClock, S as Score, a as LayerFactory, R as RenderCtx, b as ScoreFromMusicXMLOpts, T as TempoMap, c as ScoreNote } from '../waveform-DdSMAbYQ.js';
 export { L as Layer, d as SpectrumInput, e as SpectrumProps, W as WaveformInput, f as WaveformProps, s as scoreFromMusicXML, g as spectrumFactory, w as waveformFactory } from '../waveform-DdSMAbYQ.js';
 import { PromoTheme, RecordOpts, Scene, SafeBox } from '../video.js';
-import { RenderedNotation, Box, StaffMeasureBox, MeasureColumnBox } from '../promo.js';
+import { RenderedNotation, Box } from '../promo.js';
+import { N as NotationLayout } from '../notationGeometry-CZJ0U6PQ.js';
+export { F as FOLLOW_BARS, a as FOLLOW_PAD, b as NotationLayoutOpts, c as NotationRect, P as PlayheadLine, d as audioPlayheadLine, e as cropAroundBox, f as cubicEaseInOut, g as distinctMeasureIndices, h as distinctOnsets, i as firstMeasureBox, j as followBoxAt, k as followWindowStart, l as lerpBox, m as measureColumnsFromLayout, n as measureCount, o as measureSpanBox, p as measureSystemMap, q as notationLayout, r as playheadLine, s as systemBox, v as vstackAudioPlayheadLine, t as vstackFollowBox } from '../notationGeometry-CZJ0U6PQ.js';
 
 /** One scheduled audio event, in seconds RELATIVE to the schedule start. */
 interface AudioEvent {
@@ -595,138 +597,6 @@ interface ScrollCursorProps {
 }
 declare const scrollCursorFactory: LayerFactory<ScrollCursorProps>;
 
-/** measures (= rows) visible at once in the follow window. */
-declare const FOLLOW_BARS = 2;
-/** breathing room around the follow window. */
-declare const FOLLOW_PAD = 1.06;
-/** Cubic ease-in-out, t in [0,1] (RSR port of stave-video core/camera.py). */
-declare function cubicEaseInOut(t: number): number;
-/** Linear interpolation of two boxes. (RSR lerpBox) */
-declare function lerpBox(a: Box, b: Box, e: number): Box;
-/** Smallest crop of `aspect` containing `box` padded by `pad`, clamped to the
- *  canvas. (RSR cropAroundBox) */
-declare function cropAroundBox(box: Box, aspect: number, pad: number, cw: number, ch: number): Box;
-/** Union (canvas coords) of all staff measure boxes with index in [lo,hi).
- *  (RSR measureSpanBox) */
-declare function measureSpanBox(rn: RenderedNotation, lo: number, hi: number): Box | null;
-/** Union of the index-0 measure boxes — the opening focal. (RSR firstMeasureBox) */
-declare function firstMeasureBox(rn: RenderedNotation): Box | null;
-/** Number of distinct measures in the notation. (RSR measureCount) */
-declare function measureCount(rn: RenderedNotation): number;
-/** The DISTINCT measure indices present in the engraving, ASCENDING. For excerpts
- *  these do NOT start at 0 (e.g. bars 5-8 → [4,5,6,7]) and may be non-contiguous,
- *  so the follow window must scroll across THESE indices, not a 0..measureCount
- *  range. (measureCount returns maxIndex+1 — a count valid only for 0-based scores.) */
-declare function distinctMeasureIndices(rn: RenderedNotation): number[];
-/** The follow window (canvas coords) for a continuous measure-start position,
- *  spanning FOLLOW_BARS and lerping between adjacent windows. (RSR followBoxAt) */
-declare function followBoxAt(rn: RenderedNotation, posMeasures: number): Box | null;
-/**
- * The continuous follow-window START measure (ABSOLUTE index) for an hstack
- * audio-clock progress 0..1.
- *
- * hstack (single horizontal staffline): pan CONTINUOUSLY so the playhead sits at a
- * stable fraction (`HSTACK_PLAYHEAD_LEAD`) from the LEFT of the window — the playing
- * bar is always on screen with look-ahead to its right, and the cursor never drifts
- * to the screen edge.
- *
- * BUG FIX (web-core 0.21.0) — playhead pinned at the right edge for EXCERPTS. This
- * used to take `nBars = measureCount(rn) = maxIndex+1` and pan progress across a
- * 0..nBars range. That is only correct when measure indices are 0-based: RSR's
- * excerpts engrave e.g. bars 5-8 → indices [4,5,6,7], so measureCount=8 but only 4
- * measures exist. The window then panned a phantom 0..8 axis while the playhead
- * (which steps over the 4 REAL columns) raced ahead — pinning the cursor at the far
- * right while the music barely scrolled. We now pan across the ACTUAL distinct
- * indices: progress 0..1 maps to absolute index `firstIndex .. firstIndex+nReal`,
- * and `followBoxAt` (which already indexes absolute measures via measureSpanBox)
- * frames the right bars. Clamped so the window never runs past the last measure.
- *
- * Pass the RenderedNotation so the real index range is known. (The legacy 0-based
- * `nBars`-only call still works via the `firstIndex=0, nReal=nBars` fallback.)
- */
-declare function followWindowStart(rn: RenderedNotation | number, camProgress01: number): number;
-/** For each measure index, the system (row) it lives on — ordered by index.
- *  Empty when geometry is missing. */
-declare function measureSystemMap(rn: RenderedNotation): number[];
-/** Union (canvas coords) of every measure box on system `sys`. Falls back to the
- *  system's own box when no measures map to it. */
-declare function systemBox(rn: RenderedNotation, sys: number, sysMap?: number[]): Box | null;
-/**
- * vstack follow window (canvas coords) for an audio-clock progress 0..1. Frames
- * the ACTIVE system (the row the playhead's current bar is on) and eases
- * VERTICALLY to the NEXT system over the tail of the active system's last bar, so
- * the next row slides up just as the playhead crosses into it. Within a system
- * the box is fixed (the playhead pans L→R inside it). No measure-window vertical
- * jumps: the focusBox always spans an integer-or-tween of FULL systems.
- *
- * The box keeps a constant size (the larger of the two framed systems' extents)
- * so the dest mapping doesn't breathe as it scrolls — the camera just translates.
- */
-declare function vstackFollowBox(rn: RenderedNotation, camProgress01: number): Box | null;
-/** The dest rect a notation frame is drawn into, on screen. */
-interface NotationRect {
-    dx: number;
-    dy: number;
-    dw: number;
-    dh: number;
-}
-/** Geometry result of laying out the notation for one frame: which canvas `src`
- *  rect is blitted to which screen `dest` rect, plus the mapped boxes. */
-interface NotationLayout {
-    /** Canvas-space crop blitted this frame. */
-    src: Box;
-    /** Screen-space dest rect. */
-    rect: NotationRect;
-    /** Per-row system boxes mapped into screen coords (for the playhead fallback). */
-    systems: Box[];
-    /** Per-(measure,staff) boxes mapped into screen coords (for highlights/cursor). */
-    measures: StaffMeasureBox[];
-}
-interface NotationLayoutOpts {
-    /** 0 = zoomed on bar 1, 1 = full excerpt (opening camera). Default 1. */
-    zoom01?: number;
-    /** Follow window (canvas coords); when set, overrides zoom and scrolls. */
-    focusBox?: Box | null;
-}
-/**
- * Compute the notation layout (src crop + dest rect + mapped boxes) for one
- * frame. This is RSR's `drawNotation` with the single `ctx.drawImage` call REMOVED
- * — pure geometry, so it is testable headless and shared by the notation +
- * scroll-cursor layers. The layer does the drawImage using `src` + `rect`.
- */
-declare function notationLayout(rn: RenderedNotation, W: number, H: number, boxTop: number, boxH: number, opts?: NotationLayoutOpts): NotationLayout;
-/** Per-measure grand-staff column boxes (both staves unioned) from a frame's
- *  mapped measures, in render order. (RSR measureColumns) */
-declare function measureColumnsFromLayout(measures: StaffMeasureBox[]): MeasureColumnBox[];
-/** The playhead line + alpha for progress `t01`. null when fully faded. (RSR
- *  drawPlayhead, with the actual stroke factored out into the layer.) */
-interface PlayheadLine {
-    x: number;
-    y0: number;
-    y1: number;
-    alpha: number;
-}
-declare function playheadLine(layout: NotationLayout, t01: number): PlayheadLine | null;
-/** Distinct, sorted note onsets from a Score's notes. */
-declare function distinctOnsets(notes: {
-    onsetMs: number;
-}[]): number[];
-/**
- * The FOOLPROOF audio-driven playhead line for absolute audio time `tMs`.
- *
- * `tMs` is the audio clock; `onsetsMs` are the score's distinct note onsets
- * (sorted). The cursor is the time-lerp of the two anchors bracketing `tMs`:
- * before the first onset it holds on anchor 0; after the last it holds on the
- * last; in a gap it eases between the bracketing onsets. Pure function of
- * (layout, onsetsMs, tMs). Returns null only when there is no geometry to anchor
- * to (falls back to the rect sweep in the layer, same as `playheadLine`).
- *
- * Fade in/out mirrors `playheadLine` but is keyed on position in the ONSET span
- * (first→last onset), not on musicMs — so the fade tracks the notes too.
- */
-declare function audioPlayheadLine(layout: NotationLayout, onsetsMs: number[], tMs: number, barDurMs?: number, noteCols?: number[]): PlayheadLine | null;
-declare function vstackAudioPlayheadLine(layout: NotationLayout, onsetsMs: number[], tMs: number, nBars: number, noteCols?: number[]): PlayheadLine | null;
-
 /** Map a canvas-space box through a base notation layout into world/screen coords. */
 declare function mapBoxThroughLayout(base: NotationLayout, b: Box): Box;
 /** RSR's per-frame `src` crop from a follow box (FOLLOW_PAD expand + clamp) —
@@ -1825,4 +1695,4 @@ interface ImageRevealProps {
 }
 declare const imageRevealFactory: LayerFactory<ImageRevealProps>;
 
-export { type Affine, AudioClock, type AudioEvent, type BackgroundProps, type BeatGridOpts, type BeatPulseProps, type BeatTick, type BrandingProps, type BufferFactory, type BuildSceneOpts, type BuiltScene, type CameraState, type CaptionCue, type CaptionProps, type CaptionScript, type CaptionStyle, type ChordRibbonProps, type ChordSpan, type CircleOfFifthsProps, type CirclePoint, type ClickTrackOpts, type ColorBy, type ContourPlot, type ContourPoint, type CountInOpts, type CountdownProps, type CountingTrackProps, type CtaProps, DEFAULT_FUNCTION_COLORS, type DegreeLabel, type DegreeLabelsProps, type DroneOpts, type DuckWindow, type Easing, type EndCardProps, type ExtendedDemoOpts, FIFTHS_MAJOR, FIFTHS_MINOR, FOLLOW_BARS, FOLLOW_PAD, type FallingKeyboardDemoOpts, type FallingNotesProps, type FretboardProps, type FunctionColors, type FunctionalHarmonyProps, type GateError, type GateInput, type HandColors, type HarmonicFunction, type HarmonyMode, type HighlightRegion, type HookProps, type ImageRevealMode, type ImageRevealProps, type IntervalArcsProps, type KaraokeCaptionProps, type KaraokeWord, type KeyRect, type KeyboardLayout, type KeyboardLayoutOpts, type KeyboardProps, type KineticMode, type KineticTextProps, type LabelMode, LayerFactory, type McqCardProps, type NotationEngraving, type NotationLayout, type NotationLayoutOpts, type NotationProps, type NotationRect, type OutputProbe, PIANO_HIGH, PIANO_LOW, type ParticleBurstProps, type PitchContourProps, type Placement, type PlayheadLine, type PortraitProps, type ProgressRingProps, type PromoCardsDemoOpts, type PulseStyle, type Quiz, type QuizOption, type QuizPhase, type RadialSpectrumProps, type RayEndpoints, type RecordSceneSpecOpts, type Rect, RenderCtx, type ResolvedSegment, type RevealEasing, type RevealProps, SCALE_INTERVALS, type SafeGuidesProps, type ScaleHighlightProps, type SceneSpec, type ScheduleTarget, Score, ScoreFromMusicXMLOpts, ScoreNote, type ScrollCursorProps, type Section, type SectionMinimapProps, type SegmentAudio, type SegmentAudioCtx, type SegmentTransition, type SpecLayer, type StaffKeyboardRayProps, type StatCounterProps, TempoMap, type TensionGraphProps, type TensionPoint, type TextureProps, type TimeAnchor, type TimelineSegment, activeChord, activeCue, activeSection, animatedSlot, applySchedule, applyToContext, assertGate, audioPlayheadLine, ballArc, ballX, beatGrid, beatPhase, beatPulseFactory, blackKeys, bpmOf, brandingFactory, buildScene, cameraForFollow, cameraTransform, chordRibbonFactory, circleOfFifthsDemoSpec, circleOfFifthsFactory, clamp, clickTrackSchedule, contourMinimapDemoSpec, contourPoints, contourPolyline, countInLeadSec, countInSchedule, countdownFactory, countdownRemaining, countdownSeconds, countingDegreeDemoSpec, countingTrackFactory, cropAroundBox, ctaFactory, cubicEaseInOut, cueOpacity, degreeLabel, degreeLabelsFactory, distinctMeasureIndices, distinctOnsets, dotAt, drawCaption, drawHighlight, droneSchedule, duckGainAt, easeIn, easeInOut, easeOut, endCardFactory, fallingKeyboardDemoScore, fallingKeyboardDemoSpec, fallingNotesFactory, firstMeasureBox, followBoxAt, followSrcBox, followWindowStart, fracSlotPoint, frameRect, fretboardFactory, functionColor, functionalHarmonyFactory, getKeyboardLayout, getLayerFactory, getNotationEngraving, harmonyDemoSpec, highlightIntensity, hookFactory, identityCamera, imageRevealFactory, inRange, intervalArcsFactory, invLerp, isBlackKey, karaokeCaptionFactory, kenBurns, keyCenterX, keyColumnWidth, keyRect, keySlot, keyboardFactory, keyboardLayout, kineticTextFactory, lerp, lerpBox, lerpCamera, linear, mapBoxThroughLayout, mcqCardFactory, mcqDemoSpec, measureColumnsFromLayout, measureCount, measureSpanBox, measureSpans, measureSystemMap, timeToX as minimapTimeToX, msPerBeat, notationFactory, notationLayout, noteColor, noteSetXRange, parseKey, parseTimeSig, particleBurstFactory, pcToSlot, pitchAt, pitchContourFactory, pitchRange, playheadLine, portraitFactory, progress01, progressRingFactory, projectPoint, promoCardsDemoSpec, pulseAt, quizPhase, radialSpectrumFactory, rayEndpoints, rayPointAt, recordSceneSpec, registerLayer, registeredKeys, resolveAnchor, resolveKeyboardLayout, resolveTimeline, revealFactory, revealProgress, runGate, safeGuidesFactory, scaleHighlightFactory, scorePitchSpan, scrollCursorFactory, sectionMinimapFactory, setFollowLayoutProvider, setKeyboardLayout, setNotationEngraving, slotAngle, slotPc, slotPoint, staffAnchor, staffKeyboardRayFactory, staffRayDemoSpec, statCounterFactory, systemBox, tensionGraphFactory, textureFactory, transitionProgress, validateChordTrack, validateQuiz, validateSections, visualTimelineMs, vstackAudioPlayheadLine, vstackFollowBox, whiteKeys, worldToViewport };
+export { type Affine, AudioClock, type AudioEvent, type BackgroundProps, type BeatGridOpts, type BeatPulseProps, type BeatTick, type BrandingProps, type BufferFactory, type BuildSceneOpts, type BuiltScene, type CameraState, type CaptionCue, type CaptionProps, type CaptionScript, type CaptionStyle, type ChordRibbonProps, type ChordSpan, type CircleOfFifthsProps, type CirclePoint, type ClickTrackOpts, type ColorBy, type ContourPlot, type ContourPoint, type CountInOpts, type CountdownProps, type CountingTrackProps, type CtaProps, DEFAULT_FUNCTION_COLORS, type DegreeLabel, type DegreeLabelsProps, type DroneOpts, type DuckWindow, type Easing, type EndCardProps, type ExtendedDemoOpts, FIFTHS_MAJOR, FIFTHS_MINOR, type FallingKeyboardDemoOpts, type FallingNotesProps, type FretboardProps, type FunctionColors, type FunctionalHarmonyProps, type GateError, type GateInput, type HandColors, type HarmonicFunction, type HarmonyMode, type HighlightRegion, type HookProps, type ImageRevealMode, type ImageRevealProps, type IntervalArcsProps, type KaraokeCaptionProps, type KaraokeWord, type KeyRect, type KeyboardLayout, type KeyboardLayoutOpts, type KeyboardProps, type KineticMode, type KineticTextProps, type LabelMode, LayerFactory, type McqCardProps, type NotationEngraving, NotationLayout, type NotationProps, type OutputProbe, PIANO_HIGH, PIANO_LOW, type ParticleBurstProps, type PitchContourProps, type Placement, type PortraitProps, type ProgressRingProps, type PromoCardsDemoOpts, type PulseStyle, type Quiz, type QuizOption, type QuizPhase, type RadialSpectrumProps, type RayEndpoints, type RecordSceneSpecOpts, type Rect, RenderCtx, type ResolvedSegment, type RevealEasing, type RevealProps, SCALE_INTERVALS, type SafeGuidesProps, type ScaleHighlightProps, type SceneSpec, type ScheduleTarget, Score, ScoreFromMusicXMLOpts, ScoreNote, type ScrollCursorProps, type Section, type SectionMinimapProps, type SegmentAudio, type SegmentAudioCtx, type SegmentTransition, type SpecLayer, type StaffKeyboardRayProps, type StatCounterProps, TempoMap, type TensionGraphProps, type TensionPoint, type TextureProps, type TimeAnchor, type TimelineSegment, activeChord, activeCue, activeSection, animatedSlot, applySchedule, applyToContext, assertGate, ballArc, ballX, beatGrid, beatPhase, beatPulseFactory, blackKeys, bpmOf, brandingFactory, buildScene, cameraForFollow, cameraTransform, chordRibbonFactory, circleOfFifthsDemoSpec, circleOfFifthsFactory, clamp, clickTrackSchedule, contourMinimapDemoSpec, contourPoints, contourPolyline, countInLeadSec, countInSchedule, countdownFactory, countdownRemaining, countdownSeconds, countingDegreeDemoSpec, countingTrackFactory, ctaFactory, cueOpacity, degreeLabel, degreeLabelsFactory, dotAt, drawCaption, drawHighlight, droneSchedule, duckGainAt, easeIn, easeInOut, easeOut, endCardFactory, fallingKeyboardDemoScore, fallingKeyboardDemoSpec, fallingNotesFactory, followSrcBox, fracSlotPoint, frameRect, fretboardFactory, functionColor, functionalHarmonyFactory, getKeyboardLayout, getLayerFactory, getNotationEngraving, harmonyDemoSpec, highlightIntensity, hookFactory, identityCamera, imageRevealFactory, inRange, intervalArcsFactory, invLerp, isBlackKey, karaokeCaptionFactory, kenBurns, keyCenterX, keyColumnWidth, keyRect, keySlot, keyboardFactory, keyboardLayout, kineticTextFactory, lerp, lerpCamera, linear, mapBoxThroughLayout, mcqCardFactory, mcqDemoSpec, measureSpans, timeToX as minimapTimeToX, msPerBeat, notationFactory, noteColor, noteSetXRange, parseKey, parseTimeSig, particleBurstFactory, pcToSlot, pitchAt, pitchContourFactory, pitchRange, portraitFactory, progress01, progressRingFactory, projectPoint, promoCardsDemoSpec, pulseAt, quizPhase, radialSpectrumFactory, rayEndpoints, rayPointAt, recordSceneSpec, registerLayer, registeredKeys, resolveAnchor, resolveKeyboardLayout, resolveTimeline, revealFactory, revealProgress, runGate, safeGuidesFactory, scaleHighlightFactory, scorePitchSpan, scrollCursorFactory, sectionMinimapFactory, setFollowLayoutProvider, setKeyboardLayout, setNotationEngraving, slotAngle, slotPc, slotPoint, staffAnchor, staffKeyboardRayFactory, staffRayDemoSpec, statCounterFactory, tensionGraphFactory, textureFactory, transitionProgress, validateChordTrack, validateQuiz, validateSections, visualTimelineMs, whiteKeys, worldToViewport };