tonus 0.1.0

package/dist/engines/score/parse.js

@@ -0,0 +1,359 @@
+import { buildArticulation } from "./articulation.js";
+import { detectVowelAccent } from "../chant/syllabify.js";
+// Constants
+const DEFAULT_OPTIONS = {
+    oct: 3,
+    useVowelAccent: true,
+};
+const CLEF_OFFSETS = new Map([
+    ["c1", -3],
+    ["c2", -1],
+    ["c3", 1],
+    ["c4", 3],
+    ["f1", 1],
+    ["f2", 3],
+    ["f3", 5],
+    ["f4", 7],
+    ["cb1", -3],
+    ["cb2", -1],
+    ["cb3", 1],
+    ["cb4", 3],
+    ["fb1", 1],
+    ["fb2", 3],
+    ["fb3", 5],
+    ["fb4", 7],
+]);
+const DIVISIO_DURATIONS = new Map([
+    [",", 0.54],
+    ["`", 0.33],
+    [";", 0.8],
+    [":", 1.1],
+    ["::", 1.8],
+]);
+const STAFF_STEPS = [0, 2, 4, 5, 7, 9, 11];
+const SYLLABLES_REGEX = /(?=.)((?:[^(])*)(?:\(?([^)]*)\)?)?/g;
+const NOTATIONS_REGEX = /z0|z|Z|::|:|[,;][1-6]?|`|[cf][1-4]|cb[1-4]|fb[1-4]|\/+| |\!|-?[a-mA-M][oOwWvVrRsxy#~\+><_\.'012345]*(?:\[[^\]]*\]?)*|\{([^}]+)\}?/g;
+// Helpers
+function initialAccidentalState(clef) {
+    const state = new Map();
+    if (clef.includes("b"))
+        state.set(6, -1); // B-flat key signature
+    return state;
+}
+function isSkippable(token) {
+    return (token === " " ||
+        token === "z" ||
+        token === "Z" ||
+        token === "z0" ||
+        token === "\r" ||
+        token.startsWith("{") ||
+        token.includes("+"));
+}
+// parseNeume
+function parseNeume(notation, context) {
+    const { lyric, clef, oct, syllableIndex, accent, accidentalState, profile } = context;
+    const weights = profile.weights;
+    const ruleGain = profile.ruleGain ?? 1.0;
+    const contourScale = profile.contourScale ?? 0.2;
+    const neumeArch = profile.neumeArch ?? 0.5;
+    const durArch = profile.durArch ?? 0.08;
+    const ictusBoost = profile.ictusBoost ?? 1.08;
+    // bmolle: set from clef key sig, updated by x/y modifiers within tokens
+    let bmolle = clef.includes("b");
+    // Count note tokens for initio/melisma detection
+    const noteTokenCount = notation.filter((t) => /^-?[a-mA-M]/.test(t ?? "")).length;
+    const breaks = [];
+    const intermed = [];
+    // neumeGroup: 0-based index of the neume figure within this syllable. GABC
+    // glyph separators (!, /, //) start a new figure; MusicXML slurs each figure.
+    let neumeGroup = 0;
+    notation.forEach((rawToken, i) => {
+        if (!rawToken || rawToken.length < 1)
+            return;
+        // Break markers — end the current neume figure, begin the next.
+        if (rawToken === "!" || rawToken === "/" || rawToken === "//") {
+            breaks.push(i);
+            neumeGroup++;
+            return;
+        }
+        let token = rawToken;
+        let w = 0;
+        let durWeight = 0;
+        let ictus = false;
+        let isQuilisma = false;
+        let isLiquescent = false;
+        let isStrophicus = false;
+        let isDoubleEpisema = false;
+        // Dash prefix (weak note)
+        if (token[0] === "-") {
+            token = token.slice(1);
+            w += weights.dashWeight; // negative weight
+            durWeight += weights.dashDuration;
+        }
+        const letter = token[0]?.toLowerCase();
+        if (!letter)
+            return;
+        const pitchOffset = letter.charCodeAt(0) - "a".charCodeAt(0);
+        if (pitchOffset < 0 || pitchOffset > 12)
+            return;
+        const clefOffset = CLEF_OFFSETS.get(clef) ?? 0;
+        const pos = pitchOffset - 6 - clefOffset;
+        const octave = Math.floor(pos / 7) + oct + 1;
+        const degree = ((pos % 7) + 7) % 7;
+        const baseStep = STAFF_STEPS[degree];
+        // bmolle / accidental modifier extraction
+        // Modifiers appear after the pitch letter in the token string
+        const modifiers = token.slice(1);
+        let explicitAccidental = null;
+        if (modifiers.includes("x")) {
+            bmolle = true;
+            explicitAccidental = -1;
+            accidentalState.set(degree, -1);
+        }
+        else if (modifiers.includes("y")) {
+            bmolle = false;
+            explicitAccidental = 0;
+            accidentalState.set(degree, 0);
+        }
+        else if (modifiers.includes("#")) {
+            explicitAccidental = 1;
+            accidentalState.set(degree, 1);
+        }
+        // Apply bmolle to B (degree 6 = B natural step 11 → B-flat step 10)
+        let step = baseStep;
+        if (bmolle && degree === 6)
+            step -= 1;
+        // Apply chromatic accidentals from state (on top of bmolle)
+        const stateAccidental = accidentalState.get(degree) ?? 0;
+        const activeAccidental = explicitAccidental ?? stateAccidental;
+        // If bmolle already lowered B, don't double-apply flat from state
+        if (!(bmolle && degree === 6 && activeAccidental === -1)) {
+            step += activeAccidental;
+        }
+        step += octave * 12;
+        const accidentalSource = explicitAccidental !== null
+            ? "explicit"
+            : accidentalState.has(degree)
+                ? "state"
+                : "none";
+        // Ictus markers (' and _)
+        if (modifiers.includes("'") || modifiers.includes("_")) {
+            w += weights.ictusWeight;
+            durWeight += weights.ictusDuration;
+            ictus = true;
+        }
+        // Episema (horizontal lengthening '.')
+        if (modifiers.includes(".")) {
+            w += weights.episemaWeight;
+            durWeight += weights.episemaDuration;
+            ictus = true;
+            // Double episema '..' — boost first note of neume
+            if (modifiers.includes("..")) {
+                isDoubleEpisema = true;
+                if (intermed[0])
+                    intermed[0]._durWeight += weights.episemaDoubleDuration;
+            }
+        }
+        // Strophicus (ss or vv = repeated/tremolo notes)
+        if (modifiers.includes("ss") || modifiers.includes("vv")) {
+            w += weights.strophicusWeight;
+            durWeight += weights.strophicusDuration;
+            ictus = true;
+            isStrophicus = true;
+            if (modifiers.includes("sss") || modifiers.includes("vvv")) {
+                durWeight += weights.strophicusTripleDuration;
+            }
+        }
+        // Quilisma (w = wavy ornamental note; boosts preceding note)
+        if (modifiers.toLowerCase().includes("w")) {
+            const prev = intermed.length > 0 ? intermed[intermed.length - 1] : null;
+            if (prev)
+                prev._weight += weights.quilismaPrevWeight;
+            w += weights.quilismaWeight; // reduces this note's weight
+            isQuilisma = true;
+        }
+        // First note of neume (initio debilis treatment)
+        if (i === 0 || (accent && i === 2)) {
+            w += weights.initioWeight;
+            if (noteTokenCount > 1) {
+                ictus = true;
+                w += weights.initioMelismaWeight;
+                durWeight += weights.initioMelismaDuration;
+            }
+        }
+        // Accented syllable
+        if (accent) {
+            w += weights.accentWeight;
+            if (i === 0 || i === 2)
+                ictus = true;
+        }
+        // Liquescent (softened ending: ~, <, >)
+        if (modifiers.includes("~") ||
+            modifiers.includes("<") ||
+            modifiers.includes(">")) {
+            w += weights.liquescentWeight;
+            durWeight += weights.liquescentDuration;
+            isLiquescent = true;
+        }
+        // Upper case = light/weak note
+        if (token[0] === token[0]?.toUpperCase()) {
+            w += weights.uppercaseWeight;
+            durWeight += weights.uppercaseDuration;
+        }
+        // Repercussion (same pitch as previous note)
+        const prev = intermed.length > 0 ? intermed[intermed.length - 1] : null;
+        if (prev && step === prev.step) {
+            prev._weight += weights.repercussionPrevWeight;
+            prev._durWeight += weights.repercussionPrevDuration;
+            if (modifiers.includes("o")) {
+                prev._weight += weights.repercussionOriscusWeight;
+            }
+        }
+        intermed.push({
+            step,
+            degree,
+            lyric,
+            syllableIndex,
+            neumeGroup,
+            ictus,
+            accidental: activeAccidental,
+            accidentalSource,
+            quilisma: isQuilisma,
+            liquescent: isLiquescent,
+            strophicus: isStrophicus,
+            doubleEpisema: isDoubleEpisema,
+            _weight: w,
+            _durWeight: durWeight,
+        });
+    });
+    // Apply break markers to corresponding notes
+    breaks.forEach((b, bi) => {
+        const idx = b - bi;
+        const target = intermed[idx];
+        if (target) {
+            target._weight += weights.breakWeight;
+            target.ictus = true;
+        }
+    });
+    // Finalization pass: arch + melodic contour + tanh saturation
+    const result = intermed.map((note, idx) => {
+        const t = (idx + 0.5) / (intermed.length + 0.0001);
+        const arch = Math.sin(Math.PI * t);
+        // Melodic contour: peak/valley emphasis
+        const prev = intermed[idx - 1];
+        const next = intermed[idx + 1];
+        let contour = 0;
+        if (prev && next) {
+            if (note.step > prev.step && note.step > next.step) {
+                contour = 0.4 * (contourScale / 0.2); // melodic peak
+            }
+            else if (note.step < prev.step && note.step < next.step) {
+                contour = -0.3 * (contourScale / 0.2); // melodic valley
+            }
+        }
+        const weight = profile.weightBase +
+            profile.weightGain *
+                ruleGain *
+                Math.tanh((note._weight + contour) / profile.weightSaturation) +
+            arch * neumeArch;
+        let duration = profile.durationBase * (1 + profile.durationGain * Math.tanh(note._durWeight));
+        duration *= 1 + arch * durArch;
+        if (note.ictus)
+            duration *= ictusBoost;
+        duration = Math.max(profile.durationMin, Math.min(profile.durationMax, duration));
+        return {
+            type: "note",
+            step: note.step,
+            lyric: note.lyric,
+            syllableIndex: note.syllableIndex,
+            neumeGroup: note.neumeGroup,
+            ictus: note.ictus,
+            weight,
+            duration,
+            accidental: note.accidental,
+            accidentalSource: note.accidentalSource,
+            quilisma: note.quilisma,
+            liquescent: note.liquescent,
+            strophicus: note.strophicus,
+            doubleEpisema: note.doubleEpisema,
+        };
+    });
+    return result;
+}
+// parseGABC — main entry point
+export function parseGABC(gabc, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const interpretation = options.interpretation ?? {};
+    const articulation = buildArticulation(interpretation.articulation ?? "balanced", { overrides: interpretation.articulationOverrides });
+    const errors = [];
+    const events = [];
+    const source = (gabc || "").trim();
+    if (!source) {
+        return {
+            events,
+            errors: [{ message: "Empty GABC input" }],
+        };
+    }
+    let currentClef = "c3";
+    let accidentalState = initialAccidentalState(currentClef);
+    const split = source.replace(/\)\s(?=[^\)]*(?:\(|$))/g, ")\n").split(/\n/g);
+    split.forEach((word) => {
+        if (!word)
+            return;
+        SYLLABLES_REGEX.lastIndex = 0;
+        let match;
+        let syllableIndex = 0;
+        while ((match = SYLLABLES_REGEX.exec(word)) !== null) {
+            const text = (match[1] ? match[1].trim().split("|")[0] : "") || "";
+            const notation = match[2] ? match[2].match(NOTATIONS_REGEX) : null;
+            if (!notation || notation.length === 0) {
+                syllableIndex += 1;
+                continue;
+            }
+            // Single-pass: classify tokens, collect note tokens in order
+            const noteTokens = [];
+            let divisioToken = null;
+            for (const token of notation) {
+                if (CLEF_OFFSETS.has(token)) {
+                    currentClef = token;
+                    accidentalState = initialAccidentalState(currentClef);
+                    continue;
+                }
+                if (DIVISIO_DURATIONS.has(token)) {
+                    if (!divisioToken)
+                        divisioToken = token;
+                    continue;
+                }
+                if (isSkippable(token))
+                    continue;
+                noteTokens.push(token);
+            }
+            if (noteTokens.length > 0) {
+                const accent = opts.useVowelAccent ? detectVowelAccent(text) : false;
+                events.push(...parseNeume(noteTokens, {
+                    lyric: text,
+                    clef: currentClef,
+                    oct: opts.oct,
+                    syllableIndex,
+                    accent,
+                    accidentalState,
+                    profile: articulation,
+                }));
+            }
+            if (divisioToken) {
+                events.push({
+                    type: "rest",
+                    divisio: divisioToken,
+                    duration: DIVISIO_DURATIONS.get(divisioToken) ?? 0.5,
+                });
+                accidentalState = initialAccidentalState(currentClef);
+            }
+            syllableIndex += 1;
+        }
+    });
+    if (events.length === 0) {
+        errors.push({ message: "No parseable notation found" });
+    }
+    return { events, errors };
+}
+//# sourceMappingURL=parse.js.map

package/dist/engines/score/phrasing.d.ts

@@ -0,0 +1,24 @@
+import type { Note, PhrasingProfile, PhrasingType } from "./types.js";
+import type { ModeData } from "../temper/modes.js";
+export type { PhrasingProfile } from "./types.js";
+export interface ShapedNote extends Note {
+    shapedDuration: number;
+}
+export interface BuildPhrasingOptions {
+    overrides?: Partial<PhrasingProfile>;
+}
+export interface ShapePhrasingForModeOptions {
+    enabled?: boolean;
+    strength?: number;
+}
+export declare function buildPhrasing(type?: PhrasingType, options?: BuildPhrasingOptions): PhrasingProfile;
+export declare function shapePhrasingForMode(profile: PhrasingProfile, modeData?: ModeData, options?: ShapePhrasingForModeOptions): PhrasingProfile;
+export type PhrasingInputEvent = (Note & {
+    type?: "note";
+}) | {
+    type: "rest";
+    divisio: string;
+    duration: number;
+};
+export declare function applyPhrasing(events: PhrasingInputEvent[], profile: PhrasingProfile, tenorPc?: number): ShapedNote[];
+//# sourceMappingURL=phrasing.d.ts.map

package/dist/engines/score/phrasing.js

@@ -0,0 +1,257 @@
+// ---------------------------------------------------------------------------
+// engines/score/phrasing — performance-shaping profiles
+// ---------------------------------------------------------------------------
+const PHRASING_PROFILES = {
+    recitative: {
+        curve: 0.1,
+        accent: 0.5,
+        cadence: 0.1,
+        tenor: 2.3,
+        baseVelocity: 0.65,
+        contourVel: 0.08,
+        contourDur: 0.05,
+        velSpread: 0.35,
+        ictusBoost: 1.06,
+        neumeArch: 0.2,
+        durArch: 0.04,
+    },
+    lyrical: {
+        curve: 0.35,
+        accent: 0.8,
+        cadence: 0.15,
+        tenor: 1.2,
+        baseVelocity: 0.68,
+        contourVel: 0.18,
+        contourDur: 0.11,
+        velSpread: 0.5,
+        ictusBoost: 1.08,
+        neumeArch: 0.5,
+        durArch: 0.08,
+    },
+    hymnic: {
+        curve: 0.25,
+        accent: 0.6,
+        cadence: 0.12,
+        tenor: 0.9,
+        baseVelocity: 0.69,
+        contourVel: 0.14,
+        contourDur: 0.08,
+        velSpread: 0.45,
+        ictusBoost: 1.08,
+        neumeArch: 0.38,
+        durArch: 0.06,
+    },
+    solemn: {
+        curve: 0.5,
+        accent: 1,
+        cadence: 0.2,
+        tenor: 1.7,
+        baseVelocity: 0.71,
+        contourVel: 0.22,
+        contourDur: 0.13,
+        velSpread: 0.55,
+        ictusBoost: 1.12,
+        neumeArch: 0.62,
+        durArch: 0.1,
+    },
+};
+export function buildPhrasing(type = "lyrical", options = {}) {
+    const base = PHRASING_PROFILES[type] ?? PHRASING_PROFILES.lyrical;
+    return {
+        ...base,
+        ...(options.overrides ?? {}),
+    };
+}
+const MODE_TYPE_TENOR_MULTIPLIER = {
+    authentic: 1.08,
+    plagal: 0.92,
+};
+const MODE_TYPE_CADENCE_MULTIPLIER = {
+    authentic: 1.05,
+    plagal: 0.95,
+};
+const MODE_TENDENCY_CADENCE_MULTIPLIER = {
+    melismatic: 1.06,
+    neumatic: 1.0,
+    syllabic: 0.96,
+    neutral: 1.0,
+};
+const MODE_MOOD_BASE_VELOCITY_DELTA = {
+    neutral: 0,
+    serious: -0.01,
+    sad: -0.03,
+    mystic: -0.01,
+    harmonious: 0.01,
+    happy: 0.04,
+    devout: 0.01,
+    angelical: 0.03,
+    perfect: 0.02,
+};
+const MODE_MOOD_CURVE_DELTA = {
+    neutral: 0,
+    serious: 0.01,
+    sad: 0.02,
+    mystic: 0.015,
+    harmonious: 0.005,
+    happy: -0.01,
+    devout: 0.01,
+    angelical: -0.015,
+    perfect: -0.005,
+};
+const MODE_STRENGTH_DEFAULT = 0.5;
+const MODE_STRENGTH_MIN = 0;
+const MODE_STRENGTH_MAX = 1;
+const TENOR_MIN = 0.4;
+const TENOR_MAX = 2.8;
+const CADENCE_MIN = 0.05;
+const CADENCE_MAX = 0.35;
+const CURVE_MIN = 0.05;
+const CURVE_MAX = 0.65;
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function blendMultiplier(multiplier, strength) {
+    return 1 + (multiplier - 1) * strength;
+}
+export function shapePhrasingForMode(profile, modeData, options = {}) {
+    if (!modeData || options.enabled === false)
+        return { ...profile };
+    const strength = clamp(options.strength ?? MODE_STRENGTH_DEFAULT, MODE_STRENGTH_MIN, MODE_STRENGTH_MAX);
+    const mood = modeData.profile.mood ?? "neutral";
+    const tendency = modeData.profile.tendency ?? "neutral";
+    const tenor = clamp(profile.tenor *
+        blendMultiplier(MODE_TYPE_TENOR_MULTIPLIER[modeData.type], strength), TENOR_MIN, TENOR_MAX);
+    const cadence = clamp(profile.cadence *
+        blendMultiplier(MODE_TYPE_CADENCE_MULTIPLIER[modeData.type], strength) *
+        blendMultiplier(MODE_TENDENCY_CADENCE_MULTIPLIER[tendency], strength), CADENCE_MIN, CADENCE_MAX);
+    const baseVelocity = clamp(profile.baseVelocity + (MODE_MOOD_BASE_VELOCITY_DELTA[mood] ?? 0) * strength, 0.4, 0.9);
+    const curve = clamp(profile.curve + (MODE_MOOD_CURVE_DELTA[mood] ?? 0) * strength, CURVE_MIN, CURVE_MAX);
+    return {
+        ...profile,
+        tenor,
+        cadence,
+        baseVelocity,
+        curve,
+    };
+}
+const VELOCITY_MIN = 0.1;
+const VELOCITY_MAX = 1.0;
+const VELOCITY_SPREAD_MULTIPLIER = 2;
+const VELOCITY_CENTER = 0.5;
+const DURATION_BASE_FACTOR = 0.85;
+const DURATION_ARSIS_FACTOR = 0.25;
+const DURATION_ARCH_FACTOR = 0.2;
+const DURATION_MIN = 0.2;
+const DURATION_MAX = 4.0;
+const TENOR_GAIN = 0.05;
+const TENOR_DISTANCE_DIVISOR = 6;
+const CADENCE_VELOCITY_FACTOR = 0.5;
+const CADENCE_DURATION_FACTOR = 0.6;
+const DIVISIO_STRENGTH = {
+    "::": 1.0,
+    ":": 0.7,
+    ";": 0.7,
+    ",": 0.4,
+    "`": 0.0,
+};
+function getDivisioStrength(divisio) {
+    if (!divisio)
+        return 0;
+    return DIVISIO_STRENGTH[divisio] ?? 0;
+}
+function pitchClassDistance(pc1, pc2) {
+    const forward = (12 + pc2 - pc1) % 12;
+    const backward = (12 + pc1 - pc2) % 12;
+    return Math.min(forward, backward);
+}
+export function applyPhrasing(events, profile, tenorPc) {
+    const shaped = [];
+    const phrases = [];
+    let currentPhrase = [];
+    for (let i = 0; i < events.length; i++) {
+        const ev = events[i];
+        if (ev.type === "rest") {
+            if (currentPhrase.length > 0) {
+                const last = currentPhrase[currentPhrase.length - 1];
+                currentPhrase[currentPhrase.length - 1] = {
+                    ...last,
+                    nextDivisio: ev.divisio,
+                };
+                phrases.push(currentPhrase);
+                currentPhrase = [];
+            }
+        }
+        else {
+            currentPhrase.push({ ev, nextDivisio: undefined });
+        }
+    }
+    if (currentPhrase.length > 0)
+        phrases.push(currentPhrase);
+    for (const phrase of phrases) {
+        const noteEntries = phrase;
+        if (noteEntries.length === 0)
+            continue;
+        let minArsis = Infinity, maxArsis = -Infinity;
+        let minStep = Infinity, maxStep = -Infinity;
+        for (const { ev } of noteEntries) {
+            // ev is always a Note here (rest events never enter currentPhrase)
+            const note = ev;
+            const arsis = note.context.weight;
+            if (arsis < minArsis)
+                minArsis = arsis;
+            if (arsis > maxArsis)
+                maxArsis = arsis;
+            const midi = note.pitch.midi;
+            if (midi < minStep)
+                minStep = midi;
+            if (midi > maxStep)
+                maxStep = midi;
+        }
+        const arsisSpan = maxArsis - minArsis || 1;
+        const stepSpan = maxStep - minStep || 1;
+        noteEntries.forEach(({ ev, nextDivisio }, order) => {
+            const note = ev;
+            const arsis = note.context.weight;
+            const arsisRelative = (arsis - minArsis) / arsisSpan;
+            const contourRelative = (note.pitch.midi - minStep) / stepSpan;
+            const t = (order + 0.5) / (noteEntries.length + 0.0001);
+            const arch = 0.5 - 0.5 * Math.cos(2 * Math.PI * t);
+            let velocity = arsisRelative * (1 - profile.curve) + arch * profile.curve;
+            velocity += (contourRelative - VELOCITY_CENTER) * profile.contourVel;
+            velocity =
+                VELOCITY_CENTER +
+                    (velocity - VELOCITY_CENTER) *
+                        (profile.velSpread * VELOCITY_SPREAD_MULTIPLIER);
+            velocity *= profile.accent;
+            if (profile.tenor && typeof tenorPc === "number") {
+                const pc = note.pitch.pc;
+                const dist = pitchClassDistance(pc, tenorPc);
+                const tenorPull = Math.max(0, 1 - dist / TENOR_DISTANCE_DIVISOR);
+                velocity *= 1 + profile.tenor * TENOR_GAIN * tenorPull;
+            }
+            const divisioStrength = getDivisioStrength(nextDivisio);
+            velocity *=
+                1 - profile.cadence * divisioStrength * CADENCE_VELOCITY_FACTOR;
+            const finalVelocity = Math.max(VELOCITY_MIN, Math.min(VELOCITY_MAX, velocity * profile.baseVelocity));
+            const baseDur = note.performance.duration;
+            let durFactor = DURATION_BASE_FACTOR +
+                arsisRelative * DURATION_ARSIS_FACTOR +
+                arch * DURATION_ARCH_FACTOR;
+            durFactor += (contourRelative - VELOCITY_CENTER) * profile.contourDur;
+            if (note.context.ictus)
+                durFactor *= profile.ictusBoost;
+            durFactor += profile.cadence * divisioStrength * CADENCE_DURATION_FACTOR;
+            const shapedDuration = Math.max(DURATION_MIN, Math.min(DURATION_MAX, baseDur * durFactor));
+            shaped.push({
+                ...note,
+                performance: {
+                    ...note.performance,
+                    velocity: finalVelocity,
+                },
+                shapedDuration,
+            });
+        });
+    }
+    return shaped;
+}
+//# sourceMappingURL=phrasing.js.map

package/dist/engines/score/prosody.d.ts

@@ -0,0 +1,35 @@
+import type { Phrase } from "./types.js";
+export interface NoteRange {
+    min: number;
+    max: number;
+    span: number;
+}
+export interface CadenceDistribution {
+    comma: number;
+    tick: number;
+    semicolon: number;
+    colon: number;
+    doubleBar: number;
+}
+/** Aggregate of compound-beat qualities and sizes across the score. */
+export interface RhythmicProfile {
+    arsic: number;
+    thetic: number;
+    avgGroupSize: number;
+    maxGroupSize: number;
+}
+export interface Prosody {
+    noteCount: number;
+    syllableCount: number;
+    phraseCount: number;
+    noteRange: NoteRange | null;
+    ambitus: number | null;
+    melismaRatio: number;
+    melismaByPhrase: number[];
+    ictusRate: number;
+    rhythmicProfile: RhythmicProfile;
+    cadenceWeight: number;
+    cadenceDistribution: CadenceDistribution;
+}
+export declare function computeProsody(phrases: Phrase[]): Prosody;
+//# sourceMappingURL=prosody.d.ts.map