Datasets:

webxos
/

synthetic_error_correction

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>TYPE/RIGHTER - by webXOS</title>
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+    <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap">
+    <link rel="manifest" href="manifest.json">
+    <style>
+        :root {
+            --primary: #4361ee;
+            --primary-dark: #3a56d4;
+            --secondary: #7209b7;
+            --success: #4cc9f0;
+            --warning: #f72585;
+            --light: #f8f9fa;
+            --dark: #212529;
+            --gray: #6c757d;
+            --border-radius: 8px;
+            --shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+            --transition: all 0.3s ease;
+        }
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        body {
+            font-family: 'Inter', sans-serif;
+            line-height: 1.6;
+            color: var(--dark);
+            background-color: #f5f7ff;
+            min-height: 100vh;
+            padding-bottom: 2rem;
+        }
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 0 1.5rem;
+        }
+        header {
+            background: linear-gradient(135deg, var(--primary), var(--secondary));
+            color: white;
+            padding: 1.5rem 0;
+            border-bottom-left-radius: 20px;
+            border-bottom-right-radius: 20px;
+            box-shadow: var(--shadow);
+            margin-bottom: 2rem;
+        }
+        .header-content {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        .logo {
+            display: flex;
+            align-items: center;
+            gap: 0.75rem;
+        }
+        .logo i {
+            font-size: 1.8rem;
+        }
+        .logo h1 {
+            font-size: 1.8rem;
+            font-weight: 700;
+        }
+        .tagline {
+            font-size: 0.9rem;
+            opacity: 0.9;
+            margin-top: 0.25rem;
+        }
+        .offline-badge {
+            background-color: var(--success);
+            color: var(--dark);
+            padding: 0.3rem 0.8rem;
+            border-radius: 20px;
+            font-size: 0.8rem;
+            font-weight: 600;
+        }
+        main {
+            display: grid;
+            grid-template-columns: 1fr;
+            gap: 2rem;
+        }
+        @media (min-width: 992px) {
+            main {
+                grid-template-columns: 1fr 2fr;
+            }
+        }
+        .card {
+            background: white;
+            border-radius: var(--border-radius);
+            box-shadow: var(--shadow);
+            padding: 1.5rem;
+            margin-bottom: 1.5rem;
+            transition: var(--transition);
+        }
+        .card:hover {
+            box-shadow: 0 6px 12px rgba(0, 0, 0, 0.15);
+        }
+        .card h2 {
+            font-size: 1.4rem;
+            margin-bottom: 1rem;
+            color: var(--primary);
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+        .card h2 i {
+            color: var(--secondary);
+        }
+        .upload-area {
+            border: 2px dashed var(--primary);
+            border-radius: var(--border-radius);
+            padding: 2.5rem 1.5rem;
+            text-align: center;
+            cursor: pointer;
+            transition: var(--transition);
+            background-color: rgba(67, 97, 238, 0.05);
+        }
+        .upload-area:hover {
+            background-color: rgba(67, 97, 238, 0.1);
+        }
+        .upload-area i {
+            font-size: 3rem;
+            color: var(--primary);
+            margin-bottom: 1rem;
+        }
+        .upload-area p {
+            margin-bottom: 1rem;
+        }
+        .file-input {
+            display: none;
+        }
+        .file-list {
+            margin-top: 1.5rem;
+            max-height: 300px;
+            overflow-y: auto;
+        }
+        .file-item {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            padding: 0.75rem;
+            border: 1px solid #e9ecef;
+            border-radius: var(--border-radius);
+            margin-bottom: 0.5rem;
+            background-color: #f8f9fa;
+        }
+        .file-info {
+            display: flex;
+            align-items: center;
+            gap: 0.75rem;
+        }
+        .file-icon {
+            color: var(--primary);
+        }
+        .file-name {
+            font-weight: 500;
+        }
+        .file-size {
+            font-size: 0.85rem;
+            color: var(--gray);
+        }
+        .file-remove {
+            color: var(--warning);
+            cursor: pointer;
+            background: none;
+            border: none;
+            font-size: 1.1rem;
+        }
+        .slider-container {
+            margin-bottom: 1.5rem;
+        }
+        .slider-header {
+            display: flex;
+            justify-content: space-between;
+            margin-bottom: 0.5rem;
+        }
+        .slider-label {
+            font-weight: 500;
+        }
+        .slider-value {
+            font-weight: 600;
+            color: var(--primary);
+        }
+        .slider {
+            width: 100%;
+            height: 8px;
+            border-radius: 4px;
+            background: #e9ecef;
+            outline: none;
+            -webkit-appearance: none;
+        }
+        .slider::-webkit-slider-thumb {
+            -webkit-appearance: none;
+            width: 20px;
+            height: 20px;
+            border-radius: 50%;
+            background: var(--primary);
+            cursor: pointer;
+        }
+        .slider::-moz-range-thumb {
+            width: 20px;
+            height: 20px;
+            border-radius: 50%;
+            background: var(--primary);
+            cursor: pointer;
+            border: none;
+        }
+        .process-btn {
+            background: linear-gradient(to right, var(--primary), var(--secondary));
+            color: white;
+            border: none;
+            border-radius: var(--border-radius);
+            padding: 1rem 2rem;
+            font-size: 1.1rem;
+            font-weight: 600;
+            cursor: pointer;
+            width: 100%;
+            transition: var(--transition);
+            margin-top: 1rem;
+        }
+        .process-btn:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 6px 12px rgba(67, 97, 238, 0.3);
+        }
+        .process-btn:disabled {
+            opacity: 0.6;
+            cursor: not-allowed;
+        }
+        .process-btn:disabled:hover {
+            transform: none;
+            box-shadow: none;
+        }
+        .status-area {
+            margin-top: 1.5rem;
+        }
+        .status-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 1rem;
+        }
+        .progress-bar {
+            height: 10px;
+            background-color: #e9ecef;
+            border-radius: 5px;
+            overflow: hidden;
+            margin-bottom: 1rem;
+        }
+        .progress-fill {
+            height: 100%;
+            background: linear-gradient(to right, var(--success), #4cc9f0);
+            width: 0%;
+            transition: width 0.5s ease;
+        }
+        .status-message {
+            font-size: 0.9rem;
+            color: var(--gray);
+            min-height: 1.5rem;
+        }
+        .dataset-preview {
+            margin-top: 1.5rem;
+            max-height: 400px;
+            overflow-y: auto;
+            border: 1px solid #e9ecef;
+            border-radius: var(--border-radius);
+            padding: 1rem;
+        }
+        .preview-item {
+            margin-bottom: 1.5rem;
+            padding-bottom: 1.5rem;
+            border-bottom: 1px dashed #e9ecef;
+        }
+        .preview-item:last-child {
+            border-bottom: none;
+        }
+        .preview-label {
+            font-weight: 600;
+            color: var(--primary);
+            margin-bottom: 0.5rem;
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+        .preview-text {
+            font-size: 0.9rem;
+            background-color: #f8f9fa;
+            padding: 0.75rem;
+            border-radius: 5px;
+            border-left: 3px solid var(--primary);
+        }
+        .export-btn {
+            background: linear-gradient(to right, #38b000, #2d8c00);
+            color: white;
+            border: none;
+            border-radius: var(--border-radius);
+            padding: 1rem 2rem;
+            font-size: 1.1rem;
+            font-weight: 600;
+            cursor: pointer;
+            width: 100%;
+            transition: var(--transition);
+            margin-top: 1rem;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            gap: 0.5rem;
+        }
+        .export-btn:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 6px 12px rgba(56, 176, 0, 0.3);
+        }
+        .export-btn:disabled {
+            opacity: 0.6;
+            cursor: not-allowed;
+        }
+        .export-btn:disabled:hover {
+            transform: none;
+            box-shadow: none;
+        }
+        .use-case-example {
+            background: linear-gradient(135deg, #f8f9fa, #e9ecef);
+            border-left: 4px solid var(--secondary);
+            padding: 1.5rem;
+            margin-top: 2rem;
+            border-radius: var(--border-radius);
+        }
+        .use-case-example h3 {
+            color: var(--secondary);
+            margin-bottom: 0.75rem;
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+        .step {
+            display: flex;
+            align-items: flex-start;
+            gap: 1rem;
+            margin-bottom: 1rem;
+        }
+        .step-number {
+            background-color: var(--primary);
+            color: white;
+            width: 24px;
+            height: 24px;
+            border-radius: 50%;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            font-size: 0.9rem;
+            font-weight: 600;
+            flex-shrink: 0;
+        }
+        .footer {
+            text-align: center;
+            margin-top: 3rem;
+            color: var(--gray);
+            font-size: 0.9rem;
+            padding-top: 1.5rem;
+            border-top: 1px solid #e9ecef;
+        }
+        .toast {
+            position: fixed;
+            bottom: 2rem;
+            right: 2rem;
+            background: var(--dark);
+            color: white;
+            padding: 1rem 1.5rem;
+            border-radius: var(--border-radius);
+            box-shadow: var(--shadow);
+            transform: translateY(100px);
+            opacity: 0;
+            transition: transform 0.5s ease, opacity 0.5s ease;
+            z-index: 1000;
+            max-width: 350px;
+        }
+        .toast.show {
+            transform: translateY(0);
+            opacity: 1;
+        }
+        .loading-spinner {
+            display: inline-block;
+            width: 20px;
+            height: 20px;
+            border: 3px solid rgba(255, 255, 255, 0.3);
+            border-radius: 50%;
+            border-top-color: white;
+            animation: spin 1s ease-in-out infinite;
+        }
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+        .pwa-install {
+            background-color: var(--primary);
+            color: white;
+            padding: 0.75rem 1.5rem;
+            border-radius: var(--border-radius);
+            border: none;
+            font-weight: 600;
+            cursor: pointer;
+            display: none;
+            align-items: center;
+            gap: 0.5rem;
+        }
+        @media (max-width: 768px) {
+            .header-content {
+                flex-direction: column;
+                gap: 1rem;
+                text-align: center;
+            }
+            .card {
+                padding: 1rem;
+            }
+        }
+    </style>
+</head>
+<body>
+    <header>
+        <div class="container">
+            <div class="header-content">
+                <div class="logo">
+                    <i class="fas fa-keyboard"></i>
+                    <div>
+                        <h1>TYPE/RIGHTER by webXOS</h1>
+                        <div class="tagline">Transform documents into synthetic datasets for error correction</div>
+                    </div>
+                </div>
+                <div>
+                    <button id="installBtn" class="pwa-install">
+                        <i class="fas fa-download"></i> Install App
+                    </button>
+                    <div class="offline-badge">
+                        <i class="fas fa-wifi-slash"></i> Offline-First PWA
+                    </div>
+                </div>
+            </div>
+        </div>
+    </header>
+    <div class="container">
+        <main>
+            <div class="left-column">
+                <div class="card">
+                    <h2><i class="fas fa-file-upload"></i> Document Import</h2>
+                    <div class="upload-area" id="uploadArea">
+                        <i class="fas fa-cloud-upload-alt"></i>
+                        <p><strong>Click to upload documents</strong></p>
+                        <p>Supported formats: .txt, .csv, .md, .jsonl</p>
+                        <p class="tagline">All processing happens locally in your browser</p>
+                        <input type="file" id="fileInput" class="file-input" multiple accept=".txt,.csv,.md,.jsonl">
+                    </div>
+                    <div class="file-list" id="fileList">
+                        <!-- Files will appear here -->
+                    </div>
+                </div>
+                <div class="card">
+                    <h2><i class="fas fa-sliders-h"></i> Error Injection Settings</h2>
+                    <div class="slider-container">
+                        <div class="slider-header">
+                            <span class="slider-label">Keyboard Adjacent Errors</span>
+                            <span class="slider-value" id="adjacentValue">5%</span>
+                        </div>
+                        <input type="range" min="0" max="20" value="5" class="slider" id="adjacentSlider">
+                        <div class="status-message">Swaps keys with adjacent keyboard positions</div>
+                    </div>
+                    <div class="slider-container">
+                        <div class="slider-header">
+                            <span class="slider-label">Case Corruption</span>
+                            <span class="slider-value" id="caseValue">3%</span>
+                        </div>
+                        <input type="range" min="0" max="15" value="3" class="slider" id="caseSlider">
+                        <div class="status-message">Randomly changes letter casing (uPPER/lower)</div>
+                    </div>
+                    <div class="slider-container">
+                        <div class="slider-header">
+                            <span class="slider-label">Symbol Insertion</span>
+                            <span class="slider-value" id="symbolValue">2%</span>
+                        </div>
+                        <input type="range" min="0" max="10" value="2" class="slider" id="symbolSlider">
+                        <div class="status-message">Adds random symbols like !, @, # to words</div>
+                    </div>
+                    <div class="slider-container">
+                        <div class="slider-header">
+                            <span class="slider-label">OCR Line Noise</span>
+                            <span class="slider-value" id="ocrValue">0%</span>
+                        </div>
+                        <input type="range" min="0" max="10" value="0" class="slider" id="ocrSlider">
+                        <div class="status-message">Simulates vertical line noise from old scanners</div>
+                    </div>
+                    <button id="processBtn" class="process-btn">
+                        <i class="fas fa-cogs"></i> Generate Synthetic Dataset
+                    </button>
+                </div>
+                <!-- Example Use Case (General) -->
+                <div class="use-case-example">
+                    <h3><i class="fas fa-lightbulb"></i> Example Use Case</h3>
+                    <div class="step">
+                        <div class="step-number">1</div>
+                        <div>Upload your .txt, .csv, .md, or .jsonl files containing any text content</div>
+                    </div>
+                    <div class="step">
+                        <div class="step-number">2</div>
+                        <div>TYPE/RIGHTER normalizes the text and injects controlled errors based on your settings</div>
+                    </div>
+                    <div class="step">
+                        <div class="step-number">3</div>
+                        <div>Outputs a synthetic dataset of "error-clean" pairs ready to train custom correction models</div>
+                    </div>
+                </div>
+            </div>
+            <div class="right-column">
+                <div class="card">
+                    <div class="status-header">
+                        <h2><i class="fas fa-tasks"></i> Processing Status</h2>
+                        <div id="progressPercent">0%</div>
+                    </div>
+                    <div class="progress-bar">
+                        <div class="progress-fill" id="progressFill"></div>
+                    </div>
+                    <div class="status-message" id="statusMessage">
+                        Upload documents to begin processing...
+                    </div>
+                    <div class="dataset-preview" id="datasetPreview">
+                        <div class="preview-item">
+                            <div class="preview-label"><i class="fas fa-file-alt"></i> Original</div>
+                            <div class="preview-text" id="originalText">No data yet. Upload documents to see preview.</div>
+                        </div>
+                        <div class="preview-item">
+                            <div class="preview-label"><i class="fas fa-bomb"></i> Corrupted</div>
+                            <div class="preview-text" id="corruptedText">The corrupted version with injected errors will appear here.</div>
+                        </div>
+                        <div class="preview-item">
+                            <div class="preview-label"><i class="fas fa-bullseye"></i> Target</div>
+                            <div class="preview-text" id="targetText">The cleaned, normalized version will appear here.</div>
+                        </div>
+                    </div>
+                    <button id="exportBtn" class="export-btn" disabled>
+                        <i class="fas fa-file-export"></i> Export to Hugging Face Format
+                    </button>
+                </div>
+                <div class="card">
+                    <h2><i class="fas fa-info-circle"></i> How It Works</h2>
+                    <div class="step">
+                        <div class="step-number">1</div>
+                        <div><strong>Normalization (Cleaner):</strong> Uses simulated cleaning to fix existing typos, creating a "Ground Truth" clean version.</div>
+                    </div>
+                    <div class="step">
+                        <div class="step-number">2</div>
+                        <div><strong>Corruption (RNG Noiser):</strong> Injects fresh, controlled errors based on your slider settings.</div>
+                    </div>
+                    <div class="step">
+                        <div class="step-number">3</div>
+                        <div><strong>Tagging (Annotator):</strong> Performs content-based auto-labeling based on text content.</div>
+                    </div>
+                    <div class="step">
+                        <div class="step-number">4</div>
+                        <div><strong>Export:</strong> Creates a "triplet" dataset with original, corrupted, and target versions in Hugging Face format.</div>
+                    </div>
+                </div>
+            </div>
+        </main>
+        <div class="footer">
+            <p>TYPE/RIGHTER • Offline-First PWA • webXOS 2026 • All processing happens locally in your browser</p>
+            <p>No data is uploaded to any server • Privacy by design</p>
+        </div>
+    </div>
+    <div class="toast" id="toast"></div>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js"></script>
+    <script>
+        // PWA Installation
+        let deferredPrompt;
+        const installBtn = document.getElementById('installBtn');
+        window.addEventListener('beforeinstallprompt', (e) => {
+            e.preventDefault();
+            deferredPrompt = e;
+            installBtn.style.display = 'flex';
+        });
+        installBtn.addEventListener('click', async () => {
+            if (!deferredPrompt) return;
+            deferredPrompt.prompt();
+            const { outcome } = await deferredPrompt.userChoice;
+            if (outcome === 'accepted') {
+                installBtn.style.display = 'none';
+                showToast('TYPE/RIGHTER installed successfully!');
+            }
+            deferredPrompt = null;
+        });
+        // Service Worker Registration for Offline Capability
+        if ('serviceWorker' in navigator) {
+            window.addEventListener('load', () => {
+                navigator.serviceWorker.register('/service-worker.js').catch(error => {
+                    console.log('Service Worker registration failed:', error);
+                });
+            });
+        }
+        // App State
+        const state = {
+            files: [],
+            processing: false,
+            dataset: [],
+            progress: 0
+        };
+        // DOM Elements
+        const uploadArea = document.getElementById('uploadArea');
+        const fileInput = document.getElementById('fileInput');
+        const fileList = document.getElementById('fileList');
+        const processBtn = document.getElementById('processBtn');
+        const exportBtn = document.getElementById('exportBtn');
+        const progressFill = document.getElementById('progressFill');
+        const progressPercent = document.getElementById('progressPercent');
+        const statusMessage = document.getElementById('statusMessage');
+        const toast = document.getElementById('toast');
+        const sliders = {
+            adjacent: document.getElementById('adjacentSlider'),
+            case: document.getElementById('caseSlider'),
+            symbol: document.getElementById('symbolSlider'),
+            ocr: document.getElementById('ocrSlider')
+        };
+        const sliderValues = {
+            adjacent: document.getElementById('adjacentValue'),
+            case: document.getElementById('caseValue'),
+            symbol: document.getElementById('symbolValue'),
+            ocr: document.getElementById('ocrValue')
+        };
+        const preview = {
+            original: document.getElementById('originalText'),
+            corrupted: document.getElementById('corruptedText'),
+            target: document.getElementById('targetText')
+        };
+        // Event Listeners
+        uploadArea.addEventListener('click', () => fileInput.click());
+        uploadArea.addEventListener('dragover', (e) => {
+            e.preventDefault();
+            uploadArea.style.borderColor = 'var(--secondary)';
+            uploadArea.style.backgroundColor = 'rgba(114, 9, 183, 0.1)';
+        });
+        uploadArea.addEventListener('dragleave', () => {
+            uploadArea.style.borderColor = 'var(--primary)';
+            uploadArea.style.backgroundColor = 'rgba(67, 97, 238, 0.05)';
+        });
+        uploadArea.addEventListener('drop', (e) => {
+            e.preventDefault();
+            uploadArea.style.borderColor = 'var(--primary)';
+            uploadArea.style.backgroundColor = 'rgba(67, 97, 238, 0.05)';
+            if (e.dataTransfer.files.length) {
+                handleFiles(e.dataTransfer.files);
+            }
+        });
+        fileInput.addEventListener('change', (e) => {
+            if (e.target.files.length) {
+                handleFiles(e.target.files);
+            }
+        });
+        processBtn.addEventListener('click', processDocuments);
+        exportBtn.addEventListener('click', exportDataset);
+        // Update slider value displays
+        Object.keys(sliders).forEach(key => {
+            sliders[key].addEventListener('input', (e) => {
+                sliderValues[key].textContent = `${e.target.value}%`;
+            });
+        });
+        // File Handling
+        function handleFiles(fileList) {
+            for (let i = 0; i < fileList.length; i++) {
+                const file = fileList[i];
+                const ext = file.name.split('.').pop().toLowerCase();
+                if (['txt', 'csv', 'md', 'jsonl'].includes(ext)) {
+                    state.files.push({
+                        name: file.name,
+                        size: formatFileSize(file.size),
+                        type: ext,
+                        content: null,
+                        chunks: []
+                    });
+                    readFileContent(file, state.files.length - 1);
+                } else {
+                    showToast(`Unsupported file type: .${ext}. Please upload .txt, .csv, .md, or .jsonl files.`);
+                }
+            }
+            renderFileList();
+        }
+        function readFileContent(file, index) {
+            const reader = new FileReader();
+            reader.onload = (e) => {
+                state.files[index].content = e.target.result;
+                state.files[index].chunks = chunkText(e.target.result);
+                updateProcessButton();
+            };
+            reader.readAsText(file);
+        }
+        function chunkText(text) {
+            // Simple sentence-level chunking
+            const sentences = text.split(/[.!?]+/).filter(s => s.trim().length > 0);
+            return sentences.map(s => s.trim()).filter(s => s.length > 10);
+        }
+        function renderFileList() {
+            if (state.files.length === 0) {
+                fileList.innerHTML = '<p style="text-align: center; color: var(--gray); padding: 1rem;">No files uploaded yet</p>';
+                return;
+            }
+            fileList.innerHTML = state.files.map((file, index) => `
+                <div class="file-item">
+                    <div class="file-info">
+                        <i class="fas fa-file-alt file-icon"></i>
+                        <div>
+                            <div class="file-name">${file.name}</div>
+                            <div class="file-size">${file.size} • ${file.type.toUpperCase()} • ${file.chunks.length} chunks</div>
+                        </div>
+                    </div>
+                    <button class="file-remove" onclick="removeFile(${index})">
+                        <i class="fas fa-times"></i>
+                    </button>
+                </div>
+            `).join('');
+        }
+        function removeFile(index) {
+            state.files.splice(index, 1);
+            renderFileList();
+            updateProcessButton();
+        }
+        function updateProcessButton() {
+            const hasFiles = state.files.length > 0;
+            processBtn.disabled = !hasFiles || state.processing;
+            if (!hasFiles) {
+                statusMessage.textContent = 'Upload documents to begin processing...';
+            } else {
+                const totalChunks = state.files.reduce((sum, file) => sum + file.chunks.length, 0);
+                statusMessage.textContent = `Ready to process ${state.files.length} file(s) with ${totalChunks} text chunks`;
+            }
+        }
+        // Processing Functions
+        async function processDocuments() {
+            if (state.processing || state.files.length === 0) return;
+            state.processing = true;
+            state.dataset = [];
+            updateProcessButton();
+            processBtn.innerHTML = '<span class="loading-spinner"></span> Processing...';
+            // Reset progress
+            updateProgress(0);
+            statusMessage.textContent = 'Starting document processing...';
+            // Get all chunks from all files
+            const allChunks = [];
+            state.files.forEach(file => {
+                file.chunks.forEach(chunk => {
+                    allChunks.push({
+                        text: chunk,
+                        source: file.name,
+                        type: file.type
+                    });
+                });
+            });
+            // Process chunks in batches (simulated)
+            const batchSize = 5;
+            const totalChunks = allChunks.length;
+            for (let i = 0; i < totalChunks; i += batchSize) {
+                const batch = allChunks.slice(i, i + batchSize);
+                // Process each chunk in the batch
+                for (let j = 0; j < batch.length; j++) {
+                    const chunk = batch[j];
+                    const processed = processChunk(chunk.text, chunk.source, chunk.type);
+                    state.dataset.push(processed);
+                    // Update progress
+                    const progress = Math.round(((i + j + 1) / totalChunks) * 100);
+                    updateProgress(progress);
+                    statusMessage.textContent = `Processing: ${i + j + 1} of ${totalChunks} chunks`;
+                    // Update preview with the first processed item
+                    if (state.dataset.length === 1) {
+                        updatePreview(processed);
+                    }
+                    // Simulate processing time
+                    await sleep(50);
+                }
+            }
+            // Complete processing
+            updateProgress(100);
+            statusMessage.textContent = `Processing complete! Generated ${state.dataset.length} synthetic examples.`;
+            processBtn.innerHTML = '<i class="fas fa-check"></i> Processing Complete';
+            exportBtn.disabled = false;
+            // Show success message
+            showToast(`Successfully generated ${state.dataset.length} synthetic examples!`);
+            // Re-enable process button after a delay
+            setTimeout(() => {
+                state.processing = false;
+                processBtn.innerHTML = '<i class="fas fa-cogs"></i> Generate Synthetic Dataset';
+                updateProcessButton();
+            }, 1000);
+        }
+        function processChunk(text, source, fileType) {
+            // Step 1: Normalization (simulated cleaning)
+            const normalized = normalizeText(text);
+            // Step 2: Corruption (error injection based on sliders)
+            const corrupted = corruptText(normalized);
+            // Step 3: Tagging (simulated zero-shot classification)
+            const tags = classifyText(normalized, fileType);
+            return {
+                original: text,
+                corrupted: corrupted,
+                target: normalized,
+                tags: tags,
+                source: source,
+                id: generateId()
+            };
+        }
+        function normalizeText(text) {
+            // Simulated text normalization
+            const commonTypos = {
+                'teh': 'the',
+                'adn': 'and',
+                'th e': 'the',
+                't he': 'the',
+                'wiht': 'with',
+                'recieve': 'receive',
+                'seperate': 'separate',
+                'occured': 'occurred',
+                'definately': 'definitely',
+                'goverment': 'government'
+            };
+            let result = text;
+            // Apply common typo fixes
+            Object.keys(commonTypos).forEach(typo => {
+                const regex = new RegExp(`\\b${typo}\\b`, 'gi');
+                result = result.replace(regex, commonTypos[typo]);
+            });
+            // Fix double spaces
+            result = result.replace(/\s+/g, ' ');
+            // Fix missing spaces after punctuation
+            result = result.replace(/([.,!?])([A-Za-z])/g, '$1 $2');
+            return result;
+        }
+        function corruptText(text) {
+            // Get corruption levels from sliders
+            const adjacentLevel = parseInt(sliders.adjacent.value) / 100;
+            const caseLevel = parseInt(sliders.case.value) / 100;
+            const symbolLevel = parseInt(sliders.symbol.value) / 100;
+            const ocrLevel = parseInt(sliders.ocr.value) / 100;
+            let result = text;
+            // Apply keyboard adjacent errors
+            if (adjacentLevel > 0) {
+                result = injectAdjacentErrors(result, adjacentLevel);
+            }
+            // Apply case corruption
+            if (caseLevel > 0) {
+                result = injectCaseErrors(result, caseLevel);
+            }
+            // Apply symbol insertion
+            if (symbolLevel > 0) {
+                result = injectSymbolErrors(result, symbolLevel);
+            }
+            // Apply OCR line noise simulation
+            if (ocrLevel > 0) {
+                result = injectOCRNoise(result, ocrLevel);
+            }
+            return result;
+        }
+        function injectAdjacentErrors(text, level) {
+            // Keyboard adjacency map
+            const adjacencyMap = {
+                'q': 'w', 'w': 'qe', 'e': 'wr', 'r': 'et', 't': 'ry', 'y': 'tu', 'u': 'yi', 'i': 'uo', 'o': 'ip', 'p': 'o[',
+                'a': 's', 's': 'ad', 'd': 'sf', 'f': 'dg', 'g': 'fh', 'h': 'gj', 'j': 'hk', 'k': 'jl', 'l': 'k;',
+                'z': 'x', 'x': 'zc', 'c': 'xv', 'v': 'cb', 'b': 'vn', 'n': 'bm', 'm': 'n,'
+            };
+            return text.split('').map(char => {
+                if (Math.random() < level && char.toLowerCase() in adjacencyMap) {
+                    const adjacent = adjacencyMap[char.toLowerCase()];
+                    return adjacent[Math.floor(Math.random() * adjacent.length)];
+                }
+                return char;
+            }).join('');
+        }
+        function injectCaseErrors(text, level) {
+            return text.split('').map(char => {
+                if (Math.random() < level && /[a-zA-Z]/.test(char)) {
+                    return Math.random() > 0.5 ? char.toUpperCase() : char.toLowerCase();
+                }
+                return char;
+            }).join('');
+        }
+        function injectSymbolErrors(text, level) {
+            const symbols = ['!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '-', '+', '=', '[', ']', '{', '}'];
+            return text.split('').map(char => {
+                if (Math.random() < level && /[a-zA-Z]/.test(char)) {
+                    // Sometimes replace, sometimes insert before/after
+                    if (Math.random() > 0.7) {
+                        return symbols[Math.floor(Math.random() * symbols.length)];
+                    } else if (Math.random() > 0.5) {
+                        return char + symbols[Math.floor(Math.random() * symbols.length)];
+                    } else {
+                        return symbols[Math.floor(Math.random() * symbols.length)] + char;
+                    }
+                }
+                return char;
+            }).join('');
+        }
+        function injectOCRNoise(text, level) {
+            // Simulate vertical line noise from old scanners
+            const noiseChars = ['|', 'l', 'I', '1', '!', ':', ';'];
+            return text.split('').map(char => {
+                if (Math.random() < level) {
+                    // Add noise character after original
+                    return char + noiseChars[Math.floor(Math.random() * noiseChars.length)];
+                }
+                return char;
+            }).join('');
+        }
+        function classifyText(text, fileType) {
+            // Content-based classification
+            const tags = [fileType.toUpperCase(), 'User Content'];
+            // Add content-based tags
+            const words = text.toLowerCase().split(/\s+/);
+            // Check for various content types
+            const checks = [
+                { terms: ['patient', 'clinical', 'diagnosis', 'treatment', 'hospital', 'doctor', 'medical', 'health'], tag: 'Medical' },
+                { terms: ['agreement', 'contract', 'party', 'legal', 'law', 'clause', 'jurisdiction'], tag: 'Legal' },
+                { terms: ['algorithm', 'function', 'variable', 'code', 'software', 'system', 'data', 'api'], tag: 'Technical' },
+                { terms: ['email', 'dear', 'sincerely', 'regards', 'hello', 'hi'], tag: 'Correspondence' },
+                { terms: ['chapter', 'section', 'paragraph', 'article', 'page'], tag: 'Document' }
+            ];
+            checks.forEach(check => {
+                if (check.terms.some(term => text.toLowerCase().includes(term))) {
+                    tags.push(check.tag);
+                }
+            });
+            // Add length-based tags
+            if (text.length < 50) {
+                tags.push('Short Text');
+            } else if (text.length > 200) {
+                tags.push('Long Text');
+            }
+            return Array.from(new Set(tags)); // Remove duplicates
+        }
+        function updatePreview(example) {
+            preview.original.textContent = example.original.length > 200 ?
+                example.original.substring(0, 200) + '...' : example.original;
+            preview.corrupted.textContent = example.corrupted.length > 200 ?
+                example.corrupted.substring(0, 200) + '...' : example.corrupted;
+            preview.target.textContent = example.target.length > 200 ?
+                example.target.substring(0, 200) + '...' : example.target;
+        }
+        function updateProgress(percent) {
+            state.progress = percent;
+            progressFill.style.width = `${percent}%`;
+            progressPercent.textContent = `${percent}%`;
+        }
+        // Export Function - Fixed for Hugging Face compatibility
+        async function exportDataset() {
+            if (state.dataset.length === 0) return;
+            exportBtn.innerHTML = '<span class="loading-spinner"></span> Creating ZIP...';
+            exportBtn.disabled = true;
+            try {
+                // Create dataset in Hugging Face format
+                const trainData = [];
+                const testData = [];
+                // Split dataset into train/test (80/20)
+                const splitIndex = Math.floor(state.dataset.length * 0.8);
+                // Prepare training data
+                for (let i = 0; i < splitIndex; i++) {
+                    trainData.push({
+                        original: state.dataset[i].original,
+                        corrupted: state.dataset[i].corrupted,
+                        target: state.dataset[i].target,
+                        tags: state.dataset[i].tags,
+                        source: state.dataset[i].source
+                    });
+                }
+                // Prepare test data
+                for (let i = splitIndex; i < state.dataset.length; i++) {
+                    testData.push({
+                        original: state.dataset[i].original,
+                        corrupted: state.dataset[i].corrupted,
+                        target: state.dataset[i].target,
+                        tags: state.dataset[i].tags,
+                        source: state.dataset[i].source
+                    });
+                }
+                // Create dataset info in correct Hugging Face format
+                const datasetInfos = {
+                    "default": {
+                        description: "Synthetic error correction dataset generated by TYPE/RIGHTER",
+                        citation: "Generated locally in browser using TYPE/RIGHTER PWA",
+                        homepage: "",
+                        license: "cc-by-4.0",
+                        features: {
+                            original: {
+                                dtype: "string",
+                                id: null,
+                                _type: "Value"
+                            },
+                            corrupted: {
+                                dtype: "string",
+                                id: null,
+                                _type: "Value"
+                            },
+                            target: {
+                                dtype: "string",
+                                id: null,
+                                _type: "Value"
+                            },
+                            tags: {
+                                feature: {
+                                    dtype: "string",
+                                    id: null,
+                                    _type: "Value"
+                                },
+                                length: -1,
+                                id: null,
+                                _type: "Sequence"
+                            },
+                            source: {
+                                dtype: "string",
+                                id: null,
+                                _type: "Value"
+                            }
+                        },
+                        post_processed: {
+                            cleaned: true,
+                            corrupted: true,
+                            error_types: {
+                                keyboard_adjacent: parseInt(sliders.adjacent.value),
+                                case_corruption: parseInt(sliders.case.value),
+                                symbol_insertion: parseInt(sliders.symbol.value),
+                                ocr_noise: parseInt(sliders.ocr.value)
+                            }
+                        },
+                        supervised_keys: {
+                            input: "corrupted",
+                            output: "target"
+                        },
+                        builder_name: "typerighter",
+                        config_name: "default",
+                        dataset_name: "typerighter_dataset",
+                        dataset_size: state.dataset.length * 100,
+                        splits: {
+                            train: {
+                                name: "train",
+                                num_bytes: trainData.length * 100,
+                                num_examples: trainData.length
+                            },
+                            test: {
+                                name: "test",
+                                num_bytes: testData.length * 100,
+                                num_examples: testData.length
+                            }
+                        },
+                        version: {
+                            version_str: "1.0.0",
+                            major: 1,
+                            minor: 0,
+                            patch: 0
+                        },
+                        download_checksums: {},
+                        download_size: state.dataset.length * 100,
+                        size_in_bytes: state.dataset.length * 200
+                    }
+                };
+                // Create README
+                const readme = `# Dataset: TYPE/RIGHTER Synthetic Error Correction
+## Dataset Summary
+This dataset was generated locally using the TYPE/RIGHTER offline-first PWA. It contains synthetic error-correction pairs for training text correction models.
+## Supported Tasks and Leaderboards
+- Text error correction
+- OCR post-processing
+- Typographical error correction
+## Languages
+English
+## Dataset Structure
+### Data Instances
+Each instance contains:
+- \`original\`: The text as it appeared in the uploaded file
+- \`corrupted\`: The procedurally "damaged" version for error detection training
+- \`target\`: The cleaned, normalized version for error correction training
+- \`tags\`: Content-based classification tags
+- \`source\`: Original file name
+### Data Fields
+- \`original\`: string - Original text
+- \`corrupted\`: string - Text with injected errors
+- \`target\`: string - Cleaned target text
+- \`tags\`: Sequence[string] - Content classification tags
+- \`source\`: string - Source file name
+### Data Splits
+- Train: ${trainData.length} examples
+- Test: ${testData.length} examples
+## Dataset Creation
+### Curation Rationale
+This dataset was created to provide synthetic data for training error correction models from user-provided documents.
+### Source Data
+The data was generated from user-uploaded documents in .txt, .csv, .md, or .jsonl formats.
+### Annotations
+Annotations were automatically generated through:
+1. Text normalization (simulated cleaning)
+2. Controlled error injection based on configurable parameters
+3. Content-based classification
+### Personal and Sensitive Information
+All processing occurs locally in the browser. No data was uploaded to any server.
+## Considerations for Using the Data
+### Social Impact of Dataset
+This dataset enables the creation of error correction models for various text domains.
+### Discussion of Biases
+The error patterns are synthetic and may not perfectly represent real-world error distributions.
+### Other Known Limitations
+- Synthetic errors may not capture all real-world error patterns
+- Limited to text-based errors (no formatting or layout errors)
+## Additional Information
+### Dataset Curators
+Generated by TYPE/RIGHTER PWA
+### Licensing Information
+Creative Commons Attribution 4.0 International (CC BY 4.0)
+### Citation Information
+\`\`\`
+@misc{typerighter2026,
+  title={TYPE/RIGHTER Synthetic Error Correction Dataset},
+  author={TYPE/RIGHTER PWA},
+  year={2026},
+  url={https://github.com/typerighter}
+}
+\`\`\`
+### Contributions
+Thanks to the user who generated this dataset using TYPE/RIGHTER.
+## Error Distribution
+- Keyboard Adjacent Errors: ${parseInt(sliders.adjacent.value)}%
+- Case Corruption: ${parseInt(sliders.case.value)}%
+- Symbol Insertion: ${parseInt(sliders.symbol.value)}%
+- OCR Line Noise: ${parseInt(sliders.ocr.value)}%
+## Generated on
+${new Date().toISOString()}
+---
+*Generated by TYPE/RIGHTER • Offline-First PWA • Privacy by Design • 2026*
+`;
+                // Create ZIP file
+                const zip = new JSZip();
+                // Create data directory structure
+                const dataFolder = zip.folder("data");
+                // Add train and test data as JSONL in data folder
+                dataFolder.file("train-00000-of-00001.jsonl", trainData.map(JSON.stringify).join('\n'));
+                dataFolder.file("test-00000-of-00001.jsonl", testData.map(JSON.stringify).join('\n'));
+                // Add metadata files at root
+                zip.file("dataset_infos.json", JSON.stringify(datasetInfos, null, 2));
+                zip.file("README.md", readme);
+                // Generate and download ZIP
+                const content = await zip.generateAsync({ type: "blob" });
+                const url = URL.createObjectURL(content);
+                const a = document.createElement('a');
+                a.href = url;
+                a.download = `typerighter_dataset_${new Date().toISOString().split('T')[0]}.zip`;
+                document.body.appendChild(a);
+                a.click();
+                document.body.removeChild(a);
+                URL.revokeObjectURL(url);
+                showToast(`Dataset exported successfully! ${state.dataset.length} examples in ZIP file.`);
+            } catch (error) {
+                console.error('Export error:', error);
+                showToast('Error exporting dataset. Please try again.');
+            } finally {
+                exportBtn.innerHTML = '<i class="fas fa-file-export"></i> Export to Hugging Face Format';
+                exportBtn.disabled = false;
+            }
+        }
+        // Utility Functions
+        function formatFileSize(bytes) {
+            if (bytes === 0) return '0 Bytes';
+            const k = 1024;
+            const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+            const i = Math.floor(Math.log(bytes) / Math.log(k));
+            return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+        }
+        function generateId() {
+            return Date.now().toString(36) + Math.random().toString(36).substring(2);
+        }
+        function sleep(ms) {
+            return new Promise(resolve => setTimeout(resolve, ms));
+        }
+        function showToast(message) {
+            toast.textContent = message;
+            toast.classList.add('show');
+            setTimeout(() => {
+                toast.classList.remove('show');
+            }, 3000);
+        }
+        // Initialize
+        updateProcessButton();
+        // Make functions available globally for inline event handlers
+        window.removeFile = removeFile;
+    </script>
+</body>
+</html>