@pepperhorn/chordl-core 0.3.4 → 0.4.0

package/dist/index.js

@@ -1,37 +1,41 @@
-export { computeKeyboard, computeSvgDimensions } from "./engine/keyboard-layout";
-export { mapHighlights, normalizeNote } from "./engine/highlight-mapper";
-export { FLAT_TO_SHARP, SHARP_TO_FLAT, FLAT_KEYS, normalizeToSharps, spellForKey, spellWithPreference, PC_SEMITONES, MIDI_A3, assignAscendingOctaves, } from "./engine/note-spelling";
-export { autoFingering, assignFingering } from "./engine/auto-fingering";
-export { scaleAutoFingering } from "./engine/scale-fingering";
-export { computeStaffLayout } from "./engine/staff-layout";
-export { getDefaultGlyphs, setDefaultGlyphs, BRAVURA_GLYPHS, PETALUMA_GLYPHS } from "./engine/staff-glyphs";
-export { STAFF_LINE_SPACING, HALF_STAFF_SPACING, STAFF_WIDTH, CLEF_AREA_WIDTH, NOTE_COLUMN_X, NOTE_HEAD_RX, ACCIDENTAL_OFFSET, LEDGER_LINE_EXTEND, LEDGER_LINE_STROKE, STAFF_GAP, STAFF_TOP_MARGIN, STAFF_BOTTOM_MARGIN, STAFF_LINE_STROKE, BRACE_WIDTH, SECOND_OFFSET, ACCIDENTAL_COL_WIDTH, } from "./engine/staff-constants";
-export { WHITE_KEY_WIDTH, WHITE_KEY_WIDTH_EXACT, WHITE_KEY_HEIGHT_COMPACT, WHITE_KEY_HEIGHT_EXACT, WHITE_KEY_RY, BLACK_KEY_WIDTH, BLACK_KEY_WIDTH_EXACT, BLACK_KEY_HEIGHT_COMPACT, BLACK_KEY_HEIGHT_EXACT, BLACK_KEY_RY, BLACK_KEY_OFFSETS, BLACK_KEY_OFFSETS_EXACT, WHITE_NOTES_WITH_SHARPS, WHITE_NOTE_ORDER, DEFAULT_WHITE_FILL, DEFAULT_BLACK_FILL, DEFAULT_STROKE, DEFAULT_STROKE_WIDTH, } from "./engine/svg-constants";
-export { parseChordDescription } from "./parser/natural-language";
-export { isProgressionRequest, parseProgressionRequest } from "./parser/progression-parser";
-export { resolveChord } from "./resolver/chord-resolver";
-export { calculateLayout, whiteIdxHasSharp } from "./resolver/auto-layout";
-export { MAX_EXAMPLES, ENABLE_CHORD_LOGGING } from "./config";
+export { computeKeyboard, computeSvgDimensions } from "./engine/keyboard-layout.js";
+export { mapHighlights, normalizeNote } from "./engine/highlight-mapper.js";
+export { FLAT_TO_SHARP, SHARP_TO_FLAT, FLAT_KEYS, normalizeToSharps, spellForKey, spellWithPreference, PC_SEMITONES, MIDI_A3, assignAscendingOctaves, } from "./engine/note-spelling.js";
+export { autoFingering, assignFingering } from "./engine/auto-fingering.js";
+export { scaleAutoFingering } from "./engine/scale-fingering.js";
+export { computeStaffLayout } from "./engine/staff-layout.js";
+export { buildMei } from "./engine/mei-builder.js";
+export { getDefaultGlyphs, setDefaultGlyphs, BRAVURA_GLYPHS, PETALUMA_GLYPHS } from "./engine/staff-glyphs.js";
+export { STAFF_LINE_SPACING, HALF_STAFF_SPACING, STAFF_WIDTH, CLEF_AREA_WIDTH, NOTE_COLUMN_X, NOTE_HEAD_RX, ACCIDENTAL_OFFSET, LEDGER_LINE_EXTEND, LEDGER_LINE_STROKE, STAFF_GAP, STAFF_TOP_MARGIN, STAFF_BOTTOM_MARGIN, STAFF_LINE_STROKE, BRACE_WIDTH, SECOND_OFFSET, ACCIDENTAL_COL_WIDTH, } from "./engine/staff-constants.js";
+export { WHITE_KEY_WIDTH, WHITE_KEY_WIDTH_EXACT, WHITE_KEY_HEIGHT_COMPACT, WHITE_KEY_HEIGHT_EXACT, WHITE_KEY_RY, BLACK_KEY_WIDTH, BLACK_KEY_WIDTH_EXACT, BLACK_KEY_HEIGHT_COMPACT, BLACK_KEY_HEIGHT_EXACT, BLACK_KEY_RY, BLACK_KEY_OFFSETS, BLACK_KEY_OFFSETS_EXACT, WHITE_NOTES_WITH_SHARPS, WHITE_NOTE_ORDER, DEFAULT_WHITE_FILL, DEFAULT_BLACK_FILL, DEFAULT_STROKE, DEFAULT_STROKE_WIDTH, } from "./engine/svg-constants.js";
+export { parseChordDescription } from "./parser/natural-language.js";
+export { isProgressionRequest, parseProgressionRequest } from "./parser/progression-parser.js";
+export { resolveChord } from "./resolver/chord-resolver.js";
+export { calculateLayout, whiteIdxHasSharp } from "./resolver/auto-layout.js";
+export { MAX_EXAMPLES, ENABLE_CHORD_LOGGING } from "./config.js";
 // Progression
-export { resolveProgression, tokenizeProgression } from "./progression/roman-numeral";
-export { FORM_TEMPLATES, findTemplate } from "./progression/form-templates";
-export { resolveProgressionRequest } from "./progression/progression-resolver";
+export { resolveProgression, tokenizeProgression } from "./progression/roman-numeral.js";
+export { FORM_TEMPLATES, findTemplate } from "./progression/form-templates.js";
+export { resolveProgressionRequest } from "./progression/progression-resolver.js";
 // Audio
-export { generateMidiFile, downloadMidi } from "./audio/midi-export";
+export { generateMidiFile, downloadMidi } from "./audio/midi-export.js";
 // Logging
-export { logChordRequest, LOG_SCHEMA_VERSION } from "./logging";
+export { logChordRequest, LOG_SCHEMA_VERSION } from "./logging.js";
 // Theory
-export { classifyTones, parseInterval, minimalVoicing, dropOrder } from "./theory/chord-tones";
-export { intervalToDegreeLabel, degreesForIntervals } from "./theory/degree-labels";
+export { classifyTones, parseInterval, minimalVoicing, dropOrder } from "./theory/chord-tones.js";
+export { intervalToDegreeLabel, degreesForIntervals, degreeLabelsForNotes } from "./theory/degree-labels.js";
 // Scale resolver
-export { resolveScale } from "./resolver/scale-resolver";
+export { resolveScale } from "./resolver/scale-resolver.js";
 // Themes
-export { getTheme, resolveTheme } from "./themes";
-export { CRF_PITCH_PALETTE, formatCmyk } from "./themes/crf";
+export { getTheme, resolveTheme } from "./themes/index.js";
+export { CRF_PITCH_PALETTE, formatCmyk } from "./themes/crf.js";
 // Pipeline
-export { processChordRequest } from "./pipeline";
+export { processChordRequest } from "./pipeline.js";
 // ChordSheet
-export { resolveDefaults, chordRef, SYSTEM_DEFAULTS } from "./chord-sheet/defaults";
-export { CHORD_SHEET_SCHEMA_VERSION, validateVersion } from "./chord-sheet/schema";
-export { encodeChordSheet, decodeChordSheet } from "./chord-sheet/codec";
+export { resolveDefaults, chordRef, SYSTEM_DEFAULTS } from "./chord-sheet/defaults.js";
+export { CHORD_SHEET_SCHEMA_VERSION, validateVersion } from "./chord-sheet/schema.js";
+export { encodeChordSheet, decodeChordSheet } from "./chord-sheet/codec.js";
+// Hand Constraints
+export { midiOf, placeAscending, spanOf, constrainVoicing } from "./theory/hand-constraints.js";
+export { generateConstrainedVariants } from "./theory/constrained-variants.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/parser/natural-language.d.ts

@@ -1,4 +1,4 @@
-import type { ParsedChordRequest } from "../types";
+import type { ParsedChordRequest } from "../types.js";
 /**
  * Extract modifiers first (format, inversion, bass, style, etc.) using
  * dedicated regexes, then strip ALL matched patterns plus filler words

package/dist/parser/natural-language.js

@@ -1,8 +1,45 @@
-// "a"/"an" are excluded when immediately followed by '#', '/', or end-of-string —
-// those are the only non-word-char continuations a real chord root can have
-// (e.g. bare "A", "A#dim", "A/C#"); any word-char continuation (e.g. "Adim",
-// "Am7") already fails the trailing \b below, so this doesn't affect them.
-const FILLER_WORDS = /\b(show\s+me|draw|display|render|please|a(?![#/]|$)|an(?![#/]|$)|the|with|that|this|me|of)\b/gi;
+import { resolveChord } from "../resolver/chord-resolver.js";
+// Filler runs in two passes, and the order is load-bearing.
+//
+// The articles "a"/"an" are also the note A, and by the time filler is stripped
+// every modifier has already been cut out — so "A with note names" arrives as
+// "A ", and so does "a compact". The residual cannot tell them apart, because
+// the article's own noun is one of the things that was deleted.
+//
+// So the article pass decides on evidence the stripping cannot destroy: the
+// character after it, the capital letter the user typed, and where the token
+// sat in the original input. See `stripArticles`.
+const FILLER_WORDS = /\b(show\s+me|draw|display|render|please|the|with|that|this|me|of)\b/gi;
+const ARTICLE_RE = /\b(an?)\b/gi;
+/** An article at the very end of the *original* input is the note A: "a", "an A". */
+const ARTICLE_AT_INPUT_END = /\ban?(?=[#/]|\s*$)/i;
+/**
+ * Remove English articles without eating the note A.
+ *
+ * Three things say "this is the note, not an article", none of which an earlier
+ * `.replace` can have invented:
+ *
+ *  - what follows is `#` or `/` — only a root can be ("A#dim", "A/C#");
+ *  - the token is a capital `A`, which is how a chord is written and not how an
+ *    article is ("A minor", "A with note names", "A in second inversion");
+ *  - the article ends the original input ("a", "show me an A").
+ *
+ * Anything else is an article, including one left trailing because its noun was
+ * stripped — "in a compact layout" must not resolve to the chord A.
+ */
+function stripArticles(text, input) {
+    const bareArticleAtEnd = ARTICLE_AT_INPUT_END.test(input);
+    return text.replace(ARTICLE_RE, (token, _g, offset, whole) => {
+        const rest = whole.slice(offset + token.length);
+        if (/^[#/]/.test(rest))
+            return token;
+        if (token === "A")
+            return token;
+        if (/^\s*$/.test(rest) && bareArticleAtEnd)
+            return token;
+        return "";
+    });
+}
 const FORMAT_RE = /\b(compact|exact|full)\b/i;
 const FORMAT_FULL_RE = /\bfull\s+(?:layout|height|size|keys?)\b/i;
 // "size 80" / "size 80%" / "size 0.8" / "size xl" / "keys xl"
@@ -55,7 +92,7 @@ const FINGERING_RE = /(?:with\s+)?finger(?:ing|s)?\s+([\dxX\-](?:[,\s\-]*[\dxX\-
 const VALID_FINGERING = new Set(["0", "1", "2", "3", "4", "5", "-", "x"]);
 // "custom fingering "A0,A1,A2"" / "fingering "G3-G0-E1"" / "fingering xl "1-2-3"" / "fingering "1-2-3" 2xl"
 // Quoted strings after "fingering" or "custom fingering" are treated as free-form labels.
-const CUSTOM_FINGERING_RE = /(?:with\s+)?(?:custom\s+)?finger(?:ing|s)?\s+(?:(?:in\s+)?(base|lg|xl|2xl)\s+)?[""]([^""]+)[""](?:\s+(?:in\s+)?(base|lg|xl|2xl))?/i;
+const CUSTOM_FINGERING_RE = /(?:with\s+)?(?:custom\s+)?finger(?:ing|s)?\s+(?:(?:in\s+)?(base|lg|xl|2xl)\s+)?["“”']([^"“”']+)["“”'](?:\s+(?:in\s+)?(base|lg|xl|2xl))?/i;
 // "with fingerings" / "show fingering" / "with fingering in xl" / "fingering 2xl" (no explicit numbers → auto)
 // Negative lookahead: don't match when followed by digits (explicit fingering like "1 2 3 5")
 const AUTO_FINGERING_RE = /(?:with\s+)?(?:show\s+)?finger(?:ings?|s)?(?:\s+(?:in\s+)?(base|lg|xl|2xl)|\s+(base|lg|xl|2xl))?(?!\s+\d)(?:\s|$)/i;
@@ -73,10 +110,34 @@ const UNAMBIGUOUS_SCALE_TYPES = [
     "major\\s+pentatonic", "minor\\s+pentatonic", "pentatonic",
     "blues", "whole\\s+tone", "bebop", "diminished",
 ];
-// Scale patterns: "D major scale", "C blues", "A dorian", etc.
+// Scale patterns: "D major scale", "C blues", "A dorian", "Dm harmonic minor".
 // For "major"/"minor" alone, require the trailing word "scale" to avoid chord collision.
-const SCALE_UNAMBIGUOUS_RE = new RegExp(`([A-Ga-g][#b]?)\\s+(${UNAMBIGUOUS_SCALE_TYPES.join("|")})(?:\\s+scale)?`, "i");
-const SCALE_EXPLICIT_RE = /([A-Ga-g][#b]?)\s+(major|minor)\s+scale/i;
+//
+// The root must not be preceded by a letter, or the trailing "c" of
+// "harmonic"/"melodic" is read as a root note and "dm harmonic minor" resolves
+// to C minor. An optional chord-quality marker may sit between the root and the
+// scale type, so shorthand roots ("dm", "f#m", "dmaj") work the same as bare
+// ones — the named scale type wins, the marker is only there to be absorbed.
+const ROOT = "(?<![A-Za-z#b])([A-Ga-g][#b]?)";
+const QUALITY_MARKER = "(?:\\s*(?:maj|min|m|M)\\b)?";
+const SCALE_UNAMBIGUOUS_RE = new RegExp(`${ROOT}${QUALITY_MARKER}\\s+(${UNAMBIGUOUS_SCALE_TYPES.join("|")})(?:\\s+scale)?`, "i");
+const SCALE_EXPLICIT_RE = new RegExp(`${ROOT}${QUALITY_MARKER}\\s+(major|minor)\\s+scale`, "i");
+// Chord-shorthand scales: "dm scale", "d maj scale", "dmaj scale", "d scale".
+// Only the major/minor markers — anything richer stays a chord. The word
+// "scale" is required, so a bare "Dm" is still a chord.
+// The quality marker is matched case-insensitively but read case-sensitively,
+// since "M" means major and "m" means minor.
+const SCALE_SHORTHAND_RE = /(?<![A-Za-z#b])([A-Ga-g][#b]?)\s*(major|maj|minor|min|M|m)?\s+scale\b/i;
+/** Resolve a shorthand quality marker to a scale type. Absent marker = major. */
+function shorthandScaleType(marker) {
+    if (!marker)
+        return "major";
+    if (marker === "M")
+        return "major";
+    if (marker === "m")
+        return "minor";
+    return marker.toLowerCase().startsWith("min") ? "minor" : "major";
+}
 // "ascending" / "descending" for melodic minor
 const DIRECTION_RE = /\b(ascending|descending)\b/i;
 // "in N octaves" / "N octaves" — works for both scales and arpeggios
@@ -84,7 +145,17 @@ const OCTAVES_RE = /\b(?:in\s+)?(\d+)\s+octaves?\b/i;
 // "degrees" anywhere — combined with note names if present, standalone otherwise.
 // The literal word "degree(s)" isn't used by any other parser rule
 // (bass-degree / starting-degree use "5th", "9th", etc.), so a broad match is safe.
-const DEGREES_KEYWORD_RE = /\bdegrees?(?:\s+(?:in\s+)?(base|lg|xl|2xl))?\b/i;
+/*
+ * Two forms, because only one of them is unambiguous.
+ *
+ * "degrees in lg" names the degrees' own size and always keeps it. "degrees lg"
+ * is a bare size between two keywords, and NOTE_NAMES_RE accepts exactly that
+ * shape in front of its own keyword ("lg note names") — so in "degrees 2xl note
+ * names" the size belongs to what follows it, not to what precedes it. Without
+ * the lookahead the degrees clause swallowed it and the note names silently
+ * fell back to the default.
+ */
+const DEGREES_KEYWORD_RE = /\bdegrees?(?:\s+(?:in\s+(base|lg|xl|2xl)|(base|lg|xl|2xl)(?!\s+(?:midi\s+)?note\s*names?)))?\b/i;
 // "with heading" / "with a heading" / "show heading"
 const HEADING_RE = /\b(?:with\s+)?(?:a\s+)?(?:show\s+)?heading\b/i;
 // All recognized hand/clef phrases — long forms before shorthand to ensure
@@ -93,10 +164,16 @@ const HAND_CLEF_PATTERN = "left\\s+hand|right\\s+hand|bottom\\s+hand|top\\s+hand
 // 2+ note tokens separated by spaces/commas/dashes; "and" allowed between tokens.
 // Single-letter notes (A-G) plus optional accidental (#/b) and optional single-digit octave.
 const NOTE_LIST_PATTERN = "[A-Ga-g][#b]?\\d?(?:[\\s,\\-]+(?:and\\s+)?[A-Ga-g][#b]?\\d?)+";
-// "with notes C E G" / "notes E4 G4 C5" — optional trailing "in <hand|clef>".
-const NOTES_GROUP_RE = new RegExp(`(?:with\\s+|and\\s+)?notes\\s+([A-Ga-g][#b]?\\d?\\b(?:[\\s,\\-]+[A-Ga-g][#b]?\\d?\\b)*)(?:\\s+in\\s+(?:the\\s+)?(${HAND_CLEF_PATTERN}))?`, "gi");
+// After the explicit "notes" keyword, a token may be a run-together sequence
+// of notes with no separators ("cdefgabc", "EbGbBb", "E4G4C5"). The trailing
+// lookahead stops the run at any non-note word ("and", "in", "with", ...)
+// while still allowing a run to end in an accidental ("C#").
+const NOTE_RUN_PATTERN = "(?:[A-Ga-g][#b]?\\d?)+(?![A-Za-z0-9])";
+// "with notes C E G" / "notes E4 G4 C5" / "notes cdefgabc" — optional
+// trailing "in <hand|clef>".
+const NOTES_GROUP_RE = new RegExp(`(?:with\\s+|and\\s+)?notes\\s+(${NOTE_RUN_PATTERN}(?:[\\s,\\-]+${NOTE_RUN_PATTERN})*)(?:\\s+in\\s+(?:the\\s+)?(${HAND_CLEF_PATTERN}))?`, "gi");
 // "notes in lh Eb Gb Bb" / "notes in the right hand D F A" — prefix form.
-const NOTES_GROUP_PREFIX_RE = new RegExp(`(?:with\\s+|and\\s+)?notes\\s+in\\s+(?:the\\s+)?(${HAND_CLEF_PATTERN})\\s+([A-Ga-g][#b]?\\d?\\b(?:[\\s,\\-]+[A-Ga-g][#b]?\\d?\\b)*)`, "gi");
+const NOTES_GROUP_PREFIX_RE = new RegExp(`(?:with\\s+|and\\s+)?notes\\s+in\\s+(?:the\\s+)?(${HAND_CLEF_PATTERN})\\s+(${NOTE_RUN_PATTERN}(?:[\\s,\\-]+${NOTE_RUN_PATTERN})*)`, "gi");
 // "lh Eb Gb Bb" / "lh: Eb Gb Bb" / "left Eb Gb Bb" / "bass clef C E G"
 // Hand keyword first, no "notes" word. Optional colon between hand and notes.
 const HAND_PREFIX_BARE_RE = new RegExp(`\\b(${HAND_CLEF_PATTERN})\\s*(?::\\s*|\\s+)(${NOTE_LIST_PATTERN})`, "gi");
@@ -114,6 +191,34 @@ const SINGLE_NOTE_PATTERN = "[A-Ga-g][#b]?";
 const HAND_PREFIX_SINGLE_RE = new RegExp(`\\b(${HAND_CLEF_PATTERN})\\s*(?::\\s*|\\s+)(${SINGLE_NOTE_PATTERN})(?=[\\s,;]|$)`, "gi");
 // "Bb in lh" / "Bb lh" / "(Bb) lh" — single bare note + hand.
 const NOTE_BARE_HAND_SINGLE_RE = new RegExp(`\\(?\\b(${SINGLE_NOTE_PATTERN})\\b\\)?\\s*(?:in\\s+(?:the\\s+)?)?(${HAND_CLEF_PATTERN})\\b`, "gi");
+// A chord symbol following a hand keyword: "rh Cmaj7", "lh: Bbm7b5",
+// "left hand Am", "bass clef G7/B". Deliberately permissive — the token is
+// validated by actually resolving it as a chord, so junk never becomes a group.
+const CHORD_TOKEN_PATTERN = "[A-Ga-g][#b]?[A-Za-z0-9#b\\u00b0\\u00f8+\\-/]*";
+// "rh Cmaj7 lh Dm7" — hand keyword + chord symbol(s). The trailing group
+// captures any further chord tokens so "rh Cmaj7 Dm7" can drop the second one:
+// only the first chord after a hand keyword is used.
+const HAND_PREFIX_CHORD_RE = new RegExp(`\\b(${HAND_CLEF_PATTERN})\\s*(?::\\s*|\\s+)(${CHORD_TOKEN_PATTERN})((?:\\s+${CHORD_TOKEN_PATTERN})*)`, "gi");
+// A plain pitch class ("C", "Eb") — the single-note pass already claims those.
+// Tokens carrying a digit ("G7", "C9") read as chords here, matching how
+// "G7 in lh" / "Bb7 in lh" are treated elsewhere in this parser; an
+// octave-qualified note needs the explicit "notes" keyword ("notes G7 in lh").
+const BARE_NOTE_TOKEN_RE = /^[A-Ga-g][#b]?$/;
+/**
+ * Resolve a token as a chord symbol, or undefined when it isn't one.
+ * Bare pitches are rejected so "lh Bb" stays a single-note assignment.
+ */
+function chordTokenNotes(token) {
+    if (BARE_NOTE_TOKEN_RE.test(token))
+        return undefined;
+    try {
+        const { notes } = resolveChord(token);
+        return notes.length > 0 ? notes : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 // "Eb Gb Bb // Db Eb F Gb" — polychord-style "top over bottom" (rh then lh).
 const POLYCHORD_SLASH_RE = new RegExp(`(${NOTE_LIST_PATTERN})\\s*\\/\\/\\s*(${NOTE_LIST_PATTERN})`, "gi");
 // "Eb Gb Bb; Db Eb F Gb" — semicolon separator; reading order (lh then rh).
@@ -237,8 +342,16 @@ export function parseChordDescription(input) {
         const isDown = direction === "down" || direction === "lower";
         result.bassOctaveShift = isDown ? -count : count;
     }
+    /*
+     * Note-name sizes are read from the input with the degrees clause taken out.
+     * NOTE_NAMES_RE accepts a size *before* the keyword ("xl note names"), so in
+     * "with degrees in base note names in 2xl" it read the degrees' own "base" as
+     * the note-name size. Two clauses that each carry a size must not be able to
+     * read each other's.
+     */
+    const sizeSource = input.replace(DEGREES_KEYWORD_RE, " ");
     // Extract "midi note names" / "with midi names" (check before regular note names)
-    const midiNamesMatch = input.match(MIDI_NAMES_RE);
+    const midiNamesMatch = sizeSource.match(MIDI_NAMES_RE);
     if (midiNamesMatch) {
         result.showNoteNames = true;
         result.noteNameMode = "midi";
@@ -246,7 +359,7 @@ export function parseChordDescription(input) {
     }
     // Extract "with note names" / "note names in xl" / "xl note names"
     if (!midiNamesMatch) {
-        const noteNamesMatch = input.match(NOTE_NAMES_RE);
+        const noteNamesMatch = sizeSource.match(NOTE_NAMES_RE);
         if (noteNamesMatch) {
             result.showNoteNames = true;
             // Size can be in group 1 (before "note names"), 2 (after), or 3 ("name the notes in xl")
@@ -261,7 +374,13 @@ export function parseChordDescription(input) {
     // Check custom fingering FIRST ("custom fingering A0,A1,A2")
     const customFingerMatch = input.match(CUSTOM_FINGERING_RE);
     if (customFingerMatch) {
-        result.customFingering = customFingerMatch[2].split(/[,\-\s]+/).filter(Boolean);
+        // Comma-separated lists split ONLY on commas/spaces so "-" placeholders
+        // survive as positional blanks ("1,-,3"); dash-separated lists keep the
+        // documented "D2-D1-D0-D1" behavior.
+        const raw = customFingerMatch[2];
+        result.customFingering = (raw.includes(",")
+            ? raw.split(/[,\s]+/)
+            : raw.split(/[\-\s]+/)).filter(Boolean);
         result.fingeringSize = toTextSize(customFingerMatch[1]) ?? toTextSize(customFingerMatch[3]);
     }
     // Check auto fingering ("with fingering", "fingering 2xl", "fingering in xl")
@@ -330,27 +449,64 @@ export function parseChordDescription(input) {
     // segments separated by "and" / "with". Paired example:
     //   "notes C E G in bass clef and notes B D F in treble clef"
     const groups = [];
+    // Explode a run-together token ("cdefgabc", "EbGbBb", "E4G4C5") into
+    // individual notes. In runs, a lowercase 'b' binds as a flat only after
+    // an UPPERCASE letter ("EbGbBb") — in lowercase runs like "cdefgabc"
+    // every letter is its own note, so 'b' stays the note B.
+    const explodeNoteRun = (token) => {
+        const out = [];
+        let i = 0;
+        while (i < token.length) {
+            const letter = token[i];
+            if (!/[A-Ga-g]/.test(letter))
+                return [token]; // not a pure note run
+            i++;
+            let accidental = "";
+            if (token[i] === "#") {
+                accidental = "#";
+                i++;
+            }
+            else if (token[i] === "b" && letter === letter.toUpperCase()) {
+                accidental = "b";
+                i++;
+            }
+            let octave = "";
+            if (/\d/.test(token[i] ?? "")) {
+                octave = token[i];
+                i++;
+            }
+            out.push(letter.toUpperCase() + accidental + octave);
+        }
+        return out;
+    };
     const normalizeTokens = (raw) => raw
         .split(/[\s,\-]+/)
         .filter(Boolean)
-        .map((t) => {
+        .flatMap((t) => {
+        // Single-note tokens keep their exact old handling ("eb5" → Eb5,
+        // "bb" → Bb) — run explosion applies only to longer sequences.
         const nm = t.match(/^([A-Ga-g])([#b])?(\d)?$/);
-        if (!nm)
-            return t;
-        return nm[1].toUpperCase() + (nm[2] ?? "") + (nm[3] ?? "");
+        if (nm)
+            return [nm[1].toUpperCase() + (nm[2] ?? "") + (nm[3] ?? "")];
+        return explodeNoteRun(t);
     });
     // Note-group extraction runs in priority order. Each pass strips its matches
     // from `residual` so later (looser) passes can't re-consume the same notes.
     let residual = input;
+    // Hand-prefixed chord phrases actually consumed by pass 4d, so the chord-name
+    // pass below strips exactly those (and not look-alikes it rejected).
+    const handChordMatches = [];
     const stripFromResidual = (match) => {
         residual = residual.replace(match, " ");
     };
-    const pushGroup = (tokens, hand, clef) => {
+    const pushGroup = (tokens, hand, clef, chord) => {
         const g = { notes: tokens };
         if (hand)
             g.hand = hand;
         if (clef)
             g.clef = clef;
+        if (chord)
+            g.chord = chord;
         groups.push(g);
     };
     // 1. "notes in <hand> <notes>" (prefix with explicit "notes" keyword)
@@ -424,6 +580,32 @@ export function parseChordDescription(input) {
         pushGroup(tokens, hand, clef);
         stripFromResidual(m[0]);
     }
+    // 4d. "rh Cmaj7 lh Dm7" — hand keyword + chord symbol. Runs after every
+    // bare-note pass so note lists still win; whatever is left here is a chord.
+    // Only the first chord after a hand keyword is used — trailing chords are
+    // dropped (and removed from the residual so they don't become the chord name).
+    HAND_PREFIX_CHORD_RE.lastIndex = 0;
+    for (const m of [...residual.matchAll(HAND_PREFIX_CHORD_RE)]) {
+        const { hand, clef } = parseHandOrClef(m[1]);
+        if (!hand && !clef)
+            continue;
+        const notes = chordTokenNotes(m[2]);
+        if (!notes)
+            continue;
+        pushGroup(notes, hand, clef, m[2]);
+        // Drop the run of extra chord tokens that directly follows, stopping at
+        // the first token that isn't a chord so unrelated text survives.
+        let extras = m[3] ?? "";
+        while (extras.length > 0) {
+            const next = extras.match(/^\s+(\S+)/);
+            if (!next || !chordTokenNotes(next[1]))
+                break;
+            extras = extras.slice(next[0].length);
+        }
+        const consumed = m[0].slice(0, m[0].length - extras.length);
+        handChordMatches.push(consumed);
+        stripFromResidual(consumed);
+    }
     // 5. "Eb Gb Bb // Db Eb F Gb" — polychord-style "top over bottom" (rh, lh).
     POLYCHORD_SLASH_RE.lastIndex = 0;
     for (const m of [...residual.matchAll(POLYCHORD_SLASH_RE)]) {
@@ -454,21 +636,26 @@ export function parseChordDescription(input) {
     if (themeMatch) {
         result.colorTheme = THEME_MAP[themeMatch[1].toLowerCase()] ?? themeMatch[1].toLowerCase();
     }
-    // Degrees keyword is independent — combines with note names if already detected,
-    // otherwise stands alone as degree-only mode. Skipped if MIDI names are active
-    // since "midi+degree" isn't a supported display mode.
+    // Degrees keyword is independent — combines with whichever note names are
+    // already detected, otherwise stands alone as degree-only mode. Midi names
+    // combine too: "midi note names with degrees" is a real request for two rows,
+    // and skipping the clause there dropped both the mode and the degree size, so
+    // the degrees the user asked for were silently never drawn.
     const degMatch = input.match(DEGREES_KEYWORD_RE);
-    if (degMatch && result.noteNameMode !== "midi") {
+    if (degMatch) {
         if (result.showNoteNames) {
-            result.noteNameMode = "pitch-class+degree";
+            result.noteNameMode = result.noteNameMode === "midi" ? "midi+degree" : "pitch-class+degree";
         }
         else {
             result.showNoteNames = true;
             result.noteNameMode = "degree";
         }
-        const sz = toTextSize(degMatch[1]);
+        // Its own field. Writing it to noteNameSize meant the second size in
+        // "note names in xl with degrees in lg" overwrote the first, and both rows
+        // came out at lg — the note names silently demoted to the degrees' size.
+        const sz = toTextSize(degMatch[1]) ?? toTextSize(degMatch[2]);
         if (sz)
-            result.noteNameSize = sz;
+            result.degreeSize = sz;
     }
     // Extract scale direction
     const dirMatch = input.match(DIRECTION_RE);
@@ -478,10 +665,12 @@ export function parseChordDescription(input) {
     // Extract octave count (used by both scales and arpeggios)
     const octavesMatch = input.match(OCTAVES_RE);
     const octaveCount = octavesMatch ? parseInt(octavesMatch[1], 10) : undefined;
-    // Detect scales — check BEFORE chord extraction
+    // Detect scales — check BEFORE chord extraction. Spelled-out forms first,
+    // then chord shorthand ("dm scale"), so "d minor scale" keeps its own path.
     const scaleUnambig = input.match(SCALE_UNAMBIGUOUS_RE);
     const scaleExplicit = input.match(SCALE_EXPLICIT_RE);
     const scaleMatch = scaleUnambig || scaleExplicit;
+    const scaleShorthand = scaleMatch ? null : input.match(SCALE_SHORTHAND_RE);
     if (scaleMatch) {
         const scaleRoot = capitalizeNote(scaleMatch[1]);
         const scaleType = scaleMatch[2].toLowerCase().replace(/\s+/g, " ").trim();
@@ -489,6 +678,12 @@ export function parseChordDescription(input) {
         result.scaleName = `${scaleRoot} ${scaleType}`;
         result.scaleOctaves = octaveCount ?? 1;
     }
+    else if (scaleShorthand) {
+        const scaleRoot = capitalizeNote(scaleShorthand[1]);
+        result.isScale = true;
+        result.scaleName = `${scaleRoot} ${shorthandScaleType(scaleShorthand[2])}`;
+        result.scaleOctaves = octaveCount ?? 1;
+    }
     else if (octaveCount) {
         // Not a scale but has "N octaves" → arpeggio mode for chord
         result.chordOctaves = octaveCount;
@@ -502,8 +697,11 @@ export function parseChordDescription(input) {
     else if (startMatch) {
         result.startingNote = capitalizeNote(startMatch[1]);
     }
-    // Strip extracted patterns and filler for chord name extraction
-    let cleaned = input
+    // Strip extracted patterns and filler for chord name extraction. Chord
+    // phrases already claimed by a hand go first — they're plain substrings of
+    // the input, so removing them here keeps them out of the chord name.
+    let cleaned = handChordMatches
+        .reduce((text, phrase) => text.replace(phrase, " "), input)
         .replace(FORMAT_FULL_RE, "")
         .replace(FORMAT_RE, "")
         .replace(SIZE_NAME_RE, "")
@@ -516,6 +714,11 @@ export function parseChordDescription(input) {
         .replace(PADDING_RE, "")
         .replace(CHORD_OCTAVE_RE, "")
         .replace(BASS_OCTAVE_RE, "")
+        // Before NOTE_NAMES_RE, which matches the "note names" half on its own and
+        // would leave "midi" behind. The leftover word is not inert: CHORD_RE's
+        // quality class contains `m`, so "C midi" parsed as Cm, and an A root lost
+        // to FILLER_WORDS let the extractor find its root in the `d` of "midi".
+        .replace(MIDI_NAMES_RE, "")
         .replace(NOTE_NAMES_RE, "")
         .replace(CUSTOM_FINGERING_RE, "")
         .replace(FINGERING_RE, "")
@@ -532,6 +735,10 @@ export function parseChordDescription(input) {
         .replace(OCTAVES_RE, "")
         .replace(SCALE_UNAMBIGUOUS_RE, "")
         .replace(SCALE_EXPLICIT_RE, "")
+        .replace(SCALE_SHORTHAND_RE, "")
+        // A loose "midi" is itself the request for midi note names (see the
+        // fallback above), so it has to leave with the rest of the request.
+        .replace(/\bmidi\b/gi, "")
         .replace(/\bscale\b/gi, "")
         .replace(HEADING_RE, "")
         .replace(NOTES_GROUP_PREFIX_RE, "")
@@ -557,6 +764,9 @@ export function parseChordDescription(input) {
         .replace(/\bin\b/gi, "")
         .replace(/\s+/g, " ")
         .trim();
+    // Last, so the article test is asked of text that is finished — and of the
+    // original input, which still knows what the article was standing in front of.
+    cleaned = stripArticles(cleaned, input).replace(/\s+/g, " ").trim();
     // Replace word-based accidentals before chord extraction
     cleaned = cleaned
         .replace(/\bsharp\b/gi, "#")