Upload IMPLEMENTATION.md with huggingface_hub

IMPLEMENTATION.md

@@ -1,123 +1,213 @@
 # Implementation Guide
 
-This guide explains how the audio files and word-by-word timestamp data are structured in this repository, and provides implementation examples to help you build a seamless playback and highlighting experience across various major technology stacks.
+This guide explains how to integrate the Quranic Recitation Dataset into your application using the **Cloudflare Edge CDN** and **Protocol Buffer** timing data.
 
-## 🗂️ Data Structure
+## 🏗️ Architecture
+
+```
+┌─────────────┐     ┌──────────────────────────┐     ┌─────────────────┐
+│  Your App   │────▶│  Cloudflare Worker CDN   │────▶│   HuggingFace   │
+│  (Web/Mobile)│     │  recitation-cdn.         │     │   Dataset Repo  │
+│             │◀────│  mughalistian.workers.dev │◀────│                 │
+└─────────────┘     └──────────────────────────┘     └─────────────────┘
+                    • Edge caching (1 year)
+                    • Range requests (206)
+                    • CORS enabled
+                    • Slug → folder mapping
+```
+
+### Per-Surah Model
+Each surah is stored as a **single audio file** (not per-ayah). To play a specific ayah:
+1. Load the surah `.opus` file
+2. Parse the `.pb` timing data
+3. Seek the audio player to the ayah's first word `timestamp_from`
+
+This dramatically reduces the number of HTTP requests (from ~6,236 per reciter down to 114) while maintaining word-level precision.
 
-The repository uses a highly structured directory format to make programmatic access to any verse's audio and timing data incredibly simple.
+---
+
+## 🗂️ Data Structure
 
-### Directory Layout
-Files are organized in the following hierarchy:
-`/{reciter_name}/{surah_index}/{surah_index}{verse_index}.[opus|json]`
+### CDN URL Format
+```
+https://recitation-cdn.mughalistian.workers.dev/{slug}/{surah_number}.{opus|pb}
+```
 
 Where:
-- `{reciter_name}`: The slugged directory name of the reciter (e.g., `abdul-basit-abdul-samad-murattal-hafs-950`).
-- `{surah_index}`: The Surah number, strictly 3-digit zero-padded (e.g., `001` for Al-Fatihah, `114` for An-Nas).
-- `{verse_index}`: The Verse number, strictly 3-digit zero-padded. Combined, `{surah_index}{verse_index}` creates a 6-digit filename prefix (e.g., `001001` or `114006`).
-
-**Example Paths**:
-- 🎵 **Audio**: `https://cdn.jsdelivr.net/gh/zaibihsn/recitation-all@main/abdul-basit-abdul-samad-murattal-hafs-950/001/001001.opus`
-- ⏱️ **Metadata**: `https://cdn.jsdelivr.net/gh/zaibihsn/recitation-all@main/abdul-basit-abdul-samad-murattal-hafs-950/001/001001.json`
-
-### JSON Metadata Formats
-When fetching the `.json` files, you will encounter one of two primary formats depending on the data source. Your parsing logic should seamlessly handle both.
-
-**Format A (Flat Array)**
-A direct array of timestamps. Each inner array element represents a specific word.
-```json
-[
-  [0, 1, 0, 920], 
-  [1, 2, 1080, 1440], 
-  [2, 3, 2120, 2440]
-]
+- `{slug}` — URL-friendly reciter identifier (see slug map in README.md)
+- `{surah_number}` — 3-digit zero-padded surah number (e.g., `001`, `114`)
+
+### Example URLs
+```bash
+# Audio: Mishari Rashid Al-Afasy, Surah Al-Baqarah
+https://recitation-cdn.mughalistian.workers.dev/mishari-rashid-al-afasy-murattal-hafs/002.opus
+
+# Timing: Same reciter, same surah
+https://recitation-cdn.mughalistian.workers.dev/mishari-rashid-al-afasy-murattal-hafs/002.pb
+```
+
+### Direct HuggingFace Fallback
+If the CDN is unreachable, fall back to the raw HuggingFace URL:
 ```
-*Structure: `[current_word_index, next_word_index, start_time_ms, end_time_ms]`*
-
-**Format B (Detailed Object)**
-An object containing verse metadata along with an array of word segments.
-```json
-{
-  "verse_key": "1:1",
-  "timestamp_from": 0,
-  "timestamp_to": 8037,
-  "segments": [
-    [1, 0, 579], 
-    [2, 579, 1331]
-  ]
+https://huggingface.co/datasets/zaibihassan/Quranic-Recitation-Data/resolve/main/{Folder Name}/{Surah}/{File}
+```
+
+> **Note:** The folder names contain spaces and special characters. The CDN handles slug-to-folder mapping automatically.
+
+---
+
+## ⏱️ Protocol Buffer Schema
+
+The `.pb` timing files use this schema:
+
+```protobuf
+syntax = "proto3";
+package recitation;
+
+message WordSegment {
+  int32 word_index_0_based = 1;
+  int32 word_index_1_based = 2;
+  int32 timestamp_from = 3;      // ms from start of surah audio
+  int32 timestamp_to = 4;        // ms from start of surah audio
+}
+
+message VerseSegments {
+  repeated WordSegment segments = 1;
+}
+
+message SurahTimestamps {
+  map<string, VerseSegments> verses = 1;  // key = "surah:ayah" e.g. "1:1"
 }
 ```
-*Structure within `segments`: `[word_index, start_time_ms, end_time_ms]`*
+
+### Key Concept
+Timestamps are **relative to the start of the surah audio**. To play ayah 5 of surah 2:
+```
+seekPosition = verses["2:5"].segments[0].timestamp_from  // in milliseconds
+```
 
 ---
 
 ## 💻 Tech Stack Implementations
 
-The core concept across all frameworks is:
-1. Fetch the JSON timestamp array for a verse.
-2. Load the Audio track for that verse.
-3. Listen to the audio stream's current position (time).
-4. Given the current time in milliseconds, loop over the timestamps and find the word where `start_time <= current_time <= end_time`.
-5. Apply a "highlighted" style/class to that word index.
+The core pattern across all frameworks:
+1. Fetch the `.pb` timing data for the surah
+2. Decode it using a protobuf library
+3. Load the `.opus` audio file
+4. Listen to playback position (in milliseconds)
+5. Find the word where `timestamp_from <= currentTimeMs <= timestamp_to`
+6. Apply a highlighted style to that word
+
+### 1. JavaScript / TypeScript (Web)
 
-### 1. Vanilla JavaScript
 ```javascript
-const audio = new Audio("https://cdn.jsdelivr.net/gh/zaibihsn/recitation-all@main/abdul-basit.../001/001001.opus");
-let timestamps = []; // E.g., [[0,1,0,920], [1,2,1080,1440]]
-let activeWordIndex = -1;
+import protobuf from 'protobufjs';
 
-audio.addEventListener("timeupdate", () => {
-    const currentTimeMs = audio.currentTime * 1000;
-    
-    // Find matching word
-    const match = timestamps.find(t => {
-        // Handle both format variants appropriately (Format A in this example)
-        return currentTimeMs >= t[2] && currentTimeMs <= t[3];
-    });
+const CDN_BASE = 'https://recitation-cdn.mughalistian.workers.dev';
 
-    if (match) {
-        const newWordIndex = match[0];
-        if (activeWordIndex !== newWordIndex) {
-            activeWordIndex = newWordIndex;
-            highlightWordInDOM(activeWordIndex); // Your custom function
-        }
-    }
+async function loadSurahData(slug, surahNum) {
+  const padded = String(surahNum).padStart(3, '0');
+  
+  // Fetch protobuf timing data
+  const pbResponse = await fetch(`${CDN_BASE}/${slug}/${padded}.pb`);
+  const pbBuffer = await pbResponse.arrayBuffer();
+  
+  // Decode using your compiled protobuf schema
+  const root = await protobuf.load('recitation.proto');
+  const SurahTimestamps = root.lookupType('recitation.SurahTimestamps');
+  const timingData = SurahTimestamps.decode(new Uint8Array(pbBuffer));
+  
+  return timingData;
+}
+
+// Audio playback with word highlighting
+const audio = new Audio(`${CDN_BASE}/mishari-rashid-al-afasy-murattal-hafs/001.opus`);
+const timings = await loadSurahData('mishari-rashid-al-afasy-murattal-hafs', 1);
+
+let activeWordIndex = -1;
+
+audio.addEventListener('timeupdate', () => {
+  const currentTimeMs = audio.currentTime * 1000;
+  const verseTimings = timings.verses['1:1']; // Current verse
+  
+  if (!verseTimings) return;
+  
+  const match = verseTimings.segments.find(
+    seg => currentTimeMs >= seg.timestampFrom && currentTimeMs <= seg.timestampTo
+  );
+  
+  if (match && match.wordIndex0Based !== activeWordIndex) {
+    activeWordIndex = match.wordIndex0Based;
+    highlightWord(activeWordIndex); // Your UI function
+  }
 });
 
+// Seek to a specific ayah
+function seekToAyah(surah, ayah) {
+  const key = `${surah}:${ayah}`;
+  const verse = timings.verses[key];
+  if (verse && verse.segments.length > 0) {
+    audio.currentTime = verse.segments[0].timestampFrom / 1000;
+    audio.play();
+  }
+}
+
 audio.play();
 ```
 
 ### 2. React.js
+
 ```tsx
 import React, { useState, useEffect, useRef } from 'react';
 
-const QuranPlayer = ({ audioUrl, timestamps, words }) => {
-  const audioRef = useRef(null);
+const CDN_BASE = 'https://recitation-cdn.mughalistian.workers.dev';
+
+const QuranPlayer = ({ slug, surahNum, words, verseKey }) => {
+  const audioRef = useRef<HTMLAudioElement>(null);
   const [activeWordIndex, setActiveWordIndex] = useState(-1);
+  const [timings, setTimings] = useState(null);
+
+  const padded = String(surahNum).padStart(3, '0');
+
+  useEffect(() => {
+    // Load protobuf timing data on mount
+    fetch(`${CDN_BASE}/${slug}/${padded}.pb`)
+      .then(res => res.arrayBuffer())
+      .then(buf => {
+        // Decode protobuf (using your compiled schema)
+        const decoded = SurahTimestamps.decode(new Uint8Array(buf));
+        setTimings(decoded);
+      });
+  }, [slug, surahNum]);
 
   const handleTimeUpdate = () => {
-    if (!audioRef.current || !timestamps) return;
-    
+    if (!audioRef.current || !timings) return;
     const currentTimeMs = audioRef.current.currentTime * 1000;
-    
-    // Assume Format A timestamps: [wordIdx, nextIdx, startMs, endMs]
-    const match = timestamps.find(
-      (t) => currentTimeMs >= t[2] && currentTimeMs <= t[3]
+    const verse = timings.verses[verseKey];
+    if (!verse) return;
+
+    const match = verse.segments.find(
+      s => currentTimeMs >= s.timestampFrom && currentTimeMs <= s.timestampTo
     );
 
-    if (match && match[0] !== activeWordIndex) {
-      setActiveWordIndex(match[0]);
-    } else if (!match && activeWordIndex !== -1) {
-      setActiveWordIndex(-1); // Resets when pause/delay happens
-    }
+    setActiveWordIndex(match ? match.wordIndex0Based : -1);
   };
 
   return (
     <div>
-      <audio ref={audioRef} src={audioUrl} onTimeUpdate={handleTimeUpdate} controls />
-      <div className="quran-text">
-        {words.map((word, index) => (
-          <span key={index} className={index === activeWordIndex ? "text-blue-500 font-bold" : "text-black"}>
-            {word}
+      <audio
+        ref={audioRef}
+        src={`${CDN_BASE}/${slug}/${padded}.opus`}
+        onTimeUpdate={handleTimeUpdate}
+        controls
+      />
+      <div className="quran-text" dir="rtl">
+        {words.map((word, i) => (
+          <span
+            key={i}
+            className={i === activeWordIndex ? 'text-blue-500 font-bold' : ''}
+          >
+            {word}{' '}
           </span>
         ))}
       </div>
@@ -126,96 +216,89 @@ const QuranPlayer = ({ audioUrl, timestamps, words }) => {
 };
 ```
 
-### 3. Vue 3 (Composition API)
-```vue
-<script setup>
-import { ref, onMounted } from 'vue';
+### 3. Flutter (Dart)
 
-const audioUrl = ref("https://cdn.jsdelivr.net/gh/zaibihsn/recitation-all@main/...opus");
-const activeWordIndex = ref(-1);
-// Assuming array of Format A timestamps loaded here
-const timestamps = ref([[0, 1, 0, 920], [1, 2, 1080, 1440]]);
-const words = ref(["Bismillah", "ir-Rahman", "ir-Raheem"]); 
-
-const onTimeUpdate = (event) => {
-  const currentTimeMs = event.target.currentTime * 1000;
-  
-  const match = timestamps.value.find(t => currentTimeMs >= t[2] && currentTimeMs <= t[3]);
-  activeWordIndex.value = match ? match[0] : -1;
-};
-</script>
-
-<template>
-  <div>
-    <audio :src="audioUrl" @timeupdate="onTimeUpdate" controls />
-    <p>
-      <span 
-        v-for="(word, i) in words" 
-        :key="i"
-        :class="{ 'highlighted-word': i === activeWordIndex }"
-      >
-        {{ word }}
-      </span>
-    </p>
-  </div>
-</template>
-
-<style scoped>
-.highlighted-word { color: #3b82f6; font-weight: bold; }
-</style>
-```
-
-### 4. Flutter (Dart)
-Using the popular `just_audio` package.
+Using `just_audio` and the `protobuf` package:
 
 ```dart
 import 'package:flutter/material.dart';
 import 'package:just_audio/just_audio.dart';
+import 'package:http/http.dart' as http;
+import 'recitation.pb.dart'; // Generated from recitation.proto
 
-class QuranPlayerWidget extends StatefulWidget {
-  final String audioUrl;
-  final List<dynamic> timestamps;  // Parsed JSON
-  final List<String> words; 
+const cdnBase = 'https://recitation-cdn.mughalistian.workers.dev';
 
-  QuranPlayerWidget({required this.audioUrl, required this.timestamps, required this.words});
+class QuranPlayerWidget extends StatefulWidget {
+  final String slug;
+  final int surahNum;
+  final List<String> words;
+  final String verseKey; // e.g., "1:1"
+
+  const QuranPlayerWidget({
+    required this.slug,
+    required this.surahNum,
+    required this.words,
+    required this.verseKey,
+  });
 
   @override
-  _QuranPlayerWidgetState createState() => _QuranPlayerWidgetState();
+  State<QuranPlayerWidget> createState() => _QuranPlayerState();
 }
 
-class _QuranPlayerWidgetState extends State<QuranPlayerWidget> {
+class _QuranPlayerState extends State<QuranPlayerWidget> {
   final AudioPlayer _player = AudioPlayer();
+  SurahTimestamps? _timings;
   int _activeWordIndex = -1;
 
   @override
   void initState() {
     super.initState();
-    _initPlayer();
+    _init();
   }
 
-  Future<void> _initPlayer() async {
-    await _player.setUrl(widget.audioUrl);
+  Future<void> _init() async {
+    final padded = widget.surahNum.toString().padLeft(3, '0');
     
+    // Load protobuf timing data
+    final pbUrl = '$cdnBase/${widget.slug}/$padded.pb';
+    final response = await http.get(Uri.parse(pbUrl));
+    _timings = SurahTimestamps.fromBuffer(response.bodyBytes);
+
+    // Load audio (supports range requests for seeking)
+    final audioUrl = '$cdnBase/${widget.slug}/$padded.opus';
+    await _player.setUrl(audioUrl);
+
+    // Track position for word highlighting
     _player.positionStream.listen((position) {
       final currentTimeMs = position.inMilliseconds;
-      int matchIndex = -1;
+      final verse = _timings?.verses[widget.verseKey];
+      if (verse == null) return;
 
-      for (var t in widget.timestamps) {
-        // Format A check: [wordIndex, nextIndex, start, end]
-        if (currentTimeMs >= t[2] && currentTimeMs <= t[3]) {
-          matchIndex = t[0];
+      int matchIndex = -1;
+      for (final seg in verse.segments) {
+        if (currentTimeMs >= seg.timestampFrom && 
+            currentTimeMs <= seg.timestampTo) {
+          matchIndex = seg.wordIndex0Based;
           break;
         }
       }
 
       if (_activeWordIndex != matchIndex) {
-        setState(() {
-          _activeWordIndex = matchIndex;
-        });
+        setState(() => _activeWordIndex = matchIndex);
       }
     });
   }
 
+  /// Seek to a specific ayah within the loaded surah
+  void seekToAyah(String verseKey) {
+    final verse = _timings?.verses[verseKey];
+    if (verse != null && verse.segments.isNotEmpty) {
+      final seekMs = verse.segments.first.timestampFrom;
+      _player.seek(Duration(milliseconds: seekMs));
+      _player.play();
+    }
+  }
+
   @override
   void dispose() {
     _player.dispose();
@@ -225,13 +308,15 @@ class _QuranPlayerWidgetState extends State<QuranPlayerWidget> {
   @override
   Widget build(BuildContext context) {
     return Wrap(
+      textDirection: TextDirection.rtl,
       children: widget.words.asMap().entries.map((entry) {
-        bool isActive = entry.key == _activeWordIndex;
+        final isActive = entry.key == _activeWordIndex;
         return Text(
-          entry.value + " ",
+          '${entry.value} ',
           style: TextStyle(
             color: isActive ? Colors.blue : Colors.black,
             fontWeight: isActive ? FontWeight.bold : FontWeight.normal,
+            fontSize: 28,
           ),
         );
       }).toList(),
@@ -240,27 +325,86 @@ class _QuranPlayerWidgetState extends State<QuranPlayerWidget> {
 }
 ```
 
+### 4. Swift (iOS)
+
+```swift
+import AVFoundation
+
+let cdnBase = "https://recitation-cdn.mughalistian.workers.dev"
+
+class QuranPlayer {
+    var player: AVPlayer?
+    var timings: SurahTimestamps?  // Generated from protobuf
+    var activeWordIndex: Int = -1
+    
+    func loadSurah(slug: String, surahNum: Int) async {
+        let padded = String(format: "%03d", surahNum)
+        
+        // Load audio with range request support
+        let audioURL = URL(string: "\(cdnBase)/\(slug)/\(padded).opus")!
+        player = AVPlayer(url: audioURL)
+        
+        // Load protobuf timing
+        let pbURL = URL(string: "\(cdnBase)/\(slug)/\(padded).pb")!
+        let (data, _) = try! await URLSession.shared.data(from: pbURL)
+        timings = try! SurahTimestamps(serializedBytes: data)
+        
+        // Observe playback position
+        player?.addPeriodicTimeObserver(
+            forInterval: CMTime(value: 1, timescale: 30),
+            queue: .main
+        ) { [weak self] time in
+            self?.updateHighlight(currentTimeMs: Int(time.seconds * 1000))
+        }
+    }
+    
+    func seekToAyah(_ verseKey: String) {
+        guard let verse = timings?.verses[verseKey],
+              let firstSeg = verse.segments.first else { return }
+        let seekTime = CMTime(value: Int64(firstSeg.timestampFrom), timescale: 1000)
+        player?.seek(to: seekTime)
+        player?.play()
+    }
+    
+    private func updateHighlight(currentTimeMs: Int) {
+        // Find active word in current verse's segments
+        guard let verse = timings?.verses["1:1"] else { return }
+        
+        for seg in verse.segments {
+            if currentTimeMs >= seg.timestampFrom && currentTimeMs <= seg.timestampTo {
+                activeWordIndex = Int(seg.wordIndex0Based)
+                return
+            }
+        }
+    }
+}
+```
+
 ---
 
-## 🤖 AI Prompt Generator 
+## 🤖 AI Prompt Template
 
-If you are using ChatGPT, Claude, GitHub Copilot, or Cursor to build your application, you can copy and paste the prompt below to get an instant, perfectly structured word-by-word active highlighting system tailored to this repository's structure.
+Copy this prompt into ChatGPT, Claude, or Copilot to scaffold your integration:
 
-> **Copy this Prompt:**
+> I am building a Quran application with **word-by-word audio highlighting** (karaoke style).
+> 
+> **CDN Base URL:** `https://recitation-cdn.mughalistian.workers.dev`
+> **URL Format:** `{CDN_BASE}/{reciter-slug}/{surah_padded}.opus` (audio) and `.pb` (timing)
+> 
+> The timing data is a Protocol Buffer file using this schema:
+> ```protobuf
+> message WordSegment { int32 word_index_0_based=1; int32 word_index_1_based=2; int32 timestamp_from=3; int32 timestamp_to=4; }
+> message VerseSegments { repeated WordSegment segments=1; }
+> message SurahTimestamps { map<string, VerseSegments> verses=1; }
+> ```
 > 
-> "I am building a Quran application where I need to play audio for a Quran verse and highlight the textual Arabic words as they are being spoken (karaoke style). 
+> Each surah is a **single audio file**. Timestamps are in **milliseconds from the start of the surah audio**. The `.pb` file contains all verses of that surah.
 > 
-> The verse audio is hosted via CDN: `https://cdn.jsdelivr.net/gh/zaibihsn/recitation-all@main/{reciter_name}/{surah_padded}/{surah_padded}{verse_padded}.opus`. (E.g., Surah 1 Verse 1 for reciter 'abdul-basit-abdul-samad-murattal-hafs-950' is `.../001/001001.opus`).
+> To play a specific ayah, seek the audio player to `verses["surah:ayah"].segments[0].timestamp_from` ms.
 > 
-> The timestamp file is located at the exact same path but with a `.json` extension instead (e.g. `.../001/001001.json`). 
-> The timestamp JSON could come in one of two formats:
-> 1. A flat array of arrays: `[[word_index, next_word_index, start_time_ms, end_time_ms]]`.
-> 2. A detailed object: `{"segments": [[word_index, start_time_ms, end_time_ms]]}`.
->
-> Please write the UI and logic using **[INSERT YOUR STACK/FRAMEWORK HERE]**.
-> Requirements:
-> 1. Fetch and parse both timestamp formats safely.
-> 2. Initialize an audio player streaming the `.opus` file.
-> 3. Track the current playback time of the audio stream in milliseconds.
-> 4. Use the timestamp interval logic (`start_time <= current_time <= end_time`) to determine the active active word index.
-> 5. Map over a list of placeholder strings (simulating Arabic words) and visually highlight the word that corresponds to the active word index."
+> Please write the complete implementation using **[YOUR FRAMEWORK]**:
+> 1. Fetch and decode the `.pb` file
+> 2. Stream the `.opus` audio with seeking support
+> 3. Track playback position in milliseconds
+> 4. Highlight the active word using `timestamp_from <= currentMs <= timestamp_to`
+> 5. Support seeking to any ayah within the surah