waitless-api 0.1.0

package/dist/index.esm.js

@@ -0,0 +1,1956 @@
+/**
+ * Base game class with common functionality
+ */
+class BaseGame {
+    constructor(config) {
+        this.isRunning = false;
+        this.score = 0;
+        this.container = config.container;
+        this.theme = config.theme || 'default';
+        this.onScoreCallback = config.onScore;
+    }
+    /**
+     * Update the score and trigger callback
+     * @param points Points to add to the score
+     */
+    updateScore(points) {
+        this.score += points;
+        // Call score callback if provided
+        if (this.onScoreCallback && typeof this.onScoreCallback === 'function') {
+            this.onScoreCallback(this.score);
+        }
+    }
+    /**
+     * Get the current score
+     * @returns Current score
+     */
+    getScore() {
+        return this.score;
+    }
+    /**
+     * Check if the game is currently running
+     * @returns Whether the game is running
+     */
+    isActive() {
+        return this.isRunning;
+    }
+}
+
+/**
+ * Tetris game implementation
+ */
+class TetrisGame extends BaseGame {
+    constructor(config) {
+        var _a, _b, _c, _d;
+        super(config);
+        // Game state
+        this.grid = [];
+        this.currentPiece = null;
+        this.nextPiece = null;
+        this.animationFrame = null;
+        this.lastTime = 0;
+        this.dropInterval = 1000;
+        this.dropCounter = 0;
+        // Tetromino shapes and colors
+        this.shapes = [
+            // I-piece
+            [
+                [0, 0, 0, 0],
+                [1, 1, 1, 1],
+                [0, 0, 0, 0],
+                [0, 0, 0, 0]
+            ],
+            // J-piece
+            [
+                [2, 0, 0],
+                [2, 2, 2],
+                [0, 0, 0]
+            ],
+            // L-piece
+            [
+                [0, 0, 3],
+                [3, 3, 3],
+                [0, 0, 0]
+            ],
+            // O-piece
+            [
+                [4, 4],
+                [4, 4]
+            ],
+            // S-piece
+            [
+                [0, 5, 5],
+                [5, 5, 0],
+                [0, 0, 0]
+            ],
+            // T-piece
+            [
+                [0, 6, 0],
+                [6, 6, 6],
+                [0, 0, 0]
+            ],
+            // Z-piece
+            [
+                [7, 7, 0],
+                [0, 7, 7],
+                [0, 0, 0]
+            ]
+        ];
+        this.colors = [
+            'transparent',
+            '#00FFFF',
+            '#0000FF',
+            '#FF8000',
+            '#FFFF00',
+            '#00FF00',
+            '#8000FF',
+            '#FF0000' // Z-piece (red)
+        ];
+        /**
+         * Handle keyboard input
+         */
+        this.handleKeyDown = (e) => {
+            if (!this.isRunning) {
+                return;
+            }
+            switch (e.key) {
+                case 'ArrowLeft':
+                    this.movePiece(-1);
+                    break;
+                case 'ArrowRight':
+                    this.movePiece(1);
+                    break;
+                case 'ArrowDown':
+                    this.dropPiece();
+                    break;
+                case 'ArrowUp':
+                    this.rotatePiece();
+                    break;
+                case ' ': // Space - hard drop
+                    while (!this.checkCollision()) {
+                        this.currentPiece.pos.y++;
+                    }
+                    this.currentPiece.pos.y--;
+                    this.mergePiece();
+                    this.checkLines();
+                    this.createPiece();
+                    break;
+            }
+        };
+        this.blockSize = typeof config.blockSize === 'number' ? config.blockSize : 30;
+        const width = typeof config.width === 'number' ? config.width : 300;
+        const height = typeof config.height === 'number' ? config.height : 600;
+        this.cols = Math.floor(width / this.blockSize) || 10;
+        this.rows = Math.floor(height / this.blockSize) || 20;
+        const speed = typeof config.speed === 'number' ? config.speed : 1;
+        this.scoring = config.scoring && typeof config.scoring === 'object'
+            ? {
+                singleLine: (_a = config.scoring.singleLine) !== null && _a !== void 0 ? _a : 100,
+                doubleLine: (_b = config.scoring.doubleLine) !== null && _b !== void 0 ? _b : 300,
+                tripleLine: (_c = config.scoring.tripleLine) !== null && _c !== void 0 ? _c : 500,
+                tetris: (_d = config.scoring.tetris) !== null && _d !== void 0 ? _d : 800
+            }
+            : { singleLine: 100, doubleLine: 300, tripleLine: 500, tetris: 800 };
+        this.dropInterval = Math.max(100, 1000 / speed);
+        this.canvas = document.createElement('canvas');
+        this.canvas.width = this.cols * this.blockSize;
+        this.canvas.height = this.rows * this.blockSize;
+        this.canvas.style.display = 'block';
+        this.canvas.style.margin = '0 auto';
+        this.canvas.style.border = '1px solid #333';
+        this.container.appendChild(this.canvas);
+        const ctx = this.canvas.getContext('2d');
+        if (!ctx) {
+            throw new Error('Could not get canvas context');
+        }
+        this.ctx = ctx;
+        // Initialize game grid
+        this.resetGrid();
+        // Set up event listeners
+        this.setupControls();
+    }
+    /**
+     * Start the game
+     */
+    start() {
+        if (this.isRunning) {
+            return;
+        }
+        this.isRunning = true;
+        this.resetGrid();
+        this.createPiece();
+        this.lastTime = 0;
+        this.score = 0;
+        // Start game loop
+        this.update(0);
+    }
+    /**
+     * Pause the game
+     */
+    pause() {
+        if (!this.isRunning || !this.animationFrame) {
+            return;
+        }
+        this.isRunning = false;
+        cancelAnimationFrame(this.animationFrame);
+        this.animationFrame = null;
+    }
+    /**
+     * Resume the game
+     */
+    resume() {
+        if (this.isRunning) {
+            return;
+        }
+        this.isRunning = true;
+        this.lastTime = 0;
+        this.update(0);
+    }
+    /**
+     * Destroy the game and clean up
+     */
+    destroy() {
+        // Stop game loop
+        if (this.animationFrame) {
+            cancelAnimationFrame(this.animationFrame);
+            this.animationFrame = null;
+        }
+        // Remove event listeners
+        window.removeEventListener('keydown', this.handleKeyDown);
+        // Remove canvas
+        if (this.canvas.parentNode) {
+            this.canvas.parentNode.removeChild(this.canvas);
+        }
+        this.isRunning = false;
+    }
+    /**
+     * Main game update loop
+     */
+    update(time) {
+        if (!this.isRunning) {
+            return;
+        }
+        const deltaTime = time - this.lastTime;
+        this.lastTime = time;
+        // Update drop counter
+        this.dropCounter += deltaTime;
+        if (this.dropCounter > this.dropInterval) {
+            this.dropPiece();
+        }
+        // Draw game
+        this.draw();
+        // Continue game loop
+        this.animationFrame = requestAnimationFrame(this.update.bind(this));
+    }
+    /**
+     * Draw the game state
+     */
+    draw() {
+        // Clear canvas
+        this.ctx.fillStyle = '#000';
+        this.ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
+        // Draw grid
+        this.drawGrid();
+        // Draw current piece
+        if (this.currentPiece) {
+            this.drawPiece(this.currentPiece);
+        }
+    }
+    /**
+     * Draw the game grid
+     */
+    drawGrid() {
+        for (let y = 0; y < this.rows; y++) {
+            for (let x = 0; x < this.cols; x++) {
+                const value = this.grid[y][x];
+                if (value !== 0) {
+                    this.ctx.fillStyle = this.colors[value];
+                    this.ctx.fillRect(x * this.blockSize, y * this.blockSize, this.blockSize, this.blockSize);
+                    // Draw outline
+                    this.ctx.strokeStyle = '#222';
+                    this.ctx.strokeRect(x * this.blockSize, y * this.blockSize, this.blockSize, this.blockSize);
+                }
+            }
+        }
+    }
+    /**
+     * Draw a tetromino piece
+     */
+    drawPiece(piece) {
+        const { shape, pos } = piece;
+        for (let y = 0; y < shape.length; y++) {
+            for (let x = 0; x < shape[y].length; x++) {
+                const value = shape[y][x];
+                if (value !== 0) {
+                    this.ctx.fillStyle = this.colors[value];
+                    this.ctx.fillRect((pos.x + x) * this.blockSize, (pos.y + y) * this.blockSize, this.blockSize, this.blockSize);
+                    // Draw outline
+                    this.ctx.strokeStyle = '#222';
+                    this.ctx.strokeRect((pos.x + x) * this.blockSize, (pos.y + y) * this.blockSize, this.blockSize, this.blockSize);
+                }
+            }
+        }
+    }
+    /**
+     * Reset the game grid
+     */
+    resetGrid() {
+        this.grid = Array(this.rows).fill(0).map(() => Array(this.cols).fill(0));
+    }
+    /**
+     * Create a new tetromino piece
+     */
+    createPiece() {
+        // If we have a next piece, use it
+        if (this.nextPiece) {
+            this.currentPiece = this.nextPiece;
+            this.nextPiece = null;
+        }
+        else {
+            // Create a new random piece
+            const shapeIndex = Math.floor(Math.random() * this.shapes.length);
+            this.currentPiece = {
+                shape: this.shapes[shapeIndex],
+                pos: { x: Math.floor(this.cols / 2) - 1, y: 0 }
+            };
+        }
+        // Create the next piece
+        const nextShapeIndex = Math.floor(Math.random() * this.shapes.length);
+        this.nextPiece = {
+            shape: this.shapes[nextShapeIndex],
+            pos: { x: Math.floor(this.cols / 2) - 1, y: 0 }
+        };
+        // Check for game over
+        if (this.checkCollision()) {
+            // Game over
+            this.isRunning = false;
+            this.resetGrid();
+        }
+    }
+    /**
+     * Move the current piece down
+     */
+    dropPiece() {
+        this.currentPiece.pos.y++;
+        this.dropCounter = 0;
+        if (this.checkCollision()) {
+            // Revert position
+            this.currentPiece.pos.y--;
+            // Merge piece with grid
+            this.mergePiece();
+            // Check for completed lines
+            this.checkLines();
+            // Create new piece
+            this.createPiece();
+        }
+    }
+    /**
+     * Check if the current piece collides with the grid or boundaries
+     */
+    checkCollision() {
+        const { shape, pos } = this.currentPiece;
+        for (let y = 0; y < shape.length; y++) {
+            for (let x = 0; x < shape[y].length; x++) {
+                if (shape[y][x] !== 0) {
+                    const gridX = pos.x + x;
+                    const gridY = pos.y + y;
+                    // Check boundaries
+                    if (gridX < 0 || gridX >= this.cols || gridY >= this.rows) {
+                        return true;
+                    }
+                    // Check collision with existing blocks
+                    if (gridY >= 0 && this.grid[gridY][gridX] !== 0) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Merge the current piece with the grid
+     */
+    mergePiece() {
+        const { shape, pos } = this.currentPiece;
+        for (let y = 0; y < shape.length; y++) {
+            for (let x = 0; x < shape[y].length; x++) {
+                const value = shape[y][x];
+                if (value !== 0) {
+                    const gridY = pos.y + y;
+                    const gridX = pos.x + x;
+                    // Only merge if within bounds
+                    if (gridY >= 0 && gridY < this.rows && gridX >= 0 && gridX < this.cols) {
+                        this.grid[gridY][gridX] = value;
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Check for completed lines and remove them
+     */
+    checkLines() {
+        var _a;
+        let linesCleared = 0;
+        for (let y = this.rows - 1; y >= 0; y--) {
+            // Check if row is full
+            if (this.grid[y].every(value => value !== 0)) {
+                // Remove the line
+                this.grid.splice(y, 1);
+                // Add a new empty line at the top
+                this.grid.unshift(Array(this.cols).fill(0));
+                // Increment counter and check the same row again (since we moved rows down)
+                linesCleared++;
+                y++;
+            }
+        }
+        if (linesCleared > 0) {
+            const pts = (_a = [0, this.scoring.singleLine, this.scoring.doubleLine, this.scoring.tripleLine, this.scoring.tetris][linesCleared]) !== null && _a !== void 0 ? _a : this.scoring.tetris;
+            this.updateScore(pts);
+        }
+    }
+    /**
+     * Move the current piece left or right
+     */
+    movePiece(dir) {
+        this.currentPiece.pos.x += dir;
+        if (this.checkCollision()) {
+            this.currentPiece.pos.x -= dir;
+        }
+    }
+    /**
+     * Rotate the current piece
+     */
+    rotatePiece() {
+        // Save current position
+        const pos = this.currentPiece.pos.x;
+        // Rotate matrix
+        const rotated = [];
+        const shape = this.currentPiece.shape;
+        for (let y = 0; y < shape[0].length; y++) {
+            const row = [];
+            for (let x = 0; x < shape.length; x++) {
+                row.push(shape[shape.length - 1 - x][y]);
+            }
+            rotated.push(row);
+        }
+        // Apply rotation
+        this.currentPiece.shape = rotated;
+        // Check for collision and adjust if needed
+        let offset = 1;
+        while (this.checkCollision()) {
+            this.currentPiece.pos.x += offset;
+            offset = -(offset + (offset > 0 ? 1 : -1));
+            // If we've tried moving too far, revert rotation
+            if (offset > shape[0].length) {
+                this.currentPiece.shape = shape;
+                this.currentPiece.pos.x = pos;
+                return;
+            }
+        }
+    }
+    /**
+     * Set up control event listeners
+     */
+    setupControls() {
+        window.addEventListener('keydown', this.handleKeyDown);
+        // Mobile touch controls could be added here
+    }
+}
+
+// Simple theme colors for snake/food (SDK has theme string only)
+const THEME_COLORS$1 = {
+    default: { primary: '#333333', secondary: '#666666', accent: '#4caf50', text: '#222222' },
+    cyberpunk: { primary: '#ff00ff', secondary: '#00ffff', accent: '#ffff00', text: '#ffffff' },
+    minimal: { primary: '#000000', secondary: '#333333', accent: '#555555', text: '#111111' },
+    corporate: { primary: '#3f51b5', secondary: '#7986cb', accent: '#ff4081', text: '#263238' }
+};
+/**
+ * Snake game implementation
+ */
+class SnakeGame extends BaseGame {
+    constructor(config) {
+        super(config);
+        this.snake = [];
+        this.food = null;
+        this.direction = 'right';
+        this.nextDirection = 'right';
+        this.animationFrame = null;
+        this.lastTime = 0;
+        this.moveInterval = 200;
+        this.moveCounter = 0;
+        this.highScore = 0;
+        this.touchStartX = 0;
+        this.touchStartY = 0;
+        this.handleKeyDown = (e) => {
+            if (!this.isRunning)
+                return;
+            const current = this.nextDirection;
+            switch (e.key) {
+                case 'ArrowUp':
+                    if (current !== 'down')
+                        this.nextDirection = 'up';
+                    break;
+                case 'ArrowDown':
+                    if (current !== 'up')
+                        this.nextDirection = 'down';
+                    break;
+                case 'ArrowLeft':
+                    if (current !== 'right')
+                        this.nextDirection = 'left';
+                    break;
+                case 'ArrowRight':
+                    if (current !== 'left')
+                        this.nextDirection = 'right';
+                    break;
+            }
+            e.preventDefault();
+        };
+        this.handleTouchStart = (e) => {
+            if (e.touches.length > 0) {
+                this.touchStartX = e.touches[0].clientX;
+                this.touchStartY = e.touches[0].clientY;
+            }
+        };
+        this.handleTouchEnd = (e) => {
+            if (!this.isRunning || !e.changedTouches || e.changedTouches.length === 0)
+                return;
+            const dx = e.changedTouches[0].clientX - this.touchStartX;
+            const dy = e.changedTouches[0].clientY - this.touchStartY;
+            const minSwipe = 30;
+            if (Math.abs(dx) > Math.abs(dy)) {
+                if (dx > minSwipe && this.nextDirection !== 'left')
+                    this.nextDirection = 'right';
+                else if (dx < -minSwipe && this.nextDirection !== 'right')
+                    this.nextDirection = 'left';
+            }
+            else {
+                if (dy > minSwipe && this.nextDirection !== 'up')
+                    this.nextDirection = 'down';
+                else if (dy < -minSwipe && this.nextDirection !== 'down')
+                    this.nextDirection = 'up';
+            }
+        };
+        this.gridSize = typeof config.gridSize === 'number' ? config.gridSize : 20;
+        this.foodValue = typeof config.foodValue === 'number' ? config.foodValue : 10;
+        const width = typeof config.width === 'number' ? config.width : 400;
+        const height = typeof config.height === 'number' ? config.height : 400;
+        this.gridWidth = this.gridSize;
+        this.gridHeight = this.gridSize;
+        this.cellSize = Math.max(10, Math.floor(Math.min(width, height) / this.gridSize)) || 20;
+        this.moveInterval = typeof config.speed === 'number' && config.speed > 0
+            ? Math.max(80, 200 / config.speed)
+            : 200;
+        this.canvas = document.createElement('canvas');
+        this.canvas.width = this.gridWidth * this.cellSize;
+        this.canvas.height = this.gridHeight * this.cellSize;
+        this.canvas.style.display = 'block';
+        this.canvas.style.margin = '0 auto';
+        this.canvas.style.border = '1px solid #333';
+        this.container.appendChild(this.canvas);
+        const ctx = this.canvas.getContext('2d');
+        if (!ctx) {
+            throw new Error('Could not get canvas context');
+        }
+        this.ctx = ctx;
+        this.setupControls();
+    }
+    getColors() {
+        return THEME_COLORS$1[this.theme] || THEME_COLORS$1.default;
+    }
+    start() {
+        if (this.isRunning) {
+            return;
+        }
+        this.isRunning = true;
+        this.resetGame();
+        this.lastTime = 0;
+        this.score = 0;
+        this.moveInterval = 200;
+        this.update(0);
+    }
+    pause() {
+        if (!this.isRunning || !this.animationFrame) {
+            return;
+        }
+        this.isRunning = false;
+        cancelAnimationFrame(this.animationFrame);
+        this.animationFrame = null;
+    }
+    resume() {
+        if (this.isRunning) {
+            return;
+        }
+        this.isRunning = true;
+        this.lastTime = 0;
+        this.update(0);
+    }
+    destroy() {
+        if (this.animationFrame) {
+            cancelAnimationFrame(this.animationFrame);
+            this.animationFrame = null;
+        }
+        window.removeEventListener('keydown', this.handleKeyDown);
+        window.removeEventListener('touchstart', this.handleTouchStart);
+        window.removeEventListener('touchend', this.handleTouchEnd);
+        if (this.canvas.parentNode) {
+            this.canvas.parentNode.removeChild(this.canvas);
+        }
+        this.isRunning = false;
+    }
+    update(time) {
+        if (!this.isRunning)
+            return;
+        const deltaTime = time - this.lastTime;
+        this.lastTime = time;
+        this.moveCounter += deltaTime;
+        if (this.moveCounter >= this.moveInterval) {
+            this.direction = this.nextDirection;
+            this.moveSnake();
+            this.moveCounter = 0;
+        }
+        this.draw();
+        this.animationFrame = requestAnimationFrame(this.update.bind(this));
+    }
+    draw() {
+        const colors = this.getColors();
+        this.ctx.fillStyle = '#0a0a0a';
+        this.ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
+        // Subtle grid
+        this.ctx.strokeStyle = colors.text;
+        this.ctx.globalAlpha = 0.15;
+        for (let i = 0; i <= this.gridWidth; i++) {
+            this.ctx.beginPath();
+            this.ctx.moveTo(i * this.cellSize, 0);
+            this.ctx.lineTo(i * this.cellSize, this.canvas.height);
+            this.ctx.stroke();
+        }
+        for (let j = 0; j <= this.gridHeight; j++) {
+            this.ctx.beginPath();
+            this.ctx.moveTo(0, j * this.cellSize);
+            this.ctx.lineTo(this.canvas.width, j * this.cellSize);
+            this.ctx.stroke();
+        }
+        this.ctx.globalAlpha = 1;
+        // Food
+        if (this.food) {
+            this.ctx.fillStyle = colors.secondary;
+            this.ctx.fillRect(this.food.x * this.cellSize + 1, this.food.y * this.cellSize + 1, this.cellSize - 2, this.cellSize - 2);
+        }
+        // Snake body
+        for (let i = 0; i < this.snake.length; i++) {
+            const seg = this.snake[i];
+            const isHead = i === this.snake.length - 1;
+            this.ctx.fillStyle = isHead ? colors.accent : colors.primary;
+            this.ctx.fillRect(seg.x * this.cellSize + 1, seg.y * this.cellSize + 1, this.cellSize - 2, this.cellSize - 2);
+        }
+        // Score
+        this.ctx.fillStyle = colors.text;
+        this.ctx.font = '14px Arial';
+        this.ctx.fillText(`Score: ${this.score}  High: ${this.highScore}`, 8, 18);
+    }
+    resetGame() {
+        const cx = Math.floor(this.gridWidth / 2);
+        const cy = Math.floor(this.gridHeight / 2);
+        this.snake = [
+            { x: cx - 2, y: cy },
+            { x: cx - 1, y: cy },
+            { x: cx, y: cy }
+        ];
+        this.direction = 'right';
+        this.nextDirection = 'right';
+        this.spawnFood();
+    }
+    spawnFood() {
+        const empty = [];
+        for (let y = 0; y < this.gridHeight; y++) {
+            for (let x = 0; x < this.gridWidth; x++) {
+                if (!this.snake.some(s => s.x === x && s.y === y)) {
+                    empty.push({ x, y });
+                }
+            }
+        }
+        if (empty.length === 0) {
+            this.food = null;
+            return;
+        }
+        this.food = empty[Math.floor(Math.random() * empty.length)];
+    }
+    moveSnake() {
+        const head = this.snake[this.snake.length - 1];
+        let nx = head.x;
+        let ny = head.y;
+        switch (this.direction) {
+            case 'up':
+                ny--;
+                break;
+            case 'down':
+                ny++;
+                break;
+            case 'left':
+                nx--;
+                break;
+            case 'right':
+                nx++;
+                break;
+        }
+        // Wall collision
+        if (nx < 0 || nx >= this.gridWidth || ny < 0 || ny >= this.gridHeight) {
+            this.gameOver();
+            return;
+        }
+        // Self collision
+        if (this.snake.some(s => s.x === nx && s.y === ny)) {
+            this.gameOver();
+            return;
+        }
+        this.snake.push({ x: nx, y: ny });
+        // Food collision
+        if (this.food && this.food.x === nx && this.food.y === ny) {
+            this.updateScore(this.foodValue);
+            if (this.score > this.highScore)
+                this.highScore = this.score;
+            this.spawnFood();
+            if (this.moveInterval > 80) {
+                this.moveInterval -= 5;
+            }
+        }
+        else {
+            this.snake.shift();
+        }
+    }
+    gameOver() {
+        this.isRunning = false;
+        if (this.animationFrame) {
+            cancelAnimationFrame(this.animationFrame);
+            this.animationFrame = null;
+        }
+    }
+    setupControls() {
+        window.addEventListener('keydown', this.handleKeyDown);
+        window.addEventListener('touchstart', this.handleTouchStart, { passive: true });
+        window.addEventListener('touchend', this.handleTouchEnd, { passive: true });
+    }
+}
+
+const THEME_COLORS = {
+    default: { primary: '#333333', secondary: '#666666', accent: '#4caf50', text: '#222222' },
+    cyberpunk: { primary: '#ff00ff', secondary: '#00ffff', accent: '#ffff00', text: '#ffffff' },
+    minimal: { primary: '#000000', secondary: '#333333', accent: '#555555', text: '#111111' },
+    corporate: { primary: '#3f51b5', secondary: '#7986cb', accent: '#ff4081', text: '#263238' }
+};
+/**
+ * Breakout game implementation
+ */
+class BreakoutGame extends BaseGame {
+    constructor(config) {
+        super(config);
+        this.bricks = [];
+        this.animationFrame = null;
+        this.lastTime = 0;
+        this.ballLaunched = false;
+        this.lives = 3;
+        this.level = 1;
+        this.highScore = 0;
+        this.paused = false;
+        this.paddleHeight = 10;
+        this.ballRadius = 8;
+        this.brickPadding = 8;
+        this.brickOffsetTop = 50;
+        this.handleMouseMove = (e) => {
+            const rect = this.canvas.getBoundingClientRect();
+            const scaleX = this.canvas.width / rect.width;
+            const relativeX = (e.clientX - rect.left) * scaleX;
+            this.paddle.x = Math.max(0, Math.min(this.width - this.paddle.width, relativeX - this.paddle.width / 2));
+        };
+        this.handleTouchMove = (e) => {
+            e.preventDefault();
+            if (e.touches.length > 0) {
+                const rect = this.canvas.getBoundingClientRect();
+                const scaleX = this.canvas.width / rect.width;
+                const relativeX = (e.touches[0].clientX - rect.left) * scaleX;
+                this.paddle.x = Math.max(0, Math.min(this.width - this.paddle.width, relativeX - this.paddle.width / 2));
+            }
+        };
+        this.handleClick = () => {
+            this.launchBall();
+        };
+        this.handleKeyDown = (e) => {
+            if (e.key === ' ') {
+                e.preventDefault();
+                if (this.isRunning) {
+                    if (this.paused)
+                        this.resume();
+                    else
+                        this.pause();
+                }
+            }
+        };
+        this.width = typeof config.width === 'number' ? config.width : 480;
+        this.height = typeof config.height === 'number' ? config.height : 320;
+        this.paddleWidth = typeof config.paddleWidth === 'number' ? config.paddleWidth : 100;
+        this.brickRows = typeof config.brickRows === 'number' ? config.brickRows : 5;
+        this.brickColumns = typeof config.brickColumns === 'number' ? config.brickColumns : 8;
+        this.baseBallSpeed = typeof config.ballSpeed === 'number' && config.ballSpeed > 0 ? config.ballSpeed : 5;
+        this.canvas = document.createElement('canvas');
+        this.canvas.width = this.width;
+        this.canvas.height = this.height;
+        this.canvas.style.display = 'block';
+        this.canvas.style.margin = '0 auto';
+        this.canvas.style.border = '1px solid #333';
+        this.container.appendChild(this.canvas);
+        const ctx = this.canvas.getContext('2d');
+        if (!ctx)
+            throw new Error('Could not get canvas context');
+        this.ctx = ctx;
+        this.paddle = {
+            x: this.width / 2 - this.paddleWidth / 2,
+            y: this.height - 25,
+            width: this.paddleWidth,
+            height: this.paddleHeight
+        };
+        this.ball = {
+            x: this.width / 2,
+            y: this.height - 40,
+            dx: 0,
+            dy: 0,
+            radius: this.ballRadius
+        };
+        this.setupControls();
+    }
+    getColors() {
+        return THEME_COLORS[this.theme] || THEME_COLORS.default;
+    }
+    start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        this.lives = 3;
+        this.level = 1;
+        this.score = 0;
+        this.ballLaunched = false;
+        this.baseBallSpeed = 5;
+        this.resetGame();
+        this.lastTime = 0;
+        this.update(0);
+    }
+    pause() {
+        if (!this.isRunning || !this.animationFrame)
+            return;
+        this.paused = true;
+        this.isRunning = false;
+        cancelAnimationFrame(this.animationFrame);
+        this.animationFrame = null;
+    }
+    resume() {
+        if (this.isRunning)
+            return;
+        this.paused = false;
+        this.isRunning = true;
+        this.lastTime = 0;
+        this.update(0);
+    }
+    destroy() {
+        if (this.animationFrame) {
+            cancelAnimationFrame(this.animationFrame);
+            this.animationFrame = null;
+        }
+        this.canvas.removeEventListener('mousemove', this.handleMouseMove);
+        this.canvas.removeEventListener('touchmove', this.handleTouchMove);
+        this.canvas.removeEventListener('click', this.handleClick);
+        window.removeEventListener('keydown', this.handleKeyDown);
+        if (this.canvas.parentNode) {
+            this.canvas.parentNode.removeChild(this.canvas);
+        }
+        this.isRunning = false;
+    }
+    update(time) {
+        if (!this.isRunning) {
+            this.draw();
+            this.animationFrame = requestAnimationFrame(this.update.bind(this));
+            return;
+        }
+        const deltaTime = Math.min(time - this.lastTime, 50);
+        this.lastTime = time;
+        if (!this.paused && this.ballLaunched) {
+            this.updateGameState(deltaTime);
+        }
+        this.draw();
+        this.animationFrame = requestAnimationFrame(this.update.bind(this));
+    }
+    initBricks() {
+        const colors = this.getColors();
+        const rowColors = [colors.primary, colors.secondary, colors.accent];
+        const brickW = (this.width - this.brickPadding * (this.brickColumns + 1)) / this.brickColumns;
+        const brickH = 18;
+        this.bricks = [];
+        for (let r = 0; r < this.brickRows; r++) {
+            for (let c = 0; c < this.brickColumns; c++) {
+                const points = this.brickRows - r;
+                this.bricks.push({
+                    x: this.brickPadding + c * (brickW + this.brickPadding),
+                    y: this.brickOffsetTop + r * (brickH + this.brickPadding),
+                    width: brickW,
+                    height: brickH,
+                    visible: true,
+                    color: rowColors[r % rowColors.length],
+                    points
+                });
+            }
+        }
+    }
+    resetGame() {
+        this.initBricks();
+        this.paddle.x = this.width / 2 - this.paddle.width / 2;
+        this.paddle.y = this.height - 25;
+        this.baseBallSpeed;
+        this.ball.x = this.width / 2;
+        this.ball.y = this.height - 40;
+        this.ball.dx = 0;
+        this.ball.dy = 0;
+        this.ballLaunched = false;
+    }
+    launchBall() {
+        if (this.ballLaunched)
+            return;
+        this.ballLaunched = true;
+        const speed = this.baseBallSpeed;
+        this.ball.dx = speed * 0.6;
+        this.ball.dy = -speed;
+    }
+    updateGameState(deltaTime) {
+        this.ball.x += this.ball.dx;
+        this.ball.y += this.ball.dy;
+        if (this.ball.x - this.ball.radius < 0) {
+            this.ball.x = this.ball.radius;
+            this.ball.dx = -this.ball.dx;
+        }
+        if (this.ball.x + this.ball.radius > this.width) {
+            this.ball.x = this.width - this.ball.radius;
+            this.ball.dx = -this.ball.dx;
+        }
+        if (this.ball.y - this.ball.radius < 0) {
+            this.ball.y = this.ball.radius;
+            this.ball.dy = -this.ball.dy;
+        }
+        if (this.ball.y + this.ball.radius > this.paddle.y &&
+            this.ball.y - this.ball.radius < this.paddle.y + this.paddle.height &&
+            this.ball.x >= this.paddle.x &&
+            this.ball.x <= this.paddle.x + this.paddle.width) {
+            const hitPos = (this.ball.x - (this.paddle.x + this.paddle.width / 2)) / (this.paddle.width / 2);
+            this.ball.dy = -Math.abs(this.ball.dy);
+            this.ball.dx = this.baseBallSpeed * 0.8 * hitPos;
+            this.ball.y = this.paddle.y - this.ball.radius;
+        }
+        if (this.ball.y + this.ball.radius > this.height) {
+            this.lives--;
+            if (this.lives <= 0) {
+                this.isRunning = false;
+                if (this.score > this.highScore)
+                    this.highScore = this.score;
+                return;
+            }
+            this.ball.x = this.width / 2;
+            this.ball.y = this.height - 40;
+            this.ball.dx = 0;
+            this.ball.dy = 0;
+            this.ballLaunched = false;
+            return;
+        }
+        for (const brick of this.bricks) {
+            if (!brick.visible)
+                continue;
+            if (this.ball.x + this.ball.radius > brick.x &&
+                this.ball.x - this.ball.radius < brick.x + brick.width &&
+                this.ball.y + this.ball.radius > brick.y &&
+                this.ball.y - this.ball.radius < brick.y + brick.height) {
+                brick.visible = false;
+                this.updateScore(brick.points);
+                if (this.score > this.highScore)
+                    this.highScore = this.score;
+                this.ball.dy = -this.ball.dy;
+                break;
+            }
+        }
+        const visibleCount = this.bricks.filter(b => b.visible).length;
+        if (visibleCount === 0) {
+            this.level++;
+            this.baseBallSpeed = Math.min(this.baseBallSpeed * 1.1, this.baseBallSpeed * 2);
+            this.resetGame();
+            this.ballLaunched = false;
+        }
+    }
+    draw() {
+        const colors = this.getColors();
+        this.ctx.fillStyle = '#0a0a12';
+        this.ctx.fillRect(0, 0, this.width, this.height);
+        this.bricks.forEach(b => {
+            if (!b.visible)
+                return;
+            this.ctx.fillStyle = b.color;
+            this.ctx.fillRect(b.x, b.y, b.width, b.height);
+        });
+        this.ctx.fillStyle = colors.primary;
+        this.ctx.fillRect(this.paddle.x, this.paddle.y, this.paddle.width, this.paddle.height);
+        this.ctx.fillStyle = colors.accent;
+        this.ctx.beginPath();
+        this.ctx.arc(this.ball.x, this.ball.y, this.ball.radius, 0, Math.PI * 2);
+        this.ctx.fill();
+        this.ctx.fillStyle = colors.text;
+        this.ctx.font = '14px Arial';
+        this.ctx.fillText(`Lives: ${this.lives}  Score: ${this.score}  High: ${this.highScore}`, 8, 22);
+        this.ctx.fillText(`Level ${this.level}`, this.width - 60, 22);
+        for (let i = 0; i < this.lives; i++) {
+            this.ctx.beginPath();
+            this.ctx.arc(8 + i * 14, 38, 5, 0, Math.PI * 2);
+            this.ctx.fillStyle = colors.accent;
+            this.ctx.fill();
+        }
+        if (this.paused) {
+            this.ctx.fillStyle = 'rgba(0,0,0,0.6)';
+            this.ctx.fillRect(0, 0, this.width, this.height);
+            this.ctx.fillStyle = '#fff';
+            this.ctx.font = '24px Arial';
+            this.ctx.textAlign = 'center';
+            this.ctx.fillText('Paused - Press Space', this.width / 2, this.height / 2);
+            this.ctx.textAlign = 'left';
+        }
+        if (!this.isRunning && this.lives <= 0) {
+            this.ctx.fillStyle = 'rgba(0,0,0,0.7)';
+            this.ctx.fillRect(0, 0, this.width, this.height);
+            this.ctx.fillStyle = '#fff';
+            this.ctx.font = '28px Arial';
+            this.ctx.textAlign = 'center';
+            this.ctx.fillText('Game Over', this.width / 2, this.height / 2 - 20);
+            this.ctx.font = '16px Arial';
+            this.ctx.fillText(`Score: ${this.score}`, this.width / 2, this.height / 2 + 10);
+            this.ctx.textAlign = 'left';
+        }
+        if (this.isRunning && !this.ballLaunched) {
+            this.ctx.fillStyle = 'rgba(0,0,0,0.4)';
+            this.ctx.font = '14px Arial';
+            this.ctx.textAlign = 'center';
+            this.ctx.fillText('Click or tap to launch', this.width / 2, this.height / 2);
+            this.ctx.textAlign = 'left';
+        }
+    }
+    setupControls() {
+        this.canvas.addEventListener('mousemove', this.handleMouseMove);
+        this.canvas.addEventListener('touchmove', this.handleTouchMove, { passive: false });
+        this.canvas.addEventListener('click', this.handleClick);
+        window.addEventListener('keydown', this.handleKeyDown);
+    }
+}
+
+/**
+ * Load a game instance
+ * @param gameType Type of game to load
+ * @param config Game configuration
+ * @returns Game instance
+ */
+function loadGame(gameType, config) {
+    switch (gameType) {
+        case 'tetris':
+            return new TetrisGame(config);
+        case 'snake':
+            return new SnakeGame(config);
+        case 'breakout':
+            return new BreakoutGame(config);
+        default:
+            // TypeScript should prevent this, but just in case
+            return new TetrisGame(config);
+    }
+}
+
+/**
+ * Validate and normalize game options
+ * @param options User-provided game options
+ * @returns Validated game options
+ */
+function validateOptions(options) {
+    const validatedOptions = { ...options };
+    // Validate game type
+    if (options.game && !isValidGameType(options.game)) {
+        console.warn(`Invalid game type: ${options.game}. Defaulting to tetris.`);
+        validatedOptions.game = 'tetris';
+    }
+    // Validate theme
+    if (options.theme && !isValidThemeType(options.theme)) {
+        console.warn(`Invalid theme: ${options.theme}. Defaulting to default theme.`);
+        validatedOptions.theme = 'default';
+    }
+    // Ensure message is a string
+    if (options.message && typeof options.message !== 'string') {
+        validatedOptions.message = String(options.message);
+    }
+    // Validate dimensions
+    if (options.width && (typeof options.width !== 'number' || options.width <= 0)) {
+        delete validatedOptions.width;
+    }
+    if (options.height && (typeof options.height !== 'number' || options.height <= 0)) {
+        delete validatedOptions.height;
+    }
+    return validatedOptions;
+}
+/**
+ * Check if a game type is valid
+ * @param game Game type to validate
+ * @returns Whether the game type is valid
+ */
+function isValidGameType(game) {
+    return ['tetris', 'snake', 'breakout'].includes(game);
+}
+/**
+ * Check if a theme type is valid
+ * @param theme Theme type to validate
+ * @returns Whether the theme type is valid
+ */
+function isValidThemeType(theme) {
+    return ['default', 'cyberpunk', 'minimal', 'corporate'].includes(theme);
+}
+/**
+ * Preload common assets used by games
+ */
+function preloadAssets() {
+    // This would preload images, sounds, etc. needed by the games
+    // For now, we'll just create a placeholder implementation
+    // Example of image preloading
+    const imageUrls = [
+    // These would be actual URLs in production
+    // 'https://assets.waitlessapi.com/tetris/blocks.png',
+    // 'https://assets.waitlessapi.com/common/bg.png'
+    ];
+    imageUrls.forEach(url => {
+        const img = new Image();
+        img.src = url;
+    });
+}
+
+class AdPlayer {
+    constructor(container) {
+        this.loadingOverlay = null;
+        this.adBadge = null;
+        this.container = container;
+        this.adDisplayContainer = null;
+        this.adsLoader = null;
+        this.adsManager = null;
+        this.videoElement = null;
+        this.adContainer = null;
+        this.setupElements();
+    }
+    setupElements() {
+        this.videoElement = document.createElement('video');
+        this.videoElement.style.cssText = `
+      width: 100%;
+      height: 100%;
+      object-fit: contain;
+      background: #000;
+    `;
+        this.adContainer = document.createElement('div');
+        const w = Math.max(this.container.offsetWidth || 1, 1);
+        const h = Math.max(this.container.offsetHeight || 1, 1);
+        this.adContainer.style.cssText = `
+      position: absolute;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      min-width: ${w}px;
+      min-height: ${h}px;
+    `;
+        this.adContainer.appendChild(this.videoElement);
+        this.adBadge = document.createElement('div');
+        this.adBadge.textContent = 'Ad';
+        this.adBadge.style.cssText = `
+      position: absolute;
+      top: 8px;
+      right: 8px;
+      font-size: 10px;
+      font-family: sans-serif;
+      color: rgba(255,255,255,0.9);
+      background: rgba(0,0,0,0.5);
+      padding: 2px 6px;
+      border-radius: 2px;
+      z-index: 10;
+      display: none;
+    `;
+        this.adContainer.appendChild(this.adBadge);
+        this.container.appendChild(this.adContainer);
+    }
+    showLoadingOverlay() {
+        if (this.loadingOverlay && this.loadingOverlay.parentNode)
+            return;
+        this.loadingOverlay = document.createElement('div');
+        this.loadingOverlay.setAttribute('aria-live', 'polite');
+        this.loadingOverlay.setAttribute('aria-label', 'Loading ad');
+        this.loadingOverlay.style.cssText = `
+      position: absolute;
+      top: 0; left: 0;
+      width: 100%; height: 100%;
+      background: rgba(0,0,0,0.85);
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      gap: 12px;
+      z-index: 20;
+      color: rgba(255,255,255,0.9);
+      font-family: sans-serif;
+      font-size: 14px;
+    `;
+        const spinner = document.createElement('div');
+        spinner.style.cssText = `
+      width: 32px; height: 32px;
+      border: 3px solid rgba(255,255,255,0.2);
+      border-top-color: #fff;
+      border-radius: 50%;
+      animation: ad-spin 0.8s linear infinite;
+    `;
+        const style = document.createElement('style');
+        style.textContent = '@keyframes ad-spin { to { transform: rotate(360deg); } }';
+        this.loadingOverlay.appendChild(style);
+        this.loadingOverlay.appendChild(spinner);
+        const text = document.createElement('span');
+        text.textContent = 'Loading ad…';
+        this.loadingOverlay.appendChild(text);
+        this.container.appendChild(this.loadingOverlay);
+    }
+    removeLoadingOverlay() {
+        if (this.loadingOverlay && this.loadingOverlay.parentNode) {
+            this.loadingOverlay.parentNode.removeChild(this.loadingOverlay);
+        }
+        this.loadingOverlay = null;
+    }
+    showErrorOverlay(thenRun) {
+        this.removeLoadingOverlay();
+        const overlay = document.createElement('div');
+        overlay.setAttribute('aria-live', 'polite');
+        overlay.setAttribute('aria-label', 'Ad could not load');
+        overlay.style.cssText = `
+      position: absolute;
+      top: 0; left: 0;
+      width: 100%; height: 100%;
+      background: rgba(0,0,0,0.9);
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      gap: 16px;
+      z-index: 30;
+      color: rgba(255,255,255,0.95);
+      font-family: sans-serif;
+      font-size: 14px;
+    `;
+        const message = document.createElement('p');
+        message.textContent = "Ad couldn't load";
+        message.style.margin = '0';
+        overlay.appendChild(message);
+        const btn = document.createElement('button');
+        btn.textContent = 'Continue';
+        btn.style.cssText = `
+      padding: 8px 20px;
+      font-size: 14px;
+      cursor: pointer;
+      background: rgba(255,255,255,0.2);
+      color: #fff;
+      border: 1px solid rgba(255,255,255,0.4);
+      border-radius: 4px;
+    `;
+        const run = () => {
+            if (overlay.parentNode)
+                overlay.parentNode.removeChild(overlay);
+            thenRun();
+        };
+        btn.addEventListener('click', run);
+        overlay.appendChild(btn);
+        this.container.appendChild(overlay);
+        setTimeout(run, 3000);
+    }
+    async playAd(config) {
+        return new Promise((resolve) => {
+            var _a;
+            this.showLoadingOverlay();
+            const onError = () => {
+                this.showErrorOverlay(() => {
+                    this.cleanup();
+                    resolve();
+                });
+            };
+            if (!((_a = window.google) === null || _a === void 0 ? void 0 : _a.ima)) {
+                this.loadIMAScript()
+                    .then(() => this.initializeAd(config, resolve, onError))
+                    .catch(() => {
+                    var _a;
+                    (_a = config.onAdError) === null || _a === void 0 ? void 0 : _a.call(config, new Error('Failed to load IMA SDK'));
+                    onError();
+                });
+            }
+            else {
+                this.initializeAd(config, resolve, onError);
+            }
+        });
+    }
+    loadIMAScript() {
+        return new Promise((resolve, reject) => {
+            var _a;
+            if ((_a = window.google) === null || _a === void 0 ? void 0 : _a.ima) {
+                resolve();
+                return;
+            }
+            const script = document.createElement('script');
+            script.src = 'https://imasdk.googleapis.com/js/sdkloader/ima3.js';
+            script.async = true;
+            script.onload = () => resolve();
+            script.onerror = () => reject(new Error('Failed to load IMA SDK'));
+            document.head.appendChild(script);
+        });
+    }
+    initializeAd(config, resolve, onError) {
+        var _a;
+        const google = window.google;
+        if (!(google === null || google === void 0 ? void 0 : google.ima)) {
+            (_a = config.onAdError) === null || _a === void 0 ? void 0 : _a.call(config, new Error('IMA SDK not available'));
+            onError();
+            return;
+        }
+        this.adDisplayContainer = new google.ima.AdDisplayContainer(this.adContainer, this.videoElement);
+        this.adsLoader = new google.ima.AdsLoader(this.adDisplayContainer);
+        this.adsLoader.addEventListener(google.ima.AdsManagerLoadedEvent.Type.ADS_MANAGER_LOADED, (event) => this.onAdsManagerLoaded(event, config, resolve, onError), false);
+        this.adsLoader.addEventListener(google.ima.AdErrorEvent.Type.AD_ERROR, (event) => {
+            var _a;
+            console.warn('Ad error:', event.getError());
+            (_a = config.onAdError) === null || _a === void 0 ? void 0 : _a.call(config, event.getError());
+            this.showErrorOverlay(() => {
+                this.cleanup();
+                resolve();
+            });
+        }, false);
+        const adsRequest = new google.ima.AdsRequest();
+        adsRequest.adTagUrl = config.adTagUrl;
+        adsRequest.linearAdSlotWidth = this.container.offsetWidth;
+        adsRequest.linearAdSlotHeight = this.container.offsetHeight;
+        adsRequest.nonLinearAdSlotWidth = this.container.offsetWidth;
+        adsRequest.nonLinearAdSlotHeight = this.container.offsetHeight;
+        this.adDisplayContainer.initialize();
+        this.adsLoader.requestAds(adsRequest);
+    }
+    onAdsManagerLoaded(event, config, resolve, onError) {
+        var _a;
+        const google = window.google;
+        if (!(google === null || google === void 0 ? void 0 : google.ima)) {
+            resolve();
+            return;
+        }
+        const adsRenderingSettings = new google.ima.AdsRenderingSettings();
+        adsRenderingSettings.restoreCustomPlaybackStateOnAdBreakComplete = true;
+        this.adsManager = event.getAdsManager(this.videoElement, adsRenderingSettings);
+        this.adsManager.addEventListener(google.ima.AdErrorEvent.Type.AD_ERROR, (e) => {
+            var _a;
+            console.warn('Ad manager error:', e.getError());
+            (_a = config.onAdError) === null || _a === void 0 ? void 0 : _a.call(config, e.getError());
+            this.showErrorOverlay(() => {
+                this.cleanup();
+                resolve();
+            });
+        });
+        this.adsManager.addEventListener(google.ima.AdEvent.Type.CONTENT_PAUSE_REQUESTED, () => {
+            var _a;
+            this.removeLoadingOverlay();
+            if (this.adBadge)
+                this.adBadge.style.display = 'block';
+            (_a = config.onAdStarted) === null || _a === void 0 ? void 0 : _a.call(config);
+        });
+        this.adsManager.addEventListener(google.ima.AdEvent.Type.CONTENT_RESUME_REQUESTED, () => {
+            var _a;
+            (_a = config.onAdComplete) === null || _a === void 0 ? void 0 : _a.call(config);
+            this.cleanup();
+            resolve();
+        });
+        this.adsManager.addEventListener(google.ima.AdEvent.Type.ALL_ADS_COMPLETED, () => {
+            var _a;
+            (_a = config.onAdComplete) === null || _a === void 0 ? void 0 : _a.call(config);
+            this.cleanup();
+            resolve();
+        });
+        this.adsManager.addEventListener(google.ima.AdEvent.Type.SKIPPED, () => {
+            var _a;
+            (_a = config.onAdSkipped) === null || _a === void 0 ? void 0 : _a.call(config);
+            this.cleanup();
+            resolve();
+        });
+        try {
+            this.adsManager.init(this.container.offsetWidth, this.container.offsetHeight, google.ima.ViewMode.NORMAL);
+            this.adsManager.start();
+        }
+        catch (error) {
+            console.warn('Ad start error:', error);
+            (_a = config.onAdError) === null || _a === void 0 ? void 0 : _a.call(config, error);
+            this.showErrorOverlay(() => {
+                this.cleanup();
+                resolve();
+            });
+        }
+    }
+    cleanup() {
+        if (this.adsManager) {
+            try {
+                this.adsManager.destroy();
+            }
+            catch (_) { }
+            this.adsManager = null;
+        }
+        if (this.adsLoader) {
+            try {
+                this.adsLoader.destroy();
+            }
+            catch (_) { }
+            this.adsLoader = null;
+        }
+        this.removeLoadingOverlay();
+        if (this.adContainer && this.adContainer.parentNode) {
+            this.adContainer.parentNode.removeChild(this.adContainer);
+        }
+        this.adBadge = null;
+    }
+    destroy() {
+        this.cleanup();
+    }
+}
+
+const CONFIG_CACHE_TTL_MS = 5 * 60 * 1000;
+const CONFIG_CACHE_KEY_PREFIX = 'waitless_config_';
+const DEFAULT_AD_TAG_URL = 'https://pubads.g.doubleclick.net/gampad/ads?iu=/21775744923/external/single_ad_samples&sz=640x480&cust_params=sample_ct%3Dlinear&ciu_szs=300x250%2C728x90&gdfp_req=1&output=vast&unviewed_position_start=1&env=vp&impl=s&correlator=';
+class WaitlessAPI {
+    /**
+     * Initialize the WaitlessAPI SDK
+     * @param apiKey Your WaitlessAPI key
+     * @param baseUrlOrOptions Base URL string or options object with apiBaseUrl (defaults to production)
+     */
+    constructor(apiKey, baseUrlOrOptions = 'https://api.waitlessapi.com') {
+        var _a;
+        this.sessionId = null;
+        this.container = null;
+        this.gameInstance = null;
+        this.isPlaying = false;
+        this.lastBackendConfig = null;
+        this.config = null;
+        this.configLoaded = false;
+        this.configPromise = null;
+        this.batchIdsSeen = new Set();
+        this.lastAdTime = 0;
+        this.adsThisSession = 0;
+        this.adsThisHour = 0;
+        this.lastHourStart = 0;
+        if (!apiKey) {
+            throw new Error('API key is required');
+        }
+        const baseUrl = typeof baseUrlOrOptions === 'string'
+            ? baseUrlOrOptions
+            : (_a = baseUrlOrOptions === null || baseUrlOrOptions === void 0 ? void 0 : baseUrlOrOptions.apiBaseUrl) !== null && _a !== void 0 ? _a : 'https://api.waitlessapi.com';
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl;
+        this.apiBaseUrl = baseUrl;
+        this.defaultAdTagUrl = DEFAULT_AD_TAG_URL;
+        this.configPromise = this.loadConfig();
+        preloadAssets();
+    }
+    getDefaultConfig() {
+        return {
+            strategy: { preset: 'balanced', behavior: 'auto' },
+            frequency: { minInterval: 300, maxAdsPerSession: 3, maxAdsPerHour: 6 },
+            duration: { shortThreshold: 10, longThreshold: 60, adMaxDuration: 15, enableGames: true },
+            batch: { enabled: true, showAdOnce: true },
+            fallback: { type: 'spinner', showMessage: true },
+            analytics: { trackEvents: true, enableABTesting: false }
+        };
+    }
+    getCachedConfig() {
+        try {
+            const raw = typeof localStorage !== 'undefined' ? localStorage.getItem(CONFIG_CACHE_KEY_PREFIX + this.apiKey) : null;
+            if (!raw)
+                return null;
+            const { config, timestamp } = JSON.parse(raw);
+            if (Date.now() - timestamp > CONFIG_CACHE_TTL_MS)
+                return null;
+            return config;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    cacheConfig(config) {
+        try {
+            if (typeof localStorage !== 'undefined') {
+                localStorage.setItem(CONFIG_CACHE_KEY_PREFIX + this.apiKey, JSON.stringify({ config, timestamp: Date.now() }));
+            }
+        }
+        catch (_a) {
+            // ignore
+        }
+    }
+    async loadConfig() {
+        const cached = this.getCachedConfig();
+        if (cached) {
+            this.config = cached;
+            this.configLoaded = true;
+            return;
+        }
+        try {
+            const url = `${this.apiBaseUrl}/api/keys/${encodeURIComponent(this.apiKey)}/config`;
+            const res = await fetch(url);
+            if (res.ok) {
+                const data = (await res.json());
+                this.config = data;
+                this.cacheConfig(data);
+            }
+            else {
+                this.config = this.getDefaultConfig();
+            }
+        }
+        catch (_a) {
+            this.config = this.getDefaultConfig();
+        }
+        this.configLoaded = true;
+    }
+    /** Wait for config to be loaded (e.g. before using showAd). */
+    async ensureConfigLoaded() {
+        if (!this.configLoaded && this.configPromise)
+            await this.configPromise;
+    }
+    /** Clear cache and reload config from API. */
+    async refreshConfig() {
+        try {
+            if (typeof localStorage !== 'undefined')
+                localStorage.removeItem(CONFIG_CACHE_KEY_PREFIX + this.apiKey);
+        }
+        catch (_a) {
+            // ignore
+        }
+        this.configLoaded = false;
+        this.configPromise = this.loadConfig();
+        await this.configPromise;
+    }
+    /** Return current config (for debugging). */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Run processing with a minimal fallback UI (spinner/message). No ad or game.
+     */
+    async showProcessing(processingFn, type, message) {
+        const overlay = document.createElement('div');
+        overlay.style.cssText =
+            'position:fixed;inset:0;z-index:9999;background:rgba(0,0,0,0.7);display:flex;flex-direction:column;align-items:center;justify-content:center;';
+        const text = document.createElement('div');
+        text.textContent = message || 'Processing...';
+        text.style.cssText = 'color:#fff;font-size:18px;margin-top:12px;';
+        const spinner = document.createElement('div');
+        spinner.style.cssText =
+            'width:40px;height:40px;border:3px solid rgba(255,255,255,0.3);border-top-color:#fff;border-radius:50%;animation:waitless-spin 0.8s linear infinite;';
+        if (!document.getElementById('waitless-spinner-style')) {
+            const style = document.createElement('style');
+            style.id = 'waitless-spinner-style';
+            style.textContent = '@keyframes waitless-spin { to { transform: rotate(360deg); } }';
+            document.head.appendChild(style);
+        }
+        overlay.appendChild(spinner);
+        overlay.appendChild(text);
+        document.body.appendChild(overlay);
+        try {
+            return await processingFn();
+        }
+        finally {
+            overlay.remove();
+        }
+    }
+    shouldShowAd(frequency) {
+        var _a, _b, _c;
+        if (!frequency)
+            return true;
+        const now = Date.now();
+        const minInterval = ((_a = frequency.minInterval) !== null && _a !== void 0 ? _a : 300) * 1000;
+        if (now - this.lastAdTime < minInterval)
+            return false;
+        const maxSession = (_b = frequency.maxAdsPerSession) !== null && _b !== void 0 ? _b : 3;
+        if (this.adsThisSession >= maxSession)
+            return false;
+        const hourMs = 60 * 60 * 1000;
+        const currentHourStart = Math.floor(now / hourMs) * hourMs;
+        if (currentHourStart !== this.lastHourStart) {
+            this.lastHourStart = currentHourStart;
+            this.adsThisHour = 0;
+        }
+        const maxHour = (_c = frequency.maxAdsPerHour) !== null && _c !== void 0 ? _c : 6;
+        if (this.adsThisHour >= maxHour)
+            return false;
+        return true;
+    }
+    recordAdShown() {
+        this.lastAdTime = Date.now();
+        this.adsThisSession += 1;
+        this.adsThisHour += 1;
+    }
+    /**
+     * Config-driven entry point: show ad and/or game based on dashboard config, then run processing.
+     */
+    async showAd(processingFn, options = {}) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        if (!processingFn || typeof processingFn !== 'function') {
+            throw new Error('Processing function is required and must be a function');
+        }
+        await this.ensureConfigLoaded();
+        const base = (_a = this.config) !== null && _a !== void 0 ? _a : this.getDefaultConfig();
+        const merged = {
+            ...base,
+            strategy: { ...base.strategy, ...(_b = options.overrideConfig) === null || _b === void 0 ? void 0 : _b.strategy },
+            frequency: { ...base.frequency, ...(_c = options.overrideConfig) === null || _c === void 0 ? void 0 : _c.frequency },
+            duration: { ...base.duration, ...(_d = options.overrideConfig) === null || _d === void 0 ? void 0 : _d.duration },
+            batch: { ...base.batch, ...(_e = options.overrideConfig) === null || _e === void 0 ? void 0 : _e.batch },
+            fallback: { ...base.fallback, ...(_f = options.overrideConfig) === null || _f === void 0 ? void 0 : _f.fallback },
+            analytics: { ...base.analytics, ...(_g = options.overrideConfig) === null || _g === void 0 ? void 0 : _g.analytics }
+        };
+        const batch = (_h = merged.batch) !== null && _h !== void 0 ? _h : {};
+        const frequency = (_j = merged.frequency) !== null && _j !== void 0 ? _j : {};
+        const strategy = (_k = merged.strategy) !== null && _k !== void 0 ? _k : {};
+        const behavior = (_l = strategy.behavior) !== null && _l !== void 0 ? _l : 'auto';
+        const duration = (_m = merged.duration) !== null && _m !== void 0 ? _m : {};
+        const message = (_o = options.message) !== null && _o !== void 0 ? _o : 'Loading...';
+        if (options.batchId && batch.enabled && batch.showAdOnce && this.batchIdsSeen.has(options.batchId)) {
+            return this.showProcessing(processingFn, 'spinner', message);
+        }
+        if (!this.shouldShowAd(frequency)) {
+            return this.showProcessing(processingFn, 'spinner', message);
+        }
+        const shortThreshold = (_p = duration.shortThreshold) !== null && _p !== void 0 ? _p : 10;
+        const longThreshold = (_q = duration.longThreshold) !== null && _q !== void 0 ? _q : 60;
+        const estimatedDuration = (_r = options.estimatedDuration) !== null && _r !== void 0 ? _r : 0;
+        const enableGames = duration.enableGames !== false;
+        let mode = 'ad-only';
+        if (behavior === 'game-only' || (enableGames && estimatedDuration > longThreshold)) {
+            mode = 'game-only';
+        }
+        else if (enableGames && estimatedDuration > shortThreshold && estimatedDuration <= longThreshold) {
+            mode = 'ad-plus-game';
+        }
+        if (options.batchId && batch.enabled && batch.showAdOnce) {
+            this.batchIdsSeen.add(options.batchId);
+        }
+        if (mode === 'game-only') {
+            return this.showGame(processingFn, { message });
+        }
+        const validatedOptions = validateOptions({ container: undefined, message });
+        const session = await this.createSession(validatedOptions);
+        const { container, overlay } = this.initializeGameUI(validatedOptions);
+        const adMaxDuration = (_s = duration.adMaxDuration) !== null && _s !== void 0 ? _s : 15;
+        try {
+            if (session.sessionId) {
+                await this.playAdInContainer(container, {
+                    adTagUrl: this.defaultAdTagUrl,
+                    maxDuration: adMaxDuration,
+                    sessionId: session.sessionId
+                });
+                this.recordAdShown();
+            }
+            if (mode === 'ad-plus-game') {
+                const gameInstance = this.startGame(validatedOptions);
+                const result = await processingFn();
+                this.endGame(session.sessionId);
+                this.cleanup(overlay, gameInstance);
+                return result;
+            }
+            container.innerHTML = '';
+            const spinner = document.createElement('div');
+            spinner.style.cssText =
+                'width:40px;height:40px;border:3px solid rgba(255,255,255,0.3);border-top-color:#fff;border-radius:50%;animation:waitless-spin 0.8s linear infinite;margin:auto;';
+            const text = document.createElement('div');
+            text.textContent = message;
+            text.style.cssText = 'color:#fff;font-size:18px;margin-top:12px;text-align:center;';
+            container.style.display = 'flex';
+            container.style.flexDirection = 'column';
+            container.style.alignItems = 'center';
+            container.style.justifyContent = 'center';
+            container.appendChild(spinner);
+            container.appendChild(text);
+            if (!document.getElementById('waitless-spinner-style')) {
+                const style = document.createElement('style');
+                style.id = 'waitless-spinner-style';
+                style.textContent = '@keyframes waitless-spin { to { transform: rotate(360deg); } }';
+                document.head.appendChild(style);
+            }
+            const result = await processingFn();
+            this.endGame(session.sessionId);
+            this.cleanup(overlay, null);
+            return result;
+        }
+        catch (err) {
+            this.endGame(session.sessionId);
+            this.cleanup(overlay, null);
+            throw err;
+        }
+    }
+    /**
+     * Show a game while executing a long-running function
+     * @param processingFn The function to execute while showing the game
+     * @param options Game configuration options
+     * @returns Promise with the result of the processing function
+     */
+    async showGame(processingFn, options = {}) {
+        if (!processingFn || typeof processingFn !== 'function') {
+            throw new Error('Processing function is required and must be a function');
+        }
+        const showAds = options.showAds !== false && this.apiKey !== 'demo';
+        const adPlacement = options.adPlacement || 'pre-game';
+        const validatedOptions = validateOptions(options);
+        const session = await this.createSession(validatedOptions);
+        const { container, overlay } = this.initializeGameUI(validatedOptions);
+        let gameInstance = null;
+        try {
+            if (showAds && session.sessionId && (adPlacement === 'pre-game' || adPlacement === 'both')) {
+                await this.playAdInContainer(container, {
+                    adTagUrl: options.adTagUrl || this.defaultAdTagUrl,
+                    maxDuration: options.adDuration || 15,
+                    sessionId: session.sessionId
+                });
+            }
+            gameInstance = this.startGame(validatedOptions);
+            const result = await processingFn();
+            if (showAds && session.sessionId && (adPlacement === 'post-game' || adPlacement === 'both')) {
+                await this.playAdInContainer(container, {
+                    adTagUrl: options.adTagUrl || this.defaultAdTagUrl,
+                    maxDuration: options.adDuration || 15,
+                    sessionId: session.sessionId
+                });
+            }
+            this.endGame(session.sessionId);
+            this.cleanup(overlay, gameInstance);
+            return result;
+        }
+        catch (error) {
+            this.endGame(session.sessionId);
+            this.cleanup(overlay, gameInstance || this.gameInstance);
+            throw error;
+        }
+    }
+    /**
+     * Create a new game session with the API
+     * @param options Game options
+     * @returns Session id and config (null for demo/offline)
+     */
+    async createSession(options) {
+        if (this.apiKey === 'demo') {
+            this.sessionId = null;
+            this.lastBackendConfig = null;
+            return { sessionId: null, config: null };
+        }
+        try {
+            const response = await fetch(`${this.baseUrl}/sessions`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this.apiKey
+                },
+                body: JSON.stringify({
+                    game: options.game,
+                    theme: options.theme,
+                    message: options.message
+                })
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to create game session: ${response.statusText}`);
+            }
+            const data = await response.json();
+            this.sessionId = data.sessionId;
+            this.lastBackendConfig = data.config && typeof data.config === 'object' ? data.config : null;
+            return { sessionId: this.sessionId, config: this.lastBackendConfig };
+        }
+        catch (error) {
+            console.error('Error creating WaitlessAPI session:', error);
+            this.sessionId = null;
+            this.lastBackendConfig = null;
+            return { sessionId: null, config: null };
+        }
+    }
+    /**
+     * Initialize the game UI container
+     * @param options Game options
+     * @returns container and overlay (overlay is non-null when we created the full-screen div)
+     */
+    initializeGameUI(options) {
+        let overlay = null;
+        if (options.container) {
+            if (typeof options.container === 'string') {
+                this.container = document.querySelector(options.container);
+                if (!this.container) {
+                    throw new Error(`Container element not found: ${options.container}`);
+                }
+            }
+            else {
+                this.container = options.container;
+            }
+        }
+        else {
+            this.container = document.createElement('div');
+            this.container.id = 'waitless-game-container';
+            this.container.style.position = 'fixed';
+            this.container.style.top = '0';
+            this.container.style.left = '0';
+            this.container.style.width = '100%';
+            this.container.style.height = '100%';
+            this.container.style.zIndex = '9999';
+            document.body.appendChild(this.container);
+            overlay = this.container;
+        }
+        if (options.width) {
+            this.container.style.width = `${options.width}px`;
+        }
+        if (options.height) {
+            this.container.style.height = `${options.height}px`;
+        }
+        const messageElement = document.createElement('div');
+        messageElement.id = 'waitless-message';
+        messageElement.textContent = options.message || 'Loading...';
+        messageElement.style.position = 'absolute';
+        messageElement.style.bottom = '20px';
+        messageElement.style.left = '0';
+        messageElement.style.width = '100%';
+        messageElement.style.textAlign = 'center';
+        messageElement.style.color = '#ffffff';
+        messageElement.style.fontSize = '18px';
+        messageElement.style.fontFamily = 'Arial, sans-serif';
+        messageElement.style.padding = '10px';
+        this.container.appendChild(messageElement);
+        return { container: this.container, overlay };
+    }
+    /**
+     * Start the game
+     * @param options Game options
+     * @returns The game instance
+     */
+    startGame(options) {
+        if (!this.container) {
+            return null;
+        }
+        const mergedConfig = {
+            container: this.container,
+            theme: options.theme || 'default',
+            onScore: options.onScore
+        };
+        if (options.width != null)
+            mergedConfig.width = options.width;
+        if (options.height != null)
+            mergedConfig.height = options.height;
+        if (this.lastBackendConfig) {
+            Object.assign(mergedConfig, this.lastBackendConfig);
+        }
+        this.gameInstance = loadGame(options.game || 'tetris', mergedConfig);
+        if (this.gameInstance && typeof this.gameInstance.start === 'function') {
+            this.gameInstance.start();
+        }
+        this.isPlaying = true;
+        if (options.onStart && typeof options.onStart === 'function') {
+            options.onStart();
+        }
+        return this.gameInstance;
+    }
+    async playAdInContainer(container, config) {
+        if (config.sessionId === null) {
+            return;
+        }
+        const adPlayer = new AdPlayer(container);
+        const adStartTime = Date.now();
+        try {
+            await adPlayer.playAd({
+                adTagUrl: config.adTagUrl,
+                maxDuration: config.maxDuration,
+                onAdStarted: () => {
+                    this.trackAdEvent(config.sessionId, 'ad_started');
+                },
+                onAdComplete: () => {
+                    const duration = (Date.now() - adStartTime) / 1000;
+                    this.trackAdEvent(config.sessionId, 'ad_completed', { duration });
+                },
+                onAdSkipped: () => {
+                    const duration = (Date.now() - adStartTime) / 1000;
+                    this.trackAdEvent(config.sessionId, 'ad_skipped', { duration });
+                },
+                onAdError: (error) => {
+                    this.trackAdEvent(config.sessionId, 'ad_error', { error: String(error) });
+                }
+            });
+        }
+        catch (error) {
+            console.warn('Ad loading failed, continuing:', error);
+        }
+        finally {
+            adPlayer.destroy();
+        }
+    }
+    async trackAdEvent(sessionId, event, data) {
+        try {
+            await fetch(`${this.baseUrl}/sessions/${sessionId}/ad-event`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this.apiKey
+                },
+                body: JSON.stringify({
+                    event,
+                    timestamp: Date.now(),
+                    ...data
+                })
+            });
+        }
+        catch (error) {
+            console.warn('Failed to track ad event:', error);
+        }
+    }
+    cleanup(overlay, gameInstance) {
+        if (overlay && overlay.parentNode) {
+            overlay.parentNode.removeChild(overlay);
+        }
+        this.container = null;
+        this.gameInstance = null;
+        this.isPlaying = false;
+    }
+    /**
+     * End the game and send session complete (overlay removal is done in cleanup)
+     */
+    endGame(sessionId) {
+        var _a, _b;
+        if (!this.isPlaying && !this.gameInstance) {
+            return;
+        }
+        const score = this.gameInstance && typeof this.gameInstance.getScore === 'function'
+            ? this.gameInstance.getScore()
+            : ((_b = (_a = this.gameInstance) === null || _a === void 0 ? void 0 : _a.score) !== null && _b !== void 0 ? _b : 0);
+        if (this.gameInstance && typeof this.gameInstance.destroy === 'function') {
+            this.gameInstance.destroy();
+        }
+        this.isPlaying = false;
+        this.gameInstance = null;
+        this.container = null;
+        const id = sessionId !== undefined ? sessionId : this.sessionId;
+        if (id) {
+            this.completeSession(score, id);
+        }
+        this.sessionId = null;
+    }
+    async completeSession(score, sessionId) {
+        try {
+            await fetch(`${this.baseUrl}/sessions/${sessionId}/complete`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this.apiKey
+                },
+                body: JSON.stringify({ duration: 0, score })
+            });
+        }
+        catch (error) {
+            console.error('Error completing game session:', error);
+        }
+    }
+}
+
+export { AdPlayer, WaitlessAPI, WaitlessAPI as default };
+//# sourceMappingURL=index.esm.js.map