codeplay-common 4.9.6 → 4.9.9

package/files/buildCodeplay/codeplayBeforeBuild-6.5.js

@@ -0,0 +1,4434 @@
+// Version 6.5: migrate AdMob files to ZIP-distributed folder packages.
+// Version 6.5: recreate failed WebViews, defer background recovery, and suppress foreground recovery toasts.
+const fs = require('fs');
+const path = require('path');
+const plist = require('plist');
+
+
+
+const { execSync } = require("child_process");
+
+
+
+
+const { readFileSync } = require("fs");
+const readline = require('readline');
+
+// Await import confirmation before continuing the remaining build steps.
+(async () => {
+
+// Standalone builds default to Android on every host OS.
+// npm run build:ios explicitly selects iOS through CODEPLAY_BUILD_PLATFORM.
+const buildPlatform = String(process.env.CODEPLAY_BUILD_PLATFORM || '').trim().toLowerCase() || 'android';
+
+if (!['android', 'ios'].includes(buildPlatform)) {
+  console.error(`❌ Unsupported build target: ${buildPlatform}. Expected android or ios.`);
+  process.exit(1);
+}
+
+const ENABLE_AUTO_UPDATE = true;
+const USE_LIVE_SERVER_VERSION = true;
+
+// Reuse directory traversal; refresh after generators or plugin downloads alter src.
+let sourceFileInventory = null;
+function getSourceFiles() {
+  if (!sourceFileInventory) {
+    const sourceRoot = path.join(process.cwd(), 'src');
+    sourceFileInventory = fs.existsSync(sourceRoot) ? walkSync(sourceRoot) : [];
+  }
+  return sourceFileInventory;
+}
+
+const configPath = path.join(process.cwd(), 'capacitor.config.json');
+const packageJsonPath = path.join(process.cwd(), 'package.json');
+const updateLogFile = path.join(process.cwd(), "", "plugin-update-log.txt");
+const ONESIGNAL_PLUGIN_NAME = "onesignal-cordova-plugin";
+const { syncAdmobNextgen, syncImports: syncAdmobImports, findLatestPackage: findAdmobPackage } = require('./sync-admob-nextgen.js');
+const ADMOB_NEXTGEN_CONFIG = "admob-ad-configuration-nextgen.json";
+const ADMOB_OLD_CONFIG = "admob-ad-configuration.json";
+const AGENT_INSTRUCTIONS_VERSION_KEY = "agents";
+const AGENT_INSTRUCTIONS_ZIP_PREFIX = "agents";
+const AGENT_INSTRUCTIONS_FILE = "AGENTS.md";
+const AGENT_INSTRUCTIONS_DIR = "AGENTS";
+const AGENT_INSTRUCTIONS_VERSION_FILE = ".codeplay-version";
+
+// Remove the retired plugin before any validation, patching or package updates.
+removeOneSignalPlugin();
+
+const parseVersionParts = (version) => String(version || "0")
+  .trim()
+  .split(".")
+  .map(part => Number(part) || 0);
+
+const extractVersionFromFileName = (fileName) => {
+  const match = String(fileName).match(/(\d+(?:\.\d+)*)/);
+  return match?.[1] || "0";
+};
+
+const compareVersionStrings = (versionA, versionB) => {
+  const aParts = parseVersionParts(versionA);
+  const bParts = parseVersionParts(versionB);
+  const maxParts = Math.max(aParts.length, bParts.length);
+
+  for (let i = 0; i < maxParts; i++) {
+    const diff = (aParts[i] || 0) - (bParts[i] || 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+};
+
+const getLatestVersionedFileName = (dir, pattern) => {
+  if (!fs.existsSync(dir)) return null;
+
+  const matches = fs.readdirSync(dir).filter((name) => pattern.test(name));
+  if (!matches.length) return null;
+
+  return matches.sort((a, b) => {
+    const versionA = extractVersionFromFileName(a);
+    const versionB = extractVersionFromFileName(b);
+    return compareVersionStrings(versionB, versionA);
+  })[0];
+};
+
+
+// Expected plugin list with minimum versions
+/* const requiredPlugins = [
+
+  { pattern: /backbutton-(\d+\.\d+)\.js$/, minVersion: '2.0', required: true, baseDir: 'js',mandatoryUpdate: true},
+  
+
+  { pattern: /common-(\d+\.\d+)(?:-beta-(\d+))?\.js$/, minVersion: '6.0', required: true, baseDir: 'js',mandatoryUpdate: true },
+  
+  { pattern: /localization_settings-(\d+\.\d+)\.js$/, minVersion: '1.1', required: true, baseDir: 'js',mandatoryUpdate: false },
+  { pattern: /localization-(\d+\.\d+)\.js$/, minVersion: '1.5', required: true, baseDir: 'js',mandatoryUpdate: true },
+  { pattern: /localNotification-(\d+\.\d+)\.js$/, minVersion: '2.2', required: true, baseDir: 'js',mandatoryUpdate: false },
+  { pattern: /localNotification_AppSettings-(\d+\.\d+)\.js$/, minVersion: '1.0', required: true, baseDir: 'js',mandatoryUpdate: false },
+  { pattern: /saveToGalleryAndSaveAnyFile-(\d+\.\d+)(-ios)?\.js$/, minVersion: '3.1', required: true, baseDir: 'js',mandatoryUpdate: true },
+  { pattern: /Ads[\/\\]admob-emi-(\d+\.\d+)\.js$/, minVersion: '3.7', required: true, baseDir: 'js',mandatoryUpdate: true },
+
+  // New added plugins
+  { pattern: /video-player-(\d+\.\d+)\.js$/, minVersion: '1.5', required: true, baseDir: 'js',mandatoryUpdate: false },
+  { pattern: /image-cropper-(\d+\.\d+)\.js$/, minVersion: '1.1', required: true, baseDir: 'js',mandatoryUpdate: false },
+  { pattern: /common-(\d+\.\d+)\.less$/, minVersion: '1.6', required: true, baseDir: 'assets/css',mandatoryUpdate: false },
+  
+  
+  // New folders
+  { pattern: /IAP-(\d+\.\d+)$/, minVersion: '2.8', isFolder: true , required: true, baseDir: 'js/Ads',mandatoryUpdate: true },
+  { pattern: /editor-(\d+\.\d+)$/, minVersion: '1.9', isFolder: true, required: true, baseDir: 'js',mandatoryUpdate: true },
+  { pattern: /ffmpeg-(\d+\.\d+)$/, minVersion: '1.6', isFolder: true, required: true, baseDir: 'js',mandatoryUpdate: true },
+  { pattern: /theme-(\d+\.\d+)$/, minVersion: '3.3', isFolder: true , required: true, baseDir: 'theme',mandatoryUpdate: true },
+
+
+  { pattern: /certificatejs-(\d+\.\d+)$/, minVersion: '1.6', isFolder: true , required: true, baseDir: 'certificate',mandatoryUpdate: true }
+  
+]; */
+
+
+const ROOT_DIR = path.join(__dirname, "..", "src");
+
+function requireOrInstall(packageName) {
+  try {
+    return require(packageName);
+  } catch (err) {
+
+    console.log(`📦 "${packageName}" not found. Installing automatically...`);
+
+    try {
+      execSync(`npm install ${packageName}`, { stdio: "inherit" });
+      console.log(`✅ "${packageName}" installed successfully.`);
+    } catch (installErr) {
+      console.error(`❌ Failed to install "${packageName}".`);
+      process.exit(1);
+    }
+
+    // Try loading again
+    return require(packageName);
+  }
+}
+
+const AdmZip = requireOrInstall("adm-zip");
+
+
+
+const pkg = require(path.join(process.cwd(), 'node_modules', 'codeplay-common', 'package.json'));
+
+const pluginName = pkg.name;
+const pluginVersion = pkg.version;
+
+let updateLogs = [];
+
+function writeUpdateLine(message) {
+  updateLogs.push(message);
+}
+
+const MAX_LOG_BLOCKS = 50;
+
+function saveUpdateLogs() {
+
+  if (updateLogs.length === 0) return;
+
+  const logDir = path.dirname(updateLogFile);
+
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+
+  const now = new Date();
+
+  const formattedTime = now.toLocaleString('en-GB', {
+    day: '2-digit',
+    month: '2-digit',
+    year: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: true
+  }).replace(',', '').replace(/\//g, '-');
+
+  let newBlock = `${pluginName}: ${pluginVersion}\n[${formattedTime}]\n`;
+
+  updateLogs.forEach(line => {
+    newBlock += `${line}\n`;
+  });
+
+  newBlock += "\n";
+
+  let existingLog = "";
+
+  if (fs.existsSync(updateLogFile)) {
+    existingLog = fs.readFileSync(updateLogFile, "utf8");
+  }
+
+  let combinedLog = newBlock + existingLog;
+
+  // Split blocks by plugin header
+  const blocks = combinedLog.split(/\n(?=codeplay-common:)/);
+
+  // Keep only latest 50
+  const trimmed = blocks.slice(0, MAX_LOG_BLOCKS).join("\n");
+
+  fs.writeFileSync(updateLogFile, trimmed);
+
+}
+
+
+
+
+
+const versionsFile = path.join(__dirname, "versions.json");
+
+function loadRequiredPlugins() {
+
+  if (!fs.existsSync(versionsFile)) {
+    console.error("❌ versions.json not found");
+    process.exit(1);
+  }
+
+  const json = JSON.parse(fs.readFileSync(versionsFile, "utf8"));
+
+  // OneSignal is retired; do not download its legacy helpers again.
+  return json.plugins.filter(p =>
+    !/^admob-(?:emi-)?nextgen$/i.test(String(p.name || '')) && !/^onesignal(?:-|$)/i.test(String(p.name || '')) && !/onesignal/i.test(String(p.pattern || ''))
+  ).map(p => ({
+    ...p,
+    pattern: new RegExp(p.pattern)
+  }));
+
+}
+
+let requiredPlugins = loadRequiredPlugins();
+
+
+
+
+
+
+async function downloadAndExtractZip(url, destFolder) {
+
+  const zipPath = destFolder + ".zip";
+
+  await downloadFile(url, zipPath);
+
+  const zip = new AdmZip(zipPath);
+  zip.extractAllTo(destFolder, true);
+
+  fs.unlinkSync(zipPath);
+
+}
+
+
+
+
+
+
+
+//Check codeplay-common latest version installed or not Start
+//const { execSync } = require('child_process');
+
+
+function getInstalledVersion(packageName) {
+  try {
+    const packageJsonPath = path.join(process.cwd(), 'node_modules', packageName, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      return packageJson.version;
+    }
+  } catch (error) {
+    return null;
+  }
+  return null;
+}
+
+function getLatestVersion(packageName) {
+  try {
+    return execSync(`npm view ${packageName} version`).toString().trim();
+  } catch (error) {
+    console.error(`Failed to fetch latest version for ${packageName}`);
+    return null;
+  }
+}
+
+function checkPackageVersion() {
+  const packageName = 'codeplay-common';
+  const installedVersion = getInstalledVersion(packageName);
+  const latestVersion = getLatestVersion(packageName);
+
+  if (!installedVersion) {
+    console.error(`${packageName} is not installed. Installing now...`);
+    execSync(`npm install ${packageName}`, { stdio: 'inherit' });
+    return;
+  }
+
+  if (installedVersion !== latestVersion) {
+    console.log(`${packageName} is outdated (installed: ${installedVersion}, latest: ${latestVersion}). Updating now...`);
+    
+    try {
+      execSync(`npm uninstall ${packageName}`, { stdio: 'inherit' });
+      execSync(`npm install ${packageName}`, { stdio: 'inherit' });
+      console.log(`${packageName} successfully updated.`);
+    } catch (err) {
+      console.error(`Failed to update ${packageName}:`, err.message);
+      process.exit(1);
+    }
+
+    return;
+  }
+
+  console.log(`${packageName} is up to date (version ${installedVersion}).`);
+}
+
+// Run package version check before executing the main script
+try {
+  checkPackageVersion();
+} catch (error) {
+  console.error(error.message);
+  process.exit(1);
+}
+
+//Check codeplay-common latest version installed or not END
+
+
+
+function compareWithBeta(installedVersion, minVersion, isBeta) {
+  const baseCompare = compareVersions(installedVersion, minVersion);
+
+  if (!isBeta) {
+    // Stable version → normal compare
+    return baseCompare;
+  }
+
+  // Beta version logic
+  if (baseCompare > 0) return 1;   // 5.3-beta > 5.2
+  if (baseCompare < 0) return -1;  // 5.1-beta < 5.2
+
+  // Same version but beta → LOWER than stable
+  return -1; // 5.2-beta < 5.2
+}
+
+
+
+
+const ensureAnalyticsFlagsInConfig = (config) => {
+  const analyticsFlagKey = 'ANALYTICS_ENABLED';
+  const legacyAnalyticsFlagKey = ['ANALY', 'STICS_ENABLED'].join('');
+  let updated = false;
+
+  if (!config.android) {
+    config.android = {};
+    updated = true;
+  }
+
+  if (!config.ios) {
+    config.ios = {};
+    updated = true;
+  }
+
+  const syncPlatformFlag = (platformName, platformConfig) => {
+    const existingValue = platformConfig[analyticsFlagKey];
+    const legacyValue = platformConfig[legacyAnalyticsFlagKey];
+    let nextValue = false;
+
+    if (typeof existingValue === 'boolean') {
+      nextValue = existingValue;
+    } else if (typeof legacyValue === 'boolean') {
+      nextValue = legacyValue;
+    } else if (existingValue !== undefined) {
+      console.warn(`⚠️ ${platformName}.ANALYTICS_ENABLED should be true or false. Automatically setting it to false.`);
+    }
+
+    if (platformConfig[analyticsFlagKey] !== nextValue) {
+      platformConfig[analyticsFlagKey] = nextValue;
+      updated = true;
+      console.warn(`⚠️ ${platformName}.ANALYTICS_ENABLED added/updated as ${nextValue}.`);
+    }
+
+    if (legacyAnalyticsFlagKey in platformConfig) {
+      delete platformConfig[legacyAnalyticsFlagKey];
+      updated = true;
+      console.warn(`⚠️ ${platformName}.ANALYTICS_ENABLED spelling corrected.`);
+    }
+
+    if (nextValue === false) {
+      console.warn(`⚠️ Google Analytics is disabled for ${platformName}. Mostly recommended to enable it when IAP is available.`);
+    }
+  };
+
+  syncPlatformFlag('android', config.android);
+  syncPlatformFlag('ios', config.ios);
+
+  return updated;
+};
+
+const checkAppUniqueId=()=>{
+
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  const analyticsFlagsUpdated = ensureAnalyticsFlagsInConfig(config);
+
+  const appUniqueId = config.android?.APP_UNIQUE_ID;
+  const RESIZEABLE_ACTIVITY = config.android?.RESIZEABLE_ACTIVITY;
+  const orientation = config.android?.ORIENTATION;
+
+
+  let logErrorMessage="";
+
+    // 1️⃣ Check if it’s missing
+  if (RESIZEABLE_ACTIVITY === undefined) {
+    logErrorMessage+='❌ Missing android.RESIZEABLE_ACTIVITY option in capacitor.config.json.\n';
+  }
+
+  // 2️⃣ Check if it’s not boolean (true/false only)
+  else if (typeof RESIZEABLE_ACTIVITY !== 'boolean') {
+    logErrorMessage+='❌ Invalid android.RESIZEABLE_ACTIVITY value. Please use only true or false (without quotes).\n';
+  }
+
+
+
+  if (!orientation) {
+    logErrorMessage+='❌ Missing android.ORIENTATION option in capacitor.config.json.\n';
+  } 
+
+  else if(orientation!="portrait" && orientation!="landscape" && orientation!="auto")
+  {
+    logErrorMessage+='❌ Spelling mistake in android.ORIENTATION option in capacitor.config.json. Please use only ["portrait" "landscape" "auto"]\n';
+  }
+
+
+  if (!appUniqueId) {
+    logErrorMessage+='❌ APP_UNIQUE_ID is missing in capacitor.config.json.';
+  }
+
+  else if (!Number.isInteger(appUniqueId)) {
+    logErrorMessage+='❌ APP_UNIQUE_ID must be an integer. Example: 1, 2, 3, etc.';
+  }
+
+  if(logErrorMessage!="")
+  {
+    if (analyticsFlagsUpdated) {
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+      console.log('✅ capacitor.config.json analytics flags synced.');
+    }
+
+    console.error(logErrorMessage);
+    process.exit(1)
+  }
+
+  if (analyticsFlagsUpdated) {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log('✅ capacitor.config.json analytics flags synced.');
+  }
+
+
+  console.log(`✅ APP_UNIQUE_ID is valid: ${appUniqueId}`);
+  warnForNonAutoOrientationConfig(orientation, RESIZEABLE_ACTIVITY);
+
+}
+
+function readBuildConfirmationInput(question) {
+  process.stdout.write(question);
+
+  const buffer = Buffer.alloc(1024);
+  let answer = "";
+
+  while (!answer.includes("\n")) {
+    const bytesRead = fs.readSync(0, buffer, 0, buffer.length, null);
+
+    if (bytesRead === 0) {
+      return null;
+    }
+
+    answer += buffer.toString("utf8", 0, bytesRead);
+  }
+
+  return answer.trim().toLowerCase();
+}
+
+function warnForNonAutoOrientationConfig(orientation, RESIZEABLE_ACTIVITY) {
+  if (orientation === "auto" && RESIZEABLE_ACTIVITY === true) {
+    return;
+  }
+
+  console.warn(`
+⚠️ WARNING: Android orientation/resizable settings are not set to the recommended values.
+
+Current:
+  android.ORIENTATION: ${orientation}
+  android.RESIZEABLE_ACTIVITY: ${RESIZEABLE_ACTIVITY}
+
+Recommended:
+  android.ORIENTATION: auto
+  android.RESIZEABLE_ACTIVITY: true
+
+Press Enter, y, or yes to continue.
+Press n, no, or not to stop the build.
+`);
+
+  while (true) {
+    const answer = readBuildConfirmationInput("Continue build? (Y/n): ");
+
+    if (answer === "" || answer === "y" || answer === "yes") {
+      console.log("✅ Continuing build...");
+      return;
+    }
+
+    if (answer === null) {
+      console.log("❌ Build cancelled because no user input was received.");
+      process.exit(1);
+    }
+
+    if (answer === "n" || answer === "no" || answer === "not") {
+      console.log("❌ Build cancelled due to orientation/resizable settings.");
+      process.exit(1);
+    }
+
+    console.log("Please enter y, yes, n, no, not, or press Enter.");
+  }
+}
+
+checkAppUniqueId();
+
+
+
+
+
+
+// ======================================================
+// ENSURE IAP STARTS FROM THE HOME PAGE
+// ======================================================
+
+const getHomePagePath = () => {
+  const pagesDir = path.join(ROOT_DIR, "pages");
+  if (!fs.existsSync(pagesDir)) return null;
+
+  const exactHomePath = path.join(pagesDir, "home.f7");
+  if (fs.existsSync(exactHomePath)) return exactHomePath;
+
+  const pageFiles = fs.readdirSync(pagesDir)
+    .filter(fileName => fileName.endsWith(".f7"));
+
+  return pageFiles
+    .map(fileName => path.join(pagesDir, fileName))
+    .find(filePath => /data-name\s*=\s*['"]home['"]/.test(fs.readFileSync(filePath, "utf8"))) || null;
+};
+
+const getRelativeModuleImport = (sourceFile, targetFile) => {
+  let relativePath = path.relative(path.dirname(sourceFile), targetFile).replace(/\\/g, "/");
+  if (!relativePath.startsWith(".")) relativePath = `./${relativePath}`;
+  return relativePath;
+};
+
+const addInitIapToExistingImport = (content) => {
+  const iapImportRegex = /import\s*\{([^}]*)\}\s*from\s*(['"])([^'"]*\/IAP-\d+(?:\.\d+)*\/IAP-check-And-LoadAd\.js)\2\s*;?/;
+  const match = content.match(iapImportRegex);
+  if (!match || /\binitIAP\b/.test(match[1])) return content;
+
+  const importNames = match[1].trim();
+  const nextImportNames = importNames ? `initIAP, ${importNames}` : "initIAP";
+  return content.replace(iapImportRegex, `import { ${nextImportNames} } from ${match[2]}${match[3]}${match[2]};`);
+};
+
+const addInitIapCall = (content) => {
+  if (/\binitIAP\s*\(/.test(content)) return content;
+
+  const pageInitRegex = /(\$on\(\s*(['"])pageInit\2\s*,\s*(?:async\s*)?\(\)\s*=>\s*\{\s*\r?\n)/;
+  if (pageInitRegex.test(content)) {
+    return content.replace(pageInitRegex, "$1    initIAP();\n");
+  }
+
+  const componentStartRegex = /(export\s+default\s*\([^)]*\)\s*=>\s*\{\s*\r?\n)/;
+  if (componentStartRegex.test(content)) {
+    return content.replace(componentStartRegex, "$1  initIAP();\n");
+  }
+
+  throw new Error("Unable to find a Framework7 component or pageInit lifecycle for IAP startup.");
+};
+
+const ensureIapStartupOnHomePage = () => {
+  const iapConfig = getAdmobIapConfig()?.IAP;
+  if (!isAnyIapStoreEnabled(iapConfig)) {
+    console.log("ℹ️ IAP is disabled for every store. AdMob will use direct startup.");
+    return;
+  }
+
+  const latestIapDir = getLatestIapDir();
+  if (!latestIapDir) {
+    throw new Error("IAP is enabled but no IAP-x.x folder was found.");
+  }
+
+  const homePagePath = getHomePagePath();
+  if (!homePagePath) {
+    throw new Error("IAP is enabled but a Framework7 Home page could not be found in src/pages.");
+  }
+
+  const iapModulePath = path.join(latestIapDir, "IAP-check-And-LoadAd.js");
+  if (!fs.existsSync(iapModulePath)) {
+    throw new Error(`IAP startup module is missing: ${iapModulePath}`);
+  }
+
+  let content = fs.readFileSync(homePagePath, "utf8");
+  const originalContent = content;
+  const staticInitImportRegex = /import\s*\{[^}]*\binitIAP\b[^}]*\}\s*from\s*['"][^'"]*\/IAP-\d+(?:\.\d+)*\/IAP-check-And-LoadAd\.js['"]\s*;?/;
+
+  content = addInitIapToExistingImport(content);
+
+  if (!staticInitImportRegex.test(content)) {
+    const relativeImport = getRelativeModuleImport(homePagePath, iapModulePath);
+    const scriptStartRegex = /<script>\s*\r?\n/;
+    if (!scriptStartRegex.test(content)) {
+      throw new Error(`Unable to find the script block in ${homePagePath}`);
+    }
+    content = content.replace(scriptStartRegex, `$&import { initIAP } from '${relativeImport}';\n`);
+  }
+
+  content = addInitIapCall(content);
+
+  if (content !== originalContent) {
+    fs.writeFileSync(homePagePath, content, "utf8");
+    console.log(`✅ Added direct IAP startup to ${path.relative(process.cwd(), homePagePath)}.`);
+  } else {
+    console.log(`ℹ️ Direct IAP startup already configured in ${path.relative(process.cwd(), homePagePath)}.`);
+  }
+};
+
+// ======================================================
+// ENSURE IAP STARTS FROM THE HOME PAGE END
+// ======================================================
+
+
+
+
+
+
+
+
+
+
+
+//@Codemirror check and install/uninstall the packages START
+//const fs = require("fs");
+//const path = require("path");
+//const { execSync } = require("child_process");
+
+const jsDir = path.join(__dirname, "..", "src", "js");
+
+// 🔍 Detect OLD structure
+const oldEditorDirs = fs.readdirSync(jsDir)
+  .filter(name => /^editor-\d+\.\d+$/.test(name));
+
+// 📁 New structure path (optional, not mandatory)
+const newEditorBaseDir = path.join(jsDir, "editor");
+
+// ======================================================
+// ❌ CASE 1: OLD STRUCTURE FOUND → STOP
+// ======================================================
+if (oldEditorDirs.length > 0) {
+
+  console.error(`
+❌ OLD EDITOR STRUCTURE DETECTED
+
+You are using outdated folder structure:
+  src/js/editor-x.x/
+
+🚨 This is no longer supported.
+
+📦 Found folders:
+${oldEditorDirs.map(d => "  - " + d).join("\n")}
+
+👉 Please move them manually:
+
+  src/js/editor-1.6
+      ⬇
+  src/js/editor/editor-1.6
+
+⚠️ Also ensure:
+  src/js/editor/configuration.json exists
+
+❌ Build stopped.
+`);
+
+  process.exit(1);
+}
+
+// ======================================================
+// ✅ CASE 2: NEW STRUCTURE EXISTS → VALIDATE
+// ======================================================
+if (fs.existsSync(newEditorBaseDir)) {
+
+  // 🔍 Find editor-x.x inside new folder
+  const editorDirs = fs.readdirSync(newEditorBaseDir)
+    .filter(name => /^editor-\d+\.\d+$/.test(name));
+
+  // 👉 If editor folder exists but no versions → skip safely
+  if (editorDirs.length === 0) {
+    console.log("ℹ️ No editor-x.x folders found inside src/js/editor/");
+    return;
+  }
+
+  // ======================================================
+  // ✅ Validate configuration.json (NEW RULE)
+  // ======================================================
+
+  const editorConfigPath = path.join(newEditorBaseDir, "configuration.json");
+
+  // ❌ Missing config
+  if (!fs.existsSync(editorConfigPath)) {
+    console.error(`
+❌ MISSING EDITOR CONFIGURATION FILE
+
+Required:
+  src/js/editor/configuration.json
+
+❌ Build stopped.
+`);
+    process.exit(1);
+  }
+
+  // ❌ Check wrong placement
+  const invalidConfigs = [];
+
+  editorDirs.forEach(dir => {
+    const wrongPath = path.join(newEditorBaseDir, dir, "configuration.json");
+    if (fs.existsSync(wrongPath)) {
+      invalidConfigs.push(`src/js/editor/${dir}/configuration.json`);
+    }
+  });
+
+  if (invalidConfigs.length > 0) {
+    console.error(`
+    ❌ INVALID CONFIGURATION LOCATION
+
+    🚫 configuration.json must NOT be inside version folders.
+
+    Found:
+    ${invalidConfigs.map(p => "  - " + p).join("\n")}
+
+    ✅ Correct:
+      src/js/editor/configuration.json
+
+    ❌ Build stopped.
+    `);
+    process.exit(1);
+  }
+
+  console.log("✅ Editor structure validated.");
+
+  // ======================================================
+  // 🚀 Continue execution (run.js)
+  // ======================================================
+
+  const latestEditorDir = editorDirs.sort((a, b) => {
+    const vA = parseFloat(a.split('-')[1]);
+    const vB = parseFloat(b.split('-')[1]);
+    return vB - vA;
+  })[0];
+
+  const runJsPath = path.join(newEditorBaseDir, latestEditorDir, "run.js");
+
+  if (!fs.existsSync(runJsPath)) {
+    console.error(`❌ run.js not found in ${latestEditorDir}`);
+    process.exit(1);
+  }
+
+  console.log(`🚀 Executing ${runJsPath}...`);
+  execSync(`node "${runJsPath}"`, { stdio: "inherit" });
+}
+
+// ======================================================
+// ✅ CASE 3: NOTHING EXISTS → DO NOTHING
+// ======================================================
+else {
+  console.log("ℹ️ Editor not used in this project. Skipping...");
+}
+
+//@Codemirror check and install/uninstall the packages END
+
+
+
+
+
+
+
+
+
+// Validate saveToGalleryAndSaveAnyFile imports for the build platform START
+
+const saveToGalleryAndSaveFileCheck_iOS = async () => {
+
+  const SOURCE_ROOT = path.resolve(__dirname, '../src');
+  const EXCLUDED_DIR = path.join(SOURCE_ROOT, 'js', 'Ads');
+  const ANDROID_MANIFEST_PATH = path.resolve(__dirname, '../android/app/src/main/AndroidManifest.xml');
+
+
+  // Skip comments and unrelated strings; match static/dynamic imports, re-exports and require.
+  const COMMENT_OR_STRING_REGEX = /\/\/[^\r\n]*|\/\*[\s\S]*?\*\/|(['"`])(?:\\[\s\S]|(?!\1)[^\\])*\1/g;
+  const IMPORT_REGEX = /(['"`])(?:\\[\s\S]|(?!\1)[^\\])*\1|\b(?:import\s+(?:[^;'"`]*?\s+from\s*)?|export\s+[^;'"`]*?\s+from\s*|(?:import|require)\s*\(\s*)(['"])([^'"\r\n]+)\2/g;
+  const SAVE_FILE_REGEX = /^(.*[\/\\])?(saveToGalleryAndSaveAnyFile-\d+(?:\.\d+)*)(-ios)?(\.js)?([?#].*)?$/;
+  const pendingChanges = [];
+
+  const ALLOWED_EXTENSIONS = ['.js', '.mjs', '.ts', '.f7'];
+  const referencedVersions = new Set();
+  let aliasImportFound = false;
+  let hasForbiddenEditorImport = false;
+  const FORBIDDEN_REGEX = /editor\/editor-\d+(\.\d+)+/;
+const ERROR_MESSAGE = `const ERROR_MESSAGE = ❌ Invalid import detected!
+
+You are using a direct version-based path like: editor/editor-x.x/editor.js
+
+🚫 This is NOT allowed.
+
+👉 Please use the proper alias or updated import method.
+	Example: import { ... } from '@editor'
+	
+⚠️ Do not use version-based paths in imports.
+👉 Please add this manually in vite.config.js:
+
+alias: {
+  '@editor': path.resolve(__dirname, './src/js/editor/editor-x.x')
+}`
+
+  const isIOSBuild = buildPlatform === 'ios';
+
+  let iosImportFound = false;
+  let androidImportFound = false;
+
+// Files to skip completely (full or partial match)
+const SKIP_FILES = [
+  'pdf-3.11.174.min.js',
+  'pdf.worker-3.11.174.min.js'
+  ,'index.browser.js'
+];
+
+
+
+const STATUSBAR_FILE = path.resolve(__dirname, '../src/js/common-configuration.js');
+const STATUSBAR_REGEX = /^(?!\s*\/\/).*Capacitor\.Plugins\.StatusBar\.setStyle/m;
+
+
+function scanSourceFile(dir) {
+/*
+  //#########################  DO NOT DELETE THIS - START [Appid base validation] #####################################
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  const appUniqueId = config.android?.APP_UNIQUE_ID;
+  if (appUniqueId == "206") return;
+  //#########################  DO NOT DELETE THIS - END [Appid base validation] #####################################
+*/
+
+    const baseName = path.basename(dir);
+    const isGalleryScope = ['certificate', 'pages', 'js'].some(folder =>
+      dir.startsWith(path.join(SOURCE_ROOT, folder) + path.sep)
+    ) || dir === path.join(SOURCE_ROOT, 'app.f7');
+    const shouldCheckGallery = isGalleryScope && !dir.startsWith(EXCLUDED_DIR + path.sep)
+      && !dir.split(path.sep).includes('node_modules') && !SKIP_FILES.includes(baseName)
+      && ALLOWED_EXTENSIONS.some(ext => dir.endsWith(ext));
+    const shouldCheckEditor = /\.(js|ts|f7)$/.test(dir);
+    const shouldCheckOneSignal = /\.(js|mjs|cjs|ts|tsx|jsx|f7)$/.test(dir);
+    if (!shouldCheckGallery && !shouldCheckEditor && !shouldCheckOneSignal) return;
+
+    const content = fs.readFileSync(dir, 'utf8');
+    if (shouldCheckEditor) {
+      content.split('\n').forEach((line, index) => {
+        if (!FORBIDDEN_REGEX.test(line)) return;
+        console.error(`❌ Forbidden import found:\nFile: ${dir}\nLine: ${index + 1}\nCode: ${line.trim()}\n`, ERROR_MESSAGE);
+        hasForbiddenEditorImport = true;
+      });
+    }
+    if (dir === STATUSBAR_FILE) {
+      const contentWithoutComments = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+      if (contentWithoutComments.includes('Capacitor.Plugins.StatusBar.setStyle')) {
+        throw new Error(`❌ StatusBar.setStyle should NOT be used in common-configuration.js. File: ${dir}`);
+      }
+    }
+
+    const code = content.replace(COMMENT_OR_STRING_REGEX, (match, quote) =>
+      quote ? match : match.replace(/[^\r\n]/g, ' ')
+    );
+    const replacements = [];
+    IMPORT_REGEX.lastIndex = 0;
+    let imported;
+    while ((imported = IMPORT_REGEX.exec(code)) !== null) {
+      if (!imported[3]) continue;
+      const importPath = imported[3];
+      if (importPath === ONESIGNAL_PLUGIN_NAME || importPath.startsWith(ONESIGNAL_PLUGIN_NAME + '/')) {
+        throw new Error(`❌ OneSignal was removed, but ${dir} still imports ${importPath}. Remove that import and its initialization before building.`);
+      }
+      if (!shouldCheckGallery) continue;
+      if (/^@saveGallery[?#]/.test(importPath)) {
+        throw new Error(`❌ ${importPath} in ${dir} requires a dedicated Vite alias for its query/hash suffix.`);
+      }
+      if (importPath === '@saveGallery') {
+        aliasImportFound = true;
+        continue;
+      }
+      const fileMatch = importPath.match(SAVE_FILE_REGEX);
+      if (!fileMatch) continue;
+      if (fileMatch[5]) {
+        throw new Error(`❌ Cannot migrate ${importPath} in ${dir} to a plain @saveGallery alias: its query/hash suffix requires a dedicated Vite alias.`);
+      }
+      referencedVersions.add(fileMatch[2]);
+      const nextImportPath = '@saveGallery';
+      const offset = imported.index + imported[0].lastIndexOf(imported[2] + importPath + imported[2]) + 1;
+      replacements.push({ offset, importPath, nextImportPath });
+    }
+
+    if (replacements.length) {
+      let nextContent = content;
+      for (const replacement of [...replacements].reverse()) {
+        nextContent = nextContent.slice(0, replacement.offset) + replacement.nextImportPath
+          + nextContent.slice(replacement.offset + replacement.importPath.length);
+      }
+      pendingChanges.push({ filePath: dir, content, nextContent, replacements });
+    }
+}
+
+// One source content pass handles gallery migration, retired OneSignal imports, StatusBar and editor validation.
+for (const sourceFile of getSourceFiles()) scanSourceFile(sourceFile);
+if (hasForbiddenEditorImport) throw new Error('🚫 Build failed due to forbidden editor imports.');
+console.log('✅ No forbidden editor imports found.');
+
+if (referencedVersions.size || aliasImportFound) {
+  const viteConfigPath = getViteConfigPath();
+  if (!viteConfigPath) throw new Error('❌ Cannot configure @saveGallery: vite.config.js or vite.config.mjs is missing.');
+  const viteContent = fs.readFileSync(viteConfigPath, 'utf8');
+  const viteCode = viteContent.replace(COMMENT_OR_STRING_REGEX, (match, quote) =>
+    quote ? match : match.replace(/[^\r\n]/g, ' ')
+  );
+  const aliasRegex = /(['"])@saveGallery\1\s*:\s*path\.resolve\(\s*__dirname\s*,\s*(['"])([^'"]+)\2\s*\)/g;
+  const aliasMatches = [...viteCode.matchAll(aliasRegex)];
+  if (aliasMatches.length > 1) throw new Error('❌ Multiple active @saveGallery alias entries found. Keep one entry.');
+  const aliasMatch = aliasMatches[0];
+  if (!aliasMatch && /['"]@saveGallery['"]\s*:/.test(viteCode)) {
+    throw new Error('❌ Unsupported @saveGallery alias format. Use path.resolve(__dirname, a literal file path).');
+  }
+  if (aliasImportFound && aliasMatch) {
+    const existingName = path.basename(aliasMatch[3]).match(SAVE_FILE_REGEX);
+    if (!existingName) throw new Error('❌ @saveGallery must point to a versioned saveToGalleryAndSaveAnyFile helper.');
+    referencedVersions.add(existingName[2]);
+  }
+  if (!referencedVersions.size) {
+    const jsDir = path.join(SOURCE_ROOT, 'js');
+    const pattern = isIOSBuild ? /^saveToGalleryAndSaveAnyFile-\d+(?:\.\d+)*-ios\.js$/ : /^saveToGalleryAndSaveAnyFile-\d+(?:\.\d+)*\.js$/;
+    const latestFile = getLatestVersionedFileName(jsDir, pattern);
+    if (!latestFile) throw new Error(`❌ No ${buildPlatform} save-gallery helper found in src/js.`);
+    referencedVersions.add(latestFile.match(SAVE_FILE_REGEX)[2]);
+  }
+  if (referencedVersions.size !== 1) {
+    throw new Error(`❌ @saveGallery cannot represent multiple helper versions: ${[...referencedVersions].join(', ')}. Align them before building.`);
+  }
+  const baseName = [...referencedVersions][0];
+  const targetRelativePath = `./src/js/${baseName}${isIOSBuild ? '-ios' : ''}.js`;
+  const targetPath = path.resolve(path.dirname(viteConfigPath), targetRelativePath);
+  if (!fs.existsSync(targetPath)) throw new Error(`❌ Cannot configure @saveGallery: target file does not exist: ${targetPath}`);
+  const aliasEntry = `'@saveGallery': path.resolve(__dirname, '${targetRelativePath}')`;
+  let nextViteContent = viteContent;
+  if (aliasMatch) {
+    if (path.resolve(path.dirname(viteConfigPath), aliasMatch[3]) !== targetPath) {
+      nextViteContent = viteContent.slice(0, aliasMatch.index) + aliasEntry + viteContent.slice(aliasMatch.index + aliasMatch[0].length);
+    }
+  } else {
+    const aliasHeader = /\balias\s*:\s*\{/g.exec(viteCode);
+    const resolveHeader = /\bresolve\s*:\s*\{/g.exec(viteCode);
+    const returnHeader = /\breturn\s*\{/g.exec(viteCode);
+    const newline = viteContent.includes('\r\n') ? '\r\n' : '\n';
+    const header = aliasHeader || resolveHeader || returnHeader;
+    if (!header || (!aliasHeader && /\balias\s*:/.test(viteCode))) {
+      throw new Error('❌ Cannot safely insert @saveGallery in this Vite config. Add a resolve.alias object first.');
+    }
+    const insert = aliasHeader ? `${newline}        ${aliasEntry},`
+      : resolveHeader ? `${newline}      alias: { ${aliasEntry} },`
+      : `${newline}    resolve: { alias: { ${aliasEntry} } },`;
+    const offset = header.index + header[0].length;
+    nextViteContent = viteContent.slice(0, offset) + insert + viteContent.slice(offset);
+  }
+  nextViteContent = ensureImportOrRequire(nextViteContent, 'path', "import path from 'path';", "const path = require('path');");
+  if (nextViteContent !== viteContent) {
+    pendingChanges.unshift({ filePath: viteConfigPath, content: viteContent, nextContent: nextViteContent,
+      replacements: [{ importPath: aliasMatch ? aliasMatch[3] : '(missing @saveGallery alias)', nextImportPath: targetRelativePath }] });
+  }
+  if (isIOSBuild) iosImportFound = true;
+  else androidImportFound = true;
+}
+
+if (pendingChanges.length) {
+  console.warn(`\n⚠️ WARNING: This build is considered ${isIOSBuild ? 'iOS' : 'Android'}.`);
+  console.warn('The following source imports and Vite alias targets will be changed:');
+  for (const change of pendingChanges) {
+    console.warn(`\n📄 ${change.filePath}`);
+    for (const replacement of change.replacements) {
+      console.warn(`   ${replacement.importPath} → ${replacement.nextImportPath}`);
+    }
+  }
+
+  const confirmed = await new Promise(resolve => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.on('close', () => resolve(false));
+    rl.on('SIGINT', () => { resolve(false); rl.close(); });
+    rl.question('\nPress Enter or type y to apply these changes and continue; any other answer cancels: ', answer => {
+      const normalizedAnswer = answer.trim().toLowerCase();
+      resolve(normalizedAnswer === '' || normalizedAnswer === 'y');
+      rl.close();
+    });
+  });
+  if (!confirmed) throw new Error('❌ Build cancelled. No import filenames were changed.');
+
+  // Check every source again before writing so edits made while awaiting confirmation are preserved.
+  for (const change of pendingChanges) {
+    if (fs.readFileSync(change.filePath, 'utf8') !== change.content) {
+      throw new Error(`❌ Source changed while awaiting confirmation: ${change.filePath}. Build cancelled; run it again.`);
+    }
+  }
+  for (const change of pendingChanges) {
+    fs.writeFileSync(change.filePath, change.nextContent, 'utf8');
+    console.log(`✅ Updated platform imports in: ${change.filePath}`);
+  }
+}
+
+// The alias selects exactly one helper for the target platform.
+if (iosImportFound) {
+  console.log('✅ iOS import detected (valid for iOS build).');
+} else if (androidImportFound) {
+  console.log('✅ Android import detected (valid for Android build).');
+} else {
+  console.log('✅ No platform-specific saveToGalleryAndSaveAnyFile imports found.');
+}
+
+
+  // Android Checks
+  if (buildPlatform === 'android' && androidImportFound) {
+    console.log("📱 Android version of saveToGalleryAndSaveAnyFile detected. Checking AndroidManifest.xml...");
+
+    if (!fs.existsSync(ANDROID_MANIFEST_PATH)) {
+      console.error("❌ AndroidManifest.xml not found. Cannot add requestLegacyExternalStorage attribute.");
+      return;
+    }
+
+    let manifestContent = fs.readFileSync(ANDROID_MANIFEST_PATH, 'utf8');
+
+    if (!manifestContent.includes('android:requestLegacyExternalStorage="true"')) {
+      console.log("Adding android:requestLegacyExternalStorage=\"true\" to <application> tag...");
+
+      manifestContent = manifestContent.replace(
+        /<application([^>]*)>/,
+        (match, attrs) => {
+          if (attrs.includes('android:requestLegacyExternalStorage')) return match;
+          return `<application${attrs} android:requestLegacyExternalStorage="true">`;
+        }
+      );
+
+      fs.writeFileSync(ANDROID_MANIFEST_PATH, manifestContent, 'utf8');
+      console.log("✅ android:requestLegacyExternalStorage=\"true\" added successfully.");
+    } else {
+      console.log("ℹ️  android:requestLegacyExternalStorage already exists in AndroidManifest.xml.");
+    }
+  } else {
+    console.log("✅ No Android saveToGalleryAndSaveAnyFile imports detected.");
+  }
+};
+
+await saveToGalleryAndSaveFileCheck_iOS();
+// Validate saveToGalleryAndSaveAnyFile imports for the build platform END
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+// Clean up AppleDouble files (._*) created by macOS START
+if (process.platform === 'darwin') {
+  try {
+    console.log('🧹 Cleaning up AppleDouble files (._*)...');
+    execSync(`find . -name '._*' -delete`);
+    console.log('✅  AppleDouble files removed.');
+  } catch (err) {
+    console.warn('⚠️  Failed to remove AppleDouble files:', err.message);
+  }
+} else {
+  console.log('ℹ️  Skipping AppleDouble cleanup — not a macOS machine.');
+}
+
+// Clean up AppleDouble files (._*) created by macOS END
+*/
+
+
+
+
+
+
+//In routes.js file check static import START
+
+const routesPath = path.join(process.cwd(), 'src', 'js', 'routes.js');
+const routesContent = fs.readFileSync(routesPath, 'utf-8');
+
+let inBlockComment = false;
+const lines = routesContent.split('\n');
+
+const allowedImport = `import HomePage from '../pages/home.f7';`;
+const badImportRegex = /^[ \t]*import\s+[\w{}*,\s]*\s+from\s+['"].+\.f7['"]\s*;/;
+const badImports = [];
+
+lines.forEach((line, index) => {
+  const trimmed = line.trim();
+
+  // Handle block comment start and end
+  if (trimmed.startsWith('/*')) inBlockComment = true;
+  if (inBlockComment && trimmed.endsWith('*/')) {
+    inBlockComment = false;
+    return;
+  }
+
+  // Skip if inside block comment or line comment
+  if (inBlockComment || trimmed.startsWith('//')) return;
+
+  // Match static .f7 import
+  if (badImportRegex.test(trimmed) && trimmed !== allowedImport) {
+    badImports.push({ line: trimmed, number: index + 1 });
+  }
+});
+
+if (badImports.length > 0) {
+  console.error('\n❌ ERROR: Detected disallowed static imports of .f7 files in routes.js\n');
+  console.error(`⚠️  Only this static import is allowed:\n    ${allowedImport}\n`);
+  console.error(`🔧 Please convert other imports to async dynamic imports like this:\n`);
+  console.error(`
+
+import HomePage from '../pages/home.f7';
+
+const routes = [
+  {
+    path: '/',
+    component:HomePage,
+  },
+  {
+    path: '/ProfilePage/',
+    async async({ resolve }) {
+      const page = await import('../pages/profile.f7');
+      resolve({ component: page.default });
+    },
+  }]
+`);
+  
+  badImports.forEach(({ line, number }) => {
+    console.error(`${number}: ${line}`);
+  });
+
+  process.exit(1);
+} else {
+  console.log('✅ routes.js passed the .f7 import check.');
+}
+
+//In routes.js file check static import END
+
+
+
+
+
+
+
+
+
+
+
+
+
+// Check and change the "BridgeWebViewClient.java" file START
+/*
+For crash issue due to low memory problem, we need to modify the onRenderProcessGone method in BridgeWebViewClient.java.
+*/
+
+
+const bridgeWebViewClientFilePath = path.join(process.cwd(), 'node_modules', '@capacitor/android/capacitor/src/main/java/com/getcapacitor', 'BridgeWebViewClient.java');
+
+// Read the file
+if (!fs.existsSync(bridgeWebViewClientFilePath)) {
+  console.error('❌ Error: BridgeWebViewClient.java not found.');
+  process.exit(1);
+}
+
+let fileContent = fs.readFileSync(bridgeWebViewClientFilePath, 'utf8');
+const bridgeWebViewLineEnding = fileContent.includes('\r\n') ? '\r\n' : '\n';
+fileContent = fileContent.replace(/\r\n/g, '\n');
+
+// Define old and new code
+const oldCodeStart = `@Override
+    public boolean onRenderProcessGone(WebView view, RenderProcessGoneDetail detail) {
+        super.onRenderProcessGone(view, detail);
+        boolean result = false;
+
+        List<WebViewListener> webViewListeners = bridge.getWebViewListeners();
+        if (webViewListeners != null) {
+            for (WebViewListener listener : bridge.getWebViewListeners()) {
+                result = listener.onRenderProcessGone(view, detail) || result;
+            }
+        }
+
+        return result;
+    }`;
+
+// Match the previous patch so existing projects migrate without reinstalling Capacitor.
+const legacyReloadCode = `@Override
+    public boolean onRenderProcessGone(WebView view, RenderProcessGoneDetail detail) {
+        super.onRenderProcessGone(view, detail);
+
+        boolean result = false;
+
+        List<WebViewListener> webViewListeners = bridge.getWebViewListeners();
+        if (webViewListeners != null) {
+            for (WebViewListener listener : bridge.getWebViewListeners()) {
+                result = listener.onRenderProcessGone(view, detail) || result;
+            }
+        }
+
+        if (!result) {
+            // If no one handled it, handle it ourselves!
+
+            /*if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                if (detail.didCrash()) {
+                    //Log.e("CapacitorWebView", "WebView crashed internally!");
+                } else {
+                    //Log.w("CapacitorWebView", "WebView was killed by system (low memory) internally!");
+                }
+            }*/
+
+            view.post(() -> {
+                Toast.makeText(view.getContext(), "Reloading due to low memory issue", Toast.LENGTH_SHORT).show();
+            });
+
+            view.reload(); // Safely reload WebView
+
+            return true; // We handled it
+        }
+
+        return result;
+    }`;
+
+const newCode = `// Codeplay WebView renderer recovery (before-build 6.5).
+    private boolean codeplayRendererRecoveryPending = false;
+    private static long codeplayRendererRecoveryWindowStart = -1L;
+    private static int codeplayRendererRecoveryCount = 0;
+
+    @Override
+    public boolean onRenderProcessGone(WebView view, RenderProcessGoneDetail detail) {
+        if (codeplayRendererRecoveryPending) return true;
+
+        boolean handled = false;
+        List<WebViewListener> webViewListeners = bridge.getWebViewListeners();
+        if (webViewListeners != null) {
+            for (WebViewListener listener : webViewListeners) {
+                handled = listener.onRenderProcessGone(view, detail) || handled;
+            }
+        }
+        if (handled) return true;
+
+        codeplayRendererRecoveryPending = true;
+        final androidx.appcompat.app.AppCompatActivity activity = bridge.getActivity();
+        final boolean wasInForeground = activity != null && activity.getLifecycle()
+            .getCurrentState().isAtLeast(androidx.lifecycle.Lifecycle.State.STARTED);
+
+        // A terminated renderer's WebView must never be loaded or reloaded again.
+        if (view.getParent() instanceof android.view.ViewGroup) {
+            ((android.view.ViewGroup) view.getParent()).removeView(view);
+        }
+        view.destroy();
+
+        if (activity == null || activity.isFinishing() || activity.isDestroyed()) return true;
+
+        final android.os.Handler mainHandler = new android.os.Handler(android.os.Looper.getMainLooper());
+        final Runnable recover = () -> {
+            if (activity.isFinishing() || activity.isDestroyed()) return;
+
+            // Static counters survive Activity recreation and prevent an automatic restart loop.
+            long now = android.os.SystemClock.elapsedRealtime();
+            if (codeplayRendererRecoveryWindowStart < 0L ||
+                now - codeplayRendererRecoveryWindowStart >= 60000L) {
+                codeplayRendererRecoveryWindowStart = now;
+                codeplayRendererRecoveryCount = 0;
+            }
+
+            if (codeplayRendererRecoveryCount >= 3) {
+                new android.app.AlertDialog.Builder(activity)
+                    .setTitle("Unable to restore the app")
+                    .setMessage("The app could not recover automatically. Please try again.")
+                    .setCancelable(false)
+                    .setPositiveButton("Try again", (dialog, which) -> {
+                        codeplayRendererRecoveryWindowStart = -1L;
+                        codeplayRendererRecoveryCount = 0;
+                        if (!activity.isFinishing() && !activity.isDestroyed()) activity.recreate();
+                    })
+                    .setNegativeButton("Close", (dialog, which) -> activity.finish())
+                    .show();
+                return;
+            }
+
+            codeplayRendererRecoveryCount++;
+            if (!wasInForeground) {
+                Toast.makeText(activity.getApplicationContext(), "Restoring your app…", Toast.LENGTH_SHORT).show();
+            }
+            activity.recreate();
+        };
+
+        if (wasInForeground) {
+            mainHandler.post(recover);
+        } else {
+            // Do not allocate another renderer while the app is hidden and memory may still be low.
+            activity.getLifecycle().addObserver(new androidx.lifecycle.LifecycleEventObserver() {
+                @Override
+                public void onStateChanged(
+                    androidx.lifecycle.LifecycleOwner source,
+                    androidx.lifecycle.Lifecycle.Event event
+                ) {
+                    if (event == androidx.lifecycle.Lifecycle.Event.ON_RESUME) {
+                        source.getLifecycle().removeObserver(this);
+                        mainHandler.post(recover);
+                    } else if (event == androidx.lifecycle.Lifecycle.Event.ON_DESTROY) {
+                        source.getLifecycle().removeObserver(this);
+                    }
+                }
+            });
+        }
+        return true;
+    }`;
+
+// Step 1: Update the stock method or migrate the previous reload-based patch.
+let updated = false;
+
+if (fileContent.includes(newCode)) {
+  console.log('ℹ️  Method already updated. No changes needed in "BridgeWebViewClient.java".');
+} else if (fileContent.includes(legacyReloadCode)) {
+  fileContent = fileContent.replace(legacyReloadCode, newCode);
+  updated = true;
+} else if (fileContent.includes(oldCodeStart)) {
+  fileContent = fileContent.replace(oldCodeStart, newCode);
+  updated = true;
+} else {
+  console.error('❌ Error: Neither old nor new code found. Unexpected content.');
+  process.exit(1);
+}
+
+// Step 2: Check and add import if missing
+const importToast = 'import android.widget.Toast;';
+if (!fileContent.includes(importToast)) {
+  console.log('✅ Adding missing import for Toast...');
+  const importRegex = /import\s+[^;]+;/g;
+  const matches = [...fileContent.matchAll(importRegex)];
+
+  if (matches.length > 0) {
+    const lastImport = matches[matches.length - 1];
+    const insertPosition = lastImport.index + lastImport[0].length;
+    fileContent = fileContent.slice(0, insertPosition) + `\n${importToast}` + fileContent.slice(insertPosition);
+    updated = true;
+  } else {
+    console.error('❌ Error: No import section found in file.');
+    process.exit(1);
+  }
+} else {
+  console.log('ℹ️  Import for Toast already exists. No changes needed.');
+}
+
+// Step 3: Save if updated
+if (updated) {
+  fs.writeFileSync(bridgeWebViewClientFilePath, fileContent.replace(/\n/g, bridgeWebViewLineEnding), 'utf8');
+  console.log('✅ File updated successfully.');
+} else {
+  console.log('ℹ️  No changes needed.');
+}
+
+
+
+
+// Check and change the "BridgeWebViewClient.java" file END
+
+
+
+
+
+
+
+
+/*
+// To resolve the kotlin version issue, we need to update the kotlin version in the build.gradle file START
+
+// Build the path dynamically like you requested
+const gradlePath = path.join(
+  process.cwd(), 
+  'android', 
+  'build.gradle'
+);
+
+// Read the existing build.gradle
+let gradleContent = fs.readFileSync(gradlePath, 'utf8');
+
+// Add `ext.kotlin_version` if it's not already there
+if (!gradleContent.includes('ext.kotlin_version')) {
+  gradleContent = gradleContent.replace(
+    /buildscript\s*{/,
+    `buildscript {\n    ext.kotlin_version = '2.1.0'`
+  );
+}
+
+// Add Kotlin classpath if it's not already there
+if (!gradleContent.includes('org.jetbrains.kotlin:kotlin-gradle-plugin')) {
+  gradleContent = gradleContent.replace(
+    /dependencies\s*{([\s\S]*?)classpath 'com.android.tools.build:gradle:8.7.2'/,
+    `dependencies {\n        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version")\n$1classpath 'com.android.tools.build:gradle:8.7.2'`
+  );
+}
+
+// Write back the modified content
+fs.writeFileSync(gradlePath, gradleContent, 'utf8');
+
+console.log('✅ Kotlin version updated in build.gradle.');
+
+// To resolve the kotlin version issue, we need to update the kotlin version in the build.gradle file END
+*/
+
+
+
+
+
+
+
+
+let _admobConfig;
+
+
+
+const androidPlatformPath = path.join(process.cwd(), 'android');
+const iosPlatformPath = path.join(process.cwd(), 'ios');
+const androidManifestPath = path.join(process.cwd(), 'android', 'app', 'src', 'main', 'AndroidManifest.xml');
+const androidAppBuildGradlePath = path.join(process.cwd(), 'android', 'app', 'build.gradle');
+const AMAZON_WINDOW_EXTENSIONS_DEPENDENCY = 'implementation "androidx.window.extensions.core:core:1.0.0"';
+const AMAZON_WINDOW_EXTENSIONS_DEPENDENCY_PATTERN = /^[ \t]*implementation\s+["']androidx\.window\.extensions\.core:core:[^"']+["'][ \t]*(?:\r?\n)?/gm;
+const infoPlistPath = path.join(process.cwd(), 'ios', 'App', 'App', 'Info.plist');
+const iosSceneDelegatePath = path.join(process.cwd(), 'ios', 'App', 'App', 'SceneDelegate.swift');
+const resourcesPath = path.join(process.cwd(), 'resources', 'res');
+const androidResPath = path.join(process.cwd(), 'android', 'app', 'src', 'main', 'res');
+const localNotificationsPluginPath = path.join(process.cwd(), 'node_modules', '@capacitor', 'local-notifications');
+
+function fileExists(filePath) {
+  return fs.existsSync(filePath);
+}
+
+function copyFolderSync(source, target) {
+  if (!fs.existsSync(target)) {
+    fs.mkdirSync(target, { recursive: true });
+  }
+
+  fs.readdirSync(source).forEach(file => {
+    const sourceFile = path.join(source, file);
+    const targetFile = path.join(target, file);
+
+    if (fs.lstatSync(sourceFile).isDirectory()) {
+      copyFolderSync(sourceFile, targetFile);
+    } else {
+      fs.copyFileSync(sourceFile, targetFile);
+    }
+  });
+}
+
+function checkAndCopyResources() {
+  if (fileExists(resourcesPath)) {
+    copyFolderSync(resourcesPath, androidResPath);
+    console.log('✅ Successfully copied resources/res to android/app/src/main/res.');
+  } else {
+    console.log('resources/res folder not found.');
+
+    if (fileExists(localNotificationsPluginPath)) {
+      throw new Error('❌ resources/res is required for @capacitor/local-notifications. Stopping execution.');
+    }
+  }
+}
+
+
+
+
+
+
+
+
+function getAdMobConfig() {
+  if (!fileExists(configPath)) {
+    throw new Error('❌ capacitor.config.json not found. Ensure this is a Capacitor project.');
+  }
+
+  const capacitorConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  const packageJson = fileExists(packageJsonPath)
+    ? JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
+    : {};
+
+  const legacyAdmobConfig = capacitorConfig.plugins?.AdMob || {};
+  const nextGenAdmobConfig = packageJson.admob || {};
+  const admobJsonAppIds = getAdmobJsonAppIds();
+
+  if (!legacyAdmobConfig && !nextGenAdmobConfig) {
+    throw new Error('❌ AdMob configuration is missing in package.json or capacitor.config.json.');
+  }
+
+  const isEnabled =
+    nextGenAdmobConfig.enabled !== false &&
+    legacyAdmobConfig.ADMOB_ENABLED !== false;
+
+  if (!isEnabled) {
+    return { ADMOB_ENABLED: false };
+  }
+
+  const androidAppId = admobJsonAppIds.androidAppId || nextGenAdmobConfig.androidAppId || legacyAdmobConfig.APP_ID_ANDROID;
+  const iosAppId = admobJsonAppIds.iosAppId || nextGenAdmobConfig.iosAppId || legacyAdmobConfig.APP_ID_IOS;
+  const userTrackingDescription =
+    nextGenAdmobConfig.userTrackingDescription ||
+    legacyAdmobConfig.USER_TRACKING_DESCRIPTION ||
+    'This identifier will be used to deliver personalized ads to you.';
+
+  if (!androidAppId || !iosAppId) {
+    throw new Error(' ❌ AdMob configuration is incomplete. Ensure androidAppId/iosAppId or APP_ID_ANDROID/APP_ID_IOS are defined.');
+  }
+
+  return {
+    ADMOB_ENABLED: true,
+    APP_ID_ANDROID: androidAppId,
+    APP_ID_IOS: iosAppId,
+    USER_TRACKING_DESCRIPTION: userTrackingDescription,
+    USE_LITE_ADS: legacyAdmobConfig.USE_LITE_ADS === "lite",
+  };
+}
+
+function syncNextGenAdmobPackageJsonFromCapacitorConfig() {
+  if (!fileExists(configPath) || !fileExists(packageJsonPath)) {
+    return;
+  }
+
+  const capacitorConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+
+  const legacyAdmobConfig = capacitorConfig.plugins?.AdMob || {};
+  const admobJsonAppIds = getAdmobJsonAppIds();
+  const androidAppId = admobJsonAppIds.androidAppId || legacyAdmobConfig.APP_ID_ANDROID;
+  const iosAppId = admobJsonAppIds.iosAppId || legacyAdmobConfig.APP_ID_IOS;
+
+  if (!androidAppId || !iosAppId) {
+    return;
+  }
+
+  const desiredAdmobConfig = {
+    androidAppId,
+    iosAppId,
+    enableNativeAds: {
+      ios: packageJson.admob?.enableNativeAds?.ios ?? true,
+      android: packageJson.admob?.enableNativeAds?.android ?? true,
+    },
+    userTrackingDescription:
+      packageJson.admob?.userTrackingDescription ||
+      'This identifier will be used to deliver personalized ads to you.',
+  };
+
+  const existingAdmobConfig = packageJson.admob || {};
+  const mergedAdmobConfig = { ...existingAdmobConfig };
+  let updated = false;
+
+  const syncKeyByKey = (target, source) => {
+    for (const [key, value] of Object.entries(source)) {
+      if (value && typeof value === 'object' && !Array.isArray(value)) {
+        if (!target[key] || typeof target[key] !== 'object' || Array.isArray(target[key])) {
+          target[key] = {};
+          updated = true;
+        }
+
+        syncKeyByKey(target[key], value);
+        continue;
+      }
+
+      if (target[key] !== value) {
+        target[key] = value;
+        updated = true;
+      }
+    }
+  };
+
+  syncKeyByKey(mergedAdmobConfig, desiredAdmobConfig);
+
+  if (!updated) {
+    return;
+  }
+
+  packageJson.admob = mergedAdmobConfig;
+  fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf8');
+  console.log(admobJsonAppIds.androidAppId || admobJsonAppIds.iosAppId
+    ? '✅ package.json AdMob settings synced from AdMob configuration JSON'
+    : '✅ package.json AdMob settings synced from capacitor.config.json');
+}
+
+function validateAndroidBuildOptions() {
+
+
+    if (!fileExists(configPath)) {
+    console.log('❌ capacitor.config.json not found. Ensure this is a Capacitor project.');
+    process.exit(1);
+  }
+
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+  const targetAppId=config.appId
+
+  const buildOptions = config.android?.buildOptions;
+  
+  if (!buildOptions) {
+    console.log('❌ Missing android.buildOptions in capacitor.config.json.');
+    process.exit(1);
+  } 
+
+  const requiredProps = [
+    'keystorePath',
+    'keystorePassword',
+    'keystoreAlias',
+    'keystoreAliasPassword',
+    'releaseType',
+    'signingType'
+  ];
+
+  const missing = requiredProps.filter(prop => !buildOptions[prop]);
+  
+  if (missing.length > 0) {
+    console.log('❌ Missing properties android.buildOptions in capacitor.config.json.');
+    process.exit(1);
+  }
+
+  
+  const keystorePath=buildOptions.keystorePath
+  const keyFileName = path.basename(keystorePath);
+
+
+
+  const keystoreMap = {
+    "gameskey.jks": [
+      "com.cube.blaster",
+    ],
+    "htmleditorkeystoke.jks": [
+      "com.HTML.AngularJS.Codeplay",
+      "com.html.codeplay.pro",
+      "com.bootstrap.code.play",
+      "com.kids.learning.master",
+      "com.Simple.Barcode.Scanner",
+      "com.FAShtmlcssjs.editor"
+    ]
+  };
+
+  // find which keystore is required for the given targetAppId
+  let requiredKey = "newappskey.jks"; // default
+  for (const [keyFile, appIds] of Object.entries(keystoreMap)) {
+    if (appIds.includes(targetAppId)) {
+      requiredKey = keyFile;
+      break;
+    }
+  }
+
+  // validate
+  if (keyFileName !== requiredKey) {
+    console.log(`❌ The keystore path is mismatched. Expected ${requiredKey} for ${targetAppId}, but got ${keyFileName}`);
+    process.exit(1);
+  }
+
+
+
+
+
+  // optionally return them
+  //return buildOptions;
+}
+
+function updateAndroidManifest(admobConfig) {
+  if (!fileExists(androidManifestPath)) {
+    console.error(' ❌ AndroidManifest.xml not found. Ensure the Android platform is added.');
+    return;
+  }
+
+  let manifestContent = fs.readFileSync(androidManifestPath, 'utf8');
+  const metaDataTag = `<meta-data android:name="com.google.android.gms.ads.APPLICATION_ID" android:value="${admobConfig.APP_ID_ANDROID}" />`;
+
+  if (/com\.google\.android\.gms\.ads\.APPLICATION_ID/.test(manifestContent)) {
+    manifestContent = manifestContent.replace(
+      /<meta-data\s+android:name="com\.google\.android\.gms\.ads\.APPLICATION_ID"\s+android:value=".*?"\s*\/>/,
+      metaDataTag
+    );
+  } else {
+    manifestContent = manifestContent.replace(
+      /<application\b([^>]*)>/,
+      `<application$1>\n        ${metaDataTag}`
+    );
+  }
+
+  fs.writeFileSync(androidManifestPath, manifestContent, 'utf8');
+  console.log('✅ AdMob Android App ID successfully updated in AndroidManifest.xml');
+}
+
+function updateInfoPlist(admobConfig) {
+  if (!fileExists(infoPlistPath)) {
+    console.error('Info.plist not found. Ensure you have built the iOS project.');
+    return;
+  }
+
+  const plistContent = fs.readFileSync(infoPlistPath, 'utf8');
+  const plistData = plist.parse(plistContent);
+
+  plistData.GADApplicationIdentifier = admobConfig.APP_ID_IOS;
+  if (isKidsAdmobApp()) delete plistData.NSUserTrackingUsageDescription;
+  else plistData.NSUserTrackingUsageDescription = admobConfig.USER_TRACKING_DESCRIPTION;
+  plistData.GADDelayAppMeasurementInit = true;
+
+  // https://developers.google.com/admob/ios/quick-start
+  plistData.SKAdNetworkItems = [
+    { SKAdNetworkIdentifier: 'cstr6suwn9.skadnetwork' }, // Google
+    { SKAdNetworkIdentifier: '4fzdc2evr5.skadnetwork' }, // Aarki
+    { SKAdNetworkIdentifier: '2fnua5tdw4.skadnetwork' }, // Adform
+    { SKAdNetworkIdentifier: 'ydx93a7ass.skadnetwork' }, // Adikteev
+    { SKAdNetworkIdentifier: 'p78axxw29g.skadnetwork' }, // Amazon
+    { SKAdNetworkIdentifier: 'v72qych5uu.skadnetwork' }, // Appier
+    { SKAdNetworkIdentifier: 'ludvb6z3bs.skadnetwork' }, // Applovin
+    { SKAdNetworkIdentifier: 'cp8zw746q7.skadnetwork' }, // Arpeely
+    { SKAdNetworkIdentifier: '3sh42y64q3.skadnetwork' }, // Basis
+    { SKAdNetworkIdentifier: 'c6k4g5qg8m.skadnetwork' }, // Beeswax.io
+    { SKAdNetworkIdentifier: 's39g8k73mm.skadnetwork' }, // Bidease
+    { SKAdNetworkIdentifier: '3qy4746246.skadnetwork' }, // Bigabid
+    { SKAdNetworkIdentifier: 'hs6bdukanm.skadnetwork' }, // Criteo
+    { SKAdNetworkIdentifier: 'mlmmfzh3r3.skadnetwork' }, // Digital Turbine DSP
+    { SKAdNetworkIdentifier: 'v4nxqhlyqp.skadnetwork' }, // i-mobile
+    { SKAdNetworkIdentifier: 'wzmmz9fp6w.skadnetwork' }, // InMobi
+    { SKAdNetworkIdentifier: 'su67r6k2v3.skadnetwork' }, // ironSource Ads
+    { SKAdNetworkIdentifier: 'yclnxrl5pm.skadnetwork' }, // Jampp
+    { SKAdNetworkIdentifier: '7ug5zh24hu.skadnetwork' }, // Liftoff
+    { SKAdNetworkIdentifier: 'gta9lk7p23.skadnetwork' }, // Liftoff Monetize
+    { SKAdNetworkIdentifier: 'vutu7akeur.skadnetwork' }, // LINE
+    { SKAdNetworkIdentifier: 'y5ghdn5j9k.skadnetwork' }, // Mediaforce
+    { SKAdNetworkIdentifier: 'v9wttpbfk9.skadnetwork' }, // Meta (1 of 2)
+    { SKAdNetworkIdentifier: 'n38lu8286q.skadnetwork' }, // Meta (2 of 2)
+    { SKAdNetworkIdentifier: '47vhws6wlr.skadnetwork' }, // MicroAd
+    { SKAdNetworkIdentifier: 'kbd757ywx3.skadnetwork' }, // Mintegral / Mobvista
+    { SKAdNetworkIdentifier: '9t245vhmpl.skadnetwork' }, // Moloco
+    { SKAdNetworkIdentifier: 'a2p9lx4jpn.skadnetwork' }, // Opera
+    { SKAdNetworkIdentifier: '22mmun2rn5.skadnetwork' }, // Pangle
+    { SKAdNetworkIdentifier: '4468km3ulz.skadnetwork' }, // Realtime Technologies GmbH
+    { SKAdNetworkIdentifier: '2u9pt9hc89.skadnetwork' }, // Remerge
+    { SKAdNetworkIdentifier: '8s468mfl3y.skadnetwork' }, // RTB House
+    { SKAdNetworkIdentifier: 'ppxm28t8ap.skadnetwork' }, // Smadex
+    { SKAdNetworkIdentifier: 'uw77j35x4d.skadnetwork' }, // The Trade Desk
+    { SKAdNetworkIdentifier: 'pwa73g5rt2.skadnetwork' }, // Tremor
+    { SKAdNetworkIdentifier: '578prtvx9j.skadnetwork' }, // Unicorn
+    { SKAdNetworkIdentifier: '4dzt52r2t5.skadnetwork' }, // Unity Ads
+    { SKAdNetworkIdentifier: 'tl55sbb4fm.skadnetwork' }, // Verve
+    { SKAdNetworkIdentifier: 'e5fvkxwrpn.skadnetwork' }, // Yahoo!
+    { SKAdNetworkIdentifier: '8c4e2ghe7u.skadnetwork' }, // Yahoo! Japan Ads
+    { SKAdNetworkIdentifier: '3rd42ekr43.skadnetwork' }, // YouAppi
+    { SKAdNetworkIdentifier: '3qcr597p9d.skadnetwork' }, // Zucks
+];
+
+  const updatedPlistContent = plist.build(plistData);
+  fs.writeFileSync(infoPlistPath, updatedPlistContent, 'utf8');
+  console.log('AdMob IDs and additional configurations successfully updated in Info.plist');
+}
+
+function updateIOSSceneDelegateForATT() {
+  if (!fileExists(iosSceneDelegatePath)) {
+    console.warn('SceneDelegate.swift not found. Skipping the iOS ATT scene update.');
+    return;
+  }
+
+  let content = fs.readFileSync(iosSceneDelegatePath, 'utf8');
+  const newline = content.includes('\r\n') ? '\r\n' : '\n';
+  const requestBody = [
+    '        if ATTrackingManager.trackingAuthorizationStatus == .notDetermined &&',
+    '            !isTrackingAuthorizationRequestScheduled {',
+    '            isTrackingAuthorizationRequestScheduled = true',
+    '',
+    '            DispatchQueue.main.asyncAfter(deadline: .now() + 1) { [weak self] in',
+    '                self?.isTrackingAuthorizationRequestScheduled = false',
+    '',
+    '                guard UIApplication.shared.applicationState == .active,',
+    '                      ATTrackingManager.trackingAuthorizationStatus == .notDetermined else { return }',
+    '',
+    '                ATTrackingManager.requestTrackingAuthorization { _ in }',
+    '            }',
+    '        }',
+  ].join(newline);
+
+  // ATT is owned by the ad bootstrap after UMP consent. Remove the block
+  // injected by earlier builds so scene activation cannot race that flow.
+  const originalContent = content;
+  content = content.split(requestBody).join('');
+  if (content.includes('ATTrackingManager.requestTrackingAuthorization')) {
+    throw new Error('SceneDelegate.swift still contains a custom ATT request that can precede UMP consent. Remove that request before building.');
+  }
+  content = content.replace(/^[ \t]*private var isTrackingAuthorizationRequestScheduled = false\r?\n/gm, '');
+  if (!content.includes('ATTrackingManager')) {
+    content = content.replace(/^import AppTrackingTransparency\r?\n/gm, '');
+  }
+  if (content !== originalContent) fs.writeFileSync(iosSceneDelegatePath, content, 'utf8');
+  console.log('iOS startup ATT prompt disabled; the ad consent flow controls ATT.');
+}
+
+
+try {
+  if (!fileExists(configPath)) {
+    throw new Error(' ❌ capacitor.config.json not found. Skipping setup.');
+  }
+
+  if (!fileExists(androidPlatformPath) && !fileExists(iosPlatformPath)) {
+    throw new Error('Neither Android nor iOS platforms are found. Ensure platforms are added to your Capacitor project.');
+  }
+
+  checkAndCopyResources();
+
+  syncNextGenAdmobPackageJsonFromCapacitorConfig();
+
+
+  _admobConfig = getAdMobConfig();
+
+
+  
+
+
+  // Proceed only if ADMOB_ENABLED is true
+  if (_admobConfig.ADMOB_ENABLED) {
+    if (fileExists(androidPlatformPath)) {
+      updateAndroidManifest(_admobConfig);
+    }
+
+    if (fileExists(iosPlatformPath)) {
+      updateInfoPlist(_admobConfig);
+      updateIOSSceneDelegateForATT();
+    }
+  }
+
+
+} catch (error) {
+  console.error(error.message);
+  process.exit(1); // Stop execution if there's a critical error
+}
+
+
+
+validateAndroidBuildOptions();
+
+
+
+
+
+
+// Check all the codeplays plugins version START
+
+
+
+
+//const srcDir = path.join(__dirname, 'src');
+const srcDir = path.join(process.cwd(), 'src');
+let outdatedPlugins = [];
+
+function parseVersion(ver) {
+  return ver.split('.').map(n => parseInt(n, 10));
+}
+
+function compareVersions(v1, v2) {
+  const [a1, b1] = parseVersion(v1);
+  const [a2, b2] = parseVersion(v2);
+  if (a1 !== a2) return a1 - a2;
+  return b1 - b2;
+}
+
+function walkSync(dir, filelist = []) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path.join(dir, entry.name);
+    const isDirectory = entry.isDirectory() || (entry.isSymbolicLink() && fs.statSync(fullPath).isDirectory());
+    if (isDirectory) walkSync(fullPath, filelist);
+    else filelist.push(fullPath);
+  }
+  return filelist;
+}
+
+function getSearchRoot(plugin) {
+  return path.join(srcDir, plugin.baseDir || 'js');
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*##############################################   AUTO DOWNLOAD FROM SERVER START  #####################################*/
+
+// ============================================================
+// 🔥 AUTO PLUGIN UPDATE SYSTEM (MANDATORY UPDATES)
+// ============================================================
+
+const https = require("https");
+
+/**
+ * Check if file exists on server using HEAD request
+ */
+function urlExists(url) {
+  return new Promise(resolve => {
+    const req = https.request(url, { method: "HEAD" }, res => {
+      res.resume();
+      resolve(res.statusCode === 200);
+    });
+
+    req.on("error", () => resolve(false));
+    req.setTimeout(8000, () => {
+      req.destroy();
+      resolve(false);
+    });
+    req.end();
+  });
+}
+
+/**
+ * Download file from server
+ */
+function downloadFile(url, dest) {
+  if (path.resolve(dest).startsWith(path.join(process.cwd(), 'src') + path.sep)) sourceFileInventory = null;
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+
+    const req = https.get(url, response => {
+      if (response.statusCode !== 200) {
+        response.resume();
+        file.close(() => fs.unlink(dest, () => {}));
+        reject("Download failed");
+        return;
+      }
+
+      response.pipe(file);
+
+      file.on("finish", () => {
+        file.close(resolve);
+      });
+    }).on("error", err => {
+      fs.unlink(dest, () => {});
+      reject(err);
+    });
+
+    req.setTimeout(30000, () => {
+      req.destroy();
+      file.close(() => fs.unlink(dest, () => {}));
+      reject(new Error(`Download timed out: ${url}`));
+    });
+  });
+}
+
+/**
+ * Update imports across src folder
+ * Replaces old filename → new filename
+ */
+/**
+ * Update imports across project
+ * Replaces old filename → new filename
+ */
+
+const VITE_ALIAS_ONLY = [
+  "common",
+  "admob-emi",
+  "admob-emi-nextgen",
+  "localization",
+  "theme",
+  "certificatejs",
+  "ffmpeg"
+];
+
+function updateImports(oldName, newName) {
+
+  const projectRoot = process.cwd();
+  const oldSaveHelper = oldName.match(/^(saveToGalleryAndSaveAnyFile-\d+(?:\.\d+)*)(?:-ios)?\.js$/);
+  const newSaveHelper = newName.match(/^(saveToGalleryAndSaveAnyFile-\d+(?:\.\d+)*)(?:-ios)?\.js$/);
+
+  const filesToScan = [
+    path.join(projectRoot, "vite.config.js"),
+    path.join(projectRoot, "vite.config.mjs")
+  ];
+
+  const srcDir = path.join(projectRoot, "src");
+
+  // scan vite config
+  filesToScan.forEach(file => {
+
+    if (!fs.existsSync(file)) return;
+
+    let content = fs.readFileSync(file, "utf8");
+
+    if (content.includes(oldName) || (oldSaveHelper && newSaveHelper && content.includes('@saveGallery'))) {
+
+      content = content.split(oldName).join(newName);
+      // Plugin updates can replace an iOS filename with the generic new filename.
+      // Keep the centralized save-gallery alias aligned with the selected build.
+      content = content.replace(/(['"]@saveGallery['"]\s*:\s*path\.resolve\(\s*__dirname\s*,\s*['"])([^'"]+)(['"]\s*\))/g,
+        (match, prefix, target, suffix) => {
+          if (!/saveToGalleryAndSaveAnyFile-\d+(?:\.\d+)*(?:-ios)?\.js$/.test(target)) return match;
+          if (oldSaveHelper && newSaveHelper && target.includes(oldSaveHelper[1])) {
+            target = target.replace(oldSaveHelper[1], newSaveHelper[1]);
+          }
+          const nextTarget = target.replace(/(?:-ios)?\.js$/, buildPlatform === 'ios' ? '-ios.js' : '.js');
+          if (!fs.existsSync(path.resolve(path.dirname(file), nextTarget))) {
+            throw new Error(`❌ Updated @saveGallery target is missing: ${nextTarget}`);
+          }
+          return prefix + nextTarget + suffix;
+        });
+
+      fs.writeFileSync(file, content);
+
+      console.log(`✏️ Updated alias in ${path.basename(file)}`);
+    }
+
+  });
+
+  // Downloads invalidate the inventory; content-only edits reuse it.
+  for (const full of getSourceFiles()) {
+    const relativePath = path.relative(srcDir, full);
+    if (relativePath.split(path.sep).some(part => ['node_modules', 'android', 'ios', 'dist', '.git'].includes(part))) continue;
+    if (!/\.(js|f7|mjs)$/.test(full) || full.endsWith('.min.js')) continue;
+    let content = fs.readFileSync(full, 'utf8');
+    if (!content.includes(oldName)) continue;
+    content = content.split(oldName).join(newName);
+    fs.writeFileSync(full, content);
+    console.log(`✏️ Updated import in ${path.relative(projectRoot, full)}`);
+  }
+
+}
+
+
+/**
+ * Auto-update a plugin file
+ * Returns TRUE if success
+ * Returns FALSE if fallback to manual needed
+ */
+
+
+let _serverVersions = null;
+async function fetchVersions() {
+
+  if (_serverVersions) return _serverVersions;
+
+  return new Promise((resolve) => {
+
+    https.get(
+      "https://htmlcodeplay.com/code-play-plugin/versions.json",
+      { timeout: 5000 },
+      res => {
+
+        let data = "";
+
+        res.on("data", chunk => data += chunk);
+
+        res.on("end", () => {
+
+          try {
+
+            _serverVersions = JSON.parse(data);
+
+            resolve(_serverVersions);
+
+          } catch {
+
+            resolve(null);
+
+          }
+
+        });
+
+      }
+
+    ).on("error", () => resolve(null));
+
+  });
+
+}
+
+function getAgentInstructionsZipLayout(zip) {
+  const entries = zip.getEntries().filter(entry => !entry.isDirectory);
+
+  for (const entry of entries) {
+    const normalizedName = entry.entryName.replace(/\\/g, "/");
+    if (
+      normalizedName.startsWith("/") ||
+      normalizedName.split("/").includes("..") ||
+      path.isAbsolute(entry.entryName)
+    ) {
+      throw new Error(`Unsafe path in agent instructions ZIP: ${entry.entryName}`);
+    }
+  }
+
+  const normalizedEntries = entries.map(entry => ({
+    entry,
+    name: entry.entryName.replace(/\\/g, "/")
+  }));
+  const agentFile = normalizedEntries.find(({ name }) =>
+    name.toLowerCase() === AGENT_INSTRUCTIONS_FILE.toLowerCase()
+  );
+  const supportFiles = normalizedEntries
+    .filter(({ name }) => name.toLowerCase() !== AGENT_INSTRUCTIONS_FILE.toLowerCase())
+    .map(({ entry, name }) => {
+      const agentDirectoryPrefix = `${AGENT_INSTRUCTIONS_DIR.toLowerCase()}/`;
+      const relativePath = name.toLowerCase().startsWith(agentDirectoryPrefix)
+        ? name.slice(name.indexOf("/") + 1)
+        : name;
+
+      return { entry, relativePath };
+    })
+    .filter(({ relativePath }) =>
+      relativePath &&
+      path.basename(relativePath).toLowerCase() !== AGENT_INSTRUCTIONS_VERSION_FILE.toLowerCase()
+    );
+
+  if (!agentFile || !supportFiles.length) {
+    throw new Error(
+      `Agent instructions ZIP must contain ${AGENT_INSTRUCTIONS_FILE} (case-insensitive) and at least one supporting file.`
+    );
+  }
+
+  return { agentFile: agentFile.entry, supportFiles };
+}
+
+function readInstalledAgentInstructionsVersion(projectRoot) {
+  const versionFile = path.join(projectRoot, AGENT_INSTRUCTIONS_DIR, AGENT_INSTRUCTIONS_VERSION_FILE);
+  if (!fs.existsSync(versionFile)) return "0";
+
+  const installedVersion = String(fs.readFileSync(versionFile, "utf8")).trim();
+  return /^\d+(?:\.\d+)*$/.test(installedVersion) ? installedVersion : "0";
+}
+
+async function syncAgentInstructions() {
+  const projectRoot = process.cwd();
+  const targetAgentFile = path.join(projectRoot, AGENT_INSTRUCTIONS_FILE);
+  const targetAgentDir = path.join(projectRoot, AGENT_INSTRUCTIONS_DIR);
+  const localVersion = readInstalledAgentInstructionsVersion(projectRoot);
+
+  const versions = await fetchVersions();
+  const remoteVersion = String(versions?.[AGENT_INSTRUCTIONS_VERSION_KEY] || "").trim();
+
+  if (!/^\d+(?:\.\d+)*$/.test(remoteVersion)) {
+    throw new Error(`Required agent instructions could not be resolved from the server.`);
+  }
+
+  const remoteIsNewer = compareVersionStrings(remoteVersion, localVersion) > 0;
+  if (!remoteIsNewer) {
+    console.log(`✅ Agent instructions do not need an update (local ${localVersion}, online ${remoteVersion}).`);
+    return;
+  }
+
+  const zipName = `${AGENT_INSTRUCTIONS_ZIP_PREFIX}-${remoteVersion}.zip`;
+  const url = `https://htmlcodeplay.com/code-play-plugin/${zipName}`;
+  const tempRoot = fs.mkdtempSync(path.join(require("os").tmpdir(), "codeplay-agents-"));
+  const zipPath = path.join(tempRoot, zipName);
+  const extractPath = path.join(tempRoot, "extracted");
+
+  try {
+    console.log(`🔍 Checking latest agent instructions: ${zipName}`);
+    if (!(await urlExists(url))) {
+      throw new Error(`Required agent instructions archive not found: ${url}`);
+    }
+
+    await downloadFile(url, zipPath);
+    console.log(`⬇️ Downloaded agent instructions archive: ${zipName}`);
+    const zip = new AdmZip(zipPath);
+    const archiveLayout = getAgentInstructionsZipLayout(zip);
+
+    const stagedAgentFile = path.join(extractPath, AGENT_INSTRUCTIONS_FILE);
+    const stagedAgentDir = path.join(extractPath, AGENT_INSTRUCTIONS_DIR);
+    fs.mkdirSync(stagedAgentDir, { recursive: true });
+    fs.writeFileSync(stagedAgentFile, archiveLayout.agentFile.getData());
+    archiveLayout.supportFiles.forEach(({ entry, relativePath }) => {
+      const stagedSupportFile = path.join(stagedAgentDir, relativePath);
+      fs.mkdirSync(path.dirname(stagedSupportFile), { recursive: true });
+      fs.writeFileSync(stagedSupportFile, entry.getData());
+    });
+
+    fs.rmSync(targetAgentDir, { recursive: true, force: true });
+    fs.mkdirSync(targetAgentDir, { recursive: true });
+    fs.copyFileSync(stagedAgentFile, targetAgentFile);
+    fs.cpSync(stagedAgentDir, targetAgentDir, { recursive: true, force: true });
+    fs.writeFileSync(
+      path.join(targetAgentDir, AGENT_INSTRUCTIONS_VERSION_FILE),
+      `${remoteVersion}\n`,
+      "utf8"
+    );
+
+    writeUpdateLine(`Agent instructions ${localVersion} -> ${remoteVersion}`);
+    console.log(`✅ Agent instructions replaced in the project root → v${remoteVersion}.`);
+  } catch (error) {
+    throw new Error(`Required agent instructions installation failed: ${error?.message || error}`);
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+}
+
+
+
+
+
+async function autoUpdatePlugin(pluginDef, pluginInfo) {
+
+  const versions = await fetchVersions();
+
+  if (!versions) {
+    console.log("⚠️ versions.json not reachable");
+    return false;
+  }
+
+  const oldFullPath = path.join(srcDir, pluginInfo.name);
+  const oldFileName = path.basename(oldFullPath);
+
+  //const oldFileName = path.basename(oldFullPath);
+  const oldVersionFile = oldFileName;
+
+
+const ext = path.extname(oldFileName);   // .js or .less
+//const baseName = oldFileName.replace(/-\d+\.\d+.*$/, "");
+const baseName = oldFileName.replace(/-\d+\.\d+.*$/, '').replace(/\.(js|less)$/, '');
+
+// version lookup key
+let pluginKey = baseName;
+
+
+// Only common plugin has js and less variants
+if (baseName === "common") {
+  if (ext === ".js") pluginKey = "common-js";
+  if (ext === ".less") pluginKey = "common-less";
+}
+
+const latestVersion = versions[pluginKey];
+
+  if (!latestVersion) {
+    console.log(`❌ No version entry for ${baseName}`);
+    return false;
+  }
+
+  // ===============================
+  // FOLDER PLUGIN UPDATE
+  // ===============================
+if (pluginDef.isFolder) {
+
+  const zipName = `${baseName}-${latestVersion}.zip`;
+  const url = `https://htmlcodeplay.com/code-play-plugin/${zipName}`;
+
+  const destRoot = path.join(srcDir, pluginDef.destDir || pluginDef.baseDir || '');
+  const oldPath = path.join(destRoot, pluginInfo.name);
+  const newPath = path.join(destRoot, `${baseName}-${latestVersion}`);
+
+  if (!(await urlExists(url))) return false;
+
+  fs.rmSync(oldPath, { recursive: true, force: true });
+
+  await downloadAndExtractZip(url, newPath);
+
+  updateImports(pluginInfo.name, `${baseName}-${latestVersion}`);
+
+  // ✅ ADD THIS
+  writeUpdateLine(`${pluginInfo.name} -> ${baseName}-${latestVersion}`);
+
+  console.log(`✅ Folder updated → ${baseName}-${latestVersion}`);
+
+  return true;
+}
+// ===============================
+// FILE PLUGIN UPDATE
+// ===============================
+
+const pluginDir = path.dirname(oldFullPath);
+
+// Only this plugin has ios variant
+const IOS_VARIANT_PLUGINS = [
+  "saveToGalleryAndSaveAnyFile"
+];
+
+/* let variants = [
+  `${baseName}-${latestVersion}.js`
+]; */
+
+//const ext = path.extname(oldFileName);
+const variants = [`${baseName.replace(ext,'')}-${latestVersion}${ext}`];
+
+
+if (IOS_VARIANT_PLUGINS.includes(baseName)) {
+  variants.push(`${baseName}-${latestVersion}-ios.js`);
+}
+
+let downloaded = [];
+
+// Download files
+for (const fileName of variants) {
+
+  const url = `https://htmlcodeplay.com/code-play-plugin/${fileName}`;
+
+  console.log(`🔍 Checking latest: ${fileName}`);
+
+  if (await urlExists(url)) {
+
+    const destPath = path.join(pluginDir, fileName);
+
+    await downloadFile(url, destPath);
+
+    downloaded.push(fileName);
+
+    console.log(`⬇ Downloaded → ${fileName}`);
+
+    //writeUpdateLine(`Downloaded: ${fileName}`);
+
+  }
+}
+
+if (downloaded.length === 0) {
+  console.log(`❌ No files downloaded for ${baseName}`);
+  return false;
+}
+
+// Remove ONLY versioned files (safe)
+//const versionPattern = new RegExp(`^${baseName}-\\d+\\.\\d+(-ios)?\\.js$`);
+const versionPattern = new RegExp(`^${baseName}-\\d+\\.\\d+(-ios)?\\${ext}$`);
+
+const existingFiles = fs.readdirSync(pluginDir);
+
+existingFiles.forEach(file => {
+
+  if (
+    versionPattern.test(file) &&
+    !downloaded.includes(file)
+  ) {
+
+    const oldPath = path.join(pluginDir, file);
+
+    fs.unlinkSync(oldPath);
+
+    console.log(`🗑 Removed old file → ${file}`);
+    //writeUpdateLine(`Removed old file: ${file}`);   
+  }
+
+});
+
+//const newFileName = `${baseName}-${latestVersion}.js`;
+const newFileName = `${baseName}-${latestVersion}${ext}`;
+
+writeUpdateLine(`${oldVersionFile} -> ${newFileName}`);
+
+updateImports(oldFileName, newFileName);
+//updateImports(baseName, `${baseName}-${latestVersion}.js`);
+//updateImports(pluginInfo.name, `${baseName}-${latestVersion}`);
+
+//console.log(`✅ Updated → ${newFileName}`);
+ //console.log(`✅ Updated → ${baseName}-${latestVersion}`);
+
+return true;
+}
+
+
+
+
+/*##############################################   AUTO DOWNLOAD FROM SERVER END  #####################################*/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+async function loadPluginVersions() {
+
+  if (!USE_LIVE_SERVER_VERSION) {
+    console.log("ℹ️ Using local plugin versions (offline mode).");
+    return;
+  }
+
+  console.log("🌐 Fetching plugin versions from server...");
+
+  const versions = await fetchVersions();
+
+  if (!versions || typeof versions !== "object") {
+    console.log("⚠️ Server unavailable or invalid versions.json. Falling back to local versions.");
+    return;
+  }
+
+  requiredPlugins.forEach(plugin => {
+
+    if (!plugin.name) return;
+
+    if (versions[plugin.name]) {
+      plugin.minVersion = versions[plugin.name];
+    }
+
+  });
+
+  console.log("✅ Plugin versions loaded from server.");
+
+}
+
+
+
+let hasMandatoryUpdate = false;
+function checkPlugins() {
+  return new Promise(async (resolve, reject) => {
+    const files = getSourceFiles();
+    const outdatedPlugins = [];
+    let hasMandatoryUpdate = false;
+
+    for (const plugin of requiredPlugins) {
+      const searchRoot = getSearchRoot(plugin);
+
+      // ---------- Folder plugins ----------
+      if (plugin.isFolder) {
+        if (!fs.existsSync(searchRoot)) continue;
+
+        const subDirs = fs.readdirSync(searchRoot)
+          .map(name => path.join(searchRoot, name))
+          .filter(p => fs.statSync(p).isDirectory());
+
+        for (const dir of subDirs) {
+          const relativePath = path.relative(searchRoot, dir).replace(/\\/g, '/');
+          const match = plugin.pattern.exec(relativePath);
+
+          if (match) {
+            const currentVersion = match[1];
+
+            if (compareVersions(currentVersion, plugin.minVersion) < 0) {
+              outdatedPlugins.push({
+                name: relativePath,
+                currentVersion,
+                requiredVersion: plugin.minVersion,
+                mandatoryUpdate: plugin.mandatoryUpdate === true
+              });
+
+              if (plugin.mandatoryUpdate) {
+                hasMandatoryUpdate = true;
+              }
+            }
+          }
+        }
+        continue;
+      }
+
+      // ---------- File plugins ----------
+      const matchedFile = files.find(file =>
+        file.startsWith(searchRoot) && plugin.pattern.test(file)
+      );
+
+      if (matchedFile) {
+        const match = plugin.pattern.exec(matchedFile);
+        if (match) {
+          const currentVersion = match[1];
+          const isBeta = !!match[2];
+
+          const cmp = plugin.pattern.source.includes('beta')
+            ? compareWithBeta(currentVersion, plugin.minVersion, isBeta)
+            : compareVersions(currentVersion, plugin.minVersion);
+
+          if (cmp < 0) {
+            outdatedPlugins.push({
+              name: path.relative(srcDir, matchedFile),
+              currentVersion: isBeta ? `${currentVersion}-beta` : currentVersion,
+              requiredVersion: plugin.minVersion,
+              mandatoryUpdate: plugin.mandatoryUpdate === true
+            });
+
+            if (plugin.mandatoryUpdate) {
+              hasMandatoryUpdate = true;
+            }
+          }
+        }
+      }
+    }
+
+    // ---------- Result handling ----------
+    if (outdatedPlugins.length > 0) {
+      console.log('\n❗ The following plugins are outdated:\n');
+
+      outdatedPlugins.forEach( p => {
+        const tag = p.mandatoryUpdate ? '🔥 MANDATORY' : '';
+        console.log(
+          ` ⚠️ - ${p.name} (Current: ${p.currentVersion}, Required: ${p.requiredVersion}) ${tag}`
+        );
+      });
+
+      // 🚨 Mandatory update → stop build
+/*       if (hasMandatoryUpdate) {
+        console.log('\n🚫 One or more plugins require a mandatory update.');
+        console.log('❌ Build cancelled. Please update mandatory plugins and try again.');
+        process.exit(1);
+      } */
+
+
+        
+
+
+if (hasMandatoryUpdate) {
+
+  //--------------------------------------------------
+  // 🚫 AUTO UPDATE DISABLED
+  //--------------------------------------------------
+  if (!ENABLE_AUTO_UPDATE) {
+    console.log("\n🚫 Auto-update disabled.");
+    console.log("❌ Manual update required.");
+    process.exit(1);
+  }
+
+  //--------------------------------------------------
+  // 🔥 AUTO UPDATE ENABLED
+  //--------------------------------------------------
+  console.log("\n🔥 Mandatory plugins outdated. Trying auto-update...\n");
+
+
+
+        let autoFailed = false;
+
+        for (const p of outdatedPlugins.filter(x => x.mandatoryUpdate)) {
+
+          const pluginDef = requiredPlugins.find(def =>
+            def.pattern.test(p.name)
+          );
+
+          if (!pluginDef) continue;
+
+          const success = await autoUpdatePlugin(
+            pluginDef,
+            p
+          );
+
+          if (!success) {
+            autoFailed = true;
+
+            const pluginDef = requiredPlugins.find(def =>
+              def.pattern.test(p.name)
+            );
+
+            console.log(`❌ Manual update required for ${p.name}`);
+
+            if (pluginDef) {
+              console.log(`👉 Required minimum version: ${pluginDef.minVersion}`);
+            }
+          }
+        }
+
+        // 🚨 Fallback to manual if any failed
+        if (autoFailed) {
+          console.log('\n🚫 One or more plugins require manual update.');
+          console.log('❌ Build cancelled. Please update mandatory plugins.');
+          process.exit(1);
+        }
+
+        console.log('\n🎉 All mandatory plugins auto-updated! Skipping recheck for speed.\n');
+
+        saveUpdateLogs();
+        resolve();
+        return;
+      }
+
+
+
+
+
+
+      // Optional updates → ask user
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+
+      rl.question(
+        '\nAre you sure you want to continue without updating these plugins? (y/n): ',
+        answer => {
+          rl.close();
+
+          if (answer.toLowerCase() !== 'y') {
+            console.log('\n❌ Build cancelled due to outdated plugins.');
+            process.exit(1);
+          } else {
+            console.log('\n✅ Continuing build...');
+            resolve();
+          }
+        }
+      );
+    } else {
+      console.log('✅ All plugin versions are up to date.');
+      saveUpdateLogs();
+      resolve();
+    }
+  });
+}
+
+
+
+
+
+
+
+
+
+
+const localizationBaseDir = path.join(__dirname, "..", "src", "js", "localization");
+
+// ======================================================
+// 🌐 LOCALIZATION CHECK (FULLY DYNAMIC)
+// ======================================================
+
+
+const jsRootDir = path.join(__dirname, "..", "src", "js");
+
+// 🔍 Detect OLD localization files in root js/
+const oldLocalizationFiles = fs.readdirSync(jsRootDir)
+  .filter(name =>
+    /^localization-\d+(\.\d+)*\.js$/.test(name) ||
+    /^localization_settings-\d+(\.\d+)*\.js$/.test(name)
+  );
+
+// ❌ If old structure found → STOP
+if (oldLocalizationFiles.length > 0) {
+
+  console.error(`
+❌ OLD LOCALIZATION STRUCTURE DETECTED
+
+You are using outdated file structure:
+  src/js/localization-x.x.js
+  src/js/localization_settings-x.x.js
+
+🚨 This is no longer supported.
+
+📦 Found files:
+${oldLocalizationFiles.map(f => "  - " + f).join("\n")}
+
+👉 Please move them to new structure:
+
+  src/js/localization/localization_settings-x.x.js
+  src/js/localization/localization-x.x/
+
+⚠️ Example:
+
+  OLD:
+    src/js/localization-x.x.js
+    src/js/localization_settings-x.x.js
+
+  NEW:
+    src/js/localization/localization_settings-1.1.js
+    src/js/localization/localization-x.x/index.js
+
+  in vite.config.json
+    '@translate': path.resolve(__dirname, './src/js/localization/localization-x.x'),
+
+❌ Build stopped.
+`);
+
+  process.exit(1);
+}
+
+
+
+
+if (fs.existsSync(localizationBaseDir)) {
+
+  // ❌ Block wrong files
+  const invalidFiles = fs.readdirSync(localizationBaseDir)
+    .filter(name => /^localization-\d+(\.\d+)*\.js$/.test(name));
+
+  if (invalidFiles.length > 0) {
+    console.error(`
+❌ INVALID LOCALIZATION FILE LOCATION
+
+🚫 localization-x.x.js must NOT be directly inside:
+  src/js/localization/
+
+📦 Found:
+${invalidFiles.map(f => "  - " + f).join("\n")}
+
+❌ Build stopped.
+`);
+    process.exit(1);
+  }
+
+  // 🔍 Find localization-x.x folders
+  const localizationVersions = fs.readdirSync(localizationBaseDir)
+    .filter(name => /^localization-\d+(\.\d+)+$/.test(name));
+
+  if (localizationVersions.length === 0) {
+    console.log("ℹ️ No localization-x.x folder found. Skipping...");
+  } else {
+
+    // ✅ Get latest version (same logic as editor)
+    const latestLocalizationDir = localizationVersions.sort((a, b) => {
+      const vA = parseFloat(a.split('-')[1]);
+      const vB = parseFloat(b.split('-')[1]);
+      return vB - vA;
+    })[0];
+
+    const localizationPath = path.join(localizationBaseDir, latestLocalizationDir);
+
+    // ======================================================
+    // ✅ CHECK localization-x.x.js exists
+    // ======================================================
+
+const localizationFilePath = path.join(localizationPath, "index.js");
+
+if (!fs.existsSync(localizationFilePath)) {
+  console.error(`
+❌ localization entry file missing
+
+Expected:
+  ${localizationFilePath}
+
+👉 Each localization version folder must contain:
+   index.js
+
+⚠️ Example:
+
+  src/js/localization/localization-x.x/index.js
+
+❌ Build stopped.
+`);
+  process.exit(1);
+}
+
+    // ======================================================
+    // ✅ CHECK run.js exists
+    // ======================================================
+
+    const runJsPath = path.join(localizationPath, "run.js");
+
+    if (!fs.existsSync(runJsPath)) {
+      console.error(`❌ run.js not found in ${latestLocalizationDir}`);
+      process.exit(1);
+    }
+
+    // ======================================================
+    // 🚀 EXECUTE run.js
+    // ======================================================
+
+    console.log(`🌐 Localization detected: ${latestLocalizationDir}`);
+    console.log(`🚀 Executing ${runJsPath}...`);
+
+    execSync(`node "${runJsPath}"`, { stdio: "inherit" });
+    sourceFileInventory = null;
+  }
+
+} else {
+  console.log("ℹ️ Localization not used in this project. Skipping...");
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const checkAndupdateDropInViteConfig = () => {
+
+  const possibleFiles = [
+    "vite.config.js",
+    "vite.config.mjs"
+  ];
+
+  // Detect existing config file
+  const viteConfigPath = possibleFiles
+    .map(file => path.join(process.cwd(), file))
+    .find(filePath => fs.existsSync(filePath));
+
+  if (!viteConfigPath) {
+    console.warn("⚠️ No vite config found. Skipping.");
+    return;
+  }
+
+  //console.log("📄 Using:", viteConfigPath.split("/").pop());
+
+  let viteContent = fs.readFileSync(viteConfigPath, "utf8");
+
+  // Skip if already exists
+  if (/drop\s*:\s*\[.*['"]console['"].*\]/.test(viteContent)) {
+    console.log("ℹ️  vite.config.(m)js already Updated. Skipping...");
+    return;
+  }
+
+  console.log("🔧 Adding esbuild.drop ...");
+
+  // If esbuild block exists
+  if (/esbuild\s*:\s*{/.test(viteContent)) {
+    viteContent = viteContent.replace(
+      /esbuild\s*:\s*{([\s\S]*?)(^ {0,8})}/m,
+      (full, inner, indent) => {
+
+        let lines = inner
+          .split("\n")
+          .map(l => l.trim())
+          .filter(Boolean);
+
+        // Fix last comma
+        if (lines.length > 0) {
+          lines[lines.length - 1] =
+            lines[lines.length - 1].replace(/,+$/, "") + ",";
+        }
+
+        // Re-indent
+        lines = lines.map(l => indent + "  " + l);
+
+        // Add drop
+        lines.push(`${indent}  drop: ['console','debugger'],`);
+
+        return `esbuild: {\n${lines.join("\n")}\n${indent}}`;
+      }
+    );
+  }
+
+  // If esbuild missing
+  else {
+    viteContent = viteContent.replace(
+      /export default defineConfig\s*\(\s*{/,
+      m => `${m}\n  esbuild: {\n    drop: ['console','debugger'],\n  },`
+    );
+  }
+
+  fs.writeFileSync(viteConfigPath, viteContent, "utf8");
+  console.log("✅ vite.config.(m)js Updated successfully.");
+};
+
+const syncAdmobAliasInViteConfig = () => {
+  const latest = findAdmobPackage(path.join(process.cwd(), 'src', 'js', 'Ads'));
+  if (latest) syncAdmobImports(process.cwd(), latest);
+};
+
+
+function getViteConfigPath() {
+  const possibleFiles = [
+    "vite.config.mjs",
+    "vite.config.js"
+  ];
+
+  return possibleFiles
+    .map(file => path.join(process.cwd(), file))
+    .find(filePath => fs.existsSync(filePath));
+};
+
+const getLatestIapDir = () => {
+  const adsDir = path.join(process.cwd(), "src", "js", "Ads");
+
+  if (!fs.existsSync(adsDir)) return null;
+
+  const iapDirs = fs.readdirSync(adsDir, { withFileTypes: true })
+    .filter(entry => entry.isDirectory() && /^IAP-\d+(\.\d+)*$/.test(entry.name))
+    .map(entry => entry.name)
+    .sort((a, b) => {
+      const versionA = a.match(/(\d+(?:\.\d+)*)/)[1].split(".").map(Number);
+      const versionB = b.match(/(\d+(?:\.\d+)*)/)[1].split(".").map(Number);
+
+      for (let i = 0; i < Math.max(versionA.length, versionB.length); i++) {
+        const diff = (versionB[i] || 0) - (versionA[i] || 0);
+        if (diff !== 0) return diff;
+      }
+
+      return 0;
+    });
+
+  return iapDirs.length > 0 ? path.join(adsDir, iapDirs[0]) : null;
+};
+
+const getAnalyticsConfig = () => {
+  const config = fs.existsSync(configPath)
+    ? JSON.parse(fs.readFileSync(configPath, "utf8"))
+    : {};
+
+  const analyticsFlagKey = "ANALYTICS_ENABLED";
+  const androidEnabled = config.android?.[analyticsFlagKey] ?? false;
+  const iosEnabled = config.ios?.[analyticsFlagKey] ?? false;
+
+  return {
+    androidEnabled: androidEnabled === true,
+    iosEnabled: iosEnabled === true,
+    enabled: androidEnabled === true || iosEnabled === true
+  };
+};
+
+function isPackageAvailable(packageName) {
+  if (!fs.existsSync(packageJsonPath)) return false;
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+
+  return Boolean(
+    packageJson.dependencies?.[packageName] ||
+    packageJson.devDependencies?.[packageName] ||
+    packageJson.optionalDependencies?.[packageName] ||
+    packageJson.peerDependencies?.[packageName] ||
+    fs.existsSync(path.join(process.cwd(), "node_modules", packageName, "package.json"))
+  );
+};
+
+const sourceImportsPackage = (packageName, ignoredFilePath) => {
+  const escapedPackage = packageName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const importRegex = new RegExp(`(?:from\\s*['"]${escapedPackage}(?:/[^'"]*)?['"]|import\\s*['"]${escapedPackage}(?:/[^'"]*)?['"]|import\\s*\\(\\s*['"]${escapedPackage}(?:/[^'"]*)?['"]\\s*\\)|require\\s*\\(\\s*['"]${escapedPackage}(?:/[^'"]*)?['"]\\s*\\))`);
+
+  return getSourceFiles().some(fullPath => {
+    if (ignoredFilePath && path.resolve(fullPath) === path.resolve(ignoredFilePath)) return false;
+    if (!/\.(js|mjs|cjs|ts|tsx|jsx|f7)$/.test(fullPath)) return false;
+    return importRegex.test(fs.readFileSync(fullPath, 'utf8'));
+  });
+};
+
+function runNpmCommand(command) {
+  console.log(`🚀 ${command}`);
+  execSync(command, { stdio: "inherit" });
+};
+
+function removeOneSignalPlugin() {
+  if (!isPackageAvailable(ONESIGNAL_PLUGIN_NAME)) {
+    console.log('ℹ️ OneSignal is not installed. Skipping removal.');
+    return;
+  }
+
+  console.warn(`⚠️ WARNING: ${ONESIGNAL_PLUGIN_NAME} was found. OneSignal is retired and will be uninstalled automatically.`);
+  runNpmCommand(`npm uninstall ${ONESIGNAL_PLUGIN_NAME}`);
+  if (isPackageAvailable(ONESIGNAL_PLUGIN_NAME)) {
+    throw new Error(`❌ ${ONESIGNAL_PLUGIN_NAME} is still declared or installed after npm uninstall. Build stopped; check dependent packages.`);
+  }
+  sourceFileInventory = null;
+  console.log(`✅ Uninstalled ${ONESIGNAL_PLUGIN_NAME}.`);
+}
+
+const CODEPLAY_SYSTEM_BARS_PLUGIN = "capacitor-codeplay-system-bars";
+
+function ensureMandatoryCapacitorPlugins() {
+  const requiredPackages = [
+    "@capacitor/device",
+    "@capacitor-community/in-app-review",
+    "@capawesome/capacitor-app-update"
+  ];
+
+  for (const packageName of requiredPackages) {
+    const installedPackagePath = path.join(process.cwd(), "node_modules", packageName, "package.json");
+    if (isPackageAvailable(packageName) && fs.existsSync(installedPackagePath)) {
+      console.log(`ℹ️ ${packageName} is already installed.`);
+      continue;
+    }
+
+    runNpmCommand(`npm install ${packageName}`);
+  }
+}
+
+const syncCodeplaySystemBarsPackage = () => {
+  if (!fs.existsSync(packageJsonPath)) {
+    console.warn(`⚠️ package.json not found. Skipping ${CODEPLAY_SYSTEM_BARS_PLUGIN} package sync.`);
+    return;
+  }
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+  const declaredVersion = packageJson.dependencies?.[CODEPLAY_SYSTEM_BARS_PLUGIN];
+  const usesLocalReference = typeof declaredVersion === "string" && declaredVersion.startsWith("file:");
+
+  if (usesLocalReference) {
+    console.log(`ℹ️ Replacing the local ${CODEPLAY_SYSTEM_BARS_PLUGIN} reference with the npm package.`);
+    runNpmCommand(`npm install ${CODEPLAY_SYSTEM_BARS_PLUGIN}`);
+    return;
+  }
+
+  if (!isPackageAvailable(CODEPLAY_SYSTEM_BARS_PLUGIN)) {
+    runNpmCommand(`npm install ${CODEPLAY_SYSTEM_BARS_PLUGIN}`);
+    return;
+  }
+
+  console.log(`ℹ️ ${CODEPLAY_SYSTEM_BARS_PLUGIN} is already installed.`);
+};
+
+const ADMOB_NEXTGEN_DEFAULTS = {
+  VERSION: "1.6",
+  ios: { nativeid: "" },
+  android: { nativeid: "" },
+  config: {
+    bannerStartupDelayMs: "",
+    interstitialStartupDelayMs: "",
+    appOpenLoadOnColdStart: "",
+    appOpenStartupDelayMs: "",
+    useAndroidPreloadAds: true,
+    useAndroidBannerPreloadAds: false,
+    preloadBufferSize: 1,
+    consentDebug: false,
+    isKidsApp: false,
+    isTesting: false,
+    consentDebug: false,
+    isConsoleLogEnabled: false,
+    bannerEnabled: true,
+    bannerDisabledPages: [],
+    interstitialEnabled: true,
+    appOpenEnabled: true,
+    rewardVideoEnabled: false,
+    rewardInterstitialEnabled: false,
+    collapsibleEnabled: "",
+    isLandScape: "",
+    isOverlappingEnable: "",
+    overlappingHeight: "",
+    bannerTypeAndroid: "",
+    bannerTypeAndroidLandscape: "",
+    bannerTypeiOS: "",
+    bannerTypeiOSLandscape: "",
+    bannerTopSpaceColor: "",
+    interstitialLoadScreenTextColor: "",
+    interstitialLoadScreenBackgroundColor: "",
+    beforeBannerSpace: "",
+    whenShow: "",
+    minimumClick: "",
+    interstitialTimeOut: "",
+    interstitialFirstTimeOut: "",
+    appOpenAdsTimeOut: "",
+    maxRetryCount: "",
+    retrySecondsAr: "",
+    appOpenPerSession: "",
+    interstitialPerSession: "",
+    appOpenFirstTimeOut: ""
+  },
+  testid: {
+    nativeid: "",
+    nativeid_android: "ca-app-pub-3940256099942544/2247696110",
+    nativeid_ios: "ca-app-pub-3940256099942544/3986624511"
+  }
+};
+
+function getAdmobJsonPath() {
+  const adsDir = path.join(process.cwd(), "src", "js", "Ads");
+  const possiblePaths = [
+    path.join(adsDir, ADMOB_NEXTGEN_CONFIG),
+    path.join(adsDir, ADMOB_OLD_CONFIG)
+  ];
+
+  return possiblePaths.find(fileExists);
+}
+
+function readJsonSafe(filePath) {
+  try {
+    return filePath && fileExists(filePath)
+      ? JSON.parse(fs.readFileSync(filePath, "utf8"))
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function isKidsAdmobApp() {
+  return readJsonSafe(getAdmobJsonPath())?.config?.isKidsApp === true;
+}
+
+function pickFirstValue(...values) {
+  return values.find(value => typeof value === "string" && value.trim() !== "") || "";
+}
+
+function getAdmobJsonAppIds(config = readJsonSafe(getAdmobJsonPath())) {
+  return {
+    androidAppId: pickFirstValue(
+      config?.androidAppId,
+      config?.android_app_id,
+      config?.android?.appId,
+      config?.android?.appid,
+      config?.android?.applicationId
+    ),
+    iosAppId: pickFirstValue(
+      config?.iosAppId,
+      config?.ios_app_id,
+      config?.ios?.appId,
+      config?.ios?.appid,
+      config?.ios?.applicationId
+    )
+  };
+}
+
+const mergeObjects = (template, source) => {
+  if (!template || typeof template !== "object" || Array.isArray(template)) {
+    return source !== undefined ? source : template;
+  }
+
+  const output = { ...template };
+
+  if (!source || typeof source !== "object" || Array.isArray(source)) {
+    return output;
+  }
+
+  Object.keys(source).forEach(key => {
+    if (
+      template[key] &&
+      typeof template[key] === "object" &&
+      !Array.isArray(template[key]) &&
+      source[key] &&
+      typeof source[key] === "object" &&
+      !Array.isArray(source[key])
+    ) {
+      output[key] = mergeObjects(template[key], source[key]);
+    } else if (key !== "VERSION") {
+      output[key] = source[key];
+    }
+  });
+
+  return output;
+};
+
+const hasObjectKeys = (value) => {
+  return value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0;
+};
+
+const ensureAdmobNextgenConfigDefaults = (config) => {
+  const normalizedConfig = { ...config };
+  const runtimeConfig = hasObjectKeys(config?.config) ? config.config : {};
+
+  normalizedConfig.config = mergeObjects(ADMOB_NEXTGEN_DEFAULTS.config, runtimeConfig);
+
+  return normalizedConfig;
+};
+
+const mergeNextgenConfigWithoutReplacingExisting = (defaultConfig, oldConfig, existingNextgenConfig) => {
+  const defaultWithOldConfig = mergeObjects(defaultConfig, oldConfig);
+  return mergeObjects(defaultWithOldConfig, existingNextgenConfig);
+};
+
+const buildNextgenAdmobConfigFromOldConfig = (templateConfig, existingNextgenConfig, oldConfig) => {
+  const mergedConfig = mergeNextgenConfigWithoutReplacingExisting(templateConfig, oldConfig, existingNextgenConfig);
+
+  const templateVersion = templateConfig.VERSION || ADMOB_NEXTGEN_DEFAULTS.VERSION;
+  mergedConfig.VERSION = compareVersionStrings(existingNextgenConfig?.VERSION || '0', templateVersion) > 0
+    ? existingNextgenConfig.VERSION : templateVersion;
+
+  return ensureAdmobNextgenConfigDefaults(mergedConfig);
+};
+
+const syncAdmobNextgenPackage = () => {
+  if (!fs.existsSync(packageJsonPath)) {
+    console.warn("⚠️ package.json not found. Skipping AdMob nextgen package sync.");
+    return;
+  }
+
+  if (isPackageAvailable("emi-indo-cordova-plugin-admob")) {
+    runNpmCommand("npm uninstall emi-indo-cordova-plugin-admob");
+  } else {
+    console.log("ℹ️ emi-indo-cordova-plugin-admob is not installed.");
+  }
+
+  if (!isPackageAvailable("capacitor-admob-nextgen")) {
+    runNpmCommand("npm install capacitor-admob-nextgen");
+  } else {
+    console.log("ℹ️ capacitor-admob-nextgen is already installed.");
+  }
+};
+
+const downloadOptionalCodeplayFile = async (fileName, destPath) => {
+  const url = `https://htmlcodeplay.com/code-play-plugin/${fileName}`;
+
+  if (!(await urlExists(url))) {
+    return false;
+  }
+
+  await downloadFile(url, destPath);
+  console.log(`⬇ Downloaded → ${fileName}`);
+  return true;
+};
+
+const syncAdmobConfigImports = () => {
+  const adsDir = path.join(process.cwd(), "src", "js", "Ads");
+  if (!fs.existsSync(adsDir)) return;
+
+  // Downloads invalidate the inventory; content-only migrations reuse it.
+  for (const fullPath of getSourceFiles()) {
+    if (!fullPath.startsWith(adsDir + path.sep)) continue;
+    if (!/\.(js|mjs|ts|f7)$/.test(fullPath) || fullPath.endsWith('.min.js')) continue;
+    let content = fs.readFileSync(fullPath, 'utf8');
+    if (!content.includes(ADMOB_OLD_CONFIG)) continue;
+    content = content.split(ADMOB_OLD_CONFIG).join(ADMOB_NEXTGEN_CONFIG);
+    fs.writeFileSync(fullPath, content, 'utf8');
+    console.log(`✏️ Updated AdMob config import in ${path.relative(process.cwd(), fullPath)}`);
+  }
+
+};
+
+const ensureAdmobNextgenFiles = async () => {
+  const adsDir = path.join(process.cwd(), "src", "js", "Ads");
+  if (!fs.existsSync(adsDir)) {
+    console.log("ℹ️ Ads folder not found. Skipping AdMob nextgen file sync.");
+    return;
+  }
+
+  await syncAdmobNextgen({ projectRoot: process.cwd(), versions: await fetchVersions() });
+  sourceFileInventory = null;
+  const nextgenConfigPath = path.join(adsDir, ADMOB_NEXTGEN_CONFIG);
+  const oldConfigPath = path.join(adsDir, ADMOB_OLD_CONFIG);
+  const templateDir = path.join(process.cwd(), 'agent-temp', 'admob-config-sync');
+  fs.mkdirSync(templateDir, { recursive: true });
+  const tempTemplatePath = path.join(templateDir, ADMOB_NEXTGEN_CONFIG);
+
+  let templateConfig = ADMOB_NEXTGEN_DEFAULTS;
+
+  if (await downloadOptionalCodeplayFile(ADMOB_NEXTGEN_CONFIG, tempTemplatePath)) {
+    const downloadedTemplateConfig = JSON.parse(fs.readFileSync(tempTemplatePath, "utf8"));
+    templateConfig = mergeObjects(ADMOB_NEXTGEN_DEFAULTS, downloadedTemplateConfig);
+    templateConfig.VERSION = downloadedTemplateConfig.VERSION || ADMOB_NEXTGEN_DEFAULTS.VERSION;
+    fs.unlinkSync(tempTemplatePath);
+  } else if (fs.existsSync(nextgenConfigPath)) {
+    templateConfig = mergeObjects(ADMOB_NEXTGEN_DEFAULTS, JSON.parse(fs.readFileSync(nextgenConfigPath, "utf8")));
+  }
+
+  const oldConfig = fs.existsSync(oldConfigPath)
+    ? JSON.parse(fs.readFileSync(oldConfigPath, "utf8"))
+    : {};
+  const existingNextgenConfig = fs.existsSync(nextgenConfigPath)
+    ? JSON.parse(fs.readFileSync(nextgenConfigPath, "utf8"))
+    : {};
+
+  const mergedConfig = buildNextgenAdmobConfigFromOldConfig(templateConfig, existingNextgenConfig, oldConfig);
+
+  const capacitorConfig = readJsonSafe(configPath) || {};
+  const legacyAdmobConfig = capacitorConfig.plugins?.AdMob || {};
+  const mergedAppIds = getAdmobJsonAppIds(mergedConfig);
+  const androidAppId = mergedAppIds.androidAppId || legacyAdmobConfig.APP_ID_ANDROID || "";
+  const iosAppId = mergedAppIds.iosAppId || legacyAdmobConfig.APP_ID_IOS || "";
+
+  if (androidAppId && !mergedAppIds.androidAppId) {
+    mergedConfig.androidAppId = androidAppId;
+  }
+
+  if (iosAppId && !mergedAppIds.iosAppId) {
+    mergedConfig.iosAppId = iosAppId;
+  }
+
+  if (!fs.existsSync(nextgenConfigPath)) sourceFileInventory = null;
+  fs.writeFileSync(nextgenConfigPath, JSON.stringify(mergedConfig, null, 2) + "\n", "utf8");
+  syncAdmobConfigImports();
+  console.log("✅ AdMob nextgen files and configuration are ready.");
+};
+
+const syncAdmobNextgenMigration = async () => {
+  syncAdmobNextgenPackage();
+  await ensureAdmobNextgenFiles();
+  syncAdmobAliasInViteConfig();
+};
+
+const syncSystemBarsSafeAreaMigration = () => {
+  if (isPackageAvailable("@capacitor-community/safe-area")) {
+    runNpmCommand("npm uninstall @capacitor-community/safe-area");
+  } else {
+    console.log("ℹ️ @capacitor-community/safe-area is not installed.");
+  }
+
+  if (!fs.existsSync(configPath)) {
+    console.warn("⚠️ capacitor.config.json not found. Skipping SystemBars config sync.");
+    return;
+  }
+
+  const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+  if (!config.plugins) config.plugins = {};
+  if (!config.plugins.SystemBars) config.plugins.SystemBars = {};
+
+  if (config.plugins.SystemBars.insetsHandling !== "css") {
+    config.plugins.SystemBars.insetsHandling = "css";
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+    console.log('✅ capacitor.config.json SystemBars.insetsHandling set to "css".');
+  } else {
+    console.log('ℹ️ capacitor.config.json SystemBars.insetsHandling already "css".');
+  }
+};
+
+const ensureFirebaseAnalyticsWrapper = (analyticsEnabled) => {
+  const analyticsDir = getLatestIapDir();
+  const legacyAnalyticsDir = path.join(process.cwd(), "src", "js", "analytics");
+  const legacyAnalyticsFile = path.join(legacyAnalyticsDir, "firebase-analytics.js");
+
+  if (!analyticsDir) {
+    console.warn("⚠️ No IAP-x.x folder found. Skipping Firebase analytics wrapper sync.");
+    return null;
+  }
+
+  const analyticsFile = path.join(analyticsDir, "firebase-analytics.js");
+
+  if (!fs.existsSync(analyticsDir)) {
+    fs.mkdirSync(analyticsDir, { recursive: true });
+  }
+
+  const activeWrapper = `import { Capacitor, registerPlugin } from '@capacitor/core';
+
+const FirebaseAnalytics = registerPlugin('FirebaseAnalytics');
+
+const isEnabledValue = (value) => value === true || value === 'true';
+
+const canUseNativeAnalytics = () => {
+    if (!Capacitor.isNativePlatform()) return false;
+
+    const platform = Capacitor.getPlatform();
+
+    if (platform === 'android') {
+        return isEnabledValue(import.meta.env.VITE_ANDROID_ANALYTICS_ENABLED);
+    }
+
+    if (platform === 'ios') {
+        return isEnabledValue(import.meta.env.VITE_IOS_ANALYTICS_ENABLED);
+    }
+
+    return false;
+};
+
+const cleanParams = (params = {}) => {
+    return Object.entries(params).reduce((result, [key, value]) => {
+        if (value === undefined || value === null || value === '') return result;
+        if (typeof value === 'number' && Number.isNaN(value)) return result;
+
+        result[key] = value;
+        return result;
+    }, {});
+};
+
+const trackEvent = async (name, params = {}) => {
+    if (!canUseNativeAnalytics()) return;
+
+    try {
+        await FirebaseAnalytics.logEvent({
+            name,
+            params: cleanParams(params),
+        });
+    } catch (err) {
+        console.warn(\`Firebase analytics event failed: \${name}\`, err);
+    }
+};
+
+const normalizeCurrency = (currency) => {
+    if (typeof currency !== 'string') return '';
+    return currency.trim().toUpperCase();
+};
+
+const buildPurchaseParams = (params = {}) => {
+    const value = Number(params.value || 0);
+    const itemId = params.item_id || params.itemId || '';
+    const itemName = params.item_name || params.itemName || itemId || params.store || 'purchase';
+    const quantity = Number(params.quantity || 1);
+    const transactionId = params.transaction_id || params.transactionId || \`\${params.store || 'store'}_\${itemId || itemName || 'purchase'}\`;
+
+    return cleanParams({
+        transaction_id: transactionId,
+        currency: normalizeCurrency(params.currency),
+        value,
+        items: [
+            cleanParams({
+                item_id: itemId,
+                item_name: itemName,
+                item_category: params.store || '',
+                price: value,
+                quantity,
+                subscription_period: params.subscription_period || '',
+            }),
+        ],
+    });
+};
+
+const buildAdRevenueParams = (params = {}) => {
+    const value = Number(params.value || 0);
+
+    return cleanParams({
+        ad_platform: params.ad_platform || 'AdMob',
+        ad_source: params.ad_source || 'AdMob',
+        ad_unit_name: params.ad_unit_name || params.adUnitId || '',
+        ad_format: params.ad_format || '',
+        currency: normalizeCurrency(params.currency),
+        value,
+    });
+};
+
+const trackMonetizationEvent = async (customEventName, params = {}) => {
+    await trackEvent(customEventName, params);
+    await trackEvent('purchase', buildPurchaseParams(params));
+};
+
+export const trackAdRevenue = (params) => {
+    trackEvent('ad_impression', buildAdRevenueParams(params));
+};
+
+export const trackSubscriptionScreenViewed = (params) => {
+    trackEvent('subscription_screen_view', params);
+};
+
+export const trackSubscriptionCheckoutStarted = (params) => {
+    trackEvent('subscription_checkout_start', params);
+};
+
+export const trackSubscriptionPurchased = (params) => {
+    trackMonetizationEvent('subscription_purchase', params);
+};
+
+export const trackConsumablePurchased = (params) => {
+    trackMonetizationEvent('consumable_purchase', params);
+};
+`;
+
+  const noopWrapper = `const trackEvent = () => {};
+
+export const trackAdRevenue = trackEvent;
+export const trackSubscriptionScreenViewed = trackEvent;
+export const trackSubscriptionCheckoutStarted = trackEvent;
+export const trackSubscriptionPurchased = trackEvent;
+export const trackConsumablePurchased = trackEvent;
+`;
+
+  const nextContent = analyticsEnabled ? activeWrapper : noopWrapper;
+  const analyticsFileExists = fs.existsSync(analyticsFile);
+  const currentContent = analyticsFileExists ? fs.readFileSync(analyticsFile, "utf8") : "";
+  if (!analyticsFileExists) sourceFileInventory = null;
+
+  if (currentContent !== nextContent) {
+    fs.writeFileSync(analyticsFile, nextContent, "utf8");
+    console.log(`✅ Firebase analytics wrapper ${analyticsEnabled ? "enabled" : "disabled"}: ${path.relative(process.cwd(), analyticsFile)}`);
+  } else {
+    console.log(`ℹ️ Firebase analytics wrapper already ${analyticsEnabled ? "enabled" : "disabled"}.`);
+  }
+
+  if (fs.existsSync(legacyAnalyticsFile)) {
+    fs.unlinkSync(legacyAnalyticsFile);
+    sourceFileInventory = null;
+    console.log("✅ Removed old Firebase analytics wrapper: src/js/analytics/firebase-analytics.js");
+  }
+
+  if (fs.existsSync(legacyAnalyticsDir) && fs.readdirSync(legacyAnalyticsDir).length === 0) {
+    fs.rmdirSync(legacyAnalyticsDir);
+  }
+
+  return analyticsFile;
+};
+
+const syncFirebaseAnalyticsPackages = () => {
+  const analyticsConfig = getAnalyticsConfig();
+
+  if (analyticsConfig.enabled) {
+    if (!isPackageAvailable("@capacitor-firebase/analytics") || !isPackageAvailable("firebase")) {
+      runNpmCommand("npm install @capacitor-firebase/analytics firebase");
+    } else {
+      console.log("ℹ️ Firebase Analytics packages already installed.");
+    }
+
+    ensureFirebaseAnalyticsWrapper(true);
+    return;
+  }
+
+  const analyticsFile = ensureFirebaseAnalyticsWrapper(false);
+
+  if (isPackageAvailable("@capacitor-firebase/analytics")) {
+    runNpmCommand("npm uninstall @capacitor-firebase/analytics");
+  } else {
+    console.log("ℹ️ @capacitor-firebase/analytics is not installed.");
+  }
+
+  if (isPackageAvailable("firebase")) {
+    if (sourceImportsPackage("firebase", analyticsFile)) {
+      console.log("ℹ️ Keeping firebase package because other source files import it.");
+    } else {
+      runNpmCommand("npm uninstall firebase");
+    }
+  }
+};
+
+const syncFirebaseAnalyticsPodfile = () => {
+  const podfilePath = path.join(process.cwd(), "ios", "App", "Podfile");
+  if (!fs.existsSync(podfilePath)) return;
+
+  const { iosEnabled } = getAnalyticsConfig();
+  const basePodLine = "  pod 'CapacitorFirebaseAnalytics', :path => '../../node_modules/@capacitor-firebase/analytics'";
+  const analyticsPodLine = "  pod 'CapacitorFirebaseAnalytics/Analytics', :path => '../../node_modules/@capacitor-firebase/analytics'";
+
+  let content = fs.readFileSync(podfilePath, "utf8");
+  let nextContent = content;
+
+  if (iosEnabled) {
+    if (!nextContent.includes(basePodLine)) {
+      nextContent = nextContent.replace(
+        /(pod 'CapacitorCommunitySafeArea'[^\n]*\r?\n)/,
+        `$1${basePodLine}\n`
+      );
+    }
+
+    if (!nextContent.includes(analyticsPodLine)) {
+      nextContent = nextContent.replace(
+        /(# Add your Pods here\r?\n)/,
+        `$1${analyticsPodLine}\n`
+      );
+    }
+  } else {
+    nextContent = nextContent
+      .split(/\r?\n/)
+      .filter(line => !line.includes("CapacitorFirebaseAnalytics"))
+      .join("\n");
+  }
+
+  if (nextContent !== content) {
+    fs.writeFileSync(podfilePath, nextContent, "utf8");
+    console.log(`✅ iOS Firebase Analytics Podfile entries ${iosEnabled ? "enabled" : "removed"}.`);
+  } else {
+    console.log(`ℹ️ iOS Firebase Analytics Podfile entries already ${iosEnabled ? "enabled" : "disabled"}.`);
+  }
+};
+
+function ensureImportOrRequire(content, moduleName, esmLine, cjsLine) {
+  const escaped = moduleName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  if (new RegExp(`from\\s*['"]${escaped}['"]|require\\s*\\(\\s*['"]${escaped}['"]\\s*\\)`).test(content)) {
+    return content;
+  }
+
+  const isCommonJs = /module\.exports|require\s*\(/.test(content);
+  const line = isCommonJs ? cjsLine : esmLine;
+
+  return `${line}\n${content}`;
+};
+
+const ensureViteDefineEntry = (viteContent, key, valueExpression) => {
+  const entry = `      '${key}': JSON.stringify(${valueExpression}),`;
+
+  if (viteContent.includes(`'${key}'`) || viteContent.includes(`"${key}"`)) {
+    return viteContent;
+  }
+
+  if (/define\s*:\s*{/.test(viteContent)) {
+    return viteContent.replace(/define\s*:\s*{\s*/, match => `${match}\n${entry}\n`);
+  }
+
+  const defineBlock = `    define: {
+      '${key}': JSON.stringify(${valueExpression}),
+    },`;
+
+  if (/\n\s*publicDir\s*:\s*[^,\n]+,?/.test(viteContent)) {
+    return viteContent.replace(
+      /(\n\s*publicDir\s*:\s*[^,\n]+,?)/,
+      `$1\n${defineBlock}`
+    );
+  }
+
+  return viteContent.replace(
+    /(return\s+{)/,
+    `$1\n${defineBlock}`
+  );
+};
+
+const ensurePrivacyAndAnalyticsViteConfig = () => {
+  const viteConfigPath = getViteConfigPath();
+
+  if (!viteConfigPath) {
+    console.warn("⚠️ No vite config found. Skipping privacy/analytics Vite sync.");
+    return;
+  }
+
+  let viteContent = fs.readFileSync(viteConfigPath, "utf8");
+  const originalContent = viteContent;
+
+  viteContent = ensureImportOrRequire(
+    viteContent,
+    "fs",
+    "import fs from 'fs';",
+    "const fs = require('fs');"
+  );
+
+  viteContent = ensureImportOrRequire(
+    viteContent,
+    "path",
+    "import path from 'path';",
+    "const path = require('path');"
+  );
+
+  if (!/\bcapacitorConfig\b/.test(viteContent)) {
+    viteContent = viteContent.replace(
+      /(\r?\nexport\s+default|\r?\nmodule\.exports)/,
+      `\nconst capacitorConfig = JSON.parse(fs.readFileSync(path.resolve(__dirname, './capacitor.config.json'), 'utf8'));\n$1`
+    );
+  }
+
+  if (!/\bAPP_UNIQUE_ID\b/.test(viteContent)) {
+    viteContent = viteContent.replace(
+      /(const capacitorConfig = JSON\.parse\(fs\.readFileSync\(path\.resolve\(__dirname,\s*['"]\.\/capacitor\.config\.json['"]\),\s*['"]utf8['"]\)\);\r?\n)/,
+      `$1const APP_UNIQUE_ID = capacitorConfig.android?.APP_UNIQUE_ID ?? '';\n`
+    );
+  }
+
+  if (!/\bANDROID_ANALYTICS_ENABLED\b/.test(viteContent)) {
+    viteContent = viteContent.replace(
+      /(const APP_UNIQUE_ID = capacitorConfig\.android\?\.APP_UNIQUE_ID \?\? ['"]['"];\r?\n)/,
+      `$1const ANDROID_ANALYTICS_ENABLED = capacitorConfig.android?.ANALYTICS_ENABLED ?? false;\n`
+    );
+  }
+
+  if (!/\bIOS_ANALYTICS_ENABLED\b/.test(viteContent)) {
+    viteContent = viteContent.replace(
+      /(const ANDROID_ANALYTICS_ENABLED = capacitorConfig\.android\?\.ANALYTICS_ENABLED \?\? false;\r?\n)/,
+      `$1const IOS_ANALYTICS_ENABLED = capacitorConfig.ios?.ANALYTICS_ENABLED ?? false;\n`
+    );
+  }
+
+  if (!/\bIAP_DESIGN\b/.test(viteContent)) {
+    viteContent = viteContent.replace(
+      /(const IOS_ANALYTICS_ENABLED = capacitorConfig\.ios\?\.ANALYTICS_ENABLED \?\? false;\r?\n)/,
+      `$1const IAP_DESIGN = capacitorConfig["IAP-Design"] ?? 'default';\n`
+    );
+  }
+
+  viteContent = viteContent
+    .replace(
+      /const ANDROID_ANALYTICS_ENABLED = capacitorConfig\.android\?\.ANALY[ST]ICS_ENABLED \?\? capacitorConfig\.android\?\.ANALYTICS_ENABLED \?\? false;/g,
+      "const ANDROID_ANALYTICS_ENABLED = capacitorConfig.android?.ANALYTICS_ENABLED ?? false;"
+    )
+    .replace(
+      /const IOS_ANALYTICS_ENABLED = capacitorConfig\.ios\?\.ANALY[ST]ICS_ENABLED \?\? capacitorConfig\.ios\?\.ANALYTICS_ENABLED \?\? false;/g,
+      "const IOS_ANALYTICS_ENABLED = capacitorConfig.ios?.ANALYTICS_ENABLED ?? false;"
+    );
+
+  viteContent = ensureViteDefineEntry(viteContent, "import.meta.env.VITE_APP_UNIQUE_ID", "APP_UNIQUE_ID");
+  viteContent = ensureViteDefineEntry(viteContent, "import.meta.env.VITE_ANDROID_ANALYTICS_ENABLED", "ANDROID_ANALYTICS_ENABLED");
+  viteContent = ensureViteDefineEntry(viteContent, "import.meta.env.VITE_IOS_ANALYTICS_ENABLED", "IOS_ANALYTICS_ENABLED");
+  viteContent = ensureViteDefineEntry(viteContent, "import.meta.env.VITE_IAP_DESIGN", "IAP_DESIGN");
+
+  if (viteContent !== originalContent) {
+    fs.writeFileSync(viteConfigPath, viteContent, "utf8");
+    console.log("✅ vite.config.(m)js privacy/analytics settings synced.");
+  } else {
+    console.log("ℹ️ vite.config.(m)js privacy/analytics settings already synced.");
+  }
+};
+
+const syncFirebaseAnalyticsSetup = () => {
+  syncFirebaseAnalyticsPackages();
+  syncFirebaseAnalyticsPodfile();
+  ensurePrivacyAndAnalyticsViteConfig();
+};
+
+const getAdmobIapConfigPath = () => {
+  const possiblePaths = [
+    path.join(process.cwd(), 'src', 'js', 'Ads', 'admob-ad-configuration-nextgen.json'),
+    path.join(process.cwd(), 'src', 'js', 'Ads', 'admob-ad-configuration.json')
+  ];
+
+  return possiblePaths.find(fileExists);
+};
+
+const getAdmobIapConfig = () => {
+  const admobIapConfigPath = getAdmobIapConfigPath();
+
+  if (!admobIapConfigPath) {
+    console.warn("⚠️ No AdMob configuration JSON found. Skipping RevenueCat IAP package sync.");
+    return null;
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(admobIapConfigPath, "utf8"));
+  } catch (err) {
+    console.error(`❌ Failed to read ${path.relative(process.cwd(), admobIapConfigPath)}`, err);
+    process.exit(1);
+  }
+};
+
+const isAnyIapStoreEnabled = (iapConfig) => {
+  return Boolean(
+    iapConfig?.playstore === true ||
+    iapConfig?.samsung === true ||
+    iapConfig?.amazon === true ||
+    iapConfig?.ios === true
+  );
+};
+
+const ensureIapDesignInCapacitorConfig = (iapConfig) => {
+  if (!isAnyIapStoreEnabled(iapConfig)) return;
+
+  if (!fs.existsSync(configPath)) {
+    console.warn("⚠️ capacitor.config.json not found. Skipping IAP-Design sync.");
+    return;
+  }
+
+  const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+
+  if (Object.prototype.hasOwnProperty.call(config, "IAP-Design")) {
+    console.log("ℹ️ capacitor.config.json IAP-Design already configured.");
+    return;
+  }
+
+  config["IAP-Design"] = "default";
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log('✅ Added "IAP-Design": "default" to capacitor.config.json.');
+};
+
+const getCurrentStoreId = () => {
+  const envStoreId = Number(process.env.VITE_STORE_ID);
+  if (Number.isInteger(envStoreId) && envStoreId > 0) return envStoreId;
+
+  const viteConfigPath = getViteConfigPath();
+  if (!viteConfigPath) return 1;
+
+  const viteConfigContent = fs.readFileSync(viteConfigPath, "utf8");
+  const commonAliasMatch = viteConfigContent.match(/['"]@common['"]:\s*path\.resolve\(__dirname,\s*['"]([^'"]+)['"]\)/);
+
+  if (!commonAliasMatch) return 1;
+
+  const commonFilePath = path.resolve(path.dirname(viteConfigPath), commonAliasMatch[1]);
+  if (!fs.existsSync(commonFilePath)) return 1;
+
+  const commonFileContent = fs.readFileSync(commonFilePath, "utf8");
+  const environmentStoreIdMatch = commonFileContent.match(
+    /^[ \t]*export\s+let\s+_storeid\s*=\s*import\.meta\.env\.VITE_STORE_ID\s*\|\|\s*(\d+)\s*;/m
+  );
+  if (environmentStoreIdMatch) return Number(environmentStoreIdMatch[1]);
+
+  const directStoreIdMatch = commonFileContent.match(
+    /^[ \t]*export\s+let\s+_storeid\s*=\s*(\d+)\s*;/m
+  );
+
+  return directStoreIdMatch ? Number(directStoreIdMatch[1]) : 1;
+};
+
+const getRevenueCatStoreState = (iapConfig) => {
+  const storeId = getCurrentStoreId();
+  const configuration = iapConfig.configuration || {};
+  const storeMap = {
+    1: {
+      name: "PlayStore",
+      enabled: iapConfig.playstore === true,
+      apiKeyName: "IAP.configuration.playstore",
+      apiKey: configuration.playstore,
+      usesGoogleBilling: true
+    },
+    6: {
+      name: "iOSStore",
+      enabled: iapConfig.ios === true,
+      apiKeyName: "IAP.configuration.ios",
+      apiKey: configuration.ios,
+      usesGoogleBilling: false
+    },
+    7: {
+      name: "AmazonStore",
+      enabled: iapConfig.amazon === true,
+      apiKeyName: "IAP.configuration.amazon",
+      apiKey: configuration.amazon,
+      usesGoogleBilling: false
+    }
+  };
+
+  return {
+    storeId,
+    store: storeMap[storeId] || null
+  };
+};
+
+const syncAmazonFireWebViewDependency = (enabled) => {
+  if (!fs.existsSync(androidAppBuildGradlePath)) {
+    console.error(`❌ Android app build.gradle not found: ${androidAppBuildGradlePath}`);
+    process.exit(1);
+  }
+
+  const currentContent = fs.readFileSync(androidAppBuildGradlePath, "utf8");
+  let nextContent = currentContent.replace(AMAZON_WINDOW_EXTENSIONS_DEPENDENCY_PATTERN, "");
+
+  if (enabled) {
+    const newline = nextContent.includes("\r\n") ? "\r\n" : "\n";
+    const dependenciesHeaderPattern = /(^dependencies[ \t]*\{[ \t]*\r?\n)/m;
+
+    if (!dependenciesHeaderPattern.test(nextContent)) {
+      console.error(`❌ dependencies block not found in ${androidAppBuildGradlePath}`);
+      process.exit(1);
+    }
+
+    nextContent = nextContent.replace(
+      dependenciesHeaderPattern,
+      `$1    ${AMAZON_WINDOW_EXTENSIONS_DEPENDENCY}${newline}`
+    );
+  }
+
+  if (nextContent !== currentContent) {
+    fs.writeFileSync(androidAppBuildGradlePath, nextContent, "utf8");
+  }
+
+  console.log(enabled
+    ? "✅ Amazon Fire WebView compatibility dependency enabled for Store ID 7."
+    : "ℹ️ Amazon Fire WebView compatibility dependency disabled for this store.");
+};
+
+function syncAndroidAdIdPermission() {
+  if (!fs.existsSync(androidManifestPath)) return;
+  const originalContent = fs.readFileSync(androidManifestPath, 'utf8');
+  const newline = originalContent.includes('\r\n') ? '\r\n' : '\n';
+  const marker = '<!-- Codeplay: child-directed advertising ID exclusion -->';
+  const permission = 'com.google.android.gms.permission.AD_ID';
+  const permissionTag = `<uses-permission android:name="${permission}" tools:node="remove" />`;
+  const generatedRule = new RegExp(`^[ \\t]*${marker}\\r?\\n[ \\t]*<uses-permission\\b[^>]*tools:node="remove"[^>]*\\/>\\r?\\n`, 'gm');
+  const hadGeneratedRule = originalContent.includes(marker);
+  let content = originalContent.replace(generatedRule, '');
+  if (isKidsAdmobApp()) {
+    content = content.replace(/(?:^[ \t]*)?<uses-permission\b[^>]*>(?:[ \t\r\n]*<\/uses-permission>)?[ \t]*(?:\r?\n)?/gm, tag =>
+      /android:name\s*=\s*["']com\.google\.android\.gms\.permission\.AD_ID["']/.test(tag) ? '' : tag);
+    if (!/xmlns:tools\s*=/.test(content)) {
+      content = content.replace(/<manifest\b/, '<manifest xmlns:tools="http://schemas.android.com/tools"');
+    }
+    content = content.replace(/(<manifest\b[^>]*>)(?:\r?\n)?/, (match, root) => `${root}${newline}    ${marker}${newline}    ${permissionTag}${newline}`);
+  } else if (hadGeneratedRule) {
+    content = content.replace(/(<manifest\b[^>]*>)(?:\r?\n)?/, (match, root) => `${root}${newline}    <uses-permission android:name="${permission}" />${newline}`);
+  }
+  if (content !== originalContent) {
+    fs.writeFileSync(androidManifestPath, content, 'utf8');
+    console.log(isKidsAdmobApp() ? 'Android advertising ID permission excluded for this kids app.' : 'Android advertising ID permission restored for this non-kids app.');
+  }
+}
+
+const ensureAndroidPermission = (permission, enabled) => {
+  if (!fs.existsSync(androidManifestPath)) return false;
+
+  let manifestContent = fs.readFileSync(androidManifestPath, "utf8");
+  const permissionLine = `    <uses-permission android:name="${permission}" />`;
+  const permissionRegex = new RegExp(`^\\s*<uses-permission\\s+android:name="${permission.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}"\\s*/?>\\s*\\r?\\n?`, "m");
+
+  if (enabled) {
+    if (permissionRegex.test(manifestContent)) return false;
+
+    manifestContent = manifestContent.replace(
+      /<\/manifest>\s*$/,
+      `${permissionLine}\n</manifest>`
+    );
+    fs.writeFileSync(androidManifestPath, manifestContent, "utf8");
+    console.log(`✅ Added Android permission: ${permission}`);
+    return true;
+  }
+
+  if (!permissionRegex.test(manifestContent)) return false;
+
+  manifestContent = manifestContent.replace(permissionRegex, "");
+  fs.writeFileSync(androidManifestPath, manifestContent, "utf8");
+  console.log(`✅ Removed Android permission: ${permission}`);
+  return true;
+};
+
+const syncRevenueCatIapSetup = () => {
+  const admobConfig = getAdmobIapConfig();
+  const iapConfig = admobConfig?.IAP;
+
+  if (!iapConfig) {
+    syncAmazonFireWebViewDependency(false);
+    console.log("ℹ️ IAP configuration not found. Skipping RevenueCat package sync.");
+    return;
+  }
+
+  ensureIapDesignInCapacitorConfig(iapConfig);
+
+  const revenueCatEnabled =
+    iapConfig.playstore === true ||
+    iapConfig.ios === true ||
+    iapConfig.amazon === true;
+  const { storeId, store } = getRevenueCatStoreState(iapConfig);
+  const revenueCatEnabledForCurrentStore = store?.enabled === true;
+  syncAmazonFireWebViewDependency(storeId === 7 && iapConfig.amazon === true);
+
+  if (revenueCatEnabledForCurrentStore && !store.apiKey) {
+    console.error(`❌ RevenueCat IAP is enabled for ${store.name} but ${store.apiKeyName} is missing.`);
+    process.exit(1);
+  }
+
+  let packageChanged = false;
+
+  if (revenueCatEnabledForCurrentStore) {
+    if (!isPackageAvailable("@revenuecat/purchases-capacitor")) {
+      runNpmCommand("npm install @revenuecat/purchases-capacitor");
+      packageChanged = true;
+    } else {
+      console.log(`ℹ️ RevenueCat package already installed for ${store.name}.`);
+    }
+  } else if (isPackageAvailable("@revenuecat/purchases-capacitor")) {
+    runNpmCommand("npm uninstall @revenuecat/purchases-capacitor");
+    packageChanged = true;
+  } else {
+    console.log(`ℹ️ RevenueCat package is not required for store id ${storeId}.`);
+  }
+
+  ensureAndroidPermission("com.android.vending.BILLING", store?.usesGoogleBilling === true && revenueCatEnabledForCurrentStore);
+
+  if (iapConfig.samsung === true && revenueCatEnabled) {
+    console.warn("⚠️ Samsung IAP uses cordova-plugin-samsungiap; PlayStore/Amazon/iOS use RevenueCat.");
+  }
+
+  if (packageChanged) {
+    runNpmCommand("npx cap sync");
+  }
+};
+
+
+
+
+
+
+
+
+
+const compareVersion = (v1, v2) => {
+  const a = v1.split(".").map(Number);
+  const b = v2.split(".").map(Number);
+
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const num1 = a[i] || 0;
+    const num2 = b[i] || 0;
+    if (num1 > num2) return 1;
+    if (num1 < num2) return -1;
+  }
+  return 0;
+};
+
+
+
+
+
+
+
+
+
+
+const admobConfigPaths = [
+  path.join('src', 'js', 'Ads', 'admob-ad-configuration-nextgen.json'),
+  path.join('src', 'js', 'Ads', 'admob-ad-configuration.json')
+];
+
+const checkAdmobConfigurationProperty=()=>{
+
+
+  if (!_admobConfig.ADMOB_ENABLED)
+  {
+    console.log("ℹ️  Admob is not enabled so ad configuration checking is skipping...");
+    return;
+  }
+
+  const admobConfigPath = admobConfigPaths.find(fileExists);
+
+  if (!admobConfigPath) {
+    console.error("❌ Failed to find AdMob configuration JSON. Checked admob-ad-configuration-nextgen.json and admob-ad-configuration.json");
+    process.exit(1);
+  }
+
+
+const REQUIRED_CONFIG_KEYS = [
+  "isKidsApp",
+  "isTesting",
+  "consentDebug",
+  "isConsoleLogEnabled",
+  "bannerEnabled",
+  "bannerDisabledPages",
+  "interstitialEnabled",
+  "appOpenEnabled",
+  "rewardVideoEnabled",
+  "rewardInterstitialEnabled",
+  "collapsibleEnabled",
+  "isLandScape",
+  "isOverlappingEnable",
+  "overlappingHeight",
+  "bannerTypeAndroid",
+  "bannerTypeAndroidLandscape",
+  "bannerTypeiOS",
+  "bannerTypeiOSLandscape",
+  "bannerTopSpaceColor",
+  "interstitialLoadScreenTextColor",
+  "interstitialLoadScreenBackgroundColor",
+  "beforeBannerSpace",
+  "whenShow",
+  "minimumClick",
+  "interstitialTimeOut",
+  "interstitialFirstTimeOut",
+  "appOpenAdsTimeOut",
+  "maxRetryCount",
+  "retrySecondsAr",
+  "appOpenPerSession",
+  "interstitialPerSession",
+  "appOpenFirstTimeOut"
+];
+
+
+
+
+
+  let admobConfigInJson;
+
+  try {
+    admobConfigInJson = JSON.parse(readFileSync(admobConfigPath, "utf8"));
+  } catch (err) {
+      console.error(`❌ Failed to read ${admobConfigPath}`, err);
+      process.exit(1);
+  }
+
+  // ✅ Validate config object exists
+  if (!admobConfigInJson.config) {
+    console.error(`❌ "config" object is missing in ${admobConfigPath}`);
+    process.exit(1);
+  }
+
+
+  const admobConfigMinVersion="1.0"
+
+if (compareVersion(admobConfigInJson.VERSION, admobConfigMinVersion) < 0) {
+  console.error(`❌ Please use at-least version ${admobConfigMinVersion} in "${admobConfigPath}"`);
+  process.exit(1);
+}
+
+
+  const config = admobConfigInJson.config;
+
+  // ✅ Find missing properties
+  const missingKeys = REQUIRED_CONFIG_KEYS.filter(
+    key => !(key in config)
+  );
+
+
+
+  if (missingKeys.length > 0) {
+    console.error(`❌ Missing required configuration keys. Please check it in '${admobConfigPath}'`);
+
+    missingKeys.forEach(k => console.error("   - " + k));
+    process.exit(1);
+  }
+
+
+  console.log(`✅ All keys exist in "${admobConfigPath}". Configuration looks good.`);
+}
+
+
+
+function ensureGitignoreEntry(entry, shouldIgnore = true) {
+  const gitignorePath = path.join(process.cwd(), '.gitignore');
+
+  // If .gitignore doesn't exist, create it
+  if (!fs.existsSync(gitignorePath)) {
+    if (!shouldIgnore) return;
+    fs.writeFileSync(gitignorePath, `${entry}\n`, 'utf8');
+    console.log(`✅ .gitignore created and added: ${entry}`);
+    return;
+  }
+
+  const content = fs.readFileSync(gitignorePath, 'utf8');
+
+  if (!shouldIgnore) {
+    const normalizedEntry = entry.replace(/^\/|\/$/g, '');
+    const nextContent = content.split(/(?<=\n)/).filter(line =>
+      line.trim().replace(/^\/|\/$/g, '') !== normalizedEntry
+    ).join('');
+    if (nextContent !== content) {
+      fs.writeFileSync(gitignorePath, nextContent, 'utf8');
+      console.log(`✅ Removed from .gitignore: ${entry}`);
+    }
+    return;
+  }
+
+  // Normalize lines (trim + remove trailing slashes for comparison)
+  const lines = content
+    .split(/\r?\n/)
+    .map(l => l.trim());
+
+  const normalizedEntry = entry.replace(/\/$/, '');
+
+  const exists = lines.some(
+    line => line.replace(/\/$/, '') === normalizedEntry
+  );
+
+  if (exists) {
+    console.log(`ℹ️  .gitignore already contains: ${entry}`);
+    return;
+  }
+
+  // Ensure file ends with newline
+  const separator = content.endsWith('\n') ? '' : '\n';
+
+  fs.appendFileSync(gitignorePath, `${separator}${entry}\n`, 'utf8');
+  console.log(`✅ Added to .gitignore: ${entry}`);
+}
+
+
+ensureGitignoreEntry('buildCodeplay/', false);
+ensureGitignoreEntry('agent-temp/');
+
+
+// ======================================================
+// Validate theme folder location (src/js/theme is NOT allowed)
+// ======================================================
+
+function validateThemeFolderLocation() {
+  const oldThemePath = path.join(process.cwd(), 'src', 'js', 'theme');
+  const newThemePath = path.join(process.cwd(), 'src', 'theme');
+
+  // ❌ Block old structure
+  if (fs.existsSync(oldThemePath)) {
+    console.error(
+      '\n❌ INVALID PROJECT STRUCTURE DETECTED\n' +
+      '--------------------------------------------------\n' +
+      'The "theme" folder must NOT be inside:\n' +
+      '  src/js/theme\n\n' +
+      '✅ Correct location is:\n' +
+      '  src/theme\n\n' +
+      '🛑 Please move the folder and re-run the build.\n'
+    );
+    process.exit(1);
+  }
+
+  // ⚠️ Optional warning if new theme folder is missing
+  if (!fs.existsSync(newThemePath)) {
+    console.warn(
+      '\n⚠️ WARNING: "src/theme" folder not found.\n' +
+      'If your app uses themes, please ensure it exists.\n'
+    );
+  } else {
+    console.log('✅ Theme folder structure validated (src/theme).');
+  }
+}
+const validateAndRestoreSignDetails=()=>{
+
+  // Read config file
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+  // Ensure android and buildOptions exist
+  if (!config.android) config.android = {};
+  if (!config.android.buildOptions) config.android.buildOptions = {};
+
+  // Update only if changed
+  let updated = false;
+
+  if (config.android.buildOptions.releaseType !== 'AAB') {
+    config.android.buildOptions.releaseType = 'AAB';
+    updated = true;
+  }
+
+  if (config.android.buildOptions.signingType !== 'jarsigner') {
+    config.android.buildOptions.signingType = 'jarsigner';
+    updated = true;
+  }
+
+  // Write back only if modified
+  if (updated) {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log('capacitor.config.json updated successfully.');
+  } else {
+    console.log('No changes needed.');
+  }
+
+}
+
+//##################################  SystemBars.java update for "@capacitor/android": "^8.3.0" plugin START ###############################
+
+
+const filePath = path.join(
+  __dirname,
+  "../node_modules/@capacitor/android/capacitor/src/main/java/com/getcapacitor/plugin/SystemBars.java"
+);
+
+const SYSTEM_BARS_PATCH_MARKER = "CODEPLAY_KEYBOARD_INSET_FIX";
+
+function getSystemBarsPatchedBlock(originalBlock, content) {
+  const isCapacitor842OrNewer = content.includes("private String insetsHandling = INSETS_HANDLING_CSS;");
+  const safeAreaCondition = isCapacitor842OrNewer
+    ? "INSETS_HANDLING_CSS.equals(insetsHandling)"
+    : "Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM && hasViewportCover && insetHandlingEnabled";
+
+  return `if (shouldPassthroughInsets) {
+                /* ${SYSTEM_BARS_PATCH_MARKER}
+${originalBlock.split("\n").map(line => "                   " + line).join("\n")}
+                */
+
+                // Codeplay fix: avoid adding IME height as WebView parent padding.
+                v.setPadding(0, 0, 0, 0);
+
+                if (${safeAreaCondition}) {
+                    Insets safeAreaInsets = calcSafeAreaInsets(insets);
+                    injectSafeAreaCSS(safeAreaInsets.top, safeAreaInsets.right, safeAreaInsets.bottom, safeAreaInsets.left);
+                }
+
+                return insets; // WebView handles keyboard and safe-area sizing.
+            }`;
+}
+
+function findShouldPassthroughInsetsBlock(content) {
+  const start = content.indexOf("            if (shouldPassthroughInsets) {");
+  if (start === -1) return null;
+
+  const endMarker = "\n\n            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM)";
+  const end = content.indexOf(endMarker, start);
+  if (end === -1) return null;
+
+  return {
+    start,
+    end,
+    text: content.slice(start, end)
+  };
+}
+
+// 🚨 ERROR MESSAGE
+const ERROR_MSG = `
+❌ Capacitor SystemBars.java structure changed!
+
+Plugin: @capacitor/android
+Path : node_modules\@capacitor\android\capacitor\src\main\java\com\getcapacitor\plugin\SystemBars.java
+
+Check version of "@capacitor/android": in package.json
+
+👉 Expected code block not found.
+
+This usually means Capacitor updated internally.
+
+Please:
+1. Open SystemBars.java
+2. Update patch script
+3. Re-run build
+
+⛔ Build stopped.
+`;
+
+function patchFile() {
+  if (!fs.existsSync(filePath)) {
+    console.error("❌ SystemBars.java not found!");
+    process.exit(1);
+  }
+
+  const capacitorConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
+  if (capacitorConfig.plugins?.SystemBars?.insetsHandling === "disable") {
+    console.log('ℹ️ SystemBars.insetsHandling is "disable"; skipping SystemBars.java keyboard inset patch.');
+    return;
+  }
+
+  let content = fs.readFileSync(filePath, "utf8");
+
+  // ✅ Already patched?
+  if (content.includes(SYSTEM_BARS_PATCH_MARKER) || content.includes("🔴 ORIGINAL CODE (COMMENTED FOR SAFETY)")) {
+    console.log("✅ Already SystemBars.java patched. Skipping...");
+    return;
+  }
+
+  const block = findShouldPassthroughInsetsBlock(content);
+  if (!block) {
+    console.error(ERROR_MSG);
+    process.exit(1);
+  }
+
+  // 🔁 Replace
+  const updated =
+    content.slice(0, block.start) +
+    getSystemBarsPatchedBlock(block.text, content) +
+    content.slice(block.end);
+
+  fs.writeFileSync(filePath, updated, "utf8");
+
+  console.log("✅ SystemBars.java patched with Codeplay keyboard inset fix!");
+}
+
+//patchFile();
+
+//##################################  SystemBars.java update for "@capacitor/android": "^8.3.0" plugin END ###############################
+
+// Android build optimization START
+function findAndroidBuildBlock(content, name) {
+  // Mask comments and strings without changing offsets or line endings.
+  const masked = content.replace(/\/\*[\s\S]*?\*\/|\/\/[^\r\n]*|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/g,
+    value => value.replace(/[^\r\n]/g, ' '));
+  const header = new RegExp(`\\b${name}\\s*\\{`, 'g');
+  let depth = 0;
+  for (let index = 0; index < masked.length; index += 1) {
+    if (depth === 0) {
+      header.lastIndex = index;
+      const match = header.exec(masked);
+      if (match && match.index === index) {
+        const start = header.lastIndex;
+        let blockDepth = 1;
+        for (let end = start; end < masked.length; end += 1) {
+          if (masked[end] === '{') blockDepth += 1;
+          if (masked[end] === '}' && --blockDepth === 0) return { start, end };
+        }
+        throw new Error(`Unclosed Android Gradle ${name} block.`);
+      }
+    }
+    if (masked[index] === '{') depth += 1;
+    if (masked[index] === '}') depth -= 1;
+  }
+  return null;
+}
+
+function syncAndroidBuildOptimization() {
+  if (buildPlatform !== 'android' || !fs.existsSync(androidAppBuildGradlePath)) return;
+
+  const original = fs.readFileSync(androidAppBuildGradlePath, 'utf8');
+  const newline = original.includes('\r\n') ? '\r\n' : '\n';
+  const androidBlock = findAndroidBuildBlock(original, 'android');
+  if (!androidBlock) throw new Error('Android Gradle android block was not found.');
+  let androidContent = original.slice(androidBlock.start, androidBlock.end);
+  const buildTypesBlock = findAndroidBuildBlock(androidContent, 'buildTypes');
+  if (!buildTypesBlock) throw new Error('Android Gradle buildTypes block was not found.');
+  let buildTypesContent = androidContent.slice(buildTypesBlock.start, buildTypesBlock.end);
+
+  // Match the existing finalrelease compatibility exception for this native plugin.
+  const ffmpegPluginXml = path.join(process.cwd(), 'node_modules', 'codeplay-fmpg', 'plugin.xml');
+  const optimizeRelease = !(fs.existsSync(ffmpegPluginXml)
+    && /<plugin\b/.test(fs.readFileSync(ffmpegPluginXml, 'utf8')));
+
+  for (const name of ['debug', 'release']) {
+    const enabled = name === 'debug' || optimizeRelease;
+    const block = findAndroidBuildBlock(buildTypesContent, name);
+    const blockComments = buildTypesContent.match(/\/\*[\s\S]*?\*\/|\/\/[^\r\n]*|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/g) || [];
+    if (!block && blockComments.some(comment => (comment.startsWith('//') || comment.startsWith('/*'))
+      && new RegExp(`\\b${name}\\s*\\{`).test(comment))) continue;
+    let body = block ? buildTypesContent.slice(block.start, block.end) : `${newline}        `;
+    const comments = (body.match(/\/\*[\s\S]*?\*\/|\/\/[^\r\n]*|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/g) || [])
+      .filter(value => value.startsWith('//') || value.startsWith('/*'));
+    for (const setting of ['minifyEnabled', 'shrinkResources']) {
+      const masked = body.replace(/\/\*[\s\S]*?\*\/|\/\/[^\r\n]*|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/g,
+        value => value.replace(/[^\r\n]/g, ' '));
+      const settingPattern = new RegExp(`\\b${setting}\\b`);
+      // Existing values, expressions and commented opt-outs take precedence.
+      if (settingPattern.test(masked) || comments.some(comment => settingPattern.test(comment))) continue;
+      const value = setting === 'shrinkResources'
+        ? enabled && /\bminifyEnabled\s*(?:=\s*)?true\b/.test(masked)
+        : enabled;
+      body = `${newline}            ${setting} ${value}${body}`;
+    }
+    const activeBody = body.replace(/\/\*[\s\S]*?\*\/|\/\/[^\r\n]*|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/g,
+      value => value.startsWith('//') || value.startsWith('/*') ? value.replace(/[^\r\n]/g, ' ') : value);
+    const defaultRules = [...activeBody.matchAll(/getDefaultProguardFile\(\s*(['"])proguard-android\.txt\1\s*\)/g)];
+    for (const match of defaultRules.reverse()) {
+      body = body.slice(0, match.index) + "getDefaultProguardFile('proguard-android-optimize.txt')"
+        + body.slice(match.index + match[0].length);
+    }
+    if (!/\bproguardFiles\b/.test(activeBody)
+      && !comments.some(comment => /\bproguardFiles\b/.test(comment))) {
+      body = `${newline}            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'${body}`;
+    }
+    buildTypesContent = block
+      ? buildTypesContent.slice(0, block.start) + body + buildTypesContent.slice(block.end)
+      : `${buildTypesContent.trimEnd()}${newline}        ${name} {${body}}${newline}    `;
+  }
+
+  androidContent = androidContent.slice(0, buildTypesBlock.start) + buildTypesContent
+    + androidContent.slice(buildTypesBlock.end);
+  const next = original.slice(0, androidBlock.start) + androidContent + original.slice(androidBlock.end);
+  if (next !== original) fs.writeFileSync(androidAppBuildGradlePath, next, 'utf8');
+
+  const propertiesPath = path.join(androidPlatformPath, 'gradle.properties');
+  const properties = fs.existsSync(propertiesPath) ? fs.readFileSync(propertiesPath, 'utf8') : '';
+  const property = 'android.r8.optimizedResourceShrinking=true';
+  const propertyPattern = /^[ \t]*[#!]?[ \t]*android\.r8\.optimizedResourceShrinking(?:[ \t]*[=:]|[ \t]+|[ \t]*$)/m;
+  const nextProperties = propertyPattern.test(properties)
+    ? properties
+    : `${properties.trimEnd()}${newline}${property}${newline}`;
+  if (nextProperties !== properties) fs.writeFileSync(propertiesPath, nextProperties, 'utf8');
+  console.log('✅ Android build optimization defaults checked; existing settings and commented opt-outs preserved.');
+}
+// Android build optimization END
+
+function syncAndroidCordovaResourceKeep() {
+  if (buildPlatform !== 'android' || !fs.existsSync(androidPlatformPath)) return;
+
+  // Cordova loads config.xml by name; preserve it even when no plugins are installed yet.
+  const rawPath = path.join(androidPlatformPath, 'app', 'src', 'main', 'res', 'raw');
+  const keepPath = path.join(rawPath, 'codeplay_cordova_keep.xml');
+  const content = '<?xml version="1.0" encoding="utf-8"?>\n'
+    + '<resources xmlns:tools="http://schemas.android.com/tools"\n'
+    + '    tools:keep="@xml/config" />\n';
+  if (fs.existsSync(keepPath) && fs.readFileSync(keepPath, 'utf8') === content) return;
+
+  fs.mkdirSync(rawPath, { recursive: true });
+  fs.writeFileSync(keepPath, content, 'utf8');
+}
+
+async function main() {
+  validateThemeFolderLocation();
+  validateAndRestoreSignDetails();
+  ensureMandatoryCapacitorPlugins();
+
+  await loadPluginVersions();   // 🔥 NEW
+  await syncAgentInstructions();
+
+   await syncAdmobNextgenMigration();
+   syncCodeplaySystemBarsPackage();
+   syncSystemBarsSafeAreaMigration();
+  await checkPlugins();
+  ensureIapStartupOnHomePage();
+  syncRevenueCatIapSetup();
+  syncFirebaseAnalyticsSetup();
+  checkAndupdateDropInViteConfig();
+  checkAdmobConfigurationProperty();
+  syncAndroidAdIdPermission();
+  syncAndroidBuildOptimization();
+  syncAndroidCordovaResourceKeep();
+}
+
+await main();
+})().catch(err => {
+  console.error(err?.message || err);
+  process.exit(1);
+});
+
+
+
+
+/*
+Release Notes
+
+  6.5
+    Enable debug/release optimization and optimized resource shrinking before Android builds.
+    Preserve existing values and commented opt-outs without adding duplicate settings.
+    Kids ad configuration disables iOS ATT prompts and excludes Android AD_ID during builds.
+    Non-kids apps retain tracking prompts and normal permission behavior.
+    Ad configuration migration preserves newer local configuration versions.
+
+  5.1
+    Kotlin version update is commented. Previously admob is not worked if not update the kotlin version to higher version
+
+*/