Update app.py

app.py

@@ -1,195 +1,208 @@
 # -*- coding: utf-8 -*-
 """
-app.py — IPLM 2025 (STABLE, COPY-PASTE, HF Spaces)
-
-✅ IPLM Real:
-   - Rename indikator (alias -> kanonik)
-   - Yeo-Johnson per indikator + MinMax nasional (sekali)
-   - Subindeks (koleksi/sdm/pelayanan/pengelolaan)
-   - Dimensi (kepatuhan/kinerja)
-   - Indeks_Real_0_100
-
-✅ FINAL:
-   Indeks_Final_0_100 = Indeks_Real_0_100 × SamplingFactor_Total (Target 68%)
-
-✅ UI:
-   - Dropdown Provinsi / Kab-Kota / Kewenangan (Kab/Kota disable kalau PROVINSI)
-   - Label rapi (tidak jadi PROVINSIACEH)
-   - Provinsi/Kab key join stabil (Kep Seribu beres)
-   - Output lengkap:
-     1) Indeks Agregat (FINAL)
-     2) Agregat (FINAL) per Jenis
-     3) Detail (FINAL) per Unit
-     4) Agregat (RealScore) per Jenis (Subindeks & Dimensi)
-     5) Detail (RealScore) per Unit (Subindeks & Dimensi + Indikator raw)
-     6) Coverage Populasi vs Sampel (Target 68%) + BAR chart (dibuat TERBACA via HTML)
-     7) Bell curve per Jenis (RealScore) — seperti contoh kamu
-     8) Analisis (LLM opsional) + Word report opsional
-
-Catatan penting untuk kasus Kep. Seribu:
-- Coverage sekolah (SD+SMP) = 0 biasanya karena:
-  (a) kolom SD+SMP di meta kab/kota tidak terdeteksi, ATAU
-  (b) baris Kep Seribu tidak ada di meta, ATAU
-  (c) key join kab/kota tidak match.
-Kode ini memperkeras normalisasi & deteksi kolom meta.
+app.py — IPLM (Hitung Indeks) + Dashboard Kekurangan Sampel (Gap 68%) + Analisis AI (HF)
+======================================================================================
+TUJUAN (sesuai maumu):
+1) Tetap HITUNG IPLM (Yeo-Johnson + normalisasi nasional -> subindeks -> dimensi -> indeks 0–100)
+2) Tetap HITUNG GAP sampel (Target 68%) pakai meta populasi (SD+SMP, Kec+Desa, SMA)
+3) Analisis AI (LLM) + Word report pakai kode gap milikmu (tanpa bahas skor IPLM)
+4) FIX utama: "jumlah sekolah tidak kedetect" -> diperbaiki join meta dengan:
+   - KEY gabungan: prov_key + kab_key (lebih presisi)
+   - fallback: kab_key saja (kalau meta tidak punya prov)
+   - fallback-2: mapping alias kab/kota (opsional) + debug table "Meta_Match_Debug"
+
+PASTIKAN file ada di root HF Spaces:
+- IPLM_clean_manual_131225.xlsx
+- Data_populasi_Kab_kota.xlsx
+- Data_populasi_propinsi.xlsx
 """
 
 import os
 import re
 import math
-import json
 import tempfile
 from pathlib import Path
-from collections import Counter
 
+import gradio as gr
 import numpy as np
 import pandas as pd
-import gradio as gr
 import plotly.graph_objects as go
 import plotly.express as px
+from huggingface_hub import InferenceClient
 from sklearn.preprocessing import PowerTransformer
 
-# =========================
-# 0) FILES (SESUAIKAN)
-# =========================
-DATA_FILE       = "IPLM_clean_manual_131225.xlsx"
-META_KAB_FILE   = "Data_populasi_Kab_kota.xlsx"
-META_PROV_FILE  = "Data_populasi_propinsi.xlsx"
+# Word report
+from docx import Document
+
+# Pie opsional (butuh kaleido)
+try:
+    import kaleido  # noqa: F401
+    HAS_KALEIDO = True
+except Exception:
+    HAS_KALEIDO = False
 
-TARGET_FRAC = 0.68
 
-# Bobot dimensi IPLM (Real)
+# ============================================================
+# 0) FILES (SESUAIKAN)
+# ============================================================
+DATA_FILE     = "IPLM_clean_manual_131225.xlsx"  # DM sampel masuk (multi-sheet)
+META_KAB_FILE = "Data_populasi_Kab_kota.xlsx"    # populasi kab/kota (kec, desa, SD, SMP)
+META_SMA_FILE = "Data_populasi_propinsi.xlsx"    # populasi provinsi (SMA)
+
+# ============================================================
+# 0a) TARGET CAKUPAN
+# ============================================================
+TARGET_COVERAGE = 0.68
+
+# ============================================================
+# 0b) BOBOT IPLM (REAL)
+# ============================================================
 W_KEPATUHAN = 0.30
 W_KINERJA   = 0.70
 
-
-# =========================
-# 1) UTIL — string & kolom
-# =========================
-def make_unique_columns(cols):
-    """Hindari kolom duplikat agar df['X'] tidak menjadi DataFrame."""
-    seen = {}
-    out = []
-    for c in cols:
-        c0 = str(c).strip()
-        if c0 not in seen:
-            seen[c0] = 0
-            out.append(c0)
+# ============================================================
+# 0c) LLM (HF Inference)
+# ============================================================
+USE_LLM = True
+LLM_MODEL_NAME = "meta-llama/Meta-Llama-3-8B-Instruct"
+HF_TOKEN = (
+    os.getenv("HF_SECRET")
+    or os.getenv("HUGGINGFACEHUB_API_TOKEN")
+    or os.getenv("HF_API_TOKEN")
+)
+
+_HF_CLIENT = None
+def get_llm_client():
+    global _HF_CLIENT
+    if _HF_CLIENT is not None:
+        return _HF_CLIENT
+    try:
+        if HF_TOKEN:
+            _HF_CLIENT = InferenceClient(model=LLM_MODEL_NAME, token=HF_TOKEN)
         else:
-            seen[c0] += 1
-            out.append(f"{c0}__dup{seen[c0]}")
-    return out
-
-def canon(s: str) -> str:
-    return re.sub(r"[^a-z0-9]+", "", str(s).lower())
-
-def clean_spaces(s: str) -> str:
-    return re.sub(r"\s+", " ", str(s).strip())
-
-def pretty_admin_name(s: str, kind: str = "prov") -> str:
-    """
-    Display label manusiawi untuk dropdown.
-    - PROVINSI JAWA BARAT
-    - KOTA SURABAYA / KAB. BANDUNG
-    - KAB. ADM. KEPULAUAN SERIBU (tetap kebaca)
-    """
-    t = clean_spaces(str(s)).upper()
-    t = t.replace("PROPINSI", "PROVINSI")
-    t = re.sub(r"\bKABUPATEN\b", "KAB.", t)
-    t = re.sub(r"\bKOTA\s+ADMINISTRASI\b", "KOTA ADM.", t)
-    t = re.sub(r"\bKABUPATEN\s+ADMINISTRASI\b", "KAB. ADM.", t)
-    t = t.replace("ADMINISTRASI", "ADM.")
-    # rapikan spasi titik
-    t = re.sub(r"\s+\.", ".", t)
-    t = re.sub(r"\.\s+", ". ", t)
-
-    if kind == "prov":
-        # jika belum ada prefiks PROVINSI, tambahkan
-        if not t.startswith("PROVINSI "):
-            t = "PROVINSI " + t
-    return t
-
-def norm_key(x) -> str:
-    """
-    Key join prov/kab:
-    distabilkan supaya:
-    KEP. SERIBU == KEPULAUAN SERIBU == KAB. ADM. KEPULAUAN SERIBU
-    """
-    if pd.isna(x):
-        return ""
-    t = clean_spaces(str(x)).upper()
-
-    # normalisasi umum
-    t = t.replace("PROPINSI", "PROVINSI")
-    t = re.sub(r"\bKABUPATEN\b", "KAB.", t)
-    t = re.sub(r"\bKOTA\s+ADMINISTRASI\b", "KOTA ADM.", t)
-    t = re.sub(r"\bKABUPATEN\s+ADMINISTRASI\b", "KAB. ADM.", t)
-    t = t.replace("ADMINISTRASI", "ADM.")
-    t = t.replace("KEP.", "KEPULAUAN")
-    t = re.sub(r"\bKEP\b", "KEPULAUAN", t)
-
-    # khusus Kepulauan Seribu
-    if "SERIBU" in t:
-        t = "KAB. ADM. KEPULAUAN SERIBU"
+            _HF_CLIENT = InferenceClient(model=LLM_MODEL_NAME)
+        return _HF_CLIENT
+    except Exception:
+        _HF_CLIENT = None
+        return None
 
-    # buang non alnum utk key
-    return re.sub(r"[^A-Z0-9]", "", t)
 
-def norm_kew(v):
-    if pd.isna(v):
-        return ""
-    t = clean_spaces(v).upper()
-    if any(x in t for x in ["KAB", "KOTA", "KABUPATEN", "KAB/KOTA"]):
-        return "KAB/KOTA"
-    if any(x in t for x in ["PROV", "PROP", "PROVINSI", "PROPINSI"]):
-        return "PROVINSI"
-    if "PUSAT" in t or "NASIONAL" in t:
-        return "PUSAT"
-    return t
+# ============================================================
+# 1) UTIL
+# ============================================================
+def _canon(s: str) -> str:
+    return re.sub(r"[^a-z0-9]+", "", str(s).lower())
 
+def pick_col(df, candidates):
+    # exact
+    for c in candidates:
+        if c in df.columns:
+            return c
+    # canon exact
+    can_map = {_canon(c): c for c in df.columns}
+    for c in candidates:
+        k = _canon(c)
+        if k in can_map:
+            return can_map[k]
+    # contains fallback
+    for cc in df.columns:
+        ccc = _canon(cc)
+        for c in candidates:
+            if _canon(c) in ccc:
+                return cc
+    return None
 
-# =========================
-# 2) NUM COERCION (AMAN)
-# =========================
 def coerce_num(val):
-    # guard: kalau val bukan scalar (mis. Series) → ambil item pertama
-    if isinstance(val, (pd.Series, np.ndarray, list, tuple)):
-        if len(val) == 0:
-            return np.nan
-        val = val[0]
-
-    if val is None:
+    if pd.isna(val):
         return np.nan
-    if isinstance(val, (int, float, np.integer, np.floating)):
-        return float(val)
-
     t = str(val).strip()
-    if t == "" or t in {"-", "–", "—", "NA", "N/A", "nan", "None"}:
+    if t == "" or t in {"-", "–", "—"}:
         return np.nan
-
     t = t.replace("\u00a0", " ").replace("Rp", "").replace("%", "")
     t = re.sub(r"[^0-9,.\-]", "", t)
-
-    # 1.234.567,89 -> 1234567.89
     if t.count(".") > 1 and t.count(",") == 1:
         t = t.replace(".", "").replace(",", ".")
+    elif t.count(",") > 1 and t.count(".") == 1:
+        t = t.replace(",", "")
     elif t.count(",") == 1 and t.count(".") == 0:
         t = t.replace(",", ".")
     else:
         t = t.replace(",", "")
-
     try:
         return float(t)
     except Exception:
         return np.nan
 
-def minmax_norm(s: pd.Series) -> pd.Series:
-    x = pd.to_numeric(s, errors="coerce").astype(float)
-    mn = x.min(skipna=True)
-    mx = x.max(skipna=True)
-    if pd.isna(mn) or pd.isna(mx) or mx == mn:
-        return pd.Series(0.0, index=s.index)
-    return (x - mn) / (mx - mn)
+def norm_kew(v):
+    if pd.isna(v):
+        return None
+    t = str(v).strip().upper()
+    if "KAB" in t or "KOTA" in t:
+        return "KAB/KOTA"
+    if "PROV" in t:
+        return "PROVINSI"
+    if "PUSAT" in t or "NASIONAL" in t:
+        return "PUSAT"
+    return t
+
+def _norm_text(x):
+    if pd.isna(x):
+        return None
+    t = str(x).strip().upper()
+    return " ".join(t.split())
+
+def clean_prov_display(s):
+    if pd.isna(s):
+        return None
+    t = str(s).upper().strip()
+    t = " ".join(t.split())
+    while t.startswith("PROVINSI PROVINSI "):
+        t = t.replace("PROVINSI PROVINSI ", "PROVINSI ", 1)
+    t = t.replace("PROVINSI PROVINSI ", "PROVINSI ")
+    if not t.startswith("PROVINSI "):
+        t = "PROVINSI " + t
+    return t
+
+def clean_kab_display(s):
+    if pd.isna(s):
+        return None
+    t = str(s).upper().strip()
+    t = " ".join(t.split())
+    t = t.replace("KABUPATEN", "KAB.")
+    t = t.replace("KAB  ", "KAB. ")
+    t = t.replace("KOTA ADMINISTRASI", "KOTA")
+    t = t.replace("KOTA ADM.", "KOTA")
+    return t
+
+def norm_prov_label(s):
+    if pd.isna(s):
+        return None
+    t = str(s).upper()
+    for bad in ["PROVINSI", "PROPINSI"]:
+        t = t.replace(bad, "")
+    t = " ".join(t.split())
+    return re.sub(r"[^A-Z0-9]+", "", t)
+
+def norm_kab_label(s):
+    """
+    KEY join kab/kota super stabil (termasuk Kep Seribu)
+    """
+    if pd.isna(s):
+        return None
+    t = str(s).upper()
+    t = t.replace("KABUPATEN", "KAB")
+    t = t.replace("KAB.", "KAB")
+    t = t.replace("KAB  ", "KAB ")
+    t = t.replace("KOTA ADMINISTRASI", "KOTA")
+    t = t.replace("KOTA ADM.", "KOTA")
+    t = t.replace("KOTA.", "KOTA")
+    t = t.replace("KEP.", "KEPULAUAN")
+    t = t.replace("KEP ", "KEPULAUAN ")
+    # khusus Kepulauan Seribu
+    if "SERIBU" in t:
+        t = "KAB ADM KEPULAUAN SERIBU"
+    t = " ".join(t.split())
+    return re.sub(r"[^A-Z0-9]+", "", t)
 
 def ceil_int(x):
     try:
@@ -208,112 +221,46 @@ def sampling_factor(sample, target):
     except Exception:
         return 1.0
 
+def make_pie_plotly(num, den, title):
+    if not HAS_KALEIDO:
+        return None
+    if den is None or pd.isna(den) or den <= 0:
+        values = [0, 1]
+        labels = ["Terjangkau", "Belum Terjangkau"]
+    else:
+        num = 0 if pd.isna(num) else float(num)
+        den = float(den)
+        values = [max(num, 0), max(den - num, 0)]
+        labels = ["Terjangkau", "Belum Terjangkau"]
+    fig = px.pie(values=values, names=labels, title=title, hole=0.35)
+    tmp = tempfile.mktemp(suffix=".png")
+    try:
+        fig.write_image(tmp, scale=2)
+        return tmp
+    except Exception:
+        return None
 
-# =========================
-# 3) LOAD MULTISHEET DM
-# =========================
-def load_multisheet_excel(path: str) -> tuple[pd.DataFrame, list]:
-    fp = Path(path)
-    if not fp.exists():
-        raise FileNotFoundError(f"File tidak ditemukan: {path}")
-    xls = pd.ExcelFile(fp)
-    frames = []
-    for s in xls.sheet_names:
-        df = pd.read_excel(fp, sheet_name=s)
-        df.columns = make_unique_columns(df.columns)
-        frames.append(df)
-    out = pd.concat(frames, ignore_index=True, sort=False)
-    return out, list(xls.sheet_names)
-
-
-# =========================
-# 4) AUTO DETECT COLUMNS (DM & META)
-# =========================
-def pick_col(df: pd.DataFrame, candidates: list[str]) -> str | None:
-    cols = list(df.columns)
-    cmap = {canon(c): c for c in cols}
-    for cand in candidates:
-        key = canon(cand)
-        if key in cmap:
-            return cmap[key]
-    # fallback partial contains
-    for c in cols:
-        cc = canon(c)
-        for cand in candidates:
-            if canon(cand) in cc:
-                return c
-    return None
 
-def detect_dm_cols(df: pd.DataFrame) -> dict:
-    prov = pick_col(df, ["provinsi", "provinsi_asal", "provinsi asal", "prov"])
-    kab  = pick_col(df, ["kab_kota", "kab/kota", "kabupaten_kota", "kabupaten/kota", "kab kota", "kota", "kab"])
-    kew  = pick_col(df, ["kewenangan", "kew"])
-    jenis = pick_col(df, ["jenis_perpustakaan", "jenis perpustakaan", "jenis"])
-    subjenis = pick_col(df, ["sub_jenis_perpus", "subjenis", "sub_jenis", "sub jenis", "sub jenis perpus"])
-    nama = pick_col(df, ["nm_perpustakaan", "nama_perpustakaan", "nama perpus", "nama"])
-
-    missing = [k for k,v in {"prov":prov, "kab":kab, "kew":kew, "jenis":jenis, "nama":nama}.items() if v is None]
-    if missing:
-        raise KeyError(f"Kolom DM wajib tidak ketemu: {missing}. Cek header Excel DM kamu.")
-    return {"prov":prov, "kab":kab, "kew":kew, "jenis":jenis, "subjenis":subjenis, "nama":nama}
-
-def detect_meta_kab(df: pd.DataFrame) -> dict:
-    prov = pick_col(df, ["PROVINSI", "provinsi", "Provinsi"])
-    kab  = pick_col(df, ["KABUPATEN_KOTA", "kabupaten_kota", "KAB/KOTA", "kab/kota", "Kab/Kota", "KABKOTA", "KAB_KOTA"])
-
-    # 🔥 kandidat lebih luas (biar SD+SMP ketemu)
-    pop_sd_smp = pick_col(df, [
-        "TOTAL_SD_SMP", "total_sd_smp", "JUMLAH_SD_SMP", "SD_SMP", "TOTAL_SDSMP",
-        "SD+SMP", "SD SMP", "TOTAL SD SMP", "JML SD SMP", "JUMLAH SD SMP"
-    ])
-
-    pop_kec_desa = pick_col(df, [
-        "TOTAL_KEC_DESA", "total_kec_desa", "KEC_DESA", "TOTAL_KECAMATAN_DESA",
-        "KECAMATAN+DESA", "KEC+DESA", "KEC DESA", "TOTAL KEC DESA"
-    ])
-
-    col_kec  = pick_col(df, ["JUMLAH_KECAMATAN", "jumlah_kecamatan", "KECAMATAN", "JML_KEC", "JML KEC"])
-    col_desa = pick_col(df, ["JUMLAH_DESA_KEL", "jumlah_desa_kel", "DESA_KEL", "JML_DESA", "JUMLAH_DESA", "JUMLAH_KELURAHAN", "JML DESA", "JML KEL"])
-
-    if prov is None or kab is None:
-        raise KeyError("Meta Kab/Kota minimal harus punya kolom provinsi & kab/kota.")
-
-    return {"prov": prov, "kab": kab, "pop_sd_smp": pop_sd_smp, "pop_kec_desa": pop_kec_desa, "col_kec": col_kec, "col_desa": col_desa}
-
-def detect_meta_prov(df: pd.DataFrame) -> dict:
-    prov = pick_col(df, ["PROVINSI", "provinsi", "Provinsi"])
-    pop_sma = pick_col(df, ["TOTAL_SMA_SMK_SLB", "total_sma_smk_slb", "SMA_SMK_SLB", "TOTAL_SMA_SMK", "TOTAL_SMA", "SMA+SMK+SLB"])
-    if prov is None or pop_sma is None:
-        raise KeyError("Meta Provinsi minimal harus punya kolom PROVINSI & TOTAL_SMA_SMK_SLB (atau padanan).")
-    return {"prov": prov, "pop_sma": pop_sma}
-
-
-# =========================
-# 5) INDIKATOR IPLM (KANONIK) + ALIAS
-# =========================
+# ============================================================
+# 2) DEFINISI INDIKATOR IPLM (KANONIK)
+# ============================================================
 koleksi_cols = [
     "JudulTercetak","EksemplarTercetak","JudulElektronik","EksemplarElektronik",
     "TambahJudulTercetak","TambahEksemplarTercetak",
     "TambahJudulElektronik","TambahEksemplarElektronik",
     "KomitmenAnggaranKoleksi"
 ]
-sdm_cols = [
-    "TenagaKualifikasiIlmuPerpustakaan",
-    "TenagaFungsionalProfesional",
-    "TenagaPKB",
-    "AnggaranTenaga"
-]
+sdm_cols = ["TenagaKualifikasiIlmuPerpustakaan","TenagaFungsionalProfesional","TenagaPKB","AnggaranTenaga"]
 pelayanan_cols = [
     "PesertaBudayaBaca","PemustakaLuringDaring","PemustakaFasilitasTIK",
     "PemanfaatanJudulTercetak","PemanfaatanEksemplarTercetak",
     "PemanfaatanJudulElektronik","PemanfaatanEksemplarElektronik"
 ]
-pengelolaan_cols = [
-    "KegiatanBudayaBaca","KegiatanKerjasama","VariasiLayanan","Kebijakan","AnggaranLayanan"
-]
-all_indicators = koleksi_cols + sdm_cols + pelayanan_cols + pengelolaan_cols
+pengelolaan_cols = ["KegiatanBudayaBaca","KegiatanKerjasama","VariasiLayanan","Kebijakan","AnggaranLayanan"]
+ALL_IND = koleksi_cols + sdm_cols + pelayanan_cols + pengelolaan_cols
 
-alias_map_raw = {
+# alias (kolom DM kamu -> kanonik)
+ALIAS = {
     # koleksi
     "j_judul_koleksi_tercetak": "JudulTercetak",
     "j_eksemplar_koleksi_tercetak": "EksemplarTercetak",
@@ -324,14 +271,11 @@ alias_map_raw = {
     "tambah_judul_koleksi_digital": "TambahJudulElektronik",
     "tambah_eksemplar_koleksi_digital": "TambahEksemplarElektronik",
     "j_anggaran_koleksi": "KomitmenAnggaranKoleksi",
-    "komitmenanggarankoleksi": "KomitmenAnggaranKoleksi",
-
     # sdm
     "j_tenaga_ilmu_perpus": "TenagaKualifikasiIlmuPerpustakaan",
     "j_tenaga_nonilmu_perpus": "TenagaFungsionalProfesional",
     "j_tenaga_pkb": "TenagaPKB",
     "j_anggaran_diklat_perpus": "AnggaranTenaga",
-
     # pelayanan
     "j_peserta_budaya_baca": "PesertaBudayaBaca",
     "j_pemustaka_luring_daring": "PemustakaLuringDaring",
@@ -340,7 +284,6 @@ alias_map_raw = {
     "j_eksemplar_koleksi_tercetak_termanfaat": "PemanfaatanEksemplarTercetak",
     "j_judul_koleksi_digital_termanfaat": "PemanfaatanJudulElektronik",
     "j_eksemplar_koleksi_digital_termanfaat": "PemanfaatanEksemplarElektronik",
-
     # pengelolaan
     "j_kegiatan_budaya_baca_peningkatan_literasi": "KegiatanBudayaBaca",
     "j_kerjasama_pengembangan_perpus": "KegiatanKerjasama",
@@ -348,809 +291,860 @@ alias_map_raw = {
     "j_kebijakan_prosedur_pelayanan": "Kebijakan",
     "j_anggaran_peningkatan_pelayanan": "AnggaranLayanan",
 }
-alias_map = {canon(k): v for k,v in alias_map_raw.items()}
+ALIAS_CAN = {_canon(k): v for k, v in ALIAS.items()}
 
-def rename_indicators(df: pd.DataFrame) -> pd.DataFrame:
-    targets = set(all_indicators)
-    rename_map = {}
+def rename_to_canonical(df: pd.DataFrame) -> pd.DataFrame:
+    r = {}
     for c in df.columns:
-        cc = canon(c)
-        if cc in alias_map:
-            rename_map[c] = alias_map[cc]
+        cc = _canon(c)
+        if cc in ALIAS_CAN:
+            r[c] = ALIAS_CAN[cc]
         else:
-            for t in targets:
-                if cc == canon(t):
-                    rename_map[c] = t
+            # kalau sudah kanonik
+            for t in ALL_IND:
+                if cc == _canon(t):
+                    r[c] = t
                     break
-    if rename_map:
-        df = df.rename(columns=rename_map)
-    return df
+    return df.rename(columns=r) if r else df
 
 
-# =========================
-# 6) LOAD DATA (DM + META)
-# =========================
+# ============================================================
+# 3) LOAD DM (multi-sheet) + DETECT COLS
+# ============================================================
 DATA_INFO = ""
-WARNINGS = []
+df_all_raw = None
+
+meta_kab_df = None
+meta_sma_df = None
 
-df_dm_raw = None
-dm_cols = None
-dm_sheets = []
+prov_col_glob = None
+kab_col_glob = None
+kew_col_glob = None
+jenis_col_glob = None
+subjenis_col_glob = None
+nama_col_glob = None
 
-meta_kab = None
-meta_prov = None
+extra_info = []
 
 try:
-    df_dm_raw, dm_sheets = load_multisheet_excel(DATA_FILE)
-    dm_cols = detect_dm_cols(df_dm_raw)
-
-    # display label rapi
-    df_dm_raw[dm_cols["prov"]] = df_dm_raw[dm_cols["prov"]].astype(str).map(lambda x: pretty_admin_name(x, "prov"))
-    df_dm_raw[dm_cols["kab"]]  = df_dm_raw[dm_cols["kab"]].astype(str).map(lambda x: pretty_admin_name(x, "kab"))
-
-    df_dm_raw["KEW_NORM"] = df_dm_raw[dm_cols["kew"]].map(norm_kew)
-
-    # key join stabil
-    df_dm_raw["prov_key"] = df_dm_raw[dm_cols["prov"]].map(norm_key)
-    df_dm_raw["kab_key"]  = df_dm_raw[dm_cols["kab"]].map(norm_key)
-
-    def map_dataset(x):
-        t = str(x).upper() if not pd.isna(x) else ""
-        if "KHUSUS" in t:
-            return "khusus"
-        if "UMUM" in t or "DAERAH" in t:
-            return "umum"
-        if "SEKOLAH" in t:
-            return "sekolah"
-        if any(k in t for k in ["SMA","SMK","SLB","SMP","SD"]):
-            return "sekolah"
-        return "umum"
-
-    df_dm_raw["_dataset"] = df_dm_raw[dm_cols["jenis"]].map(map_dataset)
-
-    DATA_INFO = (
-        f"DM: <b>{DATA_FILE}</b> | Baris: <b>{len(df_dm_raw)}</b> | Kolom: <b>{len(df_dm_raw.columns)}</b> | Sheets: <b>{len(dm_sheets)}</b><br>"
-        f"Deteksi kolom: prov=<code>{dm_cols['prov']}</code>, kab=<code>{dm_cols['kab']}</code>, kew=<code>{dm_cols['kew']}</code>, "
-        f"jenis=<code>{dm_cols['jenis']}</code>, nama=<code>{dm_cols['nama']}</code>"
-        + (f", subjenis=<code>{dm_cols['subjenis']}</code>" if dm_cols.get("subjenis") else "")
-    )
+    fp = Path(DATA_FILE)
+    if not fp.exists():
+        raise FileNotFoundError(f"File tidak ditemukan: {DATA_FILE}")
+
+    xls = pd.ExcelFile(fp)
+    frames = [pd.read_excel(fp, sheet_name=s) for s in xls.sheet_names]
+    df_all_raw = pd.concat(frames, ignore_index=True, sort=False)
+
+    df_all_raw = rename_to_canonical(df_all_raw)
+
+    prov_col_glob  = pick_col(df_all_raw, ["provinsi", "Provinsi", "PROVINSI"])
+    kab_col_glob   = pick_col(df_all_raw, ["kab_kota", "kab/kota", "Kab/Kota", "KAB/KOTA", "kabupaten_kota", "kota"])
+    kew_col_glob   = pick_col(df_all_raw, ["kewenangan", "jenis_kewenangan", "Kewenangan", "KEWENANGAN"])
+    jenis_col_glob = pick_col(df_all_raw, ["jenis_perpustakaan", "JENIS_PERPUSTAKAAN", "Jenis Perpustakaan"])
+    subjenis_col_glob = pick_col(df_all_raw, ["sub_jenis_perpus", "Sub Jenis", "SubJenis", "subjenis", "jenjang"])
+    nama_col_glob  = pick_col(df_all_raw, ["nm_perpustakaan", "nama_perpustakaan", "nm_instansi_lembaga", "Nama Perpustakaan"])
+
+    if prov_col_glob is None or kab_col_glob is None or kew_col_glob is None or jenis_col_glob is None:
+        raise KeyError("Kolom minimum DM tidak lengkap (prov/kab/kew/jenis).")
+
+    df_all_raw["KEW_NORM"] = df_all_raw[kew_col_glob].apply(norm_kew)
+
+    val_map_jenis = {
+        "PERPUSTAKAAN SEKOLAH": "sekolah",
+        "SEKOLAH": "sekolah",
+        "PERPUSTAKAAN UMUM": "umum",
+        "UMUM": "umum",
+        "PERPUSTAKAAN DAERAH": "umum",
+        "PERPUSTAKAAN KHUSUS": "khusus",
+        "KHUSUS": "khusus",
+        "PERPUSTAKAAN PERGURUAN TINGGI": "khusus",
+        "PERGURUAN TINGGI": "khusus",
+    }
+    df_all_raw["_dataset"] = df_all_raw[jenis_col_glob].apply(_norm_text).map(val_map_jenis)
+
+    df_all_raw["prov_clean"] = df_all_raw[prov_col_glob].apply(clean_prov_display)
+    df_all_raw["kab_clean"]  = df_all_raw[kab_col_glob].apply(clean_kab_display)
+
+    # KEY gabungan untuk join meta (FIX utama)
+    df_all_raw["prov_key"] = df_all_raw["prov_clean"].apply(norm_prov_label)
+    df_all_raw["kab_key"]  = df_all_raw["kab_clean"].apply(norm_kab_label)
+
+    DATA_INFO = f"DM terbaca: **{DATA_FILE}** | baris: **{len(df_all_raw)}** | sheet: {len(xls.sheet_names)}"
 except Exception as e:
-    WARNINGS.append(f"⚠️ Gagal memuat DM: {repr(e)}")
+    df_all_raw = None
+    DATA_INFO = f"⚠️ Gagal memuat `{DATA_FILE}` | Error: `{e}`"
 
-# Meta Kab/Kota
-try:
-    if Path(META_KAB_FILE).exists():
-        mk = pd.read_excel(META_KAB_FILE)
-        mk.columns = make_unique_columns(mk.columns)
-        meta_kab_cols = detect_meta_kab(mk)
 
-        prov_c = meta_kab_cols["prov"]
-        kab_c  = meta_kab_cols["kab"]
+# ============================================================
+# 4) LOAD META (KAB/KOTA & SMA) — FIX JOIN DUA KEY + FALLBACK
+# ============================================================
+def load_meta_kab_kota(path: str) -> pd.DataFrame | None:
+    fp = Path(path)
+    if not fp.exists():
+        return None
+    m = pd.read_excel(fp)
 
-        mk[prov_c] = mk[prov_c].astype(str).map(lambda x: pretty_admin_name(x, "prov"))
-        mk[kab_c]  = mk[kab_c].astype(str).map(lambda x: pretty_admin_name(x, "kab"))
+    col_prov = pick_col(m, ["PROVINSI","Provinsi","provinsi","nama_provinsi","nm_provinsi"])
+    col_kab  = pick_col(m, ["KABUPATEN_KOTA","Kabupaten/Kota","Kab/Kota","KAB/KOTA","kabupaten_kota","kab/kota","Kab_Kota"])
 
-        mk["prov_key"] = mk[prov_c].map(norm_key)
-        mk["kab_key"]  = mk[kab_c].map(norm_key)
+    col_kec  = pick_col(m, ["Jml Kec","JML KEC","Jml Kecamatan","Jumlah Kecamatan","Kecamatan","jumlah_kecamatan","jml_kecamatan"])
+    col_des  = pick_col(m, ["Jml Desa","JML DESA","Jml Desa/Kel","Jumlah Desa","Desa/Kel","jumlah_desa","jumlah_kelurahan"])
 
-        # POP_SD_SMP
-        if meta_kab_cols["pop_sd_smp"]:
-            mk["POP_SD_SMP"] = mk[meta_kab_cols["pop_sd_smp"]].map(coerce_num).fillna(0)
-        else:
-            mk["POP_SD_SMP"] = 0
+    col_sd   = pick_col(m, ["SD","Jumlah SD","Total SD","Jml_SD","jml_sd","jumlah_sd","SD_Total"])
+    col_smp  = pick_col(m, ["SMP","Jumlah SMP","Total SMP","Jml_SMP","jml_smp","jumlah_smp","SMP_Total"])
 
-        # POP_KEC_DESA
-        if meta_kab_cols["pop_kec_desa"]:
-            mk["POP_KEC_DESA"] = mk[meta_kab_cols["pop_kec_desa"]].map(coerce_num).fillna(0)
-        else:
-            kec = mk[meta_kab_cols["col_kec"]].map(coerce_num).fillna(0) if meta_kab_cols["col_kec"] else pd.Series(0, index=mk.index)
-            desa = mk[meta_kab_cols["col_desa"]].map(coerce_num).fillna(0) if meta_kab_cols["col_desa"] else pd.Series(0, index=mk.index)
-            mk["POP_KEC_DESA"] = (kec + desa).fillna(0)
+    col_pop_umum    = pick_col(m, ["jumlah_populasi_umum","Populasi Umum","pop_umum"])
+    col_pop_sekolah = pick_col(m, ["jumlah_populasi_sekolah","Populasi Sekolah","pop_sekolah"])
 
-        meta_kab = (mk.groupby(["prov_key","kab_key"], as_index=False)
-                      .agg({prov_c:"first", kab_c:"first", "POP_SD_SMP":"sum", "POP_KEC_DESA":"sum"}))
+    if col_kab is None:
+        return None
 
-        # DEBUG SERIBU (biar kamu langsung lihat ada/tidak)
-        ser = meta_kab[meta_kab["kab_key"].str.contains("SERIBU", na=False)]
-        DATA_INFO += f"<br>Meta Kab/Kota: <b>{META_KAB_FILE}</b> (n={len(meta_kab)})"
-        DATA_INFO += f"<br><b>DEBUG Kep Seribu meta rows:</b> {len(ser)}"
-    else:
-        WARNINGS.append("⚠️ Meta Kab/Kota file tidak ditemukan (skip).")
-except Exception as e:
-    meta_kab = None
-    WARNINGS.append(f"⚠️ Meta Kab/Kota tidak aktif: {repr(e)}")
+    out = pd.DataFrame()
+    out["prov_meta_raw"] = m[col_prov].astype(str).str.strip() if col_prov else None
+    out["kab_meta_raw"]  = m[col_kab].astype(str).str.strip()
 
-# Meta Provinsi
-try:
-    if Path(META_PROV_FILE).exists():
-        mp = pd.read_excel(META_PROV_FILE)
-        mp.columns = make_unique_columns(mp.columns)
-        meta_prov_cols = detect_meta_prov(mp)
+    # tampil & key
+    out["prov_meta_clean"] = out["prov_meta_raw"].apply(clean_prov_display) if col_prov else None
+    out["kab_meta_clean"]  = out["kab_meta_raw"].apply(clean_kab_display)
+
+    out["prov_key"] = out["prov_meta_clean"].apply(norm_prov_label) if col_prov else ""
+    out["kab_key"]  = out["kab_meta_clean"].apply(norm_kab_label)
+
+    out["Kab_Kota_Label"] = out["kab_meta_clean"]
+
+    out["Jml_Kecamatan"] = m[col_kec].apply(coerce_num) if col_kec else np.nan
+    out["Jml_DesaKel"]   = m[col_des].apply(coerce_num) if col_des else np.nan
+    out["Jml_SD"]        = m[col_sd].apply(coerce_num) if col_sd else np.nan
+    out["Jml_SMP"]       = m[col_smp].apply(coerce_num) if col_smp else np.nan
+
+    out["Pop_Umum_Meta"]    = m[col_pop_umum].apply(coerce_num) if col_pop_umum else np.nan
+    out["Pop_Sekolah_Meta"] = m[col_pop_sekolah].apply(coerce_num) if col_pop_sekolah else np.nan
+
+    # agregat gabungan prov+kab
+    grp_pk = out.groupby(["prov_key","kab_key"], as_index=False).agg({
+        "Kab_Kota_Label":"first",
+        "Jml_Kecamatan":"max",
+        "Jml_DesaKel":"max",
+        "Jml_SD":"max",
+        "Jml_SMP":"max",
+        "Pop_Umum_Meta":"max",
+        "Pop_Sekolah_Meta":"max",
+    })
 
-        prov_c = meta_prov_cols["prov"]
-        pop_c  = meta_prov_cols["pop_sma"]
+    # fallback kab-only
+    grp_k = out.groupby(["kab_key"], as_index=False).agg({
+        "Kab_Kota_Label":"first",
+        "Jml_Kecamatan":"max",
+        "Jml_DesaKel":"max",
+        "Jml_SD":"max",
+        "Jml_SMP":"max",
+        "Pop_Umum_Meta":"max",
+        "Pop_Sekolah_Meta":"max",
+    }).rename(columns={
+        "Kab_Kota_Label":"Kab_Kota_Label_kabonly",
+        "Jml_Kecamatan":"Jml_Kecamatan_kabonly",
+        "Jml_DesaKel":"Jml_DesaKel_kabonly",
+        "Jml_SD":"Jml_SD_kabonly",
+        "Jml_SMP":"Jml_SMP_kabonly",
+        "Pop_Umum_Meta":"Pop_Umum_Meta_kabonly",
+        "Pop_Sekolah_Meta":"Pop_Sekolah_Meta_kabonly",
+    })
+
+    merged = grp_pk.merge(grp_k, on="kab_key", how="left")
+
+    def fill0(a, b):
+        aa = pd.to_numeric(a, errors="coerce")
+        bb = pd.to_numeric(b, errors="coerce")
+        return aa.where(aa.notna() & (aa > 0), bb)
+
+    merged["Jml_SD"] = fill0(merged["Jml_SD"], merged["Jml_SD_kabonly"])
+    merged["Jml_SMP"] = fill0(merged["Jml_SMP"], merged["Jml_SMP_kabonly"])
+    merged["Jml_Kecamatan"] = fill0(merged["Jml_Kecamatan"], merged["Jml_Kecamatan_kabonly"])
+    merged["Jml_DesaKel"] = fill0(merged["Jml_DesaKel"], merged["Jml_DesaKel_kabonly"])
+    merged["Pop_Umum_Meta"] = fill0(merged["Pop_Umum_Meta"], merged["Pop_Umum_Meta_kabonly"])
+    merged["Pop_Sekolah_Meta"] = fill0(merged["Pop_Sekolah_Meta"], merged["Pop_Sekolah_Meta_kabonly"])
+
+    # label final
+    merged["Kab_Kota_Label"] = merged["Kab_Kota_Label"].fillna(merged["Kab_Kota_Label_kabonly"])
+
+    drop_cols = [c for c in merged.columns if c.endswith("_kabonly")]
+    merged = merged.drop(columns=drop_cols)
+
+    return merged
+
+def load_meta_sma(path: str) -> pd.DataFrame | None:
+    fp = Path(path)
+    if not fp.exists():
+        return None
+    m = pd.read_excel(fp)
+
+    col_prov = pick_col(m, ["Provinsi","provinsi","PROVINSI","NAMA_PROVINSI","Nama Provinsi","nm_prov"])
+    col_sma  = pick_col(m, ["sma ","SMA","Total SMA","TOTAL_SMA","Jml_SMA","Jumlah SMA","jumlah_sma","total_sma","jml_sma"])
+
+    if col_prov is None or col_sma is None:
+        return None
 
-        mp[prov_c] = mp[prov_c].astype(str).map(lambda x: pretty_admin_name(x, "prov"))
-        mp["prov_key"] = mp[prov_c].map(norm_key)
-        mp["POP_SMA_SMK_SLB"] = mp[pop_c].map(coerce_num).fillna(0)
+    out = pd.DataFrame({
+        "Provinsi_Label": m[col_prov].astype(str).str.strip(),
+        "Jml_SMA": m[col_sma].apply(coerce_num),
+    })
+    out["prov_key"] = out["Provinsi_Label"].apply(norm_prov_label)
+    out = out.groupby("prov_key", as_index=False).agg({"Provinsi_Label":"first","Jml_SMA":"sum"})
+    return out
 
-        meta_prov = (mp.groupby("prov_key", as_index=False)
-                       .agg({prov_c:"first", "POP_SMA_SMK_SLB":"sum"}))
-        DATA_INFO += f"<br>Meta Provinsi: <b>{META_PROV_FILE}</b> (n={len(meta_prov)})"
+try:
+    meta_kab_df = load_meta_kab_kota(META_KAB_FILE)
+    if meta_kab_df is not None:
+        extra_info.append(f"Meta Kab/Kota terbaca: **{META_KAB_FILE}** (n={len(meta_kab_df)})")
     else:
-        WARNINGS.append("⚠️ Meta Provinsi file tidak ditemukan (skip).")
+        extra_info.append(f"⚠️ Meta Kab/Kota tidak terbaca / kolom tidak ditemukan.")
+
+    meta_sma_df = load_meta_sma(META_SMA_FILE)
+    if meta_sma_df is not None:
+        extra_info.append(f"Meta SMA terbaca: **{META_SMA_FILE}** (n={len(meta_sma_df)})")
+    else:
+        extra_info.append(f"⚠️ Meta SMA tidak terbaca / kolom tidak ditemukan.")
 except Exception as e:
-    meta_prov = None
-    WARNINGS.append(f"⚠️ Meta Provinsi tidak aktif: {repr(e)}")
+    extra_info.append(f"⚠️ Gagal load meta: {e}")
+
+if extra_info:
+    DATA_INFO = DATA_INFO + "<br>" + "<br>".join(extra_info)
+
 
-if WARNINGS:
-    DATA_INFO += "<br>" + "<br>".join(WARNINGS)
+# ============================================================
+# 5) HITUNG IPLM (REAL) — YJ + minmax nasional
+# ============================================================
+def minmax01(s: pd.Series) -> pd.Series:
+    x = pd.to_numeric(s, errors="coerce").astype(float)
+    mn = x.min(skipna=True)
+    mx = x.max(skipna=True)
+    if pd.isna(mn) or pd.isna(mx) or mx == mn:
+        return pd.Series(0.0, index=s.index)
+    return (x - mn) / (mx - mn)
 
+def mean_row_norm(df: pd.DataFrame, cols_norm: list[str]) -> pd.Series:
+    return df[cols_norm].mean(axis=1, skipna=True)
 
-# =========================
-# 7) IPLM REAL (NASIONAL)
-# =========================
-def prepare_global_iplm(df_src: pd.DataFrame) -> pd.DataFrame:
-    df = df_src.copy()
-    df = rename_indicators(df)
+def compute_iplm_real(df: pd.DataFrame) -> pd.DataFrame:
+    out = df.copy()
 
-    available = [c for c in all_indicators if c in df.columns]
-    for c in available:
-        df[c] = df[c].map(coerce_num)
+    # pastikan indikator numeric
+    avail = [c for c in ALL_IND if c in out.columns]
+    for c in avail:
+        out[c] = out[c].apply(coerce_num)
 
-    # YJ + minmax
-    for c in available:
-        x = df[c].astype(float).to_numpy()
-        mask = ~np.isnan(x)
+    # transform Yeo-Johnson tiap indikator -> yj_*
+    for c in avail:
+        x = out[c].to_numpy(dtype=float)
+        m = ~np.isnan(x)
         y = np.full_like(x, np.nan, dtype=float)
-        if mask.sum() > 1:
+        if m.sum() > 1:
             pt = PowerTransformer(method="yeo-johnson", standardize=False)
-            y[mask] = pt.fit_transform(x[mask].reshape(-1,1)).ravel()
+            y[m] = pt.fit_transform(x[m].reshape(-1, 1)).ravel()
         else:
-            y[mask] = x[mask]
-        df[f"yj_{c}"] = y
-        df[f"norm_{c}"] = minmax_norm(pd.Series(df[f"yj_{c}"])).to_numpy()
-
-    def mean_norm(row, cols):
-        vals = []
-        for c in cols:
-            nc = f"norm_{c}"
-            if nc in row and pd.notna(row[nc]):
-                vals.append(float(row[nc]))
-        return float(np.mean(vals)) if vals else np.nan
-
-    k_cols = [c for c in koleksi_cols if c in available]
-    s_cols = [c for c in sdm_cols if c in available]
-    p_cols = [c for c in pelayanan_cols if c in available]
-    g_cols = [c for c in pengelolaan_cols if c in available]
-
-    df["sub_koleksi"]     = df.apply(lambda r: mean_norm(r, k_cols), axis=1)
-    df["sub_sdm"]         = df.apply(lambda r: mean_norm(r, s_cols), axis=1)
-    df["sub_pelayanan"]   = df.apply(lambda r: mean_norm(r, p_cols), axis=1)
-    df["sub_pengelolaan"] = df.apply(lambda r: mean_norm(r, g_cols), axis=1)
-
-    df["dim_kepatuhan"] = df[["sub_koleksi","sub_sdm"]].mean(axis=1, skipna=True).fillna(0.0)
-    df["dim_kinerja"]   = df[["sub_pelayanan","sub_pengelolaan"]].mean(axis=1, skipna=True).fillna(0.0)
-
-    df["Indeks_Real_0_100"] = 100.0 * (W_KEPATUHAN*df["dim_kepatuhan"] + W_KINERJA*df["dim_kinerja"])
-    return df
-
-df_iplm = None
-if df_dm_raw is not None and len(df_dm_raw) > 0:
-    df_iplm = prepare_global_iplm(df_dm_raw)
-
-
-# =========================
-# 8) SAMPLING FACTOR (68%)
-# =========================
-def detect_school_menengah(df: pd.DataFrame) -> pd.Series:
-    if dm_cols.get("subjenis") and dm_cols["subjenis"] in df.columns:
-        t = df[dm_cols["subjenis"]].astype(str).str.upper()
-    else:
-        t = df[dm_cols["jenis"]].astype(str).str.upper()
-    return t.str.contains(r"\bSMA\b|\bSMK\b|\bSLB\b", na=False)
+            y[m] = x[m]
+        out[f"yj_{c}"] = y
+        out[f"norm_{c}"] = minmax01(pd.Series(out[f"yj_{c}"])).to_numpy()
+
+    def norm_list(cols):
+        return [f"norm_{c}" for c in cols if f"norm_{c}" in out.columns]
+
+    nk = norm_list(koleksi_cols)
+    ns = norm_list(sdm_cols)
+    npel = norm_list(pelayanan_cols)
+    npeng = norm_list(pengelolaan_cols)
+
+    out["sub_koleksi"]     = mean_row_norm(out, nk).fillna(0.0)
+    out["sub_sdm"]         = mean_row_norm(out, ns).fillna(0.0)
+    out["sub_pelayanan"]   = mean_row_norm(out, npel).fillna(0.0)
+    out["sub_pengelolaan"] = mean_row_norm(out, npeng).fillna(0.0)
+
+    out["dim_kepatuhan"] = out[["sub_koleksi","sub_sdm"]].mean(axis=1, skipna=True).fillna(0.0)
+    out["dim_kinerja"]   = out[["sub_pelayanan","sub_pengelolaan"]].mean(axis=1, skipna=True).fillna(0.0)
+
+    out["Indeks_Real_0_100"] = 100.0 * (W_KEPATUHAN*out["dim_kepatuhan"] + W_KINERJA*out["dim_kinerja"])
+    return out
 
-def apply_sampling_factor(df: pd.DataFrame) -> pd.DataFrame:
+
+# ============================================================
+# 6) SAMPLING FACTOR (68%) UNTUK IPLM FINAL (REAL * factor)
+# ============================================================
+def attach_sampling_factor(df: pd.DataFrame) -> tuple[pd.DataFrame, pd.DataFrame]:
+    """
+    Output:
+      - df dengan kolom: Target_Unit_68, SamplingFactor_68, Indeks_Final_0_100
+      - debug table: Meta_Match_Debug (buat cek wilayah yg SD/SMP 0 / gak match meta)
+    """
     out = df.copy()
-    out["SamplingFactor_Total"] = 1.0
-
-    # KAB/KOTA: sekolah=SD+SMP; umum=KEC+DESA
-    if meta_kab is not None and len(meta_kab) > 0:
-        kab_part = out[out["KEW_NORM"] == "KAB/KOTA"].copy()
-        if not kab_part.empty:
-            g = (kab_part.groupby(["prov_key","kab_key","_dataset"])
-                         .size().unstack(fill_value=0).reset_index())
+    out["Target_Unit_68"] = np.nan
+    out["SamplingFactor_68"] = 1.0
+
+    debug_rows = []
+
+    # ----------- KAB/KOTA (sekolah & umum) -----------
+    if meta_kab_df is not None and len(meta_kab_df) > 0:
+        m = out["KEW_NORM"] == "KAB/KOTA"
+        kab = out[m].copy()
+        if not kab.empty:
+            # hitung sampel per prov+kab per dataset
+            g = (kab.groupby(["prov_key","kab_key","_dataset"]).size()
+                    .unstack(fill_value=0).reset_index())
             for c in ["sekolah","umum","khusus"]:
                 if c not in g.columns:
                     g[c] = 0
 
-            merged = g.merge(meta_kab[["prov_key","kab_key","POP_SD_SMP","POP_KEC_DESA"]],
-                             on=["prov_key","kab_key"], how="left")
+            merged = g.merge(meta_kab_df, on=["prov_key","kab_key"], how="left", suffixes=("","_meta"))
+
+            # POP sekolah = SD+SMP fallback Pop_Sekolah_Meta
+            sd = pd.to_numeric(merged.get("Jml_SD"), errors="coerce").fillna(0)
+            smp = pd.to_numeric(merged.get("Jml_SMP"), errors="coerce").fillna(0)
+            pop_sek = sd + smp
+            pop_sek = pop_sek.where(pop_sek > 0, pd.to_numeric(merged.get("Pop_Sekolah_Meta"), errors="coerce").fillna(0))
+            merged["POP_SD_SMP"] = pop_sek
 
-            merged["POP_SD_SMP"] = pd.to_numeric(merged["POP_SD_SMP"], errors="coerce").fillna(0)
-            merged["POP_KEC_DESA"] = pd.to_numeric(merged["POP_KEC_DESA"], errors="coerce").fillna(0)
+            # POP umum = Kec+Desa fallback Pop_Umum_Meta
+            kec = pd.to_numeric(merged.get("Jml_Kecamatan"), errors="coerce").fillna(0)
+            desa = pd.to_numeric(merged.get("Jml_DesaKel"), errors="coerce").fillna(0)
+            pop_um = kec + desa
+            pop_um = pop_um.where(pop_um > 0, pd.to_numeric(merged.get("Pop_Umum_Meta"), errors="coerce").fillna(0))
+            merged["POP_KEC_DESA"] = pop_um
 
-            merged["target_sd_smp_68"] = merged["POP_SD_SMP"].map(lambda x: ceil_int(TARGET_FRAC*x))
-            merged["target_kec_desa_68"] = merged["POP_KEC_DESA"].map(lambda x: ceil_int(TARGET_FRAC*x))
+            merged["Target_Sekolah_68"] = merged["POP_SD_SMP"].apply(lambda x: ceil_int(TARGET_COVERAGE * float(x)))
+            merged["Target_Umum_68"]    = merged["POP_KEC_DESA"].apply(lambda x: ceil_int(TARGET_COVERAGE * float(x)))
 
-            merged["sf_sekolah"] = merged.apply(lambda r: sampling_factor(r["sekolah"], r["target_sd_smp_68"]), axis=1)
-            merged["sf_umum"]    = merged.apply(lambda r: sampling_factor(r["umum"], r["target_kec_desa_68"]), axis=1)
+            merged["SF_Sekolah"] = merged.apply(lambda r: sampling_factor(r["sekolah"], r["Target_Sekolah_68"]), axis=1)
+            merged["SF_Umum"]    = merged.apply(lambda r: sampling_factor(r["umum"], r["Target_Umum_68"]), axis=1)
 
-            fmap = {}
+            # map faktor ke baris DM
+            sf_map = {}
+            tgt_map = {}
             for _, r in merged.iterrows():
-                fmap[(r["prov_key"], r["kab_key"], "sekolah")] = float(r["sf_sekolah"])
-                fmap[(r["prov_key"], r["kab_key"], "umum")]    = float(r["sf_umum"])
-                fmap[(r["prov_key"], r["kab_key"], "khusus")]  = 1.0
-
-            m = out["KEW_NORM"] == "KAB/KOTA"
-            out.loc[m, "SamplingFactor_Total"] = [
-                fmap.get((pk, kk, ds), 1.0)
-                for pk, kk, ds in zip(out.loc[m,"prov_key"], out.loc[m,"kab_key"], out.loc[m,"_dataset"])
+                sf_map[(r["prov_key"], r["kab_key"], "sekolah")] = float(r["SF_Sekolah"])
+                sf_map[(r["prov_key"], r["kab_key"], "umum")]    = float(r["SF_Umum"])
+                sf_map[(r["prov_key"], r["kab_key"], "khusus")]  = 1.0
+
+                tgt_map[(r["prov_key"], r["kab_key"], "sekolah")] = float(r["Target_Sekolah_68"])
+                tgt_map[(r["prov_key"], r["kab_key"], "umum")]    = float(r["Target_Umum_68"])
+                tgt_map[(r["prov_key"], r["kab_key"], "khusus")]  = np.nan
+
+                debug_rows.append({
+                    "prov_key": r["prov_key"],
+                    "kab_key": r["kab_key"],
+                    "Kab_Kota_Label_meta": r.get("Kab_Kota_Label", None),
+                    "sampel_sekolah": int(r["sekolah"]),
+                    "sd": float(sd.loc[r.name]) if r.name in sd.index else np.nan,
+                    "smp": float(smp.loc[r.name]) if r.name in smp.index else np.nan,
+                    "pop_sd_smp": float(r["POP_SD_SMP"]),
+                    "target_sekolah_68": int(r["Target_Sekolah_68"]),
+                    "meta_match": "MATCH" if pd.notna(r.get("Kab_Kota_Label", np.nan)) else "NO_META_ROW",
+                    "flag_pop0": float(r["POP_SD_SMP"]) <= 0
+                })
+
+            idx = out[m].index
+            out.loc[idx, "SamplingFactor_68"] = [
+                sf_map.get((pk, kk, ds), 1.0)
+                for pk, kk, ds in zip(out.loc[idx,"prov_key"], out.loc[idx,"kab_key"], out.loc[idx,"_dataset"])
+            ]
+            out.loc[idx, "Target_Unit_68"] = [
+                tgt_map.get((pk, kk, ds), np.nan)
+                for pk, kk, ds in zip(out.loc[idx,"prov_key"], out.loc[idx,"kab_key"], out.loc[idx,"_dataset"])
             ]
 
-    # PROVINSI: sekolah menengah SMA/SMK/SLB pakai POP_SMA_SMK_SLB
-    if meta_prov is not None and len(meta_prov) > 0:
-        prov_part = out[out["KEW_NORM"] == "PROVINSI"].copy()
-        if not prov_part.empty:
-            prov_part["is_menengah"] = detect_school_menengah(prov_part)
-            g = prov_part.groupby("prov_key")["is_menengah"].sum().reset_index().rename(columns={"is_menengah":"sampel_menengah"})
-            mergedp = g.merge(meta_prov[["prov_key","POP_SMA_SMK_SLB"]], on="prov_key", how="left")
-            mergedp["POP_SMA_SMK_SLB"] = pd.to_numeric(mergedp["POP_SMA_SMK_SLB"], errors="coerce").fillna(0)
-            mergedp["target_68"] = mergedp["POP_SMA_SMK_SLB"].map(lambda x: ceil_int(TARGET_FRAC*x))
-            mergedp["sf_prov"] = mergedp.apply(lambda r: sampling_factor(r["sampel_menengah"], r["target_68"]), axis=1)
-            fprov = mergedp.set_index("prov_key")["sf_prov"].to_dict()
-
-            m = (out["KEW_NORM"] == "PROVINSI") & (out["_dataset"] == "sekolah")
-            out.loc[m, "SamplingFactor_Total"] = [float(fprov.get(pk, 1.0)) for pk in out.loc[m, "prov_key"]]
-
-    out["Indeks_Final_0_100"] = out["Indeks_Real_0_100"].fillna(0) * out["SamplingFactor_Total"].fillna(1.0)
-    return out
-
-if df_iplm is not None and len(df_iplm) > 0:
-    df_iplm = apply_sampling_factor(df_iplm)
-
-
-# =========================
-# 9) CHOICES (DEDUP RAPi)
-# =========================
-def build_prov_choice_map(df: pd.DataFrame) -> dict:
-    tmp = df[[dm_cols["prov"], "prov_key"]].dropna()
-    tmp = tmp[tmp["prov_key"] != ""]
-    by = tmp.groupby("prov_key")[dm_cols["prov"]].agg(lambda s: Counter(s).most_common(1)[0][0])
-    return by.to_dict()
-
-def prov_choices(df: pd.DataFrame):
-    mp = build_prov_choice_map(df)
-    labels = sorted(set(mp.values()))
-    return ["(Semua)"] + labels, mp
-
-def kab_choices_for_prov(df: pd.DataFrame, prov_label: str):
-    if prov_label is None or prov_label == "(Semua)":
-        vals = sorted(df[dm_cols["kab"]].dropna().unique().tolist())
-        return ["(Semua)"] + vals
-    m = df[dm_cols["prov"]].astype(str) == str(prov_label)
-    vals = sorted(df.loc[m, dm_cols["kab"]].dropna().unique().tolist())
-    return ["(Semua)"] + vals
-
-def kew_choices(df: pd.DataFrame):
-    vals = sorted(df["KEW_NORM"].dropna().unique().tolist())
-    vals = [v for v in vals if v]
-    return ["(Semua)"] + vals
+    # ----------- PROVINSI (SMA) -----------
+    if meta_sma_df is not None and len(meta_sma_df) > 0:
+        mp = out["KEW_NORM"] == "PROVINSI"
+        prov = out[mp].copy()
+        if not prov.empty:
+            # sampel SMA = jumlah baris dataset sekolah di level prov (anggap SMA)
+            prov_sek = prov[prov["_dataset"]=="sekolah"].copy()
+            g = prov_sek.groupby("prov_key").size().rename("Sampel_SMA_DM").reset_index()
+            mergedp = g.merge(meta_sma_df[["prov_key","Jml_SMA","Provinsi_Label"]], on="prov_key", how="left")
+            mergedp["Jml_SMA"] = pd.to_numeric(mergedp["Jml_SMA"], errors="coerce").fillna(0)
+            mergedp["Target_SMA_68"] = mergedp["Jml_SMA"].apply(lambda x: ceil_int(TARGET_COVERAGE*float(x)))
+            mergedp["SF_SMA"] = mergedp.apply(lambda r: sampling_factor(r["Sampel_SMA_DM"], r["Target_SMA_68"]), axis=1)
+
+            sfp = mergedp.set_index("prov_key")["SF_SMA"].to_dict()
+            tgtp = mergedp.set_index("prov_key")["Target_SMA_68"].to_dict()
+
+            idx = out[(out["KEW_NORM"]=="PROVINSI") & (out["_dataset"]=="sekolah")].index
+            out.loc[idx, "SamplingFactor_68"] = [float(sfp.get(pk, 1.0)) for pk in out.loc[idx,"prov_key"]]
+            out.loc[idx, "Target_Unit_68"]     = [float(tgtp.get(pk, np.nan)) for pk in out.loc[idx,"prov_key"]]
+
+    out["Indeks_Final_0_100"] = out["Indeks_Real_0_100"].fillna(0) * out["SamplingFactor_68"].fillna(1.0)
+
+    debug = pd.DataFrame(debug_rows)
+    if not debug.empty:
+        debug = debug.sort_values(["meta_match","flag_pop0"], ascending=[True, False]).reset_index(drop=True)
+    return out, debug
+
+
+# ============================================================
+# 7) GAP VERIFICATION (TABEL) — pakai meta (FIX join)
+# ============================================================
+def compute_gap_verification(df_filtered: pd.DataFrame, kew_value: str) -> pd.DataFrame:
+    if df_filtered is None or len(df_filtered) == 0:
+        return pd.DataFrame()
+
+    kew_norm = str(kew_value or "").upper()
+
+    # =================== KAB/KOTA ===================
+    if ("KAB" in kew_norm or "KOTA" in kew_norm):
+        if meta_kab_df is None:
+            return pd.DataFrame({"Info": ["Meta Kab/Kota tidak tersedia."]})
+
+        tmp = df_filtered.copy()
+        tmp = tmp[pd.notna(tmp["kab_clean"])]
+        if tmp.empty:
+            return pd.DataFrame()
+
+        g_total = tmp.groupby(["prov_key","kab_key"]).size().rename("Sampel Total").reset_index()
+        g_sek_total = tmp[tmp["_dataset"]=="sekolah"].groupby(["prov_key","kab_key"]).size().rename("Sampel Sekolah").reset_index()
+        g_umum = tmp[tmp["_dataset"]=="umum"].groupby(["prov_key","kab_key"]).size().rename("Sampel Umum").reset_index()
+
+        merged = (
+            g_total
+            .merge(g_sek_total, on=["prov_key","kab_key"], how="left")
+            .merge(g_umum, on=["prov_key","kab_key"], how="left")
+            .merge(meta_kab_df, on=["prov_key","kab_key"], how="left")
+        )
 
-PROV_CHOICES, _ = (["(Semua)"], {}) if df_dm_raw is None else prov_choices(df_dm_raw)
-KEW_CHOICES = ["(Semua)"] if df_dm_raw is None else kew_choices(df_dm_raw)
-DEFAULT_KEW = "KAB/KOTA" if "KAB/KOTA" in KEW_CHOICES else (KEW_CHOICES[0] if KEW_CHOICES else "(Semua)")
-KAB_CHOICES = ["(Semua)"] if df_dm_raw is None else kab_choices_for_prov(df_dm_raw, "(Semua)")
-
-def on_prov_change(prov_value, kew_value):
-    if str(kew_value).upper() == "PROVINSI":
-        return gr.update(choices=["(Semua)"], value="(Semua)", interactive=False)
-    ch = kab_choices_for_prov(df_dm_raw, prov_value)
-    return gr.update(choices=ch, value="(Semua)", interactive=True)
-
-def on_kew_change(kew_value, prov_value):
-    if str(kew_value).upper() == "PROVINSI":
-        return gr.update(choices=["(Semua)"], value="(Semua)", interactive=False)
-    ch = kab_choices_for_prov(df_dm_raw, prov_value)
-    return gr.update(choices=ch, value="(Semua)", interactive=True)
-
-
-# =========================
-# 10) TABLE BUILDERS (FINAL & REAL)
-# =========================
-LABEL_DATASET = {"sekolah":"Perpustakaan Sekolah","umum":"Perpustakaan Umum","khusus":"Perpustakaan Khusus"}
-
-def agg_final_overall(df):
-    return pd.DataFrame([{
-        "n_unit": int(len(df)),
-        "Rata2_Indeks_Real_0_100": float(df["Indeks_Real_0_100"].mean(skipna=True)),
-        "Rata2_SamplingFactor_Total": float(df["SamplingFactor_Total"].mean(skipna=True)),
-        "Rata2_Indeks_Final_0_100": float(df["Indeks_Final_0_100"].mean(skipna=True))
-    }]).round(3)
-
-def agg_final_by_jenis(df):
-    rows = []
-    for ds in ["sekolah","umum","khusus"]:
-        d = df[df["_dataset"] == ds]
-        rows.append({
-            "Jenis Perpustakaan": LABEL_DATASET[ds],
-            "Jumlah Perpustakaan": int(len(d)),
-            "Rata2_Indeks_Final_0_100": float(d["Indeks_Final_0_100"].mean(skipna=True)) if len(d) else 0.0,
-            "Rata2_SamplingFactor_Total": float(d["SamplingFactor_Total"].mean(skipna=True)) if len(d) else 1.0
+        for c in ["Sampel Total","Sampel Sekolah","Sampel Umum"]:
+            merged[c] = merged[c].fillna(0).astype(int)
+
+        # Populasi sekolah: SD+SMP fallback Pop_Sekolah_Meta
+        sd = pd.to_numeric(merged.get("Jml_SD"), errors="coerce").fillna(0)
+        smp = pd.to_numeric(merged.get("Jml_SMP"), errors="coerce").fillna(0)
+        pop_sek = sd + smp
+        pop_sek = pop_sek.where(pop_sek > 0, pd.to_numeric(merged.get("Pop_Sekolah_Meta"), errors="coerce").fillna(0))
+        merged["Populasi Sekolah (SD+SMP)"] = pop_sek
+
+        # Populasi umum: Kec+Desa fallback Pop_Umum_Meta
+        kec = pd.to_numeric(merged.get("Jml_Kecamatan"), errors="coerce").fillna(0)
+        desa = pd.to_numeric(merged.get("Jml_DesaKel"), errors="coerce").fillna(0)
+        pop_um = kec + desa
+        pop_um = pop_um.where(pop_um > 0, pd.to_numeric(merged.get("Pop_Umum_Meta"), errors="coerce").fillna(0))
+        merged["Populasi Admin (Kec+Desa/Kel)"] = pop_um
+
+        merged["Target Sekolah (68%)"] = np.ceil(merged["Populasi Sekolah (SD+SMP)"] * TARGET_COVERAGE)
+        merged["Target Umum (68%)"]    = np.ceil(merged["Populasi Admin (Kec+Desa/Kel)"] * TARGET_COVERAGE)
+
+        merged["Kekurangan Sampel Sekolah"] = (merged["Target Sekolah (68%)"] - merged["Sampel Sekolah"]).fillna(0).astype(int).clip(lower=0)
+        merged["Kekurangan Sampel Umum"]    = (merged["Target Umum (68%)"] - merged["Sampel Umum"]).fillna(0).astype(int).clip(lower=0)
+
+        out = pd.DataFrame({
+            "Kab/Kota": merged["Kab_Kota_Label"].fillna(merged["kab_key"]),
+            "Sampel Total": merged["Sampel Total"],
+
+            "Sampel Sekolah": merged["Sampel Sekolah"],
+            "Populasi Sekolah (SD+SMP)": merged["Populasi Sekolah (SD+SMP)"],
+            "Target Sekolah (68%)": merged["Target Sekolah (68%)"],
+            "Kekurangan Sampel Sekolah": merged["Kekurangan Sampel Sekolah"],
+
+            "Sampel Umum": merged["Sampel Umum"],
+            "Populasi Admin (Kec+Desa/Kel)": merged["Populasi Admin (Kec+Desa/Kel)"],
+            "Target Umum (68%)": merged["Target Umum (68%)"],
+            "Kekurangan Sampel Umum": merged["Kekurangan Sampel Umum"],
         })
-    rows.append({
-        "Jenis Perpustakaan": "Rata-rata keseluruhan",
-        "Jumlah Perpustakaan": int(len(df)),
-        "Rata2_Indeks_Final_0_100": float(df["Indeks_Final_0_100"].mean(skipna=True)) if len(df) else 0.0,
-        "Rata2_SamplingFactor_Total": float(df["SamplingFactor_Total"].mean(skipna=True)) if len(df) else 1.0
-    })
-    return pd.DataFrame(rows).round(3)
-
-def detail_final(df):
-    cols = [dm_cols["prov"], dm_cols["kab"], dm_cols["nama"], dm_cols["jenis"]]
-    if dm_cols.get("subjenis") and dm_cols["subjenis"] in df.columns:
-        cols.append(dm_cols["subjenis"])
-    cols += ["KEW_NORM","_dataset","Indeks_Real_0_100","SamplingFactor_Total","Indeks_Final_0_100"]
-    cols = [c for c in cols if c in df.columns]
-    return df[cols].copy().round(3)
-
-def agg_real_by_jenis(df):
-    rows = []
-    for ds in ["sekolah","umum","khusus"]:
-        d = df[df["_dataset"] == ds]
-        rows.append({
-            "Jenis Perpustakaan": LABEL_DATASET[ds],
-            "Jumlah Perpustakaan": int(len(d)),
-            "Rata2_sub_koleksi": float(d["sub_koleksi"].mean(skipna=True)) if len(d) else 0.0,
-            "Rata2_sub_sdm": float(d["sub_sdm"].mean(skipna=True)) if len(d) else 0.0,
-            "Rata2_sub_pelayanan": float(d["sub_pelayanan"].mean(skipna=True)) if len(d) else 0.0,
-            "Rata2_sub_pengelolaan": float(d["sub_pengelolaan"].mean(skipna=True)) if len(d) else 0.0,
-            "Rata2_dim_kepatuhan": float(d["dim_kepatuhan"].mean(skipna=True)) if len(d) else 0.0,
-            "Rata2_dim_kinerja": float(d["dim_kinerja"].mean(skipna=True)) if len(d) else 0.0,
-            "Rata2_Indeks_IPLM_0_100": float(d["Indeks_Real_0_100"].mean(skipna=True)) if len(d) else 0.0
-        })
-    rows.append({
-        "Jenis Perpustakaan": "Rata-rata keseluruhan",
-        "Jumlah Perpustakaan": int(len(df)),
-        "Rata2_sub_koleksi": float(df["sub_koleksi"].mean(skipna=True)),
-        "Rata2_sub_sdm": float(df["sub_sdm"].mean(skipna=True)),
-        "Rata2_sub_pelayanan": float(df["sub_pelayanan"].mean(skipna=True)),
-        "Rata2_sub_pengelolaan": float(df["sub_pengelolaan"].mean(skipna=True)),
-        "Rata2_dim_kepatuhan": float(df["dim_kepatuhan"].mean(skipna=True)),
-        "Rata2_dim_kinerja": float(df["dim_kinerja"].mean(skipna=True)),
-        "Rata2_Indeks_IPLM_0_100": float(df["Indeks_Real_0_100"].mean(skipna=True)),
-    })
-    return pd.DataFrame(rows).round(3)
-
-def detail_real(df):
-    base = [dm_cols["prov"], dm_cols["kab"], dm_cols["nama"], dm_cols["jenis"]]
-    if dm_cols.get("subjenis") and dm_cols["subjenis"] in df.columns:
-        base.append(dm_cols["subjenis"])
-    base += ["KEW_NORM","_dataset","sub_koleksi","sub_sdm","sub_pelayanan","sub_pengelolaan","dim_kepatuhan","dim_kinerja","Indeks_Real_0_100"]
-
-    available_ind = [c for c in all_indicators if c in df.columns]
-    cols = [c for c in (base + available_ind) if c in df.columns]
-    return df[cols].copy().round(3)
-
-
-# =========================
-# 11) COVERAGE (TERBACA) + BAR
-# =========================
-def df_to_html_big(df: pd.DataFrame, title: str = "") -> str:
-    if df is None or df.empty:
-        return f"<div style='font-size:16px;'><b>{title}</b><br>(Tidak ada data)</div>"
-    d = df.copy()
-    for c in d.columns:
-        if c == "Jenis":
-            continue
-        d[c] = pd.to_numeric(d[c], errors="coerce")
-        if pd.api.types.is_numeric_dtype(d[c]):
-            d[c] = d[c].fillna(0).map(lambda x: f"{int(x):,}".replace(",", "."))
-    html = d.to_html(index=False, escape=False)
-    return f"""
-    <div style="font-size:16px; line-height:1.35;">
-      <div style="font-size:18px; font-weight:700; margin-bottom:8px;">{title}</div>
-      <div style="overflow-x:auto; border:1px solid #333; border-radius:10px; padding:8px;">
-        {html}
-      </div>
-    </div>
-    """
-
-def coverage_table_and_bar(df_subset, kew_value):
-    kew = str(kew_value).upper()
-    tbl = pd.DataFrame()
-    fig = go.Figure()
-    fig.update_layout(barmode="group", title=f"BAR — Populasi vs Sampel ({kew})")
 
-    if df_subset is None or df_subset.empty:
-        return tbl, fig
+        return out.sort_values("Kab/Kota").reset_index(drop=True).round(0)
 
-    if kew == "KAB/KOTA" and meta_kab is not None and len(meta_kab) > 0:
-        samp_sek = int((df_subset["_dataset"] == "sekolah").sum())
-        samp_um  = int((df_subset["_dataset"] == "umum").sum())
+    # =================== PROVINSI ===================
+    if ("PROV" in kew_norm):
+        if meta_sma_df is None:
+            return pd.DataFrame({"Info": ["Meta SMA tidak tersedia."]})
 
-        keys = df_subset[["prov_key","kab_key"]].dropna().drop_duplicates()
-        merged = keys.merge(meta_kab[["prov_key","kab_key","POP_SD_SMP","POP_KEC_DESA"]],
-                            on=["prov_key","kab_key"], how="left")
+        tmp = df_filtered.copy()
+        tmp = tmp[pd.notna(tmp["prov_clean"])]
+        if tmp.empty:
+            return pd.DataFrame({"Info": ["Tidak ada data sampel kewenangan provinsi."]})
 
-        pop_sek = int(pd.to_numeric(merged["POP_SD_SMP"], errors="coerce").fillna(0).sum())
-        pop_um  = int(pd.to_numeric(merged["POP_KEC_DESA"], errors="coerce").fillna(0).sum())
+        g_total = tmp.groupby("prov_key").size().rename("Sampel Total (Prov)").reset_index()
+        g_sma = tmp[tmp["_dataset"]=="sekolah"].groupby("prov_key").size().rename("Sampel SMA (DM)").reset_index()
 
-        target_sek = ceil_int(TARGET_FRAC * pop_sek)
-        target_um  = ceil_int(TARGET_FRAC * pop_um)
-
-        tbl = pd.DataFrame([
-            {"Jenis":"Sekolah (SD+SMP)", "Populasi":pop_sek, "Target_68%":target_sek, "Sampel":samp_sek, "Gap_ke_68%": max(target_sek - samp_sek, 0)},
-            {"Jenis":"Umum (Kec+Desa)",  "Populasi":pop_um,  "Target_68%":target_um,  "Sampel":samp_um,  "Gap_ke_68%": max(target_um - samp_um, 0)},
-        ])
-
-        fig = px.bar(
-            tbl.melt(id_vars="Jenis", value_vars=["Populasi","Sampel"]),
-            x="Jenis", y="value", color="variable",
-            barmode="group",
-            title="BAR — Populasi vs Sampel (KAB/KOTA)"
+        merged = (
+            g_total
+            .merge(g_sma, on="prov_key", how="left")
+            .merge(meta_sma_df[["prov_key","Provinsi_Label","Jml_SMA"]], on="prov_key", how="left")
         )
-        return tbl, fig
-
-    if kew == "PROVINSI" and meta_prov is not None and len(meta_prov) > 0:
-        samp = int(detect_school_menengah(df_subset).sum())
-        keys = df_subset[["prov_key"]].dropna().drop_duplicates()
-        merged = keys.merge(meta_prov[["prov_key","POP_SMA_SMK_SLB"]], on="prov_key", how="left")
-        pop = int(pd.to_numeric(merged["POP_SMA_SMK_SLB"], errors="coerce").fillna(0).sum())
-        target = ceil_int(TARGET_FRAC * pop)
-
-        tbl = pd.DataFrame([
-            {"Jenis":"Sekolah Menengah (SMA+SMK+SLB)", "Populasi":pop, "Target_68%":target, "Sampel":samp, "Gap_ke_68%": max(target - samp, 0)},
-        ])
-
-        fig = px.bar(
-            tbl.melt(id_vars="Jenis", value_vars=["Populasi","Sampel"]),
-            x="Jenis", y="value", color="variable",
-            barmode="group",
-            title="BAR — Populasi vs Sampel (PROVINSI)"
-        )
-        return tbl, fig
+        merged["Sampel SMA (DM)"] = merged["Sampel SMA (DM)"].fillna(0).astype(int)
+        merged["Jml_SMA"] = pd.to_numeric(merged["Jml_SMA"], errors="coerce").fillna(0)
+
+        merged["Target SMA (68%)"] = np.ceil(merged["Jml_SMA"] * TARGET_COVERAGE)
+        merged["Kekurangan Sampel SMA"] = (merged["Target SMA (68%)"] - merged["Sampel SMA (DM)"]).fillna(0).astype(int).clip(lower=0)
+
+        out = pd.DataFrame({
+            "Provinsi": merged["Provinsi_Label"].fillna(merged["prov_key"]),
+            "Sampel Total (Prov)": merged["Sampel Total (Prov)"].fillna(0).astype(int),
+            "Sampel SMA (DM)": merged["Sampel SMA (DM)"],
+            "Populasi SMA (Meta)": merged["Jml_SMA"],
+            "Target SMA (68%)": merged["Target SMA (68%)"],
+            "Kekurangan Sampel SMA": merged["Kekurangan Sampel SMA"],
+        })
+        return out.sort_values("Provinsi").reset_index(drop=True).round(0)
 
-    return tbl, fig
+    return pd.DataFrame({"Info": ["Kewenangan tidak dikenali / tidak didukung."]})
 
 
-# =========================
-# 12) BELL CURVE (per jenis)
-# =========================
-def bell_curve_fig(df, score_col: str, title: str, name_col: str | None = None):
+# ============================================================
+# 8) GRAFIK GAP (bar)
+# ============================================================
+def make_gap_figure(verif_df: pd.DataFrame, kew_value: str) -> go.Figure:
     fig = go.Figure()
-    if df is None or df.empty:
-        fig.update_layout(title=title)
+    if verif_df is None or verif_df.empty:
+        fig.update_layout(title="Kekurangan Sampel (tidak ada data)")
         return fig
 
-    x = pd.to_numeric(df[score_col], errors="coerce").dropna().astype(float)
-    if len(x) < 5:
-        fig.update_layout(title=title)
-        return fig
+    kew_norm = str(kew_value or "").upper()
 
-    mu = float(x.mean())
-    sd = float(x.std(ddof=1)) if float(x.std(ddof=1)) > 0 else 1.0
+    def _num(s):
+        return pd.to_numeric(s, errors="coerce").fillna(0).astype(int)
 
-    xs = np.linspace(float(x.min()), float(x.max()), 300)
-    pdf = (1/(sd*np.sqrt(2*np.pi))) * np.exp(-0.5*((xs-mu)/sd)**2)
+    if ("KAB" in kew_norm or "KOTA" in kew_norm) and ("Kab/Kota" in verif_df.columns):
+        dfp = verif_df.copy()
+        dfp["gap_total"] = _num(dfp.get("Kekurangan Sampel Sekolah", 0)) + _num(dfp.get("Kekurangan Sampel Umum", 0))
+        dfp = dfp.sort_values("gap_total", ascending=False).head(50)  # biar kebaca
 
-    q1 = float(x.quantile(0.25))
-    q2 = float(x.quantile(0.50))
-    q3 = float(x.quantile(0.75))
+        x = dfp["Kab/Kota"].astype(str).tolist()
+        gap_sek  = _num(dfp.get("Kekurangan Sampel Sekolah", 0))
+        gap_umum = _num(dfp.get("Kekurangan Sampel Umum", 0))
 
-    fig.add_trace(go.Scatter(x=xs, y=pdf, mode="lines", name="Bell curve"))
+        fig.add_trace(go.Bar(x=x, y=gap_sek, name="Gap Sekolah", text=gap_sek, textposition="outside"))
+        fig.add_trace(go.Bar(x=x, y=gap_umum, name="Gap Umum", text=gap_umum, textposition="outside"))
 
-    y0 = np.zeros(len(x))
-    hover = None
-    if name_col and name_col in df.columns:
-        hover = df.loc[x.index, name_col].astype(str).tolist()
-
-    fig.add_trace(go.Scatter(
-        x=x, y=y0, mode="markers", name="Perpustakaan",
-        marker=dict(size=6),
-        text=hover,
-        hovertemplate="%{text}<br>Indeks: %{x:.2f}<extra></extra>" if hover else "Indeks: %{x:.2f}<extra></extra>"
-    ))
+        fig.update_layout(
+            title=f"Kekurangan Sampel (Top 50) — Target {int(TARGET_COVERAGE*100)}%",
+            barmode="group",
+            margin=dict(l=40, r=20, t=60, b=160),
+            xaxis_title="Kab/Kota",
+            yaxis_title="Kekurangan (unit)"
+        )
+        fig.update_xaxes(tickangle=-35)
+        return fig
 
-    fig.add_vline(x=q1, line_width=2, line_dash="solid", annotation_text=f"Q1<br>{q1:.1f}", annotation_position="top")
-    fig.add_vline(x=q2, line_width=2, line_dash="solid", annotation_text=f"Q2 (Median)<br>{q2:.1f}", annotation_position="top")
-    fig.add_vline(x=q3, line_width=2, line_dash="solid", annotation_text=f"Q3<br>{q3:.1f}", annotation_position="top")
+    if ("PROV" in kew_norm) and ("Provinsi" in verif_df.columns):
+        dfp = verif_df.copy().sort_values("Kekurangan Sampel SMA", ascending=False)
+        x = dfp["Provinsi"].astype(str).tolist()
+        gap = _num(dfp.get("Kekurangan Sampel SMA", 0))
+        fig.add_trace(go.Bar(x=x, y=gap, name="Gap SMA", text=gap, textposition="outside"))
+        fig.update_layout(
+            title=f"Kekurangan Sampel (PROVINSI) — Target {int(TARGET_COVERAGE*100)}%",
+            margin=dict(l=40, r=20, t=60, b=160),
+            xaxis_title="Provinsi",
+            yaxis_title="Kekurangan (unit)"
+        )
+        fig.update_xaxes(tickangle=-35)
+        return fig
 
-    fig.update_layout(
-        title=title,
-        xaxis_title="Indeks IPLM (0–100)",
-        yaxis_title="Kepadatan (relatif)",
-        height=420,
-        margin=dict(l=40, r=20, t=60, b=40)
-    )
+    fig.update_layout(title="Kekurangan Sampel — format data tidak dikenali")
     return fig
 
 
-# =========================
-# 13) ANALISIS (LLM opsional)
-# =========================
-def llm_analysis_text(df_subset: pd.DataFrame, cov_tbl: pd.DataFrame, scope_label: str, kew: str,
-                      use_llm: bool, hf_model: str):
-    mean_final = float(df_subset["Indeks_Final_0_100"].mean(skipna=True)) if len(df_subset) else 0.0
-    mean_real  = float(df_subset["Indeks_Real_0_100"].mean(skipna=True)) if len(df_subset) else 0.0
-    mean_sf    = float(df_subset["SamplingFactor_Total"].mean(skipna=True)) if len(df_subset) else 1.0
-
+# ============================================================
+# 9) LLM NARASI (GAP) + WORD
+# ============================================================
+def build_context_gap(verif_df: pd.DataFrame, prov: str, kab: str, kew: str) -> str:
+    wilayah = kab if kab and kab != "(Semua)" else (prov if prov and prov != "(Semua)" else "NASIONAL")
     lines = []
-    lines.append(f"**Ringkasan ({scope_label} | {kew})**")
-    lines.append(f"- Rata-rata **Indeks Final (0–100)**: **{mean_final:.2f}**")
-    lines.append(f"- Rata-rata **Indeks Real (0–100)**: {mean_real:.2f}")
-    lines.append(f"- Rata-rata **SamplingFactor (target 68%)**: {mean_sf:.3f}")
-
-    if cov_tbl is not None and not cov_tbl.empty:
-        cov_tbl2 = cov_tbl.copy()
-        cov_tbl2["Gap_ke_68%"] = pd.to_numeric(cov_tbl2["Gap_ke_68%"], errors="coerce").fillna(0)
-        top = cov_tbl2.sort_values("Gap_ke_68%", ascending=False).head(1)
-        if len(top):
-            r = top.iloc[0].to_dict()
-            lines.append(f"- Kesenjangan keterwakilan terbesar: **{r.get('Jenis')}** (Gap ke 68% = **{int(r.get('Gap_ke_68%',0))}** unit).")
-
-    if use_llm:
-        try:
-            from huggingface_hub import InferenceClient
-            token = os.environ.get("HF_SECRET") or os.environ.get("HUGGINGFACEHUB_API_TOKEN")
-            if not token:
-                lines.append("\n⚠️ HF_TOKEN tidak ditemukan di environment. Pakai analisis template.")
-                return "\n".join(lines)
-
-            client = InferenceClient(model=hf_model, token=token)
-
-            prompt = (
-                "You are a policy analyst for Indonesia National Library (Perpusnas). "
-                "Write a concise Indonesian policy analysis (max 180 words) based on this summary:\n"
-                f"- Scope: {scope_label}, Authority: {kew}\n"
-                f"- Mean Final Index: {mean_final:.2f}\n"
-                f"- Mean Real Index: {mean_real:.2f}\n"
-                f"- Mean Sampling Factor: {mean_sf:.3f}\n"
-                f"- Coverage table: {cov_tbl.to_dict(orient='records') if cov_tbl is not None else []}\n"
-                "Include: key interpretation, risk to validity from sampling, and 2 actionable recommendations."
-            )
-
-            resp = client.text_generation(prompt, max_new_tokens=220, temperature=0.2)
-            lines.append("\n**Analisis LLM (Perpusnas-ready):**\n" + resp.strip())
-            return "\n".join(lines)
-        except Exception as e:
-            lines.append(f"\n⚠️ LLM call gagal ({repr(e)}). Pakai analisis template.")
-            return "\n".join(lines)
-
-    lines.append("\n**Implikasi kebijakan (template cepat):**")
-    lines.append("- SamplingFactor < 1 menandakan keterwakilan belum mencapai target 68% → interpretasi indeks perlu disertai catatan coverage/kualitas data.")
-    lines.append("- Prioritaskan percepatan pengisian pada jenis dengan gap terbesar, dan lakukan validasi minimal (kelengkapan indikator kunci) sebelum agregasi.")
+    lines.append(f"Wilayah filter: {wilayah}")
+    lines.append(f"Kewenangan: {kew}")
+    lines.append(f"Target pengumpulan: {int(TARGET_COVERAGE*100)}% dari populasi unit (meta).")
+    lines.append(f"Jumlah unit analisis: {len(verif_df)}")
+
+    gap_cols = [c for c in verif_df.columns if "Kekurangan Sampel" in c]
+    for gc in gap_cols:
+        total_gap = int(pd.to_numeric(verif_df[gc], errors="coerce").fillna(0).sum())
+        lines.append(f"Total {gc}: {total_gap}")
+
+    if gap_cols:
+        gc = gap_cols[0]
+        t = verif_df.copy()
+        t[gc] = pd.to_numeric(t[gc], errors="coerce").fillna(0)
+        keycol = "Kab/Kota" if "Kab/Kota" in t.columns else ("Provinsi" if "Provinsi" in t.columns else t.columns[0])
+        top = t.sort_values(gc, ascending=False).head(10)
+        lines.append("\nTop prioritas (gap terbesar):")
+        for _, r in top.iterrows():
+            lines.append(f"- {r[keycol]}: {gc}={int(r[gc])}")
+
     return "\n".join(lines)
 
+def rule_based_gap_report(verif_df: pd.DataFrame, prov: str, kab: str, kew: str) -> str:
+    if verif_df is None or verif_df.empty:
+        return "Tidak ada data verifikasi yang dapat dilaporkan."
+    wilayah = kab if kab and kab != "(Semua)" else (prov if prov and prov != "(Semua)" else "NASIONAL")
+    gap_cols = [c for c in verif_df.columns if "Kekurangan Sampel" in c]
+    lines = [
+        "## Ringkasan Kekurangan Sampel IPLM (Rule-based)\n",
+        f"Wilayah: {wilayah}",
+        f"Kewenangan: {kew}",
+        f"Target pengumpulan: {int(TARGET_COVERAGE*100)}% dari populasi unit (meta).",
+        f"Jumlah unit analisis: {len(verif_df)}\n",
+    ]
+    for gc in gap_cols:
+        total_gap = int(pd.to_numeric(verif_df[gc], errors="coerce").fillna(0).sum())
+        lines.append(f"- Total {gc}: **{total_gap}** unit.")
+    lines.append("\nFokuskan pengumpulan pada wilayah dengan gap terbesar dan lakukan monitoring rutin hingga gap turun.")
+    return "\n".join(lines)
 
-# =========================
-# 14) WORD REPORT (opsional)
-# =========================
-HAS_DOCX = True
-try:
-    from docx import Document
-    from docx.shared import Inches
-except Exception:
-    HAS_DOCX = False
+def generate_llm_gap_report(verif_df: pd.DataFrame, prov: str, kab: str, kew: str) -> str:
+    ctx = build_context_gap(verif_df, prov, kab, kew)
+    client = get_llm_client()
+    if client is None or not USE_LLM:
+        return "⚠️ LLM tidak tersedia.\n\n" + rule_based_gap_report(verif_df, prov, kab, kew)
 
-def try_plotly_png(fig, out_png):
-    try:
-        fig.write_image(out_png, width=1400, height=700, scale=2)
-        return True
-    except Exception:
-        return False
+    system_prompt = (
+        "Anda adalah analis kebijakan dan manajer program IPLM. "
+        "Fokus hanya pada gap sampel (kekurangan unit) dan strategi menutup kekurangan."
+    )
+    user_prompt = f"""
+DATA RINGKAS GAP SAMPEL IPLM:
 
-def generate_word_report(scope_label, kew, agg_overall, agg_final, agg_real, cov_tbl, bar_fig,
-                         bell_all, bell_sek, bell_um, bell_kh, narrative):
-    if not HAS_DOCX:
-        return None
+{ctx}
+
+TULIS LAPORAN (BAHASA INDONESIA FORMAL) DENGAN STRUKTUR:
+1) Ringkasan kondisi pengumpulan data (1 paragraf).
+2) Total kekurangan sampel menuju target {int(TARGET_COVERAGE*100)}% (1 paragraf).
+3) Prioritas wilayah (gap terbesar) dan alasan operasional (1 paragraf).
+4) Rencana aksi 30–60 hari (naratif, bukan bullet).
 
+BATASAN:
+- Jangan membahas indeks/skor IPLM.
+- Fokus hanya pada kekurangan sampel, target 68%, strategi.
+"""
+    try:
+        resp = client.chat_completion(
+            model=LLM_MODEL_NAME,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt},
+            ],
+            max_tokens=900,
+            temperature=0.2,
+            top_p=0.9,
+        )
+        text = resp.choices[0].message.content.strip()
+        if not text:
+            raise ValueError("Respon LLM kosong.")
+        return text
+    except Exception as e:
+        return f"⚠️ Error LLM: {repr(e)}\n\n" + rule_based_gap_report(verif_df, prov, kab, kew)
+
+def generate_word_report_gap(verif_df: pd.DataFrame, prov: str, kab: str, kew: str, analysis_text: str):
+    wilayah = kab if kab and kab != "(Semua)" else (prov if prov and prov != "(Semua)" else "NASIONAL")
     doc = Document()
-    doc.add_heading(f"Laporan IPLM 2025 — {scope_label}", level=1)
+    doc.add_heading(f"Laporan Kekurangan Sampel IPLM – {wilayah}", level=1)
     doc.add_paragraph(f"Kewenangan: {kew}")
-    doc.add_paragraph("Final: Indeks_Final_0_100 = Indeks_Real_0_100 × SamplingFactor_Total (target 68%).")
-
-    def add_table(df, title):
-        doc.add_heading(title, level=2)
-        if df is None or df.empty:
-            doc.add_paragraph("(Tidak ada data)")
-            return
-        t = doc.add_table(rows=1, cols=len(df.columns))
-        for j,c in enumerate(df.columns):
-            t.rows[0].cells[j].text = str(c)
-        for _, r in df.iterrows():
-            row = t.add_row().cells
-            for j,c in enumerate(df.columns):
-                row[j].text = str(r[c])
-
-    add_table(agg_overall, "1) Indeks Agregat (FINAL)")
-    add_table(agg_final, "2) Agregat (FINAL) per Jenis Perpustakaan")
-    add_table(agg_real, "3) Agregat (RealScore) per Jenis — Subindeks & Dimensi")
-    add_table(cov_tbl, "4) Coverage Populasi vs Sampel (Target 68%)")
-
-    doc.add_heading("5) Grafik", level=2)
-    tmpdir = tempfile.mkdtemp()
-
-    p = os.path.join(tmpdir, "bar.png")
-    if bar_fig is not None and try_plotly_png(bar_fig, p) and Path(p).exists():
-        doc.add_paragraph("Grafik BAR — Populasi vs Sampel")
-        doc.add_picture(p, width=Inches(6.5))
-
-    for title, fig in [
-        ("Sebaran Indeks (RealScore) — Semua", bell_all),
-        ("Sebaran Indeks (RealScore) — Perpustakaan Sekolah", bell_sek),
-        ("Sebaran Indeks (RealScore) — Perpustakaan Umum", bell_um),
-        ("Sebaran Indeks (RealScore) — Perpustakaan Khusus", bell_kh),
-    ]:
-        p = os.path.join(tmpdir, canon(title) + ".png")
-        if fig is not None and try_plotly_png(fig, p) and Path(p).exists():
-            doc.add_paragraph(title)
-            doc.add_picture(p, width=Inches(6.5))
-
-    doc.add_heading("6) Analisis", level=2)
-    doc.add_paragraph(narrative)
+    doc.add_paragraph(f"Target pengumpulan: {int(TARGET_COVERAGE*100)}% dari populasi unit (meta).")
+    doc.add_paragraph(f"Jumlah unit analisis: {len(verif_df)}")
+
+    doc.add_heading("Tabel Verifikasi (Target & Kekurangan Sampel)", level=2)
+    view = verif_df.copy()
+    if len(view) > 200:
+        doc.add_paragraph("Catatan: tabel dipotong (200 baris pertama).")
+        view = view.head(200)
+
+    table = doc.add_table(rows=1, cols=len(view.columns))
+    hdr = table.rows[0].cells
+    for i, c in enumerate(view.columns):
+        hdr[i].text = str(c)
+
+    for _, row in view.iterrows():
+        r = table.add_row().cells
+        for i, c in enumerate(view.columns):
+            r[i].text = str(row[c])
+
+    doc.add_heading("Ringkasan Visual (Opsional)", level=2)
+    if not HAS_KALEIDO:
+        doc.add_paragraph("Grafik pie tidak dibuat karena 'kaleido' tidak tersedia.")
+    else:
+        pie_made = False
+        if "Sampel Sekolah" in verif_df.columns and "Target Sekolah (68%)" in verif_df.columns:
+            samp = pd.to_numeric(verif_df["Sampel Sekolah"], errors="coerce").fillna(0).sum()
+            tgt  = pd.to_numeric(verif_df["Target Sekolah (68%)"], errors="coerce").fillna(0).sum()
+            img = make_pie_plotly(samp, tgt, "Capaian Sekolah (Total) terhadap Target")
+            if img:
+                doc.add_picture(img)
+                pie_made = True
+        if not pie_made:
+            doc.add_paragraph("Pie chart tidak tersedia (kolom sampel/target tidak lengkap).")
+
+    doc.add_heading("Analisis Naratif (LLM)", level=2)
+    for p in analysis_text.split("\n"):
+        if p.strip():
+            doc.add_paragraph(p)
 
     outpath = tempfile.mktemp(suffix=".docx")
     doc.save(outpath)
     return outpath
 
 
-# =========================
-# 15) RUN CORE (FILTER + OUTPUT)
-# =========================
-def run_app(prov_value, kab_value, kew_value, use_llm, hf_model):
-    empty = pd.DataFrame()
-    empty_fig = go.Figure()
+# ============================================================
+# 10) DROPDOWN
+# ============================================================
+def all_prov_choices():
+    if df_all_raw is None or "prov_clean" not in df_all_raw.columns:
+        return ["(Semua)"]
+    s = df_all_raw["prov_clean"].dropna().astype(str).str.strip()
+    vals = sorted([o for o in s.unique() if o])
+    return ["(Semua)"] + vals
+
+def get_kab_choices_for_prov(prov_value):
+    if df_all_raw is None or "kab_clean" not in df_all_raw.columns:
+        return ["(Semua)"]
+    if prov_value is None or prov_value == "(Semua)":
+        s = df_all_raw["kab_clean"].dropna().astype(str).str.strip()
+    else:
+        m = df_all_raw["prov_clean"].astype(str).str.strip() == str(prov_value).strip()
+        s = df_all_raw.loc[m, "kab_clean"].dropna().astype(str).str.strip()
+    vals = sorted([x for x in s.unique() if x])
+    return ["(Semua)"] + vals
+
+def all_kew_choices():
+    if df_all_raw is None:
+        return ["(Semua)"]
+    s = df_all_raw.get("KEW_NORM", pd.Series(dtype=object)).dropna().astype(str).str.strip()
+    vals = sorted([o for o in s.unique() if o])
+    return ["(Semua)"] + vals if vals else ["(Semua)"]
+
+prov_choices = all_prov_choices()
+kab_choices  = get_kab_choices_for_prov(prov_choices[0] if prov_choices else "(Semua)")
+kew_choices  = all_kew_choices()
+default_kew  = "KAB/KOTA" if "KAB/KOTA" in kew_choices else (kew_choices[0] if kew_choices else "(Semua)")
+
 
-    if df_iplm is None or df_iplm.empty:
-        return (empty, empty, empty, empty, empty, "", empty_fig, empty_fig, empty_fig, empty_fig, empty_fig,
-                None, None, None, "⚠️ Data belum siap (DM gagal dimuat / kosong).")
+# ============================================================
+# 11) CORE RUN (FILTER + IPLM + GAP + EXPORT)
+# ============================================================
+def run_core(prov_value, kab_value, kew_value):
+    if df_all_raw is None or df_all_raw.empty:
+        empty = pd.DataFrame()
+        return empty, empty, empty, None, None, None, None, "DM tidak terbaca.", "Tidak ada analisis."
 
-    prov_value = prov_value or "(Semua)"
-    kab_value  = kab_value or "(Semua)"
-    kew_value  = kew_value or "(Semua)"
-    kew_norm   = str(kew_value).upper()
+    df = df_all_raw.copy()
 
-    if kew_norm == "PROVINSI":
-        kab_value = "(Semua)"
+    # filter prov
+    if prov_value and prov_value != "(Semua)":
+        df = df[df["prov_clean"].astype(str).str.strip() == str(prov_value).strip()]
 
-    df = df_iplm.copy()
+    # filter kab
+    if kab_value and kab_value != "(Semua)":
+        df = df[df["kab_clean"].astype(str).str.strip() == str(kab_value).strip()]
 
-    if prov_value != "(Semua)":
-        df = df[df[dm_cols["prov"]] == str(prov_value)]
-    if kab_value != "(Semua)" and kew_norm != "PROVINSI":
-        df = df[df[dm_cols["kab"]] == str(kab_value)]
-    if kew_value != "(Semua)":
-        df = df[df["KEW_NORM"] == kew_norm]
+    # filter kew
+    if kew_value and kew_value != "(Semua)":
+        df = df[df["KEW_NORM"] == kew_value]
 
     if df.empty:
-        return (empty, empty, empty, empty, empty, "", empty_fig, empty_fig, empty_fig, empty_fig, empty_fig,
-                None, None, None, "Tidak ada data untuk filter ini.")
-
-    # TABLES
-    t1 = agg_final_overall(df)
-    t2 = agg_final_by_jenis(df)
-    t3 = detail_final(df)
-    t4 = agg_real_by_jenis(df)
-    t5 = detail_real(df)
-
-    # COVERAGE + BAR
-    cov_tbl, bar_fig = coverage_table_and_bar(df, kew_norm)
-    cov_html = df_to_html_big(cov_tbl, "Coverage Populasi vs Sampel (Target 68%)")
-
-    # BELL CURVES
-    bell_all = bell_curve_fig(df, "Indeks_Real_0_100", "Sebaran Indeks RealScore — Semua", dm_cols["nama"])
-    bell_sek = bell_curve_fig(df[df["_dataset"]=="sekolah"], "Indeks_Real_0_100", "Sebaran Indeks RealScore — Perpustakaan Sekolah", dm_cols["nama"])
-    bell_um  = bell_curve_fig(df[df["_dataset"]=="umum"], "Indeks_Real_0_100", "Sebaran Indeks RealScore — Perpustakaan Umum", dm_cols["nama"])
-    bell_kh  = bell_curve_fig(df[df["_dataset"]=="khusus"], "Indeks_Real_0_100", "Sebaran Indeks RealScore — Perpustakaan Khusus", dm_cols["nama"])
-
-    # NARASI
-    scope_label = kab_value if (kab_value != "(Semua)" and kew_norm != "PROVINSI") else prov_value
-    if scope_label == "(Semua)":
-        scope_label = "NASIONAL"
-    narrative = llm_analysis_text(df, cov_tbl, scope_label, kew_norm, bool(use_llm), str(hf_model or ""))
-
-    # SAVE FILES
-    tmpdir = tempfile.mkdtemp()
-    f_final_agg = os.path.join(tmpdir, "IPLM2025_Agregat_FINAL.xlsx")
-    f_final_det = os.path.join(tmpdir, "IPLM2025_Detail_FINAL.xlsx")
-    f_real_agg  = os.path.join(tmpdir, "IPLM2025_Agregat_Real_SubindeksDimensi.xlsx")
-    f_real_det  = os.path.join(tmpdir, "IPLM2025_Detail_Real_SubindeksDimensi_Indikator.xlsx")
-
-    t2.to_excel(f_final_agg, index=False)
-    t3.to_excel(f_final_det, index=False)
-    t4.to_excel(f_real_agg, index=False)
-    t5.to_excel(f_real_det, index=False)
-
-    word_path = generate_word_report(
-        scope_label, kew_norm, t1, t2, t4, cov_tbl, bar_fig,
-        bell_all, bell_sek, bell_um, bell_kh,
-        narrative
-    )
+        empty = pd.DataFrame()
+        return empty, empty, empty, None, None, None, None, "Tidak ada data untuk filter ini.", "Tidak ada analisis."
 
-    msg = f"✅ OK | n={len(df)} | Mean Final={float(df['Indeks_Final_0_100'].mean()):.2f} | Mean SamplingFactor={float(df['SamplingFactor_Total'].mean()):.3f}"
-    return (t1, t2, t3, t4, t5, cov_html, bar_fig, bell_all, bell_sek, bell_um, bell_kh,
-            f_final_agg, f_final_det, word_path, narrative, msg)
+    # 1) HITUNG IPLM (REAL)
+    df_iplm = compute_iplm_real(df)
 
+    # 2) SAMPLING FACTOR 68% (untuk Indeks_Final)
+    df_iplm, dbg_meta = attach_sampling_factor(df_iplm)
 
-# =========================
-# 16) UI
-# =========================
-with gr.Blocks() as demo:
-    gr.Markdown(f"""
-# IPLM 2025 — Real × SamplingFactor 68% (FINAL)
+    # 3) GAP TABLE (unit kekurangan)
+    verif_df = compute_gap_verification(df_iplm, kew_value)
 
-<b>Final</b>: <code>Indeks_Final_0_100 = Indeks_Real_0_100 × SamplingFactor_Total</code><br><br>
-{DATA_INFO}
-""")
+    # 4) Grafik GAP
+    fig_gap = make_gap_figure(verif_df, kew_value)
 
-    with gr.Row():
-        dd_prov = gr.Dropdown(label="Provinsi", choices=PROV_CHOICES, value="(Semua)")
-        dd_kab  = gr.Dropdown(label="Kab/Kota", choices=KAB_CHOICES, value="(Semua)")
-        dd_kew  = gr.Dropdown(label="Kewenangan", choices=KEW_CHOICES, value=DEFAULT_KEW)
+    # 5) Detail subset (ringkas) -> termasuk Indeks
+    keep_cols = [
+        "prov_clean","kab_clean", nama_col_glob, "KEW_NORM", jenis_col_glob, subjenis_col_glob, "_dataset",
+        "sub_koleksi","sub_sdm","sub_pelayanan","sub_pengelolaan",
+        "dim_kepatuhan","dim_kinerja",
+        "Indeks_Real_0_100","SamplingFactor_68","Indeks_Final_0_100"
+    ]
+    keep_cols = [c for c in keep_cols if c and c in df_iplm.columns]
+    detail_df = df_iplm[keep_cols].copy()
 
-    dd_prov.change(fn=on_prov_change, inputs=[dd_prov, dd_kew], outputs=dd_kab)
-    dd_kew.change(fn=on_kew_change, inputs=[dd_kew, dd_prov], outputs=dd_kab)
+    # 6) Simpan download
+    tmpdir = tempfile.mkdtemp()
+    rekap_excel_path = os.path.join(tmpdir, "Rekap_IPLM_Gap_Target.xlsx")
+    raw_dm_path      = os.path.join(tmpdir, "DM_Subset_Raw.xlsx")
 
-    with gr.Row():
-        use_llm = gr.Checkbox(label="Aktifkan Analisis LLM (opsional, butuh HF_TOKEN)", value=False)
-        hf_model = gr.Textbox(label="HF model (opsional)", value="HuggingFaceH4/zephyr-7b-beta")
+    with pd.ExcelWriter(rekap_excel_path, engine="openpyxl") as w:
+        verif_df.to_excel(w, sheet_name="Verifikasi_Gap_Target", index=False)
+        detail_df.to_excel(w, sheet_name="Detail_IPLM_Subset", index=False)
+        dbg_meta.to_excel(w, sheet_name="Meta_Match_Debug", index=False)
 
-    run_btn = gr.Button("Jalankan Perhitungan")
-    msg_out = gr.Markdown()
+    df_iplm.to_excel(raw_dm_path, index=False)
+
+    # 7) Analisis AI (GAP only)
+    analysis_text = generate_llm_gap_report(verif_df, prov_value, kab_value, kew_value)
+    word_path = generate_word_report_gap(verif_df, prov_value, kab_value, kew_value, analysis_text)
 
-    gr.Markdown("## 1) Indeks Agregat (FINAL)")
-    out_agg_overall = gr.DataFrame(interactive=False)
+    msg = (
+        f"OK | Subset DM: {len(df_iplm)} baris | Verifikasi: {len(verif_df)} baris | "
+        f"Debug meta: {len(dbg_meta)} baris | Target: {int(TARGET_COVERAGE*100)}%."
+    )
 
-    gr.Markdown("## 2) Hasil Agregat (FINAL) — per Jenis Perpustakaan")
-    out_agg_final = gr.DataFrame(interactive=False)
+    return verif_df, detail_df, dbg_meta, fig_gap, rekap_excel_path, raw_dm_path, word_path, msg, analysis_text
 
-    gr.Markdown("## 3) Hasil Detail (FINAL) — per Unit")
-    out_det_final = gr.DataFrame(interactive=False)
+def on_prov_change(prov_value):
+    return gr.update(choices=get_kab_choices_for_prov(prov_value), value="(Semua)")
 
-    gr.Markdown("## 4) Hasil Agregat (RealScore) — per Jenis (Subindeks & Dimensi)")
-    out_agg_real = gr.DataFrame(interactive=False)
 
-    gr.Markdown("## 5) Detail Indeks (RealScore) — per Unit (Subindeks & Dimensi + Indikator)")
-    out_det_real = gr.DataFrame(interactive=False)
+# ============================================================
+# 12) BUILD UI
+# ============================================================
+with gr.Blocks() as demo:
+    gr.Markdown(
+        f"""
+# IPLM + Gap Sampel {int(TARGET_COVERAGE*100)}% + LLM Report
 
-    gr.Markdown("## 6) Coverage Populasi vs Sampel (Target 68%)")
-    out_cov_html = gr.HTML()  # ✅ biar kebaca
+**Data:**
+- DM: `{DATA_FILE}` (multi-sheet)
+- Meta Kab/Kota: `{META_KAB_FILE}`
+- Meta Provinsi (SMA): `{META_SMA_FILE}`
 
-    gr.Markdown("## Grafik BAR — Populasi vs Sampel")
-    out_bar = gr.Plot()
+{DATA_INFO}
+
+**Catatan FIX jumlah sekolah tidak kedetect:**
+- Join meta sekarang pakai `prov_key + kab_key` (lebih presisi) + fallback `kab_key`.
+- Lihat sheet/tabel **Meta_Match_Debug** untuk kab/kota yang *NO_META_ROW* atau *pop_sd_smp = 0*.
+"""
+    )
+
+    with gr.Row():
+        dd_prov = gr.Dropdown(label="Provinsi", choices=prov_choices, value=prov_choices[0])
+        dd_kab  = gr.Dropdown(label="Kab/Kota", choices=kab_choices, value=kab_choices[0])
+        dd_kew  = gr.Dropdown(label="Kewenangan", choices=kew_choices, value=default_kew)
+
+    dd_prov.change(fn=on_prov_change, inputs=dd_prov, outputs=dd_kab)
+
+    run_btn = gr.Button("Run (Hitung IPLM + Gap Sampel)")
+    msg_out = gr.Markdown()
 
-    gr.Markdown("## Sebaran Indeks — Semua Perpustakaan (RealScore)")
-    out_bell_all = gr.Plot()
+    gr.Markdown("## 1) Verifikasi Gap (Target & Kekurangan Unit)")
+    verif_out = gr.DataFrame(interactive=False)
 
-    gr.Markdown("## Sebaran Indeks — Perpustakaan Sekolah (RealScore)")
-    out_bell_sek = gr.Plot()
+    gr.Markdown("## 2) Grafik Kekurangan Sampel (Top 50 biar kebaca)")
+    gap_plot_out = gr.Plot()
 
-    gr.Markdown("## Sebaran Indeks — Perpustakaan Umum (RealScore)")
-    out_bell_um = gr.Plot()
+    gr.Markdown("## 3) Detail Subset (IPLM Real + Final)")
+    detail_out = gr.DataFrame(interactive=False)
 
-    gr.Markdown("## Sebaran Indeks — Perpustakaan Khusus (RealScore)")
-    out_bell_kh = gr.Plot()
+    gr.Markdown("## 4) Debug Meta (Kenapa SD/SMP tidak kedetect?)")
+    dbg_out = gr.DataFrame(interactive=False)
 
-    gr.Markdown("## Analisis (LLM / Template)")
-    out_analysis = gr.Markdown()
+    gr.Markdown("## 5) Analisis Naratif (LLM) — GAP ONLY")
+    analysis_out = gr.Markdown()
 
     with gr.Row():
-        f1 = gr.File(label="Download Agregat FINAL (.xlsx)")
-        f2 = gr.File(label="Download Detail FINAL (.xlsx)")
-        f3 = gr.File(label="Download Laporan Word (.docx) (opsional)")
+        rekap_excel_out = gr.File(label="Download Rekap (.xlsx)")
+        raw_dm_out      = gr.File(label="Download DM Subset + IPLM (.xlsx)")
+        word_out        = gr.File(label="Download Laporan Word (.docx)")
 
     run_btn.click(
-        fn=run_app,
-        inputs=[dd_prov, dd_kab, dd_kew, use_llm, hf_model],
+        fn=run_core,
+        inputs=[dd_prov, dd_kab, dd_kew],
         outputs=[
-            out_agg_overall, out_agg_final, out_det_final,
-            out_agg_real, out_det_real,
-            out_cov_html,
-            out_bar, out_bell_all, out_bell_sek, out_bell_um, out_bell_kh,
-            f1, f2, f3,
-            out_analysis,
-            msg_out
+            verif_out, detail_out, dbg_out,
+            gap_plot_out,
+            rekap_excel_out, raw_dm_out, word_out,
+            msg_out, analysis_out
         ],
     )