tonus 0.1.0

package/dist/engines/planet/types.d.ts

@@ -0,0 +1,61 @@
+export interface HelioPos {
+    lon: number;
+    lat: number;
+    dist: number;
+}
+export interface GeoPos {
+    lon: number;
+    lat: number;
+    dist: number;
+    equatorial: {
+        ra: number;
+        dec: number;
+        dist: number;
+    };
+}
+export type BodyName = "Sun" | "Moon" | "Mercury" | "Venus" | "Earth" | "Mars" | "Jupiter" | "Saturn";
+export type PlanetName = "Mercury" | "Venus" | "Mars" | "Jupiter" | "Saturn";
+export declare function latinName(name: BodyName): string;
+export interface Body {
+    name: BodyName;
+    nomen: string;
+    symbol: string;
+    helio: HelioPos;
+    geo: GeoPos;
+    speed: number;
+    retrograde: boolean;
+    magnitude: number;
+    elongation: number;
+    phase: number;
+    apparentDiameter: number | {
+        equ: number;
+        pol: number;
+    };
+    zodiac: number;
+    sign: string;
+    distEarthRadii?: number;
+}
+export interface Aspect {
+    type: "conjunction" | "opposition" | "trine" | "square" | "sextile";
+    bodies: [string, string];
+    angle: number;
+    orb: number;
+    strength: number;
+}
+export interface Cosmos {
+    date: Date;
+    bodies: Body[];
+    aspects: Aspect[];
+}
+export interface CosmosQuery {
+    date?: Date;
+    feast?: {
+        date: Date;
+    };
+    from?: Date;
+    to?: Date;
+    step?: number;
+    bodies?: BodyName[];
+    orbLimit?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/engines/planet/types.js

@@ -0,0 +1,14 @@
+const LATIN_NAMES = {
+    Sun: "Sol",
+    Moon: "Luna",
+    Mercury: "Mercurius",
+    Venus: "Venus",
+    Earth: "Terra",
+    Mars: "Mars",
+    Jupiter: "Iuppiter",
+    Saturn: "Saturnus",
+};
+export function latinName(name) {
+    return LATIN_NAMES[name];
+}
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,54 @@
+import { type Imprint } from "../imprint.js";
+import { type Prosody } from "./prosody.js";
+import { type ChantTabulaRow } from "./tabula.js";
+import { type MidiOpts, type MidiEmitResult } from "./emitters/midi.js";
+import { type MusicXmlOpts, type MusicXmlEmitResult } from "./emitters/musicxml.js";
+import type { Chant } from "../chant/types.js";
+import type { Temperamentum } from "../temper/api.js";
+import type { ArticulationProfile, PhrasingProfile, ParseError, Phrase as IRPhrase } from "./types.js";
+export type PondusStyle = "restrained" | "balanced" | "expressive" | "strict";
+export type AccentusStyle = "recitative" | "lyrical" | "hymnic" | "solemn";
+export interface PondusOpts {
+    style?: PondusStyle;
+    overrides?: Partial<ArticulationProfile>;
+}
+export interface AccentusOpts {
+    style?: AccentusStyle;
+    overrides?: Partial<PhrasingProfile>;
+}
+export type PondusInput = PondusStyle | PondusOpts;
+export type AccentusInput = AccentusStyle | AccentusOpts;
+export interface ScoreOpts {
+    temperamentum?: Temperamentum;
+    pondus?: PondusInput;
+    accentus?: AccentusInput;
+}
+export interface Score {
+    chant: Chant;
+    phrases: IRPhrase[];
+    errors: ParseError[];
+    tabula: ChantTabulaRow[];
+    prosody: Prosody;
+    imprint: Imprint;
+    /**
+     * Emit a Standard MIDI File from the score's tabula. Returns the file bytes
+     * by default; `format: "json"` returns the event structure, `"both"` an
+     * object. The score's pondus/accentus reach the output via the tabula.
+     */
+    midi(opts?: MidiOpts): Uint8Array | MidiEmitResult;
+    /** Emit a MusicXML 4.0 partwise document from the score's tabula. */
+    musicxml(opts?: MusicXmlOpts): MusicXmlEmitResult;
+}
+/**
+ * Score builder (`tonus.notatio`). Parses a chant's GABC into a musical
+ * IR — phrases, syllables, notes with tuned pitches, arsis/thesis
+ * rhythm, prosody, imprint, and a tabula. Options: a temperamentum
+ * (tuning), a pondus (articulation weight, style name or opts), and an
+ * accentus (phrasing, style name or opts).
+ * @throws Error on invalid Chant input or unparseable GABC.
+ */
+export declare function buildScore(chant: Chant, opts?: ScoreOpts): Score;
+export type { ParseError };
+export type { MidiOpts, MidiEmitResult, MidiJsonResult, MidiJsonEvent } from "./emitters/midi.js";
+export type { MusicXmlOpts, MusicXmlEmitResult } from "./emitters/musicxml.js";
+//# sourceMappingURL=api.d.ts.map

package/dist/engines/score/api.js

@@ -0,0 +1,87 @@
+// ---------------------------------------------------------------------------
+// engines/score/api — score builder and interpretation profiles
+// ---------------------------------------------------------------------------
+import { parseGABC } from "./parse.js";
+import { buildIR } from "./ir.js";
+import { buildRatios } from "../temper/scale.js";
+import { computeMeta } from "./meta.js";
+import { computeImprint } from "../imprint.js";
+import { computeProsody } from "./prosody.js";
+import { computeTabula } from "./tabula.js";
+import { toMidi } from "./emitters/midi.js";
+import { toMusicXML } from "./emitters/musicxml.js";
+const PONDUS_TO_ARTICULATION = {
+    restrained: "restrained",
+    balanced: "balanced",
+    expressive: "expressive",
+    strict: "strict",
+};
+const ACCENTUS_TO_PHRASING = {
+    recitative: "recitative",
+    lyrical: "lyrical",
+    hymnic: "hymnic",
+    solemn: "solemn",
+};
+function resolvePondus(input) {
+    return typeof input === "string" ? { style: input } : (input ?? {});
+}
+function resolveAccentus(input) {
+    return typeof input === "string" ? { style: input } : (input ?? {});
+}
+/**
+ * Score builder (`tonus.notatio`). Parses a chant's GABC into a musical
+ * IR — phrases, syllables, notes with tuned pitches, arsis/thesis
+ * rhythm, prosody, imprint, and a tabula. Options: a temperamentum
+ * (tuning), a pondus (articulation weight, style name or opts), and an
+ * accentus (phrasing, style name or opts).
+ * @throws Error on invalid Chant input or unparseable GABC.
+ */
+export function buildScore(chant, opts) {
+    const pondus = resolvePondus(opts?.pondus);
+    const accentus = resolveAccentus(opts?.accentus);
+    const parsed = parseGABC(chant.gabc, {
+        interpretation: {
+            articulation: PONDUS_TO_ARTICULATION[pondus.style ?? "balanced"],
+            articulationOverrides: pondus.overrides,
+        },
+    });
+    const modeNum = chant.mode ? parseInt(chant.mode) || undefined : undefined;
+    const scale = buildRatios({
+        mode: opts?.temperamentum?.mode === "auto" ? (modeNum ?? 1) : (opts?.temperamentum?.mode ?? modeNum ?? 1),
+        a4: opts?.temperamentum?.a4 ?? 440,
+        transpose: opts?.temperamentum?.transpose ?? 0,
+        // Carry the temperamentum's fully resolved scale — otherwise custom
+        // and non-pythagorean tunings would be silently rebuilt as default.
+        steps: opts?.temperamentum?.cents,
+    });
+    const ir = buildIR(parsed, chant, scale);
+    const meta = computeMeta(ir, { mode: modeNum });
+    const tabula = computeTabula(ir, {
+        mode: meta.mode ?? undefined,
+        a4Hz: opts?.temperamentum?.a4,
+        transpose: opts?.temperamentum?.transpose,
+        // Only pass phrasing when the caller asked for it, so the default
+        // tabula shaping (mode-gated) is unchanged.
+        interpretation: opts?.accentus
+            ? {
+                phrasing: ACCENTUS_TO_PHRASING[accentus.style ?? "lyrical"],
+                phrasingOverrides: accentus.overrides,
+            }
+            : undefined,
+    });
+    return {
+        chant,
+        phrases: ir.phrases,
+        errors: ir.errors,
+        tabula,
+        prosody: computeProsody(ir.phrases),
+        imprint: computeImprint(ir.phrases, scale),
+        midi(emitOpts) {
+            return toMidi(tabula, emitOpts);
+        },
+        musicxml(emitOpts) {
+            return toMusicXML(tabula, chant, emitOpts);
+        },
+    };
+}
+//# sourceMappingURL=api.js.map

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

@@ -0,0 +1,6 @@
+import type { ArticulationProfile, ArticulationType } from "./types.js";
+export interface BuildArticulationOptions {
+    overrides?: Partial<ArticulationProfile>;
+}
+export declare function buildArticulation(type?: ArticulationType, options?: BuildArticulationOptions): ArticulationProfile;
+//# sourceMappingURL=articulation.d.ts.map

package/dist/engines/score/articulation.js

@@ -0,0 +1,112 @@
+// ---------------------------------------------------------------------------
+// engines/score/articulation — note-level articulation profiles
+// ---------------------------------------------------------------------------
+const BASE_WEIGHTS = {
+    ictusWeight: 0.9,
+    ictusDuration: 0.35,
+    episemaWeight: 0.6,
+    episemaDuration: 0.9,
+    episemaDoubleDuration: 0.6,
+    strophicusWeight: 0.4,
+    strophicusDuration: 0.8,
+    strophicusTripleDuration: 0.6,
+    quilismaPrevWeight: 0.6,
+    quilismaWeight: -0.3,
+    liquescentWeight: -0.4,
+    liquescentDuration: -0.35,
+    initioWeight: 0.6,
+    initioMelismaWeight: 0.3,
+    initioMelismaDuration: 0.1,
+    accentWeight: 0.4,
+    uppercaseWeight: -0.7,
+    uppercaseDuration: -0.2,
+    repercussionPrevWeight: 0.5,
+    repercussionPrevDuration: 0.4,
+    repercussionOriscusWeight: -0.5,
+    breakWeight: 0.6,
+    dashWeight: -0.8,
+    dashDuration: -0.2,
+};
+const ARTICULATION_PROFILES = {
+    restrained: {
+        weights: { ...BASE_WEIGHTS, accentWeight: 0.25, ictusDuration: 0.2 },
+        weightBase: 5,
+        weightGain: 2.3,
+        weightSaturation: 3,
+        durationBase: 1,
+        durationGain: 0.45,
+        durationMin: 0.25,
+        durationMax: 3.6,
+        ruleGain: 0.8,
+        contourScale: 0.12,
+        neumeArch: 0.3,
+        durArch: 0.05,
+        ictusBoost: 1.04,
+    },
+    balanced: {
+        weights: { ...BASE_WEIGHTS },
+        weightBase: 5,
+        weightGain: 3,
+        weightSaturation: 3,
+        durationBase: 1,
+        durationGain: 0.6,
+        durationMin: 0.2,
+        durationMax: 4,
+        ruleGain: 1,
+        contourScale: 0.2,
+        neumeArch: 0.5,
+        durArch: 0.08,
+        ictusBoost: 1.08,
+    },
+    expressive: {
+        weights: { ...BASE_WEIGHTS, ictusWeight: 1.1, accentWeight: 0.55 },
+        weightBase: 5,
+        weightGain: 3.5,
+        weightSaturation: 2.8,
+        durationBase: 1,
+        durationGain: 0.72,
+        durationMin: 0.2,
+        durationMax: 4,
+        ruleGain: 1.2,
+        contourScale: 0.28,
+        neumeArch: 0.62,
+        durArch: 0.1,
+        ictusBoost: 1.12,
+    },
+    strict: {
+        weights: {
+            ...BASE_WEIGHTS,
+            episemaDuration: 1.0,
+            quilismaPrevWeight: 0.7,
+            quilismaWeight: -0.4,
+            liquescentDuration: -0.4,
+        },
+        weightBase: 5,
+        weightGain: 3.2,
+        weightSaturation: 3,
+        durationBase: 1,
+        durationGain: 0.65,
+        durationMin: 0.2,
+        durationMax: 4,
+        ruleGain: 1.08,
+        contourScale: 0.2,
+        neumeArch: 0.56,
+        durArch: 0.1,
+        ictusBoost: 1.1,
+    },
+};
+export function buildArticulation(type = "balanced", options = {}) {
+    const base = ARTICULATION_PROFILES[type] ?? ARTICULATION_PROFILES.balanced;
+    const overrides = options.overrides ?? {};
+    const baseWeights = base.weights;
+    const overrideWeights = overrides.weights ?? {};
+    return {
+        ...base,
+        ...overrides,
+        weights: {
+            ...baseWeights,
+            ...overrideWeights,
+        },
+    };
+}
+//# sourceMappingURL=articulation.js.map

package/dist/engines/score/emitters/midi.d.ts

@@ -0,0 +1,65 @@
+import type { ChantTabulaRow } from "../tabula.js";
+/** Lightweight diagnostic record. */
+interface Diagnostic {
+    code?: string;
+    message: string;
+}
+export interface MidiOpts {
+    /** "file" (default) → Uint8Array; "json" → event structure; "both" → object. */
+    format?: "file" | "json" | "both";
+    ppq?: number;
+    tempoBpm?: number;
+    channel?: number;
+    /** Fallback 0–127 velocity when a row has no phrasing velocity. */
+    velocity?: number;
+    includeMeta?: boolean;
+    trackName?: string;
+    emitPitchBend?: boolean;
+    transpose?: number;
+}
+export type MidiJsonEvent = {
+    type: "noteOn";
+    tick: number;
+    pitch: number;
+    velocity: number;
+    channel: number;
+    hz?: number;
+} | {
+    type: "noteOff";
+    tick: number;
+    pitch: number;
+    velocity: number;
+    channel: number;
+} | {
+    type: "pitchBend";
+    tick: number;
+    channel: number;
+    value14: number;
+} | {
+    type: "meta";
+    tick: number;
+    metaType: "tempo" | "trackName";
+    value: number | string;
+};
+export interface MidiJsonTrack {
+    name?: string;
+    events: MidiJsonEvent[];
+}
+export interface MidiJsonResult {
+    ppq: number;
+    tempoBpm: number;
+    tracks: MidiJsonTrack[];
+    diagnostics: Diagnostic[];
+}
+export interface MidiEmitResult {
+    json?: MidiJsonResult;
+    bytes?: Uint8Array;
+}
+/**
+ * Emit a Standard MIDI File from a score's tabula rows. Returns the file bytes
+ * (`Uint8Array`) by default; `format: "json"` returns the event structure and
+ * `"both"` returns `{ json, bytes }`.
+ */
+export declare function toMidi(rows: ChantTabulaRow[], options?: MidiOpts): Uint8Array | MidiEmitResult;
+export {};
+//# sourceMappingURL=midi.d.ts.map

package/dist/engines/score/emitters/midi.js

@@ -0,0 +1,158 @@
+// Divisio → rest duration (in the same beat units as note durations). Mirrors
+// DIVISIO_DURATIONS in parse.ts; a phrase's terminal divisio becomes a rest.
+const DIVISIO_REST = {
+    ",": 0.54, "`": 0.33, ";": 0.8, ":": 1.1, "::": 1.8,
+};
+const DEFAULT_PPQ = 480;
+const DEFAULT_TEMPO = 120;
+const DEFAULT_CHANNEL = 0;
+const DEFAULT_VELOCITY = 80;
+const PITCH_BEND_CENTER = 8192;
+function resolveOpts(options) {
+    return {
+        format: options.format ?? "file",
+        ppq: options.ppq ?? DEFAULT_PPQ,
+        tempoBpm: options.tempoBpm ?? DEFAULT_TEMPO,
+        channel: options.channel ?? DEFAULT_CHANNEL,
+        velocity: options.velocity ?? DEFAULT_VELOCITY,
+        includeMeta: options.includeMeta ?? true,
+        trackName: options.trackName ?? "tonus",
+        emitPitchBend: options.emitPitchBend ?? true,
+        transpose: options.transpose ?? 0,
+    };
+}
+function encodeVarLen(value) {
+    let val = Math.max(0, value | 0);
+    const bytes = [val & 0x7f];
+    while ((val >>= 7) > 0)
+        bytes.unshift((val & 0x7f) | 0x80);
+    return bytes;
+}
+function writeUInt32BE(value) {
+    return [(value >>> 24) & 0xff, (value >>> 16) & 0xff, (value >>> 8) & 0xff, value & 0xff];
+}
+function writeUInt16BE(value) {
+    return [(value >>> 8) & 0xff, value & 0xff];
+}
+function eventPriority(event) {
+    if (event.type === "meta")
+        return 0;
+    if (event.type === "pitchBend")
+        return 1;
+    if (event.type === "noteOff")
+        return 2;
+    return 3;
+}
+function clampToMidiPitch(step, diagnostics) {
+    if (step < 0 || step > 127) {
+        diagnostics.push({
+            code: "MIDI_PITCH_CLAMPED",
+            message: `Pitch ${step} clamped to MIDI range 0..127`,
+        });
+    }
+    return Math.min(127, Math.max(0, step));
+}
+function buildJson(rows, opts, diagnostics) {
+    const events = [];
+    let tick = 0;
+    if (opts.includeMeta) {
+        events.push({ type: "meta", tick: 0, metaType: "tempo", value: opts.tempoBpm });
+        events.push({ type: "meta", tick: 0, metaType: "trackName", value: opts.trackName });
+    }
+    let prevPhrase = null;
+    for (const row of rows) {
+        // A phrase boundary inserts the previous phrase's terminal divisio as a rest.
+        if (prevPhrase !== null && row.phraseIndex !== prevPhrase) {
+            const restDivisio = rows.find((r) => r.phraseIndex === prevPhrase)?.divisio ?? null;
+            const restBeats = restDivisio ? (DIVISIO_REST[restDivisio] ?? 0) : 0;
+            tick += Math.max(0, Math.round(restBeats * opts.ppq));
+        }
+        prevPhrase = row.phraseIndex;
+        const pitch = clampToMidiPitch(row.midi + opts.transpose, diagnostics);
+        const durationTicks = Math.max(1, Math.round(row.shapedDuration * opts.ppq));
+        const velocity = row.velocity != null && row.velocity > 0
+            ? Math.round(row.velocity * 127)
+            : opts.velocity;
+        const bends = opts.emitPitchBend && Math.abs(row.bend - PITCH_BEND_CENTER) > 1;
+        if (bends) {
+            events.push({ type: "pitchBend", tick, channel: opts.channel, value14: row.bend });
+        }
+        events.push({ type: "noteOn", tick, pitch, velocity, channel: opts.channel, hz: row.hz });
+        events.push({ type: "noteOff", tick: tick + durationTicks, pitch, velocity: 0, channel: opts.channel });
+        if (bends) {
+            events.push({ type: "pitchBend", tick: tick + durationTicks, channel: opts.channel, value14: PITCH_BEND_CENTER });
+        }
+        tick += durationTicks;
+    }
+    events.sort((a, b) => a.tick - b.tick || eventPriority(a) - eventPriority(b));
+    return {
+        ppq: opts.ppq,
+        tempoBpm: opts.tempoBpm,
+        tracks: [{ name: opts.trackName, events }],
+        diagnostics,
+    };
+}
+function buildMidiBytes(json) {
+    const trackEvents = json.tracks[0]?.events ?? [];
+    const trackData = [];
+    let lastTick = 0;
+    for (const event of trackEvents) {
+        const delta = Math.max(0, event.tick - lastTick);
+        lastTick = event.tick;
+        trackData.push(...encodeVarLen(delta));
+        if (event.type === "meta") {
+            if (event.metaType === "tempo") {
+                const mpqn = Math.max(1, Math.round(60000000 / Number(event.value)));
+                trackData.push(0xff, 0x51, 0x03, (mpqn >>> 16) & 0xff, (mpqn >>> 8) & 0xff, mpqn & 0xff);
+            }
+            else if (event.metaType === "trackName") {
+                const textBytes = Array.from(new TextEncoder().encode(String(event.value)));
+                trackData.push(0xff, 0x03, ...encodeVarLen(textBytes.length), ...textBytes);
+            }
+            continue;
+        }
+        if (event.type === "pitchBend") {
+            const lsb = event.value14 & 0x7f;
+            const msb = (event.value14 >> 7) & 0x7f;
+            trackData.push(0xe0 | (event.channel & 0x0f), lsb, msb);
+            continue;
+        }
+        if (event.type === "noteOn") {
+            trackData.push(0x90 | (event.channel & 0x0f), event.pitch & 0x7f, event.velocity & 0x7f);
+        }
+        else {
+            trackData.push(0x80 | (event.channel & 0x0f), event.pitch & 0x7f, event.velocity & 0x7f);
+        }
+    }
+    // End-of-track meta event
+    trackData.push(0x00, 0xff, 0x2f, 0x00);
+    const headerChunk = [
+        0x4d, 0x54, 0x68, 0x64, // "MThd"
+        ...writeUInt32BE(6), // chunk length
+        ...writeUInt16BE(0), // format 0
+        ...writeUInt16BE(1), // 1 track
+        ...writeUInt16BE(json.ppq),
+    ];
+    const trackChunk = [
+        0x4d, 0x54, 0x72, 0x6b, // "MTrk"
+        ...writeUInt32BE(trackData.length),
+        ...trackData,
+    ];
+    return Uint8Array.from([...headerChunk, ...trackChunk]);
+}
+/**
+ * Emit a Standard MIDI File from a score's tabula rows. Returns the file bytes
+ * (`Uint8Array`) by default; `format: "json"` returns the event structure and
+ * `"both"` returns `{ json, bytes }`.
+ */
+export function toMidi(rows, options = {}) {
+    const opts = resolveOpts(options);
+    const diagnostics = [];
+    const json = buildJson(rows, opts, diagnostics);
+    if (opts.format === "file")
+        return buildMidiBytes(json);
+    if (opts.format === "json")
+        return { json };
+    return { json, bytes: buildMidiBytes(json) };
+}
+//# sourceMappingURL=midi.js.map

package/dist/engines/score/emitters/musicxml.d.ts

@@ -0,0 +1,18 @@
+import type { ChantTabulaRow } from "../tabula.js";
+import type { Chant } from "../../chant/types.js";
+export interface MusicXmlOpts {
+    /** Emit the arsis/thesis shape + index as an other-notation annotation. */
+    emitWeights?: boolean;
+}
+export interface MusicXmlEmitResult {
+    xml: string;
+    diagnostics: {
+        message: string;
+    }[];
+}
+/**
+ * Emit a MusicXML 4.0 partwise document from a score's tabula rows plus the
+ * source chant (for titling). Returns `{ xml, diagnostics }`.
+ */
+export declare function toMusicXML(rows: ChantTabulaRow[], chant: Chant, options?: MusicXmlOpts): MusicXmlEmitResult;
+//# sourceMappingURL=musicxml.d.ts.map