tonus 0.1.0

package/dist/engines/harmonia/voice.js

@@ -0,0 +1,51 @@
+import { toPitch } from "../temper/pitch.js";
+import { PLANET_VOWELS } from "./data/vowels.js";
+import { computePresence, computeMotion } from "./presence.js";
+// MIDI anchor for the doctrina's mese. A4 = MIDI 69 — matches the default temper
+// reference. Ratios in the doctrina are multiplied by this anchor to produce Hz.
+const ANCHOR_MIDI = 69;
+function voiceOne(body, voice, vowel, scale) {
+    const pliny = voice.greekName === "proslambanomenos" && body.name === "Earth";
+    const presence = pliny ? 1 : computePresence(body);
+    const motion = pliny ? 0 : computeMotion(body);
+    // Direct Hz from anchor (A4) and doctrina ratio — bypass scale quantization
+    // so the ratio's pure Hz relationship is preserved.
+    const ratioVal = voice.ratio[0] / voice.ratio[1];
+    const hz = scale.a4 * ratioVal;
+    const midi = ANCHOR_MIDI + 12 * Math.log2(ratioVal);
+    // Nearest MIDI for Pitch metadata; override hz to the pure ratio-derived value.
+    const roundedMidi = Math.max(0, Math.min(127, Math.round(midi)));
+    const pitch = { ...toPitch(roundedMidi, scale), hz };
+    const performance = {
+        velocity: presence, // 0–1, same scale as the score engine
+        duration: 0,
+        rhythmicShape: "arsic",
+        rhythmicIndex: 1,
+    };
+    return {
+        ...body,
+        nota: { pitch, performance },
+        presence,
+        motion,
+        greekName: voice.greekName,
+        vowel,
+    };
+}
+export function voiceBodies(bodies, doctrina, scale) {
+    // Map doctrina body name → Voice entry
+    const voiceByBody = new Map();
+    for (const v of doctrina.voices)
+        voiceByBody.set(v.body, v);
+    const result = [];
+    for (const body of bodies) {
+        const voice = voiceByBody.get(body.name);
+        if (!voice)
+            continue; // body not part of this doctrina (e.g. Earth in Boethius)
+        const vowel = PLANET_VOWELS[body.name];
+        if (!vowel)
+            continue; // body has no classical vowel mapping (e.g. Earth, FixedStars)
+        result.push(voiceOne(body, voice, vowel, scale));
+    }
+    return result;
+}
+//# sourceMappingURL=voice.js.map

package/dist/engines/imprint.d.ts

@@ -0,0 +1,30 @@
+import type { Phrase } from "./score/types.js";
+import type { Pitch } from "./temper/pitch.js";
+import type { Scale } from "./temper/scale.js";
+import type { VoicedBody } from "./harmonia/voice.js";
+export interface Attractor {
+    pc: number;
+    weight: number;
+    pitch: Pitch;
+}
+export interface VowelAttractor {
+    vowel: string;
+    weight: number;
+    pitch: Pitch;
+}
+export interface ModalAffinity {
+    mode: number;
+    alias: string;
+    score: number;
+}
+export interface Imprint {
+    pcDistribution: Record<number, number>;
+    attractors: Attractor[];
+    vowelAttractors: VowelAttractor[];
+    modalAffinity: ModalAffinity[];
+}
+/** Build an Imprint from chant phrases (unweighted pc counts). */
+export declare function computeImprint(phrases: Phrase[], scale: Scale): Imprint;
+/** Build an Imprint from voiced planetary bodies (presence-weighted pc counts). */
+export declare function computeImprintFromBodies(bodies: VoicedBody[], scale: Scale): Imprint;
+//# sourceMappingURL=imprint.d.ts.map

package/dist/engines/imprint.js

@@ -0,0 +1,152 @@
+import { toPitch } from "./temper/pitch.js";
+import { MODES } from "./temper/modes.js";
+const DEFAULT_TOP = 5;
+const DEFAULT_MIDI_OCTAVE = 4;
+const VOWELS = ["a", "e", "i", "o", "u"];
+function pitchForPc(pc, scale) {
+    return toPitch(12 * (DEFAULT_MIDI_OCTAVE + 1) + pc, scale);
+}
+function computeAttractors(pcDistribution, scale, topN = DEFAULT_TOP) {
+    const entries = [];
+    for (let pc = 0; pc < 12; pc++) {
+        const w = pcDistribution[pc] ?? 0;
+        if (w > 0)
+            entries.push([pc, w]);
+    }
+    entries.sort((a, b) => b[1] - a[1]);
+    const top = entries.slice(0, topN);
+    const total = top.reduce((s, [, w]) => s + w, 0) || 1;
+    return top.map(([pc, w]) => ({
+        pc,
+        weight: w / total,
+        pitch: pitchForPc(pc, scale),
+    }));
+}
+function computeModalAffinity(pcDistribution) {
+    const results = [];
+    for (let m = 1; m <= 8; m++) {
+        const data = MODES.get(m);
+        if (!data)
+            continue;
+        const structural = new Set([
+            data.final,
+            data.tenor,
+            ...data.modulations.regular,
+        ]);
+        let score = 0;
+        for (const pc of structural)
+            score += pcDistribution[pc] ?? 0;
+        results.push({ mode: m, alias: data.alias, score });
+    }
+    return results.sort((a, b) => b.score - a.score);
+}
+function computeVowelAttractors(phrases, scale) {
+    const vowelPcMap = new Map();
+    for (const v of VOWELS)
+        vowelPcMap.set(v, new Map());
+    for (const phrase of phrases) {
+        for (const syl of phrase.syllables) {
+            for (const note of syl.notes) {
+                const vowel = note.context.vowel?.toLowerCase();
+                if (!vowel)
+                    continue;
+                const pcMap = vowelPcMap.get(vowel);
+                if (!pcMap)
+                    continue;
+                pcMap.set(note.pitch.pc, (pcMap.get(note.pitch.pc) ?? 0) + 1);
+            }
+        }
+    }
+    const vowelTotals = new Map();
+    for (const [v, pcMap] of vowelPcMap) {
+        let total = 0;
+        for (const w of pcMap.values())
+            total += w;
+        vowelTotals.set(v, total);
+    }
+    const grandTotal = Array.from(vowelTotals.values()).reduce((s, v) => s + v, 0);
+    if (grandTotal === 0)
+        return [];
+    const results = [];
+    for (const v of VOWELS) {
+        const pcMap = vowelPcMap.get(v);
+        if (pcMap.size === 0)
+            continue;
+        let bestPc = 0;
+        let bestW = -1;
+        for (const [pc, w] of pcMap) {
+            if (w > bestW) {
+                bestW = w;
+                bestPc = pc;
+            }
+        }
+        const total = vowelTotals.get(v) ?? 0;
+        results.push({ vowel: v, weight: total / grandTotal, pitch: pitchForPc(bestPc, scale) });
+    }
+    return results.sort((a, b) => b.weight - a.weight);
+}
+/** Build an Imprint from chant phrases (unweighted pc counts). */
+export function computeImprint(phrases, scale) {
+    const pcCounts = new Array(12).fill(0);
+    let total = 0;
+    for (const phrase of phrases) {
+        for (const syl of phrase.syllables) {
+            for (const note of syl.notes) {
+                pcCounts[note.pitch.pc]++;
+                total++;
+            }
+        }
+    }
+    const pcDistribution = {};
+    for (let pc = 0; pc < 12; pc++) {
+        pcDistribution[pc] = total > 0 ? pcCounts[pc] / total : 0;
+    }
+    return {
+        pcDistribution,
+        attractors: computeAttractors(pcDistribution, scale),
+        vowelAttractors: computeVowelAttractors(phrases, scale),
+        modalAffinity: computeModalAffinity(pcDistribution),
+    };
+}
+/** Build an Imprint from voiced planetary bodies (presence-weighted pc counts). */
+export function computeImprintFromBodies(bodies, scale) {
+    const pcWeight = new Array(12).fill(0);
+    let totalPresence = 0;
+    for (const b of bodies) {
+        pcWeight[b.nota.pitch.pc] += b.presence;
+        totalPresence += b.presence;
+    }
+    const pcDistribution = {};
+    for (let pc = 0; pc < 12; pc++) {
+        pcDistribution[pc] = totalPresence > 0 ? pcWeight[pc] / totalPresence : 0;
+    }
+    // Vowel attractors: harmony has no phrase text, but each voiced body carries
+    // its own Greek planetary vowel. Weight by presence; pitch is the body's own.
+    const vowelWeight = new Map();
+    let vowelTotal = 0;
+    for (const b of bodies) {
+        const key = b.vowel.phonetic;
+        const entry = vowelWeight.get(key);
+        if (entry) {
+            entry.weight += b.presence;
+        }
+        else {
+            vowelWeight.set(key, { weight: b.presence, pitch: b.nota.pitch });
+        }
+        vowelTotal += b.presence;
+    }
+    const vowelAttractors = [];
+    if (vowelTotal > 0) {
+        for (const [vowel, { weight, pitch }] of vowelWeight) {
+            vowelAttractors.push({ vowel, weight: weight / vowelTotal, pitch });
+        }
+        vowelAttractors.sort((a, b) => b.weight - a.weight);
+    }
+    return {
+        pcDistribution,
+        attractors: computeAttractors(pcDistribution, scale),
+        vowelAttractors,
+        modalAffinity: computeModalAffinity(pcDistribution),
+    };
+}
+//# sourceMappingURL=imprint.js.map

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

@@ -0,0 +1,40 @@
+export interface SunAppearance {
+    elongation: 0;
+    phaseAngle: 0;
+    phase: 1;
+    magnitude: -26.74;
+    apparentDiameter: number;
+}
+export declare function sunAppearance(distAu: number): SunAppearance;
+export interface MoonAppearance {
+    elongation: number;
+    phaseAngle: number;
+    phase: number;
+    apparentDiameter: number;
+}
+export declare function moonAppearance(config: {
+    sunLongitude: number;
+    moonLongitude: number;
+    moonLatitude: number;
+    distEarthRadii: number;
+}): MoonAppearance;
+export interface PlanetAppearance {
+    elongation: number;
+    phaseAngle: number;
+    phase: number;
+    apparentDiameter: number | {
+        equ: number;
+        pol: number;
+    };
+    magnitude: number;
+}
+export declare function planetAppearance(config: {
+    name: string;
+    heliocentricDistance: number;
+    geocentricDistance: number;
+    geocentricLongitude: number;
+    geocentricLatitude: number;
+    sunDistance: number;
+    J: number;
+}): PlanetAppearance;
+//# sourceMappingURL=appearance.d.ts.map

package/dist/engines/planet/appearance.js

@@ -0,0 +1,84 @@
+// ---------------------------------------------------------------------------
+// engines/planet/appearance — magnitude, phase, elongation, apparent diameter
+// ---------------------------------------------------------------------------
+import { sinDeg, cosDeg, asinDeg, acosDeg, wrapAngle } from "./math.js";
+// Apparent diameter at 1 AU (arcsec) — flat for Mercury/Venus/Sun, obj for others
+const DIAMETERS_AT_1AU = new Map([
+    ["Mercury", 6.74],
+    ["Venus", 16.92],
+    ["Earth", { equ: 17.59, pol: 17.53 }],
+    ["Mars", { equ: 9.36, pol: 9.28 }],
+    ["Jupiter", { equ: 196.94, pol: 185.08 }],
+    ["Saturn", { equ: 165.6, pol: 150.8 }],
+    ["Uranus", { equ: 65.8, pol: 62.1 }],
+    ["Neptune", { equ: 62.2, pol: 60.9 }],
+    ["Sun", 1919.26],
+]);
+const apparentDiam = (d0, dist) => d0 / dist;
+export function sunAppearance(distAu) {
+    return {
+        elongation: 0,
+        phaseAngle: 0,
+        phase: 1,
+        magnitude: -26.74,
+        apparentDiameter: apparentDiam(1919.26, distAu),
+    };
+}
+function moonElongation(sunLon, moonLon, moonLat) {
+    const delta = wrapAngle(sunLon - moonLon);
+    return acosDeg(cosDeg(delta) * cosDeg(moonLat));
+}
+export function moonAppearance(config) {
+    const { sunLongitude, moonLongitude, moonLatitude, distEarthRadii } = config;
+    const elong = moonElongation(sunLongitude, moonLongitude, moonLatitude);
+    const phaseAngle = 180 - elong;
+    const phase = (1 + cosDeg(phaseAngle)) / 2;
+    return {
+        elongation: elong,
+        phaseAngle,
+        phase,
+        apparentDiameter: (1873.7 * 60) / distEarthRadii,
+    };
+}
+function saturnRingTilt(los, las, J) {
+    const ir = 28.06;
+    const Nr = 169.51 + 3.82e-5 * J;
+    return asinDeg(sinDeg(las) * cosDeg(ir) - cosDeg(las) * sinDeg(ir) * sinDeg(los - Nr));
+}
+function planetMagnitude(name, r, R, FV, extras) {
+    const base = 5 * Math.log10(r * R);
+    switch (name) {
+        case "Mercury": return -0.36 + base + 0.027 * FV + 2.2e-13 * FV ** 6;
+        case "Venus": return -4.34 + base + 0.013 * FV + 4.2e-7 * FV ** 3;
+        case "Mars": return -1.51 + base + 0.016 * FV;
+        case "Jupiter": return -9.25 + base + 0.014 * FV;
+        case "Saturn": {
+            const B = saturnRingTilt(extras?.los ?? 0, extras?.las ?? 0, extras?.J ?? 0);
+            return -9.0 + base + 0.044 * FV + (-2.6 * Math.abs(sinDeg(B)) + 1.2 * sinDeg(B) ** 2);
+        }
+        case "Uranus": return -7.15 + base + 0.001 * FV;
+        case "Neptune": return -6.9 + base + 0.001 * FV;
+        default: return 0;
+    }
+}
+export function planetAppearance(config) {
+    const { name, heliocentricDistance: r, geocentricDistance: R, sunDistance: s, geocentricLongitude, geocentricLatitude, J } = config;
+    // elongation: angle at Earth between Sun and planet
+    const elongation = acosDeg((s * s + R * R - r * r) / (2 * s * R));
+    // phase angle: angle at planet between Sun and Earth
+    const phaseAngle = acosDeg((r * r + R * R - s * s) / (2 * r * R));
+    const phase = (1 + cosDeg(phaseAngle)) / 2;
+    const d0 = DIAMETERS_AT_1AU.get(name);
+    let apparentDiameter = 0;
+    if (typeof d0 === "number") {
+        apparentDiameter = apparentDiam(d0, R);
+    }
+    else if (d0) {
+        apparentDiameter = { equ: apparentDiam(d0.equ, R), pol: apparentDiam(d0.pol, R) };
+    }
+    const magnitude = planetMagnitude(name, r, R, phaseAngle, {
+        los: geocentricLongitude, las: geocentricLatitude, J,
+    });
+    return { elongation, phaseAngle, phase, apparentDiameter, magnitude };
+}
+//# sourceMappingURL=appearance.js.map

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

@@ -0,0 +1,5 @@
+import type { Aspect } from "./types.js";
+export declare function detectAspects(bodies: Record<string, number>, opts?: {
+    orbLimit?: number;
+}): Aspect[];
+//# sourceMappingURL=aspects.d.ts.map

package/dist/engines/planet/aspects.js

@@ -0,0 +1,41 @@
+// ---------------------------------------------------------------------------
+// engines/planet/aspects — angular aspect detection
+// ---------------------------------------------------------------------------
+import { wrapAngle } from "./math.js";
+const ASPECTS = [
+    ["conjunction", 0],
+    ["sextile", 60],
+    ["square", 90],
+    ["trine", 120],
+    ["opposition", 180],
+];
+const DEFAULT_ORB = 8;
+function separation(a, b) {
+    const d = Math.abs(wrapAngle(b - a));
+    return d > 180 ? 360 - d : d;
+}
+export function detectAspects(bodies, opts) {
+    const orbLimit = opts?.orbLimit ?? DEFAULT_ORB;
+    const names = Object.keys(bodies);
+    const results = [];
+    for (let i = 0; i < names.length; i++) {
+        for (let j = i + 1; j < names.length; j++) {
+            const sep = separation(bodies[names[i]], bodies[names[j]]);
+            for (const [type, angle] of ASPECTS) {
+                const orb = Math.abs(sep - angle);
+                if (orb <= orbLimit) {
+                    results.push({
+                        type,
+                        bodies: [names[i], names[j]],
+                        angle: sep,
+                        orb,
+                        strength: Math.max(0, 1 - orb / orbLimit),
+                    });
+                }
+            }
+        }
+    }
+    results.sort((a, b) => b.strength - a.strength || a.type.localeCompare(b.type));
+    return results;
+}
+//# sourceMappingURL=aspects.js.map

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

@@ -0,0 +1,13 @@
+export declare const sinDeg: (d: number) => number;
+export declare const cosDeg: (d: number) => number;
+export declare const asinDeg: (v: number) => number;
+export declare const acosDeg: (v: number) => number;
+export declare const atan2Deg: (y: number, x: number) => number;
+export declare function kepler(M: number, e: number, tol?: number): number;
+export declare const wrapAngle: (deg: number) => number;
+export declare function angleDelta(a: number, b: number): number;
+export declare const toAu: (km: number) => number;
+export declare const toCartesian: (lon: number, lat: number, dist: number) => [number, number, number];
+export declare const toSpherical: (x: number, y: number, z: number) => [number, number, number];
+export declare const toEquatorial: (x: number, y: number, z: number, eps: number) => [number, number, number];
+//# sourceMappingURL=math.d.ts.map

package/dist/engines/planet/math.js

@@ -0,0 +1,56 @@
+// ---------------------------------------------------------------------------
+// engines/planet/math — pure trig/math helpers
+// ---------------------------------------------------------------------------
+const DEG2RAD = Math.PI / 180;
+const RAD2DEG = 180 / Math.PI;
+export const sinDeg = (d) => Math.sin(d * DEG2RAD);
+export const cosDeg = (d) => Math.cos(d * DEG2RAD);
+export const asinDeg = (v) => Math.asin(Math.max(-1, Math.min(1, v))) * RAD2DEG;
+export const acosDeg = (v) => Math.acos(Math.max(-1, Math.min(1, v))) * RAD2DEG;
+export const atan2Deg = (y, x) => Math.atan2(y, x) * RAD2DEG;
+// Solve Kepler's equation M = E - e*sin(E) for E (eccentric anomaly), all in degrees
+export function kepler(M, e, tol = 1e-7) {
+    let E = M + RAD2DEG * e * sinDeg(M);
+    for (let i = 0; i < 80; i++) {
+        const dM = E - e * RAD2DEG * sinDeg(E) - M;
+        const dE = -dM / (1 - e * cosDeg(E));
+        E += dE;
+        if (Math.abs(dE) < tol)
+            break;
+    }
+    return E;
+}
+// Wrap angle to 0–360
+export const wrapAngle = (deg) => {
+    const a = deg % 360;
+    return a < 0 ? a + 360 : a;
+};
+// Signed angular difference (shortest arc, -180 to +180)
+export function angleDelta(a, b) {
+    let d = wrapAngle(b - a);
+    if (d > 180)
+        d -= 360;
+    return d;
+}
+// km → AU
+export const toAu = (km) => km * 6.6845871222684e-9;
+// Ecliptic spherical → Cartesian (lon, lat in deg, dist in any unit)
+export const toCartesian = (lon, lat, dist) => [
+    dist * cosDeg(lon) * cosDeg(lat),
+    dist * sinDeg(lon) * cosDeg(lat),
+    dist * sinDeg(lat),
+];
+// Cartesian → ecliptic spherical [lon, lat, dist]
+export const toSpherical = (x, y, z) => {
+    const lon = atan2Deg(y, x);
+    const lat = atan2Deg(z, Math.sqrt(x * x + y * y));
+    const dist = Math.sqrt(x * x + y * y + z * z);
+    return [lon, lat, dist];
+};
+// Rotate ecliptic Cartesian to equatorial by obliquity ε (deg)
+export const toEquatorial = (x, y, z, eps) => [
+    x,
+    y * cosDeg(eps) - z * sinDeg(eps),
+    y * sinDeg(eps) + z * cosDeg(eps),
+];
+//# sourceMappingURL=math.js.map

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

@@ -0,0 +1,25 @@
+export interface OrbitalElements {
+    name: string;
+    symbol: string;
+    datasets: [
+        [
+            number,
+            number
+        ][],
+        [
+            number,
+            number
+        ][],
+        [
+            number,
+            number,
+            number,
+            number
+        ]?
+    ];
+    radius: number;
+    rotation_period: number;
+}
+export type PerturbCoeffs = [number, number, number, number];
+export declare const ORBITAL_ELEMENTS: Map<string, OrbitalElements>;
+//# sourceMappingURL=orbital.d.ts.map