fluxy-bot 0.10.16 → 0.10.18

package/cli/commands/update.ts

@@ -88,6 +88,15 @@ export function registerUpdateCommand(program: Command) {
           fs.cpSync(wsSrc, path.join(DATA_DIR, 'workspace'), { recursive: true });
         }
 
+        // Always update index.html — contains splash screen, SW registration,
+        // and meta tags that ship with each version. Safe to overwrite since
+        // users don't edit this file (their code lives in src/ and backend/).
+        const indexSrc = path.join(extracted, 'workspace', 'client', 'index.html');
+        const indexDst = path.join(DATA_DIR, 'workspace', 'client', 'index.html');
+        if (fs.existsSync(indexSrc)) {
+          fs.cpSync(indexSrc, indexDst, { force: true });
+        }
+
         for (const file of ['package.json', 'vite.config.ts', 'vite.fluxy.config.ts', 'tsconfig.json', 'postcss.config.js', 'components.json']) {
           const src = path.join(extracted, file);
           if (fs.existsSync(src)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluxy-bot",
-  "version": "0.10.16",
+  "version": "0.10.18",
   "releaseNotes": [
     "Adding a way for users to claim their fluxies on the fluxy.bot dashboard",
     "2. ",

package/supervisor/widget.js

@@ -6,11 +6,9 @@
   // ── Styles ──
   var style = document.createElement('style');
   style.textContent = [
-    '#fluxy-widget-bubble{position:fixed;bottom:24px;right:24px;z-index:99998;cursor:pointer;width:60px;height:60px;border-radius:50%;display:flex;align-items:center;justify-content:center;transition:transform .15s ease;-webkit-tap-highlight-color:transparent}',
+    '#fluxy-widget-bubble{transition:transform .15s ease;-webkit-tap-highlight-color:transparent}',
     '#fluxy-widget-bubble:hover{transform:scale(1.1)}',
     '#fluxy-widget-bubble:active{transform:scale(0.95)}',
-    '#fluxy-widget-bubble video{height:60px;width:auto;pointer-events:none;-webkit-user-drag:none}',
-    '#fluxy-widget-bubble img{width:60px;height:60px;object-fit:contain;pointer-events:none;-webkit-user-drag:none}',
     '#fluxy-widget-backdrop{position:fixed;inset:0;z-index:99998;background:rgba(0,0,0,0.4);opacity:0;transition:opacity .2s ease;pointer-events:none}',
     '#fluxy-widget-backdrop.open{opacity:1;pointer-events:auto}',
     '#fluxy-widget-panel{position:fixed;top:0;right:0;bottom:0;z-index:99999;width:' + PANEL_WIDTH + ';max-width:100vw;transform:translateX(100%);transition:transform .25s cubic-bezier(.4,0,.2,1);box-shadow:-4px 0 24px rgba(0,0,0,0.3);border-left:1px solid #3a3a3a;overflow:hidden}',
@@ -35,50 +33,360 @@
   iframe.setAttribute('loading', 'lazy');
   panel.appendChild(iframe);
 
-  // ── Bubble ──
-  var bubble = document.createElement('div');
-  bubble.id = 'fluxy-widget-bubble';
-  bubble.setAttribute('role', 'button');
-  bubble.setAttribute('aria-label', 'Open Fluxy chat');
-
-  // Safari doesn't support WebM alpha — fall back to poster image
-  var isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent)
-    || (/iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream);
-
-  if (isSafari) {
-    var img = document.createElement('img');
-    img.src = '/fluxy_frame1.png';
-    img.alt = 'Fluxy';
-    img.draggable = false;
-    bubble.appendChild(img);
-  } else {
-    var video = document.createElement('video');
-    video.src = '/fluxy_tilts.webm';
-    video.poster = '/fluxy_frame1.png';
-    video.autoplay = true;
-    video.loop = true;
-    video.muted = true;
-    video.playsInline = true;
-    video.setAttribute('playsinline', '');
-    video.draggable = false;
-    bubble.appendChild(video);
+  // ══════════════════════════════════════════════════════════════════
+  // ── Sprite Sheet Animation (Splash + Bubble) ─────────────────────
+  // ══════════════════════════════════════════════════════════════════
+
+  // ── Sprite config ──
+  var COLS = 16;
+  var FRAME_W = 125;
+  var FRAME_H = 120;
+  var DISPLAY_H = 58;
+  var DISPLAY_W = DISPLAY_H * (FRAME_W / FRAME_H);
+
+  // Frame ranges (0-indexed)
+  var IDLE_START = 0, IDLE_END = 29;
+  var MELT_START = 30, MELT_END = 52;
+  var TRAVEL_START = 52, TRAVEL_END = 84;
+  var REFORM_START = 84, REFORM_END = 191;
+
+  // Timing
+  var FPS = 29;
+  var FRAME_MS = 1000 / FPS;
+  var IDLE_FPS = 22;
+  var IDLE_FRAME_MS = 1000 / IDLE_FPS;
+  var REFORM_FPS = 70;
+  var REFORM_FRAME_MS = 1000 / REFORM_FPS;
+
+  var TRAVEL_PX_PER_MS = 0.65;
+  var TRAVEL_MIN = 385;
+  var TRAVEL_MAX = 1150;
+  var MIN_SPLASH_MS = 2000;
+  var BUBBLE_SIZE = 60;
+  var BUBBLE_MARGIN = 24;
+
+  // ── Easing ──
+  function easeInOutCubic(t) { return t < 0.5 ? 4*t*t*t : 1 - Math.pow(-2*t + 2, 3) / 2; }
+
+  // ── Canvas setup (starts fullscreen for splash) ──
+  var canvas = document.createElement('canvas');
+  canvas.id = 'fluxy-widget-bubble';
+  canvas.setAttribute('role', 'button');
+  canvas.setAttribute('aria-label', 'Open Fluxy chat');
+  canvas.dataset.fluxyWidget = '1';
+  canvas.style.cssText = 'position:fixed;inset:0;width:100vw;height:100dvh;z-index:9999;pointer-events:none;';
+  document.body.appendChild(canvas);
+
+  var bubble = canvas;
+  var ctx = canvas.getContext('2d');
+  var dpr = window.devicePixelRatio || 1;
+  var W = 0, H = 0;
+
+  // ── Canvas phase: 'splash' | 'transitioning' | 'bubble' | 'disabled' ──
+  var canvasPhase = 'splash';
+  var canvasCreatedAt = Date.now();
+  var appReady = false;
+  var hideAfterTransition = false;
+  var skipSplash = false;
+
+  function resizeCanvas() {
+    if (canvasPhase === 'bubble') {
+      W = BUBBLE_SIZE;
+      H = BUBBLE_SIZE;
+    } else {
+      W = window.innerWidth;
+      H = window.innerHeight;
+    }
+    canvas.width = W * dpr;
+    canvas.height = H * dpr;
+    canvas.style.width = W + 'px';
+    canvas.style.height = H + 'px';
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+  }
+  resizeCanvas();
+  window.addEventListener('resize', function () {
+    resizeCanvas();
+    if (canvasPhase === 'splash' && animState === 'idle') {
+      center.x = Math.round(W / 2);
+      center.y = Math.round(H / 2);
+    }
+  });
+
+  // ── Animation state ──
+  var spriteSheet = null;
+  var animState = 'loading';
+  var currentFrame = 0;
+  var idleDirection = 1;
+  var lastFrameTime = 0;
+  var travelDuration = 0;
+  var travelStartTime = 0;
+  var travelAngle = 0;
+  var travelDrawAngle = 0;
+  var travelFlip = 1;
+
+  var center  = { x: 0, y: 0 };
+  var travelA = { x: 0, y: 0 };
+  var target  = { x: 0, y: 0 };
+
+  // ── Load sprite sheet ──
+  function loadSprite(onDone, onFail) {
+    var img = new Image();
+    img.onload = function () {
+      spriteSheet = img;
+      center.x = Math.round(W / 2);
+      center.y = Math.round(H / 2);
+      currentFrame = IDLE_START;
+      animState = 'idle';
+
+      // Hide the HTML splash fallback
+      var splash = document.getElementById('splash');
+      if (splash) splash.style.display = 'none';
+
+      onDone();
+    };
+    img.onerror = function () {
+      if (onFail) onFail();
+    };
+    img.src = '/spritesheet.webp';
+  }
+
+  // ── Trigger move ──
+  function moveTo(tx, ty) {
+    if (animState !== 'idle') return;
+    target.x = tx;
+    target.y = ty;
+    travelA.x = center.x;
+    travelA.y = center.y;
+
+    var dx = target.x - center.x;
+    var dy = target.y - center.y;
+    var dist = Math.sqrt(dx * dx + dy * dy);
+
+    travelAngle = Math.atan2(dy, dx);
+    travelDrawAngle = travelAngle;
+    travelFlip = 1;
+    if (travelDrawAngle > Math.PI / 2) { travelDrawAngle -= Math.PI; travelFlip = -1; }
+    else if (travelDrawAngle < -Math.PI / 2) { travelDrawAngle += Math.PI; travelFlip = -1; }
+    travelDuration = Math.min(TRAVEL_MAX, Math.max(TRAVEL_MIN, dist / TRAVEL_PX_PER_MS));
+
+    currentFrame = MELT_START;
+    lastFrameTime = performance.now();
+    animState = 'melting';
+  }
+
+  // ── Update ──
+  function update(now) {
+    // Smooth position update during travel (every rAF)
+    if (animState === 'traveling') {
+      var elapsed = now - travelStartTime;
+      var progress = Math.min(1, elapsed / travelDuration);
+      var e = easeInOutCubic(progress);
+      center.x = travelA.x + (target.x - travelA.x) * e;
+      center.y = travelA.y + (target.y - travelA.y) * e;
+
+      if (progress >= 1) {
+        center.x = target.x;
+        center.y = target.y;
+        animState = 'reforming';
+        currentFrame = REFORM_START;
+        lastFrameTime = now;
+        return;
+      }
+    }
+
+    // Sprite frame advance (at configured FPS)
+    var frameInterval = animState === 'idle' ? IDLE_FRAME_MS
+                      : animState === 'reforming' ? REFORM_FRAME_MS
+                      : FRAME_MS;
+    var frameDelta = now - lastFrameTime;
+    if (frameDelta < frameInterval) return;
+    lastFrameTime = now - (frameDelta % frameInterval);
+
+    if (animState === 'idle') {
+      currentFrame += idleDirection;
+      if (currentFrame >= IDLE_END) { currentFrame = IDLE_END; idleDirection = -1; }
+      else if (currentFrame <= IDLE_START) { currentFrame = IDLE_START; idleDirection = 1; }
+    } else if (animState === 'melting') {
+      currentFrame++;
+      if (currentFrame > MELT_END) {
+        animState = 'traveling';
+        currentFrame = TRAVEL_START;
+        travelStartTime = now;
+      }
+    } else if (animState === 'traveling') {
+      currentFrame++;
+      if (currentFrame > TRAVEL_END) currentFrame = TRAVEL_START;
+    } else if (animState === 'reforming') {
+      currentFrame++;
+      if (currentFrame > REFORM_END) {
+        animState = 'idle';
+        currentFrame = IDLE_START;
+        idleDirection = 1;
+        // Transition canvas to bubble mode
+        if (canvasPhase === 'transitioning') {
+          canvasPhase = 'bubble';
+          canvas.style.cssText = 'position:fixed;bottom:' + BUBBLE_MARGIN + 'px;right:' + BUBBLE_MARGIN + 'px;width:' + BUBBLE_SIZE + 'px;height:' + BUBBLE_SIZE + 'px;z-index:99998;cursor:pointer;border-radius:50%;transition:transform .15s ease;-webkit-tap-highlight-color:transparent;';
+          W = BUBBLE_SIZE;
+          H = BUBBLE_SIZE;
+          canvas.width = BUBBLE_SIZE * dpr;
+          canvas.height = BUBBLE_SIZE * dpr;
+          ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+          center.x = BUBBLE_SIZE / 2;
+          center.y = BUBBLE_SIZE / 2;
+          if (hideAfterTransition) {
+            canvas.style.display = 'none';
+          }
+        }
+      }
+    }
+  }
+
+  // ── Draw ──
+  function drawFrame(frame, x, y, rotate, flipX) {
+    if (!spriteSheet) return;
+    var col = frame % COLS;
+    var row = Math.floor(frame / COLS);
+    var sx = col * FRAME_W;
+    var sy = row * FRAME_H;
+
+    ctx.save();
+    ctx.translate(x, y);
+    if (rotate) ctx.rotate(rotate);
+    if (flipX === -1) ctx.scale(-1, 1);
+    ctx.imageSmoothingEnabled = true;
+    ctx.imageSmoothingQuality = 'high';
+    ctx.drawImage(
+      spriteSheet,
+      sx, sy, FRAME_W, FRAME_H,
+      -DISPLAY_W / 2, -DISPLAY_H / 2,
+      DISPLAY_W, DISPLAY_H
+    );
+    ctx.restore();
   }
 
-  // Mark widget present
-  bubble.dataset.fluxyWidget = '1';
-  document.body.appendChild(bubble);
+  function draw(now) {
+    ctx.clearRect(0, 0, W, H);
+    if (!spriteSheet || animState === 'loading') return;
+
+    if (animState === 'melting') {
+      var p = (currentFrame - MELT_START) / (MELT_END - MELT_START);
+      var eased = p * p;
+      drawFrame(currentFrame, center.x, center.y, travelDrawAngle * eased, travelFlip);
+    } else if (animState === 'traveling') {
+      drawFrame(currentFrame, center.x, center.y, travelDrawAngle, travelFlip);
+    } else if (animState === 'reforming') {
+      var p2 = (currentFrame - REFORM_START) / (REFORM_END - REFORM_START);
+      var eased2 = 1 - (1 - p2) * (1 - p2);
+      drawFrame(currentFrame, center.x, center.y, travelDrawAngle * (1 - eased2));
+    } else {
+      drawFrame(currentFrame, center.x, center.y);
+    }
+  }
+
+  // ── Animation loop ──
+  function loop(now) {
+    if (animState !== 'loading') {
+      update(now);
+      draw(now);
+    }
+    requestAnimationFrame(loop);
+  }
+
+  // ── App-ready coordination ──
+  function maybeTransition() {
+    if (!appReady || animState !== 'idle' || canvasPhase !== 'splash') return;
+    var elapsed = Date.now() - canvasCreatedAt;
+    if (elapsed < MIN_SPLASH_MS) {
+      setTimeout(maybeTransition, MIN_SPLASH_MS - elapsed);
+      return;
+    }
+    triggerTransition();
+  }
+
+  function triggerTransition() {
+    canvasPhase = 'transitioning';
+    var tx = W - BUBBLE_MARGIN - BUBBLE_SIZE / 2;
+    var ty = H - BUBBLE_MARGIN - BUBBLE_SIZE / 2;
+    moveTo(tx, ty);
+  }
+
+  // Skip splash and go straight to bubble mode (for onboard / instant load)
+  function skipToBubble() {
+    canvasPhase = 'bubble';
+    canvas.style.cssText = 'position:fixed;bottom:' + BUBBLE_MARGIN + 'px;right:' + BUBBLE_MARGIN + 'px;width:' + BUBBLE_SIZE + 'px;height:' + BUBBLE_SIZE + 'px;z-index:99998;cursor:pointer;border-radius:50%;transition:transform .15s ease;-webkit-tap-highlight-color:transparent;';
+    W = BUBBLE_SIZE;
+    H = BUBBLE_SIZE;
+    canvas.width = BUBBLE_SIZE * dpr;
+    canvas.height = BUBBLE_SIZE * dpr;
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    center.x = BUBBLE_SIZE / 2;
+    center.y = BUBBLE_SIZE / 2;
+    currentFrame = IDLE_START;
+    idleDirection = 1;
+    animState = 'idle';
+    // Hide the HTML splash fallback
+    var splash = document.getElementById('splash');
+    if (splash) splash.style.display = 'none';
+  }
+
+  window.addEventListener('fluxy:app-ready', function () {
+    appReady = true;
+    maybeTransition();
+  });
+  if (window.__fluxyAppReady) {
+    appReady = true;
+  }
+
+  // ── Check onboard status, then start ──
+  // First-time users get the onboard wizard — skip the splash animation.
+  var onboardActive = false;
+  fetch('/api/settings')
+    .then(function (r) { return r.json(); })
+    .then(function (s) {
+      if (s.onboard_complete !== 'true') {
+        onboardActive = true;
+        skipSplash = true;
+      }
+      startAnimation();
+    })
+    .catch(function () {
+      startAnimation();
+    });
+
+  function startAnimation() {
+    loadSprite(
+      function onSuccess() {
+        if (skipSplash) {
+          skipToBubble();
+          if (onboardActive) canvas.style.display = 'none';
+        }
+        requestAnimationFrame(loop);
+        maybeTransition();
+      },
+      function onFail() {
+        canvas.style.display = 'none';
+        canvasPhase = 'disabled';
+      }
+    );
+  }
+
+  // ══════════════════════════════════════════════════════════════════
+  // ── Widget Interaction (Panel, Toggle, Messages) ─────────────────
+  // ══════════════════════════════════════════════════════════════════
 
-  // ── Toggle ──
   var isOpen = false;
 
   function toggle() {
+    if (canvasPhase !== 'bubble') return;
     isOpen = !isOpen;
     panel.classList.toggle('open', isOpen);
     backdrop.classList.toggle('open', isOpen);
-    bubble.style.display = isOpen ? 'none' : 'flex';
+    canvas.style.display = isOpen ? 'none' : 'block';
   }
 
-  bubble.addEventListener('click', toggle);
+  bubble.addEventListener('click', function () {
+    if (canvasPhase === 'bubble') toggle();
+  });
   backdrop.addEventListener('click', toggle);
 
   // Close on Escape
@@ -97,10 +405,8 @@
   window.addEventListener('message', function (e) {
     if (!e.data || !e.data.type) return;
 
-    // Close chat panel
     if (e.data.type === 'fluxy:close' && isOpen) toggle();
 
-    // Install App request from chat iframe
     if (e.data.type === 'fluxy:install-app') {
       if (deferredInstallPrompt) {
         deferredInstallPrompt.prompt();
@@ -108,66 +414,28 @@
           if (result.outcome === 'accepted') deferredInstallPrompt = null;
         });
       } else {
-        // No native prompt available — tell chat to show instructions modal
         iframe.contentWindow.postMessage({ type: 'fluxy:show-ios-install' }, '*');
       }
     }
+
+    // Onboard complete — show the bubble
+    if (e.data.type === 'fluxy:onboard-complete') {
+      onboardActive = false;
+      hideAfterTransition = false;
+      canvas.style.display = 'block';
+    }
   });
 
-  // Restore open state after HMR reload (so chat isn't disrupted)
+  // Restore open state after HMR reload
   try {
     if (sessionStorage.getItem('fluxy_widget_open') === '1') {
       sessionStorage.removeItem('fluxy_widget_open');
-      toggle();
+      if (canvasPhase === 'bubble') toggle();
     }
   } catch (e) {}
 
-  // Hide widget during initial onboard
-  try {
-    fetch('/api/settings')
-      .then(function (r) { return r.json(); })
-      .then(function (s) {
-        if (s.onboard_complete !== 'true') {
-          bubble.style.display = 'none';
-          window.addEventListener('message', function onMsg(e) {
-            if (e.data && e.data.type === 'fluxy:onboard-complete') {
-              bubble.style.display = 'flex';
-              window.removeEventListener('message', onMsg);
-            }
-          });
-        }
-      })
-      .catch(function () {});
-  } catch (e) {}
-
   // Inject app-ws.js — proxies /app/api/* fetch calls through WebSocket
-  // (works around POST request failures through Cloudflare tunnel)
   var awsScript = document.createElement('script');
   awsScript.src = '/fluxy/app-ws.js';
   document.head.appendChild(awsScript);
-
-  // ── Splash / Service Worker upgrade logic ──────────────────────────
-  // This runs from the supervisor (always updated), so it fixes existing
-  // installs whose workspace/client/index.html is still old.
-
-  // Re-show splash before page unloads (manual refresh)
-  window.addEventListener('beforeunload', function () {
-    console.log('[widget] beforeunload — showing splash');
-    var s = document.getElementById('splash');
-    if (s) { s.style.transition = 'none'; s.style.display = 'flex'; s.style.opacity = '1'; }
-  });
-
-  // When a new SW takes control, show splash and reload so the new
-  // caching strategy (stale-while-revalidate) kicks in immediately.
-  if ('serviceWorker' in navigator) {
-    var swRefreshing = false;
-    navigator.serviceWorker.addEventListener('controllerchange', function () {
-      console.log('[widget] controllerchange — new SW took control, refreshing:', swRefreshing);
-      if (swRefreshing) return;
-      swRefreshing = true;
-      var s = document.getElementById('splash');
-      if (s) { s.style.transition = 'none'; s.style.display = 'flex'; s.style.opacity = '1'; }
-      location.reload();
-    });
-  }
 })();

package/workspace/client/index.html

@@ -10,18 +10,11 @@
     <link rel="apple-touch-icon" href="/fluxy-icon-192.png" />
     <link rel="manifest" href="/manifest.json" />
     <title>Fluxy</title>
-    <style>
-      @keyframes _fs{to{transform:rotate(360deg)}}
-    </style>
   </head>
   <body class="bg-background text-foreground" style="background:#222122">
-    <!-- App shell splash — visible instantly, no JS needed.
-         Covers the screen during reload/restore so there's never a white flash.
-         React hides it on mount; shown again before any reload. -->
-    <div id="splash" style="background:#222122;color:#fff;display:flex;flex-direction:column;align-items:center;justify-content:center;height:100dvh;width:100vw;position:fixed;inset:0;z-index:9999;font-family:system-ui,-apple-system,sans-serif;transition:opacity .25s ease-out">
-      <img src="/fluxy-icon-192.png" width="56" height="56" style="border-radius:14px;margin-bottom:20px" alt="" />
-      <div style="width:18px;height:18px;border:2px solid rgba(255,255,255,0.12);border-top-color:rgba(255,255,255,0.7);border-radius:50%;animation:_fs .6s linear infinite"></div>
-    </div>
+    <!-- Dark background fallback — visible instantly while widget.js loads.
+         The canvas animation (in widget.js) takes over as the actual splash. -->
+    <div id="splash" style="background:#222122;position:fixed;inset:0;z-index:9998;transition:opacity .25s ease-out"></div>
 
     <div id="root"></div>
 
@@ -42,13 +35,10 @@
       });
     </script>
     <script>
-    // Re-show splash before page unloads (manual refresh / navigation).
-    // The last painted frame before teardown will be the dark splash
-    // instead of a white gap.
+    // Re-show dark background before page unloads (manual refresh / navigation).
     window.addEventListener('beforeunload', function () {
-      console.log('[splash] beforeunload — showing splash');
       var s = document.getElementById('splash');
-      if (s) { s.style.transition = 'none'; s.style.display = 'flex'; s.style.opacity = '1'; }
+      if (s) { s.style.transition = 'none'; s.style.display = 'block'; s.style.opacity = '1'; }
     });
     </script>
     <script type="module" src="/src/main.tsx"></script>
@@ -63,7 +53,7 @@
         if(swRefreshing)return;
         swRefreshing=true;
         var s=document.getElementById('splash');
-        if(s){s.style.transition='none';s.style.display='flex';s.style.opacity='1'}
+        if(s){s.style.transition='none';s.style.display='block';s.style.opacity='1'}
         console.log('[sw-reg] reloading after new SW took control');
         location.reload();
       });

package/workspace/client/src/App.tsx

@@ -41,10 +41,10 @@ export default function App() {
     const splash = document.getElementById('splash');
     let hiddenAt = 0;
 
-    // Show the splash screen (used before reloads and on resume)
+    // Show the dark background (used before reloads and on resume)
     function showSplash() {
       if (!splash) return;
-      splash.style.display = 'flex';
+      splash.style.display = 'block';
       splash.style.opacity = '1';
     }
 

package/workspace/client/src/main.tsx

@@ -9,18 +9,9 @@ ReactDOM.createRoot(document.getElementById('root')!).render(
   </React.StrictMode>,
 );
 
-// Fade out the HTML splash screen once React has actually painted.
-// React 18's createRoot().render() is async — wait for the next frame
-// to ensure the app is visible before removing the splash.
-console.log('[main] React render called, waiting for paint to hide splash');
+// Signal that the app has painted — the canvas animation in widget.js
+// will trigger the melt → travel → reform transition to bubble mode.
 requestAnimationFrame(() => requestAnimationFrame(() => {
-  console.log('[main] double-rAF fired — hiding splash');
-  const splash = document.getElementById('splash');
-  if (splash) {
-    splash.style.opacity = '0';
-    splash.addEventListener('transitionend', () => {
-      splash.style.display = 'none';
-      console.log('[main] splash hidden');
-    }, { once: true });
-  }
+  (window as any).__fluxyAppReady = true;
+  window.dispatchEvent(new Event('fluxy:app-ready'));
 }));