Datasets:

webxos
/

timelink_dataset

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>TIMELINK v1.0 - by webXOS</title>
+    <!-- Libraries -->
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/three@0.128.0/examples/js/controls/OrbitControls.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/FileSaver.js/2.0.5/FileSaver.min.js"></script>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        body {
+            font-family: 'Courier New', monospace;
+            background: #000000;
+            color: #00ff00;
+            overflow: hidden;
+            height: 100vh;
+            width: 100vw;
+        }
+        /* Main Canvas */
+        #threeCanvas {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100vw;
+            height: 100vh;
+            z-index: 1;
+        }
+        /* UI Overlay */
+        #ui-overlay {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100vw;
+            height: 100vh;
+            z-index: 2;
+            pointer-events: none;
+        }
+        /* Minimal Header */
+        #minimal-header {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            background: rgba(0, 20, 0, 0.85);
+            padding: 10px 20px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            border-bottom: 1px solid #00ff00;
+            backdrop-filter: blur(5px);
+            pointer-events: auto;
+            height: 50px;
+        }
+        .minimal-logo {
+            font-size: 16px;
+            font-weight: bold;
+            color: #00ff00;
+            text-shadow: 0 0 10px #00ff00;
+        }
+        .minimal-stats {
+            display: flex;
+            gap: 20px;
+            font-size: 12px;
+        }
+        .stat-item {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+        }
+        .stat-label {
+            color: #00cc00;
+            font-size: 10px;
+        }
+        .stat-value {
+            color: #00ff00;
+            font-weight: bold;
+        }
+        /* Control Panel */
+        #control-panel {
+            position: absolute;
+            top: 60px;
+            left: 20px;
+            width: 200px;
+            background: rgba(0, 30, 0, 0.95);
+            border: 2px solid #00ff00;
+            border-radius: 8px;
+            padding: 15px;
+            backdrop-filter: blur(5px);
+            pointer-events: auto;
+        }
+        .control-title {
+            color: #00ff00;
+            font-size: 14px;
+            margin-bottom: 15px;
+            text-align: center;
+            border-bottom: 1px solid rgba(0, 255, 0, 0.3);
+            padding-bottom: 5px;
+        }
+        .shape-selector {
+            display: flex;
+            flex-direction: column;
+            gap: 8px;
+            margin-bottom: 15px;
+        }
+        .shape-btn {
+            background: rgba(0, 40, 0, 0.7);
+            border: 1px solid #00ff00;
+            color: #00ff00;
+            padding: 8px;
+            font-size: 12px;
+            cursor: pointer;
+            border-radius: 4px;
+            transition: all 0.3s;
+            text-align: center;
+        }
+        .shape-btn:hover {
+            background: rgba(0, 255, 0, 0.1);
+            box-shadow: 0 0 10px #00ff00;
+        }
+        .shape-btn.active {
+            background: rgba(0, 255, 0, 0.2);
+            box-shadow: 0 0 15px #00ff00;
+            border-color: #00ffff;
+        }
+        /* Central Generate Button */
+        #central-generate-btn {
+            position: fixed;
+            bottom: 40px;
+            left: 50%;
+            transform: translateX(-50%);
+            width: 280px;
+            background: linear-gradient(45deg, #006600, #00cc00);
+            border: none;
+            color: white;
+            padding: 20px 40px;
+            font-family: 'Courier New', monospace;
+            font-size: 18px;
+            font-weight: bold;
+            cursor: pointer;
+            border-radius: 12px;
+            text-transform: uppercase;
+            letter-spacing: 2px;
+            transition: all 0.3s;
+            z-index: 10;
+            pointer-events: auto;
+            box-shadow: 0 0 30px rgba(0, 255, 0, 0.5);
+            text-align: center;
+        }
+        #central-generate-btn:hover {
+            background: linear-gradient(45deg, #00cc00, #00ff00);
+            box-shadow: 0 0 40px rgba(0, 255, 0, 0.8);
+            transform: translateX(-50%) scale(1.05);
+        }
+        #central-generate-btn.generating {
+            background: linear-gradient(45deg, #cc0000, #ff0000);
+            animation: pulse 2s infinite;
+            box-shadow: 0 0 40px rgba(255, 0, 0, 0.6);
+        }
+        #central-generate-btn.paused {
+            background: linear-gradient(45deg, #666600, #cccc00);
+            box-shadow: 0 0 30px rgba(204, 204, 0, 0.6);
+        }
+        /* Time Scale Control */
+        .time-control {
+            margin-top: 10px;
+            padding-top: 10px;
+            border-top: 1px solid rgba(0, 255, 0, 0.3);
+        }
+        .time-slider {
+            width: 100%;
+            margin: 10px 0;
+        }
+        .time-value {
+            text-align: center;
+            font-size: 12px;
+            color: #00cc00;
+            margin-top: 5px;
+        }
+        /* Export Panel */
+        #export-panel {
+            position: absolute;
+            bottom: 20px;
+            right: 20px;
+            width: 200px;
+            background: rgba(0, 30, 0, 0.95);
+            border: 2px solid #00ff00;
+            border-radius: 8px;
+            padding: 15px;
+            backdrop-filter: blur(5px);
+            pointer-events: auto;
+        }
+        .export-btn {
+            width: 100%;
+            background: rgba(0, 60, 0, 0.8);
+            border: 1px solid #00ff00;
+            color: #00ff00;
+            padding: 10px;
+            font-family: 'Courier New', monospace;
+            font-size: 12px;
+            cursor: pointer;
+            border-radius: 4px;
+            margin: 5px 0;
+            transition: all 0.3s;
+        }
+        .export-btn:hover {
+            background: rgba(0, 255, 0, 0.1);
+            box-shadow: 0 0 10px #00ff00;
+        }
+        .export-btn.ready {
+            background: linear-gradient(45deg, #006600, #00cc00);
+            color: white;
+            font-weight: bold;
+        }
+        /* Full Screen Button */
+        #fullscreen-btn {
+            position: absolute;
+            top: 10px;
+            right: 10px;
+            background: rgba(0, 40, 0, 0.8);
+            border: 1px solid #00ff00;
+            color: #00ff00;
+            padding: 6px 12px;
+            font-family: 'Courier New', monospace;
+            font-size: 11px;
+            cursor: pointer;
+            border-radius: 4px;
+            z-index: 3;
+            pointer-events: auto;
+            transition: all 0.3s;
+        }
+        #fullscreen-btn:hover {
+            background: rgba(0, 255, 0, 0.1);
+            box-shadow: 0 0 10px #00ff00;
+        }
+        /* Emergency Stop Button */
+        #emergency-btn {
+            position: absolute;
+            bottom: 20px;
+            left: 20px;
+            background: rgba(60, 0, 0, 0.8);
+            border: 1px solid #ff0000;
+            color: #ff0000;
+            padding: 10px 15px;
+            font-family: 'Courier New', monospace;
+            font-size: 12px;
+            cursor: pointer;
+            border-radius: 4px;
+            pointer-events: auto;
+            transition: all 0.3s;
+        }
+        #emergency-btn:hover {
+            background: rgba(255, 0, 0, 0.1);
+            box-shadow: 0 0 15px #ff0000;
+        }
+        /* Progress Display */
+        #progress-display {
+            position: absolute;
+            top: 60px;
+            right: 20px;
+            width: 200px;
+            background: rgba(0, 30, 0, 0.95);
+            border: 2px solid #00ff00;
+            border-radius: 8px;
+            padding: 15px;
+            backdrop-filter: blur(5px);
+            pointer-events: auto;
+        }
+        .progress-item {
+            margin: 8px 0;
+        }
+        .progress-label {
+            display: flex;
+            justify-content: space-between;
+            font-size: 11px;
+            color: #00cc00;
+            margin-bottom: 3px;
+        }
+        .progress-bar {
+            width: 100%;
+            height: 6px;
+            background: rgba(0, 0, 0, 0.5);
+            border: 1px solid #00ff00;
+            border-radius: 3px;
+            overflow: hidden;
+        }
+        .progress-fill {
+            height: 100%;
+            background: linear-gradient(90deg, #00ff00, #00cc00);
+            width: 0%;
+            transition: width 0.5s ease;
+        }
+        /* Crystal Info */
+        .crystal-info {
+            font-size: 10px;
+            color: #00ff00;
+            text-align: center;
+            margin-top: 10px;
+            padding-top: 10px;
+            border-top: 1px solid rgba(0, 255, 0, 0.3);
+        }
+        /* Image Capture Panel */
+        #capture-panel {
+            position: absolute;
+            top: 280px;
+            left: 20px;
+            width: 200px;
+            background: rgba(0, 30, 0, 0.95);
+            border: 2px solid #00ff00;
+            border-radius: 8px;
+            padding: 15px;
+            backdrop-filter: blur(5px);
+            pointer-events: auto;
+        }
+        .capture-controls {
+            display: flex;
+            gap: 10px;
+            margin-top: 10px;
+        }
+        .capture-btn {
+            flex: 1;
+            background: rgba(0, 60, 0, 0.8);
+            border: 1px solid #00ff00;
+            color: #00ff00;
+            padding: 8px;
+            font-size: 11px;
+            cursor: pointer;
+            border-radius: 4px;
+            text-align: center;
+        }
+        .capture-btn:hover {
+            background: rgba(0, 255, 0, 0.1);
+            box-shadow: 0 0 10px #00ff00;
+        }
+        /* System Warning */
+        #system-warning {
+            position: fixed;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            background: rgba(0, 20, 0, 0.95);
+            border: 2px solid #ff0000;
+            padding: 30px;
+            color: #ff0000;
+            text-align: center;
+            display: none;
+            z-index: 100;
+            max-width: 400px;
+            border-radius: 8px;
+            backdrop-filter: blur(10px);
+            pointer-events: auto;
+        }
+        /* Notification */
+        #notification {
+            position: fixed;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            background: rgba(0, 30, 0, 0.95);
+            border: 2px solid #00ff00;
+            padding: 30px;
+            color: #00ff00;
+            text-align: center;
+            display: none;
+            z-index: 100;
+            max-width: 400px;
+            border-radius: 8px;
+            backdrop-filter: blur(10px);
+            pointer-events: auto;
+        }
+        /* Animations */
+        @keyframes pulse {
+            0%, 100% { opacity: 1; }
+            50% { opacity: 0.7; }
+        }
+        @keyframes glow {
+            0%, 100% { box-shadow: 0 0 10px #00ff00; }
+            50% { box-shadow: 0 0 20px #00ff00, 0 0 30px #00ff00; }
+        }
+        @keyframes float {
+            0%, 100% { transform: translateX(-50%) translateY(0px); }
+            50% { transform: translateX(-50%) translateY(-10px); }
+        }
+        .glow {
+            animation: glow 2s infinite;
+        }
+        .float {
+            animation: float 3s ease-in-out infinite;
+        }
+        /* Time Display */
+        #time-display {
+            position: absolute;
+            top: 120px;
+            left: 50%;
+            transform: translateX(-50%);
+            background: rgba(0, 30, 0, 0.9);
+            border: 2px solid #00ff00;
+            padding: 10px 20px;
+            border-radius: 8px;
+            min-width: 200px;
+            backdrop-filter: blur(5px);
+            pointer-events: auto;
+            text-align: center;
+        }
+        .time-scale-value {
+            font-size: 24px;
+            color: #00ff00;
+            font-weight: bold;
+            font-family: monospace;
+            margin: 5px 0;
+            text-shadow: 0 0 10px #00ff00;
+        }
+        .time-label {
+            color: #00cc00;
+            font-size: 10px;
+            letter-spacing: 1px;
+        }
+    </style>
+</head>
+<body>
+    <canvas id="threeCanvas"></canvas>
+    <div id="ui-overlay">
+        <!-- Minimal Header -->
+        <div id="minimal-header">
+            <div class="minimal-logo">TIMELINK // by webXOS</div>
+            <div class="minimal-stats">
+                <div class="stat-item">
+                    <div class="stat-label">CRYSTALS</div>
+                    <div class="stat-value" id="crystalCount">0</div>
+                </div>
+                <div class="stat-item">
+                    <div class="stat-label">IMAGES</div>
+                    <div class="stat-value" id="imageCount">0</div>
+                </div>
+                <div class="stat-item">
+                    <div class="stat-label">FPS</div>
+                    <div class="stat-value" id="fpsCounter">60</div>
+                </div>
+            </div>
+        </div>
+        <!-- Control Panel -->
+        <div id="control-panel">
+            <div class="control-title">CRYSTAL SHAPES</div>
+            <div class="shape-selector">
+                <button class="shape-btn active" onclick="selectShape('quantum_spiral')">🌀 QUANTUM SPIRAL</button>
+                <button class="shape-btn" onclick="selectShape('fractal_matrix')">⬢ FRACTAL MATRIX</button>
+                <button class="shape-btn" onclick="selectShape('neural_lattice')">⊞ NEURAL LATTICE</button>
+                <button class="shape-btn" onclick="selectShape('temporal_ring')">⭕ TEMPORAL RING</button>
+            </div>
+            <div class="time-control">
+                <div class="time-label">TIME SCALE</div>
+                <input type="range" id="timeScale" class="time-slider" min="0.1" max="5.0" value="1.0" step="0.1">
+                <div class="time-value" id="timeScaleValue">1.0x</div>
+            </div>
+        </div>
+        <!-- Capture Panel -->
+        <div id="capture-panel">
+            <div class="control-title">IMAGE CAPTURE</div>
+            <div class="progress-item">
+                <div class="progress-label">
+                    <span>CAPTURED</span>
+                    <span id="captureCount">0</span>
+                </div>
+                <div class="progress-bar">
+                    <div id="captureProgress" class="progress-fill"></div>
+                </div>
+            </div>
+            <div class="capture-controls">
+                <button class="capture-btn" onclick="captureImage()">📸 CAPTURE</button>
+                <button class="capture-btn" onclick="toggleAutoCapture()" id="autoCaptureBtn">⚙ AUTO: OFF</button>
+            </div>
+            <div class="crystal-info">
+                <div>Quality: HD (1280x720)</div>
+                <div>Format: PNG + JSON</div>
+            </div>
+        </div>
+        <!-- Progress Display -->
+        <div id="progress-display">
+            <div class="control-title">GENERATION PROGRESS</div>
+            <div class="progress-item">
+                <div class="progress-label">
+                    <span>CURRENT CRYSTAL</span>
+                    <span id="crystalProgressText">0%</span>
+                </div>
+                <div class="progress-bar">
+                    <div id="crystalProgress" class="progress-fill"></div>
+                </div>
+            </div>
+            <div class="progress-item">
+                <div class="progress-label">
+                    <span>DATASET SIZE</span>
+                    <span id="datasetSize">0 MB</span>
+                </div>
+                <div class="progress-bar">
+                    <div id="datasetProgress" class="progress-fill"></div>
+                </div>
+            </div>
+            <div class="crystal-info">
+                <div id="currentCrystalInfo">READY TO START</div>
+                <div id="vertexCount">0 vertices / 0 edges</div>
+            </div>
+        </div>
+        <!-- Export Panel -->
+        <div id="export-panel">
+            <div class="control-title">DATASET EXPORT</div>
+            <button class="export-btn" onclick="exportCurrentCrystal()">
+                💾 EXPORT CURRENT
+            </button>
+            <button class="export-btn" onclick="exportCompleteDataset()">
+                📦 EXPORT COMPLETE
+            </button>
+            <button class="export-btn" onclick="exportHuggingFace()">
+                🤗 HUGGING FACE
+            </button>
+            <div class="crystal-info" style="margin-top: 10px;">
+                <div>Includes: Images + Data</div>
+                <div>Ready: <span id="exportReady">NO</span></div>
+            </div>
+        </div>
+        <!-- Central Generate Button -->
+        <button id="central-generate-btn" onclick="toggleAutomatedGeneration()" class="float">
+            ⚡ GENERATE CRYSTALS
+        </button>
+        <!-- Full Screen Button -->
+        <button id="fullscreen-btn" onclick="toggleFullscreen()">⛶ FULLSCREEN</button>
+        <!-- Emergency Stop -->
+        <button id="emergency-btn" onclick="emergencyStop()">🛑 EMERGENCY STOP</button>
+        <!-- Time Display -->
+        <div id="time-display">
+            <div class="time-label">AUTOMATED GENERATOR</div>
+            <div class="time-scale-value" id="timeDisplay">00:00:00</div>
+            <div class="time-label">TOTAL TIME: <span id="totalTime">0s</span></div>
+        </div>
+        <!-- System Warning -->
+        <div id="system-warning">
+            <h3>⚠️ SYSTEM LIMIT REACHED</h3>
+            <p>Memory usage approaching browser limits.</p>
+            <p>Auto-exporting current dataset...</p>
+            <div style="margin-top: 20px;">
+                <button onclick="continueGeneration()" style="background: rgba(0,60,0,0.8); border: 1px solid #00ff00; color: #00ff00; padding: 10px 20px; cursor: pointer; margin: 5px;">
+                    CONTINUE
+                </button>
+                <button onclick="emergencyStop()" style="background: rgba(60,0,0,0.8); border: 1px solid #ff0000; color: #ff0000; padding: 10px 20px; cursor: pointer; margin: 5px;">
+                    STOP
+                </button>
+            </div>
+        </div>
+        <!-- Notification -->
+        <div id="notification">
+            <h3 id="notificationTitle">EXPORTING</h3>
+            <p id="notificationMessage">Preparing dataset...</p>
+            <div class="progress-bar" style="margin: 20px auto; width: 80%;">
+                <div id="notificationProgress" class="progress-fill"></div>
+            </div>
+        </div>
+    </div>
+    <script>
+        // ==================== GLOBAL STATE ====================
+        let scene, camera, renderer, controls;
+        let currentCrystal = null;
+        let isGenerating = false;
+        let generationInterval = null;
+        let animationId = null;
+        let isFullscreen = false;
+        let autoCaptureEnabled = false;
+        // Crystal generation state
+        let generationState = {
+            active: false,
+            crystalCount: 0,
+            currentShape: 'quantum_spiral',
+            timeScale: 1.0,
+            startTime: 0,
+            totalGenerationTime: 0,
+            currentCrystal: {
+                vertices: [],
+                edges: [],
+                size: 0,
+                targetSize: 200,
+                currentStep: 0,
+                maxSteps: 300,
+                color: new THREE.Color(0x00ff00),
+                shape: 'quantum_spiral'
+            }
+        };
+        // Dataset collection
+        let dataset = {
+            crystals: [],
+            currentCrystalData: [],
+            capturedImages: [],
+            autoCaptureCount: 0,
+            manualCaptureCount: 0,
+            totalImages: 0,
+            isExporting: false,
+            lastExportTime: 0
+        };
+        // System monitoring
+        let systemMonitor = {
+            fps: 60,
+            memoryUsage: 0,
+            performanceLevel: 'high',
+            frameCount: 0,
+            lastFrameTime: performance.now(),
+            lastCleanup: 0,
+            warningShown: false
+        };
+        // Color palettes for each shape
+        const SHAPE_COLORS = {
+            quantum_spiral: [0x00ff00, 0x00cc00, 0x009900], // Greens
+            fractal_matrix: [0x00ffff, 0x00cccc, 0x009999], // Cyans
+            neural_lattice: [0xff00ff, 0xcc00cc, 0x990099], // Magentas
+            temporal_ring: [0xffff00, 0xcccc00, 0x999900]  // Yellows
+        };
+        // ==================== THREE.JS INITIALIZATION ====================
+        function initThreeJS() {
+            try {
+                const canvas = document.getElementById('threeCanvas');
+                // Scene
+                scene = new THREE.Scene();
+                scene.background = new THREE.Color(0x000000);
+                // Camera
+                const width = window.innerWidth;
+                const height = window.innerHeight;
+                camera = new THREE.PerspectiveCamera(75, width / height, 0.1, 5000);
+                camera.position.set(0, 150, 300);
+                // Renderer with better quality for image capture
+                renderer = new THREE.WebGLRenderer({
+                    canvas: canvas,
+                    antialias: true,
+                    alpha: true,
+                    preserveDrawingBuffer: true // Required for image capture
+                });
+                renderer.setSize(width, height);
+                renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+                // Controls
+                controls = new THREE.OrbitControls(camera, renderer.domElement);
+                controls.enableDamping = true;
+                controls.dampingFactor = 0.05;
+                controls.minDistance = 50;
+                controls.maxDistance = 1000;
+                // Enhanced lighting for better visuals
+                const ambientLight = new THREE.AmbientLight(0xffffff, 0.5);
+                scene.add(ambientLight);
+                const directionalLight1 = new THREE.DirectionalLight(0xffffff, 0.8);
+                directionalLight1.position.set(100, 200, 100);
+                scene.add(directionalLight1);
+                const directionalLight2 = new THREE.DirectionalLight(0xffffff, 0.4);
+                directionalLight2.position.set(-100, -200, -100);
+                scene.add(directionalLight2);
+                // Create enhanced background
+                createEnhancedBackground();
+                console.log("TIMELINK: Three.js initialized with enhanced visuals");
+                return true;
+            } catch (error) {
+                console.error("TIMELINK: Three.js error:", error);
+                showNotification("ERROR", "Graphics system initialization failed");
+                return false;
+            }
+        }
+        function createEnhancedBackground() {
+            // Create multiple layers of particles for depth
+            createParticleLayer(5000, 500, 1000, 0x00ff00, 0.3); // Near layer
+            createParticleLayer(3000, 1000, 2000, 0x00ffff, 0.2); // Middle layer
+            createParticleLayer(2000, 2000, 4000, 0xff00ff, 0.1); // Far layer
+            // Add central glow effect
+            const glowGeometry = new THREE.SphereGeometry(10, 32, 32);
+            const glowMaterial = new THREE.MeshBasicMaterial({
+                color: 0x00ff00,
+                transparent: true,
+                opacity: 0.2,
+                wireframe: true
+            });
+            const centralGlow = new THREE.Mesh(glowGeometry, glowMaterial);
+            scene.add(centralGlow);
+        }
+        function createParticleLayer(count, minRadius, maxRadius, baseColor, opacity) {
+            const geometry = new THREE.BufferGeometry();
+            const positions = new Float32Array(count * 3);
+            const colors = new Float32Array(count * 3);
+            const sizes = new Float32Array(count);
+            const color = new THREE.Color(baseColor);
+            for (let i = 0; i < count * 3; i += 3) {
+                const radius = minRadius + Math.random() * (maxRadius - minRadius);
+                const theta = Math.random() * Math.PI * 2;
+                const phi = Math.acos(2 * Math.random() - 1);
+                positions[i] = radius * Math.sin(phi) * Math.cos(theta);
+                positions[i + 1] = radius * Math.sin(phi) * Math.sin(theta);
+                positions[i + 2] = radius * Math.cos(phi);
+                // Color variation
+                const colorVariation = Math.random() * 0.3;
+                colors[i] = color.r + colorVariation;
+                colors[i + 1] = color.g + colorVariation;
+                colors[i + 2] = color.b + colorVariation;
+                sizes[i/3] = 0.5 + Math.random() * 2;
+            }
+            geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+            geometry.setAttribute('color', new THREE.BufferAttribute(colors, 3));
+            geometry.setAttribute('size', new THREE.BufferAttribute(sizes, 1));
+            const material = new THREE.PointsMaterial({
+                size: 1.5,
+                vertexColors: true,
+                transparent: true,
+                opacity: opacity,
+                sizeAttenuation: true
+            });
+            const particles = new THREE.Points(geometry, material);
+            scene.add(particles);
+            // Store for animation
+            if (!window.particleLayers) window.particleLayers = [];
+            window.particleLayers.push(particles);
+        }
+        // ==================== CENTRAL GENERATE BUTTON ====================
+        function toggleAutomatedGeneration() {
+            if (generationState.active) {
+                pauseGeneration();
+            } else {
+                startGeneration();
+            }
+        }
+        function selectShape(shape) {
+            generationState.currentShape = shape;
+            updateShapeButtons();
+            if (generationState.active) {
+                showNotification("SHAPE CHANGED", `Next crystal will be ${formatShapeName(shape)}`);
+            } else {
+                showNotification("SHAPE SELECTED", `${formatShapeName(shape)} ready for generation`);
+            }
+        }
+        function formatShapeName(shape) {
+            return shape.split('_').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(' ');
+        }
+        // ==================== CRYSTAL GENERATION SYSTEM ====================
+        function startGeneration() {
+            if (generationState.active) return;
+            console.log("TIMELINK: Starting automated crystal generation...");
+            generationState.active = true;
+            generationState.startTime = Date.now();
+            generationState.crystalCount = 0;
+            // Update central generate button
+            const centralBtn = document.getElementById('central-generate-btn');
+            centralBtn.textContent = '⏸ STOP GENERATION';
+            centralBtn.classList.add('generating');
+            centralBtn.classList.remove('paused');
+            centralBtn.classList.remove('float'); // Remove floating animation when active
+            // Start first crystal
+            initializeCrystal();
+            // Start generation loop
+            generationInterval = setInterval(growCrystalStep, 50); // 20 FPS
+            // Start floating animation for button
+            centralBtn.style.animation = 'none';
+            setTimeout(() => {
+                centralBtn.style.animation = 'pulse 2s infinite';
+            }, 100);
+            showNotification("GENERATION STARTED", `Automated ${formatShapeName(generationState.currentShape)} crystal generation active`);
+        }
+        function pauseGeneration() {
+            if (!generationState.active) return;
+            console.log("TIMELINK: Pausing generation");
+            generationState.active = false;
+            clearInterval(generationInterval);
+            generationInterval = null;
+            // Update central generate button
+            const centralBtn = document.getElementById('central-generate-btn');
+            centralBtn.textContent = '▶ RESUME GENERATION';
+            centralBtn.classList.remove('generating');
+            centralBtn.classList.add('paused');
+            centralBtn.classList.add('float'); // Add floating animation when paused
+            // Restore floating animation
+            centralBtn.style.animation = 'float 3s ease-in-out infinite';
+            showNotification("GENERATION PAUSED", "Click RESUME to continue automated generation");
+        }
+        function initializeCrystal() {
+            // Clean up previous crystal
+            if (currentCrystal) {
+                scene.remove(currentCrystal);
+                currentCrystal = null;
+            }
+            // Reset crystal data
+            generationState.currentCrystal = {
+                vertices: [],
+                edges: [],
+                size: 0,
+                targetSize: 200,
+                currentStep: 0,
+                maxSteps: 300,
+                color: new THREE.Color(SHAPE_COLORS[generationState.currentShape][0]),
+                shape: generationState.currentShape
+            };
+            dataset.currentCrystalData = [];
+            // Create initial vertex at center
+            generationState.currentCrystal.vertices.push({
+                x: 0, y: 0, z: 0,
+                connections: [],
+                generation: 0,
+                energy: 1.0,
+                color: generationState.currentCrystal.color.getHex(),
+                shape: generationState.currentShape,
+                temporalPhase: null  // Initialize all vertices with temporalPhase
+            });
+            // Set color based on shape
+            const colors = SHAPE_COLORS[generationState.currentShape];
+            generationState.currentCrystal.color = new THREE.Color(colors[Math.floor(Math.random() * colors.length)]);
+            updateCrystalInfo();
+            updateCrystalProgress(0);
+            console.log(`TIMELINK: Initialized ${generationState.currentShape} crystal`);
+        }
+        function growCrystalStep() {
+            if (!generationState.active) return;
+            const crystal = generationState.currentCrystal;
+            // Check if crystal is complete
+            if (crystal.currentStep >= crystal.maxSteps || crystal.vertices.length >= crystal.targetSize) {
+                completeCurrentCrystal();
+                startNewCrystal();
+                return;
+            }
+            crystal.currentStep++;
+            crystal.size = (crystal.currentStep / crystal.maxSteps) * crystal.targetSize;
+            // Grow based on selected shape
+            switch(crystal.shape) {
+                case 'quantum_spiral':
+                    growQuantumSpiral();
+                    break;
+                case 'fractal_matrix':
+                    growFractalMatrix();
+                    break;
+                case 'neural_lattice':
+                    growNeuralLattice();
+                    break;
+                case 'temporal_ring':
+                    growTemporalRing();
+                    break;
+            }
+            // Update visualization
+            updateCrystalVisualization();
+            // Auto-capture images
+            if (autoCaptureEnabled && crystal.currentStep % 10 === 0) {
+                captureImage();
+            }
+            // Update UI
+            updateUI();
+        }
+        // ==================== SHAPE ALGORITHMS ====================
+        function growQuantumSpiral() {
+            const crystal = generationState.currentCrystal;
+            const time = generationState.totalGenerationTime;
+            const layers = Math.max(3, Math.floor(crystal.size / 20));
+            const currentLayer = Math.floor(crystal.vertices.length / 4);
+            for (let i = 0; i < 3 && crystal.vertices.length < crystal.targetSize; i++) {
+                // Calculate spiral position with time-based animation
+                const timeWarp = Math.sin(time * 0.5 + i * 0.5) * 0.3;
+                const radius = 15 + (currentLayer * 4) + timeWarp * 8;
+                const height = currentLayer * 12;
+                const angle = (currentLayer / layers) * Math.PI * 6 + (i / 3) * Math.PI * 2;
+                const x = Math.cos(angle + time * 0.2) * radius;
+                const y = height + Math.sin(time * 0.3 + i) * 4;
+                const z = Math.sin(angle + time * 0.2) * radius;
+                // Find nearest vertex for connection
+                let nearestIndex = 0;
+                let minDistance = Infinity;
+                for (let j = 0; j < crystal.vertices.length; j++) {
+                    const v = crystal.vertices[j];
+                    const dx = x - v.x;
+                    const dy = y - v.y;
+                    const dz = z - v.z;
+                    const distance = Math.sqrt(dx*dx + dy*dy + dz*dz);
+                    if (distance < minDistance && distance < 30) {
+                        minDistance = distance;
+                        nearestIndex = j;
+                    }
+                }
+                // Create new vertex
+                const newVertex = {
+                    x: x,
+                    y: y,
+                    z: z,
+                    connections: [nearestIndex],
+                    generation: currentLayer,
+                    energy: 0.7 + Math.random() * 0.3,
+                    color: crystal.color.getHex(),
+                    shape: crystal.shape,
+                    temporalPhase: null  // Add temporalPhase for consistency
+                };
+                crystal.vertices.push(newVertex);
+                // Create reciprocal connection
+                if (nearestIndex < crystal.vertices.length) {
+                    crystal.vertices[nearestIndex].connections.push(crystal.vertices.length - 1);
+                    crystal.edges.push([nearestIndex, crystal.vertices.length - 1]);
+                }
+            }
+        }
+        function growFractalMatrix() {
+            const crystal = generationState.currentCrystal;
+            // Start with central connections
+            if (crystal.vertices.length === 1) {
+                // Create initial fractal arms
+                for (let i = 0; i < 6; i++) {
+                    const angle = (i / 6) * Math.PI * 2;
+                    const length = 20;
+                    crystal.vertices.push({
+                        x: Math.cos(angle) * length,
+                        y: Math.sin(angle) * length,
+                        z: 0,
+                        connections: [0],
+                        generation: 1,
+                        energy: 0.9,
+                        color: crystal.color.getHex(),
+                        shape: crystal.shape,
+                        temporalPhase: null  // Add temporalPhase for consistency
+                    });
+                    crystal.vertices[0].connections.push(crystal.vertices.length - 1);
+                    crystal.edges.push([0, crystal.vertices.length - 1]);
+                }
+            } else {
+                // Fractal branching from existing vertices
+                const verticesToBranch = [];
+                // Select vertices with few connections
+                for (let i = 0; i < crystal.vertices.length; i++) {
+                    const vertex = crystal.vertices[i];
+                    if (vertex.connections.length < 4 && vertex.generation < 5) {
+                        verticesToBranch.push(i);
+                    }
+                }
+                // Branch from selected vertices
+                verticesToBranch.forEach(vertexIndex => {
+                    const vertex = crystal.vertices[vertexIndex];
+                    const branches = 1 + Math.floor(Math.random() * 3);
+                    for (let b = 0; b < branches && crystal.vertices.length < crystal.targetSize; b++) {
+                        // Calculate branch direction
+                        const baseAngle = vertex.generation * Math.PI / 2;
+                        const branchAngle = baseAngle + (b / branches) * Math.PI * 2;
+                        const pitch = Math.random() * Math.PI;
+                        // Fractal scaling
+                        const scale = Math.pow(0.6, vertex.generation);
+                        const length = 12 + Math.random() * 10;
+                        const x = vertex.x + Math.sin(pitch) * Math.cos(branchAngle) * length * scale;
+                        const y = vertex.y + Math.cos(pitch) * length * scale;
+                        const z = vertex.z + Math.sin(pitch) * Math.sin(branchAngle) * length * scale;
+                        const newVertex = {
+                            x: x,
+                            y: y,
+                            z: z,
+                            connections: [vertexIndex],
+                            generation: vertex.generation + 1,
+                            energy: vertex.energy * (0.6 + Math.random() * 0.4),
+                            color: crystal.color.getHex(),
+                            shape: crystal.shape,
+                            temporalPhase: null  // Add temporalPhase for consistency
+                        };
+                        crystal.vertices.push(newVertex);
+                        vertex.connections.push(crystal.vertices.length - 1);
+                        crystal.edges.push([vertexIndex, crystal.vertices.length - 1]);
+                    }
+                });
+            }
+        }
+        function growNeuralLattice() {
+            const crystal = generationState.currentCrystal;
+            const time = generationState.totalGenerationTime;
+            if (crystal.vertices.length < 15) {
+                // Initial random points for neural network
+                for (let i = 0; i < 4 && crystal.vertices.length < crystal.targetSize; i++) {
+                    const radius = 25 + crystal.size;
+                    const theta = Math.random() * Math.PI * 2;
+                    const phi = Math.acos(2 * Math.random() - 1);
+                    const x = radius * Math.sin(phi) * Math.cos(theta);
+                    const y = radius * Math.sin(phi) * Math.sin(theta);
+                    const z = radius * Math.cos(phi);
+                    const newVertex = {
+                        x: x,
+                        y: y,
+                        z: z,
+                        connections: [],
+                        generation: Math.floor(crystal.vertices.length / 5),
+                        energy: 0.8 + Math.random() * 0.2,
+                        color: crystal.color.getHex(),
+                        shape: crystal.shape,
+                        temporalPhase: null  // Add temporalPhase for consistency
+                    };
+                    // Connect to 3 nearest neighbors
+                    const neighbors = [];
+                    for (let j = 0; j < crystal.vertices.length; j++) {
+                        const v = crystal.vertices[j];
+                        const dx = x - v.x;
+                        const dy = y - v.y;
+                        const dz = z - v.z;
+                        const distance = Math.sqrt(dx*dx + dy*dy + dz*dz);
+                        neighbors.push({index: j, distance: distance});
+                    }
+                    neighbors.sort((a, b) => a.distance - b.distance);
+                    const maxConnections = Math.min(3, neighbors.length);
+                    for (let n = 0; n < maxConnections; n++) {
+                        if (neighbors[n].distance < 40) {
+                            newVertex.connections.push(neighbors[n].index);
+                            crystal.vertices[neighbors[n].index].connections.push(crystal.vertices.length);
+                            crystal.edges.push([neighbors[n].index, crystal.vertices.length]);
+                        }
+                    }
+                    crystal.vertices.push(newVertex);
+                }
+            } else {
+                // Neural network style connections
+                // Add new connections between existing vertices
+                const newConnections = Math.min(8, Math.floor(crystal.vertices.length / 20));
+                for (let c = 0; c < newConnections; c++) {
+                    const i = Math.floor(Math.random() * crystal.vertices.length);
+                    const j = Math.floor(Math.random() * crystal.vertices.length);
+                    if (i !== j && !crystal.vertices[i].connections.includes(j)) {
+                        const v1 = crystal.vertices[i];
+                        const v2 = crystal.vertices[j];
+                        const dx = v1.x - v2.x;
+                        const dy = v1.y - v2.y;
+                        const dz = v1.z - v2.z;
+                        const distance = Math.sqrt(dx*dx + dy*dy + dz*dz);
+                        // Connection probability based on distance
+                        const connectionProbability = Math.exp(-distance / 30) * (0.5 + 0.5 * Math.sin(time * 0.5));
+                        if (distance < 50 && Math.random() < connectionProbability) {
+                            crystal.vertices[i].connections.push(j);
+                            crystal.vertices[j].connections.push(i);
+                            crystal.edges.push([i, j]);
+                        }
+                    }
+                }
+                // Add new neurons occasionally
+                if (Math.random() > 0.8 && crystal.vertices.length < crystal.targetSize) {
+                    const radius = 40 + crystal.size / 2;
+                    const theta = Math.random() * Math.PI * 2;
+                    const phi = Math.acos(2 * Math.random() - 1);
+                    const x = radius * Math.sin(phi) * Math.cos(theta);
+                    const y = radius * Math.sin(phi) * Math.sin(theta);
+                    const z = radius * Math.cos(phi);
+                    const newVertex = {
+                        x: x,
+                        y: y,
+                        z: z,
+                        connections: [],
+                        generation: Math.floor(crystal.vertices.length / 25),
+                        energy: 0.7 + Math.random() * 0.3,
+                        color: crystal.color.getHex(),
+                        shape: crystal.shape,
+                        temporalPhase: null  // Add temporalPhase for consistency
+                    };
+                    crystal.vertices.push(newVertex);
+                }
+            }
+        }
+        function growTemporalRing() {
+            const crystal = generationState.currentCrystal;
+            const time = generationState.totalGenerationTime;
+            const segments = Math.min(120, 30 + Math.floor(crystal.size / 2));
+            const currentSegment = crystal.vertices.length;
+            if (currentSegment >= segments) return;
+            const radius = 30 + crystal.size / 3;
+            const angle = (currentSegment / segments) * Math.PI * 2;
+            // Time-based distortion effects
+            const timeDistortion = Math.sin(time * 0.5 + currentSegment * 0.1) * 0.5;
+            const phaseShift = time * 0.3;
+            const verticalWave = Math.sin(angle * 3 + time * 0.4) * 10;
+            const x = Math.cos(angle + phaseShift) * radius * (1 + timeDistortion * 0.2);
+            const z = Math.sin(angle + phaseShift) * radius * (1 + timeDistortion * 0.2);
+            const y = verticalWave;
+            const newVertex = {
+                x: x,
+                y: y,
+                z: z,
+                connections: [],
+                generation: currentSegment,
+                energy: 0.8 + Math.abs(Math.sin(angle)) * 0.2,
+                color: crystal.color.getHex(),
+                shape: crystal.shape,
+                temporalPhase: angle
+            };
+            // Connect to previous vertex
+            if (currentSegment > 0) {
+                newVertex.connections.push(currentSegment - 1);
+                crystal.vertices[currentSegment - 1].connections.push(currentSegment);
+                crystal.edges.push([currentSegment - 1, currentSegment]);
+            }
+            // Connect to opposite side
+            if (currentSegment > segments / 4 && currentSegment % (segments/8) === 0) {
+                const oppositeIndex = Math.floor((currentSegment + segments/2) % segments);
+                if (oppositeIndex < crystal.vertices.length) {
+                    newVertex.connections.push(oppositeIndex);
+                    crystal.vertices[oppositeIndex].connections.push(currentSegment);
+                    crystal.edges.push([oppositeIndex, currentSegment]);
+                }
+            }
+            // Connect to center
+            if (currentSegment % (segments/12) === 0) {
+                newVertex.connections.push(0);
+                crystal.vertices[0].connections.push(currentSegment);
+                crystal.edges.push([0, currentSegment]);
+            }
+            crystal.vertices.push(newVertex);
+        }
+        function updateCrystalVisualization() {
+            const crystal = generationState.currentCrystal;
+            if (crystal.vertices.length === 0) return;
+            // Create or update crystal geometry
+            if (!currentCrystal) {
+                const geometry = new THREE.BufferGeometry();
+                const material = new THREE.LineBasicMaterial({
+                    color: crystal.color,
+                    linewidth: 2,
+                    transparent: true,
+                    opacity: 0.9
+                });
+                currentCrystal = new THREE.LineSegments(geometry, material);
+                scene.add(currentCrystal);
+                // Add vertex points for better visualization
+                const pointGeometry = new THREE.BufferGeometry();
+                const pointMaterial = new THREE.PointsMaterial({
+                    color: crystal.color,
+                    size: 3,
+                    transparent: true,
+                    opacity: 0.7
+                });
+                currentCrystal.points = new THREE.Points(pointGeometry, pointMaterial);
+                scene.add(currentCrystal.points);
+            }
+            // Update line geometry
+            const positions = new Float32Array(crystal.vertices.length * 3);
+            const indices = [];
+            for (let i = 0; i < crystal.vertices.length; i++) {
+                const v = crystal.vertices[i];
+                positions[i * 3] = v.x;
+                positions[i * 3 + 1] = v.y;
+                positions[i * 3 + 2] = v.z;
+            }
+            for (const [a, b] of crystal.edges) {
+                indices.push(a, b);
+            }
+            // Update line geometry
+            currentCrystal.geometry.dispose();
+            currentCrystal.geometry = new THREE.BufferGeometry();
+            currentCrystal.geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+            currentCrystal.geometry.setIndex(indices);
+            // Update point geometry
+            currentCrystal.points.geometry.dispose();
+            currentCrystal.points.geometry = new THREE.BufferGeometry();
+            currentCrystal.points.geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+            // Update material with time-based effects
+            const pulse = 0.8 + 0.2 * Math.sin(generationState.totalGenerationTime * 2);
+            currentCrystal.material.opacity = pulse * 0.9;
+            currentCrystal.material.color = crystal.color;
+            currentCrystal.points.material.color = crystal.color;
+            currentCrystal.points.material.opacity = pulse * 0.7;
+            // Add subtle rotation
+            currentCrystal.rotation.y += 0.001 * generationState.timeScale;
+            currentCrystal.points.rotation.y = currentCrystal.rotation.y;
+        }
+        function completeCurrentCrystal() {
+            const crystal = generationState.currentCrystal;
+            // Final image capture
+            captureImage();
+            // Normalize vertex data for consistency (ensure all vertices have temporalPhase)
+            const normalizedVertices = crystal.vertices.map(v => ({
+                ...v,
+                temporalPhase: v.temporalPhase !== undefined ? v.temporalPhase : null
+            }));
+            // Store crystal data
+            const crystalData = {
+                id: generationState.crystalCount,
+                shape: crystal.shape,
+                vertices: crystal.vertices.length,
+                edges: crystal.edges.length,
+                size: crystal.size,
+                generationSteps: crystal.currentStep,
+                generationTime: crystal.currentStep * 0.05,
+                color: crystal.color.getHex(),
+                vertexData: normalizedVertices,
+                edgeData: crystal.edges,
+                images: dataset.capturedImages.filter(img => img.metadata.crystalId === generationState.crystalCount)
+            };
+            dataset.crystals.push(crystalData);
+            generationState.crystalCount++;
+            console.log(`TIMELINK: Completed crystal #${generationState.crystalCount} with ${crystal.vertices.length} vertices`);
+        }
+        function startNewCrystal() {
+            if (!generationState.active) return;
+            // Reset for new crystal
+            initializeCrystal();
+        }
+        // ==================== IMAGE CAPTURE SYSTEM ====================
+        function captureImage() {
+            try {
+                const canvas = document.getElementById('threeCanvas');
+                // Ensure canvas is ready
+                if (!canvas || canvas.width === 0) {
+                    console.warn("Canvas not ready for capture");
+                    return;
+                }
+                // Capture at high quality
+                const imageData = canvas.toDataURL('image/png', 1.0);
+                // Create metadata for the image
+                const imageMetadata = {
+                    timestamp: Date.now(),
+                    crystalId: generationState.crystalCount,
+                    crystalShape: generationState.currentShape,
+                    step: generationState.currentCrystal.currentStep,
+                    vertices: generationState.currentCrystal.vertices.length,
+                    edges: generationState.currentCrystal.edges.length,
+                    size: generationState.currentCrystal.size,
+                    timeScale: generationState.timeScale,
+                    generationTime: generationState.totalGenerationTime
+                };
+                // Store image with metadata
+                dataset.capturedImages.push({
+                    data: imageData,
+                    metadata: imageMetadata,
+                    type: 'manual'
+                });
+                dataset.totalImages++;
+                dataset.manualCaptureCount++;
+                // Update UI
+                document.getElementById('imageCount').textContent = dataset.totalImages;
+                document.getElementById('captureCount').textContent = dataset.totalImages;
+                const captureProgress = Math.min((dataset.totalImages / 100) * 100, 100);
+                document.getElementById('captureProgress').style.width = captureProgress + '%';
+                // Flash effect for visual feedback
+                if (dataset.totalImages % 5 === 0) {
+                    showNotification("IMAGE CAPTURED", `Saved image #${dataset.totalImages} for dataset`);
+                }
+            } catch (error) {
+                console.error("TIMELINK: Image capture error:", error);
+            }
+        }
+        function toggleAutoCapture() {
+            autoCaptureEnabled = !autoCaptureEnabled;
+            const btn = document.getElementById('autoCaptureBtn');
+            if (autoCaptureEnabled) {
+                btn.textContent = '⚙ AUTO: ON';
+                btn.classList.add('ready');
+                showNotification("AUTO CAPTURE", "Auto-capture enabled (every 10 steps)");
+            } else {
+                btn.textContent = '⚙ AUTO: OFF';
+                btn.classList.remove('ready');
+                showNotification("AUTO CAPTURE", "Auto-capture disabled");
+            }
+        }
+        // ==================== EXPORT FUNCTIONS ====================
+        async function exportCurrentCrystal() {
+            if (generationState.currentCrystal.vertices.length === 0) {
+                showNotification("ERROR", "No crystal data to export");
+                return;
+            }
+            showNotification("EXPORTING", "Exporting current crystal dataset...");
+            try {
+                const zip = new JSZip();
+                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                const crystalId = generationState.crystalCount;
+                const shapeName = formatShapeName(generationState.currentShape).toLowerCase().replace(' ', '_');
+                // Create metadata
+                const metadata = {
+                    crystal_id: crystalId,
+                    shape: generationState.currentShape,
+                    shape_name: formatShapeName(generationState.currentShape),
+                    vertices: generationState.currentCrystal.vertices.length,
+                    edges: generationState.currentCrystal.edges.length,
+                    generation_time: generationState.totalGenerationTime,
+                    export_time: new Date().toISOString(),
+                    time_scale: generationState.timeScale,
+                    images_captured: dataset.capturedImages.filter(img => img.metadata.crystalId === crystalId).length
+                };
+                zip.file("metadata.json", JSON.stringify(metadata, null, 2));
+                // Export crystal data
+                const crystalData = {
+                    vertices: generationState.currentCrystal.vertices,
+                    edges: generationState.currentCrystal.edges,
+                    parameters: {
+                        target_size: generationState.currentCrystal.targetSize,
+                        color: generationState.currentCrystal.color.getHex(),
+                        time_scale: generationState.timeScale
+                    }
+                };
+                zip.file("crystal_data.json", JSON.stringify(crystalData, null, 2));
+                // Export images
+                const imgFolder = zip.folder("images");
+                const crystalImages = dataset.capturedImages.filter(img => img.metadata.crystalId === crystalId);
+                crystalImages.forEach((image, index) => {
+                    const base64Data = image.data.replace(/^data:image\/png;base64,/, "");
+                    imgFolder.file(`step_${index.toString().padStart(4, '0')}.png`, base64Data, {base64: true});
+                });
+                // Create README
+                const readme = generateCrystalReadme(metadata, crystalImages.length);
+                zip.file("README.md", readme);
+                // Generate and download
+                const content = await zip.generateAsync({type: "blob"});
+                const filename = `timelink_${shapeName}_crystal_${timestamp}.zip`;
+                saveAs(content, filename);
+                showNotification("SUCCESS", `Exported ${shapeName} crystal dataset`);
+            } catch (error) {
+                console.error("TIMELINK: Export error:", error);
+                showNotification("ERROR", `Export failed: ${error.message}`);
+            }
+        }
+        async function exportCompleteDataset() {
+            if (dataset.crystals.length === 0 && generationState.currentCrystal.vertices.length === 0) {
+                showNotification("ERROR", "No dataset to export");
+                return;
+            }
+            showNotification("EXPORTING", "Preparing complete dataset package...");
+            try {
+                const zip = new JSZip();
+                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                // Create dataset structure with proper row-oriented format
+                const datasetRows = [];
+                dataset.crystals.forEach((crystal, index) => {
+                    // Normalize vertex data to ensure consistency
+                    const normalizedVertexData = crystal.vertexData.map(vertex => ({
+                        ...vertex,
+                        temporalPhase: vertex.temporalPhase !== undefined ? vertex.temporalPhase : null
+                    }));
+                    // Create a row for each crystal
+                    const row = {
+                        id: crystal.id,
+                        shape: crystal.shape,
+                        vertices: crystal.vertices,
+                        edges: crystal.edges,
+                        size: crystal.size,
+                        generationSteps: crystal.generationSteps,
+                        generationTime: parseFloat(crystal.generationTime),
+                        color: crystal.color,
+                        vertexData: normalizedVertexData,
+                        edgeData: crystal.edgeData,
+                        // Note: images are not included in JSON to avoid large files
+                        images_count: crystal.images ? crystal.images.length : 0
+                    };
+                    datasetRows.push(row);
+                    // Export images for this crystal
+                    const crystalFolder = zip.folder(`crystal_${crystal.id}_${crystal.shape}`);
+                    // Export crystal metadata
+                    crystalFolder.file("metadata.json", JSON.stringify({
+                        id: crystal.id,
+                        shape: crystal.shape,
+                        vertices: crystal.vertices,
+                        edges: crystal.edges,
+                        generationTime: parseFloat(crystal.generationTime),
+                        export_time: new Date().toISOString()
+                    }, null, 2));
+                    // Export images if available
+                    if (crystal.images && crystal.images.length > 0) {
+                        const imgFolder = crystalFolder.folder("images");
+                        crystal.images.forEach((image, imgIndex) => {
+                            const base64Data = image.data.replace(/^data:image\/png;base64,/, "");
+                            imgFolder.file(`step_${imgIndex.toString().padStart(4, '0')}.png`, base64Data, {base64: true});
+                        });
+                    }
+                });
+                // Comprehensive metadata
+                const metadata = {
+                    total_crystals: dataset.crystals.length,
+                    total_images: dataset.totalImages,
+                    total_generation_time: generationState.totalGenerationTime,
+                    start_time: new Date(generationState.startTime).toISOString(),
+                    export_time: new Date().toISOString(),
+                    shapes_generated: [...new Set(dataset.crystals.map(c => c.shape))],
+                    system_info: {
+                        memory_usage: `${systemMonitor.memoryUsage} MB`,
+                        performance_level: systemMonitor.performanceLevel
+                    },
+                    // Dataset structure information
+                    data_format: "row-oriented JSON (list of objects)",
+                    features: {
+                        id: "int64 - Crystal ID",
+                        shape: "string - Crystal shape type",
+                        vertices: "int64 - Number of vertices",
+                        edges: "int64 - Number of edges",
+                        size: "float64 - Crystal size metric",
+                        generationSteps: "int64 - Steps to generate",
+                        generationTime: "float64 - Time to generate (seconds)",
+                        color: "int64 - Hex color code",
+                        vertexData: "list of structs - Vertex information",
+                        edgeData: "list of lists - Edge connections",
+                        images_count: "int64 - Number of images captured"
+                    }
+                };
+                // Main dataset file - row-oriented JSON
+                zip.file("dataset.json", JSON.stringify(datasetRows, null, 2));
+                zip.file("dataset_metadata.json", JSON.stringify(metadata, null, 2));
+                // Export summary and README
+                const summary = generateDatasetSummary(metadata);
+                zip.file("summary.txt", summary);
+                const readme = generateCompleteReadme(metadata);
+                zip.file("README.md", readme);
+                // Generate and download
+                const content = await zip.generateAsync({type: "blob"});
+                const filename = `timelink_complete_dataset_${timestamp}.zip`;
+                saveAs(content, filename);
+                showNotification("SUCCESS", `Exported complete dataset (${metadata.total_crystals} crystals, ${metadata.total_images} images)`);
+            } catch (error) {
+                console.error("TIMELINK: Export error:", error);
+                showNotification("ERROR", `Export failed: ${error.message}`);
+            }
+        }
+        async function exportHuggingFace() {
+            if (dataset.crystals.length === 0) {
+                showNotification("ERROR", "No dataset to export for Hugging Face");
+                return;
+            }
+            showNotification("EXPORTING", "Preparing Hugging Face dataset...");
+            try {
+                const zip = new JSZip();
+                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                // Prepare the data in Hugging Face format: a list of crystal objects
+                const hfData = dataset.crystals.map(crystal => {
+                    // Normalize vertex data: ensure every vertex has temporalPhase (set to null if missing)
+                    const normalizedVertexData = crystal.vertexData.map(vertex => {
+                        // Ensure all vertices have the same fields
+                        const normalizedVertex = { ...vertex };
+                        // Ensure temporalPhase exists (null for non-temporal shapes)
+                        if (!('temporalPhase' in normalizedVertex)) {
+                            normalizedVertex.temporalPhase = null;
+                        }
+                        // Return standardized vertex structure
+                        return {
+                            x: parseFloat(normalizedVertex.x) || 0.0,
+                            y: parseFloat(normalizedVertex.y) || 0.0,
+                            z: parseFloat(normalizedVertex.z) || 0.0,
+                            connections: normalizedVertex.connections || [],
+                            generation: parseInt(normalizedVertex.generation) || 0,
+                            energy: parseFloat(normalizedVertex.energy) || 0.0,
+                            color: parseInt(normalizedVertex.color) || 0x00ff00,
+                            shape: normalizedVertex.shape || crystal.shape,
+                            temporalPhase: normalizedVertex.temporalPhase !== null ?
+                                          parseFloat(normalizedVertex.temporalPhase) : null
+                        };
+                    });
+                    // Normalize edgeData: ensure it's a list of [int, int]
+                    const normalizedEdgeData = crystal.edgeData.map(edge => {
+                        if (Array.isArray(edge) && edge.length === 2) {
+                            return [parseInt(edge[0]) || 0, parseInt(edge[1]) || 0];
+                        } else {
+                            return [0, 0];
+                        }
+                    });
+                    // Create standardized row for Hugging Face
+                    return {
+                        id: crystal.id,
+                        shape: crystal.shape,
+                        vertices: parseInt(crystal.vertices) || 0,
+                        edges: parseInt(crystal.edges) || 0,
+                        size: parseFloat(crystal.size) || 0.0,
+                        generationSteps: parseInt(crystal.generationSteps) || 0,
+                        generationTime: parseFloat(crystal.generationTime) || 0.0,
+                        color: parseInt(crystal.color) || 0x00ff00,
+                        vertexData: normalizedVertexData,
+                        edgeData: normalizedEdgeData
+                        // Note: we are not including base64 images in the JSON
+                    };
+                });
+                // Hugging Face specific metadata
+                const hfMetadata = {
+                    "description": `TIMELINK Time Crystal Dataset - ${dataset.crystals.length} crystals`,
+                    "citation": "@misc{timelink2025,\n  title={TIMELINK: Quantum Time Crystal Generation},\n  author={WebXOS Research},\n  year={2025},\n  note={Dataset of algorithmically generated time crystal structures}\n}",
+                    "license": "mit",
+                    "language": "en",
+                    "size_categories": ["n<1K", "1K<n<10K"],
+                    "task_categories": ["graph-generation", "image-generation"],
+                    "task_ids": ["graph-generation", "image-generation", "time-series-generation"],
+                    "pretty_name": "TIMELINK Time Crystal Dataset",
+                    "tags": ["quantum", "crystal", "graph", "3d", "generation", "time-series"],
+                    "dataset_info": {
+                        "features": {
+                            "id": {"dtype": "int64", "nullable": false},
+                            "shape": {"dtype": "string", "nullable": false},
+                            "vertices": {"dtype": "int64", "nullable": false},
+                            "edges": {"dtype": "int64", "nullable": false},
+                            "size": {"dtype": "float64", "nullable": false},
+                            "generationSteps": {"dtype": "int64", "nullable": false},
+                            "generationTime": {"dtype": "float64", "nullable": false},
+                            "color": {"dtype": "int64", "nullable": false},
+                            "vertexData": {
+                                "feature": {
+                                    "x": {"dtype": "float64", "nullable": false},
+                                    "y": {"dtype": "float64", "nullable": false},
+                                    "z": {"dtype": "float64", "nullable": false},
+                                    "connections": {"dtype": "int64", "list": true, "nullable": false},
+                                    "generation": {"dtype": "int64", "nullable": false},
+                                    "energy": {"dtype": "float64", "nullable": false},
+                                    "color": {"dtype": "int64", "nullable": false},
+                                    "shape": {"dtype": "string", "nullable": false},
+                                    "temporalPhase": {"dtype": "float64", "nullable": true}
+                                },
+                                "list": true,
+                                "nullable": false
+                            },
+                            "edgeData": {
+                                "feature": {
+                                    "dtype": "int64",
+                                    "list": true,
+                                    "nullable": false
+                                },
+                                "list": true,
+                                "nullable": false
+                            }
+                        },
+                        "splits": {
+                            "train": {
+                                "name": "train",
+                                "num_bytes": Math.round(systemMonitor.memoryUsage * 1024 * 1024),
+                                "num_examples": dataset.crystals.length
+                            }
+                        }
+                    }
+                };
+                zip.file("dataset_info.json", JSON.stringify(hfMetadata, null, 2));
+                zip.file("data.json", JSON.stringify(hfData, null, 2));
+                // Export images in organized folders (separate from JSON to avoid large files)
+                dataset.crystals.forEach((crystal, index) => {
+                    const crystalImages = dataset.capturedImages.filter(img => img.metadata.crystalId === crystal.id);
+                    if (crystalImages.length > 0) {
+                        const imgFolder = zip.folder(`images/crystal_${crystal.id}`);
+                        crystalImages.forEach((image, imgIndex) => {
+                            const base64Data = image.data.replace(/^data:image\/png;base64,/, "");
+                            imgFolder.file(`${crystal.shape}_${imgIndex}.png`, base64Data, {base64: true});
+                        });
+                    }
+                });
+                // Create dataset card for Hugging Face
+                const datasetCard = generateHuggingFaceDatasetCard(hfMetadata, dataset.crystals.length);
+                zip.file("README.md", datasetCard);
+                // Add dataset_infos.json for Hugging Face
+                const datasetInfos = {
+                    "default": hfMetadata
+                };
+                zip.file("dataset_infos.json", JSON.stringify(datasetInfos, null, 2));
+                // Generate and download
+                const content = await zip.generateAsync({type: "blob"});
+                const filename = `timelink_huggingface_dataset_${timestamp}.zip`;
+                saveAs(content, filename);
+                showNotification("SUCCESS", "Hugging Face dataset exported! Upload data.json and images folder to HF");
+            } catch (error) {
+                console.error("TIMELINK: Export error:", error);
+                showNotification("ERROR", `Export failed: ${error.message}`);
+            }
+        }
+        function generateCrystalReadme(metadata, imageCount) {
+            return `# TIMELINK Crystal Dataset
+## Crystal Information
+- **ID**: ${metadata.crystal_id}
+- **Shape**: ${metadata.shape_name}
+- **Vertices**: ${metadata.vertices}
+- **Edges**: ${metadata.edges}
+- **Generation Time**: ${metadata.generation_time.toFixed(2)} seconds
+- **Images Captured**: ${imageCount}
+- **Export Time**: ${metadata.export_time}
+## Contents
+- \`metadata.json\` - Crystal metadata
+- \`crystal_data.json\` - Complete crystal structure data
+- \`images/\` - Captured PNG images of growth steps
+- \`README.md\` - This file
+## Usage
+This dataset can be used for:
+1. Graph neural network training
+2. 3D structure analysis
+3. Time series generation studies
+4. Quantum crystal simulation
+## License
+MIT License - Free for academic and research use.
+`;
+        }
+        function generateCompleteReadme(metadata) {
+            return `# TIMELINK Complete Dataset
+## Dataset Overview
+Total Crystals: ${metadata.total_crystals}
+Total Images: ${metadata.total_images}
+Generation Time: ${metadata.total_generation_time.toFixed(2)} seconds
+Shapes Generated: ${metadata.shapes_generated.join(', ')}
+## File Structure
+\`\`\`
+dataset.zip/
+├── dataset.json              # Main dataset file (row-oriented)
+├── dataset_metadata.json     # Complete dataset metadata
+├── summary.txt              # Statistical summary
+├── README.md                # This file
+└── crystal_*/               # Individual crystal folders
+    ├── images/              # Crystal growth images
+    └── metadata.json        # Crystal-specific metadata
+\`\`\`
+## Data Format
+Each crystal in dataset.json includes:
+- 3D vertex positions (x, y, z)
+- Edge connections between vertices
+- Growth time series data
+- Comprehensive metadata
+Note: Images are stored separately in crystal folders to avoid large JSON files.
+## Applications
+- Machine learning training data
+- 3D graph generation research
+- Quantum system simulation
+- Time series analysis
+- Computer graphics research
+## Citation
+@misc{timelink2025,
+  title={TIMELINK: Hybrid Time Scaling Crystal Generator},
+  author={WebXOS Research},
+  year={2025},
+  note={Complete time crystal growth dataset}
+}
+## License
+MIT License
+`;
+        }
+        function generateHuggingFaceDatasetCard(metadata, crystalCount) {
+            return `# TIMELINK Time Crystal Dataset
+## Dataset Description
+This dataset contains ${crystalCount} algorithmically generated time crystal structures with corresponding growth images.
+### Dataset Summary
+Time crystals are quantum systems that exhibit periodic motion in their ground state. This dataset captures complete growth trajectories of algorithmically generated time crystals.
+### Supported Tasks
+- Graph generation and completion
+- Image generation from 3D structures
+- Time series forecasting
+- 3D structure prediction
+### Languages
+English
+## Dataset Structure
+### Data Instances
+Each instance represents a complete time crystal with:
+- 3D vertex positions in vertexData
+- Edge connections in edgeData
+- Growth images in the images folder
+- Metadata including generation parameters
+### Data Fields
+- \`id\`: Unique crystal identifier
+- \`shape\`: Crystal shape type (quantum_spiral, fractal_matrix, neural_lattice, temporal_ring)
+- \`vertices\`: Number of vertices
+- \`edges\`: Number of edges
+- \`size\`: Crystal size metric
+- \`generationSteps\`: Steps taken to generate the crystal
+- \`generationTime\`: Time taken to generate (seconds)
+- \`color\`: Hex color code
+- \`vertexData\`: List of vertex objects with x, y, z coordinates and properties
+- \`edgeData\`: List of edge connections between vertices
+## Usage
+\`\`\`python
+from datasets import load_dataset
+# Load the dataset
+dataset = load_dataset("json", data_files="data.json")
+# Access the first crystal
+first_crystal = dataset['train'][0]
+print(f"Crystal ID: {first_crystal['id']}")
+print(f"Shape: {first_crystal['shape']}")
+print(f"Vertices: {first_crystal['vertices']}")
+\`\`\`
+## Citation
+${metadata.citation}
+## License
+${metadata.license.toUpperCase()} License
+## Dataset Creation
+This dataset was generated using TIMELINK v1.0 - Central Control Crystal Generator.
+`;
+        }
+        function generateDatasetSummary(metadata) {
+            return `TIMELINK DATASET SUMMARY
+============================
+Total Crystals: ${metadata.total_crystals}
+Total Images: ${metadata.total_images}
+Total Generation Time: ${metadata.total_generation_time.toFixed(2)} seconds
+Shapes Generated: ${metadata.shapes_generated.join(', ')}
+Export Time: ${metadata.export_time}
+Memory Usage: ${metadata.system_info.memory_usage}
+Performance Level: ${metadata.system_info.performance_level}
+`;
+        }
+        // ==================== UI FUNCTIONS ====================
+        function updateUI() {
+            // Update crystal count
+            document.getElementById('crystalCount').textContent = generationState.crystalCount;
+            // Update crystal info
+            updateCrystalInfo();
+            // Update progress
+            const crystalProgress = (generationState.currentCrystal.currentStep / generationState.currentCrystal.maxSteps) * 100;
+            updateCrystalProgress(crystalProgress);
+            // Update time display
+            updateTimeDisplay();
+            // Update dataset size
+            updateDatasetSize();
+        }
+        function updateCrystalInfo() {
+            const crystal = generationState.currentCrystal;
+            document.getElementById('currentCrystalInfo').textContent =
+                `${formatShapeName(crystal.shape)} #${generationState.crystalCount + 1}`;
+            document.getElementById('vertexCount').textContent =
+                `${crystal.vertices.length} vertices / ${crystal.edges.length} edges`;
+        }
+        function updateCrystalProgress(percent) {
+            document.getElementById('crystalProgress').style.width = percent + '%';
+            document.getElementById('crystalProgressText').textContent = Math.round(percent) + '%';
+        }
+        function updateTimeDisplay() {
+            generationState.totalGenerationTime = (Date.now() - generationState.startTime) / 1000;
+            const totalSeconds = Math.floor(generationState.totalGenerationTime);
+            const hours = Math.floor(totalSeconds / 3600);
+            const minutes = Math.floor((totalSeconds % 3600) / 60);
+            const seconds = totalSeconds % 60;
+            const timeString = `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+            document.getElementById('timeDisplay').textContent = timeString;
+            document.getElementById('totalTime').textContent = totalSeconds + 's';
+        }
+        function updateDatasetSize() {
+            // Estimate dataset size
+            const dataSize = JSON.stringify(dataset.crystals).length / (1024 * 1024);
+            const imageSize = dataset.totalImages * 0.5; // ~0.5MB per image
+            systemMonitor.memoryUsage = Math.round(dataSize + imageSize);
+            document.getElementById('datasetSize').textContent = `${systemMonitor.memoryUsage} MB`;
+            const datasetProgress = Math.min((systemMonitor.memoryUsage / 500) * 100, 100);
+            document.getElementById('datasetProgress').style.width = datasetProgress + '%';
+            // Update export ready status
+            document.getElementById('exportReady').textContent =
+                dataset.crystals.length > 0 ? 'YES' : 'NO';
+        }
+        function updateShapeButtons() {
+            document.querySelectorAll('.shape-btn').forEach(btn => {
+                btn.classList.remove('active');
+                if (btn.textContent.includes(formatShapeName(generationState.currentShape).toUpperCase())) {
+                    btn.classList.add('active');
+                }
+            });
+        }
+        function toggleFullscreen() {
+            const elem = document.documentElement;
+            if (!document.fullscreenElement) {
+                if (elem.requestFullscreen) elem.requestFullscreen();
+                else if (elem.webkitRequestFullscreen) elem.webkitRequestFullscreen();
+                else if (elem.msRequestFullscreen) elem.msRequestFullscreen();
+                document.getElementById('fullscreen-btn').textContent = '🗗 EXIT FULLSCREEN';
+                isFullscreen = true;
+            } else {
+                if (document.exitFullscreen) document.exitFullscreen();
+                else if (document.webkitExitFullscreen) document.webkitExitFullscreen();
+                else if (document.msExitFullscreen) document.msExitFullscreen();
+                document.getElementById('fullscreen-btn').textContent = '⛶ FULLSCREEN';
+                isFullscreen = false;
+            }
+        }
+        function emergencyStop() {
+            console.log("TIMELINK: Emergency stop activated");
+            generationState.active = false;
+            if (generationInterval) {
+                clearInterval(generationInterval);
+                generationInterval = null;
+            }
+            const centralBtn = document.getElementById('central-generate-btn');
+            centralBtn.textContent = '⚡ GENERATE CRYSTALS';
+            centralBtn.classList.remove('generating', 'paused');
+            centralBtn.classList.add('float');
+            centralBtn.style.animation = 'float 3s ease-in-out infinite';
+            if (generationState.currentCrystal.vertices.length > 0) {
+                exportCompleteDataset();
+            }
+            showNotification("EMERGENCY STOP", "Generation stopped. Dataset exported.");
+        }
+        function continueGeneration() {
+            hideSystemWarning();
+            systemMonitor.warningShown = false;
+        }
+        function showSystemWarning() {
+            document.getElementById('system-warning').style.display = 'block';
+        }
+        function hideSystemWarning() {
+            document.getElementById('system-warning').style.display = 'none';
+        }
+        function showNotification(title, message) {
+            const notification = document.getElementById('notification');
+            document.getElementById('notificationTitle').textContent = title;
+            document.getElementById('notificationMessage').textContent = message;
+            notification.style.display = 'block';
+            setTimeout(() => {
+                notification.style.display = 'none';
+            }, 3000);
+        }
+        // ==================== ANIMATION LOOP ====================
+        function animate(currentTime) {
+            animationId = requestAnimationFrame(animate);
+            // Calculate FPS
+            if (!systemMonitor.lastFrameTime) {
+                systemMonitor.lastFrameTime = currentTime;
+                systemMonitor.frameCount = 0;
+            }
+            systemMonitor.frameCount++;
+            const deltaTime = currentTime - systemMonitor.lastFrameTime;
+            if (deltaTime >= 1000) {
+                systemMonitor.fps = Math.round((systemMonitor.frameCount * 1000) / deltaTime);
+                document.getElementById('fpsCounter').textContent = systemMonitor.fps;
+                systemMonitor.frameCount = 0;
+                systemMonitor.lastFrameTime = currentTime;
+            }
+            // Animate background particles
+            if (window.particleLayers) {
+                window.particleLayers.forEach((particles, index) => {
+                    const positions = particles.geometry.attributes.position.array;
+                    for (let i = 0; i < positions.length; i += 3) {
+                        const speed = 0.05 * (index + 1);
+                        positions[i] += (Math.random() - 0.5) * speed;
+                        positions[i + 1] += (Math.random() - 0.5) * speed;
+                        positions[i + 2] += (Math.random() - 0.5) * speed;
+                    }
+                    particles.geometry.attributes.position.needsUpdate = true;
+                });
+            }
+            // Animate crystal rotation
+            if (currentCrystal && generationState.active) {
+                currentCrystal.rotation.y += 0.002 * generationState.timeScale;
+                if (currentCrystal.points) {
+                    currentCrystal.points.rotation.y = currentCrystal.rotation.y;
+                }
+            }
+            // Update controls
+            if (controls) {
+                controls.update();
+            }
+            // Render
+            if (renderer && scene && camera) {
+                renderer.render(scene, camera);
+            }
+        }
+        // ==================== INITIALIZATION ====================
+        function init() {
+            console.log("TIMELINK v1.0 - Central Control Generator - Initializing...");
+            if (initThreeJS()) {
+                // Setup event listeners
+                document.getElementById('timeScale').addEventListener('input', function() {
+                    generationState.timeScale = parseFloat(this.value);
+                    document.getElementById('timeScaleValue').textContent = this.value + 'x';
+                });
+                document.addEventListener('fullscreenchange', updateFullscreenButton);
+                document.addEventListener('webkitfullscreenchange', updateFullscreenButton);
+                document.addEventListener('msfullscreenchange', updateFullscreenButton);
+                window.addEventListener('resize', onWindowResize);
+                // Start animation loop
+                animate(0);
+                console.log("TIMELINK: System ready with central generate button");
+                showNotification("SYSTEM READY", "Click the central GENERATE CRYSTALS button to start");
+            }
+        }
+        function updateFullscreenButton() {
+            const btn = document.getElementById('fullscreen-btn');
+            if (document.fullscreenElement || document.webkitFullscreenElement || document.msFullscreenElement) {
+                btn.textContent = '🗗 EXIT FULLSCREEN';
+                isFullscreen = true;
+            } else {
+                btn.textContent = '⛶ FULLSCREEN';
+                isFullscreen = false;
+            }
+        }
+        function onWindowResize() {
+            if (camera && renderer) {
+                const width = window.innerWidth;
+                const height = window.innerHeight;
+                camera.aspect = width / height;
+                camera.updateProjectionMatrix();
+                renderer.setSize(width, height);
+            }
+        }
+        // Cleanup on page unload
+        window.addEventListener('beforeunload', (e) => {
+            if (generationState.active) {
+                e.preventDefault();
+                e.returnValue = 'Crystal generation in progress. Are you sure you want to leave?';
+                emergencyStop();
+            }
+        });
+        // Start when page loads
+        window.addEventListener('load', init);
+        // Global functions
+        window.toggleAutomatedGeneration = toggleAutomatedGeneration;
+        window.selectShape = selectShape;
+        window.captureImage = captureImage;
+        window.toggleAutoCapture = toggleAutoCapture;
+        window.exportCurrentCrystal = exportCurrentCrystal;
+        window.exportCompleteDataset = exportCompleteDataset;
+        window.exportHuggingFace = exportHuggingFace;
+        window.toggleFullscreen = toggleFullscreen;
+        window.emergencyStop = emergencyStop;
+        window.continueGeneration = continueGeneration;
+    </script>
+</body>
+</html>