@elmahdistudio/zenith-core 0.1.0

package/dist/arc/arc.d.ts

@@ -0,0 +1,20 @@
+/** Convert polar angle (degrees, 0 = top, clockwise) to cartesian coordinates */
+export declare function polarToXY(cx: number, cy: number, r: number, deg: number): {
+    x: number;
+    y: number;
+};
+/** Map minutes (5-60) to angle (0-360) for the timer ring */
+export declare function minuteToAngle(m: number): number;
+/** Map angle (0-360) to the nearest snap interval in minutes */
+export declare function angleToMinute(deg: number): number;
+/** Map a 0-1 progress value to a point on a semi-elliptical sundial arc */
+export declare function pointOnSundialArc(t: number, cx: number, cy: number, arcWidth: number, arcHeight: number): {
+    x: number;
+    y: number;
+};
+/** Build an SVG arc path for the timer ring */
+export declare function buildArcPath(cx: number, cy: number, radius: number, angleDeg: number): string;
+/** Build a full circle SVG path */
+export declare function buildFullCirclePath(cx: number, cy: number, radius: number): string;
+/** Build the sundial arc SVG path from 40 segments */
+export declare function buildSundialArcPath(cx: number, cy: number, arcWidth: number, arcHeight: number, segments?: number): string;

package/dist/arc/arc.js

@@ -0,0 +1,48 @@
+import { SNAP_INTERVALS } from "../timer/timer.js";
+/** Convert polar angle (degrees, 0 = top, clockwise) to cartesian coordinates */
+export function polarToXY(cx, cy, r, deg) {
+    const rad = ((deg - 90) * Math.PI) / 180;
+    return { x: cx + r * Math.cos(rad), y: cy + r * Math.sin(rad) };
+}
+/** Map minutes (5-60) to angle (0-360) for the timer ring */
+export function minuteToAngle(m) {
+    return ((m - 5) / (60 - 5)) * 360;
+}
+/** Map angle (0-360) to the nearest snap interval in minutes */
+export function angleToMinute(deg) {
+    const norm = ((deg % 360) + 360) % 360;
+    const raw = 5 + (norm / 360) * (60 - 5);
+    return SNAP_INTERVALS.reduce((prev, curr) => Math.abs(curr - raw) < Math.abs(prev - raw) ? curr : prev);
+}
+/** Map a 0-1 progress value to a point on a semi-elliptical sundial arc */
+export function pointOnSundialArc(t, cx, cy, arcWidth, arcHeight) {
+    const angle = Math.PI * (1 - t); // PI to 0
+    const x = cx + (arcWidth / 2) * Math.cos(angle);
+    const y = cy - arcHeight * Math.sin(angle);
+    return { x, y };
+}
+/** Build an SVG arc path for the timer ring */
+export function buildArcPath(cx, cy, radius, angleDeg) {
+    if (angleDeg <= 0)
+        return "";
+    const start = polarToXY(cx, cy, radius, 0);
+    const end = polarToXY(cx, cy, radius, angleDeg);
+    const largeArc = angleDeg > 180 ? 1 : 0;
+    return `M ${start.x} ${start.y} A ${radius} ${radius} 0 ${largeArc} 1 ${end.x} ${end.y}`;
+}
+/** Build a full circle SVG path */
+export function buildFullCirclePath(cx, cy, radius) {
+    const start = polarToXY(cx, cy, radius, 0);
+    const end = polarToXY(cx, cy, radius, 359.99);
+    return `M ${start.x} ${start.y} A ${radius} ${radius} 0 1 1 ${end.x} ${end.y}`;
+}
+/** Build the sundial arc SVG path from 40 segments */
+export function buildSundialArcPath(cx, cy, arcWidth, arcHeight, segments = 40) {
+    const points = [];
+    for (let i = 0; i <= segments; i++) {
+        const t = i / segments;
+        const p = pointOnSundialArc(t, cx, cy, arcWidth, arcHeight);
+        points.push(`${i === 0 ? "M" : "L"} ${p.x.toFixed(1)} ${p.y.toFixed(1)}`);
+    }
+    return points.join(" ");
+}

package/dist/audio/ambient.d.ts

@@ -0,0 +1,11 @@
+import type { SoundId } from "../types/index.js";
+export interface AmbientPlayer {
+    start(): void;
+    stop(): void;
+    setVolume(v: number): void;
+}
+/**
+ * Create a procedural ambient sound using Web Audio API.
+ * All sounds are generated in real-time — no audio files needed.
+ */
+export declare function createAmbientPlayer(audioContext: AudioContext, soundId: SoundId): AmbientPlayer;

package/dist/audio/ambient.js

@@ -0,0 +1,174 @@
+/**
+ * Create a procedural ambient sound using Web Audio API.
+ * All sounds are generated in real-time — no audio files needed.
+ */
+export function createAmbientPlayer(audioContext, soundId) {
+    const masterGain = audioContext.createGain();
+    masterGain.gain.value = 0;
+    masterGain.connect(audioContext.destination);
+    const nodes = [];
+    let started = false;
+    function buildRain() {
+        // Brown noise filtered to sound like rain
+        const bufferSize = audioContext.sampleRate * 2;
+        const buffer = audioContext.createBuffer(1, bufferSize, audioContext.sampleRate);
+        const data = buffer.getChannelData(0);
+        let lastOut = 0;
+        for (let i = 0; i < bufferSize; i++) {
+            const white = Math.random() * 2 - 1;
+            lastOut = (lastOut + 0.02 * white) / 1.02;
+            data[i] = lastOut * 3.5;
+        }
+        const source = audioContext.createBufferSource();
+        source.buffer = buffer;
+        source.loop = true;
+        // Bandpass to shape into rain character
+        const bp = audioContext.createBiquadFilter();
+        bp.type = "bandpass";
+        bp.frequency.value = 2500;
+        bp.Q.value = 0.5;
+        // Highpass to remove rumble
+        const hp = audioContext.createBiquadFilter();
+        hp.type = "highpass";
+        hp.frequency.value = 400;
+        source.connect(bp);
+        bp.connect(hp);
+        hp.connect(masterGain);
+        nodes.push(source);
+        return source;
+    }
+    function buildOcean() {
+        // Noise shaped with slow LFO amplitude modulation for wave surges
+        const bufferSize = audioContext.sampleRate * 4;
+        const buffer = audioContext.createBuffer(1, bufferSize, audioContext.sampleRate);
+        const data = buffer.getChannelData(0);
+        let lastOut = 0;
+        for (let i = 0; i < bufferSize; i++) {
+            const white = Math.random() * 2 - 1;
+            lastOut = (lastOut + 0.04 * white) / 1.04;
+            data[i] = lastOut * 3;
+        }
+        const source = audioContext.createBufferSource();
+        source.buffer = buffer;
+        source.loop = true;
+        // Low-pass for deep ocean rumble
+        const lp = audioContext.createBiquadFilter();
+        lp.type = "lowpass";
+        lp.frequency.value = 800;
+        lp.Q.value = 0.3;
+        // LFO for wave-like amplitude modulation
+        const lfo = audioContext.createOscillator();
+        const lfoGain = audioContext.createGain();
+        lfo.frequency.value = 0.12; // ~8 second wave cycle
+        lfo.type = "sine";
+        lfoGain.gain.value = 0.4;
+        const modGain = audioContext.createGain();
+        modGain.gain.value = 0.6;
+        lfo.connect(lfoGain);
+        lfoGain.connect(modGain.gain);
+        source.connect(lp);
+        lp.connect(modGain);
+        modGain.connect(masterGain);
+        lfo.start();
+        nodes.push(source, lfo);
+        return source;
+    }
+    function buildForest() {
+        // Gentle ambient hiss (wind through leaves) + subtle tonal hum
+        const bufferSize = audioContext.sampleRate * 3;
+        const buffer = audioContext.createBuffer(1, bufferSize, audioContext.sampleRate);
+        const data = buffer.getChannelData(0);
+        for (let i = 0; i < bufferSize; i++) {
+            data[i] = (Math.random() * 2 - 1) * 0.3;
+        }
+        const source = audioContext.createBufferSource();
+        source.buffer = buffer;
+        source.loop = true;
+        // Very narrow bandpass for wind character
+        const bp = audioContext.createBiquadFilter();
+        bp.type = "bandpass";
+        bp.frequency.value = 1200;
+        bp.Q.value = 0.8;
+        // Slow modulation for rustling
+        const lfo = audioContext.createOscillator();
+        const lfoGain = audioContext.createGain();
+        lfo.frequency.value = 0.3;
+        lfo.type = "sine";
+        lfoGain.gain.value = 0.3;
+        const modGain = audioContext.createGain();
+        modGain.gain.value = 0.7;
+        lfo.connect(lfoGain);
+        lfoGain.connect(modGain.gain);
+        source.connect(bp);
+        bp.connect(modGain);
+        modGain.connect(masterGain);
+        lfo.start();
+        nodes.push(source, lfo);
+        return source;
+    }
+    function buildBowl() {
+        // Continuous singing bowl drone: layered sine tones with slow beating
+        const fundamentals = [174.6, 220, 277.2]; // F3, A3, C#4 (a shimmering chord)
+        const sources = [];
+        fundamentals.forEach((freq, i) => {
+            // Main tone
+            const osc = audioContext.createOscillator();
+            osc.frequency.value = freq;
+            osc.type = "sine";
+            // Slightly detuned copy for natural beating
+            const osc2 = audioContext.createOscillator();
+            osc2.frequency.value = freq + 0.5 + i * 0.3;
+            osc2.type = "sine";
+            const g = audioContext.createGain();
+            g.gain.value = 0.08 / (i + 1);
+            osc.connect(g);
+            osc2.connect(g);
+            g.connect(masterGain);
+            sources.push(osc, osc2);
+            nodes.push(osc, osc2);
+        });
+        return sources;
+    }
+    return {
+        start() {
+            if (started)
+                return;
+            started = true;
+            if (soundId === "rain") {
+                buildRain().start();
+            }
+            else if (soundId === "ocean") {
+                buildOcean().start();
+            }
+            else if (soundId === "forest") {
+                buildForest().start();
+            }
+            else if (soundId === "bowl") {
+                const sources = buildBowl();
+                sources.forEach((s) => s.start());
+            }
+            // Fade in
+            masterGain.gain.setValueAtTime(0, audioContext.currentTime);
+            masterGain.gain.linearRampToValueAtTime(0.6, audioContext.currentTime + 1.5);
+        },
+        stop() {
+            if (!started)
+                return;
+            const now = audioContext.currentTime;
+            masterGain.gain.linearRampToValueAtTime(0, now + 1.0);
+            setTimeout(() => {
+                nodes.forEach((n) => {
+                    try {
+                        if (n instanceof AudioScheduledSourceNode)
+                            n.stop();
+                    }
+                    catch { /* already stopped */ }
+                });
+                started = false;
+            }, 1200);
+        },
+        setVolume(v) {
+            masterGain.gain.linearRampToValueAtTime(Math.max(0, Math.min(1, v)), audioContext.currentTime + 0.1);
+        },
+    };
+}

package/dist/audio/chime.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Play a singing bowl strike — layered harmonics with long decay.
+ * Much warmer and more resonant than the previous sine-wave beeps.
+ */
+export declare function playChime(audioContext: AudioContext): void;

package/dist/audio/chime.js

@@ -0,0 +1,47 @@
+/**
+ * Play a singing bowl strike — layered harmonics with long decay.
+ * Much warmer and more resonant than the previous sine-wave beeps.
+ */
+export function playChime(audioContext) {
+    const now = audioContext.currentTime;
+    // Singing bowl harmonics: fundamental + partials at non-integer ratios
+    // This creates the characteristic metallic shimmer
+    const harmonics = [
+        { freq: 220, gain: 0.25, decay: 4.0 }, // fundamental A3
+        { freq: 440, gain: 0.15, decay: 3.5 }, // octave
+        { freq: 556, gain: 0.08, decay: 3.0 }, // non-integer partial (bowl character)
+        { freq: 660, gain: 0.06, decay: 2.5 }, // fifth
+        { freq: 880, gain: 0.04, decay: 2.0 }, // double octave
+        { freq: 1120, gain: 0.02, decay: 1.5 }, // high shimmer
+    ];
+    harmonics.forEach(({ freq, gain: vol, decay }) => {
+        const osc = audioContext.createOscillator();
+        const gainNode = audioContext.createGain();
+        osc.connect(gainNode);
+        gainNode.connect(audioContext.destination);
+        osc.frequency.value = freq;
+        osc.type = "sine";
+        // Attack: quick rise then long exponential decay
+        gainNode.gain.setValueAtTime(0.001, now);
+        gainNode.gain.linearRampToValueAtTime(vol, now + 0.02);
+        gainNode.gain.exponentialRampToValueAtTime(0.001, now + decay);
+        osc.start(now);
+        osc.stop(now + decay + 0.1);
+    });
+    // Add a second softer strike 1.5s later for depth
+    const delay = 1.5;
+    [220, 440, 556].forEach((freq, i) => {
+        const osc = audioContext.createOscillator();
+        const gainNode = audioContext.createGain();
+        osc.connect(gainNode);
+        gainNode.connect(audioContext.destination);
+        osc.frequency.value = freq;
+        osc.type = "sine";
+        const vol = [0.12, 0.07, 0.04][i];
+        gainNode.gain.setValueAtTime(0.001, now + delay);
+        gainNode.gain.linearRampToValueAtTime(vol, now + delay + 0.02);
+        gainNode.gain.exponentialRampToValueAtTime(0.001, now + delay + 3.5);
+        osc.start(now + delay);
+        osc.stop(now + delay + 3.6);
+    });
+}

package/dist/celestial/celestial.d.ts

@@ -0,0 +1,3 @@
+import type { Coordinates, CelestialData } from "../types/index.js";
+export declare const DEFAULT_COORDS: Coordinates;
+export declare function calculateCelestial(coords: Coordinates, now?: Date): CelestialData;

package/dist/celestial/celestial.js

@@ -0,0 +1,30 @@
+import SunCalc from "suncalc";
+export const DEFAULT_COORDS = { lat: 51.5074, lng: -0.1278 };
+export function calculateCelestial(coords, now) {
+    const date = now ?? new Date();
+    const times = SunCalc.getTimes(date, coords.lat, coords.lng);
+    const sunPos = SunCalc.getPosition(date, coords.lat, coords.lng);
+    const moonPos = SunCalc.getMoonPosition(date, coords.lat, coords.lng);
+    const moonIllum = SunCalc.getMoonIllumination(date);
+    const sunrise = times.sunrise;
+    const sunset = times.sunset;
+    const isDaytime = date >= sunrise && date <= sunset;
+    const dayLength = sunset.getTime() - sunrise.getTime();
+    const sunArcProgress = dayLength > 0
+        ? Math.max(0, Math.min(1, (date.getTime() - sunrise.getTime()) / dayLength))
+        : 0.5;
+    // Moon arc: normalize azimuth from -PI..PI to 0..1
+    const moonArcProgress = (moonPos.azimuth + Math.PI) / (2 * Math.PI);
+    const locationGranted = coords.lat !== DEFAULT_COORDS.lat || coords.lng !== DEFAULT_COORDS.lng;
+    return {
+        sunrise,
+        sunset,
+        sunPosition: sunPos,
+        moonPosition: moonPos,
+        moonPhase: moonIllum.phase,
+        isDaytime,
+        sunArcProgress,
+        moonArcProgress,
+        locationGranted,
+    };
+}

package/dist/constellation/constellations.d.ts

@@ -0,0 +1,3 @@
+import type { Constellation } from "../types/index.js";
+export declare const constellations: Constellation[];
+export declare function getCurrentConstellation(now?: Date): Constellation;

package/dist/constellation/constellations.js

@@ -0,0 +1,90 @@
+export const constellations = [
+    {
+        name: "Aquarius",
+        points: [[170, 100], [140, 80], [110, 100], [80, 80], [50, 100], [140, 120], [110, 140], [80, 120]],
+        paths: ["M 170 100 L 140 80 L 110 100 L 80 80 L 50 100", "M 140 80 L 140 120 L 110 140 L 80 120 L 80 80"],
+        dateRange: [120, 218],
+    },
+    {
+        name: "Pisces",
+        points: [[180, 60], [140, 90], [100, 110], [60, 130], [20, 160], [60, 80], [40, 40], [80, 40]],
+        paths: ["M 180 60 L 140 90 L 100 110 L 60 130 L 20 160", "M 100 110 L 60 80 L 40 40 L 80 40 L 60 80"],
+        dateRange: [219, 320],
+    },
+    {
+        name: "Aries",
+        points: [[170, 60], [130, 50], [100, 80], [80, 110]],
+        paths: ["M 170 60 L 130 50 L 100 80 L 80 110"],
+        dateRange: [321, 419],
+    },
+    {
+        name: "Taurus",
+        points: [[180, 30], [140, 70], [110, 90], [115, 110], [90, 120], [50, 130], [30, 160]],
+        paths: ["M 180 30 L 140 70 L 110 90", "M 110 90 L 115 110 L 90 120 L 50 130 L 30 160"],
+        dateRange: [420, 520],
+    },
+    {
+        name: "Gemini",
+        points: [[150, 40], [170, 70], [130, 100], [100, 120], [70, 140], [50, 170], [130, 50], [110, 80], [80, 100]],
+        paths: ["M 150 40 L 170 70 L 130 100 L 100 120 L 70 140 L 50 170", "M 130 50 L 110 80 L 80 100"],
+        dateRange: [521, 620],
+    },
+    {
+        name: "Cancer",
+        points: [[100, 50], [100, 90], [70, 120], [130, 120]],
+        paths: ["M 100 50 L 100 90 L 70 120", "M 100 90 L 130 120"],
+        dateRange: [621, 722],
+    },
+    {
+        name: "Leo",
+        points: [[160, 140], [120, 150], [80, 140], [60, 110], [70, 70], [100, 60], [120, 80], [150, 80]],
+        paths: ["M 160 140 L 120 150 L 80 140 L 60 110 L 70 70 L 100 60 L 120 80 L 100 60", "M 120 80 L 150 80"],
+        dateRange: [723, 822],
+    },
+    {
+        name: "Virgo",
+        points: [[170, 60], [140, 90], [110, 100], [100, 130], [70, 140], [50, 110], [40, 80], [130, 150]],
+        paths: ["M 170 60 L 140 90 L 110 100 L 100 130 L 70 140 L 50 110 L 40 80", "M 100 130 L 130 150"],
+        dateRange: [823, 922],
+    },
+    {
+        name: "Libra",
+        points: [[100, 60], [130, 100], [100, 140], [70, 100], [40, 120]],
+        paths: ["M 100 60 L 130 100 L 100 140 L 70 100 L 130 100", "M 70 100 L 40 120"],
+        dateRange: [923, 1022],
+    },
+    {
+        name: "Scorpio",
+        points: [[180, 50], [140, 60], [110, 80], [100, 120], [110, 150], [140, 160], [170, 150]],
+        paths: ["M 180 50 L 140 60 L 110 80 L 100 120 L 110 150 L 140 160 L 170 150"],
+        dateRange: [1023, 1121],
+    },
+    {
+        name: "Sagittarius",
+        points: [[160, 80], [130, 70], [100, 80], [100, 120], [130, 130], [160, 120], [180, 60], [180, 140]],
+        paths: ["M 160 80 L 130 70 L 100 80 L 100 120 L 130 130 L 160 120 L 160 80", "M 160 80 L 180 60", "M 160 120 L 180 140"],
+        dateRange: [1122, 1221],
+    },
+    {
+        name: "Capricorn",
+        points: [[180, 80], [120, 60], [60, 80], [40, 120], [80, 160], [140, 140]],
+        paths: ["M 180 80 L 120 60 L 60 80 L 40 120 L 80 160 L 140 140 L 180 80"],
+        dateRange: [1222, 119],
+    },
+];
+export function getCurrentConstellation(now) {
+    const date = now ?? new Date();
+    const mmdd = (date.getMonth() + 1) * 100 + date.getDate();
+    for (const c of constellations) {
+        if (c.dateRange[0] <= c.dateRange[1]) {
+            if (mmdd >= c.dateRange[0] && mmdd <= c.dateRange[1])
+                return c;
+        }
+        else {
+            // Wraps around year (Capricorn)
+            if (mmdd >= c.dateRange[0] || mmdd <= c.dateRange[1])
+                return c;
+        }
+    }
+    return constellations[0]; // fallback
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./types/index.js";
+export * from "./timer/timer.js";
+export * from "./celestial/celestial.js";
+export * from "./constellation/constellations.js";
+export * from "./audio/chime.js";
+export * from "./audio/ambient.js";
+export * from "./arc/arc.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from "./types/index.js";
+export * from "./timer/timer.js";
+export * from "./celestial/celestial.js";
+export * from "./constellation/constellations.js";
+export * from "./audio/chime.js";
+export * from "./audio/ambient.js";
+export * from "./arc/arc.js";

package/dist/timer/timer.d.ts

@@ -0,0 +1,21 @@
+import type { SessionState, SoundId, BreathCycleConfig } from "../types/index.js";
+export declare const SNAP_INTERVALS: readonly [5, 10, 15, 20, 25, 30, 45, 60];
+export declare const BREATHE_CYCLE: BreathCycleConfig;
+export declare function createInitialSession(): SessionState;
+export declare function clampDuration(minutes: number): number;
+export declare function snapToInterval(minutes: number): number;
+/**
+ * Compute elapsed from wall-clock time. Call on every tick AND
+ * on visibilitychange to catch up after background throttling.
+ */
+export declare function syncSession(session: SessionState, now: number): SessionState;
+export declare function isSessionComplete(prev: SessionState, next: SessionState): boolean;
+export declare function toggleSession(session: SessionState, now: number): SessionState;
+export declare function resetSession(session: SessionState): SessionState;
+export declare function setDuration(session: SessionState, minutes: number): SessionState;
+export declare function setSound(session: SessionState, sound: SoundId | null): SessionState;
+export declare function getRemainingSeconds(session: SessionState): number;
+export declare function formatTime(remainingSeconds: number): {
+    minutes: string;
+    seconds: string;
+};

package/dist/timer/timer.js

@@ -0,0 +1,106 @@
+export const SNAP_INTERVALS = [5, 10, 15, 20, 25, 30, 45, 60];
+export const BREATHE_CYCLE = {
+    inhale: 4,
+    hold: 7,
+    exhale: 8,
+};
+export function createInitialSession() {
+    return {
+        status: "idle",
+        duration: 10,
+        elapsed: 0,
+        startedAt: null,
+        elapsedBeforePause: 0,
+        selectedSound: null,
+    };
+}
+export function clampDuration(minutes) {
+    return Math.max(5, Math.min(60, minutes));
+}
+export function snapToInterval(minutes) {
+    return SNAP_INTERVALS.reduce((prev, curr) => Math.abs(curr - minutes) < Math.abs(prev - minutes) ? curr : prev);
+}
+/**
+ * Compute elapsed from wall-clock time. Call on every tick AND
+ * on visibilitychange to catch up after background throttling.
+ */
+export function syncSession(session, now) {
+    if (session.status !== "active" || session.startedAt === null)
+        return session;
+    const totalSeconds = session.duration * 60;
+    const wallElapsed = Math.floor((now - session.startedAt) / 1000);
+    const newElapsed = Math.min(session.elapsedBeforePause + wallElapsed, totalSeconds);
+    if (newElapsed >= totalSeconds) {
+        return {
+            ...session,
+            status: "completed",
+            elapsed: totalSeconds,
+            startedAt: null,
+        };
+    }
+    return {
+        ...session,
+        elapsed: newElapsed,
+    };
+}
+export function isSessionComplete(prev, next) {
+    return prev.status === "active" && next.status === "completed";
+}
+export function toggleSession(session, now) {
+    if (session.status === "active") {
+        // Pausing
+        return {
+            ...session,
+            status: "paused",
+            elapsedBeforePause: session.elapsed,
+            startedAt: null,
+        };
+    }
+    else {
+        // Starting or resuming (from idle, paused, or completed)
+        const isRestart = session.status === "completed" || session.status === "idle";
+        return {
+            ...session,
+            status: "active",
+            elapsed: isRestart ? 0 : session.elapsed,
+            elapsedBeforePause: isRestart ? 0 : session.elapsedBeforePause,
+            startedAt: now,
+        };
+    }
+}
+export function resetSession(session) {
+    return {
+        ...session,
+        status: "idle",
+        elapsed: 0,
+        elapsedBeforePause: 0,
+        startedAt: null,
+    };
+}
+export function setDuration(session, minutes) {
+    return {
+        ...session,
+        duration: clampDuration(minutes),
+        elapsed: 0,
+        elapsedBeforePause: 0,
+        startedAt: null,
+        status: "idle",
+    };
+}
+export function setSound(session, sound) {
+    return {
+        ...session,
+        selectedSound: sound,
+    };
+}
+export function getRemainingSeconds(session) {
+    return session.duration * 60 - session.elapsed;
+}
+export function formatTime(remainingSeconds) {
+    const mins = Math.floor(remainingSeconds / 60);
+    const secs = remainingSeconds % 60;
+    return {
+        minutes: String(mins).padStart(2, "0"),
+        seconds: String(secs).padStart(2, "0"),
+    };
+}

package/dist/types/index.d.ts

@@ -0,0 +1,51 @@
+export type SoundId = "rain" | "forest" | "ocean" | "bowl";
+export type BreathPhase = "inhale" | "hold" | "exhale";
+export interface BreathCycleConfig {
+    inhale: number;
+    hold: number;
+    exhale: number;
+}
+export type SessionStatus = "idle" | "active" | "paused" | "completed";
+export interface SessionState {
+    status: SessionStatus;
+    /** Duration in minutes */
+    duration: number;
+    /** Elapsed time in seconds */
+    elapsed: number;
+    /** Wall-clock timestamp (ms) when the session was started/resumed */
+    startedAt: number | null;
+    /** Elapsed seconds accumulated before the most recent pause */
+    elapsedBeforePause: number;
+    selectedSound: SoundId | null;
+}
+export interface Coordinates {
+    lat: number;
+    lng: number;
+}
+export interface CelestialData {
+    sunrise: Date | null;
+    sunset: Date | null;
+    sunPosition: {
+        altitude: number;
+        azimuth: number;
+    } | null;
+    moonPosition: {
+        altitude: number;
+        azimuth: number;
+    } | null;
+    /** 0-1 representing the lunar phase */
+    moonPhase: number;
+    isDaytime: boolean;
+    /** Sun progress along the arc: 0 = sunrise, 1 = sunset */
+    sunArcProgress: number;
+    /** Moon progress along the arc: 0-1 based on azimuth */
+    moonArcProgress: number;
+    locationGranted: boolean;
+}
+export interface Constellation {
+    name: string;
+    points: [number, number][];
+    paths: string[];
+    /** [startMMDD, endMMDD] */
+    dateRange: [number, number];
+}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@elmahdistudio/zenith-core",
+  "version": "0.1.0",
+  "type": "module",
+  "files": ["dist"],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.json",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "suncalc": "^1.9.0"
+  },
+  "devDependencies": {
+    "@types/suncalc": "^1.9.2",
+    "typescript": "^5.8.3"
+  }
+}