Upload 24 files

backend/.env

@@ -0,0 +1,3 @@
+PORT=8080
+API_KEY="AIzaSyAUuxggsn9uNOEHDW4NiKpyrfCUpt8vLi4"
+ADMIN_PASSWORD="Hello"

backend/jsconfig.json

@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@/backend/*": ["./*"]
+    }
+  }
+}

backend/package.json

@@ -0,0 +1,12 @@
+{
+  "dependencies": {
+    "@google/genai": "^1.35.0",
+    "@google/generative-ai": "^0.24.1",
+    "axios": "^1.13.2",
+    "cors": "^2.8.5",
+    "dotenv": "^17.2.3",
+    "express": "^5.2.1",
+    "firebase-admin": "^13.6.0",
+    "fluent-ffmpeg": "^2.1.3"
+  }
+}

backend/run.bat

@@ -0,0 +1 @@
+npx tsx --tsconfig jsconfig.json server.js

backend/server.js

@@ -0,0 +1,244 @@
+
+import express from 'express';
+import cors from 'cors';
+import dotenv from 'dotenv';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs';
+import path from 'path';
+import { AIService } from '@/backend/services/ai';
+import { AuthService } from '@/backend/services/authService';
+import { CreditService } from '@/backend/services/creditService';
+import { AdminService } from '@/backend/services/adminService';
+
+const execPromise = promisify(exec);
+dotenv.config();
+
+const app = express();
+
+// CRITICAL FIX: Increased limits to 100mb to allow processing of long audio/video base64 data
+app.use(express.json({ limit: '100mb' }));
+app.use(express.urlencoded({ limit: '100mb', extended: true }));
+
+app.use(cors());
+
+const apiRouter = express.Router();
+
+apiRouter.post('/download', async (req, res) => {
+    const { url, quality, platform, sessionId, creditCost } = req.body;
+    
+    try {
+        const eligibility = await CreditService.checkEligibility(sessionId, null, 'downloader', false, creditCost);
+        
+        const timestamp = Date.now();
+        const fileBaseName = `tm_dl_${timestamp}`;
+        const outputDir = '/tmp';
+        
+        // Determine file extension and format string
+        const extension = quality === 'audio' ? 'mp3' : 'mp4';
+        const outputPath = path.join(outputDir, `${fileBaseName}.${extension}`);
+        
+        let formatStr = "";
+        if (quality === 'audio') {
+            formatStr = "-f 'ba' -x --audio-format mp3";
+        } else {
+            const qMap = {
+                '360p': 'bestvideo[height<=360]+bestaudio/best[height<=360]',
+                '720p': 'bestvideo[height<=720]+bestaudio/best[height<=720]',
+                '1080p': 'bestvideo[height<=1080]+bestaudio/best[height<=1080]'
+            };
+            const format = qMap[quality] || qMap['720p'];
+            formatStr = `-f "${format}" --merge-output-format mp4`;
+        }
+
+        const tiktokArgs = platform === 'tiktok' ? '--referer "https://www.tiktok.com/"' : '';
+        
+        // CRITICAL FIX: Added --js-runtime node to fix JS engine missing error.
+        // Added --no-warnings and --no-check-certificate for better reliability on Cloud Run.
+        const command = `yt-dlp --no-playlist --no-warnings --no-check-certificate --js-runtime node ${formatStr} ${tiktokArgs} -o "${outputPath}" "${url.trim()}"`;
+        
+        console.log(`[DOWNLOADER] Executing: ${command}`);
+        
+        try {
+            await execPromise(command);
+        } catch (execErr) {
+            console.error("[DL-EXEC-FAIL]", execErr.stderr || execErr.message);
+            // Even if warnings are printed to stderr, check if file exists before crashing
+            if (!fs.existsSync(outputPath)) {
+                throw new Error(`Engine Error: ${execErr.stderr || execErr.message}`);
+            }
+        }
+
+        // Verify file existence explicitly
+        if (!fs.existsSync(outputPath)) {
+            throw new Error("Download engine failed. File not generated.");
+        }
+        
+        await CreditService.commitDeduction(eligibility);
+
+        res.download(outputPath, `${fileBaseName}.${extension}`, (err) => {
+            if (err) console.error("Stream Error:", err);
+            try {
+                if (fs.existsSync(outputPath)) fs.unlinkSync(outputPath);
+            } catch (e) { console.error("Cleanup Error:", e); }
+        });
+
+    } catch (error) {
+        console.error("[DOWNLOAD-ERROR]", error.message);
+        res.status(500).json({ error: error.message });
+    }
+});
+
+const handleAiRequest = async (req, res, toolKey, taskFn) => {
+    const sessionId = req.headers['x-session-id'];
+    const guestId = req.headers['x-guest-id'];
+    const { isOwnApi, customApiKey, creditCost } = req.body;
+
+    try {
+        const eligibility = await CreditService.checkEligibility(sessionId, guestId, toolKey, isOwnApi, creditCost);
+        const apiKey = isOwnApi ? (customApiKey || process.env.API_KEY) : process.env.API_KEY;
+        const result = await taskFn(apiKey, isOwnApi);
+        await CreditService.commitDeduction(eligibility);
+        res.json(result);
+    } catch (error) {
+        console.error(`[BACKEND-API] Error in ${toolKey}:`, error.message);
+        res.status(error.message.includes('REACHED') || error.message.includes('INSUFFICIENT') ? 403 : 500).json({ 
+            error: error.message 
+        });
+    }
+};
+
+apiRouter.post('/transcribe', (req, res) => {
+    handleAiRequest(req, res, 'count_transcript', async (key, isOwn) => {
+        return { text: await AIService.transcribe(req.body.media, req.body.mimeType, key, isOwn) };
+    });
+});
+
+apiRouter.post('/recap', (req, res) => {
+    handleAiRequest(req, res, 'count_transcript', async (key, isOwn) => {
+        return { recap: await AIService.recap(req.body.media, req.body.mimeType, req.body.targetLanguage, key, isOwn) };
+    });
+});
+
+apiRouter.post('/book-recap', (req, res) => {
+    handleAiRequest(req, res, 'count_translate', async (key, isOwn) => {
+        return { recap: await AIService.bookRecap(req.body.media, req.body.mimeType, req.body.targetLanguage, key, isOwn) };
+    });
+});
+
+apiRouter.post('/comic-translate', (req, res) => {
+    handleAiRequest(req, res, 'count_translate', async (key, isOwn) => {
+        return { pdfData: await AIService.comicTranslate(req.body.media, req.body.mimeType, req.body.targetLanguage, key, isOwn) };
+    });
+});
+
+apiRouter.post('/translate', (req, res) => {
+    handleAiRequest(req, res, 'count_translate', async (key, isOwn) => {
+        return await AIService.translate(req.body.text, req.body.targetLanguage, req.body.options, key, isOwn);
+    });
+});
+
+apiRouter.post('/srt-translate', (req, res) => {
+    handleAiRequest(req, res, 'count_srt_translate', async (key, isOwn) => {
+        return { srt: await AIService.srtTranslate(req.body.srtContent, req.body.sourceLanguage, req.body.targetLanguage, key, isOwn) };
+    });
+});
+
+apiRouter.post('/tts', (req, res) => {
+    handleAiRequest(req, res, 'count_tts', async (key, isOwn) => {
+        return { audioData: await AIService.tts(req.body.text, req.body.voiceId, req.body.tone, key, isOwn) };
+    });
+});
+
+apiRouter.post('/subtitle', (req, res) => {
+    req.setTimeout(1200000); 
+    handleAiRequest(req, res, 'count_subtitle', async (key, isOwn) => {
+        return await AIService.subtitle(
+            req.body.media, 
+            req.body.mimeType, 
+            req.body.script, 
+            key, 
+            isOwn, 
+            req.body.sourceLanguage,
+            req.body.startOffsetMs || 0,
+            req.body.lastScriptIndex || 0
+        );
+    });
+});
+
+apiRouter.post('/content-creator', (req, res) => {
+    handleAiRequest(req, res, 'count_creator_text', async (key, isOwn) => {
+        const script = await AIService.contentCreator(
+            req.body.topic, req.body.category, req.body.subTopics, 
+            req.body.contentType, req.body.creatorGender, req.body.targetLanguage, key, isOwn
+        );
+        let imageUrl = null;
+        if (req.body.withImage) {
+            try { imageUrl = await AIService.generateImage(req.body.topic, key, isOwn); } catch(e) {}
+        }
+        return { script, imageUrl };
+    });
+});
+
+apiRouter.post('/secure/save-key', async (req, res) => {
+    try {
+        const { sessionId, apiKey } = req.body;
+        res.json(await AuthService.saveCustomKey(sessionId, apiKey));
+    } catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+apiRouter.post('/secure/update-session', async (req, res) => {
+    try {
+        const { userId, newSessionId } = req.body;
+        res.json(await AuthService.updateActiveSession(userId, newSessionId));
+    } catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+apiRouter.post('/admin/verify', async (req, res) => {
+    const { adminPassword } = req.body;
+    if (adminPassword === process.env.ADMIN_PASSWORD) res.json({ success: true });
+    else res.status(403).json({ error: "Unauthorized" });
+});
+
+apiRouter.post('/admin/update-settings', async (req, res) => {
+    const { adminPassword, settings } = req.body;
+    if (adminPassword !== process.env.ADMIN_PASSWORD) return res.status(403).json({ error: "Denied" });
+    try { res.json(await AdminService.updateSettings(settings)); } catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+apiRouter.post('/admin/add-user', async (req, res) => {
+    const { adminPassword, userData, referrerCode } = req.body;
+    if (adminPassword !== process.env.ADMIN_PASSWORD) return res.status(403).json({ error: "Denied" });
+    try { res.json(await AdminService.addUser(userData, referrerCode)); } catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+apiRouter.post('/admin/reactivate-user', async (req, res) => {
+    const { adminPassword, nodeKey, userClass, credits } = req.body;
+    if (adminPassword !== process.env.ADMIN_PASSWORD) return res.status(403).json({ error: "Denied" });
+    try { res.json(await AdminService.reactivateUser(nodeKey, userClass, credits)); } catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+apiRouter.post('/admin/update-user-class', async (req, res) => {
+    const { adminPassword, nodeKey, userClass, credits } = req.body;
+    if (adminPassword !== process.env.ADMIN_PASSWORD) return res.status(403).json({ error: "Denied" });
+    try { res.json(await AdminService.updateUserClass(nodeKey, userClass, credits)); } catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+apiRouter.post('/admin/topup-credits', async (req, res) => {
+    const { adminPassword, sessionId, amount } = req.body;
+    if (adminPassword !== process.env.ADMIN_PASSWORD) return res.status(403).json({ error: "Denied" });
+    try { res.json(await AdminService.topUpCredits(sessionId, amount)); } catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+apiRouter.post('/admin/delete-user', async (req, res) => {
+    const { adminPassword, nodeKey } = req.body;
+    if (adminPassword !== process.env.ADMIN_PASSWORD) return res.status(403).json({ error: "Denied" });
+    try { res.json(await AdminService.deleteUser(nodeKey)); } catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+app.use('/', apiRouter);
+
+const PORT = process.env.PORT || 8080;
+app.listen(PORT, () => {
+    console.log(`🚀 Master Backend Engine running on port ${PORT}`);
+});

backend/service-account.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "klingwatermark",
+  "private_key_id": "8ac9baff7cdb9605fd3c390740659f5edae75bbe",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDmZlD5OF0UhHst\ntgf8gDuQ9D2OurWowM9s9OutRoEby+XJ6ndRZhOyCzH5iFfMqVlWBes0Dr/zSMcE\nrP09DH+bntAUDZJ4iIhV2ODLE+m/hSNdM74uSUt8xlTXpZlpBFbX77VzgNlB+iTV\nkJ3edzrFvAnzbZcXrWA8iYA10yotvCKEk1sPm3h4SrsPS1DFgywCMtkgnLAjv47d\nqW8klGuzMVKGWysBlG/THzXmxr1CzxUdiSgbMIASLLS67nBNmTwd3doAfqF7HWvY\n3e8+Iw3qKNJw7o5QAYvLr2kfRJ68sCCI8ib2+OEhLdxDru7lRUllzlFt/+CyYkaX\nM1JS+mUDAgMBAAECggEAINtCfOf+zig+cLxe0zFuTTOne61ArrogWodq/KDrVI11\nTaA0N9V4xZE3JUC+VJ9p8AyUCC56TTV5vD73NjeMEyNIxTNSSgIefy+Yjx1d3kQc\nUPRKEMu/CiI2gzJIeGN4Bv9WPwyG7xO/IP2opcsXBI/WU3Kzc1r0OG3bbNGaWD8Q\n3looKPcvVsgxceDaH3zs0+tEtP1JQ2YKlXZVnpr1lFUExkNhLPOhva+H1aPgryRG\nu380OTTnnceXMfwlYXiXSBZNLA7LToQR856k3Wbtj75Zr8+7f/y6kxQCcwYIjDUF\nfxDy0QZpM6MAMHrGc4Xzy3MZBYoWTe4ZSEttGtGasQKBgQD2hIldQxL9D5OBLmxl\nOXGJZnZaxd0gXpCCe360bTUSFUrrExznDwIkimJQZK4y5UXh30nkULWdh4KjjwIA\nAUVWSKPLGWwDl2AH9f0b3JTpHF5RIkyloGBowXrFEK9tcX5mlFxgOWqdtJaF7zes\npQJdvZ736JVxMepwcPPVSfasZQKBgQDvQxCpLv7qBDO9vRboeFGA1soeCg2syU/B\nEhql+4+p1pV1qJjyQd/1BRngRZGaAV1uokhBwLKhmvTfqNit8HUvYzw3DG99sju0\n3RwWYRFgf6xV3Cb+xW09/4/P9udE2DeKnuSAnoPZMvRA7JI9wCsNzZPA7wGx8/Bv\nXbk7dBhxRwKBgQD0VgdEjd+7PX4JEzdS2S3Ebu8uJ2F13OTEv5ylPnzUkJAyET6b\ncc/A4fxyDGhwf7jVGJjHmIt6OL7uWCc2VAwialsWSfs6UAZZvaICxI4/wuNk7Wck\n3qHQEr0Zp+EIy+3pxHEO2rnm2AA9fg4jq2V9/h0bQMcma8AfdITpSacZ1QKBgAki\nYFJ1Lto0St1liKhbX5Exogm/jIIaNWdDj6zii7uKK66QPzaQeUJbbX94aHSetLhy\njZulBazRw6N+SLdrRK4IddYMLX14/nqLLnVUQ1uRxDyK6Ro041TImu7vmCiysHwk\nUMjwRExYe6a24WZmHb6rKIbnGQN4MqetxlKUvhIlAoGAH7cTswMWvGMkrk+g87PJ\n+jsiLixAXeQLf0Je+dYs7gZGDcyXDpxcFe66bIv90en35N4aYQdiqdJu+NOoLYPM\nvAhtWg1qy9puzpf6U719jODYduE0CNIxBncj4RUlbj9PK1JRvvPvKVq3GFuGbz6C\nex5i3ryBmIdFq2d69rh43Ew=\n-----END PRIVATE KEY-----\n",
+  "client_email": "firebase-adminsdk-fbsvc@klingwatermark.iam.gserviceaccount.com",
+  "client_id": "104214968547846116587",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/firebase-adminsdk-fbsvc%40klingwatermark.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}

backend/services/adminService.js

@@ -0,0 +1,64 @@
+
+import { db } from '@/backend/services/firebase';
+
+export const AdminService = {
+    async updateSettings(settings) {
+        await db.ref('system/settings').update(settings);
+        return { success: true };
+    },
+
+    async addUser(userData, referrerCode) {
+        const membershipId = userData.Active_Session_ID;
+        
+        const userPayload = { 
+            ...userData, 
+            Login_Key: membershipId,
+            Active_Session_ID: membershipId,
+            Referrer: referrerCode || "NONE", 
+            Status: 'ACTIVE', 
+            Usage: {}, 
+            Last_Usage_Date: new Date().toISOString().split('T')[0] 
+        };
+        
+        await db.ref(`users/${Date.now()}`).set(userPayload);
+        return { success: true };
+    },
+
+    async reactivateUser(nodeKey, userClass, credits) {
+        const today = new Date();
+        const expDate = new Date(today.getTime() + 30 * 86400000).toISOString().split('T')[0];
+        
+        const updates = {
+            Class: userClass,
+            Credits: credits,
+            Expired_Date: expDate,
+            Status: 'ACTIVE'
+        };
+        
+        await db.ref(`users/${nodeKey}`).update(updates);
+        return { success: true };
+    },
+
+    async updateUserClass(nodeKey, userClass, credits) {
+        const updates = {
+            Class: userClass,
+            Credits: credits
+        };
+        await db.ref(`users/${nodeKey}`).update(updates);
+        return { success: true };
+    },
+
+    async topUpCredits(sessionId, amount) {
+        const snapshot = await db.ref('users').orderByChild('Active_Session_ID').equalTo(sessionId).once('value');
+        if (!snapshot.exists()) throw new Error("User not found");
+        const userKey = Object.keys(snapshot.val())[0];
+        const currentCredits = snapshot.val()[userKey].Credits || 0;
+        await db.ref(`users/${userKey}`).update({ Credits: currentCredits + amount });
+        return { success: true };
+    },
+
+    async deleteUser(nodeKey) {
+        await db.ref(`users/${nodeKey}`).remove();
+        return { success: true };
+    }
+};

backend/services/ai.js

@@ -0,0 +1,2 @@
+
+export { AIService } from '@/backend/services/ai/index';

backend/services/ai/bookRecap.js

@@ -0,0 +1,37 @@
+import { BOOK_RECAP_PROMPT } from '../../../prompts/bookRecap.js';
+
+import { tryModels, getPrompt, DEFAULT_SAFETY_SETTINGS } from '@/backend/services/ai/utils';
+
+export async function bookRecap(media, mimeType, targetLanguage, apiKey, isOwnApi = false) {
+    const models = ['gemini-3-flash-preview', 'gemini-flash-lite-latest'];
+    const isBurmese = targetLanguage.toLowerCase().includes('burm') || targetLanguage.includes('မြန်မာ');
+    
+    // Clean language name in case any legacy strings remain
+    const cleanLanguage = targetLanguage.split(' (')[0];
+    
+    const finalPrompt = BOOK_RECAP_PROMPT(targetLanguage);
+
+    return await tryModels(apiKey, models, async (ai, model) => {
+        const response = await ai.models.generateContent({
+            model: model,
+            contents: { 
+                parts: [
+                    { inlineData: { data: media, mimeType } }, 
+                    { text: `Translate this entire document COMPLETELY (100% length) into ${cleanLanguage}. Do not summarize or skip any content.` }
+                ] 
+            },
+            config: { 
+                temperature: 0.3, 
+                systemInstruction: finalPrompt, 
+                safetySettings: DEFAULT_SAFETY_SETTINGS,
+                thinkingConfig: { thinkingBudget: 0 }
+            }
+        });
+        
+        const text = response.text;
+        if (!text || text.trim().length < 50) {
+             throw new Error("MODEL_FAILED_TO_TRANSLATE_DOCUMENT");
+        }
+        return text;
+    });
+}

backend/services/ai/comicTranslator.js

@@ -0,0 +1,64 @@
+import { COMIC_TRANSLATOR_PROMPT } from '../../../prompts/comicTranslator.js';
+
+import { Type } from '@google/genai';
+import { tryModels, getPrompt, DEFAULT_SAFETY_SETTINGS, cleanJson } from '@/backend/services/ai/utils';
+
+export async function comicTranslate(media, mimeType, targetLanguage, apiKey, isOwnApi = false) {
+    const models = ['gemini-3-flash-preview', 'gemini-flash-lite-latest'];
+    const isBurmese = targetLanguage.toLowerCase().includes('burm') || targetLanguage.includes('မြန်မာ');
+    
+    const finalPrompt = COMIC_TRANSLATOR_PROMPT(targetLanguage);
+
+    // AI identifies text locations and translations
+    return await tryModels(apiKey, models, async (ai, model) => {
+        const response = await ai.models.generateContent({
+            model: model,
+            contents: { 
+                parts: [
+                    { inlineData: { data: media, mimeType } }, 
+                    { text: "TASK: Process this document page by page. For each page, identify all text bubbles. Provide their [ymin, xmin, ymax, xmax] coordinates and the translated text in " + targetLanguage + ". Output ONLY valid JSON." }
+                ] 
+            },
+            config: { 
+                temperature: 0.1, 
+                systemInstruction: finalPrompt, 
+                safetySettings: DEFAULT_SAFETY_SETTINGS,
+                responseMimeType: "application/json",
+                responseSchema: {
+                    type: Type.OBJECT,
+                    properties: {
+                        pages: {
+                            type: Type.ARRAY,
+                            items: {
+                                type: Type.OBJECT,
+                                properties: {
+                                    page_number: { type: Type.INTEGER },
+                                    text_blocks: {
+                                        type: Type.ARRAY,
+                                        items: {
+                                            type: Type.OBJECT,
+                                            properties: {
+                                                translated_text: { type: Type.STRING },
+                                                box_2d: { 
+                                                    type: Type.ARRAY, 
+                                                    items: { type: Type.NUMBER },
+                                                    description: "[ymin, xmin, ymax, xmax] coordinates normalized 0-1000"
+                                                },
+                                                background_color: { type: Type.STRING }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    required: ['pages']
+                }
+            }
+        });
+        
+        // The backend server will receive this JSON and perform the heavy image manipulation
+        // returning a final processed URL or Base64 to the client.
+        return JSON.parse(cleanJson(response.text));
+    });
+}

backend/services/ai/creator.js

@@ -0,0 +1,49 @@
+import { CONTENT_CREATOR_PROMPT } from '../../../prompts/contentCreator.js';
+
+import { tryModels, getPrompt, DEFAULT_SAFETY_SETTINGS } from '@/backend/services/ai/utils';
+
+export async function contentCreator(topic, category, subTopics, contentType, gender, targetLang, apiKey, isOwnApi = false) {
+    const models = ['gemini-3-flash-preview', 'gemini-flash-lite-latest'];
+    const isBurmese = targetLang.toLowerCase().includes('burm') || targetLang.includes('မြန်မာ');
+    const finalPrompt = CONTENT_CREATOR_PROMPT(topic, category, subTopics, contentType, gender, targetLang);
+    return await tryModels(apiKey, models, async (ai, model) => {
+        const response = await ai.models.generateContent({ 
+            model, 
+            contents: [{ parts: [{ text: `Topic: ${topic}. Category: ${category}.` }] }], 
+            config: { temperature: 0.8, systemInstruction: finalPrompt, safetySettings: DEFAULT_SAFETY_SETTINGS } 
+        });
+        return response.text;
+    });
+}
+
+export async function generateImage(prompt, apiKey, isOwnApi = false) {
+    const models = ['gemini-2.5-flash-image', 'gemini-3-pro-image-preview'];
+    
+    // Improved visual prompt for better generation
+    const visualPrompt = `High-quality cinematic illustrative 3D character design or scene showing: ${prompt}. Vivid colors, detailed environment, 8k resolution style.`;
+
+    return await tryModels(apiKey, models, async (ai, model) => {
+        const response = await ai.models.generateContent({
+            model: model,
+            contents: { 
+                parts: [
+                    { text: visualPrompt }
+                ] 
+            },
+            config: { 
+                imageConfig: { aspectRatio: "1:1" }
+            }
+        });
+
+        // Thoroughly check all candidates and parts for inlineData
+        for (const candidate of response.candidates || []) {
+            for (const part of candidate.content?.parts || []) {
+                if (part.inlineData) {
+                    return `data:image/png;base64,${part.inlineData.data}`;
+                }
+            }
+        }
+        
+        throw new Error("EMPTY_IMAGE_DATA_RESPONSE");
+    });
+}

backend/services/ai/index.js

@@ -0,0 +1,23 @@
+
+import { transcribe } from '@/backend/services/ai/transcribe';
+import { recap } from '@/backend/services/ai/recap';
+import { bookRecap } from '@/backend/services/ai/bookRecap';
+import { comicTranslate } from '@/backend/services/ai/comicTranslator';
+import { translate } from '@/backend/services/ai/translate';
+import { srtTranslate } from '@/backend/services/ai/srtTranslate';
+import { tts } from '@/backend/services/ai/tts';
+import { subtitle } from '@/backend/services/ai/subtitle';
+import { contentCreator, generateImage } from '@/backend/services/ai/creator';
+
+export const AIService = {
+    transcribe,
+    recap,
+    bookRecap,
+    comicTranslate,
+    translate,
+    srtTranslate,
+    tts,
+    subtitle,
+    contentCreator,
+    generateImage
+};

backend/services/ai/recap.js

@@ -0,0 +1,32 @@
+import { RECAP_PROMPT } from '../../../prompts/recap.js';
+
+import { tryModels, getPrompt, DEFAULT_SAFETY_SETTINGS } from '@/backend/services/ai/utils';
+
+export async function recap(media, mimeType, targetLanguage, apiKey, isOwnApi = false) {
+    // UPDATED: Aligned with the 'no Pro' preference
+    const models = ['gemini-3-flash-preview', 'gemini-flash-lite-latest'];
+    const finalPrompt = RECAP_PROMPT(targetLanguage);
+    return await tryModels(apiKey, models, async (ai, model) => {
+        const response = await ai.models.generateContent({
+            model: model,
+            contents: { 
+                parts: [
+                    { inlineData: { data: media, mimeType } }, 
+                    { text: "Narrate an extremely detailed cinematic recap." }
+                ] 
+            },
+            config: { 
+                temperature: 0.4, 
+                systemInstruction: finalPrompt, 
+                safetySettings: DEFAULT_SAFETY_SETTINGS,
+                thinkingConfig: { thinkingBudget: 0 }
+            }
+        });
+        
+        const text = response.text;
+        if (!text || text.trim().length < 10) {
+             throw new Error("MODEL_FAILED_TO_GENERATE_RECAP");
+        }
+        return text;
+    });
+}

backend/services/ai/srtTranslate.js

@@ -0,0 +1,82 @@
+import { SRT_TRANSLATOR_PROMPT } from '../../../prompts/srttranslator.js';
+import { tryModels, getPrompt, cleanSRTOutput, DEFAULT_SAFETY_SETTINGS } from '@/backend/services/ai/utils';
+
+/**
+ * Counts the number of SRT blocks in a given text.
+ */
+function countSrtBlocks(text) {
+    if (!text) return 0;
+    // Improved regex to count standard SRT blocks accurately
+    const matches = text.match(/^\d+\s*\r?\n\d{2}:\d{2}:\d{2},\d{3}/gm);
+    return matches ? matches.length : 0;
+}
+
+export async function srtTranslate(srtContent, sourceLanguage, targetLanguage, apiKey, isOwnApi = false) {
+    const models = ['gemini-3-flash-preview', 'gemini-flash-lite-latest'];
+    const finalPrompt = SRT_TRANSLATOR_PROMPT(sourceLanguage, targetLanguage);
+    
+    // Normalize line endings and split into blocks
+    const blocks = srtContent.replace(/\r\n/g, '\n').split(/\n\s*\n/).filter(b => b.trim().length > 0);
+    
+    const CHUNK_SIZE = 120; // Increased to 120 as requested for higher throughput
+    const BATCH_SIZE = 2;   // Enabled Parallel processing (2 at a time)
+    const COOLDOWN = 1000;  // Minimal cooldown between parallel batches
+    
+    console.log(`[AI-SRT-SAFE-MAX] Segment Blocks: ${blocks.length}. Chunks: ${Math.ceil(blocks.length/CHUNK_SIZE)}.`);
+
+    const chunkTexts = [];
+    const chunkBlockCounts = [];
+    for (let i = 0; i < blocks.length; i += CHUNK_SIZE) {
+        const slice = blocks.slice(i, i + CHUNK_SIZE);
+        chunkTexts.push(slice.join('\n\n'));
+        chunkBlockCounts.push(slice.length);
+    }
+
+    const results = [];
+    for (let i = 0; i < chunkTexts.length; i += BATCH_SIZE) {
+        const currentBatchIndices = Array.from({ length: Math.min(BATCH_SIZE, chunkTexts.length - i) }, (_, k) => i + k);
+        
+        const batchPromises = currentBatchIndices.map(idx => 
+            tryModels(apiKey, models, async (ai, model) => {
+                const inputText = chunkTexts[idx];
+                const expectedCount = chunkBlockCounts[idx];
+                
+                let response = await ai.models.generateContent({
+                    model: model,
+                    contents: [{ parts: [{ text: `Translate these ${expectedCount} blocks now. Maintain all IDs:\n\n${inputText}` }] }],
+                    config: { 
+                        temperature: 0.1, 
+                        systemInstruction: finalPrompt, 
+                        safetySettings: DEFAULT_SAFETY_SETTINGS,
+                        thinkingConfig: { thinkingBudget: 0 } 
+                    }
+                });
+
+                let translatedText = cleanSRTOutput(response.text);
+                let actualCount = countSrtBlocks(translatedText);
+
+                // --- INTEGRITY AUTO-RECOVERY ---
+                if (actualCount < expectedCount) {
+                    console.warn(`[AI-SRT] Gap detected in chunk ${idx} (${actualCount}/${expectedCount}). Retrying with max precision...`);
+                    response = await ai.models.generateContent({
+                        model: model,
+                        contents: [{ parts: [{ text: `CRITICAL: Do not skip lines. You MUST return exactly ${expectedCount} blocks. Translate ALL now:\n\n${inputText}` }] }],
+                        config: { temperature: 0.0, systemInstruction: finalPrompt, safetySettings: DEFAULT_SAFETY_SETTINGS }
+                    });
+                    translatedText = cleanSRTOutput(response.text);
+                }
+
+                return translatedText;
+            })
+        );
+
+        const batchResults = await Promise.all(batchPromises);
+        results.push(...batchResults);
+
+        if (i + BATCH_SIZE < chunkTexts.length) {
+            await new Promise(r => setTimeout(r, COOLDOWN));
+        }
+    }
+
+    return results.join('\n\n').trim();
+}

backend/services/ai/subtitle.js

@@ -0,0 +1,54 @@
+import { SUBTITLE_PROMPT } from '../../../prompts/subtitle.js';
+
+import { tryModels, getPrompt, cleanSRTOutput, DEFAULT_SAFETY_SETTINGS } from '@/backend/services/ai/utils';
+import { transcribe } from '@/backend/services/ai/transcribe';
+
+const formatMsToSRT = (ms) => {
+    const hours = Math.floor(ms / 3600000);
+    const mins = Math.floor((ms % 3600000) / 60000);
+    const secs = Math.floor((ms % 60000) / 1000);
+    const mms = Math.floor(ms % 1000);
+    return `${hours.toString().padStart(2, '0')}:${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')},${mms.toString().padStart(3, '0')}`;
+};
+
+export async function subtitle(mediaBase64, mimeType, fullScript, apiKey, isOwnApi = false, sourceLanguage = 'English', startOffsetMs = 0, lastScriptIndex = 0) {
+    let scriptToProcess = fullScript || "";
+
+    // If script is empty, transcribe the whole media
+    if (!scriptToProcess) {
+        scriptToProcess = await transcribe(mediaBase64, mimeType, apiKey, isOwnApi);
+    }
+
+    const isBurmese = sourceLanguage.toLowerCase().includes('burm') || sourceLanguage.includes('မြန်မာ');
+    const promptTemplate = getPrompt('subtitle.txt');
+    
+    // REMOVED: 15-second restriction logic.
+    // ADDED: Explicit instruction to process the ENTIRE audio.
+    const finalPrompt = promptTemplate
+        .replace('{{script}}', scriptToProcess)
+        .replace('{{language}}', isBurmese ? "Burmese (Conversational)" : sourceLanguage)
+        .replace('15-second audio input', 'the provided audio file') 
+        .replace('Align the script', 'Align the COMPLETE script from start to finish');
+
+    const rawSRT = await tryModels(apiKey, ['gemini-3-flash-preview'], async (ai, model) => {
+        const response = await ai.models.generateContent({
+            model,
+            contents: { 
+                parts: [
+                    { inlineData: { data: mediaBase64, mimeType: 'audio/wav' } }, 
+                    { text: `GENERATE FULL SRT: Listen to this entire file and align every word from the reference script. Return the complete SRT.` }
+                ] 
+            },
+            config: { 
+                temperature: 0, 
+                systemInstruction: finalPrompt, 
+                safetySettings: DEFAULT_SAFETY_SETTINGS
+            }
+        });
+        return cleanSRTOutput(response.text);
+    });
+
+    return { 
+        srt: rawSRT || "" 
+    };
+}

backend/services/ai/transcribe.js

@@ -0,0 +1,31 @@
+import { TRANSCRIPTION_PROMPT } from '../../../prompts/transcription.js';
+
+import { tryModels, getPrompt, DEFAULT_SAFETY_SETTINGS } from '@/backend/services/ai/utils';
+
+export async function transcribe(media, mimeType, apiKey, isOwnApi = false) {
+    const models = ['gemini-3-flash-preview', 'gemini-flash-lite-latest'];
+    const systemPrompt = TRANSCRIPTION_PROMPT;
+    return await tryModels(apiKey, models, async (ai, model) => {
+        const response = await ai.models.generateContent({
+            model: model,
+            contents: { 
+                parts: [
+                    { inlineData: { data: media, mimeType } }, 
+                    { text: "Transcribe accurately and completely. Do not skip any dialogue." }
+                ] 
+            },
+            config: { 
+                temperature: 0.1, 
+                systemInstruction: systemPrompt, 
+                safetySettings: DEFAULT_SAFETY_SETTINGS,
+                thinkingConfig: { thinkingBudget: 0 }
+            }
+        });
+
+        const text = response.text;
+        if (!text || text.trim().length < 2) {
+             throw new Error("EMPTY_RESPONSE_FROM_MODEL");
+        }
+        return text;
+    });
+}

backend/services/ai/translate.js

@@ -0,0 +1,33 @@
+import { TRANSLATION_PROMPT } from '../../../prompts/translation.js';
+
+import { Type } from '@google/genai';
+import { tryModels, getPrompt, cleanJson, DEFAULT_SAFETY_SETTINGS } from '@/backend/services/ai/utils';
+
+export async function translate(text, targetLanguage, options, apiKey, isOwnApi = false) {
+    const models = ['gemini-3-flash-preview', 'gemini-flash-lite-latest'];
+    const isBurmese = targetLanguage.toLowerCase().includes('burm') || targetLanguage.includes('မြန်မာ');
+    const finalPrompt = TRANSLATION_PROMPT(targetLanguage, options);
+
+    return await tryModels(apiKey, models, async (ai, model) => {
+        const response = await ai.models.generateContent({
+            model: model,
+            contents: [{ parts: [{ text: `CONTENT: ${text}` }] }],
+            config: {
+                temperature: 0.7,
+                systemInstruction: finalPrompt,
+                responseMimeType: "application/json",
+                safetySettings: DEFAULT_SAFETY_SETTINGS,
+                responseSchema: {
+                    type: Type.OBJECT,
+                    properties: {
+                        translation: { type: Type.STRING },
+                        deepMeaning: { type: Type.STRING, nullable: true },
+                        suggestions: { type: Type.OBJECT, nullable: true, properties: { videoTitles: { type: Type.ARRAY, items: { type: Type.STRING } }, thumbnailTexts: { type: Type.ARRAY, items: { type: Type.STRING } } } }
+                    },
+                    required: ['translation']
+                }
+            }
+        });
+        return JSON.parse(cleanJson(response.text));
+    });
+}

backend/services/ai/tts.js

@@ -0,0 +1,44 @@
+import { AI_VOICE_PROMPT } from '../../../prompts/aiVoice.js';
+
+import { tryModels, getPrompt, DEFAULT_SAFETY_SETTINGS } from '@/backend/services/ai/utils';
+import { Modality } from '@google/genai';
+
+export async function tts(text, voiceName, tone, apiKey, isOwnApi = false) {
+    // Strict requirement: Max 3500 characters
+    const ABSOLUTE_MAX_LENGTH = 3500;
+    if (text && text.length > ABSOLUTE_MAX_LENGTH) {
+        throw new Error(`Text is too long (${text.length} chars). Maximum allowed is ${ABSOLUTE_MAX_LENGTH} characters.`);
+    }
+
+    const models = ['gemini-2.5-flash-preview-tts', 'gemini-2.5-pro-preview-tts']; 
+    const promptInstructions = AI_VOICE_PROMPT(tone);
+    
+    // For TTS models, prepending the tone instructions to the text is more stable than systemInstruction
+    const textWithInstructions = `${promptInstructions}\n\nSCRIPT TO SPEAK:\n${text}`;
+
+    console.log(`[TTS] Generating content... Length: ${text?.length || 0}`);
+
+    const chunkBase64 = await tryModels(apiKey, models, async (ai, model) => {
+        const response = await ai.models.generateContent({
+            model: model,
+            contents: [{ parts: [{ text: textWithInstructions }] }],
+            config: { 
+                responseModalities: [Modality.AUDIO], 
+                safetySettings: DEFAULT_SAFETY_SETTINGS,
+                speechConfig: { 
+                    voiceConfig: { 
+                        prebuiltVoiceConfig: { 
+                            voiceName: voiceName || 'Zephyr' 
+                        } 
+                    } 
+                } 
+            }
+        });
+
+        const part = response.candidates?.[0]?.content?.parts.find(p => p.inlineData);
+        if (part?.inlineData?.data) return part.inlineData.data;
+        throw new Error("EMPTY_AUDIO_DATA_FROM_GEMINI");
+    });
+
+    return chunkBase64;
+}

backend/services/ai/utils.js

@@ -0,0 +1,73 @@
+
+import { GoogleGenAI } from '@google/genai';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export const getPrompt = (filename) => {
+    try {
+        const filePath = path.resolve(__dirname, '..', '..', 'prompts', filename);
+        if (fs.existsSync(filePath)) {
+            return fs.readFileSync(filePath, 'utf8');
+        } else {
+            const internalPath = path.resolve(__dirname, '..', '..', '..', 'prompts', filename);
+            return fs.existsSync(internalPath) ? fs.readFileSync(internalPath, 'utf8') : "";
+        }
+    } catch (e) { 
+        console.error(`[AI-ENGINE] Prompt Load Error (${filename}):`, e.message);
+        return ""; 
+    }
+};
+
+export function cleanJson(raw) {
+    if (!raw) return "";
+    return raw.replace(/```json/gi, '').replace(/```/gi, '').trim();
+}
+
+export function cleanSRTOutput(text) {
+    if (!text) return "";
+    let cleaned = text.replace(/```srt/gi, '').replace(/```/gi, '').trim();
+    const firstIndex = cleaned.search(/^\d+\s*\r?\n\d{2}:\d{2}:\d{2},\d{3}/m);
+    if (firstIndex !== -1) {
+        cleaned = cleaned.substring(firstIndex);
+    }
+    return cleaned;
+}
+
+export const DEFAULT_SAFETY_SETTINGS = [
+    { category: 'HARM_CATEGORY_HARASSMENT', threshold: 'BLOCK_ONLY_HIGH' },
+    { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_ONLY_HIGH' },
+    { category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT', threshold: 'BLOCK_ONLY_HIGH' },
+    { category: 'HARM_CATEGORY_DANGEROUS_CONTENT', threshold: 'BLOCK_ONLY_HIGH' },
+    { category: 'HARM_CATEGORY_CIVIC_INTEGRITY', threshold: 'BLOCK_ONLY_HIGH' }
+];
+
+export async function tryModels(apiKey, modelList, taskFn) {
+    let lastError = null;
+    const ai = new GoogleGenAI({ apiKey });
+    const MAX_RETRIES_PER_MODEL = 2;
+
+    for (const modelName of modelList) {
+        for (let attempt = 0; attempt <= MAX_RETRIES_PER_MODEL; attempt++) {
+            try {
+                return await taskFn(ai, modelName);
+            } catch (e) {
+                const rawError = (e.message || "Unknown error").toLowerCase();
+                const isRateLimit = rawError.includes('429') || rawError.includes('quota') || rawError.includes('limit');
+                
+                if (isRateLimit && attempt < MAX_RETRIES_PER_MODEL) {
+                    const waitTime = (attempt + 1) * 5000;
+                    console.warn(`[AI-ENGINE] Rate limit on ${modelName}. Retry in ${waitTime}ms...`);
+                    await new Promise(r => setTimeout(r, waitTime));
+                    continue;
+                }
+                console.error(`[AI-ENGINE] Error on ${modelName}:`, rawError);
+                lastError = e;
+                break;
+            }
+        }
+    }
+    throw lastError;
+}

backend/services/authService.js

@@ -0,0 +1,39 @@
+import { db } from '@/backend/services/firebase';
+
+export const AuthService = {
+    async saveCustomKey(sessionId, apiKey) {
+        const snapshot = await db.ref('users').orderByChild('Active_Session_ID').equalTo(sessionId).once('value');
+        if (!snapshot.exists()) throw new Error("User not found.");
+        const userKey = Object.keys(snapshot.val())[0];
+        await db.ref(`users/${userKey}`).update({ Private_API_Key: apiKey });
+        return { success: true };
+    },
+
+    async updateActiveSession(userId, newSessionId) {
+        if (!userId) throw new Error("Membership ID is required.");
+
+        // Find user by their PERMANENT Login_Key first
+        let snapshot = await db.ref('users').orderByChild('Login_Key').equalTo(userId).once('value');
+        
+        // Fallback: If not found, try searching by Active_Session_ID (for legacy users)
+        if (!snapshot.exists()) {
+            snapshot = await db.ref('users').orderByChild('Active_Session_ID').equalTo(userId).once('value');
+        }
+
+        if (!snapshot.exists()) throw new Error("Membership ID not found in records.");
+        
+        const userKey = Object.keys(snapshot.val())[0];
+        const userData = snapshot.val()[userKey];
+        
+        const updates = { Active_Session_ID: newSessionId };
+        
+        // If this was a legacy user without a Login_Key, set it now to stabilize their account
+        if (!userData.Login_Key) {
+            updates.Login_Key = userId;
+        }
+        
+        await db.ref(`users/${userKey}`).update(updates);
+        
+        return { success: true };
+    }
+};

backend/services/credit.js

@@ -0,0 +1,123 @@
+
+import { db } from '@/backend/services/firebase';
+
+export async function checkEligibility(sessionId, toolKey, isOwnKey) {
+    if (!sessionId) throw new Error("Authentication failed. No session ID provided.");
+
+    const now = new Date();
+    const today = now.toLocaleDateString('en-CA'); // Robust YYYY-MM-DD
+    
+    // Map toolKey to prefix-aware usage key
+    const usageKey = isOwnKey ? `own_${toolKey}` : `app_${toolKey}`;
+
+    // 1. Fetch System Tier Settings
+    const sysSnapshot = await db.ref('system/settings/tiers').once('value');
+    const tiers = sysSnapshot.val() || {};
+
+    const toolMapper = {
+        'count_transcript': 'transcript',
+        'count_translate': 'translate',
+        'count_srt_translate': 'srt_translator',
+        'count_tts': 'tts',
+        'count_subtitle': 'subtitle_gen',
+        'count_creator_text': 'content_creator',
+        'count_creator_image': 'ai_image'
+    };
+    const tierToolKey = toolMapper[toolKey] || toolKey;
+
+    let userKey, userData, userClass;
+
+    if (sessionId === 'free_access') {
+        userClass = 'FREE';
+        userData = { Usage: {}, Credits: 0, Class: 'FREE' };
+    } else {
+        const snapshot = await db.ref('users').orderByChild('Active_Session_ID').equalTo(sessionId).once('value');
+        if (!snapshot.exists()) throw new Error("Invalid Membership ID. Please login again.");
+        userKey = Object.keys(snapshot.val())[0];
+        userData = snapshot.val()[userKey];
+        if (userData.Status !== 'ACTIVE') throw new Error("Account suspended. Please contact admin.");
+        userClass = userData.Class === 'MEMBER+' ? 'MEMBER_PLUS' : 'MEMBER';
+    }
+
+    const tierConfig = tiers[userClass] || { tools: {}, ownTools: {}, limits: {}, ownLimits: {}, apiAccess: { app: true, own: true } };
+
+    // 2. CHECK API ACCESS PERMISSIONS
+    if (isOwnKey && tierConfig.apiAccess?.own === false) {
+        throw new Error(`OWN_API_RESTRICTED: Your ${userClass} class is not allowed to use private API keys.`);
+    }
+    if (!isOwnKey && tierConfig.apiAccess?.app === false) {
+        throw new Error(`APP_API_RESTRICTED: Shared App API is currently disabled for your class.`);
+    }
+
+    // 3. CHECK SPECIFIC TOOL STATUS FOR TIER (Mode Specific)
+    const toolMap = isOwnKey ? (tierConfig.ownTools || {}) : (tierConfig.tools || {});
+    if (toolMap[tierToolKey] === false) {
+        throw new Error(`TOOL_DISABLED: This tool is disabled in ${isOwnKey ? 'Own API' : 'App API'} mode for ${userClass} class.`);
+    }
+
+    const usage = (userData.Last_Usage_Date === today) ? (userData.Usage || {}) : {};
+    
+    // 4. CHECK LIMITS (Mode Specific)
+    const limit = isOwnKey ? (tierConfig.ownLimits?.[tierToolKey] ?? -1) : (tierConfig.limits?.[tierToolKey] ?? -1);
+    
+    if (limit !== -1) {
+        const currentCount = parseInt(usage[usageKey] || 0);
+        if (currentCount >= limit) {
+            throw new Error(`DAILY_QUOTA_REACHED: Your ${userClass} daily limit for ${isOwnKey ? 'Own' : 'App'} API has been reached.`);
+        }
+    }
+
+    // 5. CHECK CREDITS (Only if using App API)
+    let cost = 0;
+    if (!isOwnKey) {
+        const costMap = {
+            'count_transcript': 1, 'count_translate': 1, 'count_srt_translate': 5,
+            'count_tts': 3, 'count_subtitle': 1, 'count_creator_text': 1, 'count_creator_image': 5
+        };
+        cost = costMap[toolKey] || 1;
+        
+        if (userClass === 'MEMBER_PLUS') {
+            const freeTools = ['count_transcript', 'count_translate', 'count_subtitle', 'count_creator_text'];
+            if (freeTools.includes(toolKey)) cost = 0;
+        }
+        if (userClass === 'FREE') cost = 0;
+
+        const currentCredits = userData.Credits || 0;
+        if (cost > 0 && currentCredits < cost) {
+            throw new Error(`INSUFFICIENT_BALANCE: This task costs ${cost} credits. Your balance is ${currentCredits}.`);
+        }
+    }
+
+    return { userKey, userData, usageKey, cost, today, isGuest: (userClass === 'FREE'), isOwnKey };
+}
+
+export async function commitDeduction(eligibilityData, toolKey) {
+    if (!eligibilityData) return; 
+    const { userKey, userData, usageKey, cost, today, isGuest } = eligibilityData;
+    
+    if (isGuest) return;
+
+    const updates = {};
+    if (cost > 0) {
+        const newBalance = (userData.Credits || 0) - cost;
+        updates[`users/${userKey}/Credits`] = newBalance >= 0 ? newBalance : 0;
+    }
+
+    if (userData.Last_Usage_Date !== today) {
+        updates[`users/${userKey}/Last_Usage_Date`] = today;
+        updates[`users/${userKey}/Usage`] = { [usageKey]: 1 };
+    } else {
+        const currentUsage = (userData.Usage && userData.Usage[usageKey]) || 0;
+        updates[`users/${userKey}/Usage/${usageKey}`] = currentUsage + 1;
+    }
+
+    await db.ref().update(updates);
+}
+
+export async function processFreePool(toolKey) {
+    const today = new Date().toLocaleDateString('en-CA');
+    const poolPath = `system/daily_pool/${today}/app_${toolKey}`; // Default to app prefix for free pool
+    const snapshot = await db.ref(poolPath).once('value');
+    const current = snapshot.val() || 0;
+    await db.ref(poolPath).set(current + 1);
+}

backend/services/creditService.js

@@ -0,0 +1,153 @@
+
+import { db } from '@/backend/services/firebase';
+
+export const CreditService = {
+    async checkEligibility(sessionId, guestId, toolKey, isOwnKey, creditCostOverride = null) {
+        if (!sessionId) throw new Error("Authentication failed.");
+
+        const now = new Date();
+        const today = now.toLocaleDateString('en-CA'); 
+        const usageKey = isOwnKey ? `own_${toolKey}` : `app_${toolKey}`;
+
+        // 1. Fetch System Tier Settings
+        const sysSnapshot = await db.ref('system/settings/tiers').once('value');
+        const tiers = sysSnapshot.val() || {};
+
+        const toolMapper = {
+            'count_transcript': 'transcript',
+            'count_translate': 'translate',
+            'count_srt_translate': 'srt_translator',
+            'count_tts': 'tts',
+            'count_subtitle': 'subtitle_gen',
+            'count_creator_text': 'content_creator',
+            'count_creator_image': 'ai_image',
+            'downloader': 'downloader',
+            'book_recap': 'book_recap'
+        };
+        const tierToolKey = toolMapper[toolKey] || toolKey;
+
+        let userKey, userData, userClass, storagePath;
+
+        if (sessionId === 'free_access') {
+            userClass = 'FREE';
+            if (!guestId || guestId === 'anonymous') {
+                // Return generic guest data for free mode
+                userData = { Usage: {}, Credits: 0, Class: 'FREE', Last_Usage_Date: today };
+                storagePath = `guests/temp_guest`;
+            } else {
+                storagePath = `guests/${guestId}/${today}`;
+                const usageSnapshot = await db.ref(storagePath).once('value');
+                const currentUsage = usageSnapshot.val() || {};
+                userData = { Usage: currentUsage, Credits: 0, Class: 'FREE', Last_Usage_Date: today };
+            }
+        } else {
+            // Find user by temporary session ID
+            const snapshot = await db.ref('users').orderByChild('Active_Session_ID').equalTo(sessionId).once('value');
+            if (!snapshot.exists()) throw new Error("Invalid Session. Please login again.");
+            
+            userKey = Object.keys(snapshot.val())[0];
+            userData = snapshot.val()[userKey];
+            if (userData.Status !== 'ACTIVE') throw new Error("Account suspended.");
+            
+            userClass = userData.Class === 'MEMBER+' ? 'MEMBER_PLUS' : (userData.Class === 'BASIC' ? 'BASIC' : 'MEMBER');
+            storagePath = `users/${userKey}`;
+        }
+
+        const tierConfig = tiers[userClass] || { apiAccess: { app: true, own: true } };
+
+        // Check if user is trying to use their own API but it's disabled for their class
+        if (isOwnKey && tierConfig.apiAccess?.own === false) throw new Error("OWN_API_RESTRICTED");
+        if (!isOwnKey && tierConfig.apiAccess?.app === false) throw new Error("APP_API_RESTRICTED");
+
+        // Check Specific Tool Toggle (Mode Specific)
+        const toolToggleMap = isOwnKey ? (tierConfig.ownTools || {}) : (tierConfig.tools || {});
+        if (toolToggleMap[tierToolKey] === false) throw new Error("TOOL_DISABLED");
+
+const usage = (userData.Last_Usage_Date === today) ? (userData.Usage || {}) : {};
+        
+        // 1. Declare the limit variable based on the tier settings
+        let limit = isOwnKey 
+            ? (tierConfig.ownLimits?.[tierToolKey] ?? -1) 
+            : (tierConfig.limits?.[tierToolKey] ?? -1);
+        
+        // 2. Override: If using Own API Key, force the limit to -1 (Unlimited)
+        if (isOwnKey) {
+            limit = -1; 
+        }
+        
+        // 3. Perform the check only if a limit exists
+        if (limit !== -1) {
+            const currentCount = parseInt(usage[usageKey] || 0);
+            if (currentCount >= limit) {
+                throw new Error("DAILY_LIMIT_REACHED");
+            }
+        }
+
+        if (isOwnKey) {
+            limit = -1; // -1 means "No Limit" or "Unlimited" in your logic (LOL kyaw Gyi)
+        }        
+        
+        // Check Daily Frequency Limit (Mode Specific)
+ //       let limit = isOwnKey ? (tierConfig.ownLimits?.[tierToolKey] ?? -1) : (tierConfig.limits?.[tierToolKey] ?? -1);
+        
+        
+        if (limit !== -1) {
+            const currentCount = parseInt(usage[usageKey] || 0);
+            if (currentCount >= limit) throw new Error("DAILY_LIMIT_REACHED");
+        }
+
+        let cost = 0;
+        if (userClass !== 'FREE' && !isOwnKey) {
+            const costMap = {
+                'count_transcript': 4, 
+                'count_translate': 4, 
+                'count_srt_translate': 7,
+                'count_tts': 3, 
+                'count_subtitle': 2, 
+                'count_creator_text': 3, 
+                'count_creator_image': 5,
+                'downloader': 2,
+                'book_recap': 8
+            };
+            
+            cost = (creditCostOverride !== null) ? creditCostOverride : (costMap[toolKey] || 1);
+
+            if (cost > 0 && (userData.Credits || 0) < cost) {
+                throw new Error(`INSUFFICIENT_BALANCE: Needs ${cost} credits.`);
+            }
+        }
+
+        return { userKey, storagePath, userData, usageKey, cost, today, isGuest: (userClass === 'FREE'), isOwnKey };
+    },
+
+    async commitDeduction(eligibilityData) {
+        if (!eligibilityData) return;
+        const { storagePath, userData, usageKey, cost, today, isGuest, isOwnKey } = eligibilityData;
+        
+        // Own API mode records usage but never deducts credits
+        const finalCost = isOwnKey ? 0 : cost;
+
+        const updates = {};
+        if (isGuest) {
+            if (storagePath === 'guests/temp_guest') return;
+            const currentUsage = (userData.Usage?.[usageKey]) || 0;
+            updates[`${storagePath}/${usageKey}`] = currentUsage + 1;
+            await db.ref().update(updates);
+            return;
+        }
+
+        if (finalCost > 0) {
+            const newBalance = (userData.Credits || 0) - finalCost;
+            updates[`${storagePath}/Credits`] = Math.max(0, newBalance);
+        }
+
+        if (userData.Last_Usage_Date !== today) {
+            updates[`${storagePath}/Last_Usage_Date`] = today;
+            updates[`${storagePath}/Usage`] = { [usageKey]: 1 };
+        } else {
+            const currentUsage = (userData.Usage?.[usageKey]) || 0;
+            updates[`${storagePath}/Usage/${usageKey}`] = currentUsage + 1;
+        }
+        await db.ref().update(updates);
+    }
+};

backend/services/firebase.js

@@ -0,0 +1,36 @@
+
+import admin from 'firebase-admin';
+import fs from 'fs';
+import path from 'path';
+
+// Service Account file path - MUST be from transcript-master project
+const serviceAccountPath = path.resolve(process.cwd(), 'service-account.json');
+
+try {
+    if (!admin.apps.length) {
+        // Explicitly using transcript-master project details
+        const config = {
+            databaseURL: "https://klingwatermark-default-rtdb.asia-southeast1.firebasedatabase.app",
+            projectId: "klingwatermark"
+        };
+
+        if (fs.existsSync(serviceAccountPath)) {
+            const serviceAccount = JSON.parse(fs.readFileSync(serviceAccountPath, 'utf8'));
+            // Safety check: ensure the file matches the database project
+            if (serviceAccount.project_id !== "transcript-master") {
+                console.error(`❌ CRITICAL: service-account.json is for project "${serviceAccount.project_id}", but database is "transcript-master". Please download the correct key.`);
+            }
+            config.credential = admin.credential.cert(serviceAccount);
+            console.log("✅ Firebase Admin: Using service-account.json for transcript-master");
+        } else {
+            console.warn("ℹ️ Firebase Admin: service-account.json NOT FOUND. DB access will fail.");
+        }
+
+        admin.initializeApp(config);
+        console.log("🚀 Firebase Admin Service Initialized for transcript-master");
+    }
+} catch (error) {
+    console.error("❌ Firebase Init Error:", error.message);
+}
+
+export const db = admin.database();