Deploy Aether Garden application

app.py

@@ -1164,37 +1164,126 @@ def build_app() -> gr.Blocks:
                     };
 
                     const ensureAmbientMelody = () => {
-                        if (window._aetherAmbientStarted) return;
+                        if (window._aetherAmbientStarted) {
+                            window._aetherAmbientCtx?.resume?.();
+                            return;
+                        }
                         try {
                             const AudioCtx = window.AudioContext || window.webkitAudioContext;
                             if (!AudioCtx) return;
                             const ctx = new AudioCtx();
+                            window._aetherAmbientCtx = ctx;
+
                             const master = ctx.createGain();
-                            master.gain.value = 0.022;
+                            master.gain.value = 0.0001;
+
+                            const warmth = ctx.createBiquadFilter();
+                            warmth.type = 'lowpass';
+                            warmth.frequency.value = prefersReduced ? 1600 : 2400;
+                            warmth.Q.value = 0.5;
+
+                            const delay = ctx.createDelay(2.8);
+                            delay.delayTime.value = 0.48;
+                            const delayFb = ctx.createGain();
+                            delayFb.gain.value = 0.26;
+                            const delayMix = ctx.createGain();
+                            delayMix.gain.value = 0.32;
+
+                            warmth.connect(delay);
+                            delay.connect(delayFb);
+                            delayFb.connect(delay);
+                            delay.connect(delayMix);
+                            delayMix.connect(master);
+                            warmth.connect(master);
                             master.connect(ctx.destination);
 
-                            const notes = [220, 261.63, 329.63];
-                            notes.forEach((freq, i) => {
+                            const now = ctx.currentTime;
+                            master.gain.linearRampToValueAtTime(prefersReduced ? 0.009 : 0.013, now + 5);
+
+                            const padNotes = [220, 261.63, 293.66, 329.63, 392, 440];
+                            padNotes.forEach((freq, i) => {
                                 const osc = ctx.createOscillator();
-                                const gain = ctx.createGain();
-                                osc.type = i === 0 ? 'sine' : 'triangle';
+                                const osc2 = ctx.createOscillator();
+                                const g = ctx.createGain();
+                                const g2 = ctx.createGain();
+                                osc.type = 'sine';
+                                osc2.type = 'triangle';
                                 osc.frequency.value = freq;
-                                gain.gain.value = 0.0001;
-                                osc.connect(gain);
-                                gain.connect(master);
+                                osc2.frequency.value = freq * 1.0015;
+                                const base = 0.0007 / (i * 0.55 + 1);
+                                g.gain.value = base;
+                                g2.gain.value = base * 0.45;
+                                osc.connect(g);
+                                osc2.connect(g2);
+                                g.connect(warmth);
+                                g2.connect(warmth);
                                 osc.start();
-
-                                const pulse = () => {
-                                    const now = ctx.currentTime;
-                                    gain.gain.cancelScheduledValues(now);
-                                    gain.gain.setValueAtTime(Math.max(gain.gain.value, 0.0001), now);
-                                    gain.gain.exponentialRampToValueAtTime(0.014 / (i + 1), now + 2.2 + i * 0.35);
-                                    gain.gain.exponentialRampToValueAtTime(0.00012, now + 7.5 + i * 0.4);
+                                osc2.start();
+
+                                const breathe = () => {
+                                    const t = ctx.currentTime;
+                                    g.gain.cancelScheduledValues(t);
+                                    g.gain.setValueAtTime(g.gain.value, t);
+                                    g.gain.linearRampToValueAtTime(base * 2.1, t + 4 + i * 0.4);
+                                    g.gain.linearRampToValueAtTime(base * 0.55, t + 10 + i * 0.35);
                                 };
-                                pulse();
-                                setInterval(pulse, 7000 + i * 400);
+                                breathe();
+                                setInterval(breathe, 9000 + i * 800);
                             });
+
+                            const melodyNotes = [
+                                392, 440, 493.88, 523.25, 587.33, 659.25,
+                                587.33, 523.25, 440, 392, 329.63, 293.66, 329.63, 392
+                            ];
+                            let noteIdx = 0;
+                            const playBell = () => {
+                                if (!window._aetherAmbientStarted) return;
+                                const freq = melodyNotes[noteIdx % melodyNotes.length];
+                                noteIdx += 1;
+                                const t = ctx.currentTime;
+                                const osc = ctx.createOscillator();
+                                const env = ctx.createGain();
+                                osc.type = 'sine';
+                                osc.frequency.value = freq;
+                                env.gain.setValueAtTime(0.0001, t);
+                                env.gain.exponentialRampToValueAtTime(0.0065, t + 0.12);
+                                env.gain.exponentialRampToValueAtTime(0.0001, t + 3.2);
+                                osc.connect(env);
+                                env.connect(warmth);
+                                osc.start(t);
+                                osc.stop(t + 3.4);
+                            };
+
+                            const scheduleMelody = () => {
+                                if (!window._aetherAmbientStarted) return;
+                                playBell();
+                                setTimeout(scheduleMelody, 2600 + Math.random() * 2400);
+                            };
+                            setTimeout(scheduleMelody, 1800);
+
+                            const shimmer = () => {
+                                if (!window._aetherAmbientStarted) return;
+                                const t = ctx.currentTime;
+                                const osc = ctx.createOscillator();
+                                const env = ctx.createGain();
+                                osc.type = 'triangle';
+                                osc.frequency.value = 880 + Math.random() * 264;
+                                env.gain.setValueAtTime(0.0001, t);
+                                env.gain.exponentialRampToValueAtTime(0.0028, t + 0.6);
+                                env.gain.exponentialRampToValueAtTime(0.0001, t + 5);
+                                osc.connect(env);
+                                env.connect(warmth);
+                                osc.start(t);
+                                osc.stop(t + 5.2);
+                                setTimeout(shimmer, 14000 + Math.random() * 10000);
+                            };
+                            setTimeout(shimmer, 6000);
+
                             window._aetherAmbientStarted = true;
+
+                            document.addEventListener('visibilitychange', () => {
+                                if (document.visibilityState === 'visible') ctx.resume();
+                            }, { passive: true });
                         } catch (_) {}
                     };
 
@@ -1275,6 +1364,7 @@ def build_app() -> gr.Blocks:
                         gate.classList.remove('is-reclosed', 'is-back-visible', 'is-closing');
                         gate.classList.add('is-opened', 'is-closed');
                         playOpeningChime();
+                        ensureAmbientMelody();
                     };
 
                     const goToSpread = (idx, direction = 'next') => {
@@ -1494,6 +1584,7 @@ def build_app() -> gr.Blocks:
 
                         const beginUnfold = () => {
                             playOpeningChime();
+                            ensureAmbientMelody();
                             gate.classList.add('is-unfolding');
                             if (book3d) book3d.classList.add('is-opening');
                             if (openBook) openBook.setAttribute('aria-hidden', 'false');