Upload source/main_rs_upload.rs with huggingface_hub

source/main_rs_upload.rs

@@ -0,0 +1,874 @@
+use dashmap::DashMap;
+use flate2::write::GzEncoder;
+use flate2::Compression;
+use md5::{Digest, Md5};
+use rand::seq::SliceRandom;
+use rand::Rng;
+use regex::Regex;
+use reqwest::Client;
+use scraper::{Html, Selector};
+use serde::Serialize;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::atomic::{AtomicI64, AtomicU64, Ordering};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tokio::sync::{Mutex, Semaphore};
+use url::Url;
+
+const NUM_WORKERS: usize = 500;
+const FETCH_TIMEOUT: Duration = Duration::from_secs(8);
+const MIN_TEXT_LEN: usize = 200;
+const MAX_TEXT_LEN: usize = 200_000;
+const MAX_URLS_PER_DOMAIN: u32 = 1000;
+const CHUNK_TARGET_BYTES: i64 = 1_200_000_000;
+const MAX_QUEUE_SIZE: usize = 5_000_000;
+const STATUS_INTERVAL: Duration = Duration::from_secs(30);
+const HF_TOKEN: &str = "YOUR_HF_TOKEN_HERE";
+const TARGET_REPO: &str = "OpenTransformer/web-crawl-2026";
+const OUTPUT_DIR: &str = "/workspace/scraped_data_rust";
+
+static USER_AGENTS: &[&str] = &[
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_4) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0",
+    "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:123.0) Gecko/20100101 Firefox/123.0",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0",
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+];
+
+static BLOCKED_EXTENSIONS: &[&str] = &[
+    ".pdf", ".jpg", ".jpeg", ".png", ".gif", ".svg", ".mp3", ".mp4", ".avi",
+    ".mov", ".zip", ".tar", ".gz", ".exe", ".dmg", ".css", ".js", ".woff",
+    ".woff2", ".ttf", ".ico", ".webp", ".bmp", ".doc", ".docx", ".xls",
+    ".xlsx", ".ppt", ".pptx", ".iso", ".rar", ".7z", ".apk", ".deb", ".rpm",
+];
+
+#[derive(Serialize)]
+struct Document {
+    text: String,
+    url: String,
+    domain: String,
+    timestamp: String,
+    source: String,
+}
+
+struct URLQueue {
+    queue: Mutex<Vec<String>>,
+}
+
+impl URLQueue {
+    fn new() -> Self {
+        Self {
+            queue: Mutex::new(Vec::with_capacity(100_000)),
+        }
+    }
+
+    async fn push(&self, url: String) -> bool {
+        let mut q = self.queue.lock().await;
+        if q.len() >= MAX_QUEUE_SIZE {
+            return false;
+        }
+        q.push(url);
+        true
+    }
+
+    async fn push_bulk(&self, urls: Vec<String>) -> usize {
+        let mut q = self.queue.lock().await;
+        let mut added = 0;
+        for url in urls {
+            if q.len() >= MAX_QUEUE_SIZE {
+                break;
+            }
+            q.push(url);
+            added += 1;
+        }
+        added
+    }
+
+    async fn pop_batch(&self, n: usize) -> Vec<String> {
+        let mut q = self.queue.lock().await;
+        let drain_count = n.min(q.len());
+        if drain_count == 0 {
+            return Vec::new();
+        }
+        let start = q.len() - drain_count;
+        q.drain(start..).collect()
+    }
+
+    async fn len(&self) -> usize {
+        self.queue.lock().await.len()
+    }
+
+    async fn shuffle(&self) {
+        let mut q = self.queue.lock().await;
+        let mut rng = rand::thread_rng();
+        q.shuffle(&mut rng);
+    }
+}
+
+fn is_valid_url(raw: &str) -> bool {
+    let u = match Url::parse(raw) {
+        Ok(u) => u,
+        Err(_) => return false,
+    };
+    match u.scheme() {
+        "http" | "https" => {}
+        _ => return false,
+    }
+    let host = match u.host_str() {
+        Some(h) => h,
+        None => return false,
+    };
+    if !host.contains('.') {
+        return false;
+    }
+    let path_lower = u.path().to_lowercase();
+    for ext in BLOCKED_EXTENSIONS {
+        if path_lower.ends_with(ext) {
+            return false;
+        }
+    }
+    let full_lower = raw.to_lowercase();
+    if BLOCKED_PATTERN.is_match(&full_lower) {
+        return false;
+    }
+    true
+}
+
+fn get_domain(raw: &str) -> String {
+    Url::parse(raw)
+        .ok()
+        .and_then(|u| u.host_str().map(|h| h.to_string()))
+        .unwrap_or_default()
+}
+
+fn content_hash(text: &str) -> String {
+    let mut end = text.len().min(500);
+    while end > 0 && !text.is_char_boundary(end) {
+        end -= 1;
+    }
+    let mut hasher = Md5::new();
+    hasher.update(text[..end].as_bytes());
+    format!("{:x}", hasher.finalize())
+}
+
+fn extract_text_from_html(html_str: &str) -> String {
+    let document = Html::parse_document(html_str);
+    let body_sel = Selector::parse("article, main, [role=main], body").unwrap();
+
+    let mut text_parts: Vec<String> = Vec::new();
+
+    // Try to find main content area first, fallback to whole document
+    let root = document.select(&body_sel).next();
+    if let Some(element) = root {
+        for text_node in element.text() {
+            let trimmed = text_node.trim();
+            if !trimmed.is_empty() {
+                text_parts.push(trimmed.to_string());
+            }
+        }
+    } else {
+        for text_node in document.root_element().text() {
+            let trimmed = text_node.trim();
+            if !trimmed.is_empty() {
+                text_parts.push(trimmed.to_string());
+            }
+        }
+    }
+
+    let mut result = text_parts.join(" ");
+
+    // Collapse whitespace
+    let ws_re = Regex::new(r"\s+").unwrap();
+    result = ws_re.replace_all(&result, " ").trim().to_string();
+
+    // Remove any remaining HTML entities
+    result = result
+        .replace("&amp;", "&")
+        .replace("&lt;", "<")
+        .replace("&gt;", ">")
+        .replace("&quot;", "\"")
+        .replace("&#39;", "'")
+        .replace("&nbsp;", " ");
+
+    result
+}
+
+fn extract_links(html_str: &str, base_url: &str) -> Vec<String> {
+    let base = match Url::parse(base_url) {
+        Ok(u) => u,
+        Err(_) => return Vec::new(),
+    };
+    let document = Html::parse_document(html_str);
+    let a_sel = Selector::parse("a[href]").unwrap();
+    let mut links = Vec::new();
+
+    for element in document.select(&a_sel) {
+        if let Some(href) = element.value().attr("href") {
+            let href = href.trim();
+            if href.starts_with('#') || href.starts_with("javascript:") || href.starts_with("mailto:") || href.starts_with("tel:") {
+                continue;
+            }
+            if let Ok(resolved) = base.join(href) {
+                let mut full = resolved.to_string();
+                // Strip fragment
+                if let Some(pos) = full.find('#') {
+                    full.truncate(pos);
+                }
+                if is_valid_url(&full) {
+                    links.push(full);
+                }
+            }
+        }
+    }
+    links
+}
+
+async fn fetch_page(client: &Client, url: &str) -> Result<(String, String), String> {
+    let ua = {
+        let mut rng = rand::thread_rng();
+        USER_AGENTS[rng.gen_range(0..USER_AGENTS.len())]
+    };
+
+    let resp = client
+        .get(url)
+        .header("User-Agent", ua)
+        .header("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
+        .header("Accept-Language", "en-US,en;q=0.9")
+        .header("Accept-Encoding", "gzip, deflate, br")
+        .send()
+        .await
+        .map_err(|e| e.to_string())?;
+
+    let status = resp.status();
+    if !status.is_success() {
+        return Err(format!("status {}", status));
+    }
+
+    let ct = resp
+        .headers()
+        .get("content-type")
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or("");
+    if !ct.contains("text/html") && !ct.contains("xhtml") {
+        return Err(format!("not html: {}", ct));
+    }
+
+    let final_url = resp.url().to_string();
+
+    // Limit body to 2MB
+    let body_bytes = resp.bytes().await.map_err(|e| e.to_string())?;
+    if body_bytes.len() > 2 * 1024 * 1024 {
+        let body = String::from_utf8_lossy(&body_bytes[..2 * 1024 * 1024]).to_string();
+        return Ok((body, final_url));
+    }
+    let body = String::from_utf8_lossy(&body_bytes).to_string();
+    Ok((body, final_url))
+}
+
+async fn download_commoncrawl_urls(queue: &URLQueue, target_count: usize) -> usize {
+    println!("[seed] Downloading Common Crawl URL index...");
+    let client = Client::builder()
+        .timeout(Duration::from_secs(60))
+        .build()
+        .unwrap();
+
+    let queries = vec![
+        "*.com/*", "*.org/*", "*.net/*", "*.edu/*", "*.gov/*",
+        "*.co.uk/*", "*.io/*", "*.info/*", "*.us/*", "*.ca/*",
+        "*.au/*", "*.de/*", "*.fr/*",
+    ];
+
+    let mut added = 0usize;
+    for q in queries {
+        if added >= target_count {
+            break;
+        }
+        let api_url = format!(
+            "https://index.commoncrawl.org/CC-MAIN-2024-10-index?url={}&output=json&limit=15000&fl=url&filter=languages:eng",
+            urlencoding::encode(q)
+        );
+        let resp = match client.get(&api_url).send().await {
+            Ok(r) => r,
+            Err(e) => {
+                println!("[seed] CC query failed for {}: {}", q, e);
+                continue;
+            }
+        };
+        let text = match resp.text().await {
+            Ok(t) => t,
+            Err(_) => continue,
+        };
+        let mut batch = Vec::with_capacity(10_000);
+        for line in text.lines() {
+            if let Ok(val) = serde_json::from_str::<serde_json::Value>(line) {
+                if let Some(url) = val.get("url").and_then(|u| u.as_str()) {
+                    if is_valid_url(url) {
+                        batch.push(url.to_string());
+                        if batch.len() >= 10_000 {
+                            added += queue.push_bulk(batch).await;
+                            batch = Vec::with_capacity(10_000);
+                        }
+                    }
+                }
+            }
+        }
+        if !batch.is_empty() {
+            added += queue.push_bulk(batch).await;
+        }
+        println!("[seed] CC {}: total queued so far: {}", q, queue.len().await);
+    }
+    added
+}
+
+async fn download_wikipedia_urls(queue: &URLQueue, count: usize) -> usize {
+    println!("[seed] Fetching {} Wikipedia URLs...", count);
+    let client = Client::builder()
+        .timeout(Duration::from_secs(30))
+        .build()
+        .unwrap();
+
+    let mut added = 0;
+    let mut failures = 0;
+    while added < count && failures < 5 {
+        let remaining = (count - added).min(500);
+        let url = format!(
+            "https://en.wikipedia.org/w/api.php?action=query&list=random&rnnamespace=0&rnlimit={}&format=json",
+            remaining
+        );
+        let resp = match client.get(&url).send().await {
+            Ok(r) => r,
+            Err(_) => {
+                failures += 1;
+                tokio::time::sleep(Duration::from_secs(2)).await;
+                continue;
+            }
+        };
+        let data: serde_json::Value = match resp.json().await {
+            Ok(d) => d,
+            Err(_) => {
+                failures += 1;
+                continue;
+            }
+        };
+        let random = match data["query"]["random"].as_array() {
+            Some(a) => a,
+            None => {
+                failures += 1;
+                continue;
+            }
+        };
+        let batch: Vec<String> = random
+            .iter()
+            .filter_map(|p| p["title"].as_str())
+            .map(|t| format!("https://en.wikipedia.org/wiki/{}", t.replace(' ', "_")))
+            .collect();
+        let n = queue.push_bulk(batch).await;
+        added += n;
+        if n == 0 {
+            failures += 1;
+        } else {
+            failures = 0;
+        }
+        println!("[seed] Wikipedia: {} URLs added (total {})", n, added);
+    }
+    added
+}
+
+async fn download_sitemap_urls(queue: &URLQueue) -> usize {
+    println!("[seed] Fetching sitemaps from major sites...");
+    let client = Client::builder()
+        .timeout(Duration::from_secs(15))
+        .build()
+        .unwrap();
+
+    let sitemaps = vec![
+        "https://www.reuters.com/arc/outboundfeeds/sitemap-index/?outputType=xml",
+        "https://www.bbc.com/sitemaps/https-sitemap-com-news-1.xml",
+        "https://www.theguardian.com/sitemaps/news.xml",
+        "https://www.npr.org/sitemap.xml",
+        "https://arstechnica.com/sitemap.xml",
+        "https://www.wired.com/sitemap.xml",
+        "https://www.theatlantic.com/sitemap.xml",
+        "https://www.nature.com/sitemap.xml",
+        "https://phys.org/sitemap.xml",
+        "https://www.scientificamerican.com/sitemap.xml",
+        "https://www.smithsonianmag.com/sitemap.xml",
+        "https://www.britannica.com/sitemap.xml",
+        "https://www.healthline.com/sitemap.xml",
+        "https://www.investopedia.com/sitemap.xml",
+        "https://www.geeksforgeeks.org/sitemap.xml",
+        "https://realpython.com/sitemap.xml",
+        "https://www.freecodecamp.org/news/sitemap.xml",
+        "https://hackernoon.com/sitemap.xml",
+        "https://dev.to/sitemap.xml",
+        "https://www.history.com/sitemap.xml",
+        "https://www.livescience.com/sitemap.xml",
+        "https://www.space.com/sitemap.xml",
+        "https://www.sciencedaily.com/sitemap.xml",
+        "https://www.psychologytoday.com/sitemap.xml",
+        "https://www.mayoclinic.org/sitemap.xml",
+        "https://medlineplus.gov/sitemap.xml",
+        "https://plato.stanford.edu/sitemap.xml",
+        "https://www.brookings.edu/sitemap.xml",
+        "https://www.rand.org/sitemap.xml",
+        "https://stackoverflow.com/sitemap.xml",
+        "https://docs.python.org/3/sitemap.xml",
+        "https://docs.rs/sitemap.xml",
+        "https://www.rust-lang.org/sitemap.xml",
+        "https://go.dev/sitemap.xml",
+    ];
+
+    let loc_re = Regex::new(r"<loc>([^<]+)</loc>").unwrap();
+    let mut added = 0;
+
+    for sitemap_url in sitemaps {
+        let resp = match client.get(sitemap_url).send().await {
+            Ok(r) => r,
+            Err(_) => continue,
+        };
+        let body = match resp.text().await {
+            Ok(t) => t,
+            Err(_) => continue,
+        };
+        let batch: Vec<String> = loc_re
+            .captures_iter(&body)
+            .filter_map(|c| {
+                let u = c[1].to_string();
+                if is_valid_url(&u) && !u.ends_with(".xml") && !u.ends_with(".xml.gz") {
+                    Some(u)
+                } else {
+                    None
+                }
+            })
+            .collect();
+        let n = queue.push_bulk(batch).await;
+        if n > 0 {
+            println!("[seed] Sitemap {}: +{} URLs", get_domain(sitemap_url), n);
+        }
+        added += n;
+    }
+    println!("[seed] Sitemaps total: {} URLs added", added);
+    added
+}
+
+async fn download_hn_urls(queue: &URLQueue) -> usize {
+    let client = Client::builder()
+        .timeout(Duration::from_secs(10))
+        .build()
+        .unwrap();
+
+    let mut urls = Vec::new();
+    for endpoint in &["topstories", "newstories", "beststories"] {
+        let api = format!("https://hacker-news.firebaseio.com/v0/{}.json", endpoint);
+        let resp = match client.get(&api).send().await {
+            Ok(r) => r,
+            Err(_) => continue,
+        };
+        let ids: Vec<u64> = match resp.json::<Vec<u64>>().await {
+            Ok(v) => v,
+            Err(_) => continue,
+        };
+        // Fetch items concurrently in batches
+        let sem = Arc::new(Semaphore::new(20));
+        let mut handles = Vec::new();
+        for &id in ids.iter().take(100) {
+            let client = client.clone();
+            let sem = sem.clone();
+            handles.push(tokio::spawn(async move {
+                let _permit = sem.acquire().await.ok()?;
+                let url = format!("https://hacker-news.firebaseio.com/v0/item/{}.json", id);
+                let resp = client.get(&url).send().await.ok()?;
+                let item: serde_json::Value = resp.json().await.ok()?;
+                item["url"].as_str().map(|s| s.to_string())
+            }));
+        }
+        for h in handles {
+            if let Ok(Some(url)) = h.await {
+                if !url.is_empty() {
+                    urls.push(url);
+                }
+            }
+        }
+    }
+    let n = queue.push_bulk(urls).await;
+    println!("[seed] HN: {} URLs added", n);
+    n
+}
+
+fn upload_chunk(filepath: &str, remote_name: &str) -> bool {
+    let script = format!(
+        r#"
+from huggingface_hub import HfApi
+api = HfApi(token="{}")
+api.upload_file(path_or_fileobj="{}", path_in_repo="data/{}", repo_id="{}", repo_type="dataset")
+print("OK")
+"#,
+        HF_TOKEN, filepath, remote_name, TARGET_REPO
+    );
+    let output = Command::new("python3").arg("-c").arg(&script).output();
+    match output {
+        Ok(o) => {
+            if o.status.success() {
+                println!("  Uploaded {}", remote_name);
+                true
+            } else {
+                println!(
+                    "  Upload failed: {}",
+                    String::from_utf8_lossy(&o.stderr)
+                );
+                false
+            }
+        }
+        Err(e) => {
+            println!("  Upload error: {}", e);
+            false
+        }
+    }
+}
+
+lazy_static::lazy_static! {
+    static ref BLOCKED_PATTERN: Regex = Regex::new(
+        r"(?i)(login|signup|signin|register|cart|checkout|payment|admin|wp-admin|facebook\.com|twitter\.com|instagram\.com|tiktok\.com|linkedin\.com|youtube\.com/watch|amazon\.|ebay\.|\.pdf$|/tag/|/category/|/page/\d+|/feed/|/rss|/atom|#comment|/reply|/share|mailto:|tel:)"
+    ).unwrap();
+}
+
+#[tokio::main(flavor = "multi_thread")]
+async fn main() {
+    println!("============================================================");
+    println!("Rust Web Crawler v1 — Async high-throughput crawler");
+    println!("Target: {}", TARGET_REPO);
+    println!(
+        "Workers: {}, Chunk target: ~{:.1}GB",
+        NUM_WORKERS,
+        CHUNK_TARGET_BYTES as f64 / 1e9
+    );
+    println!("============================================================");
+
+    std::fs::create_dir_all(OUTPUT_DIR).ok();
+
+    let client = Client::builder()
+        .timeout(FETCH_TIMEOUT)
+        .pool_max_idle_per_host(20)
+        .pool_idle_timeout(Duration::from_secs(30))
+        .redirect(reqwest::redirect::Policy::limited(5))
+        .danger_accept_invalid_certs(true)
+        .tcp_keepalive(Duration::from_secs(15))
+        .connect_timeout(Duration::from_secs(5))
+        .build()
+        .expect("Failed to build HTTP client");
+
+    let seen_hashes: Arc<DashMap<String, ()>> = Arc::new(DashMap::new());
+    let domain_counts: Arc<DashMap<String, u32>> = Arc::new(DashMap::new());
+
+    // Find next chunk number
+    let mut chunk_num: u32 = 0;
+    loop {
+        let name = format!("crawl_rust_chunk{:04}.jsonl.gz", chunk_num);
+        let path = Path::new(OUTPUT_DIR).join(&name);
+        if !path.exists() {
+            break;
+        }
+        chunk_num += 1;
+    }
+
+    // === PHASE 1: SEED LOADING ===
+    let queue = Arc::new(URLQueue::new());
+    println!("\n=== PHASE 1: Loading seed URLs ===");
+    let t0 = Instant::now();
+
+    // Try loading from pre-generated mega seed file first
+    let seed_file = "/workspace/mega_seeds.txt";
+    if Path::new(seed_file).exists() {
+        println!("[seed] Loading from {}...", seed_file);
+        let content = std::fs::read_to_string(seed_file).unwrap_or_default();
+        let mut batch = Vec::with_capacity(10_000);
+        let mut loaded = 0usize;
+        for line in content.lines() {
+            let url = line.trim();
+            if !url.is_empty() && is_valid_url(url) {
+                batch.push(url.to_string());
+                if batch.len() >= 10_000 {
+                    loaded += queue.push_bulk(batch).await;
+                    batch = Vec::with_capacity(10_000);
+                }
+            }
+        }
+        if !batch.is_empty() {
+            loaded += queue.push_bulk(batch).await;
+        }
+        println!("[seed] Loaded {} URLs from seed file", loaded);
+    }
+
+    // Supplement with live sources if needed
+    if queue.len().await < 100_000 {
+        download_commoncrawl_urls(&queue, 4_000_000).await;
+    }
+    download_wikipedia_urls(&queue, 20_000).await;
+    download_sitemap_urls(&queue).await;
+    download_hn_urls(&queue).await;
+
+    println!(
+        "\n=== PHASE 1 complete: {} seed URLs loaded in {:.0}s ===\n",
+        queue.len().await,
+        t0.elapsed().as_secs_f64()
+    );
+
+    queue.shuffle().await;
+
+    // === PHASE 2: CRAWL ===
+    println!("=== PHASE 2: Crawling ===");
+
+    // Background queue refiller — keeps queue topped up without blocking crawl
+    let refill_queue = queue.clone();
+    let refilling = Arc::new(AtomicU64::new(0)); // 1 = refill in progress
+    let refilling_bg = refilling.clone();
+    let _refill_handle = tokio::spawn(async move {
+        loop {
+            tokio::time::sleep(Duration::from_secs(5)).await;
+            let qlen = refill_queue.len().await;
+            if qlen < 50_000 && refilling_bg.compare_exchange(0, 1, Ordering::SeqCst, Ordering::SeqCst).is_ok() {
+                println!("[bg-refill] Queue at {} — refilling...", qlen);
+                download_commoncrawl_urls(&refill_queue, 500_000).await;
+                download_wikipedia_urls(&refill_queue, 10_000).await;
+                download_sitemap_urls(&refill_queue).await;
+                download_hn_urls(&refill_queue).await;
+                println!("[bg-refill] Done, queue now at {}", refill_queue.len().await);
+                refilling_bg.store(0, Ordering::SeqCst);
+            }
+        }
+    });
+
+    loop {
+        if queue.len().await == 0 {
+            println!("Queue empty, waiting for background refiller...");
+            // Trigger refill if not already running
+            for _ in 0..30 {
+                tokio::time::sleep(Duration::from_secs(2)).await;
+                if queue.len().await > 0 {
+                    break;
+                }
+            }
+            if queue.len().await == 0 {
+                println!("Still empty after 60s. Force-seeding...");
+                download_wikipedia_urls(&queue, 10_000).await;
+            }
+            continue;
+        }
+
+        let chunk_name = format!("crawl_rust_chunk{:04}.jsonl.gz", chunk_num);
+        let chunk_path_str = format!("{}/{}", OUTPUT_DIR, chunk_name);
+        let chunk_path = PathBuf::from(&chunk_path_str);
+
+        let file = std::fs::File::create(&chunk_path).expect("Cannot create chunk file");
+        let gz_writer = Arc::new(Mutex::new(GzEncoder::new(file, Compression::fast())));
+
+        let chunk_bytes = Arc::new(AtomicI64::new(0));
+        let chunk_docs = Arc::new(AtomicI64::new(0));
+        let pages_tried = Arc::new(AtomicU64::new(0));
+        let chunk_start = Instant::now();
+
+        println!(
+            "\nStarting chunk {} ({} URLs queued)...",
+            chunk_num,
+            queue.len().await
+        );
+
+        // Status printer task
+        let cb = chunk_bytes.clone();
+        let cd = chunk_docs.clone();
+        let pt = pages_tried.clone();
+        let ql = queue.clone();
+        let cn = chunk_num;
+        let status_handle = tokio::spawn(async move {
+            let mut interval = tokio::time::interval(STATUS_INTERVAL);
+            loop {
+                interval.tick().await;
+                let docs = cd.load(Ordering::Relaxed);
+                let bytes = cb.load(Ordering::Relaxed);
+                let tried = pt.load(Ordering::Relaxed);
+                let elapsed = chunk_start.elapsed().as_secs_f64();
+                let rate = docs as f64 / elapsed.max(1.0);
+                println!(
+                    "  Chunk {}: {} docs, {:.0}MB, {} queued, {:.1} docs/s, tried {}, {:.0}s elapsed",
+                    cn,
+                    docs,
+                    bytes as f64 / 1e6,
+                    ql.len().await,
+                    rate,
+                    tried,
+                    elapsed
+                );
+                if bytes >= CHUNK_TARGET_BYTES {
+                    break;
+                }
+            }
+        });
+
+        // Semaphore for concurrency control
+        let semaphore = Arc::new(Semaphore::new(NUM_WORKERS));
+        let mut task_handles = Vec::new();
+
+        // Feed URLs until chunk is full
+        while chunk_bytes.load(Ordering::Relaxed) < CHUNK_TARGET_BYTES {
+            let batch = queue.pop_batch(100).await;
+            if batch.is_empty() {
+                // Don't block — just wait briefly for background refiller
+                tokio::time::sleep(Duration::from_millis(500)).await;
+                if queue.len().await == 0 {
+                    // Try a small inline refill
+                    download_wikipedia_urls(&queue, 2_000).await;
+                }
+                continue;
+            }
+
+            for url in batch {
+                let permit = semaphore.clone().acquire_owned().await.unwrap();
+                let client = client.clone();
+                let seen_hashes = seen_hashes.clone();
+                let domain_counts = domain_counts.clone();
+                let gz_writer = gz_writer.clone();
+                let chunk_bytes = chunk_bytes.clone();
+                let chunk_docs = chunk_docs.clone();
+                let pages_tried = pages_tried.clone();
+                let queue = queue.clone();
+
+                let handle = tokio::spawn(async move {
+                    let _permit = permit;
+                    pages_tried.fetch_add(1, Ordering::Relaxed);
+
+                    let domain = get_domain(&url);
+                    if let Some(count) = domain_counts.get(&domain) {
+                        if *count >= MAX_URLS_PER_DOMAIN {
+                            return;
+                        }
+                    }
+
+                    let (body, final_url) = match fetch_page(&client, &url).await {
+                        Ok((b, u)) => (b, u),
+                        Err(_) => return,
+                    };
+
+                    let text = extract_text_from_html(&body);
+                    if text.len() < MIN_TEXT_LEN {
+                        return;
+                    }
+                    let text = if text.len() > MAX_TEXT_LEN {
+                        // Find char boundary at or before MAX_TEXT_LEN
+                        let mut end = MAX_TEXT_LEN;
+                        while end > 0 && !text.is_char_boundary(end) {
+                            end -= 1;
+                        }
+                        text[..end].to_string()
+                    } else {
+                        text
+                    };
+
+                    let hash = content_hash(&text);
+                    if seen_hashes.contains_key(&hash) {
+                        return;
+                    }
+                    seen_hashes.insert(hash, ());
+
+                    let doc = Document {
+                        text,
+                        url: final_url.clone(),
+                        domain: domain.clone(),
+                        timestamp: chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string(),
+                        source: "crawl_rust_v1".to_string(),
+                    };
+                    let json_bytes = match serde_json::to_vec(&doc) {
+                        Ok(b) => b,
+                        Err(_) => return,
+                    };
+
+                    {
+                        let mut writer = gz_writer.lock().await;
+                        let _ = writer.write_all(&json_bytes);
+                        let _ = writer.write_all(b"\n");
+                    }
+                    chunk_bytes.fetch_add(json_bytes.len() as i64, Ordering::Relaxed);
+                    chunk_docs.fetch_add(1, Ordering::Relaxed);
+
+                    domain_counts
+                        .entry(domain)
+                        .and_modify(|c| *c += 1)
+                        .or_insert(1);
+
+                    // Extract and enqueue discovered links
+                    let mut links = extract_links(&body, &final_url);
+                    {
+                        let mut rng = rand::thread_rng();
+                        links.shuffle(&mut rng);
+                    }
+                    links.truncate(50);
+                    if !links.is_empty() {
+                        queue.push_bulk(links).await;
+                    }
+                });
+                task_handles.push(handle);
+
+                // Clean up completed handles periodically
+                if task_handles.len() > 2000 {
+                    let mut new_handles = Vec::with_capacity(1000);
+                    for h in task_handles.drain(..) {
+                        if !h.is_finished() {
+                            new_handles.push(h);
+                        }
+                    }
+                    task_handles = new_handles;
+                }
+            }
+        }
+
+        // Wait for all remaining tasks
+        for h in task_handles {
+            let _ = h.await;
+        }
+
+        status_handle.abort();
+
+        // Finalize chunk
+        let writer = Arc::try_unwrap(gz_writer)
+            .expect("All tasks should be done");
+        let writer = writer.into_inner();
+        let _ = writer.finish();
+
+        let docs = chunk_docs.load(Ordering::Relaxed);
+        let bytes = chunk_bytes.load(Ordering::Relaxed);
+        let elapsed = chunk_start.elapsed().as_secs_f64();
+
+        if docs == 0 {
+            println!("  No docs in chunk, cleaning up");
+            let _ = std::fs::remove_file(&chunk_path);
+            tokio::time::sleep(Duration::from_secs(300)).await;
+            continue;
+        }
+
+        let compressed_size = std::fs::metadata(&chunk_path)
+            .map(|m| m.len())
+            .unwrap_or(0);
+        println!(
+            "  Chunk {} complete: {} docs, {:.0}MB raw, {:.0}MB compressed, {:.0}s, {:.1} docs/s",
+            chunk_num,
+            docs,
+            bytes as f64 / 1e6,
+            compressed_size as f64 / 1e6,
+            elapsed,
+            docs as f64 / elapsed
+        );
+
+        if upload_chunk(&chunk_path_str, &chunk_name) {
+            let _ = std::fs::remove_file(&chunk_path);
+            chunk_num += 1;
+            println!("  Total chunks uploaded: {}", chunk_num);
+        } else {
+            println!("  Upload failed, will retry chunk");
+            let _ = std::fs::remove_file(&chunk_path);
+        }
+    }
+}