img:first-child]:pt-0 data-[size=sm]:[--card-spacing:--spacing(3)] data-[size=sm]:has-data-[slot=card-footer]:pb-0 *:[img:first-child]:rounded-t-xl *:[img:last-child]:rounded-b-xl",
+ className
+ )}
+ {...props}
+ />
+ )
+}
+
+function CardHeader({ className, ...props }: React.ComponentProps<"div">) {
+ return (
+
+ )
+}
+
+function CardTitle({ className, ...props }: React.ComponentProps<"div">) {
+ return (
+
+ )
+}
+
+function CardDescription({ className, ...props }: React.ComponentProps<"div">) {
+ return (
+
+ )
+}
+
+function CardAction({ className, ...props }: React.ComponentProps<"div">) {
+ return (
+
+ )
+}
+
+function CardContent({ className, ...props }: React.ComponentProps<"div">) {
+ return (
+
+ )
+}
+
+function CardFooter({ className, ...props }: React.ComponentProps<"div">) {
+ return (
+
+ )
+}
+
+export {
+ Card,
+ CardHeader,
+ CardFooter,
+ CardTitle,
+ CardAction,
+ CardDescription,
+ CardContent,
+}
diff --git a/src/components/ui/input.tsx b/src/components/ui/input.tsx
new file mode 100644
index 0000000..7c4ab5a
--- /dev/null
+++ b/src/components/ui/input.tsx
@@ -0,0 +1,19 @@
+import * as React from "react"
+import { Input as InputPrimitive } from "@base-ui/react/input"
+import { cn } from "cn"
+
+function Input({ className, type, ...props }: React.ComponentProps<"input">) {
+ return (
+
+ )
+}
+
+export { Input }
diff --git a/src/components/ui/label.tsx b/src/components/ui/label.tsx
new file mode 100644
index 0000000..ddfd2e1
--- /dev/null
+++ b/src/components/ui/label.tsx
@@ -0,0 +1,19 @@
+"use client"
+
+import * as React from "react"
+import { cn } from "cn"
+
+function Label({ className, ...props }: React.ComponentProps<"label">) {
+ return (
+
+ )
+}
+
+export { Label }
diff --git a/src/components/ui/scroll-area.tsx b/src/components/ui/scroll-area.tsx
new file mode 100644
index 0000000..b346b62
--- /dev/null
+++ b/src/components/ui/scroll-area.tsx
@@ -0,0 +1,54 @@
+"use client"
+
+import * as React from "react"
+import { ScrollArea as ScrollAreaPrimitive } from "@base-ui/react/scroll-area"
+import { cn } from "cn"
+
+function ScrollArea({
+ className,
+ children,
+ ...props
+}: ScrollAreaPrimitive.Root.Props) {
+ return (
+
+
+ {children}
+
+
+ )
+}
+
+function ScrollBar({
+ className,
+ orientation = "vertical",
+ ...props
+}: ScrollAreaPrimitive.Scrollbar.Props) {
+ return (
+
+
+ )
+}
+
+export { ScrollArea, ScrollBar }
diff --git a/src/components/ui/select.tsx b/src/components/ui/select.tsx
new file mode 100644
index 0000000..ca1ee68
--- /dev/null
+++ b/src/components/ui/select.tsx
@@ -0,0 +1,200 @@
+"use client"
+
+import * as React from "react"
+import { Select as SelectPrimitive } from "@base-ui/react/select"
+import { cn } from "cn"
+import { ChevronDownIcon, CheckIcon, ChevronUpIcon } from "lucide-react"
+
+const Select = SelectPrimitive.Root
+
+function SelectGroup({ className, ...props }: SelectPrimitive.Group.Props) {
+ return (
+
+ )
+}
+
+function SelectValue({ className, ...props }: SelectPrimitive.Value.Props) {
+ return (
+
+ )
+}
+
+function SelectTrigger({
+ className,
+ size = "default",
+ children,
+ ...props
+}: SelectPrimitive.Trigger.Props & {
+ size?: "sm" | "default"
+}) {
+ return (
+
+ {children}
+
+ )
+}
+
+function SelectContent({
+ className,
+ children,
+ side = "bottom",
+ sideOffset = 4,
+ align = "center",
+ alignOffset = 0,
+ alignItemWithTrigger = true,
+ ...props
+}: SelectPrimitive.Popup.Props &
+ Pick<
+ SelectPrimitive.Positioner.Props,
+ "align" | "alignOffset" | "side" | "sideOffset" | "alignItemWithTrigger"
+ >) {
+ return (
+
+
+
+ {children}
+
+
+
+ )
+}
+
+function SelectLabel({
+ className,
+ ...props
+}: SelectPrimitive.GroupLabel.Props) {
+ return (
+
+ )
+}
+
+function SelectItem({
+ className,
+ children,
+ ...props
+}: SelectPrimitive.Item.Props) {
+ return (
+
+
+ {children}
+
+
+ )
+}
+
+function SelectSeparator({
+ className,
+ ...props
+}: SelectPrimitive.Separator.Props) {
+ return (
+
+ )
+}
+
+function SelectScrollUpButton({
+ className,
+ ...props
+}: React.ComponentProps
) {
+ return (
+
+
+ )
+}
+
+function SelectScrollDownButton({
+ className,
+ ...props
+}: React.ComponentProps) {
+ return (
+
+
+ )
+}
+
+export {
+ Select,
+ SelectContent,
+ SelectGroup,
+ SelectItem,
+ SelectLabel,
+ SelectScrollDownButton,
+ SelectScrollUpButton,
+ SelectSeparator,
+ SelectTrigger,
+ SelectValue,
+}
diff --git a/src/components/ui/separator.tsx b/src/components/ui/separator.tsx
new file mode 100644
index 0000000..d69c134
--- /dev/null
+++ b/src/components/ui/separator.tsx
@@ -0,0 +1,24 @@
+"use client"
+
+import { Separator as SeparatorPrimitive } from "@base-ui/react/separator"
+import { cn } from "cn"
+
+function Separator({
+ className,
+ orientation = "horizontal",
+ ...props
+}: SeparatorPrimitive.Props) {
+ return (
+ ) {
+ return (
+ & {
+ spacing?: number
+ orientation?: "horizontal" | "vertical"
+ }
+>({
+ size: "default",
+ variant: "default",
+ spacing: 2,
+ orientation: "horizontal",
+})
+
+function ToggleGroup({
+ className,
+ variant,
+ size,
+ spacing = 2,
+ orientation = "horizontal",
+ children,
+ ...props
+}: ToggleGroupPrimitive.Props &
+ VariantProps & {
+ spacing?: number
+ orientation?: "horizontal" | "vertical"
+ }) {
+ return (
+
+
+ {children}
+
+
+ )
+}
+
+function ToggleGroupItem({
+ className,
+ children,
+ variant = "default",
+ size = "default",
+ ...props
+}: TogglePrimitive.Props & VariantProps) {
+ const context = React.useContext(ToggleGroupContext)
+
+ return (
+
+ {children}
+
+ )
+}
+
+export { ToggleGroup, ToggleGroupItem }
diff --git a/src/components/ui/toggle.tsx b/src/components/ui/toggle.tsx
new file mode 100644
index 0000000..f38073f
--- /dev/null
+++ b/src/components/ui/toggle.tsx
@@ -0,0 +1,44 @@
+"use client"
+
+import { Toggle as TogglePrimitive } from "@base-ui/react/toggle"
+import { cva, type VariantProps } from "class-variance-authority"
+import { cn } from "cn"
+
+const toggleVariants = cva(
+ "group/toggle inline-flex items-center justify-center gap-1 rounded-lg text-sm font-medium whitespace-nowrap transition-all outline-none hover:bg-muted hover:text-foreground focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 aria-pressed:bg-muted data-[state=on]:bg-muted dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+ {
+ variants: {
+ variant: {
+ default: "bg-transparent",
+ outline: "border border-input bg-transparent hover:bg-muted",
+ },
+ size: {
+ default:
+ "h-8 min-w-8 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2",
+ sm: "h-7 min-w-7 rounded-[min(var(--radius-md),12px)] px-2.5 text-[0.8rem] has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3.5",
+ lg: "h-9 min-w-9 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2",
+ },
+ },
+ defaultVariants: {
+ variant: "default",
+ size: "default",
+ },
+ }
+)
+
+function Toggle({
+ className,
+ variant = "default",
+ size = "default",
+ ...props
+}: TogglePrimitive.Props & VariantProps) {
+ return (
+ = {
+ breve: "breve",
+ whole: "whole",
+ half: "half",
+ quarter: "quarter",
+ eighth: "eighth",
+ "16th": "sixteenth",
+ "32nd": "thirty-second",
+ "64th": "sixty-fourth",
+};
+
+export function quartersMatch(a: number, b: number): boolean {
+ return Math.abs(a - b) < 0.001;
+}
+
+export function durationLabel(
+ quarters: number,
+ type?: string | null,
+ dots = 0,
+ tuplet = false,
+): string {
+ if (type && TYPE_NAMES[type]) {
+ let name = TYPE_NAMES[type];
+ if (tuplet) name = `triplet ${name}`;
+ if (dots >= 2) name = `double-dotted ${name}`;
+ else if (dots === 1) name = `dotted ${name}`;
+ return name;
+ }
+ const preset = DURATION_PRESETS.find((item) => quartersMatch(item.quarters, quarters));
+ if (preset) return preset.label;
+ const rounded = Math.round(quarters * 1000) / 1000;
+ return `${rounded} quarters`;
+}
+
+export function formatQuarterLengths(quarters: number): string {
+ const rounded = Math.round(quarters * 1000) / 1000;
+ const text = Number.isInteger(rounded) ? String(rounded) : String(rounded);
+ return `${text} quarter-length${rounded === 1 ? "" : "s"}`;
+}
diff --git a/src/lib/fingering.ts b/src/lib/fingering.ts
new file mode 100644
index 0000000..7493210
--- /dev/null
+++ b/src/lib/fingering.ts
@@ -0,0 +1,195 @@
+import { parsePitch } from "@/lib/pitch";
+
+export type HoleState = "open" | "closed" | "half";
+
+export type Fingering = {
+ thumb: HoleState;
+ /** Holes 1, 2, 3, 4, 5, 6a, 6b, 7a, 7b. */
+ holes: HoleState[];
+ bell: boolean;
+};
+
+export type FingeringSystem = "baroque" | "german";
+
+export const RANGE_LABEL = "C5–D7";
+export const LOW_MIDI = 72;
+export const HIGH_MIDI = 98;
+
+const HOLE_IDS = ["1", "2", "3", "4", "5", "6a", "6b", "7a", "7b"] as const;
+
+type ThumbCode = "0" | "x" | "-";
+type Row = [pitch: string, thumb: ThumbCode, holes: string, bell?: boolean];
+
+/**
+ * First-choice Baroque (English) fingerings from the Dolmetsch Online chart
+ * for recorders in C (Brian Blood). Octave 1 is concert C5.
+ * A listed hole is closed. 6a without 6b, or 7a without 7b, is the half-hole.
+ * Thumb 0 is closed, x is pinched, - is open.
+ * Alternates on that chart (second B, all-closed D, and so on) are not encoded.
+ */
+const BAROQUE_ROWS: Row[] = [
+ ["C5", "0", "123456a6b7a7b"],
+ ["C#5", "0", "123456a6b7a"],
+ ["D5", "0", "123456a6b"],
+ ["Eb5", "0", "123456a"],
+ ["E5", "0", "12345"],
+ ["F5", "0", "12346a6b7a7b"],
+ ["F#5", "0", "12356a6b"],
+ ["G5", "0", "123"],
+ ["Ab5", "0", "12456a"],
+ ["A5", "0", "12"],
+ ["Bb5", "0", "134"],
+ ["B5", "0", "1"],
+ ["C6", "0", "2"],
+ ["C#6", "-", "12"],
+ ["D6", "-", "2"],
+ ["Eb6", "-", "23456a6b"],
+ ["E6", "x", "12345"],
+ ["F6", "x", "12346a6b"],
+ ["F#6", "x", "1235"],
+ ["G6", "x", "123"],
+ ["Ab6", "x", "124"],
+ ["A6", "x", "12"],
+ ["Bb6", "x", "1256a6b"],
+ ["B6", "x", "1245"],
+ ["C7", "x", "145"],
+ ["C#7", "x", "1346a6b", true],
+ ["D7", "x", "1346a6b"],
+];
+
+/**
+ * German differs on F, F♯, and B♭.
+ * Low F is Dolmetsch’s German fingering: 0 123 4 (holes 5–7 open).
+ * F♯ is thumb, 1, 2, 3, 5, 6, and half-hole 7.
+ * B♭ is thumb, 1, 3, 4, 6.
+ * Those two accidentals are the school German pattern described by
+ * Zach VanderGraaff (Dynamic Music Room). The octave above keeps the same
+ * front holes and uses the Dolmetsch second-octave thumb.
+ */
+const GERMAN_ROWS: Row[] = [
+ ["F5", "0", "1234"],
+ ["F#5", "0", "12356a6b7a"],
+ ["Bb5", "0", "1346a6b"],
+ ["F6", "x", "1234"],
+ ["F#6", "x", "12356a6b7a"],
+ ["Bb6", "x", "1346a6b"],
+];
+
+export const CHART_NOTES = [
+ "C5",
+ "C#5",
+ "D5",
+ "Eb5",
+ "E5",
+ "F5",
+ "F#5",
+ "G5",
+ "Ab5",
+ "A5",
+ "Bb5",
+ "B5",
+ "C6",
+ "C#6",
+ "D6",
+ "Eb6",
+ "E6",
+ "F6",
+ "F#6",
+ "G6",
+ "Ab6",
+ "A6",
+ "Bb6",
+ "B6",
+ "C7",
+ "C#7",
+ "D7",
+] as const;
+
+function closedSet(spec: string): Set {
+ const closed = new Set();
+ let index = 0;
+ while (index < spec.length) {
+ const pair = spec.slice(index, index + 2);
+ if (pair === "6a" || pair === "6b" || pair === "7a" || pair === "7b") {
+ closed.add(pair);
+ index += 2;
+ } else {
+ closed.add(spec[index]);
+ index += 1;
+ }
+ }
+ return closed;
+}
+
+function make(thumb: ThumbCode, spec: string, bell = false): Fingering {
+ const closed = closedSet(spec);
+ return {
+ thumb: thumb === "0" ? "closed" : thumb === "x" ? "half" : "open",
+ holes: HOLE_IDS.map((id) => (closed.has(id) ? "closed" : "open")),
+ bell,
+ };
+}
+
+function table(rows: Row[]): Map {
+ const map = new Map();
+ for (const [pitch, thumb, holes, bell] of rows) {
+ const parsed = parsePitch(pitch);
+ if (!parsed) throw new Error(`Bad chart pitch ${pitch}`);
+ map.set(parsed.midi, make(thumb, holes, bell ?? false));
+ }
+ return map;
+}
+
+const BAROQUE = table(BAROQUE_ROWS);
+const GERMAN = table(GERMAN_ROWS);
+
+export function fingeringFor(pitch: string, system: FingeringSystem): Fingering | null {
+ const parsed = parsePitch(pitch);
+ if (!parsed || parsed.midi < LOW_MIDI || parsed.midi > HIGH_MIDI) return null;
+ if (system === "german") {
+ const german = GERMAN.get(parsed.midi);
+ if (german) return german;
+ }
+ return BAROQUE.get(parsed.midi) ?? null;
+}
+
+export function fingeringCode(fingering: Fingering): string {
+ const thumb = fingering.thumb === "closed" ? "0" : fingering.thumb === "half" ? "x" : "-";
+ const closed = HOLE_IDS.filter((_, index) => fingering.holes[index] === "closed");
+ const bell = fingering.bell ? " bell" : "";
+ return `${thumb} ${closed.join(" ")}${bell}`;
+}
+
+export function fingeringMarks(fingering: Fingering): string[] {
+ const marks: string[] = [];
+ if (fingering.thumb === "half") marks.push("pinch");
+ const [hole1, hole2, hole3, hole4, hole5, hole6a, hole6b, hole7a, hole7b] = fingering.holes;
+ if (hole6a !== hole6b) marks.push("half 6");
+ if (hole7a !== hole7b) marks.push("half 7");
+ const lowerRightClosed = hole6a === "closed" || hole6b === "closed" || hole7a === "closed" || hole7b === "closed";
+ if (hole4 === "closed" && hole5 === "open" && lowerRightClosed) marks.push("fork");
+ if (hole1 === "closed" && hole2 === "open" && hole3 === "closed") marks.push("fork");
+ if (fingering.bell) marks.push("cover bell");
+ return marks;
+}
+
+export function fingeringProse(fingering: Fingering): string {
+ const thumb =
+ fingering.thumb === "closed"
+ ? "thumb closed"
+ : fingering.thumb === "half"
+ ? "thumb pinched"
+ : "thumb open";
+ const names = ["1", "2", "3", "4", "5", "6a", "6b", "7a", "7b"];
+ const closed = names.filter((_, index) => fingering.holes[index] === "closed");
+ const holes = closed.length > 0 ? `holes ${closed.join(" ")} closed` : "no front holes closed";
+ const bell = fingering.bell ? ", cover the bell" : "";
+ return `${thumb}, ${holes}${bell}`;
+}
+
+export function germanDiffers(pitch: string): boolean {
+ const baroque = fingeringFor(pitch, "baroque");
+ const german = fingeringFor(pitch, "german");
+ if (!baroque || !german) return false;
+ return fingeringCode(baroque) !== fingeringCode(german);
+}
diff --git a/src/lib/musicxml.ts b/src/lib/musicxml.ts
new file mode 100644
index 0000000..8d7d710
--- /dev/null
+++ b/src/lib/musicxml.ts
@@ -0,0 +1,319 @@
+import { XMLParser } from "fast-xml-parser";
+import { durationLabel } from "@/lib/duration";
+import { parsePitch } from "@/lib/pitch";
+import { newId, type Measure, type Score, type ScoreEvent, type TimeSignature } from "@/lib/score";
+
+type XNode = Record;
+
+export type ParseSuccess = {
+ ok: true;
+ score: Score;
+ warnings: string[];
+};
+
+export type ParseFailure = {
+ ok: false;
+ error: string;
+};
+
+const parser = new XMLParser({
+ preserveOrder: true,
+ ignoreAttributes: false,
+ attributeNamePrefix: "@_",
+ removeNSPrefix: true,
+ trimValues: true,
+});
+
+function isNode(value: unknown): value is XNode {
+ return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function tagOf(node: XNode): string | null {
+ return Object.keys(node).find((key) => key !== ":@" ) ?? null;
+}
+
+function children(node: XNode): XNode[] {
+ const tag = tagOf(node);
+ if (!tag) return [];
+ const value = node[tag];
+ if (!Array.isArray(value)) return [];
+ return value.filter(isNode);
+}
+
+function textOf(node: XNode): string {
+ const tag = tagOf(node);
+ if (!tag) return "";
+ const value = node[tag];
+ if (typeof value === "string" || typeof value === "number") return String(value).trim();
+ if (!Array.isArray(value)) return "";
+ for (const item of value) {
+ if (isNode(item) && "#text" in item && item["#text"] != null) return String(item["#text"]).trim();
+ }
+ return "";
+}
+
+function attrs(node: XNode): Record {
+ const raw = node[":@"];
+ if (!isNode(raw)) return {};
+ const result: Record = {};
+ for (const [key, value] of Object.entries(raw)) result[key.replace(/^@_/, "")] = String(value);
+ return result;
+}
+
+function findChild(nodes: XNode[], name: string): XNode | undefined {
+ return nodes.find((node) => tagOf(node) === name);
+}
+
+function childText(nodes: XNode[], name: string): string | null {
+ const child = findChild(nodes, name);
+ if (!child) return null;
+ const text = textOf(child);
+ return text === "" ? null : text;
+}
+
+function hasTag(nodes: XNode[], name: string): boolean {
+ return nodes.some((node) => tagOf(node) === name);
+}
+
+function findDeep(nodes: XNode[], name: string): XNode | undefined {
+ for (const node of nodes) {
+ if (tagOf(node) === name) return node;
+ const nested = findDeep(children(node), name);
+ if (nested) return nested;
+ }
+ return undefined;
+}
+
+function tieStarts(nodes: XNode[]): boolean {
+ for (const node of nodes) {
+ const tag = tagOf(node);
+ if (tag === "tie" && attrs(node).type === "start") return true;
+ if (tag === "notations") {
+ for (const inner of children(node)) {
+ if (tagOf(inner) === "tied" && attrs(inner).type === "start") return true;
+ }
+ }
+ }
+ return false;
+}
+
+function pitchFrom(noteKids: XNode[]): { name: string; midi: number } | null {
+ const pitch = findChild(noteKids, "pitch");
+ if (!pitch) return null;
+ const kids = children(pitch);
+ const step = childText(kids, "step");
+ const octave = childText(kids, "octave");
+ if (!step || !octave) return null;
+ const alter = Number(childText(kids, "alter") ?? "0");
+ const accidental =
+ alter === 1 ? "#" : alter === -1 ? "b" : alter === 2 ? "##" : alter === -2 ? "bb" : "";
+ if (![0, 1, -1, 2, -2].includes(alter)) return null;
+ const parsed = parsePitch(`${step}${accidental}${octave}`);
+ return parsed ? { name: parsed.name, midi: parsed.midi } : null;
+}
+
+type Candidate = {
+ onset: number;
+ kind: "note" | "rest";
+ midi: number;
+ pitch: string | null;
+ quarters: number;
+ label: string;
+ tied: boolean;
+};
+
+function onsetKey(value: number): number {
+ return Math.round(value * 1000) / 1000;
+}
+
+export function parseMusicXml(xml: string): ParseSuccess | ParseFailure {
+ const cleaned = xml.replace(//gi, "");
+ let root: unknown;
+ try {
+ root = parser.parse(cleaned);
+ } catch {
+ return { ok: false, error: "The recognizer returned text that is not MusicXML." };
+ }
+ if (!Array.isArray(root)) return { ok: false, error: "The recognizer returned text that is not MusicXML." };
+
+ const scoreNode = findDeep(root.filter(isNode), "score-partwise");
+ if (!scoreNode) {
+ return {
+ ok: false,
+ error: "The recognizer did not return a partwise score. No notes were invented.",
+ };
+ }
+
+ const top = children(scoreNode);
+ const work = findChild(top, "work");
+ const title =
+ (work && childText(children(work), "work-title")) ||
+ childText(top, "movement-title") ||
+ "Uploaded page";
+
+ const parts = top.filter((node) => tagOf(node) === "part");
+ if (parts.length === 0) {
+ return { ok: false, error: "The score has no part to read as a lead line." };
+ }
+
+ const warnings: string[] = [];
+ if (parts.length > 1) warnings.push("Only the first part was read. Other parts were left out.");
+
+ let divisions = 1;
+ let timeSignature: TimeSignature = { beats: 4, beatType: 4 };
+ let sawTime = false;
+ let timeChanged = false;
+ let sawLowerStaff = false;
+ let reduced = false;
+ let sawGrace = false;
+ let sawTie = false;
+
+ const measures: Measure[] = [];
+
+ for (const [measureIndex, measureNode] of children(parts[0]).filter((node) => tagOf(node) === "measure").entries()) {
+ let cursor = 0;
+ let lastDuration = 0;
+ const grouped = new Map();
+
+ for (const element of children(measureNode)) {
+ const tag = tagOf(element);
+ if (tag === "attributes") {
+ const kids = children(element);
+ const nextDivisions = childText(kids, "divisions");
+ if (nextDivisions && Number(nextDivisions) > 0) divisions = Number(nextDivisions);
+ const time = findChild(kids, "time");
+ if (time) {
+ const timeKids = children(time);
+ const beats = Number(childText(timeKids, "beats"));
+ const beatType = Number(childText(timeKids, "beat-type"));
+ if (beats > 0 && beatType > 0) {
+ if (!sawTime) {
+ timeSignature = { beats, beatType };
+ sawTime = true;
+ } else if (timeSignature.beats !== beats || timeSignature.beatType !== beatType) {
+ timeChanged = true;
+ }
+ }
+ }
+ continue;
+ }
+ if (tag === "backup" || tag === "forward") {
+ const delta = Number(childText(children(element), "duration") ?? "0");
+ cursor += tag === "backup" ? -delta : delta;
+ continue;
+ }
+ if (tag !== "note") continue;
+
+ const kids = children(element);
+ if (hasTag(kids, "grace")) {
+ sawGrace = true;
+ continue;
+ }
+ const isChord = hasTag(kids, "chord");
+ const duration = Number(childText(kids, "duration") ?? "0");
+ const staff = childText(kids, "staff");
+ if (staff && staff !== "1") {
+ sawLowerStaff = true;
+ if (!isChord) {
+ cursor += duration;
+ lastDuration = duration;
+ }
+ continue;
+ }
+
+ const onset = onsetKey(isChord ? cursor - lastDuration : cursor);
+ if (!isChord) {
+ cursor += duration;
+ lastDuration = duration;
+ }
+
+ const type = childText(kids, "type");
+ const dots = kids.filter((node) => tagOf(node) === "dot").length;
+ const modification = findChild(kids, "time-modification");
+ let tuplet = false;
+ if (modification) {
+ const actual = Number(childText(children(modification), "actual-notes"));
+ const normal = Number(childText(children(modification), "normal-notes"));
+ tuplet = actual === 3 && normal === 2;
+ }
+ const quarters = divisions > 0 ? duration / divisions : 0;
+ const tied = tieStarts(kids);
+ if (tied) sawTie = true;
+
+ if (hasTag(kids, "rest")) {
+ const list = grouped.get(onset) ?? [];
+ list.push({
+ onset,
+ kind: "rest",
+ midi: -1,
+ pitch: null,
+ quarters,
+ label: durationLabel(quarters, type, dots, tuplet),
+ tied: false,
+ });
+ grouped.set(onset, list);
+ continue;
+ }
+
+ const pitch = pitchFrom(kids);
+ if (!pitch) continue;
+ const list = grouped.get(onset) ?? [];
+ list.push({
+ onset,
+ kind: "note",
+ midi: pitch.midi,
+ pitch: pitch.name,
+ quarters,
+ label: durationLabel(quarters, type, dots, tuplet),
+ tied,
+ });
+ grouped.set(onset, list);
+ }
+
+ const events: ScoreEvent[] = [];
+ for (const onset of [...grouped.keys()].sort((a, b) => a - b)) {
+ const candidates = grouped.get(onset) ?? [];
+ const notes = candidates.filter((candidate) => candidate.kind === "note");
+ if (notes.length > 1) reduced = true;
+ const chosen = notes.length > 0 ? notes.reduce((best, note) => (note.midi > best.midi ? note : best)) : candidates[0];
+ if (!chosen || chosen.quarters <= 0) continue;
+ events.push({
+ id: newId("e"),
+ kind: chosen.kind,
+ pitch: chosen.pitch,
+ quarters: chosen.quarters,
+ label: chosen.label,
+ tied: chosen.tied,
+ });
+ }
+
+ measures.push({ id: newId("m"), events });
+ void measureIndex;
+ }
+
+ if (sawLowerStaff) warnings.push("Notes on lower staves were left out. The tab follows the top staff.");
+ if (reduced) warnings.push("Chords and overlapping voices were reduced to the highest note.");
+ if (sawGrace) warnings.push("Grace notes were left out so the beat stays aligned.");
+ if (timeChanged) warnings.push("A later time signature was ignored. The tab uses the first one.");
+ if (sawTie) warnings.push("Tied notes stay separate so the bar lines do not move.");
+
+ const eventCount = measures.reduce((total, measure) => total + measure.events.length, 0);
+ if (eventCount === 0) {
+ return {
+ ok: false,
+ error: "The recognizer finished, but it did not find a lead note or a rest. No notes were invented.",
+ };
+ }
+
+ return {
+ ok: true,
+ warnings,
+ score: {
+ title,
+ attribution: "Read from your image. Correct anything that looks wrong before you play.",
+ timeSignature,
+ measures: measures.length > 0 ? measures : [{ id: newId("m"), events: [] }],
+ origin: "upload",
+ },
+ };
+}
diff --git a/src/lib/pitch.ts b/src/lib/pitch.ts
new file mode 100644
index 0000000..61efb9e
--- /dev/null
+++ b/src/lib/pitch.ts
@@ -0,0 +1,40 @@
+const STEPS: Record = {
+ C: 0,
+ D: 2,
+ E: 4,
+ F: 5,
+ G: 7,
+ A: 9,
+ B: 11,
+};
+
+export type ParsedPitch = {
+ midi: number;
+ name: string;
+};
+
+/** Scientific pitch, concert pitch. C4 is MIDI 60, so soprano low C is C5. */
+export function parsePitch(raw: string): ParsedPitch | null {
+ const match = /^([A-Ga-g])(##|bb|#|b|♯|♭)?(-?\d+)$/.exec(raw.trim());
+ if (!match) return null;
+ const step = match[1].toUpperCase();
+ const accidental = match[2] ?? "";
+ const alter =
+ accidental === "#" || accidental === "♯"
+ ? 1
+ : accidental === "b" || accidental === "♭"
+ ? -1
+ : accidental === "##"
+ ? 2
+ : accidental === "bb"
+ ? -2
+ : 0;
+ const octave = Number(match[3]);
+ if (!Number.isInteger(octave)) return null;
+ const pretty =
+ alter === 1 ? "#" : alter === -1 ? "b" : alter === 2 ? "##" : alter === -2 ? "bb" : "";
+ return {
+ midi: (octave + 1) * 12 + STEPS[step] + alter,
+ name: `${step}${pretty}${octave}`,
+ };
+}
diff --git a/src/lib/recognize.ts b/src/lib/recognize.ts
new file mode 100644
index 0000000..5a7cf1e
--- /dev/null
+++ b/src/lib/recognize.ts
@@ -0,0 +1,201 @@
+import { spawn } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { parseMusicXml } from "@/lib/musicxml";
+import type { Score } from "@/lib/score";
+
+export type RecognizerInfo = {
+ available: boolean;
+ name: string;
+ detail: string;
+};
+
+export type RecognizeSuccess = {
+ ok: true;
+ score: Score;
+ warnings: string[];
+ recognizer: string;
+};
+
+export type RecognizeFailure = {
+ ok: false;
+ error: string;
+ status: number;
+ recognizer: string;
+};
+
+export function resolvePython(): string | null {
+ const fromEnv = process.env.OEMER_PYTHON;
+ if (fromEnv && existsSync(fromEnv)) return fromEnv;
+ return null;
+}
+
+function modelsReady(python: string): boolean {
+ const lib = path.resolve(path.dirname(python), "..", "lib");
+ if (!existsSync(lib)) return false;
+ for (const entry of readdirSync(lib)) {
+ const model = path.join(
+ lib,
+ entry,
+ "site-packages",
+ "oemer",
+ "checkpoints",
+ "unet_big",
+ "model.onnx",
+ );
+ if (existsSync(model)) return true;
+ }
+ return false;
+}
+
+export function recognizerInfo(): RecognizerInfo {
+ const python = resolvePython();
+ if (!python) {
+ return {
+ available: false,
+ name: "oemer",
+ detail:
+ "The local reader (oemer) is not installed. Sample tunes and the note editor still work. No photo is turned into guessed notes.",
+ };
+ }
+ if (!modelsReady(python)) {
+ return {
+ available: false,
+ name: "oemer 0.1.8",
+ detail:
+ "oemer is installed, but its model files are missing, so a photo cannot be read. Sample tunes and the editor still work.",
+ };
+ }
+ return {
+ available: true,
+ name: "oemer 0.1.8",
+ detail:
+ "Photos are read on this computer by oemer. It misses notes. Correct the list; nothing is sent away, and a failed read does not invent notes.",
+ };
+}
+
+function scriptPath(): string {
+ const candidates = [
+ path.join(process.cwd(), "scripts", "run_oemer.py"),
+ path.join(process.cwd(), "..", "scripts", "run_oemer.py"),
+ ];
+ return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+}
+
+function runProcess(
+ command: string,
+ args: string[],
+ timeoutMs: number,
+): Promise<{ code: number; stdout: string; stderr: string }> {
+ return new Promise((resolve, reject) => {
+ const child = spawn(command, args, {
+ env: {
+ ...process.env,
+ MPLBACKEND: "Agg",
+ PYTHONUNBUFFERED: "1",
+ },
+ });
+ let stdout = "";
+ let stderr = "";
+ const timer = setTimeout(() => {
+ child.kill("SIGKILL");
+ reject(new Error("timeout"));
+ }, timeoutMs);
+ child.stdout.setEncoding("utf8");
+ child.stderr.setEncoding("utf8");
+ child.stdout.on("data", (chunk) => {
+ stdout += chunk;
+ });
+ child.stderr.on("data", (chunk) => {
+ stderr += chunk;
+ });
+ child.on("error", (error) => {
+ clearTimeout(timer);
+ reject(error);
+ });
+ child.on("close", (code) => {
+ clearTimeout(timer);
+ resolve({ code: code ?? 1, stdout, stderr });
+ });
+ });
+}
+
+function shortFailure(stderr: string, stdout: string): string {
+ const lines = `${stderr}\n${stdout}`
+ .split("\n")
+ .map((line) => line.trim())
+ .filter(Boolean)
+ .filter((line) => !line.startsWith("MUSICXML="));
+ const errorLine = [...lines].reverse().find((line) => /Error|Exception|assert|too small|could not/i.test(line));
+ const text = errorLine ?? lines.at(-1) ?? "The recognizer stopped without a result.";
+ return text.slice(0, 280);
+}
+
+export async function recognizeImage(file: File): Promise {
+ const info = recognizerInfo();
+ if (!info.available) {
+ return { ok: false, error: info.detail, status: 503, recognizer: info.name };
+ }
+ const python = resolvePython();
+ if (!python) {
+ return { ok: false, error: info.detail, status: 503, recognizer: info.name };
+ }
+
+ const directory = await mkdtemp(path.join(tmpdir(), "recorder-tab-"));
+ try {
+ const inputPath = path.join(directory, "upload.bin");
+ await writeFile(inputPath, Buffer.from(await file.arrayBuffer()));
+ const script = scriptPath();
+ let result: { code: number; stdout: string; stderr: string };
+ try {
+ result = await runProcess(python, [script, inputPath, directory], 240_000);
+ } catch (error) {
+ const timedOut = error instanceof Error && error.message === "timeout";
+ return {
+ ok: false,
+ status: 422,
+ recognizer: info.name,
+ error: timedOut
+ ? "Reading this page took too long and was stopped. No notes were invented. Try a clearer crop of one line, or enter the notes by hand."
+ : "The local reader could not be started. No notes were invented.",
+ };
+ }
+
+ const marker = result.stdout
+ .split("\n")
+ .map((line) => line.trim())
+ .find((line) => line.startsWith("MUSICXML="));
+ if (result.code !== 0 || !marker) {
+ return {
+ ok: false,
+ status: 422,
+ recognizer: info.name,
+ error: `This image could not be read. ${shortFailure(result.stderr, result.stdout)} No notes were invented.`,
+ };
+ }
+
+ const xmlPath = marker.slice("MUSICXML=".length);
+ const xml = await readFile(xmlPath, "utf8");
+ const parsed = parseMusicXml(xml);
+ if (!parsed.ok) {
+ return { ok: false, status: 422, recognizer: info.name, error: parsed.error };
+ }
+
+ const title = file.name.replace(/\.[^.]+$/, "").trim();
+ return {
+ ok: true,
+ recognizer: info.name,
+ warnings: parsed.warnings,
+ score: {
+ ...parsed.score,
+ title: title || parsed.score.title,
+ origin: "upload",
+ attribution: `Read locally by ${info.name}. Correct any wrong pitch or rhythm before you play.`,
+ },
+ };
+ } finally {
+ await rm(directory, { recursive: true, force: true });
+ }
+}
diff --git a/src/lib/samples.ts b/src/lib/samples.ts
new file mode 100644
index 0000000..f8af92c
--- /dev/null
+++ b/src/lib/samples.ts
@@ -0,0 +1,92 @@
+import type { Score, ScoreEvent } from "@/lib/score";
+
+const DURATION: Record = {
+ w: { quarters: 4, label: "whole" },
+ dh: { quarters: 3, label: "dotted half" },
+ h: { quarters: 2, label: "half" },
+ dq: { quarters: 1.5, label: "dotted quarter" },
+ q: { quarters: 1, label: "quarter" },
+ e: { quarters: 0.5, label: "eighth" },
+ s: { quarters: 0.25, label: "sixteenth" },
+};
+
+function events(barId: string, specs: string[]): ScoreEvent[] {
+ return specs.map((spec, index) => {
+ const [token, durationKey = "q"] = spec.split(":");
+ const duration = DURATION[durationKey] ?? DURATION.q;
+ const rest = token === "r";
+ return {
+ id: `${barId}-e${index + 1}`,
+ kind: rest ? "rest" : "note",
+ pitch: rest ? null : token,
+ quarters: duration.quarters,
+ label: duration.label,
+ tied: false,
+ };
+ });
+}
+
+function measures(prefix: string, bars: string[][]) {
+ return bars.map((bar, index) => {
+ const id = `${prefix}-m${index + 1}`;
+ return { id, events: events(id, bar) };
+ });
+}
+
+/** Traditional melody at concert pitch, starting on the soprano’s low C. */
+export const twinkle: Score = {
+ title: "Twinkle, Twinkle, Little Star",
+ attribution: "Traditional, public domain. First verse, concert pitch for soprano in C.",
+ timeSignature: { beats: 4, beatType: 4 },
+ origin: "sample",
+ measures: measures("twinkle", [
+ ["C5", "C5", "G5", "G5"],
+ ["A5", "A5", "G5:h"],
+ ["F5", "F5", "E5", "E5"],
+ ["D5", "D5", "C5:h"],
+ ["G5", "G5", "F5", "F5"],
+ ["E5", "E5", "D5:h"],
+ ["G5", "G5", "F5", "F5"],
+ ["E5", "E5", "D5:h"],
+ ["C5", "C5", "G5", "G5"],
+ ["A5", "A5", "G5:h"],
+ ["F5", "F5", "E5", "E5"],
+ ["D5", "D5", "C5:h"],
+ ]),
+};
+
+/**
+ * Ode to Joy theme in C major at concert pitch.
+ * The symphony states it in D; this is the familiar C-major teaching key,
+ * which sits on the soprano without leaving the first octave.
+ */
+export const odeToJoy: Score = {
+ title: "Ode to Joy",
+ attribution:
+ "Ludwig van Beethoven, public domain. Theme in C major, concert pitch for soprano in C.",
+ timeSignature: { beats: 4, beatType: 4 },
+ origin: "sample",
+ measures: measures("ode", [
+ ["E5", "E5", "F5", "G5"],
+ ["G5", "F5", "E5", "D5"],
+ ["C5", "C5", "D5", "E5"],
+ ["E5:dq", "D5:e", "D5:h"],
+ ["E5", "E5", "F5", "G5"],
+ ["G5", "F5", "E5", "D5"],
+ ["C5", "C5", "D5", "E5"],
+ ["D5:dq", "C5:e", "C5:h"],
+ ]),
+};
+
+export const SAMPLES = [
+ {
+ id: "twinkle",
+ score: twinkle,
+ blurb: "First verse in C. Forked F, half notes, and four-square bars.",
+ },
+ {
+ id: "ode",
+ score: odeToJoy,
+ blurb: "The hymn theme in C, with dotted quarters and held notes.",
+ },
+] as const;
diff --git a/src/lib/score.ts b/src/lib/score.ts
new file mode 100644
index 0000000..fd153b3
--- /dev/null
+++ b/src/lib/score.ts
@@ -0,0 +1,97 @@
+import { formatQuarterLengths, quartersMatch } from "@/lib/duration";
+
+export type TimeSignature = {
+ beats: number;
+ beatType: number;
+};
+
+export type ScoreEvent = {
+ id: string;
+ kind: "note" | "rest";
+ pitch: string | null;
+ quarters: number;
+ label: string;
+ tied: boolean;
+};
+
+export type Measure = {
+ id: string;
+ events: ScoreEvent[];
+};
+
+export type ScoreOrigin = "sample" | "upload" | "blank";
+
+export type Score = {
+ title: string;
+ attribution: string;
+ timeSignature: TimeSignature;
+ measures: Measure[];
+ origin: ScoreOrigin;
+};
+
+export const TIME_SIGNATURES: TimeSignature[] = [
+ { beats: 2, beatType: 4 },
+ { beats: 3, beatType: 4 },
+ { beats: 4, beatType: 4 },
+ { beats: 6, beatType: 8 },
+ { beats: 3, beatType: 8 },
+ { beats: 2, beatType: 2 },
+];
+
+export function newId(prefix: string): string {
+ return `${prefix}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+export function signatureKey(timeSignature: TimeSignature): string {
+ return `${timeSignature.beats}/${timeSignature.beatType}`;
+}
+
+export function parseSignature(key: string): TimeSignature {
+ const [beats, beatType] = key.split("/").map(Number);
+ return { beats, beatType };
+}
+
+export function expectedQuarters(timeSignature: TimeSignature): number {
+ return (timeSignature.beats * 4) / timeSignature.beatType;
+}
+
+export function barStatus(
+ measure: Measure,
+ timeSignature: TimeSignature,
+): { ok: boolean; text: string } {
+ const sum = measure.events.reduce((total, event) => total + event.quarters, 0);
+ const expected = expectedQuarters(timeSignature);
+ const signature = signatureKey(timeSignature);
+ if (quartersMatch(sum, expected)) {
+ return { ok: true, text: `${signature} · ${formatQuarterLengths(sum)}` };
+ }
+ return {
+ ok: false,
+ text: `${formatQuarterLengths(sum)} in this bar; ${signature} holds ${formatQuarterLengths(expected)}.`,
+ };
+}
+
+export function startBeats(events: ScoreEvent[], timeSignature: TimeSignature): number[] {
+ const quartersPerBeat = 4 / timeSignature.beatType;
+ let cursor = 0;
+ return events.map((event) => {
+ const beat = cursor / quartersPerBeat + 1;
+ cursor += event.quarters;
+ return beat;
+ });
+}
+
+export function formatBeat(beat: number): string {
+ const rounded = Math.round(beat * 100) / 100;
+ return Number.isInteger(rounded) ? String(rounded) : String(rounded);
+}
+
+export function blankScore(): Score {
+ return {
+ title: "Untitled line",
+ attribution: "Hand-entered lead line. Add notes, then read the tabs.",
+ timeSignature: { beats: 4, beatType: 4 },
+ origin: "blank",
+ measures: [{ id: newId("m"), events: [] }],
+ };
+}
diff --git a/src/lib/text-tab.ts b/src/lib/text-tab.ts
new file mode 100644
index 0000000..c07546d
--- /dev/null
+++ b/src/lib/text-tab.ts
@@ -0,0 +1,38 @@
+import { fingeringCode, fingeringFor, type FingeringSystem } from "@/lib/fingering";
+import { formatBeat, signatureKey, startBeats, type Score } from "@/lib/score";
+
+export function formatTextTab(score: Score, system: FingeringSystem): string {
+ const lines: string[] = [
+ score.title,
+ "Soprano recorder in C · concert pitch · sounds as written",
+ system === "baroque"
+ ? "Fingering: Baroque (English), Dolmetsch Online chart for recorders in C"
+ : "Fingering: German on F, F♯, and B♭; other notes stay on the Dolmetsch Baroque chart",
+ `Time: ${signatureKey(score.timeSignature)}`,
+ "",
+ ];
+
+ score.measures.forEach((measure, measureIndex) => {
+ const beats = startBeats(measure.events, score.timeSignature);
+ lines.push(`Bar ${measureIndex + 1}`);
+ if (measure.events.length === 0) lines.push(" (empty)");
+ measure.events.forEach((event, eventIndex) => {
+ const beat = formatBeat(beats[eventIndex] ?? 1).padEnd(4, " ");
+ const name = (event.kind === "rest" ? "rest" : (event.pitch ?? "?")).padEnd(6, " ");
+ const duration = event.label.padEnd(16, " ");
+ let fingers = "—";
+ if (event.kind === "note" && event.pitch) {
+ const fingering = fingeringFor(event.pitch, system);
+ fingers = fingering ? fingeringCode(fingering) : "outside C5–D7 chart";
+ }
+ const tie = event.tied ? " tie" : "";
+ lines.push(` beat ${beat} ${name} ${duration} ${fingers}${tie}`);
+ });
+ lines.push("");
+ });
+
+ lines.push("Legend: 0 closed thumb, x pinched thumb, - open thumb.");
+ lines.push("Digits are closed holes. 6a without 6b, or 7a without 7b, is a half-hole.");
+ lines.push("bell means cover the foot. Notes outside C5–D7 have no fingering.");
+ return lines.join("\n");
+}
diff --git a/src/lib/utils.ts b/src/lib/utils.ts
new file mode 100644
index 0000000..f815ded
--- /dev/null
+++ b/src/lib/utils.ts
@@ -0,0 +1 @@
+export { cn } from "cn"
diff --git a/tests/converter.test.ts b/tests/converter.test.ts
new file mode 100644
index 0000000..7952f9f
--- /dev/null
+++ b/tests/converter.test.ts
@@ -0,0 +1,125 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { fingeringCode, fingeringFor, fingeringMarks, CHART_NOTES } from "@/lib/fingering";
+import { parseMusicXml } from "@/lib/musicxml";
+import { parsePitch } from "@/lib/pitch";
+import { barStatus, expectedQuarters } from "@/lib/score";
+import { odeToJoy, twinkle } from "@/lib/samples";
+import { formatTextTab } from "@/lib/text-tab";
+
+const BAROQUE: Record = {
+ C5: "0 1 2 3 4 5 6a 6b 7a 7b",
+ "C#5": "0 1 2 3 4 5 6a 6b 7a",
+ D5: "0 1 2 3 4 5 6a 6b",
+ Eb5: "0 1 2 3 4 5 6a",
+ E5: "0 1 2 3 4 5",
+ F5: "0 1 2 3 4 6a 6b 7a 7b",
+ "F#5": "0 1 2 3 5 6a 6b",
+ G5: "0 1 2 3",
+ Ab5: "0 1 2 4 5 6a",
+ A5: "0 1 2",
+ Bb5: "0 1 3 4",
+ B5: "0 1",
+ C6: "0 2",
+ "C#6": "- 1 2",
+ D6: "- 2",
+ Eb6: "- 2 3 4 5 6a 6b",
+ E6: "x 1 2 3 4 5",
+ F6: "x 1 2 3 4 6a 6b",
+ "F#6": "x 1 2 3 5",
+ G6: "x 1 2 3",
+ Ab6: "x 1 2 4",
+ A6: "x 1 2",
+ Bb6: "x 1 2 5 6a 6b",
+ B6: "x 1 2 4 5",
+ C7: "x 1 4 5",
+ "C#7": "x 1 3 4 6a 6b bell",
+ D7: "x 1 3 4 6a 6b",
+};
+
+describe("soprano chart", () => {
+ it("covers every semitone from C5 through D7 and no others", () => {
+ const midis = CHART_NOTES.map((note) => parsePitch(note)?.midi);
+ expect(midis).toEqual(Array.from({ length: 27 }, (_, index) => 72 + index));
+ });
+
+ it("matches the Dolmetsch first-choice Baroque rows", () => {
+ for (const [note, code] of Object.entries(BAROQUE)) {
+ const fingering = fingeringFor(note, "baroque");
+ expect(fingering, note).not.toBeNull();
+ expect(fingeringCode(fingering!), note).toBe(code);
+ }
+ });
+
+ it("marks fork, half-holes, pinch, and bell without guessing outside the range", () => {
+ expect(fingeringMarks(fingeringFor("F5", "baroque")!)).toContain("fork");
+ expect(fingeringMarks(fingeringFor("Eb5", "baroque")!)).toContain("half 6");
+ expect(fingeringMarks(fingeringFor("C#5", "baroque")!)).toContain("half 7");
+ expect(fingeringMarks(fingeringFor("E6", "baroque")!)).toContain("pinch");
+ expect(fingeringMarks(fingeringFor("C#7", "baroque")!)).toContain("cover bell");
+ expect(fingeringFor("B4", "baroque")).toBeNull();
+ expect(fingeringFor("E7", "baroque")).toBeNull();
+ expect(fingeringCode(fingeringFor("Db5", "baroque")!)).toBe(BAROQUE["C#5"]);
+ });
+
+ it("applies only the cited German changes", () => {
+ expect(fingeringCode(fingeringFor("F5", "german")!)).toBe("0 1 2 3 4");
+ expect(fingeringCode(fingeringFor("F#5", "german")!)).toBe("0 1 2 3 5 6a 6b 7a");
+ expect(fingeringCode(fingeringFor("Bb5", "german")!)).toBe("0 1 3 4 6a 6b");
+ expect(fingeringCode(fingeringFor("F6", "german")!)).toBe("x 1 2 3 4");
+ expect(fingeringCode(fingeringFor("G5", "german")!)).toBe(fingeringCode(fingeringFor("G5", "baroque")!));
+ expect(fingeringCode(fingeringFor("E6", "german")!)).toBe(fingeringCode(fingeringFor("E6", "baroque")!));
+ });
+});
+
+describe("sample melodies", () => {
+ it("keeps Twinkle in 4/4 with forked F and full bars", () => {
+ expect(twinkle.measures).toHaveLength(12);
+ expect(twinkle.measures[0].events.map((event) => event.pitch)).toEqual(["C5", "C5", "G5", "G5"]);
+ expect(twinkle.measures[2].events[0].pitch).toBe("F5");
+ for (const measure of twinkle.measures) {
+ expect(barStatus(measure, twinkle.timeSignature).ok).toBe(true);
+ }
+ expect(formatTextTab(twinkle, "baroque")).toContain("0 1 2 3 4 6a 6b 7a 7b");
+ });
+
+ it("keeps Ode to Joy dotted rhythm inside the bar", () => {
+ expect(expectedQuarters(odeToJoy.timeSignature)).toBe(4);
+ const bar = odeToJoy.measures[3];
+ expect(bar.events.map((event) => event.label)).toEqual(["dotted quarter", "eighth", "half"]);
+ expect(bar.events.reduce((sum, event) => sum + event.quarters, 0)).toBe(4);
+ for (const measure of odeToJoy.measures) {
+ expect(barStatus(measure, odeToJoy.timeSignature).ok).toBe(true);
+ }
+ });
+});
+
+describe("lead-line MusicXML", () => {
+ const xml = readFileSync(path.join(__dirname, "fixtures", "lead.musicxml"), "utf8");
+ const parsed = parseMusicXml(xml);
+
+ it("keeps timing, the top note, and the top staff", () => {
+ expect(parsed.ok).toBe(true);
+ if (!parsed.ok) return;
+ expect(parsed.score.title).toBe("Probe");
+ expect(parsed.score.timeSignature).toEqual({ beats: 4, beatType: 4 });
+ const [first, second, third, fourth] = parsed.score.measures;
+ expect(first.events.map((event) => [event.kind, event.pitch, event.label])).toEqual([
+ ["note", "E5", "quarter"],
+ ["rest", null, "quarter"],
+ ["note", "G5", "dotted quarter"],
+ ["note", "A4", "eighth"],
+ ]);
+ expect(second.events.map((event) => [event.pitch, event.label, event.tied])).toEqual([
+ ["E5", "half", false],
+ [null, "half", false],
+ ]);
+ expect(third.events.map((event) => event.pitch)).toEqual(["G5"]);
+ expect(fourth.events.map((event) => event.pitch)).toEqual(["C6", "D6"]);
+ expect(parsed.warnings.join(" ")).toMatch(/first part/);
+ expect(parsed.warnings.join(" ")).toMatch(/lower staves/);
+ expect(parsed.warnings.join(" ")).toMatch(/highest note/);
+ expect(parsed.warnings.join(" ")).toMatch(/Grace notes/);
+ });
+});
diff --git a/tests/fixtures/lead.musicxml b/tests/fixtures/lead.musicxml
new file mode 100644
index 0000000..3158c4e
--- /dev/null
+++ b/tests/fixtures/lead.musicxml
@@ -0,0 +1,113 @@
+
+
+ Probe
+ Lead Other
+
+
+
+ 2
+ 4 4
+
+ E 5 2
+ quarter
+
+
+ 2
+ quarter
+
+
+ G 5 3
+ quarter
+
+
+ A 4 1
+ eighth
+
+
+
+
+ C 5 4
+ half
+
+
+ E 5 4
+ half
+
+
+ 4
+ half
+
+
+
+
+ F 5 eighth
+
+
+ G 5 2
+ 1
+ 1
+ quarter
+
+
+ C 4 2
+ 2
+ 2
+ quarter
+
+
+
+
+ C 6 2
+ 1
+ quarter
+
+
+ D 6 2
+ 1
+ quarter
+
+ 4
+ C 5 2
+ 2
+ quarter
+
+
+ D 5 2
+ 2
+ quarter
+
+
+
+
+
+
+ C 3 2
+ quarter
+
+
+
+
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000..cf9c65d
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,34 @@
+{
+ "compilerOptions": {
+ "target": "ES2017",
+ "lib": ["dom", "dom.iterable", "esnext"],
+ "allowJs": true,
+ "skipLibCheck": true,
+ "strict": true,
+ "noEmit": true,
+ "esModuleInterop": true,
+ "module": "esnext",
+ "moduleResolution": "bundler",
+ "resolveJsonModule": true,
+ "isolatedModules": true,
+ "jsx": "react-jsx",
+ "incremental": true,
+ "plugins": [
+ {
+ "name": "next"
+ }
+ ],
+ "paths": {
+ "@/*": ["./src/*"]
+ }
+ },
+ "include": [
+ "next-env.d.ts",
+ "**/*.ts",
+ "**/*.tsx",
+ ".next/types/**/*.ts",
+ ".next/dev/types/**/*.ts",
+ "**/*.mts"
+ ],
+ "exclude": ["node_modules"]
+}
diff --git a/vitest.config.ts b/vitest.config.ts
new file mode 100644
index 0000000..99b65f0
--- /dev/null
+++ b/vitest.config.ts
@@ -0,0 +1,13 @@
+import path from "node:path";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+ test: {
+ include: ["tests/**/*.test.ts"],
+ },
+ resolve: {
+ alias: {
+ "@": path.resolve(__dirname, "src"),
+ },
+ },
+});