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(dxdx + dydy + 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(dxdx + dydy + 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(dxdx + dydy + 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>