╔══════════════════════════════════════════════════╗
║                CODE REPOSITORY ARCHIVE           ║
╠══════════════════════════════════════════════════╣
║ Repository: Wc-multi                             ║
║ Generated: 8/31/2026, 11:26:06 AM                ║
║ Files: 1                                        ║
║ Description: Wc                                  ║
╚══════════════════════════════════════════════════╝

FILE SUMMARY
────────────────────────────────────────────────────
Total files: 1
Total size: 155775 characters
Folder structure: Wc-multi/

Languages:
  - javascript: 1 files

FILE CONTENTS
════════════════════════════════════════════════════

┌── FILE 01: Wc-multi/worker.js
│   Size: 155775 characters
│   Language: javascript
│   Created: 7/5/2026
└────────────────────────────────────────────────────

const CF_BASE_URL = "https://api.cloudflare.com/client/v4";

function jsonResponse(payload, status = 200) {
  return new Response(JSON.stringify(payload), {
    status,
    headers: {
      ...corsHeaders,
      "Content-Type": "application/json"
    }
  });
}

function sanitizeWorkerName(name) {
  const fallback = `wc-${Date.now().toString(36)}`;
  const clean = String(name || fallback)
    .toLowerCase()
    .replace(/[^a-z0-9-]/g, '-')
    .replace(/-+/g, '-')
    .replace(/^-|-$/g, '')
    .slice(0, 63);
  return clean || fallback;
}

function cleanHost(value) {
  return String(value || '')
    .trim()
    .toLowerCase()
    .replace(/^https?:\/\//, '')
    .replace(/\/.*$/, '')
    .replace(/\s+/g, '')
    .replace(/^\.+|\.+$/g, '');
}

function validBaseHost(host) {
  host = cleanHost(host);
  return !!host && host.length <= 253 && !host.includes('..') && host.split('.').every(label =>
    /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(label)
  );
}

function validHost(host) {
  host = cleanHost(host);
  if (!host) return false;
  if (host.startsWith('*.')) return validBaseHost(host.slice(2));
  return validBaseHost(host);
}

function autoNodeCount(totalHosts, targetMode = 'multi_failover') {
  const mode = String(targetMode || '').toLowerCase();
  if (mode === 'single') return 1;
  const total = Math.max(1, Number.parseInt(String(totalHosts || '1'), 10) || 1);
  if (total <= 8) return 2;
  if (total <= 30) return 4;
  if (total <= 100) return 6;
  if (total <= 250) return 8;
  if (total <= 600) return 10;
  return 12;
}

function statusFromDomain(domain) {
  if (!domain) return 'not_found';
  const values = [
    domain.status,
    domain.state,
    domain.certificate_status,
    domain.ssl_status,
    domain?.certificate?.status,
    domain?.ssl?.status,
    domain?.ownership_verification?.status,
    domain?.verification?.status
  ].filter(v => v !== undefined && v !== null).map(v => String(v).toLowerCase());

  if (values.some(v => v.includes('active') || v.includes('success') || v.includes('valid') || v.includes('issued') || v.includes('ready'))) return 'active';
  if (values.some(v => v.includes('pending') || v.includes('initial') || v.includes('verify'))) return 'pending';
  if (values.some(v => v.includes('fail') || v.includes('error') || v.includes('blocked'))) return 'error';
  return values[0] || 'listed';
}

class CfClient {
  constructor(email, apiKey) {
    this.email = String(email || '').trim();
    this.apiKey = String(apiKey || '').trim();
  }

  headers(contentType = 'application/json') {
    const h = {
      "X-Auth-Email": this.email,
      "X-Auth-Key": this.apiKey,
      "User-Agent": "Wildcard-Manager/1.6"
    };
    if (contentType) h["Content-Type"] = contentType;
    return h;
  }

  async _fetch(path, options = {}) {
    if (!this.email || !this.apiKey) throw new Error('Email/API Key kosong. Import akun dulu.');
    const url = path.startsWith('http') ? path : `${CF_BASE_URL}${path}`;
    const response = await fetch(url, {
      method: options.method || 'GET',
      headers: this.headers(options.contentType === undefined ? 'application/json' : options.contentType),
      body: options.body
    });

    const text = await response.text();
    let data = {};
    if (text) {
      try { data = JSON.parse(text); }
      catch (_) {
        if (!response.ok) throw new Error(`Cloudflare API Error ${response.status}: ${text.slice(0, 180)}`);
        data = { success: true, result: text };
      }
    }

    if (!response.ok || data?.success === false) {
      const msg = data?.errors?.map(e => e.message).join('; ') || data?.messages?.map(e => e.message).join('; ') || `Cloudflare API Error ${response.status}`;
      throw new Error(msg);
    }
    return data;
  }

  async getAccounts() {
    return this._fetch('/accounts?per_page=100');
  }

  async listZones(status = 'active') {
    const all = [];
    for (let page = 1; page <= 10; page++) {
      let path = `/zones?per_page=100&page=${page}`;
      if (status) path += `&status=${encodeURIComponent(status)}`;
      const data = await this._fetch(path);
      const rows = Array.isArray(data.result) ? data.result : [];
      all.push(...rows);
      const info = data.result_info || {};
      if (!rows.length || (info.total_pages && page >= info.total_pages)) break;
    }
    return { success: true, result: all };
  }

  async listDnsRecords(zoneId, name = '') {
    let path = `/zones/${zoneId}/dns_records?per_page=100`;
    if (name) path += `&name=${encodeURIComponent(name)}`;
    return this._fetch(path);
  }

  async deleteDnsRecord(zoneId, recordId) {
    return this._fetch(`/zones/${zoneId}/dns_records/${recordId}`, {
      method: 'DELETE',
      contentType: null
    });
  }

  async createZone(accountId, domainName) {
    return this._fetch('/zones', {
      method: 'POST',
      body: JSON.stringify({
        account: { id: accountId },
        name: domainName,
        jump_start: true,
        type: 'full'
      })
    });
  }

  async deleteZone(zoneId) {
    return this._fetch(`/zones/${zoneId}`, {
      method: 'DELETE',
      contentType: null
    });
  }

  async createDnsRecord(zoneId, record) {
    return this._fetch(`/zones/${zoneId}/dns_records`, {
      method: 'POST',
      body: JSON.stringify(record)
    });
  }

  async updateZoneSetting(zoneId, setting, value) {
    return this._fetch(`/zones/${zoneId}/settings/${setting}`, {
      method: 'PATCH',
      body: JSON.stringify({ value })
    });
  }

  async getUniversalSslSetting(zoneId) {
    return this._fetch(`/zones/${zoneId}/ssl/universal/settings`);
  }

  async updateUniversalSslSetting(zoneId, enabled = true) {
    return this._fetch(`/zones/${zoneId}/ssl/universal/settings`, {
      method: 'PATCH',
      body: JSON.stringify({ enabled: !!enabled })
    });
  }

  async getSslSettings(zoneId) {
    const settingNames = ['ssl', 'always_use_https', 'automatic_https_rewrites', 'min_tls_version'];
    const settings = {};
    for (const name of settingNames) {
      try {
        const res = await this._fetch(`/zones/${zoneId}/settings/${name}`);
        settings[name] = res.result || res;
      } catch (e) {
        settings[name] = { value: null, error: e.message };
      }
    }
    try {
      const universal = await this.getUniversalSslSetting(zoneId);
      settings.universal_ssl = universal.result || universal;
    } catch (e) {
      settings.universal_ssl = { enabled: null, error: e.message };
    }
    return settings;
  }

  async activateSslRecommended(zoneId) {
    const steps = [
      { label: 'Universal SSL', run: () => this.updateUniversalSslSetting(zoneId, true) },
      { label: 'SSL/TLS mode Full', run: () => this.updateZoneSetting(zoneId, 'ssl', 'full') },
      { label: 'Always Use HTTPS', run: () => this.updateZoneSetting(zoneId, 'always_use_https', 'on') },
      { label: 'Automatic HTTPS Rewrites', run: () => this.updateZoneSetting(zoneId, 'automatic_https_rewrites', 'on') },
      { label: 'Minimum TLS 1.2', run: () => this.updateZoneSetting(zoneId, 'min_tls_version', '1.2') }
    ];
    const results = [];
    for (const step of steps) {
      try {
        const res = await step.run();
        results.push({ label: step.label, success: true, result: res.result || res });
      } catch (e) {
        results.push({ label: step.label, success: false, message: e.message });
      }
    }
    return results;
  }

  async updateWorker(accountId, workerName, scriptContent) {
    const boundary = `----CFWildcardBoundary${Date.now().toString(16)}`;
    const metadata = {
      main_module: 'worker.js',
      compatibility_date: '2024-12-03',
      compatibility_flags: ['nodejs_compat']
    };
    const body = [
      `--${boundary}`,
      'Content-Disposition: form-data; name="worker.js"; filename="worker.js"',
      'Content-Type: application/javascript+module',
      '',
      scriptContent,
      `--${boundary}`,
      'Content-Disposition: form-data; name="metadata"',
      'Content-Type: application/json',
      '',
      JSON.stringify(metadata),
      `--${boundary}--`,
      ''
    ].join('\r\n');

    return this._fetch(`/accounts/${accountId}/workers/services/${workerName}/environments/production`, {
      method: 'PUT',
      contentType: `multipart/form-data; boundary=${boundary}`,
      body
    });
  }

  async getOrCreateSubdomain(accountId) {
    try {
      const data = await this._fetch(`/accounts/${accountId}/workers/subdomain`);
      if (data?.result?.subdomain) return data.result.subdomain;
    } catch (_) {}

    const base = (this.email.split('@')[0] || 'worker')
      .toLowerCase()
      .replace(/[^a-z0-9-]/g, '')
      .slice(0, 28) || `wc${Date.now().toString(36)}`;

    const data = await this._fetch(`/accounts/${accountId}/workers/subdomain`, {
      method: 'PUT',
      body: JSON.stringify({ subdomain: base })
    });
    return data?.result?.subdomain || base;
  }

  async createWorker(accountId, workerName, scriptContent) {
    await this.updateWorker(accountId, workerName, scriptContent);
    try {
      await this._fetch(`/accounts/${accountId}/workers/services/${workerName}/environments/production/subdomain`, {
        method: 'POST',
        body: JSON.stringify({ enabled: true })
      });
    } catch (_) {}
    return { workerName, subdomain: await this.getOrCreateSubdomain(accountId) };
  }

  async registerCustomDomain(accountId, workerName, hostname, zoneId) {
    return this._fetch(`/accounts/${accountId}/workers/domains`, {
      method: 'PUT',
      body: JSON.stringify({
        environment: 'production',
        hostname,
        service: workerName,
        zone_id: zoneId
      })
    });
  }

  async findWorkerDomain(accountId, hostname, workerName) {
    const data = await this._fetch(`/accounts/${accountId}/workers/domains?hostname=${encodeURIComponent(hostname)}`);
    const rows = Array.isArray(data.result) ? data.result : [];
    const lowerHost = String(hostname || '').toLowerCase();
    const lowerWorker = String(workerName || '').toLowerCase();
    return rows.find(d => String(d.hostname || '').toLowerCase() === lowerHost && String(d.service || '').toLowerCase() === lowerWorker)
      || rows.find(d => String(d.hostname || '').toLowerCase() === lowerHost)
      || null;
  }

  async listPagesProjects(accountId) {
    const data = await this._fetch(`/accounts/${accountId}/pages/projects`);
    return { success: true, result: Array.isArray(data.result) ? data.result : [] };
  }

  async createPagesProject(accountId, projectName) {
    return this._fetch(`/accounts/${accountId}/pages/projects`, {
      method: 'POST',
      body: JSON.stringify({
        name: projectName,
        production_branch: 'main'
      })
    });
  }

  async deployPagesProject(accountId, projectName, scriptContent) {
    const boundary = '----Boundary' + Date.now().toString(36);
    let body = '--' + boundary + '\r\nContent-Disposition: form-data; name="manifest"\r\n\r\n{"name":"' + projectName + '"}\r\n';
    body += '--' + boundary + '\r\nContent-Disposition: form-data; name="_worker.js"; filename="_worker.js"\r\nContent-Type: application/javascript\r\n\r\n' + scriptContent + '\r\n';
    body += '--' + boundary + '--\r\n';

    return this._fetch(`/accounts/${accountId}/pages/projects/${encodeURIComponent(projectName)}/deployments`, {
      method: 'POST',
      contentType: 'multipart/form-data; boundary=' + boundary,
      body: body
    });
  }

  async listPagesDomains(accountId, projectName) {
    const data = await this._fetch(`/accounts/${accountId}/pages/projects/${encodeURIComponent(projectName)}/domains`);
    return { success: true, result: Array.isArray(data.result) ? data.result : [] };
  }

  async addPagesDomain(accountId, projectName, domainName) {
    return this._fetch(`/accounts/${accountId}/pages/projects/${encodeURIComponent(projectName)}/domains`, {
      method: 'POST',
      body: JSON.stringify({ name: domainName })
    });
  }

  async deletePagesDomain(accountId, projectName, domainName) {
    return this._fetch(`/accounts/${accountId}/pages/projects/${encodeURIComponent(projectName)}/domains/${encodeURIComponent(domainName)}`, {
      method: 'DELETE',
      contentType: null
    });
  }

  async triggerPagesVerification(accountId, projectName, domainName) {
    return this._fetch(`/accounts/${accountId}/pages/projects/${encodeURIComponent(projectName)}/domains/${encodeURIComponent(domainName)}`, {
      method: 'PATCH'
    });
  }
}

const corsHeaders = {
  'Access-Control-Allow-Origin': '*',
  'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
  'Access-Control-Allow-Headers': 'Content-Type'
};

async function handleApiRequest(request) {
  if (request.method === 'OPTIONS') return new Response(null, { headers: corsHeaders });
  const url = new URL(request.url);
  const path = url.pathname;
  let body = {};
  try { body = await request.json(); }
  catch (_) { body = {}; }

  try {
    const email = body.email;
    const apiKey = body.apiKey;
    const accountId = String(body.accountId || '').trim();
    const client = new CfClient(email, apiKey);

    if (path === '/api/accounts') {
      return jsonResponse(await client.getAccounts());
    }

    if (path === '/api/domainManager/list') {
      if (!accountId) throw new Error('Account ID kosong. Import akun format email|apiKey|accountId atau biarkan sistem mengambil account ID otomatis.');
      const data = await client.listZones('');
      const domains = (Array.isArray(data.result) ? data.result : [])
        .map(z => ({
          id: z.id,
          name: z.name,
          status: z.status || '',
          paused: !!z.paused,
          type: z.type || '',
          name_servers: Array.isArray(z.name_servers) ? z.name_servers : [],
          original_name_servers: Array.isArray(z.original_name_servers) ? z.original_name_servers : [],
          plan: z.plan && z.plan.name ? z.plan.name : ''
        }))
        .filter(z => z.id && z.name)
        .sort((a, b) => a.name.localeCompare(b.name));
      return jsonResponse({ success: true, domains });
    }

    if (path === '/api/domainManager/add') {
      if (!accountId) throw new Error('Account ID kosong. Pilih account dulu.');
      const domainName = cleanHost(body.domainName);
      if (!validBaseHost(domainName) || domainName.split('.length') < 2) throw new Error('Nama domain tidak valid. Contoh: domain.com');
      const data = await client.createZone(accountId, domainName);
      return jsonResponse({ success: true, domain: data.result || data });
    }

    if (path === '/api/domainManager/delete') {
      const domainId = String(body.domainId || '').trim();
      if (!domainId) throw new Error('Domain ID kosong.');
      const data = await client.deleteZone(domainId);
      return jsonResponse({ success: true, result: data.result || data });
    }

    if (path === '/api/domainManager/dnsList') {
      const domainId = String(body.domainId || '').trim();
      if (!domainId) throw new Error('Domain ID kosong.');
      const data = await client.listDnsRecords(domainId);
      const records = (Array.isArray(data.result) ? data.result : [])
        .map(r => ({
          id: r.id,
          type: r.type,
          name: r.name,
          content: r.content,
          proxied: !!r.proxied,
          ttl: r.ttl,
          priority: r.priority,
          created_on: r.created_on,
          modified_on: r.modified_on
        }))
        .sort((a, b) => String(a.name || '').localeCompare(String(b.name || '')) || String(a.type || '').localeCompare(String(b.type || '')));
      return jsonResponse({ success: true, records });
    }

    if (path === '/api/domainManager/fetchBulkText') {
      const rawUrl = String(body.url || body.rawUrl || '').trim();
      if (!/^https?:\/\//i.test(rawUrl)) throw new Error('URL raw harus diawali http:// atau https://');
      const res = await fetch(rawUrl, {
        method: 'GET',
        headers: { 'User-Agent': 'CF-Manager-Pro-BulkDNS/1.0' },
        cf: { cacheTtl: 0, cacheEverything: false }
      });
      if (!res.ok) throw new Error('Gagal mengambil URL raw: HTTP ' + res.status);
      const text = await res.text();
      if (text.length > 300000) throw new Error('File raw terlalu besar. Maksimal sekitar 300KB.');
      return jsonResponse({ success: true, text });
    }

    if (path === '/api/domainManager/dnsAdd') {
      const domainId = String(body.domainId || '').trim();
      const domainName = cleanHost(body.domainName);
      const type = String(body.type || '').trim().toUpperCase();
      let name = cleanHost(body.name);
      const content = String(body.content || '').trim();
      const proxied = body.proxied === true;
      const ttl = Number(body.ttl || 1);
      if (!domainId || !domainName) throw new Error('Domain wajib dipilih.');
      if (!['A', 'AAAA', 'CNAME', 'TXT', 'MX', 'SRV', 'NS'].includes(type)) throw new Error('Tipe DNS tidak valid.');
      if (!name || name === '@') name = domainName;
      else if (!(name === domainName || name.endsWith('.' + domainName))) name = `${name}.${domainName}`;
      if (!validHost(name)) throw new Error('Nama record tidak valid.');
      if (!content) throw new Error('Target/content DNS kosong.');
      const record = { type, name, content, ttl: ttl || 1 };
      if (type === 'MX') record.priority = Number(body.priority || 10);
      if (['A', 'AAAA', 'CNAME'].includes(type)) record.proxied = proxied;
      const data = await client.createDnsRecord(domainId, record);
      return jsonResponse({ success: true, record: data.result || data });
    }

    if (path === '/api/domainManager/dnsDelete') {
      const domainId = String(body.domainId || '').trim();
      const recordId = String(body.recordId || '').trim();
      if (!domainId || !recordId) throw new Error('Domain atau DNS record kosong.');
      const data = await client.deleteDnsRecord(domainId, recordId);
      return jsonResponse({ success: true, result: data.result || data });
    }

    if (path === '/api/domainManager/sslSettings') {
      const domainId = String(body.domainId || '').trim();
      if (!domainId) throw new Error('Domain ID kosong.');
      const settings = await client.getSslSettings(domainId);
      return jsonResponse({ success: true, settings });
    }

    if (path === '/api/domainManager/sslUpdate') {
      const domainId = String(body.domainId || '').trim();
      const setting = String(body.setting || '').trim();
      const value = String(body.value || '').trim();
      const allowedSettings = ['ssl', 'always_use_https', 'automatic_https_rewrites', 'min_tls_version'];
      if (!domainId) throw new Error('Domain ID kosong.');
      if (!allowedSettings.includes(setting)) throw new Error('Setting SSL tidak didukung.');
      if (!value) throw new Error('Nilai setting kosong.');
      const data = await client.updateZoneSetting(domainId, setting, value);
      return jsonResponse({ success: true, result: data.result || data });
    }

    if (path === '/api/domainManager/sslUniversal') {
      const domainId = String(body.domainId || '').trim();
      if (!domainId) throw new Error('Domain ID kosong.');
      const data = await client.updateUniversalSslSetting(domainId, body.enabled !== false);
      return jsonResponse({ success: true, result: data.result || data });
    }

    if (path === '/api/domainManager/sslActivate') {
      const domainId = String(body.domainId || '').trim();
      if (!domainId) throw new Error('Domain ID kosong.');
      const results = await client.activateSslRecommended(domainId);
      return jsonResponse({ success: true, results });
    }

    if (path === '/api/pagesManager/projects') {
      if (!accountId) throw new Error('Account ID kosong. Pilih/import akun dulu.');
      const data = await client.listPagesProjects(accountId);
      const projects = (Array.isArray(data.result) ? data.result : [])
        .map(p => ({ name: p.name, subdomain: p.subdomain || '', domains: p.domains || [], production_branch: p.production_branch || '', created_on: p.created_on || '' }))
        .filter(p => p.name)
        .sort((a, b) => a.name.localeCompare(b.name));
      return jsonResponse({ success: true, projects });
    }

    if (path === '/api/pagesManager/domains') {
      if (!accountId) throw new Error('Account ID kosong.');
      const projectName = String(body.projectName || '').trim();
      if (!projectName) throw new Error('Pilih Pages Project dulu.');
      const data = await client.listPagesDomains(accountId, projectName);
      const domains = (Array.isArray(data.result) ? data.result : [])
        .map(d => ({ name: d.name, status: d.status || d.validation_status || '', verification_data: d.verification_data || null, created_on: d.created_on || '', modified_on: d.modified_on || '' }))
        .filter(d => d.name)
        .sort((a, b) => a.name.localeCompare(b.name));
      return jsonResponse({ success: true, domains });
    }

    if (path === '/api/pagesManager/bulkAdd') {
      if (!accountId) throw new Error('Account ID kosong.');
      const projectName = String(body.projectName || '').trim();
      if (!projectName) throw new Error('Pilih Pages Project dulu.');
      const raw = Array.isArray(body.domains) ? body.domains.join('\n') : String(body.domains || '');
      const rows = [];
      const seen = new Set();
      raw.split(/[\n,;]+/).map(v => v.replace(/#.*/, '').trim()).filter(Boolean).forEach(v => {
        const name = cleanHost(v);
        if (validBaseHost(name) && !seen.has(name)) { seen.add(name); rows.push(name); }
      });
      if (!rows.length) throw new Error('Tidak ada domain Pages valid.');
      const results = [];
      for (const name of rows.slice(0, 50)) {
        const row = { name, success: false, status: 'unknown' };
        try {
          const data = await client.addPagesDomain(accountId, projectName, name);
          row.success = true;
          row.status = statusFromDomain(data.result || {});
          row.result = data.result || null;
        } catch (e) {
          row.error = e.message || String(e);
          if (/already|exist|duplicate/i.test(row.error)) {
            row.success = true;
            row.status = 'already_exists_or_pending';
          }
        }
        results.push(row);
      }
      return jsonResponse({ success: true, projectName, results });
    }

    if (path === '/api/pagesManager/delete') {
      if (!accountId) throw new Error('Account ID kosong.');
      const projectName = String(body.projectName || '').trim();
      const domainName = cleanHost(body.domainName);
      if (!projectName || !domainName) throw new Error('Project/domain kosong.');
      const data = await client.deletePagesDomain(accountId, projectName, domainName);
      return jsonResponse({ success: true, result: data.result || data });
    }

    if (path === '/api/wildcardSsl/resources') {
      if (!accountId) throw new Error('Account ID kosong. Import akun format email|apiKey|accountId atau biarkan sistem mengambil account ID otomatis.');
      let workerSubdomain = '';
      try { workerSubdomain = await client.getOrCreateSubdomain(accountId); }
      catch (_) { workerSubdomain = ''; }

      const zr = await client.listZones('active');
      const zones = (Array.isArray(zr.result) ? zr.result : [])
        .map(z => ({ id: z.id, name: z.name }))
        .filter(z => z.id && z.name)
        .sort((a, b) => a.name.localeCompare(b.name));

      return jsonResponse({ success: true, workerSubdomain, zones, warnings: {} });
    }

    if (path === '/api/wildcardSsl/bulk') {
      const zoneName = cleanHost(body.zoneName);
      const zoneId = String(body.zoneId || '').trim();
      const prefix = cleanHost(body.prefix);
      const mode = String(body.mode || 'attach');
      const proxied = body.proxied !== false;
      const engine = String(body.engine || 'worker').toLowerCase();
      const targetMode = String(body.targetMode || 'multi_failover').toLowerCase();
      const offset = Math.max(0, Number.parseInt(String(body.offset || '0'), 10) || 0);
      const totalHostCount = Math.max(1, Number.parseInt(String(body.totalHostCount || body.totalHosts || '0'), 10) || 0);
      const requestedNodeCount = autoNodeCount(totalHostCount || (Array.isArray(body.hostnames) ? body.hostnames.length : 1), targetMode);

      if (!accountId) throw new Error('Account ID kosong. Pilih account dulu.');
      if (!zoneId || !zoneName) throw new Error('Domain wajib dipilih.');
      if (mode !== 'attach' && mode !== 'check') throw new Error('Mode wildcard hanya CONNECT dan CEK SSL. Tidak ada finalize/cleanup.');

      const baseHost = (!prefix || prefix === '*' || prefix === '@')
        ? zoneName
        : (prefix === zoneName || prefix.endsWith('.' + zoneName) ? prefix : `${prefix}.${zoneName}`);
      const workerName = sanitizeWorkerName(`wc-${baseHost}`);
      const targetHost = baseHost;
      const seen = new Set();
      const hostnames = [];

      const inSelectedZone = (h) => {
        h = cleanHost(h);
        const bare = h.startsWith('*.') ? h.slice(2) : h;
        return bare === zoneName || bare.endsWith('.' + zoneName);
      };
      const pushHost = (h) => {
        h = cleanHost(h);
        if (validHost(h) && inSelectedZone(h) && !seen.has(h)) {
          seen.add(h);
          hostnames.push(h);
        }
      };
      const suffixToHostname = (suffix) => {
        suffix = cleanHost(suffix);
        if (!suffix || suffix === '*') return baseHost;
        if (suffix.startsWith('*.')) {
          const bare = cleanHost(suffix.slice(2));
          if (!bare) return baseHost;
          return (bare === zoneName || bare.endsWith('.' + zoneName)) ? bare : `${bare}.${baseHost}`;
        }
        return (suffix === zoneName || suffix.endsWith('.' + zoneName)) ? suffix : `${suffix}.${baseHost}`;
      };

      pushHost(baseHost);
      const inputHosts = Array.isArray(body.hostnames) ? body.hostnames : [];
      if (inputHosts.length) {
        for (const h of inputHosts) pushHost(h);
      } else {
        String(body.suffixes || '').split(/[\n,;]+/).map(v => v.replace(/#.*/, '').trim()).filter(Boolean).forEach(s => pushHost(suffixToHostname(s)));
      }
      if (!hostnames.length) throw new Error('Tidak ada hostname valid.');

      const removeConflictingDns = async (name) => {
        try {
          const records = await client.listDnsRecords(zoneId, name);
          const rows = Array.isArray(records.result) ? records.result : [];
          for (const r of rows) {
            if (['A', 'AAAA', 'CNAME'].includes(String(r.type || '').toUpperCase())) {
              await client.deleteDnsRecord(zoneId, r.id);
            }
          }
        } catch (_) {}
      };

      const listDnsSummary = async (name) => {
        try {
          const records = await client.listDnsRecords(zoneId, name);
          return (Array.isArray(records.result) ? records.result : [])
            .filter(r => ['A', 'AAAA', 'CNAME'].includes(String(r.type || '').toUpperCase()))
            .map(r => ({ type: String(r.type || '').toUpperCase(), name: r.name || name, content: r.content || '', proxied: !!r.proxied }));
        } catch (_) {
          return [];
        }
      };

      const parseHostList = (value) => {
        const out = [];
        const seenTargets = new Set();
        const raw = Array.isArray(value) ? value.join('\n') : String(value || '');
        raw.split(/[\n,;]+/).map(v => v.replace(/#.*/, '').trim()).filter(Boolean).forEach(v => {
          const h = cleanHost(v);
          if (validBaseHost(h) && !seenTargets.has(h)) {
            seenTargets.add(h);
            out.push(h);
          }
        });
        return out;
      };

      const failoverHosts = parseHostList(body.workerUrls || body.targets || body.targetHosts || body.upstreams);
      const multiEnabled = ['multi', 'balance', 'multi_balance', 'multi_failover', 'shard', 'sharding'].includes(targetMode);
      let workerNodes = [];
      if (!multiEnabled) workerNodes = [workerName];
      if (multiEnabled) {
        for (let i = 1; i <= requestedNodeCount; i++) {
          workerNodes.push(sanitizeWorkerName(`${workerName}-n${String(i).padStart(2, '0')}`));
        }
      }
      if (!workerNodes.length) workerNodes = [workerName];

      const makeAutoWorkerScript = (nodeName, nodeIndex) => `// ============================================
// WORKER V5 - MULTI NODE + FAILOVER
// ============================================

const NODE_NAME = ${JSON.stringify(nodeName)};
const WORKER_URLS = ${JSON.stringify(failoverHosts, null, 2)};

function shuffle(list) {
  return [...list].sort(() => Math.random() - 0.5);
}

function cleanHeaders(request) {
  const headers = new Headers(request.headers);
  headers.delete("host");
  headers.delete("cf-connecting-ip");
  headers.delete("cf-ipcountry");
  headers.delete("cf-ray");
  headers.delete("cf-visitor");
  headers.delete("x-forwarded-proto");
  headers.delete("x-real-ip");
  headers.set("x-wc-node", NODE_NAME);
  return headers;
}

export default {
  async fetch(request, env, ctx) {
    if (!WORKER_URLS.length) {
      const u = new URL(request.url);
      return new Response("Wildcard Manager node aktif: " + NODE_NAME + "\\nHostname: " + u.hostname + "\\nIsi Target Failover / WORKER_URLS agar request diteruskan ke target.", {
        status: 200,
        headers: { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store" }
      });
    }

    const method = request.method.toUpperCase();
    const bodyBuffer = method !== "GET" && method !== "HEAD" ? await request.arrayBuffer() : null;
    const shuffled = shuffle(WORKER_URLS);

    for (const host of shuffled) {
      try {
        const targetUrl = new URL(request.url);
        targetUrl.hostname = host;
        targetUrl.protocol = "https:";

        const proxyRequest = new Request(targetUrl.toString(), {
          method: request.method,
          headers: cleanHeaders(request),
          body: bodyBuffer ? bodyBuffer.slice(0) : null,
          redirect: "manual"
        });

        const response = await fetch(proxyRequest);
        if (response.status !== 429 && response.status < 500) return response;
        console.log(NODE_NAME + " -> " + host + " limit/error (" + response.status + "), skip ke cadangan...");
      } catch (e) {
        console.log(NODE_NAME + " -> " + host + " timeout/koneksi putus: " + e.message);
        continue;
      }
    }

    return new Response("Semua target sedang tidak bisa diakses. Node: " + NODE_NAME, {
      status: 503,
      headers: { "Content-Type": "text/plain; charset=utf-8", "Retry-After": "30" }
    });
  }
};`;

      let workerSubdomain = '';
      try { workerSubdomain = await client.getOrCreateSubdomain(accountId); }
      catch (_) { workerSubdomain = ''; }
      const workerDnsTargets = Object.fromEntries(workerNodes.map(n => [n, workerSubdomain ? `${n}.${workerSubdomain}.workers.dev` : `${n}.workers.dev`]));

      if (engine === 'worker' && mode === 'attach' && body.deployWorkers !== false) {
        for (let i = 0; i < workerNodes.length; i++) {
          const nodeName = workerNodes[i];
          await client.createWorker(accountId, nodeName, makeAutoWorkerScript(nodeName, i));
        }
      }

      const results = [];
      let pagesDomainsCache = null;

      for (let i = 0; i < hostnames.slice(0, 10).length; i++) {
        const hostname = hostnames[i];
        const assignedIndex = (offset + i) % workerNodes.length;
        const assignedWorkerName = workerNodes[assignedIndex];
        const row = {
          hostname,
          mode,
          targetMode,
          success: false,
          status: 'unknown',
          sslActive: false,
          workerName: assignedWorkerName,
          assignedWorker: assignedWorkerName,
          assignedWorkerUrl: workerDnsTargets[assignedWorkerName],
          targetHost,
          workerUrls: failoverHosts,
          workerNodes,
          proxied,
          actions: []
        };
        try {
          if (mode === 'attach') {
            await removeConflictingDns(hostname);
            
            if (engine === 'pages') {
              let pagesProjectName = body.pagesProjectName || sanitizeWorkerName(`ssl-${baseHost}`);
              
              if (offset === 0 && i === 0 && body.deployWorkers !== false) {
                try { await client.createPagesProject(accountId, pagesProjectName); row.actions.push('project_created'); } catch (e) {}
                try {
                  let pagesScriptToDeploy = body.pagesCustomScript;
                  if (!pagesScriptToDeploy) throw new Error("Script deploy tidak ditemukan.");
                  await client.deployPagesProject(accountId, pagesProjectName, pagesScriptToDeploy);
                  row.actions.push('proxy_deployed');
                } catch (e) {
                  row.actions.push('proxy_deploy_failed: ' + e.message);
                }
              }
              try {
                await client.addPagesDomain(accountId, pagesProjectName, hostname);
                row.actions.push('attached_to_pages');
              } catch (e) {
                if (/already|exist|duplicate/i.test(e.message)) row.actions.push('pages_domain_exists');
                else throw e;
              }
              try {
                await client.createDnsRecord(zoneId, { type: 'CNAME', name: hostname, content: `${pagesProjectName}.pages.dev`, ttl: 1, proxied });
                row.actions.push('cname_created');
              } catch (e) {
                if (/already|exist|conflict/i.test(e.message)) row.actions.push('cname_exists');
                else throw e;
              }
              try {
                await client.triggerPagesVerification(accountId, pagesProjectName, hostname);
                row.actions.push('ssl_verification_triggered');
              } catch (_) {}
              
              row.status = 'pending';
              row.sslActive = false;
              row.success = true;
              row.projectName = pagesProjectName;
              
            } else {
              try {
                await client.registerCustomDomain(accountId, assignedWorkerName, hostname, zoneId);
                row.actions.push('attached_to_' + assignedWorkerName);
              } catch (e) {
                const msg = e.message || String(e);
                if (/already|exist|duplicate|conflict/i.test(msg)) row.actions.push('already_exists_or_conflict');
                else throw e;
              }
              const d = await client.findWorkerDomain(accountId, hostname, assignedWorkerName);
              row.domainId = d?.id || null;
              row.status = statusFromDomain(d);
              row.sslActive = row.status === 'active';
              row.dnsRecords = await listDnsSummary(hostname);
              row.dnsRecordCount = row.dnsRecords.length;
              row.actions.push('kept_worker_custom_domain');
              row.actions.push('kept_dns_records');
              if (multiEnabled) row.actions.push('balanced_suffix_to_worker_node');
              if (failoverHosts.length) row.actions.push('failover_targets_ready');
              else row.actions.push('status_worker_only_no_targets');
              row.success = true;
            }
          } else {
            if (engine === 'pages') {
              const pagesProjectName = body.pagesProjectName || sanitizeWorkerName(`ssl-${baseHost}`);
              if (!pagesDomainsCache) {
                 try {
                   const pdReq = await client.listPagesDomains(accountId, pagesProjectName);
                   pagesDomainsCache = Array.isArray(pdReq.result) ? pdReq.result : [];
                 } catch (e) {
                   pagesDomainsCache = [];
                 }
              }
              const pDomain = pagesDomainsCache.find(d => String(d.name).toLowerCase() === hostname.toLowerCase());
              row.status = pDomain ? statusFromDomain(pDomain) : 'not_found';
              if (row.status !== 'active') {
                try {
                  const probe = await fetch(`https://${hostname}/`, { method: 'HEAD', redirect: 'manual', cf: { cacheTtl: 0 } });
                  row.httpsProbe = { ok: true, status: probe.status };
                  if (probe.status > 0 && probe.status < 600) row.status = 'active';
                } catch (e) {
                  row.httpsProbe = { ok: false, message: e.message || String(e) };
                }
              }
              row.sslActive = row.status === 'active';
              row.success = true;
            } else {
              const d = await client.findWorkerDomain(accountId, hostname, assignedWorkerName);
              row.domainId = d?.id || null;
              row.status = statusFromDomain(d);
              if (row.status !== 'active') {
                try {
                  const probe = await fetch(`https://${hostname}/`, { method: 'HEAD', redirect: 'manual', cf: { cacheTtl: 0 } });
                  row.httpsProbe = { ok: true, status: probe.status };
                  if (probe.status > 0 && probe.status < 600) row.status = 'active';
                } catch (e) {
                  row.httpsProbe = { ok: false, message: e.message || String(e) };
                }
              }
              row.sslActive = row.status === 'active';
              row.dnsRecords = await listDnsSummary(hostname);
              row.dnsRecordCount = row.dnsRecords.length;
              if (row.sslActive && row.dnsRecordCount > 0) row.actions.push('ssl_active_dns_record_present');
              else if (row.sslActive) row.actions.push('ssl_active_waiting_dns_record_visible');
              else if (row.dnsRecordCount > 0) row.actions.push('dns_record_present_ssl_pending');
              else row.actions.push('waiting_ssl_and_dns_record');
              row.actions.push('nothing_deleted');
              row.success = true;
            }
          }
        } catch (e) {
          row.success = false;
          row.error = e.message || String(e);
        }
        results.push(row);
      }

      return jsonResponse({ success: true, baseHost, targetHost, workerName, workerNodes, workerDnsTargets, workerUrls: failoverHosts, targetMode, results });
    }

    return jsonResponse({ success: false, message: 'Not found' }, 404);
  } catch (error) {
    return jsonResponse({ success: false, message: error.message || String(error) }, 400);
  }
}

function renderHTML() {
  return `<!DOCTYPE html>
<html lang="id">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>CF Manager Pro v1.6</title>
  <script src="https://cdn.tailwindcss.com"></script>
  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
  <style>
    ::-webkit-scrollbar { width: 5px; }
    ::-webkit-scrollbar-thumb { background: #334155; border-radius: 10px; }
    .active-tab { border-bottom: 2px solid #f97316; color: white; }
    .tab-content { display: none; }
    .tab-content.active { display: block; }
    .glass-card { background: rgba(22, 27, 34, 0.8); backdrop-filter: blur(10px); border: 1px solid rgba(255, 255, 255, 0.05); }
    @keyframes fadeIn { from { opacity: 0; } to { opacity: 1; } }
    .fade-in { animation: fadeIn 0.3s ease-out; }
    .hidden { display: none !important; }
    #accountModal.hidden { display: none !important; pointer-events: none !important; }
    button, select, input, textarea, label { pointer-events: auto; }
  </style>
</head>
<body class="bg-[#0b0e14] text-slate-300 min-h-screen font-sans">
  <div class="max-w-7xl mx-auto p-4 md:p-8">
    <div class="flex flex-col md:flex-row justify-between items-center mb-8 gap-4 border-b border-slate-800 pb-6">
      <div>
        <h1 class="text-3xl font-black text-white italic tracking-tighter uppercase"><span class="text-orange-500">CF</span> <span class="text-blue-500">Manager Pro</span></h1>
        <p class="text-slate-500 text-[10px] uppercase tracking-[0.3em] mt-1 font-bold">Pages + Domain + Multi Worker SSL Suite</p>
      </div>
      <div class="flex gap-3">
        <button id="btnOpenAccountModal" type="button" class="bg-blue-600 hover:bg-blue-500 px-4 py-2 rounded-xl text-xs font-bold flex items-center gap-2 transition-all">
          <i class="fa-solid fa-users"></i> KELOLA AKUN (<span id="accCount">0</span>)
        </button>
      </div>
    </div>

    <div class="flex bg-[#161b22] rounded-t-2xl border-x border-t border-slate-800 overflow-x-auto no-scrollbar">
      <button id="btn-domainmanager" type="button" class="px-8 py-4 text-xs font-black uppercase tracking-widest active-tab transition-all">Domain Manager</button>
      <button id="btn-pagesmanager" type="button" class="px-8 py-4 text-xs font-black uppercase tracking-widest text-slate-500 hover:text-white transition-all">Pages Manager</button>
      <button id="btn-wildcardssl" type="button" class="px-8 py-4 text-xs font-black uppercase tracking-widest text-slate-500 hover:text-white transition-all">Wildcard SSL</button>
    </div>

    <div class="bg-[#161b22] border border-slate-800 rounded-b-2xl p-6 shadow-2xl">
      <div id="tab-domainmanager" class="tab-content active fade-in space-y-6">
        <div class="flex flex-col md:flex-row gap-4 items-center justify-between">
          <div class="flex gap-2 w-full md:w-auto">
            <select id="dmAccount" class="bg-[#0d1117] border border-slate-700 rounded-xl px-4 py-2 text-sm text-white outline-none focus:border-blue-500 w-full md:w-64">
              <option value="">Select Account</option>
            </select>
            <button id="btnDomainRefresh" type="button" class="bg-slate-800 hover:bg-slate-700 p-2 rounded-xl text-white transition-all" title="Refresh Domain">
              <i class="fa-solid fa-sync"></i>
            </button>
          </div>
          <div class="relative w-full md:w-64">
            <i class="fa-solid fa-search absolute left-4 top-1/2 -translate-y-1/2 text-slate-500 text-xs"></i>
            <input id="dmSearch" type="text" placeholder="Search domain..." class="w-full bg-[#0d1117] border border-slate-700 rounded-xl pl-10 pr-4 py-2 text-sm outline-none focus:border-blue-500">
          </div>
        </div>

        <div class="glass-card p-2 rounded-3xl border border-slate-800 space-y-6">
          <div class="flex flex-col md:flex-row gap-4 bg-[#0d1117] p-2 rounded-2xl border border-slate-800">
            <div class="relative flex-1 flex items-center bg-black/40 rounded-xl px-4 py-2 border border-slate-700/50">
              <i class="fa-solid fa-globe text-slate-500 mr-3"></i>
              <input type="text" id="dmAddDomain" placeholder="Masukkan domain (contoh: webku.com)" class="w-full bg-transparent text-sm text-white outline-none placeholder-slate-500 font-medium">
            </div>
            <button id="btnDomainAdd" type="button" class="mx-auto w-auto bg-gradient-to-r from-orange-600 to-red-600 hover:from-orange-500 hover:to-red-500 text-white font-black py-2 px-6 rounded-2xl shadow-xl transition-all active:scale-95 flex items-center justify-center gap-3">
              <i class="fa-solid fa-plus"></i> Tambah Domain
            </button>
          </div>

          <div class="flex justify-between items-center border-b border-slate-800/50 pb-4 px-2">
            <div>
              <h3 class="text-base sm:text-lg font-bold text-white flex items-center gap-2 sm:gap-3">
                <i class="fa-solid fa-server text-white text-sm sm:text-base"></i> Domain Cloudflare
              </h3>
              <p class="text-[10px] text-slate-500 mt-1">Kelola root domain, name server, dan DNS record langsung dari akun yang dipilih.</p>
            </div>
            <button id="btnDomainRefresh2" type="button" class="bg-[#0d1117] hover:bg-slate-800 text-white px-4 py-2 rounded-xl text-xs font-bold transition-all border border-slate-700 flex items-center gap-2">
              <i class="fa-solid fa-sync"></i> Refresh
            </button>
          </div>

          <div id="dmDomainList" class="space-y-4 max-h-[600px] overflow-y-auto pr-2 px-1">
            <div class="text-center py-20 text-slate-600">Pilih account lalu klik Refresh untuk memuat domain.</div>
          </div>
        </div>

        <div id="dmLog" class="bg-black/80 border border-slate-800 rounded-2xl p-3 h-32 overflow-y-auto text-xs font-mono text-slate-300">
          <div class="text-slate-500">// Log Domain Manager...</div>
        </div>
      </div>

      <div id="dmDnsModal" class="fixed inset-0 bg-[#070b14]/90 backdrop-blur-sm z-50 flex items-center justify-center p-4 hidden">
        <div class="bg-[#111722] border border-slate-800 rounded-2xl w-full max-w-5xl h-[85vh] flex flex-col overflow-hidden shadow-2xl relative">
          <div class="p-6 border-b border-slate-800 flex justify-between items-center bg-[#0d1117]">
            <div>
              <h3 class="text-2xl font-bold text-white mb-1" id="dmSelectedTitle">DNS records for domain.com</h3>
              <p class="text-sm text-slate-400">Manage how the Internet finds your web content, verifies services, and routes traffic.</p>
            </div>
            <button id="btnDnsClose" type="button" class="text-slate-500 hover:text-white transition-all w-8 h-8 flex items-center justify-center rounded-full hover:bg-slate-800" aria-label="Close DNS records">
              <i class="fa-solid fa-xmark text-xl"></i>
            </button>
          </div>
          <div class="flex-1 overflow-y-auto p-6 space-y-6">
            <div class="flex flex-wrap gap-4 items-center justify-between">
              <div class="relative flex-1 min-w-[300px]">
                <div class="absolute inset-y-0 left-0 pl-3 flex items-center pointer-events-none"><i class="fa-solid fa-magnifying-glass text-slate-500"></i></div>
                <input type="text" id="dmDnsSearch" placeholder="Search DNS Records" class="w-full pl-10 pr-4 py-2.5 bg-[#0d1117] border border-slate-800 rounded-lg text-sm text-white focus:outline-none focus:border-blue-500 transition-colors">
              </div>
              <div class="flex gap-3">
                <button id="btnDnsAddOpen" type="button" class="bg-blue-600 hover:bg-blue-700 text-white px-4 py-2.5 rounded-lg text-sm font-bold transition-all flex items-center gap-2"><i class="fa-solid fa-plus"></i> Add record</button>
                <button id="btnDnsBulkOpen" type="button" class="bg-indigo-600 hover:bg-indigo-700 text-white px-4 py-2.5 rounded-lg text-sm font-bold transition-all flex items-center gap-2"><i class="fa-solid fa-layer-group"></i> Bulk DNS</button>
              </div>
            </div>
            <div id="dmDnsAddForm" class="bg-[#0b0e14] border border-slate-700 rounded-xl p-5 hidden">
              <h4 class="text-white font-bold mb-4">Add record</h4>
              <p class="text-slate-400 text-xs mb-4">Select record type and enter necessary information.</p>
              <div class="grid grid-cols-1 md:grid-cols-12 gap-4 items-start">
                <div class="md:col-span-2">
                  <label class="block text-xs font-bold text-slate-400 mb-1.5 uppercase">Type</label>
                  <select id="dmDnsType" class="w-full bg-[#111722] border border-slate-700 rounded-lg px-3 py-2 text-white text-sm focus:outline-none focus:border-blue-500">
                    <option value="A">A</option><option value="AAAA">AAAA</option><option value="CNAME">CNAME</option><option value="TXT">TXT</option><option value="MX">MX</option><option value="SRV">SRV</option><option value="NS">NS</option>
                  </select>
                </div>
                <div class="md:col-span-3">
                  <label class="block text-xs font-bold text-slate-400 mb-1.5 uppercase">Name</label>
                  <input type="text" id="dmDnsName" placeholder="Use @ for root" class="w-full bg-[#111722] border border-slate-700 rounded-lg px-3 py-2 text-white text-sm focus:outline-none focus:border-blue-500">
                </div>
                <div class="md:col-span-4">
                  <label class="block text-xs font-bold text-slate-400 mb-1.5 uppercase">Target / Content</label>
                  <input type="text" id="dmDnsContent" placeholder="IPv4 address or domain" class="w-full bg-[#111722] border border-slate-700 rounded-lg px-3 py-2 text-white text-sm focus:outline-none focus:border-blue-500">
                </div>
                <div class="md:col-span-2 flex flex-col justify-center h-full pt-6">
                  <label class="flex items-center gap-2 cursor-pointer">
                    <input type="checkbox" id="dmDnsProxied" class="hidden" checked>
                    <div class="w-10 h-5 bg-orange-500 rounded-full relative transition-colors" id="dmProxyToggleBg"><div class="absolute right-1 top-1 w-3 h-3 bg-white rounded-full transition-transform" id="dmProxyToggleDot"></div></div>
                    <span class="text-xs text-slate-300 font-medium flex items-center gap-1"><i class="fa-brands fa-cloudflare text-orange-500 text-lg" id="dmProxyIcon"></i> <span id="dmProxyLabel">Proxied</span></span>
                  </label>
                </div>
                <div class="md:col-span-1">
                  <label class="block text-xs font-bold text-slate-400 mb-1.5 uppercase">TTL</label>
                  <select id="dmDnsTtl" class="w-full bg-[#111722] border border-slate-700 rounded-lg px-2 py-2 text-white text-sm focus:outline-none focus:border-blue-500">
                    <option value="1">Auto</option><option value="120">2 min</option><option value="300">5 min</option><option value="3600">1 hr</option>
                  </select>
                </div>
              </div>
              <div class="mt-5 flex justify-end gap-3 pt-4 border-t border-slate-800">
                <button id="btnDnsCancel" type="button" class="px-4 py-2 text-sm text-slate-400 hover:text-white transition-colors">Cancel</button>
                <button id="btnDnsAdd" type="button" class="bg-blue-600 hover:bg-blue-700 text-white px-5 py-2 rounded-lg text-sm font-bold transition-all">Save</button>
              </div>
            </div>
            <div id="dmDnsBulkForm" class="bg-[#0b0e14] border border-indigo-900/50 rounded-xl p-5 hidden">
              <div class="flex items-start justify-between gap-3 mb-4">
                <div>
                  <h4 class="text-white font-bold flex items-center gap-2"><i class="fa-solid fa-layer-group text-indigo-400"></i> Bulk DNS Records</h4>
                  <p class="text-slate-400 text-xs mt-1">Tambah banyak DNS record sekaligus ke domain yang sedang dibuka.</p>
                </div>
                <button id="btnDnsBulkCancelTop" type="button" class="text-slate-500 hover:text-white transition-all"><i class="fa-solid fa-xmark"></i></button>
              </div>
              <div class="grid grid-cols-1 md:grid-cols-12 gap-4 items-start">
                <div class="md:col-span-2">
                  <label class="block text-xs font-bold text-slate-400 mb-1.5 uppercase">Type</label>
                  <select id="dmBulkDnsType" class="w-full bg-[#111722] border border-slate-700 rounded-lg px-3 py-2 text-white text-sm focus:outline-none focus:border-indigo-500">
                    <option value="A">A</option><option value="AAAA">AAAA</option><option value="CNAME">CNAME</option><option value="TXT">TXT</option><option value="MX">MX</option><option value="NS">NS</option>
                  </select>
                </div>
                <div class="md:col-span-2">
                  <label class="block text-xs font-bold text-slate-400 mb-1.5 uppercase">TTL</label>
                  <select id="dmBulkDnsTtl" class="w-full bg-[#111722] border border-slate-700 rounded-lg px-3 py-2 text-white text-sm focus:outline-none focus:border-indigo-500">
                    <option value="1">Auto</option><option value="120">2 min</option><option value="300">5 min</option><option value="3600">1 hr</option>
                  </select>
                </div>
                <div class="md:col-span-2" id="dmBulkDnsPriorityWrap">
                  <label class="block text-xs font-bold text-slate-400 mb-1.5 uppercase">Priority</label>
                  <input id="dmBulkDnsPriority" type="number" value="10" min="0" class="w-full bg-[#111722] border border-slate-700 rounded-lg px-3 py-2 text-white text-sm focus:outline-none focus:border-indigo-500">
                </div>
                <div class="md:col-span-2 pt-7" id="dmBulkDnsProxyWrap">
                  <label class="flex items-center gap-2 cursor-pointer text-xs text-slate-300 font-bold">
                    <input type="checkbox" id="dmBulkDnsProxied" class="accent-orange-500" checked>
                    <span><i class="fa-brands fa-cloudflare text-orange-500"></i> Proxied</span>
                  </label>
                </div>
                <div class="md:col-span-2 pt-7">
                  <label class="flex items-center gap-2 cursor-pointer text-xs text-slate-300 font-bold">
                    <input type="checkbox" id="dmBulkDnsSingleTarget" class="accent-blue-500">
                    <span>Satu target</span>
                  </label>
                </div>
                <div class="md:col-span-2 pt-7">
                  <label class="flex items-center gap-2 cursor-pointer text-xs text-red-300 font-bold">
                    <input type="checkbox" id="dmBulkDnsReplace" class="accent-red-500">
                    <span>Replace</span>
                  </label>
                </div>
              </div>
              <div class="mt-4 grid grid-cols-1 md:grid-cols-12 gap-4 items-start">
                <div class="md:col-span-4">
                  <label class="block text-xs font-bold text-slate-400 mb-1.5 uppercase">Prefix / Base</label>
                  <input id="dmBulkDnsPrefix" type="text" placeholder="Kosong = root, contoh: app" class="w-full bg-[#111722] border border-slate-700 rounded-lg px-3 py-2 text-white text-sm focus:outline-none focus:border-indigo-500">
                  <p class="text-[10px] text-slate-500 mt-1">List akan digabung seperti Wildcard SSL.</p>
                </div>
                <div class="md:col-span-4">
                  <label class="block text-xs font-bold text-slate-400 mb-1.5 uppercase">Upload TXT</label>
                  <input id="dmBulkDnsFile" type="file" accept=".txt,text/plain" class="block w-full text-xs text-slate-300 file:mr-3 file:rounded-lg file:border-0 file:bg-slate-800 file:px-3 file:py-2 file:text-xs file:font-bold file:text-white hover:file:bg-slate-700">
                  <p class="text-[10px] text-slate-500 mt-1">Isi file otomatis masuk ke Bulk List.</p>
                </div>
                <div class="md:col-span-4">
                  <label class="block text-xs font-bold text-slate-400 mb-1.5 uppercase">URL Raw TXT</label>
                  <div class="flex gap-2">
                    <input id="dmBulkDnsRawUrl" type="url" placeholder="https://.../list.txt" class="min-w-0 flex-1 bg-[#111722] border border-slate-700 rounded-lg px-3 py-2 text-white text-sm focus:outline-none focus:border-indigo-500">
                    <button id="btnBulkDnsLoadUrl" type="button" class="bg-slate-800 hover:bg-slate-700 text-white px-3 py-2 rounded-lg text-xs font-bold transition-all">Load</button>
                  </div>
                  <p class="text-[10px] text-slate-500 mt-1">Ambil list dari raw URL tanpa buka manual.</p>
                </div>
              </div>
              <div id="dmBulkDnsTargetWrap" class="mt-4 hidden">
                <label class="block text-xs font-bold text-slate-400 mb-1.5 uppercase">Target untuk semua baris</label>
                <input id="dmBulkDnsTarget" type="text" placeholder="IP / CNAME target / TXT value" class="w-full bg-[#111722] border border-slate-700 rounded-lg px-3 py-2 text-white text-sm focus:outline-none focus:border-indigo-500">
              </div>
              <div class="mt-4">
                <div class="flex justify-between items-center mb-1.5">
                  <label class="block text-xs font-bold text-slate-400 uppercase">Bulk List</label>
                  <span id="dmBulkDnsCount" class="text-[10px] text-blue-400 font-black uppercase">0 record</span>
                </div>
                <textarea id="dmBulkDnsList" rows="6" placeholder="app,1.2.3.4&#10;api,example.pages.dev&#10;cdn,target.example.com" class="w-full bg-[#111722] border border-slate-700 rounded-lg px-3 py-3 text-white text-xs font-mono focus:outline-none focus:border-indigo-500 resize-y"></textarea>
                <p id="dmBulkDnsHint" class="text-[10px] text-slate-500 italic mt-1">Format default: name,target per baris. Kolom Prefix akan digabung ke setiap name seperti fitur Wildcard SSL.</p>
              </div>
              <div id="dmBulkDnsPreview" class="hidden mt-4 bg-black/30 border border-slate-800 rounded-xl p-3 max-h-[120px] overflow-y-auto text-[10px] text-slate-400 font-mono"></div>
              <div id="dmBulkDnsProgress" class="hidden mt-4 bg-black/50 border border-slate-800 rounded-xl p-3 max-h-[180px] overflow-y-auto text-[10px] font-mono space-y-1"></div>
              <div class="mt-5 flex justify-end gap-3 pt-4 border-t border-slate-800">
                <button id="btnDnsBulkCancel" type="button" class="px-4 py-2 text-sm text-slate-400 hover:text-white transition-colors">Cancel</button>
                <button id="btnDnsBulkProcess" type="button" class="bg-indigo-600 hover:bg-indigo-700 text-white px-5 py-2 rounded-lg text-sm font-bold transition-all"><i class="fa-solid fa-layer-group mr-1"></i> MULAI BULK</button>
              </div>
            </div>
            <div class="bg-[#0b0e14] border border-slate-800 rounded-xl overflow-hidden">
              <div class="px-4 py-3 border-b border-slate-800 bg-[#0d1117] flex justify-between items-center flex-wrap gap-3">
                <span class="text-sm text-slate-400 font-bold" id="dmDnsCount">0 records</span>
                <div class="flex gap-2">
                  <button id="btnDnsTableCopy" type="button" class="bg-slate-800 hover:bg-slate-700 text-[10px] sm:text-xs font-bold text-slate-300 border border-slate-600 px-3 py-1.5 rounded-lg transition-all flex gap-1.5 items-center"><i class="fa-solid fa-copy"></i> Salin Domain</button>
                  <button id="btnDnsTableAutoFill" type="button" class="bg-indigo-600 hover:bg-indigo-500 text-[10px] sm:text-xs font-bold text-white px-3 py-1.5 rounded-lg transition-all flex gap-1.5 items-center"><i class="fa-solid fa-bolt"></i> Auto Fill Pages</button>
                </div>
              </div>
              <div class="overflow-x-auto">
                <table class="w-full text-left text-sm text-slate-300">
                  <thead class="text-xs text-slate-400 uppercase bg-[#111722] border-b border-slate-800">
                    <tr><th scope="col" class="px-4 py-3 font-bold">Type</th><th scope="col" class="px-4 py-3 font-bold">Name</th><th scope="col" class="px-4 py-3 font-bold">Content</th><th scope="col" class="px-4 py-3 font-bold">Proxy status</th><th scope="col" class="px-4 py-3 font-bold">TTL</th><th scope="col" class="px-4 py-3 font-bold text-right">Actions</th></tr>
                  </thead>
                  <tbody id="dmDnsList" class="divide-y divide-slate-800/50"><tr><td colspan="6" class="px-4 py-10 text-center text-slate-500">Loading DNS records...</td></tr></tbody>
                </table>
              </div>
            </div>
          </div>
        </div>
      </div>
      <!-- Tab Pages Manager -->
      <div id="tab-pagesmanager" class="tab-content fade-in space-y-6">
        <div class="rounded-3xl border border-indigo-500/20 bg-gradient-to-br from-indigo-500/10 via-[#0d1117] to-[#0d1117] p-5">
          <div class="flex flex-col md:flex-row md:items-center md:justify-between gap-4">
            <div>
              <h2 class="text-xl font-black text-white"><i class="fa-solid fa-layer-group text-indigo-400 mr-2"></i>Pages Manager</h2>
              <p class="text-xs text-slate-400 mt-1">List project dan daftar custom domain di Pages. Fitur edit script via menu Wildcard SSL.</p>
            </div>
            <button id="btnPagesLoad" type="button" class="bg-indigo-600 hover:bg-indigo-500 text-white px-5 py-3 rounded-2xl text-xs font-black uppercase"><i class="fa-solid fa-rotate mr-2"></i> Muat Project</button>
          </div>
        </div>
        <div class="grid grid-cols-1 lg:grid-cols-2 gap-6">
          <div class="bg-[#161b22] border border-slate-800 rounded-3xl p-5 space-y-4">
            <div><label class="text-[10px] font-black text-slate-500 uppercase">Account</label><select id="pmAccount" class="w-full mt-1 bg-[#0d1117] border border-slate-700 rounded-2xl px-4 py-3 text-sm text-white outline-none"><option value="">Select Account</option></select></div>
            <div><label class="text-[10px] font-black text-slate-500 uppercase">Pages Project</label><select id="pmProject" class="w-full mt-1 bg-[#0d1117] border border-indigo-500/30 rounded-2xl px-4 py-3 text-sm text-white outline-none"><option value="">Klik Muat Project</option></select></div>
            <div>
              <div class="flex items-center justify-between gap-2 mt-1"><label class="text-[10px] font-black text-slate-500 uppercase">Bulk Pages Custom Domains</label><button id="btnPagesBulkPaste" type="button" class="bg-indigo-900/50 hover:bg-indigo-800 text-[10px] text-indigo-200 px-2 py-1 rounded transition-all border border-indigo-500/30 font-bold"><i class="fa-solid fa-clipboard"></i> Paste</button></div>
              <textarea id="pmDomains" rows="7" placeholder="app.domain.com" class="w-full mt-1 bg-[#0d1117] border border-indigo-500/30 rounded-2xl px-4 py-3 text-xs font-mono text-white outline-none"></textarea>
            </div>
            <button id="btnPagesBulkAdd" type="button" class="w-full bg-indigo-600 hover:bg-indigo-500 text-white px-5 py-4 rounded-2xl text-xs font-black uppercase"><i class="fa-solid fa-cloud-arrow-up mr-2"></i> Bulk Add Pages Domain</button>
          </div>
          <div class="bg-[#161b22] border border-slate-800 rounded-3xl p-5 space-y-4">
            <div class="flex items-center justify-between gap-2"><div><h3 class="text-lg font-black text-white">Pages Domain Inventory</h3></div><button id="btnPagesRefreshDomains" type="button" class="bg-slate-800 hover:bg-slate-700 text-white px-4 py-2 rounded-xl text-xs font-bold">Refresh</button></div>
            <div id="pmDomainList" class="space-y-3 max-h-[520px] overflow-y-auto pr-2"><div class="text-center py-20 text-slate-600">Pilih account + project lalu klik Refresh.</div></div>
          </div>
        </div>
        <div id="pmLog" class="bg-black/80 border border-slate-800 rounded-2xl p-3 h-32 overflow-y-auto text-xs font-mono text-slate-300"></div>
      </div>

      <!-- Tab Wildcard SSL -->
      <div id="tab-wildcardssl" class="tab-content fade-in space-y-6">
        <div class="rounded-3xl border border-orange-500/20 bg-gradient-to-br from-orange-500/10 via-[#0d1117] to-[#0d1117] p-5">
          <div class="flex flex-col md:flex-row md:items-center md:justify-between gap-4">
            <div>
              <h2 class="text-xl font-black text-white"><i class="fa-solid fa-cloud-bolt text-orange-400 mr-2"></i>Wildcard SSL</h2>
              <p class="text-xs text-slate-400 mt-1">Pilih root domain + prefix → pilih engine (Pages / Worker) → deploy custom proxy → cek SSL sampai active.</p>
            </div>
            <button id="btnLoadResources" type="button" class="bg-orange-600 hover:bg-orange-500 text-white px-5 py-3 rounded-2xl text-xs font-black uppercase"><i class="fa-solid fa-rotate mr-2"></i> Muat Domain</button>
          </div>
        </div>

        <div class="grid grid-cols-1 lg:grid-cols-2 gap-6">
          <div class="bg-[#161b22] border border-slate-800 rounded-3xl p-5 space-y-4">
            <div><label class="text-[10px] font-black text-slate-500 uppercase">Account</label><select id="wcAccount" class="w-full mt-1 bg-[#0d1117] border border-slate-700 rounded-2xl px-4 py-3 text-sm text-white outline-none"></select></div>
            <div>
              <label class="text-[10px] font-black text-slate-500 uppercase text-fuchsia-400">Platform Engine</label>
              <select id="wcEngine" class="w-full mt-1 bg-[#0d1117] border border-fuchsia-500/40 rounded-2xl px-4 py-3 text-sm text-white outline-none font-bold">
                <option value="worker">Cloudflare Workers (Reverse Proxy/Failover)</option>
                <option value="pages">Cloudflare Pages</option>
              </select>
            </div>

            <div><label class="text-[10px] font-black text-slate-500 uppercase">Root Domain</label><select id="wcZone" class="w-full mt-1 bg-[#0d1117] border border-slate-700 rounded-2xl px-4 py-3 text-sm text-white outline-none"><option value="">Klik Muat Domain</option></select></div>
            <div>
              <label class="text-[10px] font-black text-slate-500 uppercase">Prefix / Group</label>
              <input id="wcPrefix" placeholder="kosongkan untuk domain.com, atau isi contoh: gtn → gtn.domain.com" class="w-full mt-1 bg-[#0d1117] border border-slate-700 rounded-2xl px-4 py-3 text-sm text-white outline-none">
            </div>
            
            <!-- BLOK PEKERJA (WORKER) -->
            <div id="wcWorkerSettingsWrap" class="space-y-4">
              <div class="grid grid-cols-1 md:grid-cols-2 gap-3">
                <div>
                  <label class="text-[10px] font-black text-slate-500 uppercase">Target Mode</label>
                  <select id="wcTargetMode" class="w-full mt-1 bg-[#0d1117] border border-blue-500/30 rounded-2xl px-4 py-3 text-sm text-white outline-none">
                    <option value="single">Single Worker</option>
                    <option value="multi_balance">Multi Worker Balance</option>
                    <option value="multi_failover" selected>Multi Worker + Failover</option>
                  </select>
                </div>
                <div class="bg-[#0d1117] border border-blue-500/30 rounded-2xl px-4 py-3"><label class="text-[10px] font-black text-slate-500 uppercase">Auto Node Count</label><div id="wcAutoNodeCount" class="mt-1 text-lg font-black text-blue-200">AUTO</div></div>
              </div>
              <div class="bg-[#0d1117] border border-purple-500/20 rounded-2xl px-4 py-3">
                <label class="text-[10px] font-black text-slate-500 uppercase">Worker Nodes Auto</label>
                <div id="wcAutoNodePreview" class="mt-1 text-xs font-mono text-purple-100 leading-relaxed">Pilih root domain untuk melihat nama node otomatis.</div>
              </div>
              <div>
                <label class="text-[10px] font-black text-slate-500 uppercase">Target Failover / WORKER_URLS</label>
                <textarea id="wcWorkerUrls" rows="3" placeholder="target1.example.com" class="w-full mt-1 bg-[#0d1117] border border-blue-500/30 rounded-2xl px-4 py-3 text-xs font-mono text-white outline-none"></textarea>
              </div>
            </div>

            <!-- BLOK PAGES -->
            <div id="wcPagesSettingsWrap" class="space-y-4 hidden">
              <div class="bg-[#0d1117] border border-fuchsia-500/20 rounded-2xl px-4 py-3">
                <label class="text-[10px] font-black text-slate-500 uppercase text-fuchsia-300">Pages Project Name</label>
                <input id="wcPagesProjectName" placeholder="Auto-generate jika kosong (ssl-domain-com)" class="w-full mt-1 bg-[#111722] border border-slate-700 rounded-xl px-3 py-2 text-sm text-white outline-none font-mono">
              </div>
              <div class="bg-[#0d1117] border border-fuchsia-500/20 rounded-2xl px-4 py-3">
                <div class="flex justify-between items-center mb-2">
                  <label class="text-[10px] font-black text-slate-500 uppercase">Script Mode</label>
                  <select id="wcPagesMode" class="bg-[#111722] border border-slate-700 rounded-lg px-2 py-1 text-xs text-white outline-none">
                    <option value="default">Default Proxy</option>
                    <option value="custom">Custom Script</option>
                  </select>
                </div>
                <div id="wcPagesBackendWrap">
                  <label class="text-[10px] font-black text-slate-500 uppercase">Backend / Target Proxy</label>
                  <textarea id="wcPagesBackend" rows="3" placeholder="payload.goku25.workers.dev" class="w-full mt-1 bg-[#111722] border border-slate-700 rounded-xl px-3 py-2 text-xs font-mono text-white outline-none"></textarea>
                </div>
                <div id="wcPagesScriptWrap" class="hidden mt-2">
                  <div class="flex justify-between items-center">
                    <label class="text-[10px] font-black text-slate-500 uppercase">Custom Script Editor</label>
                    <button id="btnResetPagesScript" type="button" class="text-[9px] bg-slate-800 hover:bg-slate-700 text-white px-2 py-1 rounded">RESET DEFAULT</button>
                  </div>
                  <textarea id="wcPagesScript" rows="8" class="w-full mt-1 bg-[#000] border border-fuchsia-500/40 rounded-xl px-3 py-2 text-[10px] font-mono text-fuchsia-300 outline-none"></textarea>
                </div>
              </div>
            </div>
            
            <div>
              <div class="flex items-center justify-between gap-2"><label class="text-[10px] font-black text-slate-500 uppercase">Suffix List / file.txt</label><label class="cursor-pointer bg-slate-800 hover:bg-slate-700 px-3 py-1.5 rounded-xl text-[10px] font-bold text-white"><i class="fa-solid fa-file-import mr-1"></i>Upload .txt<input id="wcFileInput" type="file" class="hidden" accept=".txt,text/plain"></label></div>
              <textarea id="wcSuffix" rows="5" placeholder="*\\nsupport.zoom.us" class="w-full mt-1 bg-[#0d1117] border border-slate-700 rounded-2xl px-4 py-3 text-xs font-mono text-white outline-none"></textarea>
            </div>
            <div class="flex flex-col gap-3">
              <label class="flex items-center gap-3 bg-[#0d1117] border border-orange-500/40 rounded-2xl px-4 py-3 cursor-pointer">
                <span class="relative inline-flex h-7 w-12 items-center rounded-full bg-orange-500" id="wcProxyTrack"><input id="wcProxied" type="checkbox" checked class="sr-only"><span id="wcProxyKnob" class="absolute left-1 h-5 w-5 rounded-full bg-white transition translate-x-5"></span></span>
                <span id="wcProxyLabel" class="text-sm font-bold text-white"><i class="fa-solid fa-cloud text-orange-400 mr-2"></i>Proxied</span>
              </label>
            </div>
          </div>

          <div class="bg-[#161b22] border border-slate-800 rounded-3xl p-5 space-y-4">
            <div class="flex justify-between items-center">
              <h3 class="text-lg font-black text-white">Preview & Status Wildcard</h3>
              <button id="btnWcAutoFillPages" type="button" class="bg-indigo-600 hover:bg-indigo-500 text-[10px] sm:text-xs font-bold text-white px-3 py-1.5 rounded-lg transition-all flex gap-1.5 items-center"><i class="fa-solid fa-bolt"></i> Auto Fill Pages</button>
            </div>
            <div id="wcPreview" class="bg-black/40 border border-slate-800 rounded-2xl p-4 max-h-32 overflow-y-auto text-[11px] font-mono text-slate-300">Preview hostname...</div>
            <div class="grid grid-cols-1 gap-3">
              <button id="btnConnectWildcard" type="button" class="bg-blue-600 hover:bg-blue-500 px-4 py-3 rounded-2xl text-xs font-black text-white">1. AUTO CONNECT / DEPLOY</button>
              <button id="btnCheckWildcard" type="button" class="bg-emerald-700 hover:bg-emerald-600 px-4 py-3 rounded-2xl text-xs font-black text-white">2. CEK SSL</button>
            </div>
            <div id="wcLog" class="bg-black/80 border border-slate-800 rounded-2xl p-4 h-64 overflow-y-auto text-[11px] font-mono text-slate-300"><div class="text-slate-500">// Status deploy & SSL akan tampil berwarna di sini (Fatal Error akan muncul merah)...</div></div>
          </div>
        </div>
      </div>
    </div>
  </div>

  <div id="accountModal" class="fixed inset-0 bg-black/80 backdrop-blur-sm z-50 flex items-center justify-center p-4 hidden">
    <div class="bg-[#161b22] border border-slate-800 rounded-3xl w-full max-w-2xl overflow-hidden shadow-2xl">
      <div class="flex justify-between items-center p-6 border-b border-slate-800"><h3 class="text-xl font-bold text-white">Kelola Akun</h3><button id="btnCloseAccountTop" type="button" class="text-slate-500 hover:text-white transition-all"><i class="fa-solid fa-times text-xl"></i></button></div>
      <div class="p-6 space-y-4">
        <div class="space-y-2"><textarea id="importTextarea" rows="6" placeholder="email@example.com|api_key_here" class="w-full bg-[#0d1117] border border-slate-700 rounded-xl px-4 py-3 text-xs font-mono focus:border-blue-500 outline-none transition-all resize-none text-blue-400"></textarea><button id="btnImportAccounts" type="button" class="w-full bg-blue-600 hover:bg-blue-500 text-white font-bold py-2 rounded-xl text-xs transition-all">SIMPAN AKUN</button></div>
        <div class="border-t border-slate-800 pt-4"><div id="savedAccountsList" class="space-y-2 max-h-[200px] overflow-y-auto pr-2"></div></div>
      </div>
      <div class="p-6 border-t border-slate-800 bg-[#0d1117] flex justify-end gap-3"><button id="btnCloseAccountBottom" type="button" class="bg-slate-800 hover:bg-slate-700 px-6 py-2 rounded-xl text-xs font-bold text-white transition-all">Tutup</button><button id="btnClearAccounts" type="button" class="bg-red-900/30 hover:bg-red-900/50 text-red-500 px-6 py-2 rounded-xl text-xs font-bold border border-red-900/50 transition-all">HAPUS SEMUA</button></div>
    </div>
  </div>

<script>
  const API_BASE_URL = '';
  const ACCOUNT_STORAGE_KEY = 'wildcard_manager_accounts';
  let accounts = [];
  let domainManagerDomains = [];
  let domainManagerSelected = null;
  let domainManagerDnsRecords = [];
  let domainManagerSslDomain = null;
  let pagesManagerProjects = [];
  let pagesManagerDomains = [];

  const PAGES_DEF_SCRIPT = [
    "export default {",
    "  async fetch(request, env, ctx) {",
    "    let url = new URL(request.url);",
    "    let domainBackend = ['payload.goku25.workers.dev'];",
    "    if(env.HOST) domainBackend = await ADD(env.HOST);",
    "    let pathUji = env.PATH || '/';",
    "    if (pathUji.charAt(0) !== '/') pathUji = '/' + pathUji;",
    "    let kodeRespon = env.CODE || '200';",
    "    async function getValidResponse(request, hosts) {",
    "      let shuffledHosts = hosts.sort(() => Math.random() - 0.5);",
    "      for (const host of shuffledHosts) {",
    "        let testUrl = new URL(url.href); testUrl.hostname = host;",
    "        testUrl.pathname = pathUji.split('?')[0]; testUrl.search = pathUji.split('?')[1] || '';",
    "        try {",
    "          const response = await fetch(testUrl.href, { method: 'HEAD', redirect: 'manual' });",
    "          if (response.status.toString() === kodeRespon || response.status === 302) {",
    "            let finalUrl = new URL(url.href); finalUrl.hostname = host;",
    "            return await fetch(new Request(finalUrl.href, { method: request.method, headers: new Headers(request.headers), body: request.body, redirect: 'follow' }));",
    "          }",
    "        } catch (error) {}",
    "      }",
    "      return new Response('Down', { status: 503 });",
    "    }",
    "    return await getValidResponse(request, domainBackend);",
    "  }",
    "};",
    "async function ADD(envadd) {",
    "  var addtext = envadd.replace(/[\\\\t |\\\\\\"'\\\\r\\\\n]+/g, ',').replace(/,+/g, ',');",
    "  if (addtext.charAt(0) == ',') addtext = addtext.slice(1);",
    "  if (addtext.charAt(addtext.length - 1) == ',') addtext = addtext.slice(0, -1);",
    "  return addtext.split(',');",
    "}"
  ].join('\\n');

  function escapeHtml(value) { return String(value ?? '').replace(/[&<>"']/g, ch => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[ch]); }

  function bindWildcardEvents() {
    const bind = (id, evt, hndlr) => { const el = document.getElementById(id); if (el && !el.dataset.bound) { el.addEventListener(evt, hndlr); el.dataset.bound = '1'; } };
    bind('btnOpenAccountModal', 'click', showAccountModal);
    bind('btn-domainmanager', 'click', () => showTab('domainmanager'));
    bind('btn-pagesmanager', 'click', () => showTab('pagesmanager'));
    bind('btn-wildcardssl', 'click', () => showTab('wildcardssl'));
    bind('btnDomainRefresh', 'click', domainManagerLoad);
    bind('btnDomainRefresh2', 'click', domainManagerLoad);
    bind('btnDomainAdd', 'click', domainManagerAddDomain);
    bind('btnDnsAdd', 'click', domainManagerAddDns);
    bind('btnDnsClose', 'click', domainManagerCloseDnsModal);
    bind('btnDnsAddOpen', 'click', domainManagerOpenAddDnsForm);
    bind('btnDnsCancel', 'click', domainManagerCloseAddDnsForm);
    bind('btnDnsBulkOpen', 'click', domainManagerOpenBulkDnsForm);
    bind('btnDnsBulkCancel', 'click', domainManagerCloseBulkDnsForm);
    bind('btnDnsBulkCancelTop', 'click', domainManagerCloseBulkDnsForm);
    bind('btnDnsBulkProcess', 'click', domainManagerProcessBulkDns);
    bind('btnDnsTableCopy', 'click', domainManagerCopyTableDomains); 
    bind('btnDnsTableAutoFill', 'click', domainManagerAutoFillTablePages); 
    bind('btnPagesBulkPaste', 'click', pagesManagerPasteDomains); 
    bind('btnWcAutoFillPages', 'click', wildcardAutoFillTablePages); 
    bind('dmBulkDnsType', 'change', () => { domainManagerSyncBulkDnsType(); domainManagerUpdateBulkDnsPreview(); });
    bind('dmBulkDnsSingleTarget', 'change', () => { domainManagerToggleBulkDnsTargetMode(); domainManagerUpdateBulkDnsPreview(); });
    bind('dmBulkDnsTarget', 'input', domainManagerUpdateBulkDnsPreview);
    bind('dmBulkDnsPrefix', 'input', domainManagerUpdateBulkDnsPreview);
    bind('dmBulkDnsFile', 'change', domainManagerLoadBulkDnsFile);
    bind('btnBulkDnsLoadUrl', 'click', domainManagerLoadBulkDnsRawUrl);
    bind('dmBulkDnsRawUrl', 'keydown', e => { if (e.key === 'Enter') { e.preventDefault(); domainManagerLoadBulkDnsRawUrl(); } });
    bind('dmBulkDnsList', 'input', domainManagerUpdateBulkDnsPreview);
    bind('dmBulkDnsProxied', 'change', domainManagerUpdateBulkDnsPreview);
    bind('dmBulkDnsTtl', 'change', domainManagerUpdateBulkDnsPreview);
    bind('dmBulkDnsPriority', 'input', domainManagerUpdateBulkDnsPreview);
    bind('btnNsClose', 'click', domainManagerHideNameservers);
    bind('btnNsCloseBottom', 'click', domainManagerHideNameservers);
    bind('btnSslCloseTop', 'click', domainManagerCloseSsl);
    bind('btnSslCloseBottom', 'click', domainManagerCloseSsl);
    bind('btnDmActivateSsl', 'click', domainManagerActivateSsl);
    bind('btnDmSaveSslMode', 'click', domainManagerSaveSslMode);
    bind('btnDmSaveMinTls', 'click', domainManagerSaveMinTls);
    bind('btnDmUniversalOn', 'click', () => domainManagerSetUniversal(true));
    bind('btnDmAlwaysHttpsOn', 'click', () => domainManagerSetSslToggle('always_use_https', 'on'));
    bind('btnDmHttpsRewritesOn', 'click', () => domainManagerSetSslToggle('automatic_https_rewrites', 'on'));
    bind('dmAccount', 'change', domainManagerLoad);
    bind('pmAccount', 'change', pagesManagerLoadProjects);
    bind('pmProject', 'change', pagesManagerLoadDomains);
    bind('btnPagesLoad', 'click', pagesManagerLoadProjects);
    bind('btnPagesRefreshDomains', 'click', pagesManagerLoadDomains);
    bind('btnPagesBulkAdd', 'click', pagesManagerBulkAdd);
    bind('dmSearch', 'input', domainManagerRenderDomains);
    bind('dmDnsSearch', 'input', domainManagerFilterDns);
    bind('dmDnsProxied', 'change', e => domainManagerToggleProxyIcon(e.currentTarget));
    
    bind('wcAccount', 'change', wildcardLoadResources);
    bind('wcZone', 'change', wildcardPreview);
    bind('wcPrefix', 'input', wildcardPreview);
    bind('wcSuffix', 'input', wildcardPreview);
    bind('wcWorkerUrls', 'input', wildcardPreview);
    bind('wcTargetMode', 'change', wildcardPreview);
    bind('wcEngine', 'change', wildcardToggleEngine);
    bind('wcProxied', 'change', wildcardProxyVisual);
    bind('btnLoadResources', 'click', wildcardLoadResources);
    bind('btnConnectWildcard', 'click', e => wildcardRunBatched('attach', e));
    bind('btnCheckWildcard', 'click', e => wildcardRunBatched('check', e));
    bind('btnCloseAccountTop', 'click', hideAccountModal);
    bind('btnCloseAccountBottom', 'click', hideAccountModal);
    bind('btnImportAccounts', 'click', importAccounts);
    bind('btnClearAccounts', 'click', clearAllAccounts);
    bind('wcFileInput', 'change', e => wildcardLoadTxt(e.currentTarget));
    
    bind('wcPagesMode', 'change', e => { localStorage.setItem('cf_pro_pages_mode', e.target.value); wildcardTogglePagesMode(); });
    bind('wcPagesBackend', 'input', e => { localStorage.setItem('cf_pro_pages_backend', e.target.value); wildcardUpdatePagesScriptPreview(); });
    bind('wcPagesScript', 'input', e => { if(document.getElementById('wcPagesMode').value==='custom') localStorage.setItem('cf_pro_pages_script', e.target.value); });
    bind('btnResetPagesScript', 'click', () => { document.getElementById('wcPagesScript').value = PAGES_DEF_SCRIPT; localStorage.setItem('cf_pro_pages_script', PAGES_DEF_SCRIPT); });

    const savedList = document.getElementById('savedAccountsList');
    if (savedList && !savedList.dataset.bound) {
      savedList.addEventListener('click', e => {
        const btn = e.target.closest('[data-remove-index]');
        if (btn) removeAccount(Number(btn.dataset.removeIndex));
      });
      savedList.dataset.bound = '1';
    }

    const domainList = document.getElementById('dmDomainList');
    if (domainList && !domainList.dataset.bound) {
      domainList.addEventListener('click', e => {
        const copyBtn = e.target.closest('[data-copy-text]');
        const showNsBtn = e.target.closest('[data-show-ns]');
        const openSslBtn = e.target.closest('[data-open-ssl]');
        const selectBtn = e.target.closest('[data-select-domain]');
        const deleteBtn = e.target.closest('[data-delete-domain]');
        if (copyBtn) return copyText(copyBtn.dataset.copyText || '');
        if (showNsBtn) return domainManagerShowNameservers(showNsBtn.dataset.showNs);
        if (openSslBtn) return domainManagerOpenSsl(openSslBtn.dataset.openSsl);
        if (selectBtn) return domainManagerSelectDomain(selectBtn.dataset.selectDomain);
        if (deleteBtn) return domainManagerDeleteDomain(deleteBtn.dataset.deleteDomain);
      });
      domainList.dataset.bound = '1';
    }

    const pagesList = document.getElementById('pmDomainList');
    if (pagesList && !pagesList.dataset.bound) {
      pagesList.addEventListener('click', e => {
        const del = e.target.closest('[data-pages-delete]');
        if (del) pagesManagerDeleteDomain(del.dataset.pagesDelete || '');
      });
      pagesList.dataset.bound = '1';
    }

    const nsModal = document.getElementById('dmNameserversModal');
    if (nsModal && !nsModal.dataset.bound) {
      nsModal.addEventListener('click', e => {
        const copyBtn = e.target.closest('[data-copy-text]');
        if (copyBtn) copyText(copyBtn.dataset.copyText || '');
      });
      nsModal.dataset.bound = '1';
    }

    const dnsList = document.getElementById('dmDnsList');
    if (dnsList && !dnsList.dataset.bound) {
      dnsList.addEventListener('click', e => {
        const deleteBtn = e.target.closest('[data-delete-record]');
        if (deleteBtn) domainManagerDeleteDns(deleteBtn.dataset.deleteRecord, deleteBtn.dataset.recordName || '');
      });
      dnsList.dataset.bound = '1';
    }
  }

  window.addEventListener('DOMContentLoaded', () => {
    loadAccountsFromStorage();
    bindWildcardEvents();
    fillAllAccountSelects();
    wildcardProxyVisual();
    
    document.getElementById('wcPagesBackend').value = localStorage.getItem('cf_pro_pages_backend') || '';
    document.getElementById('wcPagesMode').value = localStorage.getItem('cf_pro_pages_mode') || 'default';
    const savedScript = localStorage.getItem('cf_pro_pages_script');
    if(savedScript) document.getElementById('wcPagesScript').value = savedScript;
    
    wildcardToggleEngine();
    wildcardTogglePagesMode();
    wildcardPreview();
  });

  function wildcardToggleEngine() {
    const engine = document.getElementById('wcEngine').value;
    const workerWrap = document.getElementById('wcWorkerSettingsWrap');
    const pagesWrap = document.getElementById('wcPagesSettingsWrap');
    if (engine === 'pages') {
      workerWrap.classList.add('hidden');
      if (pagesWrap) pagesWrap.classList.remove('hidden');
    } else {
      workerWrap.classList.remove('hidden');
      if (pagesWrap) pagesWrap.classList.add('hidden');
    }
    wildcardPreview();
  }

  function wildcardTogglePagesMode() {
    const mode = document.getElementById('wcPagesMode').value;
    const backendWrap = document.getElementById('wcPagesBackendWrap');
    const scriptWrap = document.getElementById('wcPagesScriptWrap');
    if (mode === 'custom') {
      backendWrap.classList.add('hidden');
      scriptWrap.classList.remove('hidden');
      document.getElementById('wcPagesScript').readOnly = false;
      document.getElementById('wcPagesScript').style.color = '#f0abfc'; 
    } else {
      backendWrap.classList.remove('hidden');
      scriptWrap.classList.remove('hidden');
      document.getElementById('wcPagesScript').readOnly = true;
      document.getElementById('wcPagesScript').style.color = '#86efac'; 
      wildcardUpdatePagesScriptPreview();
    }
  }

  function wildcardUpdatePagesScriptPreview() {
    if(document.getElementById('wcPagesMode').value === 'custom') return;
    const backendLines = document.getElementById('wcPagesBackend').value.split('\\n').map(x => x.trim()).filter(Boolean);
    let arr = backendLines.length > 0 ? backendLines.map(x => "'" + x + "'").join(', ') : "'payload.goku25.workers.dev'";
    let script = PAGES_DEF_SCRIPT.replace(/let domainBackend = \\['payload.goku25.workers.dev'\\];/, 'let domainBackend = [' + arr + '];');
    document.getElementById('wcPagesScript').value = script;
  }

  function loadAccountsFromStorage() {
    try { accounts = JSON.parse(localStorage.getItem(ACCOUNT_STORAGE_KEY) || '[]'); }
    catch (_) { accounts = []; }
    document.getElementById('accCount').innerText = accounts.length;
    fillAllAccountSelects();
  }

  function saveAccountsToStorage() {
    localStorage.setItem(ACCOUNT_STORAGE_KEY, JSON.stringify(accounts));
    document.getElementById('accCount').innerText = accounts.length;
    fillAllAccountSelects();
  }

  function showAccountModal() {
    renderSavedAccounts();
    document.getElementById('accountModal').classList.remove('hidden');
  }

  function hideAccountModal() {
    document.getElementById('accountModal').classList.add('hidden');
  }

  async function importAccounts() {
    const text = document.getElementById('importTextarea').value.trim();
    if (!text) return;
    const lines = text.split(/\\r?\\n/);
    let importedCount = 0;
    for (const line of lines) {
      const parts = line.split(/[|;,]/);
      if (parts.length < 2) continue;
      const email = parts[0].trim();
      const apiKey = parts[1].trim();
      let accountId = parts[2] ? parts[2].trim() : '';
      if (!email || !apiKey || accounts.some(a => a.email === email && a.apiKey === apiKey)) continue;
      if (!accountId) {
        try {
          const res = await fetch(API_BASE_URL + '/api/accounts', {
            method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email, apiKey })
          });
          const data = await res.json();
          if (data.success && data.result && data.result.length > 0) accountId = data.result[0].id;
        } catch (_) {}
      }
      accounts.push({ email, apiKey, accountId, selected: true });
      importedCount++;
    }
    document.getElementById('importTextarea').value = '';
    saveAccountsToStorage();
    renderSavedAccounts();
    alert('Berhasil menyimpan ' + importedCount + ' akun.');
  }

  function renderSavedAccounts() {
    const list = document.getElementById('savedAccountsList');
    if (!accounts.length) {
      list.innerHTML = '<div class="text-center py-4 text-slate-600 text-xs italic">Belum ada akun tersimpan.</div>';
      return;
    }
    list.innerHTML = accounts.map((acc, index) => {
      return '<div class="flex items-center justify-between bg-[#0d1117] p-3 rounded-xl border border-slate-800">' +
        '<div class="flex flex-col min-w-0"><span class="text-xs font-bold text-white truncate">' + escapeHtml(acc.email) + '</span><span class="text-[10px] text-slate-500 font-mono truncate">' + escapeHtml(acc.accountId || 'ID kosong') + '</span></div>' +
        '<button type="button" data-remove-index="' + index + '" class="text-red-500 hover:text-red-400 p-2"><i class="fa-solid fa-trash-can"></i></button>' +
      '</div>';
    }).join('');
  }

  function removeAccount(index) {
    accounts.splice(index, 1);
    saveAccountsToStorage();
    renderSavedAccounts();
  }

  function clearAllAccounts() {
    if (!confirm('Hapus semua akun tersimpan?')) return;
    accounts = [];
    saveAccountsToStorage();
    renderSavedAccounts();
  }

  function pagesLog(msg, tone) {
    const el = document.getElementById('pmLog');
    if (!el) return;
    if (el.dataset.ready !== '1') { el.dataset.ready = '1'; el.innerHTML = ''; }
    let cls = 'text-sky-200';
    if (tone === 'failed' || /fail|gagal|error/i.test(msg)) cls = 'text-red-300';
    else if (tone === 'active' || /success|berhasil|selesai/i.test(msg)) cls = 'text-emerald-300';
    else if (tone === 'pending' || /load|muat|pending/i.test(msg)) cls = 'text-yellow-300';
    const d = new Date();
    const t = String(d.getHours()).padStart(2,'0') + '.' + String(d.getMinutes()).padStart(2,'0') + '.' + String(d.getSeconds()).padStart(2,'0');
    el.innerHTML += '<div class="' + cls + '">[' + t + '] ' + escapeHtml(msg) + '</div>';
    el.scrollTop = el.scrollHeight;
  }

  function pagesSelectedAccount() {
    const idx = document.getElementById('pmAccount').value;
    if (idx === '' || !accounts[idx]) return null;
    return accounts[idx];
  }

  async function pagesManagerLoadProjects() {
    const acc = pagesSelectedAccount();
    if (!acc) return pagesLog('Pilih account dulu.', 'pending');
    if (!acc.accountId) return pagesLog('Account ID kosong.', 'failed');
    pagesLog('Memuat Pages Project...', 'pending');
    try {
      const res = await fetch(API_BASE_URL + '/api/pagesManager/projects', {
        method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email: acc.email, apiKey: acc.apiKey, accountId: acc.accountId })
      });
      const data = await res.json();
      if (!data.success) throw new Error(data.message || 'Gagal memuat project');
      pagesManagerProjects = data.projects || [];
      const sel = document.getElementById('pmProject');
      sel.innerHTML = '<option value="">Pilih Pages Project</option>' + pagesManagerProjects.map(p => '<option value="' + escapeHtml(p.name) + '">' + escapeHtml(p.name) + '</option>').join('');
      pagesLog('Pages Project dimuat: ' + pagesManagerProjects.length + ' project.', 'active');
      pagesManagerDomains = [];
      pagesManagerRenderDomains();
    } catch (e) {
      pagesLog('Gagal memuat Pages Project: ' + e.message, 'failed');
    }
  }

  async function pagesManagerLoadDomains() {
    const acc = pagesSelectedAccount();
    const projectName = document.getElementById('pmProject').value;
    if (!acc) return pagesLog('Pilih account dulu.', 'pending');
    if (!projectName) return pagesLog('Pilih Pages Project dulu.', 'pending');
    pagesLog('Memuat domain Pages untuk ' + projectName + '...', 'pending');
    try {
      const res = await fetch(API_BASE_URL + '/api/pagesManager/domains', {
        method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email: acc.email, apiKey: acc.apiKey, accountId: acc.accountId, projectName })
      });
      const data = await res.json();
      if (!data.success) throw new Error(data.message || 'Gagal memuat domain Pages');
      pagesManagerDomains = data.domains || [];
      pagesManagerRenderDomains();
      pagesLog('Domain Pages dimuat: ' + pagesManagerDomains.length + ' domain.', 'active');
    } catch (e) {
      pagesLog('Gagal memuat domain Pages: ' + e.message, 'failed');
    }
  }

  function pagesStatusClass(status) {
    status = String(status || '').toLowerCase();
    if (status.includes('active') || status.includes('verified')) return 'bg-emerald-500';
    if (status.includes('fail') || status.includes('error')) return 'bg-red-500';
    return 'bg-yellow-500';
  }

  function pagesManagerRenderDomains() {
    const list = document.getElementById('pmDomainList');
    if (!list) return;
    if (!pagesManagerDomains.length) {
      list.innerHTML = '<div class="text-center py-20 text-slate-600">Belum ada domain Pages / belum dimuat.</div>';
      return;
    }
    list.innerHTML = pagesManagerDomains.map(d => {
      const status = d.status || 'listed';
      const target = d.verification_data && d.verification_data.target ? d.verification_data.target : '';
      return '<div class="bg-[#0d1117] border border-slate-800 rounded-2xl p-4 flex items-center justify-between gap-3">' +
        '<div class="min-w-0"><div class="text-sm font-bold text-white truncate">' + escapeHtml(d.name) + '</div><div class="flex items-center gap-2 mt-1"><span class="w-2 h-2 rounded-full ' + pagesStatusClass(status) + '"></span><span class="text-[10px] uppercase font-black text-slate-500">' + escapeHtml(status) + '</span></div>' +
        (target ? '<div class="text-[10px] text-indigo-300 font-mono truncate mt-1">DNS target: ' + escapeHtml(target) + '</div>' : '') +
        '</div><button type="button" data-pages-delete="' + escapeHtml(d.name) + '" class="bg-red-950/30 hover:bg-red-900/50 text-red-400 border border-red-900/40 px-3 py-2 rounded-xl text-[10px] font-black uppercase">Delete</button></div>';
    }).join('');
  }

  async function pagesManagerPasteDomains() {
    try {
      const text = await navigator.clipboard.readText();
      if (!text) return alert('Clipboard kosong.');
      const textarea = document.getElementById('pmDomains');
      if (textarea.value.trim() === '') textarea.value = text;
      else textarea.value += '\\n' + text;
      const btn = document.getElementById('btnPagesBulkPaste');
      const origHtml = btn.innerHTML;
      btn.innerHTML = '<i class="fa-solid fa-check text-emerald-400"></i> Ditempel!';
      setTimeout(() => btn.innerHTML = origHtml, 2000);
    } catch (err) {
      alert('Gagal menempelkan teks. Error: ' + err.message);
    }
  }

  async function pagesManagerBulkAdd() {
    const acc = pagesSelectedAccount();
    const projectName = document.getElementById('pmProject').value;
    const domains = document.getElementById('pmDomains').value;
    if (!acc || !projectName || !domains.trim()) return alert('Pastikan account, project, dan list domain terisi.');
    pagesLog('Mulai bulk add Pages domain...', 'pending');
    try {
      const res = await fetch(API_BASE_URL + '/api/pagesManager/bulkAdd', {
        method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email: acc.email, apiKey: acc.apiKey, accountId: acc.accountId, projectName, domains })
      });
      const data = await res.json();
      if (!data.success) throw new Error(data.message || 'Bulk add gagal');
      (data.results || []).forEach(r => {
        pagesLog((r.success ? 'OK' : 'FAIL') + ' - ' + r.name + ' - ' + (r.status || '') + (r.error ? ' - ' + r.error : ''), r.success ? 'active' : 'failed');
      });
      await pagesManagerLoadDomains();
      pagesLog('Bulk add Pages domain selesai.', 'active');
    } catch (e) {
      pagesLog('Bulk add gagal: ' + e.message, 'failed');
    }
  }

  async function pagesManagerDeleteDomain(domainName) {
    const acc = pagesSelectedAccount();
    const projectName = document.getElementById('pmProject').value;
    if (!acc || !projectName || !domainName) return;
    if (!confirm('Hapus domain Pages ' + domainName + '?')) return;
    try {
      const res = await fetch(API_BASE_URL + '/api/pagesManager/delete', {
        method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email: acc.email, apiKey: acc.apiKey, accountId: acc.accountId, projectName, domainName })
      });
      const data = await res.json();
      if (!data.success) throw new Error(data.message || 'Delete gagal');
      pagesLog('Domain Pages dihapus: ' + domainName, 'active');
      await pagesManagerLoadDomains();
    } catch (e) {
      pagesLog('Delete Pages domain gagal: ' + e.message, 'failed');
    }
  }

  function domainLog(msg, tone) {
    const el = document.getElementById('dmLog');
    if (!el) return;
    if (el.dataset.ready !== '1') { el.dataset.ready = '1'; el.innerHTML = ''; }
    const text = String(msg || '');
    let cls = 'text-sky-200';
    if (/gagal|error|fail|hapus/i.test(text) || tone === 'failed') cls = 'text-red-300';
    else if (/berhasil|sukses|active|selesai/i.test(text) || tone === 'active') cls = 'text-emerald-300';
    else if (/menunggu|load|muat|pending/i.test(text) || tone === 'pending') cls = 'text-yellow-300';
    const d = new Date();
    const t = String(d.getHours()).padStart(2,'0') + '.' + String(d.getMinutes()).padStart(2,'0') + '.' + String(d.getSeconds()).padStart(2,'0');
    el.innerHTML += '<div class="' + cls + '">[' + t + '] ' + escapeHtml(text) + '</div>';
    el.scrollTop = el.scrollHeight;
  }

  function domainSelectedAccount() {
    const idx = document.getElementById('dmAccount').value;
    if (idx === '' || !accounts[idx]) return null;
    return accounts[idx];
  }

  function copyText(text) {
    try {
      navigator.clipboard.writeText(String(text || ''));
      domainLog('Teks berhasil disalin.', 'active');
    } catch (_) {
      domainLog('Tidak bisa menyalin otomatis di browser ini.', 'failed');
    }
  }

  function domainManagerOpenAddDnsForm() {
    domainManagerCloseBulkDnsForm();
    const form = document.getElementById('dmDnsAddForm');
    if (form) form.classList.remove('hidden');
    if (document.getElementById('dmDnsType')) document.getElementById('dmDnsType').value = 'A';
    if (document.getElementById('dmDnsName')) document.getElementById('dmDnsName').value = '';
    if (document.getElementById('dmDnsContent')) document.getElementById('dmDnsContent').value = '';
    if (document.getElementById('dmDnsTtl')) document.getElementById('dmDnsTtl').value = '1';
    const proxied = document.getElementById('dmDnsProxied');
    if (proxied) { proxied.checked = true; domainManagerToggleProxyIcon(proxied); }
  }

  function domainManagerCloseAddDnsForm() {
    const form = document.getElementById('dmDnsAddForm');
    if (form) form.classList.add('hidden');
  }

  function domainManagerIsBulkProxyType(type) {
    return ['A', 'AAAA', 'CNAME'].indexOf(String(type || '').toUpperCase()) >= 0;
  }

  function domainManagerOpenBulkDnsForm() {
    domainManagerCloseAddDnsForm();
    const form = document.getElementById('dmDnsBulkForm');
    if (form) form.classList.remove('hidden');
    if (document.getElementById('dmBulkDnsType') && !document.getElementById('dmBulkDnsType').value) document.getElementById('dmBulkDnsType').value = 'A';
    domainManagerSyncBulkDnsType();
    domainManagerToggleBulkDnsTargetMode();
    domainManagerUpdateBulkDnsPreview();
  }

  function domainManagerCloseBulkDnsForm() {
    const form = document.getElementById('dmDnsBulkForm');
    if (form) form.classList.add('hidden');
  }

  function domainManagerSyncBulkDnsType() {
    const type = document.getElementById('dmBulkDnsType') ? document.getElementById('dmBulkDnsType').value : 'A';
    const proxyWrap = document.getElementById('dmBulkDnsProxyWrap');
    const priorityWrap = document.getElementById('dmBulkDnsPriorityWrap');
    if (proxyWrap) proxyWrap.classList.toggle('hidden', !domainManagerIsBulkProxyType(type));
    if (priorityWrap) priorityWrap.classList.toggle('hidden', String(type).toUpperCase() !== 'MX');
  }

  function domainManagerToggleBulkDnsTargetMode() {
    const one = document.getElementById('dmBulkDnsSingleTarget') ? document.getElementById('dmBulkDnsSingleTarget').checked : false;
    const wrap = document.getElementById('dmBulkDnsTargetWrap');
    const hint = document.getElementById('dmBulkDnsHint');
    const list = document.getElementById('dmBulkDnsList');
    if (wrap) wrap.classList.toggle('hidden', !one);
    if (hint) hint.innerText = one ? 'Mode satu target: isi satu name/suffix per baris, target diambil dari kolom Target untuk semua baris. Prefix tetap digabung otomatis.' : 'Format default: name,target per baris. Kolom Prefix akan digabung ke setiap name seperti fitur Wildcard SSL.';
    if (list) list.placeholder = one ? ['*','app','api','cdn','www'].join(String.fromCharCode(10)) : ['*,1.2.3.4','app,1.2.3.4','api,example.pages.dev','cdn,target.example.com'].join(String.fromCharCode(10));
  }

  function domainManagerBulkBaseHost() {
    const root = wildcardClean(domainManagerSelected?.name || '');
    const prefix = wildcardClean(document.getElementById('dmBulkDnsPrefix') ? document.getElementById('dmBulkDnsPrefix').value : '');
    if (!root) return prefix;
    if (!prefix || prefix === '@' || prefix === '*') return root;
    if (prefix === root || prefix.endsWith('.' + root)) return prefix;
    return prefix + '.' + root;
  }

  function domainManagerApplyBulkDnsPrefix(name) {
    const root = wildcardClean(domainManagerSelected?.name || '');
    const baseHost = domainManagerBulkBaseHost();
    const n = wildcardClean(name);
    if (!n || n === '@' || n === '*') return baseHost || root || n;
    if (!root || !baseHost) return n;
    if (n === root || n.endsWith('.' + root)) return n;
    if (n.startsWith('*.')) {
      const bare = wildcardClean(n.slice(2));
      if (!bare || bare === '@' || bare === '*') return '*.' + baseHost;
      if (bare === root || bare.endsWith('.' + root)) return '*.' + bare;
      return '*.' + bare + '.' + baseHost;
    }
    return n + '.' + baseHost;
  }

  function domainManagerSetBulkDnsListText(text) {
    const listEl = document.getElementById('dmBulkDnsList');
    if (!listEl) return;
    listEl.value = String(text || '').replace(/\\r\\n/g, '\\n').replace(/\\r/g, '\\n').trim();
    domainManagerUpdateBulkDnsPreview();
  }

  function domainManagerLoadBulkDnsFile(e) {
    const file = e.currentTarget.files ? e.currentTarget.files[0] : null;
    if (!file) return;
    if (file.size > 300000) return alert('File TXT terlalu besar.');
    const reader = new FileReader();
    reader.onload = () => { domainManagerSetBulkDnsListText(reader.result || ''); domainLog('Bulk DNS list dimuat dari TXT: ' + file.name, 'active'); };
    reader.onerror = () => alert('Gagal membaca file TXT.');
    reader.readAsText(file);
  }

  async function domainManagerLoadBulkDnsRawUrl() {
    const rawUrl = String(document.getElementById('dmBulkDnsRawUrl')?.value || '').trim();
    if (!rawUrl) return alert('Isi URL raw TXT dulu.');
    const btn = document.getElementById('btnBulkDnsLoadUrl');
    const old = btn ? btn.innerHTML : '';
    if (btn) { btn.disabled = true; btn.innerHTML = '<i class="fa-solid fa-spinner fa-spin"></i>'; }
    try {
      const res = await fetch(API_BASE_URL + '/api/domainManager/fetchBulkText', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ url: rawUrl }) });
      const data = await res.json();
      if (!data.success) throw new Error(data.message || 'Gagal load raw URL.');
      domainManagerSetBulkDnsListText(data.text || '');
      domainLog('Bulk DNS list dimuat dari raw URL.', 'active');
    } catch (e) {
      alert('Gagal load raw URL: ' + e.message);
    } finally {
      if (btn) { btn.disabled = false; btn.innerHTML = old; }
    }
  }

  function domainManagerBuildBulkDnsRows() {
    const type = String(document.getElementById('dmBulkDnsType')?.value || 'A').toUpperCase();
    const ttl = parseInt(document.getElementById('dmBulkDnsTtl')?.value || '1', 10) || 1;
    const one = !!document.getElementById('dmBulkDnsSingleTarget')?.checked;
    const target = String(document.getElementById('dmBulkDnsTarget')?.value || '').trim();
    const priority = parseInt(document.getElementById('dmBulkDnsPriority')?.value || '10', 10) || 10;
    const raw = document.getElementById('dmBulkDnsList') ? String(document.getElementById('dmBulkDnsList').value || '') : '';
    const lines = raw.split(String.fromCharCode(10)).map(x => x.replace(String.fromCharCode(13), '').replace(/#.*/, '').trim()).filter(Boolean);
    if (!lines.length) throw new Error('List DNS masih kosong.');
    if (one && !target) throw new Error('Target untuk semua baris masih kosong.');
    const rows = [];
    lines.forEach(line => {
      let name = '', content = '';
      if (one) { name = line; content = target; } 
      else {
        const idx = line.indexOf(',');
        if (idx < 0) throw new Error('Format salah: ' + line + ' — gunakan name,target atau aktifkan Satu target.');
        name = line.slice(0, idx).trim();
        content = line.slice(idx + 1).trim();
      }
      if (!name || !content) return;
      const fullName = domainManagerApplyBulkDnsPrefix(name);
      const item = { type, name: fullName, inputName: name, content, ttl, baseHost: domainManagerBulkBaseHost() };
      if (domainManagerIsBulkProxyType(type)) item.proxied = !!document.getElementById('dmBulkDnsProxied')?.checked;
      if (type === 'MX') item.priority = priority;
      rows.push(item);
    });
    if (!rows.length) throw new Error('Tidak ada record valid.');
    return rows;
  }

  function domainManagerGetDomainsForCopy() {
    let domains = [];
    try { domains = domainManagerBuildBulkDnsRows().map(r => domainManagerNormalizeDnsName(r.name)); } catch(e) {}
    if (!domains.length && domainManagerDnsRecords && domainManagerDnsRecords.length > 0) {
      domains = domainManagerDnsRecords.filter(r => ['A', 'AAAA', 'CNAME'].includes(String(r.type).toUpperCase())).map(r => r.name);
    }
    const unique = []; const seen = new Set();
    for(let i=0; i<domains.length; i++) { if(!seen.has(domains[i])) { seen.add(domains[i]); unique.push(domains[i]); } }
    return unique;
  }

  function domainManagerCopyTableDomains() {
    if (!domainManagerSelected) return alert("Pilih domain terlebih dahulu di panel kiri sebelum menyalin.");
    const domainsToCopy = domainManagerGetDomainsForCopy();
    if (!domainsToCopy.length) return alert("Tidak ada domain yang bisa disalin.");
    navigator.clipboard.writeText(domainsToCopy.join('\\n')).then(() => {
      const btn = document.getElementById('btnDnsTableCopy');
      const origHtml = btn.innerHTML;
      btn.innerHTML = '<i class="fa-solid fa-check text-emerald-400"></i> Tersalin!';
      setTimeout(() => btn.innerHTML = origHtml, 2000);
    }).catch(err => alert('Browser menolak akses clipboard.'));
  }

  function domainManagerAutoFillTablePages() {
    if (!domainManagerSelected) return alert("Pilih domain terlebih dahulu.");
    const domainsToFill = domainManagerGetDomainsForCopy();
    if (!domainsToFill.length) return alert("Tidak ada domain yang bisa dikirim.");
    const textToAppend = domainsToFill.join('\\n');
    const textarea = document.getElementById('pmDomains');
    if (textarea.value.trim() === '') textarea.value = textToAppend;
    else textarea.value += '\\n' + textToAppend;
    domainManagerCloseBulkDnsForm();
    domainManagerCloseDnsModal();
    showTab('pagesmanager');
    pagesLog('Auto fill ' + domainsToFill.length + ' domain berhasil.', 'active');
  }

  function domainManagerUpdateBulkDnsPreview() {
    const box = document.getElementById('dmBulkDnsPreview');
    const count = document.getElementById('dmBulkDnsCount');
    if (!box || !count) return;
    try {
      const rows = domainManagerBuildBulkDnsRows();
      count.innerText = rows.length + ' record';
      box.classList.toggle('hidden', rows.length === 0);
      box.innerHTML = '<div class="text-indigo-300 font-bold mb-2">Preview hasil gabungan' + (domainManagerBulkBaseHost() ? ': ' + escapeHtml(domainManagerBulkBaseHost()) : '') + '</div>' + 
        rows.slice(0, 20).map(r => '<div>• [' + escapeHtml(r.type) + '] ' + escapeHtml(r.name) + (r.inputName && r.inputName !== r.name ? '<span class="text-slate-500"> (' + escapeHtml(r.inputName) + ')</span>' : '') + ' → ' + escapeHtml(r.content) + (domainManagerIsBulkProxyType(r.type) ? (r.proxied ? ' • proxied' : ' • DNS only') : '') + (r.type === 'MX' ? ' • priority ' + escapeHtml(r.priority) : '') + '</div>').join('') + 
        (rows.length > 20 ? '<div class="text-slate-500">... +' + (rows.length - 20) + ' lagi</div>' : '');
    } catch (e) {
      const rawLines = (document.getElementById('dmBulkDnsList') ? String(document.getElementById('dmBulkDnsList').value || '') : '').split(String.fromCharCode(10)).map(x => x.replace(String.fromCharCode(13), '').trim()).filter(Boolean);
      count.innerText = rawLines.length + ' record';
      if (rawLines.length) { box.classList.remove('hidden'); box.innerHTML = '<div class="text-orange-400">' + escapeHtml(e.message) + '</div>'; } 
      else { box.classList.add('hidden'); box.innerHTML = ''; }
    }
  }

  async function domainManagerProcessBulkDns() {
    const acc = domainSelectedAccount();
    if (!acc || !domainManagerSelected) return alert('Pilih domain dulu.');
    let rows;
    try { rows = domainManagerBuildBulkDnsRows(); } catch (e) { return alert(e.message); }
    const replace = !!document.getElementById('dmBulkDnsReplace')?.checked;
    const btn = document.getElementById('btnDnsBulkProcess');
    const progress = document.getElementById('dmBulkDnsProgress');
    const old = btn ? btn.innerHTML : '';
    if (btn) { btn.disabled = true; btn.innerHTML = '<i class="fa-solid fa-spinner fa-spin mr-1"></i> PROSES...'; }
    if (progress) { progress.classList.remove('hidden'); progress.innerHTML = '<div class="text-indigo-400">>> Memulai bulk DNS: ' + rows.length + ' record...</div>'; }
    let ok = 0, fail = 0;
    for (let i = 0; i < rows.length; i++) {
      const r = rows[i];
      if (progress) progress.innerHTML += '<div class="text-slate-400">>> [' + (i + 1) + '/' + rows.length + '] ' + escapeHtml(r.type) + ' ' + escapeHtml(r.name) + ' → ' + escapeHtml(r.content) + '</div>';
      try {
        if (replace && Array.isArray(domainManagerDnsRecords)) {
          const norm = domainManagerNormalizeDnsName(r.name);
          const same = domainManagerDnsRecords.filter(x => String(x.type || '').toUpperCase() === r.type && String(x.name || '').toLowerCase() === String(norm || '').toLowerCase());
          for (let j = 0; j < same.length; j++) {
            await fetch(API_BASE_URL + '/api/domainManager/dnsDelete', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email: acc.email, apiKey: acc.apiKey, accountId: acc.accountId, domainId: domainManagerSelected.id, recordId: same[j].id }) });
          }
        }
        const res = await fetch(API_BASE_URL + '/api/domainManager/dnsAdd', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email: acc.email, apiKey: acc.apiKey, accountId: acc.accountId, domainId: domainManagerSelected.id, domainName: domainManagerSelected.name, type: r.type, name: r.name, content: r.content, proxied: r.proxied, ttl: r.ttl, priority: r.priority }) });
        const data = await res.json();
        if (!data.success) throw new Error(data.message || 'Cloudflare error');
        ok++;
        if (progress) progress.innerHTML += '<div class="text-green-400 ml-3">✓ sukses</div>';
      } catch (e) {
        fail++;
        if (progress) progress.innerHTML += '<div class="text-red-400 ml-3">✗ gagal: ' + escapeHtml(e.message) + '</div>';
      }
      if (progress) progress.scrollTop = progress.scrollHeight;
      await new Promise(res => setTimeout(res, 250));
    }
    if (progress) progress.innerHTML += '<div class="text-blue-400 font-bold mt-2">>> Selesai: ' + ok + ' sukses, ' + fail + ' gagal.</div>';
    domainLog('Bulk DNS selesai: ' + ok + ' sukses, ' + fail + ' gagal.', fail ? 'pending' : 'active');
    await domainManagerLoadDns();
    if (btn) { btn.disabled = false; btn.innerHTML = old; }
  }

  function domainManagerNormalizeDnsName(name) {
    if (!domainManagerSelected) return String(name || '').toLowerCase();
    let n = wildcardClean(name || '');
    const root = wildcardClean(domainManagerSelected.name || '');
    if (!n || n === '@') return root;
    if (n === root || n.endsWith('.' + root)) return n;
    return n + '.' + root;
  }

  function domainManagerToggleProxyIcon(checkbox) {
    const bg = document.getElementById('dmProxyToggleBg'), dot = document.getElementById('dmProxyToggleDot'), icon = document.getElementById('dmProxyIcon'), label = document.getElementById('dmProxyLabel');
    if (!bg || !dot || !icon || !label || !checkbox) return;
    if (checkbox.checked) {
      bg.classList.remove('bg-slate-600'); bg.classList.add('bg-orange-500'); dot.classList.remove('-translate-x-5');
      icon.className = 'fa-brands fa-cloudflare text-orange-500 text-lg'; label.innerText = 'Proxied'; label.className = 'text-orange-500';
    } else {
      bg.classList.remove('bg-orange-500'); bg.classList.add('bg-slate-600'); dot.classList.add('-translate-x-5');
      icon.className = 'fa-solid fa-arrow-turn-down text-slate-500'; label.innerText = 'DNS only'; label.className = 'text-slate-400';
    }
  }

  function domainManagerCloseDnsModal() {
    if (document.getElementById('dmDnsModal')) document.getElementById('dmDnsModal').classList.add('hidden');
  }

  async function domainManagerLoad() {
    fillAccountSelect('dmAccount', document.getElementById('dmAccount').value);
    const acc = domainSelectedAccount();
    if (!acc) return domainLog('Pilih account dulu.', 'pending');
    if (!acc.accountId) return domainLog('Account ID kosong.', 'failed');
    domainLog('Muat daftar domain untuk ' + (acc.email || 'account') + '...', 'pending');
    try {
      const res = await fetch(API_BASE_URL + '/api/domainManager/list', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email: acc.email, apiKey: acc.apiKey, accountId: acc.accountId }) });
      const data = await res.json();
      if (!data.success) throw new Error(data.message || 'Gagal memuat domain');
      domainManagerDomains = data.domains || []; domainManagerSelected = null; domainManagerDnsRecords = [];
      domainManagerRenderDomains();
      domainManagerCloseDnsModal();
      domainLog('Domain dimuat: ' + domainManagerDomains.length + ' domain.', 'active');
    } catch (e) { domainLog('Gagal memuat domain: ' + e.message, 'failed'); }
  }

  function domainStatusBadge(status) {
    status = String(status || 'unknown').toLowerCase();
    if (status === 'active') return '<span class="px-2 py-1 rounded-lg bg-emerald-500/10 border border-emerald-500/20 text-emerald-300 text-[9px] font-black">ACTIVE</span>';
    if (/pending|initial/i.test(status)) return '<span class="px-2 py-1 rounded-lg bg-yellow-500/10 border border-yellow-500/20 text-yellow-300 text-[9px] font-black">PENDING</span>';
    return '<span class="px-2 py-1 rounded-lg bg-slate-500/10 border border-slate-500/20 text-slate-300 text-[9px] font-black">' + escapeHtml(status || 'UNKNOWN') + '</span>';
  }

  function domainManagerRenderDomains() {
    const list = document.getElementById('dmDomainList');
    if (!list) return;
    const q = wildcardClean(document.getElementById('dmSearch') ? document.getElementById('dmSearch').value : '');
    const rows = domainManagerDomains.filter(d => !q || String(d.name || '').toLowerCase().includes(q));
    if (!rows.length) { list.innerHTML = '<div class="text-center py-10 text-slate-500 bg-[#0d1117] rounded-2xl border border-dashed border-slate-700">Belum ada domain yang cocok.</div>'; return; }
    list.innerHTML = rows.map(d => {
      const statusColor = String(d.status || '').toLowerCase() === 'active' ? 'bg-[#10b981]/20 text-[#10b981]' : (/pending|initial/i.test(String(d.status || '')) ? 'bg-orange-500/20 text-orange-500' : 'bg-slate-500/20 text-slate-400');
      const planName = d.plan ? d.plan : 'Free Website';
      const selectedClass = domainManagerSelected && domainManagerSelected.id === d.id ? ' border-blue-500/70 bg-blue-500/5' : '';
      return '<div class="bg-[#111722] rounded-xl border border-slate-800 p-4 sm:p-5 flex flex-col hover:border-slate-600 transition-all' + selectedClass + '">' +
        '<div class="flex justify-between items-center gap-2 mb-4"><span class="text-[9px] sm:text-[10px] px-2 sm:px-3 py-0.5 sm:py-1 rounded-full ' + statusColor + ' font-black uppercase tracking-widest whitespace-nowrap">' + escapeHtml(d.status || 'unknown') + '</span><h4 class="text-xs sm:text-sm font-bold text-white tracking-wide break-words text-right">' + escapeHtml(d.name) + '</h4></div>' +
        '<div class="bg-black/50 rounded-lg p-2 sm:p-2.5 flex justify-between items-center border border-slate-800/50 mb-3"><div class="flex items-center gap-1.5 sm:gap-2 overflow-hidden text-slate-400 text-[10px] sm:text-xs font-mono"><i class="fa-solid fa-fingerprint text-slate-600 text-[10px] sm:text-xs"></i><span class="truncate">' + escapeHtml((d.id || '').slice(0,12)) + '...' + escapeHtml((d.id || '').slice(-8)) + '</span></div><button type="button" data-copy-text="' + escapeHtml(d.id || '') + '" class="text-slate-500 hover:text-white px-1.5 sm:px-2 transition-all"><i class="fa-solid fa-copy text-xs sm:text-sm"></i></button></div>' +
        '<div class="flex items-center gap-2 text-slate-400 text-[11px] sm:text-xs mb-4 sm:mb-5 font-medium"><i class="fa-solid fa-layer-group text-[10px] sm:text-xs"></i><span class="truncate">Paket: ' + escapeHtml(planName) + '</span></div>' +
        '<div class="flex gap-2 sm:gap-3 mb-2 sm:mb-3"><button type="button" data-show-ns="' + escapeHtml(d.id) + '" class="flex-1 bg-[#161b22] hover:bg-slate-800 text-white py-2 sm:py-2.5 rounded-lg text-[10px] sm:text-xs font-bold transition-all border border-slate-700 flex items-center justify-center gap-1.5 sm:gap-2"><i class="fa-solid fa-server text-[9px] sm:text-xs"></i><span>Nameservers</span></button><button type="button" data-select-domain="' + escapeHtml(d.id) + '" class="flex-1 bg-[#161b22] hover:bg-slate-800 text-white py-2 sm:py-2.5 rounded-lg text-[10px] sm:text-xs font-bold transition-all border border-slate-700 flex items-center justify-center gap-1.5 sm:gap-2"><i class="fa-solid fa-network-wired text-[9px] sm:text-xs"></i><span>Kelola DNS</span></button></div>' +
        '<div class="flex gap-2 sm:gap-3"><button type="button" data-open-ssl="' + escapeHtml(d.id) + '" class="flex-1 bg-emerald-950/30 hover:bg-emerald-900/50 text-emerald-400 py-2 sm:py-2.5 rounded-lg text-[10px] sm:text-xs font-bold transition-all border border-emerald-900/30 flex items-center justify-center gap-1.5 sm:gap-2"><i class="fa-solid fa-lock text-[9px] sm:text-xs"></i><span>SSL/TLS</span></button><button type="button" data-delete-domain="' + escapeHtml(d.id) + '" class="flex-1 bg-red-950/30 hover:bg-red-950/50 text-red-300 py-2 sm:py-2.5 rounded-lg text-[10px] sm:text-xs font-bold transition-all border border-red-900/40 flex items-center justify-center gap-1.5 sm:gap-2"><i class="fa-solid fa-trash-can text-[9px] sm:text-xs"></i><span>Hapus</span></button></div>' +
      '</div>';
    }).join('');
  }

  function domainManagerShowNameservers(domainId) {
    const domain = domainManagerDomains.find(d => d.id === domainId);
    if (!domain) return alert('Data domain tidak ditemukan.');
    const modal = document.getElementById('dmNameserversModal');
    document.getElementById('dmNsDomainName').textContent = domain.name || 'domain.com';
    const list = document.getElementById('dmNsList');
    const nsRows = Array.isArray(domain.name_servers) ? domain.name_servers : [];
    if (nsRows.length) {
      list.innerHTML = nsRows.map(ns => '<button type="button" data-copy-text="' + escapeHtml(ns) + '" class="w-full bg-[#161b22] border border-slate-700/50 p-3 rounded-lg flex justify-between items-center cursor-pointer hover:border-slate-500 transition-all group text-left"><span class="text-sm font-mono text-slate-300 tracking-wide break-all">' + escapeHtml(ns) + '</span><span class="bg-slate-800 p-2 rounded-md group-hover:bg-slate-700 transition-all ml-3"><i class="fa-solid fa-copy text-slate-400 text-xs"></i></span></button>').join('') + '<button type="button" data-copy-text="' + escapeHtml(nsRows.join('\\n')) + '" class="w-full mt-3 bg-blue-600 hover:bg-blue-500 text-white py-2.5 rounded-xl text-xs font-black transition-all"><i class="fa-solid fa-copy mr-2"></i>Copy Semua Name Server</button>';
    } else { list.innerHTML = '<div class="text-slate-500 text-sm italic py-2">Nameserver belum tersedia.</div>'; }
    if (modal) modal.classList.remove('hidden');
  }

  function domainManagerHideNameservers() {
    if (document.getElementById('dmNameserversModal')) document.getElementById('dmNameserversModal').classList.add('hidden');
  }

  function domainNormalizeSettingValue(setting) {
    if (!setting) return null;
    if (Object.prototype.hasOwnProperty.call(setting, 'value')) return setting.value;
    if (Object.prototype.hasOwnProperty.call(setting, 'enabled')) return setting.enabled ? 'on' : 'off';
    return null;
  }

  function domainBadgeText(value) {
    if (value === true) return 'ON'; if (value === false) return 'OFF'; if (value === null || value === undefined || value === '') return '-';
    return String(value).toUpperCase();
  }

  function domainSetSslLog(message) {
    const log = document.getElementById('dmSslActionLog');
    if (!log) return;
    log.classList.remove('hidden'); log.textContent = message;
  }

  async function domainManagerOpenSsl(domainId) {
    const domain = domainManagerDomains.find(d => d.id === domainId);
    if (!domain) return alert('Data domain tidak ditemukan.');
    domainManagerSslDomain = domain;
    document.getElementById('dmSslDomainName').textContent = domain.name || 'domain.com';
    document.getElementById('dmSslModal').classList.remove('hidden');
    document.getElementById('dmSslActionLog').classList.add('hidden');
    await domainManagerLoadSslSettings();
  }

  function domainManagerCloseSsl() {
    if (document.getElementById('dmSslModal')) document.getElementById('dmSslModal').classList.add('hidden');
    domainManagerSslDomain = null;
  }

  async function domainManagerLoadSslSettings() {
    const acc = domainSelectedAccount();
    if (!acc || !domainManagerSslDomain) return;
    ['dmSslModeStatus', 'dmUniversalSslStatus', 'dmAlwaysHttpsStatus', 'dmHttpsRewriteStatus', 'dmMinTlsStatus'].forEach(id => { if (document.getElementById(id)) document.getElementById(id).textContent = 'Loading...'; });
    try {
      const res = await fetch(API_BASE_URL + '/api/domainManager/sslSettings', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email: acc.email, apiKey: acc.apiKey, accountId: acc.accountId, domainId: domainManagerSslDomain.id }) });
      const data = await res.json();
      if (!data.success) throw new Error(data.message || 'Gagal memuat SSL settings');
      const settings = data.settings || {};
      const sslMode = domainNormalizeSettingValue(settings.ssl) || '-';
      const minTls = domainNormalizeSettingValue(settings.min_tls_version) || '-';
      const universalEnabled = settings.universal_ssl && Object.prototype.hasOwnProperty.call(settings.universal_ssl, 'enabled') ? settings.universal_ssl.enabled : null;
      document.getElementById('dmSslModeStatus').textContent = domainBadgeText(sslMode);
      document.getElementById('dmUniversalSslStatus').textContent = universalEnabled === null ? '-' : (universalEnabled ? 'ON' : 'OFF');
      document.getElementById('dmAlwaysHttpsStatus').textContent = domainBadgeText(domainNormalizeSettingValue(settings.always_use_https));
      document.getElementById('dmHttpsRewriteStatus').textContent = domainBadgeText(domainNormalizeSettingValue(settings.automatic_https_rewrites));
      document.getElementById('dmMinTlsStatus').textContent = domainBadgeText(minTls);
      if (sslMode !== '-' && document.getElementById('dmSslModeSelect')) document.getElementById('dmSslModeSelect').value = sslMode;
      if (minTls !== '-' && document.getElementById('dmMinTlsSelect')) document.getElementById('dmMinTlsSelect').value = minTls;
    } catch (e) {
      domainSetSslLog('Gagal memuat SSL settings: ' + e.message);
      ['dmSslModeStatus', 'dmUniversalSslStatus', 'dmAlwaysHttpsStatus', 'dmHttpsRewriteStatus', 'dmMinTlsStatus'].forEach(id => { if (document.getElementById(id)) document.getElementById(id).textContent = 'Error'; });
    }
  }

  async function domainManagerUpdateSslSetting(setting, value) {
    const acc = domainSelectedAccount();
    if (!acc || !domainManagerSslDomain) throw new Error('Pilih account dan domain dulu.');
    const res = await fetch(API_BASE_URL + '/api/domainManager/sslUpdate', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email: acc.email, apiKey: acc.apiKey, accountId: acc.accountId, domainId: domainManagerSslDomain.id, setting, value }) });
    const data = await res.json();
    if (!data.success) throw new Error(data.message || 'Update SSL gagal');
    return data;
  }

  async function domainManagerSaveSslMode() {
    try {
      const value = document.getElementById('dmSslModeSelect').value;
      await domainManagerUpdateSslSetting('ssl', value);
      domainSetSslLog('SSL mode berhasil disimpan: ' + value.toUpperCase());
      await domainManagerLoadSslSettings();
      domainLog('SSL mode disimpan: ' + value.toUpperCase(), 'active');
    } catch (e) { alert('Gagal: ' + e.message); }
  }

  async function domainManagerSaveMinTls() {
    try {
      const value = document.getElementById('dmMinTlsSelect').value;
      await domainManagerUpdateSslSetting('min_tls_version', value);
      domainSetSslLog('Minimum TLS berhasil disimpan: ' + value);
      await domainManagerLoadSslSettings();
      domainLog('Minimum TLS disimpan: ' + value, 'active');
    } catch (e) { alert('Gagal: ' + e.message); }
  }

  async function domainManagerSetSslToggle(setting, value) {
    try {
      await domainManagerUpdateSslSetting(setting, value);
      domainSetSslLog(setting + ' berhasil diset ke ' + value.toUpperCase());
      await domainManagerLoadSslSettings();
      domainLog(setting + ' diset ke ' + value.toUpperCase(), 'active');
    } catch (e) { alert('Gagal: ' + e.message); }
  }

  async function domainManagerSetUniversal(enabled) {
    const acc = domainSelectedAccount();
    if (!acc || !domainManagerSslDomain) return alert('Pilih account dan domain dulu.');
    try {
      const res = await fetch(API_BASE_URL + '/api/domainManager/sslUniversal', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email: acc.email, apiKey: acc.apiKey, accountId: acc.accountId, domainId: domainManagerSslDomain.id, enabled }) });
      const data = await res.json();
      if (!data.success) throw new Error(data.message || 'Universal SSL update gagal');
      domainSetSslLog('Universal SSL berhasil diset ke ' + (enabled ? 'ON' : 'OFF'));
      await domainManagerLoadSslSettings();
      domainLog('Universal SSL ON untuk ' + domainManagerSslDomain.name, 'active');
    } catch (e) { alert('Gagal: ' + e.message); }
  }

  async function domainManagerActivateSsl() {
    const acc = domainSelectedAccount();
    if (!acc || !domainManagerSslDomain) return alert('Pilih account dan domain dulu.');
    const btn = document.getElementById('btnDmActivateSsl');
    const old = btn.innerHTML; btn.disabled = true; btn.innerHTML = '<i class="fa-solid fa-spinner fa-spin"></i> MENGAKTIFKAN...';
    domainSetSslLog('Menyalakan SSL Cloudflare...');
    try {
      const res = await fetch(API_BASE_URL + '/api/domainManager/sslActivate', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email: acc.email, apiKey: acc.apiKey, accountId: acc.accountId, domainId: domainManagerSslDomain.id }) });
      const data = await res.json();
      if (!data.success) throw new Error(data.message || 'Aktivasi SSL gagal');
      const lines = (data.results || []).map(r => (r.success ? 'OK' : 'FAIL') + ' - ' + r.label + ': ' + (r.success ? 'berhasil' : r.message));
      domainSetSslLog(lines.join('\\n'));
      await domainManagerLoadSslSettings();
      domainLog('Aktivasi SSL selesai untuk ' + domainManagerSslDomain.name, 'active');
    } catch (e) { alert('Gagal: ' + e.message); } 
    finally { btn.disabled = false; btn.innerHTML = old; }
  }

  async function domainManagerAddDomain() {
    const acc = domainSelectedAccount();
    const domainName = wildcardClean(document.getElementById('dmAddDomain').value);
    if (!acc) return alert('Pilih account dulu.');
    if (!domainName || domainName.indexOf('.') < 0) return alert('Isi domain valid, contoh: domain.com');
    const btn = document.getElementById('btnDomainAdd');
    const old = btn.innerHTML; btn.disabled = true; btn.innerHTML = '<i class="fa-solid fa-spinner fa-spin mr-2"></i>MENAMBAH...';
    try {
      const res = await fetch(API_BASE_URL + '/api/domainManager/add', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email: acc.email, apiKey: acc.apiKey, accountId: acc.accountId, domainName }) });
      const data = await res.json();
      if (!data.success) throw new Error(data.message || 'Gagal menambah domain');
      document.getElementById('dmAddDomain').value = '';
      domainLog('Berhasil menambah domain ' + domainName + '.', 'active');
      await domainManagerLoad();
    } catch (e) { alert('Gagal menambah domain: ' + e.message); } 
    finally { btn.disabled = false; btn.innerHTML = old; }
  }

  async function domainManagerDeleteDomain(domainId) {
    const acc = domainSelectedAccount();
    const domain = domainManagerDomains.find(d => d.id === domainId);
    if (!acc || !domain) return;
    if (!confirm('Hapus domain ' + domain.name + ' dari Cloudflare?')) return;
    try {
      const res = await fetch(API_BASE_URL + '/api/domainManager/delete', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email: acc.email, apiKey: acc.apiKey, accountId: acc.accountId, domainId }) });
      const data = await res.json();
      if (!data.success) throw new Error(data.message || 'Gagal hapus domain');
      domainLog('Domain dihapus: ' + domain.name, 'failed');
      await domainManagerLoad();
    } catch (e) { alert('Gagal hapus domain: ' + e.message); }
  }

  async function domainManagerSelectDomain(domainId) {
    const domain = domainManagerDomains.find(d => d.id === domainId);
    if (!domain) return;
    domainManagerSelected = domain;
    domainManagerRenderDomains();
    if (document.getElementById('dmDnsModal')) document.getElementById('dmDnsModal').classList.remove('hidden');
    domainManagerCloseAddDnsForm();
    domainManagerCloseBulkDnsForm();
    if (document.getElementById('dmDnsSearch')) document.getElementById('dmDnsSearch').value = '';
    await domainManagerLoadDns();
  }

  async function domainManagerLoadDns() {
    const acc = domainSelectedAccount();
    if (!acc || !domainManagerSelected) return;
    document.getElementById('dmSelectedTitle').textContent = 'DNS records for ' + domainManagerSelected.name;
    document.getElementById('dmDnsCount').textContent = 'loading...';
    document.getElementById('dmDnsList').innerHTML = '<tr><td colspan="6" class="px-4 py-10 text-center text-slate-500"><i class="fa-solid fa-circle-notch fa-spin text-xl text-blue-500 mb-2 block"></i> Loading DNS records...</td></tr>';
    try {
      const res = await fetch(API_BASE_URL + '/api/domainManager/dnsList', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email: acc.email, apiKey: acc.apiKey, accountId: acc.accountId, domainId: domainManagerSelected.id }) });
      const data = await res.json();
      if (!data.success) throw new Error(data.message || 'Gagal memuat DNS');
      domainManagerDnsRecords = data.records || [];
      domainManagerRenderDns(domainManagerDnsRecords);
      domainLog('DNS record dimuat untuk ' + domainManagerSelected.name + '.', 'active');
    } catch (e) {
      document.getElementById('dmDnsCount').textContent = 'error';
      document.getElementById('dmDnsList').innerHTML = '<tr><td colspan="6" class="px-4 py-10 text-center text-red-400">Gagal memuat DNS: ' + escapeHtml(e.message) + '</td></tr>';
    }
  }

  function domainManagerRenderDns(records) {
    const list = document.getElementById('dmDnsList'), count = document.getElementById('dmDnsCount');
    if (!list) return;
    records = records || [];
    if (count) count.textContent = records.length + ' records';
    if (!records.length) { list.innerHTML = '<tr><td colspan="6" class="px-4 py-10 text-center text-slate-500">No DNS records found.</td></tr>'; return; }
    list.innerHTML = records.map(r => {
      const proxyIcon = r.proxied ? '<i class="fa-brands fa-cloudflare text-orange-500 text-lg"></i> <span class="text-orange-500">Proxied</span>' : '<i class="fa-solid fa-arrow-turn-down text-slate-500"></i> <span class="text-slate-400">DNS only</span>';
      const ttlNum = Number(r.ttl || 1);
      const ttlText = ttlNum === 1 ? 'Auto' : (ttlNum >= 3600 ? (ttlNum / 3600) + ' hr' : (ttlNum / 60) + ' min');
      return '<tr class="hover:bg-[#161b22] transition-colors group">' +
        '<td class="px-4 py-3 font-mono text-xs text-white">' + escapeHtml(r.type || '') + '</td><td class="px-4 py-3 font-medium text-white">' + escapeHtml(r.name || '') + '</td><td class="px-4 py-3 font-mono text-xs text-slate-400 truncate max-w-[200px]" title="' + escapeHtml(r.content || '') + '">' + escapeHtml(r.content || '') + '</td><td class="px-4 py-3 text-xs flex items-center gap-1.5">' + proxyIcon + '</td><td class="px-4 py-3 text-xs text-slate-400">' + escapeHtml(ttlText) + '</td><td class="px-4 py-3 text-right"><button type="button" data-delete-record="' + escapeHtml(r.id || '') + '" data-record-name="' + escapeHtml(r.name || '') + '" class="text-slate-500 hover:text-red-500 transition-colors opacity-0 group-hover:opacity-100 px-2 py-1"><i class="fa-solid fa-trash-can"></i></button></td></tr>';
    }).join('');
  }

  function domainManagerFilterDns() {
    const q = String(document.getElementById('dmDnsSearch')?.value || '').toLowerCase();
    if (!q) return domainManagerRenderDns(domainManagerDnsRecords);
    domainManagerRenderDns(domainManagerDnsRecords.filter(r => String(r.name || '').toLowerCase().includes(q) || String(r.content || '').toLowerCase().includes(q) || String(r.type || '').toLowerCase().includes(q)));
  }

  async function domainManagerAddDns() {
    const acc = domainSelectedAccount();
    if (!acc || !domainManagerSelected) return alert('Pilih domain dulu.');
    const type = document.getElementById('dmDnsType').value, name = document.getElementById('dmDnsName').value, content = document.getElementById('dmDnsContent').value.trim(), proxied = document.getElementById('dmDnsProxied').checked, ttl = parseInt(document.getElementById('dmDnsTtl')?.value || '1', 10) || 1;
    if (!content) return alert('Isi target/content DNS dulu.');
    const btn = document.getElementById('btnDnsAdd');
    const old = btn.innerHTML; btn.disabled = true; btn.innerHTML = '<i class="fa-solid fa-spinner fa-spin"></i>';
    try {
      const res = await fetch(API_BASE_URL + '/api/domainManager/dnsAdd', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email: acc.email, apiKey: acc.apiKey, accountId: acc.accountId, domainId: domainManagerSelected.id, domainName: domainManagerSelected.name, type, name, content, proxied, ttl }) });
      const data = await res.json();
      if (!data.success) throw new Error(data.message || 'Gagal tambah DNS record');
      document.getElementById('dmDnsName').value = ''; document.getElementById('dmDnsContent').value = '';
      domainLog('DNS record berhasil ditambahkan.', 'active');
      domainManagerCloseAddDnsForm();
      await domainManagerLoadDns();
    } catch (e) { alert('Gagal tambah DNS: ' + e.message); } 
    finally { btn.disabled = false; btn.innerHTML = old; }
  }

  async function domainManagerDeleteDns(recordId, recordName) {
    const acc = domainSelectedAccount();
    if (!acc || !domainManagerSelected || !recordId) return;
    if (!confirm('Hapus DNS record' + (recordName ? ' untuk ' + recordName : ' ini') + '?')) return;
    try {
      const res = await fetch(API_BASE_URL + '/api/domainManager/dnsDelete', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email: acc.email, apiKey: acc.apiKey, accountId: acc.accountId, domainId: domainManagerSelected.id, recordId }) });
      const data = await res.json();
      if (!data.success) throw new Error(data.message || 'Gagal hapus DNS record');
      domainLog('DNS record dihapus.', 'failed');
      await domainManagerLoadDns();
    } catch (e) { alert('Gagal hapus DNS: ' + e.message); }
  }

  function wildcardLog(msg, tone) {
    const el = document.getElementById('wcLog');
    if (!el) return;
    if (el.dataset.ready !== '1') { el.dataset.ready = '1'; el.innerHTML = ''; }
    const d = new Date(); const t = String(d.getHours()).padStart(2,'0')+'.'+String(d.getMinutes()).padStart(2,'0')+'.'+String(d.getSeconds()).padStart(2,'0');
    let kind = tone || 'info';
    if(tone === 'failed' || /gagal|fatal|error/i.test(msg)) kind = 'failed';
    const styles = {
      active:  { box: 'border-emerald-500/30 bg-emerald-500/10 text-emerald-200', icon: 'fa-circle-check text-emerald-400', label: 'ACTIVE' },
      pending: { box: 'border-yellow-500/30 bg-yellow-500/10 text-yellow-100', icon: 'fa-clock text-yellow-300', label: 'PENDING' },
      failed:  { box: 'border-red-500/30 bg-red-500/10 text-red-100', icon: 'fa-circle-xmark text-red-400', label: 'FAILED' },
      info:    { box: 'border-sky-500/20 bg-sky-500/10 text-sky-100', icon: 'fa-circle-info text-sky-300', label: 'INFO' }
    };
    const st = styles[kind] || styles.info;
    el.innerHTML += '<div class="mb-2 rounded-xl border px-3 py-2 ' + st.box + '"><div class="flex items-start gap-2"><i class="fa-solid ' + st.icon + ' mt-0.5"></i><div class="min-w-0 flex-1"><div class="text-[9px] font-black uppercase opacity-80">[' + t + '] ' + st.label + '</div><div class="mt-1 break-words leading-relaxed">' + escapeHtml(msg) + '</div></div></div></div>';
    el.scrollTop = el.scrollHeight;
  }

  function wildcardToneFromResult(r) {
    const status = String((r && r.status) || '').toLowerCase();
    if (!r || r.success === false || r.error || /fail|error|blocked|invalid/i.test(status)) return 'failed';
    if (r.sslActive || /active|valid|issued|ready|success/i.test(status)) return 'active';
    if (/pending|initial|verify|not_found|unknown|listed/i.test(status)) return 'pending';
    return 'info';
  }

  function wildcardSslLabel(r) {
    const status = String((r && r.status) || 'unknown').toUpperCase();
    if (!r || r.success === false || r.error) return 'SSL FAILED';
    if (r.sslActive || status === 'ACTIVE') return 'SSL ACTIVE';
    return 'SSL PENDING';
  }

  function accountOptionsHtml() {
    let html = '<option value="">Pilih Account</option>';
    html += accounts.map((a, i) => '<option value="' + i + '">' + escapeHtml((a.email || ('Account ' + (i+1))) + (a.accountId ? ' · ' + a.accountId.slice(0, 8) : ' · ID kosong')) + '</option>').join('');
    return html;
  }

  function fillAccountSelect(id, preferredValue) {
    const sel = document.getElementById(id);
    if (!sel) return;
    const before = preferredValue !== undefined && preferredValue !== null ? String(preferredValue) : String(sel.value || '');
    sel.innerHTML = accountOptionsHtml();
    if (before && sel.querySelector('option[value="' + before.replace(/"/g, '\"') + '"]')) sel.value = before;
  }

  function fillAllAccountSelects() {
    fillAccountSelect('wcAccount'); fillAccountSelect('dmAccount'); fillAccountSelect('pmAccount');
  }

  function wildcardFillAccounts(preferredValue) { fillAccountSelect('wcAccount', preferredValue); }

  function showTab(tabName) {
    document.querySelectorAll('.tab-content').forEach(el => el.classList.remove('active'));
    document.querySelectorAll('[id^="btn-"]').forEach(btn => { btn.classList.remove('active-tab'); btn.classList.add('text-slate-500'); });
    if (document.getElementById('tab-' + tabName)) document.getElementById('tab-' + tabName).classList.add('active');
    if (document.getElementById('btn-' + tabName)) { document.getElementById('btn-' + tabName).classList.add('active-tab'); document.getElementById('btn-' + tabName).classList.remove('text-slate-500'); }
  }

  async function wildcardLoadResources() {
    wildcardFillAccounts(document.getElementById('wcAccount').value);
    const idx = document.getElementById('wcAccount').value;
    if (idx === '' || !accounts[idx]) return wildcardLog('Pilih account dulu.', 'pending');
    const acc = accounts[idx];
    if (!acc.accountId) return wildcardLog('Account ID kosong.', 'failed');
    wildcardLog('Load domain untuk ' + (acc.email || ('Account ' + (Number(idx)+1))) + '...', 'info');
    try {
      const res = await fetch(API_BASE_URL + '/api/wildcardSsl/resources', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email: acc.email, apiKey: acc.apiKey, accountId: acc.accountId }) });
      const data = await res.json();
      if (!data.success) throw new Error(data.message || 'Gagal load resource');
      document.getElementById('wcZone').innerHTML = '<option value="">Pilih Domain</option>' + (data.zones || []).map(z => '<option value="' + escapeHtml(z.id + '|' + z.name) + '">' + escapeHtml(z.name) + '</option>').join('');
      wildcardLog('Domain dimuat: ' + (data.zones || []).length + ' domain.', 'active');
      wildcardPreview();
    } catch (e) { wildcardLog('Gagal load domain: ' + e.message, 'failed'); }
  }

  function wildcardAutoWorkerName(baseHost) {
    return ('wc-' + (wildcardClean(baseHost).replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '') || 'domain')).slice(0, 63);
  }

  function wildcardClean(v) {
    v = String(v || '').trim().toLowerCase();
    if (v.indexOf('https://') === 0) v = v.slice(8);
    if (v.indexOf('http://') === 0) v = v.slice(7);
    const slash = v.indexOf('/');
    if (slash >= 0) v = v.slice(0, slash);
    v = v.replace(/\\s+/g, '');
    while (v.charAt(0) === '.') v = v.slice(1);
    while (v.charAt(v.length - 1) === '.') v = v.slice(0, -1);
    return v;
  }

  function wildcardBuildHostnames() {
    const zVal = document.getElementById('wcZone').value || '', zoneName = zVal.split('|')[1] || '', prefix = wildcardClean(document.getElementById('wcPrefix').value);
    let suffixRaw = document.getElementById('wcSuffix').value || '';
    const out = []; const seen = new Set();
    function push(h) { h = wildcardClean(h); if (h && !seen.has(h)) { seen.add(h); out.push(h); } }
    if (!zoneName) return out;
    const baseHost = (!prefix || prefix === '*' || prefix === '@') ? zoneName : ((prefix === zoneName || prefix.endsWith('.' + zoneName)) ? prefix : (prefix + '.' + zoneName));
    push(baseHost);
    function suffixToHostname(line) {
      line = wildcardClean(line);
      if (!line || line === '*') return baseHost;
      if (line.indexOf('*.') === 0) {
        const bare = wildcardClean(line.slice(2));
        if (!bare) return baseHost;
        return (bare === zoneName || bare.endsWith('.' + zoneName)) ? bare : (bare + '.' + baseHost);
      }
      return (line === zoneName || line.endsWith('.' + zoneName)) ? line : (line + '.' + baseHost);
    }
    suffixRaw.replace(/\\r/g, '\\n').replace(/[,;]/g, '\\n').split('\\n').forEach(line => {
      const hash = line.indexOf('#'); if (hash >= 0) line = line.slice(0, hash);
      line = wildcardClean(line); if (!line) return;
      push(suffixToHostname(line));
    });
    return out;
  }

  function wildcardBuildWorkerUrls() {
    const raw = document.getElementById('wcWorkerUrls') ? (document.getElementById('wcWorkerUrls').value || '') : '';
    const out = []; const seen = new Set();
    raw.replace(/\\r/g, '\\n').replace(/[,;]/g, '\\n').split('\\n').forEach(line => {
      const hash = line.indexOf('#'); if (hash >= 0) line = line.slice(0, hash);
      const h = wildcardClean(line); if (!h || h.indexOf('*.') === 0) return;
      if (!seen.has(h)) { seen.add(h); out.push(h); }
    });
    return out;
  }

  function wildcardAutoNodeCount(totalHosts, targetMode) {
    targetMode = String(targetMode || 'multi_failover').toLowerCase();
    if (targetMode === 'single') return 1;
    totalHosts = Math.max(1, parseInt(totalHosts || '1', 10) || 1);
    if (totalHosts <= 8) return 2; if (totalHosts <= 30) return 4; if (totalHosts <= 100) return 6;
    if (totalHosts <= 250) return 8; if (totalHosts <= 600) return 10; return 12;
  }

  function wildcardBuildWorkerNodes(baseHost) {
    const targetMode = document.getElementById('wcTargetMode') ? document.getElementById('wcTargetMode').value : 'multi_failover';
    const baseWorker = wildcardAutoWorkerName(baseHost || 'domain'), hosts = wildcardBuildHostnames(), nodeCount = wildcardAutoNodeCount(hosts.length || 1, targetMode);
    if (targetMode === 'single') return [baseWorker];
    const nodes = [];
    for (let i = 1; i <= nodeCount; i++) nodes.push((baseWorker + '-n' + String(i).padStart(2, '0')).slice(0, 63).replace(/-+$/g, ''));
    return nodes;
  }

  function wildcardPreview() {
    const box = document.getElementById('wcPreview');
    if (!box) return;
    const hosts = wildcardBuildHostnames();
    const zVal = document.getElementById('wcZone').value || '';
    const zoneName = zVal.split('|')[1] || '';
    if (!hosts.length || !zoneName) { box.textContent = 'Preview hostname akan muncul di sini.'; return; }
    const cleanPrefix = wildcardClean(document.getElementById('wcPrefix').value);
    const baseHost = (!cleanPrefix || cleanPrefix === '*' || cleanPrefix === '@') ? zoneName : ((cleanPrefix === zoneName || cleanPrefix.endsWith('.' + zoneName)) ? cleanPrefix : (cleanPrefix + '.' + zoneName));
    const engine = document.getElementById('wcEngine').value;

    if (engine === 'pages') {
      let customProj = document.getElementById('wcPagesProjectName').value.trim();
      const projName = customProj || ('ssl-' + baseHost).replace(/[^a-z0-9-]/g, '-').slice(0, 50);
      const note = '<div class="text-fuchsia-300 mb-2">Platform Engine: <b>Pages</b> | Project Target: <b class="text-white">' + escapeHtml(projName) + '</b></div>';
      const flowNote = '<div class="text-emerald-300 mb-2">Semua hostname di bawah akan disambungkan ke project Pages otomatis dan di-deploy script reverse proxy.</div>';
      const rows = hosts.slice(0,60).map((h,i) => '<div>' + (i+1) + '. ' + escapeHtml(h) + ' -> ' + escapeHtml(projName) + '.pages.dev</div>').join('');
      box.innerHTML = note + flowNote + rows + (hosts.length > 60 ? '<div>... +' + (hosts.length-60) + ' lainnya</div>' : '');
    } else {
      const targetMode = document.getElementById('wcTargetMode').value;
      const workerNodes = wildcardBuildWorkerNodes(baseHost);
      if (document.getElementById('wcAutoNodeCount')) document.getElementById('wcAutoNodeCount').textContent = String(workerNodes.length) + ' NODE';
      const workerUrls = wildcardBuildWorkerUrls();
      const displayTargets = workerUrls.length ? workerUrls : ['BELUM DIISI - Worker akan tampil status saja'];
      if (document.getElementById('wcAutoWorkerInfo')) document.getElementById('wcAutoWorkerInfo').innerHTML = 'Mode: <b>' + escapeHtml(targetMode) + '</b><br>Auto Worker Nodes: <b>' + escapeHtml(workerNodes.join(', ')) + '</b><br>WORKER_URLS: <b>' + escapeHtml(displayTargets.join(', ')) + '</b>';
      if (document.getElementById('wcAutoNodePreview')) document.getElementById('wcAutoNodePreview').innerHTML = workerNodes.map(escapeHtml).join('<br>');
      const orderNote = '<div class="text-yellow-300 mb-2">Urutan aman: domain utama otomatis masuk nomor 1 → baris suffix mengikuti. Tanda * opsional.</div>';
      const targetNote = '<div class="text-blue-300 mb-2">WORKER_URLS: ' + displayTargets.map(escapeHtml).join(', ') + '</div>';
      const flowNote = '<div class="text-emerald-300 mb-2">Worker Nodes: ' + workerNodes.map(escapeHtml).join(', ') + '</div><div class="text-slate-400 mb-2">Pembagian: suffix nomor 1 ke node 1, muter lagi sampai selesai.</div>';
      const rows = hosts.slice(0,60).map((h,i) => '<div>' + (i+1) + '. ' + escapeHtml(h) + ' → ' + escapeHtml(workerNodes[i % workerNodes.length] || '-') + '</div>').join('');
      box.innerHTML = orderNote + targetNote + flowNote + rows + (hosts.length > 60 ? '<div>... +' + (hosts.length-60) + ' lainnya</div>' : '');
    }
  }

  function wildcardProxyVisual() {
    const checked = document.getElementById('wcProxied').checked, track = document.getElementById('wcProxyTrack'), knob = document.getElementById('wcProxyKnob'), label = document.getElementById('wcProxyLabel');
    if (checked) { track.classList.add('bg-orange-500'); track.classList.remove('bg-slate-700'); knob.classList.add('translate-x-5'); label.innerHTML = '<i class="fa-solid fa-cloud text-orange-400 mr-2"></i>Proxied'; } 
    else { track.classList.remove('bg-orange-500'); track.classList.add('bg-slate-700'); knob.classList.remove('translate-x-5'); label.innerHTML = '<i class="fa-regular fa-cloud text-slate-400 mr-2"></i>DNS Only'; }
  }

  async function wildcardLoadTxt(input) {
    const file = input.files && input.files[0];
    if (!file) return;
    document.getElementById('wcSuffix').value = await file.text();
    wildcardPreview();
  }

  // --- FUNGSI BARU: AUTO FILL PAGES DARI WILDCARD ---
  function wildcardAutoFillTablePages() {
    const hosts = wildcardBuildHostnames();
    if (!hosts.length) return alert("Tidak ada domain yang di-generate. Pilih root domain dan isi suffix terlebih dahulu.");
    
    const textToAppend = hosts.join('\\n');
    const textarea = document.getElementById('pmDomains');
    if (textarea.value.trim() === '') textarea.value = textToAppend;
    else textarea.value += '\\n' + textToAppend;
    
    showTab('pagesmanager');
    pagesLog('Auto fill ' + hosts.length + ' domain dari Wildcard berhasil.', 'active');
  }

  async function wildcardRunBatched(mode, event) {
    if (mode !== 'attach' && mode !== 'check') return alert('Wildcard Manager hanya memakai CONNECT dan CEK SSL.');
    const idx = document.getElementById('wcAccount').value;
    if (idx === '' || !accounts[idx]) return alert('Pilih account dulu.');
    const zVal = document.getElementById('wcZone').value || '', zoneId = zVal.split('|')[0] || '', zoneName = zVal.split('|')[1] || '', prefix = document.getElementById('wcPrefix').value;
    const engine = document.getElementById('wcEngine').value;
    const targetMode = document.getElementById('wcTargetMode') ? document.getElementById('wcTargetMode').value : 'multi_failover';
    const cleanPrefix = wildcardClean(prefix);
    const baseHost = (!cleanPrefix || cleanPrefix === '*' || cleanPrefix === '@') ? zoneName : ((cleanPrefix === zoneName || cleanPrefix.endsWith('.' + zoneName)) ? cleanPrefix : (cleanPrefix + '.' + zoneName));

    const payloadBody = {
      email: accounts[idx].email, apiKey: accounts[idx].apiKey, accountId: accounts[idx].accountId,
      mode, engine, targetMode, zoneId, zoneName, prefix,
      proxied: document.getElementById('wcProxied').checked
    };

    const hosts = wildcardBuildHostnames();
    if (!hosts.length) return alert('Pilih root domain dulu.');
    payloadBody.hostnames = hosts;

    if (engine === 'pages') {
       let pName = document.getElementById('wcPagesProjectName').value.trim();
       if(!pName) pName = ('ssl-'+baseHost).replace(/[^a-z0-9-]/g, '-').slice(0, 50);
       payloadBody.pagesProjectName = pName;
       let scriptToDeploy = document.getElementById('wcPagesScript').value.trim();
       if(!scriptToDeploy) return alert('Script custom kosong!');
       payloadBody.pagesCustomScript = scriptToDeploy;
       if (mode === 'attach') wildcardLog('Mode Pages: Menyiapkan project (' + pName + ') dan proxy script...', 'info');
    } else {
       const workerUrls = wildcardBuildWorkerUrls();
       payloadBody.workerUrls = workerUrls.join(String.fromCharCode(10));
    }

    const btn = event && event.currentTarget;
    const old = btn ? btn.innerHTML : '';
    if (btn) { btn.disabled = true; btn.innerHTML = '<i class="fa-solid fa-spinner fa-spin mr-2"></i> EXECUTING...'; }

    try {
      const batchSize = 5;
      wildcardLog('Menjalankan mode ' + mode + ' untuk ' + hosts.length + ' hostname...', 'pending');
      for (let i = 0; i < hosts.length; i += batchSize) {
        const chunk = hosts.slice(i, i + batchSize);
        payloadBody.hostnames = chunk;
        payloadBody.offset = i;
        payloadBody.totalHostCount = hosts.length;
        payloadBody.deployWorkers = (i === 0);

        wildcardLog('Batch ' + (Math.floor(i / batchSize) + 1) + '/' + Math.ceil(hosts.length / batchSize) + ' berjalan...', 'pending');
        const res = await fetch('/api/wildcardSsl/bulk', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(payloadBody) });
        const data = await res.json();
        if (!data.success) throw new Error(data.message || 'Batch gagal dijalankan');
        (data.results || []).forEach(r => {
          let msg = (r.success ? 'OK' : 'FAIL') + ' - ' + r.hostname;
          if (r.actions && r.actions.length) msg += ' -> ' + r.actions.join(', ');
          if (r.error) msg += ' | ERROR: ' + r.error;
          let tone = r.success ? 'active' : 'failed';
          if(r.actions && r.actions.some(a => a.includes('failed'))) tone = 'failed';
          wildcardLog(msg, tone);
        });
        await new Promise(resolve => setTimeout(resolve, 800));
      }
      wildcardLog('Selesai eksekusi ' + mode + '.', 'active');
    } catch (e) {
      wildcardLog('FATAL ERROR: ' + e.message, 'failed');
    } finally {
      if (btn) { btn.disabled = false; btn.innerHTML = old; }
    }
  }
</script>
</body>
</html>`;
}

export default {
  async fetch(request) {
    const url = new URL(request.url);
    if (request.method === 'OPTIONS') return new Response(null, { headers: corsHeaders });
    if (url.pathname.startsWith('/api/')) return handleApiRequest(request);
    return new Response(renderHTML(), { headers: { 'Content-Type': 'text/html; charset=utf-8' } });
  }
};

════════════════════════════════════════════════════════════
ARCHIVE COMPLETE - 1 files exported
Location: Wc-multi/
Exported: 8/31/2026, 11:26:06 AM
Source: CodeHub Repository
════════════════════════════════════════════════════════════