// CTA titles array
const CTA_TITLES = [
  "Performance in every act - thanks to Rivet Actors.",
  "Scale without drama - only with Rivet Actors.",
  "It's time your backend took center-stage - with Rivet Actors.",
  "SQLite the spotlight on performance - with Rivet Actors.",
  "Backend scalability: the SQL - starring Rivet Actors.",
  "Take your state to the edge - Rivet Actors makes it easy.",
  "No state fright - just scalability with Rivet Actors.",
  "Act now, deploy at the edge - with Rivet Actors.",
  "Lights, camera, serverless - powered by Rivet Actors.",
  "Your backend deserves a standing ovation - Rivet Actors delivers.",
  "Cue your backend's best performance - enter Rivet Actors.",
  "Backend performance worth applauding - only with Rivet Actors.",
  "Put your backend center-stage - with Rivet Actors.",
  "Make your backend the main actor - with Rivet Actors.",
  "Give your backend its big break - use Rivet Actors.",
  "Serverless, with no intermissions - powered by Rivet Actors.",
  "Set the stage for serverless success - with Rivet Actors."
];

function initializeAllCTAs() {
  // Find CTA container, looking for both the old class and potential new classes
  document.querySelectorAll('.cta-container:not([data-cta-initialized]), .cta-section:not([data-cta-initialized])').forEach(container => {
    // Skip if already initialized
    if (container.hasAttribute('data-cta-initialized')) return;
    
    console.log("[Initialize] CTA", container?.id || "unnamed");
    
    // Mark as initialized
    container.setAttribute('data-cta-initialized', 'true');
    
    // Try both ID and class selectors for title element
    const titleElement = container.querySelector('#rotating-cta-title, .cta-title');
    const subtitle = container.querySelector('.cta-pun-complaint');
    
    if (!titleElement || !subtitle) {
      console.log("[Initialize] CTA - Missing elements", { 
        titleElement: !!titleElement, 
        subtitle: !!subtitle,
        container: container.className 
      });
      return;
    }
    
    let currentIndex = 0;
    let clickCount = 0;
    
    function getNextTitle() {
      currentIndex = (currentIndex + 1) % CTA_TITLES.length;
      return CTA_TITLES[currentIndex];
    }

    // Set initial title if not already set
    if (!titleElement.dataset.initialized) {
      titleElement.textContent = CTA_TITLES[currentIndex];
      titleElement.dataset.initialized = "true";
    }

    subtitle.addEventListener('click', () => {
      titleElement.textContent = getNextTitle();
      clickCount++;
      
      if (clickCount === 1) {
        subtitle.textContent = "Click here to file another complaint.";
      } else if (clickCount === 2) {
        subtitle.textContent = "And another.";
      } else if (clickCount === 3) {
        subtitle.textContent = "Keep clicking.";
      } else if (clickCount === 4) {
        subtitle.textContent = "I promise this one will stop the puns.";
      } else if (clickCount === 5) {
        subtitle.textContent = "Fool me once, shame on me. Fool me twice... keep clicking.";
      } else if (clickCount === 6) {
        subtitle.textContent = "Insanity is doing the same thing over and over again and expecting different results.";
      } else if (clickCount >= 7) {
        subtitle.textContent = `Your measure of insanity: ${clickCount}`;
      }
    });
  });
}

// Initial run on DOM ready
if (document.readyState === "loading") {
  document.addEventListener("DOMContentLoaded", initializeAllCTAs);
} else {
  initializeAllCTAs();
}


//// Configuration object for all particle behavior constants
//const PARTICLE_CONFIG = {
//  // Particle appearance
//  CANVAS_SIZE: 40,
//  CONTAINER_HEIGHT: 1400,
//  BASE_OPACITY: 0.08,
//  ORANGE_COLOR: '#ff4f00',
//
//  // Velocity thresholds
//  MIN_VELOCITY_THRESHOLD: 2,
//  MAX_VELOCITY_THRESHOLD: 10,
//  MAX_VELOCITY: 100,
//
//  // Particle physics
//  DAMPING: 0.975,
//  MASS: 0.25,
//  SPRING_STRENGTH: 0.05,
//  ROTATION_SPEED: 0.01,
//  MAX_ROTATIONAL_VELOCITY: 0.5,
//
//  // Distribution
//  PARTICLE_COUNT: 1000,
//  BASE_RADIUS: 900,
//  RADIUS_STD_DEV: 200,
//
//  // Mouse interaction
//  FORCE_RADIUS: 300,
//  BASE_PUSH_FORCE: 0.001,
//  MOVEMENT_FORCE_MULTIPLIER: 1.2,
//  REPEL_FORCE_RATIO: 0.3,
//  MOVEMENT_FORCE_RATIO: 1.2,
//  MAX_MOUSE_VELOCITY: 5000,
//
//  // Animation
//  TARGET_FPS: 60,
//  MAX_FRAME_TIME: 0.1, // seconds
//};
//
//// Global particle state
//const GLOBAL_STATE = {
//  // Particle canvases
//  particleCanvases: {},
//
//  // Particles array
//  particles: [],
//
//  // Animation reference
//  animationFrameId: null,
//
//  // Current animation state
//  active: false,
//
//  // Time tracking
//  lastFrameTime: 0,
//
//  // Mouse tracking variables
//  mouseX: 0,
//  mouseY: 0,
//  lastMouseX: 0,
//  lastMouseY: 0,
//  mouseVX: 0,
//  mouseVY: 0,
//  lastMouseTime: 0
//};
//
//// Canvas and context references
//let canvas = null;
//let ctx = null;
//
//// Global DOM elements
//let wrapper = null;
//let mouseMoveListener = null;
//let resizeListener = null;
//
//// Private Particle class
//class Particle {
//  static CANVAS_SIZE = PARTICLE_CONFIG.CANVAS_SIZE;
//  static CONTAINER_HEIGHT = PARTICLE_CONFIG.CONTAINER_HEIGHT;
//  static PARTICLE_RADIUS = PARTICLE_CONFIG.CANVAS_SIZE / 6;
//  static SHAPES = ['circle', 'square', 'triangle'];
//  static BASE_OPACITY = PARTICLE_CONFIG.BASE_OPACITY;
//  static ORANGE_COLOR = PARTICLE_CONFIG.ORANGE_COLOR;
//  static MIN_VELOCITY_THRESHOLD = PARTICLE_CONFIG.MIN_VELOCITY_THRESHOLD;
//  static MAX_VELOCITY_THRESHOLD = PARTICLE_CONFIG.MAX_VELOCITY_THRESHOLD;
//
//  static initParticleCanvases() {
//    // Create offscreen canvases for each particle shape
//    Particle.SHAPES.forEach(shape => {
//      // Create white version
//      const whiteCanvas = document.createElement('canvas');
//      whiteCanvas.width = Particle.CANVAS_SIZE;
//      whiteCanvas.height = Particle.CANVAS_SIZE;
//      const whiteCtx = whiteCanvas.getContext('2d');
//      whiteCtx.fillStyle = 'white';
//      whiteCtx.globalAlpha = 1.0;
//
//      // Create orange version
//      const orangeCanvas = document.createElement('canvas');
//      orangeCanvas.width = Particle.CANVAS_SIZE;
//      orangeCanvas.height = Particle.CANVAS_SIZE;
//      const orangeCtx = orangeCanvas.getContext('2d');
//      orangeCtx.fillStyle = Particle.ORANGE_COLOR;
//      orangeCtx.globalAlpha = 1.0;
//
//      // Draw the shape on both canvases
//      [whiteCtx, orangeCtx].forEach(ctx => {
//        switch (shape) {
//          case 'circle':
//            ctx.beginPath();
//            ctx.arc(Particle.CANVAS_SIZE/2, Particle.CANVAS_SIZE/2, Particle.PARTICLE_RADIUS, 0, Math.PI * 2);
//            ctx.fill();
//            break;
//
//          case 'square':
//            const size = Particle.PARTICLE_RADIUS * 2;
//            ctx.fillRect(
//              Particle.CANVAS_SIZE/2 - Particle.PARTICLE_RADIUS,
//              Particle.CANVAS_SIZE/2 - Particle.PARTICLE_RADIUS,
//              size,
//              size
//            );
//            break;
//
//          case 'triangle':
//            const height = Particle.PARTICLE_RADIUS * 2;
//            const halfWidth = Particle.PARTICLE_RADIUS;
//            ctx.beginPath();
//            ctx.moveTo(Particle.CANVAS_SIZE/2, Particle.CANVAS_SIZE/2 - height/2);
//            ctx.lineTo(Particle.CANVAS_SIZE/2 - halfWidth, Particle.CANVAS_SIZE/2 + height/2);
//            ctx.lineTo(Particle.CANVAS_SIZE/2 + halfWidth, Particle.CANVAS_SIZE/2 + height/2);
//            ctx.closePath();
//            ctx.fill();
//            break;
//        }
//      });
//
//      if (!GLOBAL_STATE.particleCanvases[shape]) {
//        GLOBAL_STATE.particleCanvases[shape] = {};
//      }
//      GLOBAL_STATE.particleCanvases[shape].white = whiteCanvas;
//      GLOBAL_STATE.particleCanvases[shape].orange = orangeCanvas;
//    });
//  }
//
//  constructor() {    
//    this.shape = Particle.SHAPES[Math.floor(Math.random() * Particle.SHAPES.length)];
//    this.angle = Math.random() * Math.PI * 2; // Initial random angle
//    this.rotationSpeed = PARTICLE_CONFIG.ROTATION_SPEED;
//
//    // Add random rotation and rotational velocity
//    this.rotation = Math.random() * Math.PI * 2; // Random initial rotation
//    this.rotationalVelocity = (Math.random() - 0.5) * PARTICLE_CONFIG.MAX_ROTATIONAL_VELOCITY;
//
//    this.reset();
//  }
//
//  // Generate a normally distributed random number using Box-Muller transform
//  gaussianRandom(mean = 0, stdDev = 1) {
//    const u1 = Math.random();
//    const u2 = Math.random();
//    const z0 = Math.sqrt(-2.0 * Math.log(u1)) * Math.cos(2.0 * Math.PI * u2);
//    return z0 * stdDev + mean;
//  }
//
//  reset() {
//    // Circle parameters
//    const baseRadius = PARTICLE_CONFIG.BASE_RADIUS;
//    const stdDev = PARTICLE_CONFIG.RADIUS_STD_DEV;
//
//    // Generate random distance (but keep angle from constructor)
//    const randomDistance = this.gaussianRandom(0, stdDev);
//    this.radius = baseRadius + randomDistance;
//
//    // Convert polar to cartesian coordinates
//    this.updateOriginPosition();
//
//    // Current position
//    this.x = this.originX;
//    this.y = this.originY;
//
//    // Velocity (starts at 0)
//    this.vx = 0;
//    this.vy = 0;
//
//    // Physics constants
//    this.damping = PARTICLE_CONFIG.DAMPING;
//    this.mass = PARTICLE_CONFIG.MASS;
//    this.springStrength = PARTICLE_CONFIG.SPRING_STRENGTH;
//
//    // Size and opacity
//    this.size = Particle.PARTICLE_RADIUS * 2;
//    this.opacity = 1;
//    this.opacityFactor = Math.random();
//    this.opacityBase = Math.min(0, Math.random() - 0.5);
//  }
//
//  updateOriginPosition() {
//    const centerX = window.innerWidth / 2;
//    const centerY = 180;
//    this.originX = centerX + this.radius * Math.cos(this.angle);
//    this.originY = centerY + this.radius * Math.sin(this.angle);
//  }
//
//  draw(ctx) {
//    // Skip rendering if particle is outside canvas bounds
//    if (this.x + Particle.CANVAS_SIZE/2 < 0 || 
//        this.x - Particle.CANVAS_SIZE/2 > ctx.canvas.width ||
//        this.y + Particle.CANVAS_SIZE/2 < 0 || 
//        this.y - Particle.CANVAS_SIZE/2 > ctx.canvas.height) {
//      return;
//    }
//
//    // Calculate opacity based on distance from center
//    const centerX = window.innerWidth / 2;
//    const centerY = 180;
//    const dx = this.x - centerX;
//    const dy = this.y - centerY;
//    const distance = Math.sqrt(dx * dx + dy * dy);
//
//    // Fade out between 600px and 1200px from center
//    const minDistance = 600;
//    const maxDistance = 1200;
//    this.opacity = this.opacityBase + Math.max(0, Math.min(1, 1 - (distance - minDistance) / (maxDistance - minDistance))) * this.opacityFactor;
//
//    // Calculate velocity magnitude directly - simpler and more accurate
//    const velocityMagnitude = Math.sqrt(this.vx * this.vx + this.vy * this.vy);
//
//    // Calculate color mix based on velocity - lowered threshold for more visible effect
//    const colorMix = Math.min(1, (velocityMagnitude - Particle.MIN_VELOCITY_THRESHOLD) / (Particle.MAX_VELOCITY_THRESHOLD - Particle.MIN_VELOCITY_THRESHOLD) * 0.5);
//
//    // Save the current context state
//    ctx.save();
//
//    // Translate to particle position and rotate
//    ctx.translate(this.x, this.y);
//    ctx.rotate(this.rotation);
//
//    // Draw white (base) particle
//    if (this.opacity > 0) {
//      ctx.globalAlpha = this.opacity * Particle.BASE_OPACITY * (1 - colorMix);
//      ctx.drawImage(
//        GLOBAL_STATE.particleCanvases[this.shape].white,
//        -Particle.CANVAS_SIZE/2,
//        -Particle.CANVAS_SIZE/2
//      );
//    }
//
//    // Draw orange (active) particle
//    if (colorMix > 0) {
//      // Ignore this.opacity since any fast particle will turn orange
//      ctx.globalAlpha = colorMix;
//      ctx.drawImage(
//        GLOBAL_STATE.particleCanvases[this.shape].orange,
//        -Particle.CANVAS_SIZE/2,
//        -Particle.CANVAS_SIZE/2
//      );
//    }
//
//    // Restore the context state
//    ctx.restore();
//    ctx.globalAlpha = 1;
//  }
//
//  update(deltaTime) {
//    // Update the angle
//    this.angle += this.rotationSpeed * deltaTime;
//    if (this.angle > Math.PI * 2) {
//      this.angle -= Math.PI * 2;
//    }
//
//    // Update rotation
//    this.rotation += this.rotationalVelocity * deltaTime;
//    if (this.rotation > Math.PI * 2) {
//      this.rotation -= Math.PI * 2;
//    }
//
//    // Update origin position based on new angle
//    this.updateOriginPosition();
//
//    // Calculate spring force back to origin
//    const dx = this.originX - this.x;
//    const dy = this.originY - this.y;
//    const springForceX = dx * this.springStrength;
//    const springForceY = dy * this.springStrength;
//
//    // Apply spring force (scaled by deltaTime)
//    this.vx += springForceX * deltaTime;
//    this.vy += springForceY * deltaTime;
//
//    // Apply damping
//    this.vx *= Math.pow(this.damping, deltaTime * 60);
//    this.vy *= Math.pow(this.damping, deltaTime * 60);
//
//    // Clamp velocity to prevent extreme speeds
//    const currentSpeed = Math.sqrt(this.vx * this.vx + this.vy * this.vy);
//    if (currentSpeed > 1000) {
//      this.vx = (this.vx / currentSpeed) * 1000;
//      this.vy = (this.vy / currentSpeed) * 1000;
//    }
//
//    // Update position
//    this.x += this.vx;
//    this.y += this.vy;
//  }
//
//  applyForce(fx, fy) {
//    this.vx += fx;
//    this.vy += fy;
//  }
//}
//
//// Create the particle system and initialize everything needed
//function createParticleSystem() {
//  console.log("[Particles] Creating particle system");
//
//  if (GLOBAL_STATE.active) {
//    console.log("[Particles] System already active, skipping creation");
//    return; // Already active
//  }
//
//  // Initialize particle canvases if needed
//  if (Object.keys(GLOBAL_STATE.particleCanvases).length === 0) {
//    Particle.initParticleCanvases();
//  }
//
//  // Create particles if needed
//  if (GLOBAL_STATE.particles.length === 0) {
//    console.log("[Particles] Creating particles");
//    GLOBAL_STATE.particles = Array.from({ length: PARTICLE_CONFIG.PARTICLE_COUNT }, () => new Particle());
//  }
//
//  // Create wrapper element
//  wrapper = document.createElement('div');
//  wrapper.setAttribute('data-particle-wrapper', 'true');
//  Object.assign(wrapper.style, {
//    position: 'absolute',
//    top: '0',
//    left: '0',
//    width: '100%',
//    height: `${Particle.CONTAINER_HEIGHT}px`,
//    overflow: 'hidden',
//    pointerEvents: 'none',
//    zIndex: '-1'
//  });
//
//  // Create canvas
//  canvas = document.createElement('canvas');
//  canvas.setAttribute('data-particles', 'true');
//  Object.assign(canvas.style, {
//    position: 'absolute',
//    top: '0',
//    left: '0',
//    width: '100%',
//    height: `${Particle.CONTAINER_HEIGHT}px`,
//    pointerEvents: 'none',
//    zIndex: '-1'
//  });
//
//  // Set canvas size
//  canvas.width = window.innerWidth;
//  canvas.height = Particle.CONTAINER_HEIGHT;
//
//  // Get context
//  ctx = canvas.getContext('2d');
//
//  // Add canvas to wrapper
//  wrapper.appendChild(canvas);
//
//  // Add wrapper to body
//  if (document.body.firstChild) {
//    document.body.insertBefore(wrapper, document.body.firstChild);
//  } else {
//    document.body.appendChild(wrapper);
//  }
//
//  // Set up mouse tracking
//  mouseMoveListener = (e) => {
//    const currentTime = performance.now();
//    const deltaTime = (currentTime - GLOBAL_STATE.lastMouseTime) / 1000;
//
//    // Use page coordinates for absolute positioning
//    GLOBAL_STATE.mouseX = e.pageX;
//    GLOBAL_STATE.mouseY = e.pageY;
//
//    if (deltaTime > 0) {
//      GLOBAL_STATE.mouseVX = (GLOBAL_STATE.mouseX - GLOBAL_STATE.lastMouseX) / deltaTime;
//      GLOBAL_STATE.mouseVY = (GLOBAL_STATE.mouseY - GLOBAL_STATE.lastMouseY) / deltaTime;
//
//      const maxVelocity = PARTICLE_CONFIG.MAX_MOUSE_VELOCITY;
//      GLOBAL_STATE.mouseVX = Math.max(Math.min(GLOBAL_STATE.mouseVX, maxVelocity), -maxVelocity);
//      GLOBAL_STATE.mouseVY = Math.max(Math.min(GLOBAL_STATE.mouseVY, maxVelocity), -maxVelocity);
//    }
//
//    GLOBAL_STATE.lastMouseX = GLOBAL_STATE.mouseX;
//    GLOBAL_STATE.lastMouseY = GLOBAL_STATE.mouseY;
//    GLOBAL_STATE.lastMouseTime = currentTime;
//  };
//
//  document.addEventListener('mousemove', mouseMoveListener);
//
//  // Handle resize
//  resizeListener = () => {
//    if (canvas) {
//      canvas.width = window.innerWidth;
//      canvas.height = Particle.CONTAINER_HEIGHT;
//      GLOBAL_STATE.particles.forEach(particle => particle.reset());
//    }
//  };
//
//  window.addEventListener('resize', resizeListener);
//
//  // Initialize timing
//  GLOBAL_STATE.lastFrameTime = performance.now();
//  GLOBAL_STATE.lastMouseTime = performance.now();
//
//  // Start animation
//  startAnimation();
//
//  // Mark as active
//  GLOBAL_STATE.active = true;
//}
//
//// Start the animation loop
//function startAnimation() {
//  if (GLOBAL_STATE.animationFrameId !== null) {
//    // Animation already running
//    return;
//  }
//
//  console.log("[Particles] Starting animation");
//
//  const TARGET_FPS = PARTICLE_CONFIG.TARGET_FPS;
//  const FRAME_TIME = 1000 / TARGET_FPS;
//  const FORCE_RADIUS = PARTICLE_CONFIG.FORCE_RADIUS;
//
//  function animate() {
//    const currentTime = performance.now();
//    const timeSinceLastFrame = currentTime - GLOBAL_STATE.lastFrameTime;
//
//    // Only render if enough time has passed for next frame
//    if (timeSinceLastFrame >= FRAME_TIME) {
//      const deltaTime = Math.min(timeSinceLastFrame / 1000, PARTICLE_CONFIG.MAX_FRAME_TIME);
//      GLOBAL_STATE.lastFrameTime = currentTime;
//
//      // Update all particles
//      GLOBAL_STATE.particles.forEach(particle => {
//        const dx = particle.x - GLOBAL_STATE.mouseX;
//        const dy = particle.y - GLOBAL_STATE.mouseY;
//        const distance = Math.sqrt(dx * dx + dy * dy);
//
//        if (distance < FORCE_RADIUS) {
//          // Calculate mouse velocity magnitude
//          const mouseSpeed = Math.sqrt(GLOBAL_STATE.mouseVX * GLOBAL_STATE.mouseVX + GLOBAL_STATE.mouseVY * GLOBAL_STATE.mouseVY);
//          // Normalize mouse velocity to 0-1 range
//          const normalizedSpeed = Math.min(mouseSpeed / PARTICLE_CONFIG.MAX_VELOCITY, 1);
//
//          // Calculate base force factor with smoother distance falloff
//          const forceFactor = Math.pow(1 - distance / FORCE_RADIUS, 1.5) *
//                          normalizedSpeed * 
//                          PARTICLE_CONFIG.BASE_PUSH_FORCE * 
//                          PARTICLE_CONFIG.MOVEMENT_FORCE_MULTIPLIER * 
//                          deltaTime * 60;
//
//          // Calculate repulsion direction (away from mouse)
//          const repelDirX = dx / distance;
//          const repelDirY = dy / distance;
//
//          // Get normalized mouse movement direction
//          const mvx = GLOBAL_STATE.mouseVX / (mouseSpeed || 1);
//          const mvy = GLOBAL_STATE.mouseVY / (mouseSpeed || 1);
//
//          // Calculate movement influence based on distance
//          const movementInfluence = Math.pow(1 - distance / FORCE_RADIUS, 1.2);
//
//          // Combine forces with reduced repulsion and increased movement
//          const repelForce = PARTICLE_CONFIG.REPEL_FORCE_RATIO * mouseSpeed;
//          const moveForce = mouseSpeed * PARTICLE_CONFIG.MOVEMENT_FORCE_RATIO;
//
//          // More emphasis on movement direction, less on repulsion
//          const fx = (repelDirX * repelForce * 0.5 + mvx * moveForce) * forceFactor * movementInfluence;
//          const fy = (repelDirY * repelForce * 0.5 + mvy * moveForce) * forceFactor * movementInfluence;
//
//          particle.applyForce(fx, fy);
//        }
//
//        particle.update(deltaTime);
//      });
//
//      // Make sure canvas and context exist before drawing
//      if (canvas && ctx) {
//        // Clear canvas
//        ctx.clearRect(0, 0, canvas.width, canvas.height);
//
//        // Draw particles
//        GLOBAL_STATE.particles.forEach(particle => {
//          particle.draw(ctx);
//        });
//      }
//    }
//
//    // Continue animation
//    GLOBAL_STATE.animationFrameId = requestAnimationFrame(animate);
//  }
//
//  GLOBAL_STATE.animationFrameId = requestAnimationFrame(animate);
//}
//
//// Completely destroy the particle system
//function destroyParticleSystem() {
//  console.log("[Particles] Destroying particle system");
//
//  // Cancel animation frame
//  if (GLOBAL_STATE.animationFrameId !== null) {
//    cancelAnimationFrame(GLOBAL_STATE.animationFrameId);
//    GLOBAL_STATE.animationFrameId = null;
//  }
//
//  // Remove event listeners
//  if (mouseMoveListener) {
//    document.removeEventListener('mousemove', mouseMoveListener);
//    mouseMoveListener = null;
//  }
//
//  if (resizeListener) {
//    window.removeEventListener('resize', resizeListener);
//    resizeListener = null;
//  }
//
//  // Remove DOM elements
//  if (wrapper && document.body.contains(wrapper)) {
//    wrapper.remove();
//  }
//
//  // Clear references
//  canvas = null;
//  ctx = null;
//  wrapper = null;
//
//  // Mark as inactive
//  GLOBAL_STATE.active = false;
//}
//
//// Check if the page should show particles (.landing-root exists)
//function shouldShowParticles() {
//  return document.querySelector('.landing-root') !== null;
//}
//
//// Handle mutation observer updates
//function observerInitialize() {
//  // Check if we should show or hide particles
//  if (shouldShowParticles()) {
//    if (!GLOBAL_STATE.active) {
//      console.log("[Particles] Landing page detected - creating particles");
//      createParticleSystem();
//    }
//  } else {
//    if (GLOBAL_STATE.active) {
//      console.log("[Particles] Not a landing page - destroying particles");
//      destroyParticleSystem();
//    }
//  }
//
//  // Mark all containers as initialized
//  document.querySelectorAll('.particle-container:not([data-particle-initialized])').forEach(container => {
//    container.setAttribute('data-particle-initialized', 'true');
//  });
//}
//
//// Compatibility function for observer-manager.js
//function initializeAllParticles() {
//  observerInitialize();
//}
//
//// Initialize after a small delay
////setTimeout(observerInitialize, 50);


// Throttling with unique name to avoid conflicts
let observerManagerThrottleTimer = null;
const OBSERVER_MANAGER_THROTTLE_DELAY = 0; // ms

// Run all component initializers - these functions are defined in other files
function observerManagerRunAllInitializers() {
  // Skip if already scheduled
  if (observerManagerThrottleTimer) return;
  console.log('[Observer] Observe changes');
  
  // Always run particles initialization immediately to prevent flash
  if (typeof observerInitialize === 'function') {
    observerInitialize();
  }
  
  // Schedule throttled execution for other components
  observerManagerThrottleTimer = setTimeout(() => {
    // Run each component's init function directly
    if (typeof initializeFAQ === 'function') initializeFAQ();
    if (typeof initializeAllCodeGroups === 'function') initializeAllCodeGroups();
    if (typeof initializeAllCTAs === 'function') initializeAllCTAs();
    if (typeof initializeAllCopyCommands === 'function') initializeAllCopyCommands();
    
    // Run particles again to catch any late additions
    if (typeof observerInitialize === 'function') observerInitialize();
    
    // Reset timer
    observerManagerThrottleTimer = null;
  }, OBSERVER_MANAGER_THROTTLE_DELAY);
}

// Create observer with unique name to avoid conflicts
const observerManagerObserver = new MutationObserver(observerManagerRunAllInitializers);

// Start observing
observerManagerObserver.observe(document.body, {
  childList: true,
  subtree: true
});

// Initial run as soon as possible
setTimeout(observerManagerRunAllInitializers, 0);
observerManagerRunAllInitializers();

// Cleanup on page unload
window.addEventListener('unload', () => {
  observerManagerObserver.disconnect();
  if (observerManagerThrottleTimer) {
    clearTimeout(observerManagerThrottleTimer);
  }
});


Post actorsresolve

RivetKit

Welcome

Welcome to RivetKit

Stateful serverless functions with persistence, real-time communication, and automatic scaling

Getting Started

Actors

Integrations

Reference

Post actorsresolve

Headers

Body

Response