Update app.py

app.py

@@ -355,11 +355,6 @@ def _parse_pop_khusus(path_xlsx: str) -> pd.DataFrame:
     if c_mix is None:
         raise ValueError("POP_KHUSUS: kolom gabungan Provinsi/Kab/Kota tidak ditemukan.")
 
-    # =========================
-    # UPDATE SESUAI REQUEST:
-    # POP khusus ada di kolom POP_KHUSUS
-    # target 68% khusus ada di kolom SAMPEL_KHUSUS_68%
-    # =========================
     c_target = pick_col(df, [
         "SAMPEL_KHUSUS_68%", "Sampel_Khusus_68%", "sampel_khusus_68%",
         "SAMPEL_KHUSUS_68", "Sampel_Khusus_68", "sampel_khusus_68",
@@ -367,7 +362,6 @@ def _parse_pop_khusus(path_xlsx: str) -> pd.DataFrame:
         "sampel_total","Sampel_total","TOTAL_SAMPEL","total_sampel",
         "target","Target","Sampel"
     ])
-
     c_pop = pick_col(df, [
         "POP_KHUSUS", "Pop_Khusus", "pop_khusus",
         "total_populasi","Total Populasi","POPULASI","populasi",
@@ -383,8 +377,8 @@ def _parse_pop_khusus(path_xlsx: str) -> pd.DataFrame:
         c_target = numeric_cols[0]
 
     mix = df[c_mix].astype(str).fillna("").str.strip()
-    target_series = df[c_target].apply(coerce_num) if c_target else pd.Series([np.nan]*len(df))
-    pop_series    = df[c_pop].apply(coerce_num) if c_pop else pd.Series([np.nan]*len(df))
+    target_series = df[c_target].apply(coerce_num) if c_target else pd.Series([np.nan] * len(df))
+    pop_series = df[c_pop].apply(coerce_num) if c_pop else pd.Series([np.nan] * len(df))
 
     rows = []
     current_prov = None
@@ -420,29 +414,7 @@ def _parse_pop_khusus(path_xlsx: str) -> pd.DataFrame:
     m_need_target = pop["Target68_Total_Jenis"].isna() & pop["Pop_Total_Jenis"].notna() & (pop["Pop_Total_Jenis"] > 0)
     pop.loc[m_need_target, "Target68_Total_Jenis"] = pop.loc[m_need_target, "Pop_Total_Jenis"] * float(FALLBACK_TARGET_RATIO)
 
-    # agregat per kab (tetap seperti sebelumnya)
-    pop = pop.groupby("kab_key", as_index=False).agg({
-        "Kab_Kota_Label": "first",
-        "Provinsi_Label": "first",
-        "Target68_Total_Jenis": "max",
-        "Pop_Total_Jenis": "max",
-        "prov_key": "first",
-    })
-    return pop
-
-
-    pop["kab_key"] = pop["Kab_Kota_Label"].apply(norm_kab_label)
-    pop["prov_key"] = pop["Provinsi_Label"].apply(norm_prov_label)
-
-    pop["Target68_Total_Jenis"] = pd.to_numeric(pop["Target68_Total_Jenis"], errors="coerce")
-    pop["Pop_Total_Jenis"] = pd.to_numeric(pop["Pop_Total_Jenis"], errors="coerce")
-
-    m_need_pop = pop["Pop_Total_Jenis"].isna() & pop["Target68_Total_Jenis"].notna() & (pop["Target68_Total_Jenis"] > 0)
-    pop.loc[m_need_pop, "Pop_Total_Jenis"] = pop.loc[m_need_pop, "Target68_Total_Jenis"] / float(FALLBACK_TARGET_RATIO)
-
-    m_need_target = pop["Target68_Total_Jenis"].isna() & pop["Pop_Total_Jenis"].notna() & (pop["Pop_Total_Jenis"] > 0)
-    pop.loc[m_need_target, "Target68_Total_Jenis"] = pop.loc[m_need_target, "Pop_Total_Jenis"] * float(FALLBACK_TARGET_RATIO)
-
+    # keep per kab_key
     pop = pop.groupby("kab_key", as_index=False).agg({
         "Kab_Kota_Label": "first",
         "Provinsi_Label": "first",
@@ -452,40 +424,60 @@ def _parse_pop_khusus(path_xlsx: str) -> pd.DataFrame:
     })
     return pop
 
-def load_default_files(force=False):
+def load_default_files(force: bool = False):
     key = (
         DATA_FILE, POP_KAB, POP_PROV, POP_KHUSUS,
         _mtime(DATA_FILE), _mtime(POP_KAB), _mtime(POP_PROV), _mtime(POP_KHUSUS)
     )
 
     if (not force) and _CACHE["key"] == key and _CACHE["df_all"] is not None:
-        return _CACHE["df_all"], _CACHE["df_raw"], _CACHE["pop_kab"], _CACHE["pop_prov"], _CACHE["pop_khusus"], _CACHE["meta"], _CACHE["info"]
+        return (
+            _CACHE["df_all"], _CACHE["df_raw"],
+            _CACHE["pop_kab"], _CACHE["pop_prov"], _CACHE["pop_khusus"],
+            _CACHE["meta"], _CACHE["info"]
+        )
 
     for p, label in [(DATA_FILE, "DM"), (POP_KAB, "POP_KAB"), (POP_PROV, "POP_PROV"), (POP_KHUSUS, "POP_KHUSUS")]:
         if not Path(p).exists():
             info = f"❌ File {label} tidak ditemukan: `{p}`"
-            _CACHE.update({"key": key, "df_all": None, "df_raw": None, "pop_kab": None, "pop_prov": None, "pop_khusus": None, "meta": {}, "info": info})
+            _CACHE.update({
+                "key": key, "df_all": None, "df_raw": None,
+                "pop_kab": None, "pop_prov": None, "pop_khusus": None,
+                "meta": {}, "info": info
+            })
             return None, None, None, None, None, {}, info
 
+    # =========================
+    # DM gabungan semua sheet
+    # =========================
     fp = Path(DATA_FILE)
     xls = pd.ExcelFile(fp)
     frames = [pd.read_excel(fp, sheet_name=s) for s in xls.sheet_names]
     df_raw = pd.concat(frames, ignore_index=True, sort=False)
 
-    prov_col  = pick_col(df_raw, ["provinsi", "Provinsi", "PROVINSI"])
-    kab_col   = pick_col(df_raw, ["kab_kota", "Kab/Kota", "Kab_Kota", "KAB/KOTA", "kabupaten_kota", "Kabupaten/Kota", "kabupaten kota", "kota"])
-    kew_col   = pick_col(df_raw, ["kewenangan", "jenis_kewenangan", "Kewenangan", "KEWENANGAN"])
+    prov_col = pick_col(df_raw, ["provinsi", "Provinsi", "PROVINSI"])
+    kab_col = pick_col(df_raw, ["kab_kota", "Kab/Kota", "Kab_Kota", "KAB/KOTA", "kabupaten_kota", "Kabupaten/Kota", "kabupaten kota", "kota"])
+    kew_col = pick_col(df_raw, ["kewenangan", "jenis_kewenangan", "Kewenangan", "KEWENANGAN"])
     jenis_col = pick_col(df_raw, ["jenis_perpustakaan", "Jenis Perpustakaan", "JENIS_PERPUSTAKAAN"])
-    nama_col  = pick_col(df_raw, ["nm_perpustakaan","nama_perpustakaan","Nama Perpustakaan","nm_instansi_lembaga","nm_perpus"])
+    nama_col = pick_col(df_raw, ["nm_perpustakaan","nama_perpustakaan","Nama Perpustakaan","nm_instansi_lembaga","nm_perpus"])
 
     missing = []
-    if prov_col is None:  missing.append("Provinsi")
-    if kab_col is None:   missing.append("Kab/Kota")
-    if kew_col is None:   missing.append("Kewenangan")
-    if jenis_col is None: missing.append("Jenis Perpustakaan")
+    if prov_col is None:
+        missing.append("Provinsi")
+    if kab_col is None:
+        missing.append("Kab/Kota")
+    if kew_col is None:
+        missing.append("Kewenangan")
+    if jenis_col is None:
+        missing.append("Jenis Perpustakaan")
+
     if missing:
         info = f"❌ Kolom wajib tidak ditemukan di DM: {', '.join(missing)}"
-        _CACHE.update({"key": key, "df_all": None, "df_raw": None, "pop_kab": None, "pop_prov": None, "pop_khusus": None, "meta": {}, "info": info})
+        _CACHE.update({
+            "key": key, "df_all": None, "df_raw": None,
+            "pop_kab": None, "pop_prov": None, "pop_khusus": None,
+            "meta": {}, "info": info
+        })
         return None, None, None, None, None, {}, info
 
     val_map_jenis = {
@@ -494,12 +486,12 @@ def load_default_files(force=False):
         "PERPUSTAKAAN KHUSUS": "khusus", "KHUSUS": "khusus",
     }
 
-    df_raw["KEW_NORM"]  = df_raw[kew_col].apply(norm_kew)
-    df_raw["_dataset"]  = df_raw[jenis_col].astype(str).str.strip().str.upper().map(val_map_jenis)
+    df_raw["KEW_NORM"] = df_raw[kew_col].apply(norm_kew)
+    df_raw["_dataset"] = df_raw[jenis_col].astype(str).str.strip().str.upper().map(val_map_jenis)
     df_raw["PROV_DISP"] = df_raw[prov_col].apply(norm_prov_disp)
-    df_raw["KAB_DISP"]  = df_raw[kab_col].apply(_disp_text)
-    df_raw["prov_key"]  = df_raw["PROV_DISP"].apply(norm_prov_label)
-    df_raw["kab_key"]   = df_raw["KAB_DISP"].apply(norm_kab_label)
+    df_raw["KAB_DISP"] = df_raw[kab_col].apply(_disp_text)
+    df_raw["prov_key"] = df_raw["PROV_DISP"].apply(norm_prov_label)
+    df_raw["kab_key"] = df_raw["KAB_DISP"].apply(norm_kab_label)
 
     if nama_col and nama_col in df_raw.columns:
         kcols = [prov_col, kab_col, kew_col, jenis_col, nama_col]
@@ -513,11 +505,11 @@ def load_default_files(force=False):
     after = len(df_raw)
 
     # =========================
-    # POP KAB
+    # POP KAB (KEEP PER-JENIS)
     # =========================
     pk = pd.read_excel(POP_KAB)
 
-    c_kab  = pick_col(pk, ["KABUPATEN_KOTA","Kab/Kota","Kabupaten/Kota","KAB/KOTA","Kabupaten_Kota","kab_kota","kabupaten_kota"])
+    c_kab = pick_col(pk, ["KABUPATEN_KOTA","Kab/Kota","Kabupaten/Kota","KAB/KOTA","Kabupaten_Kota","kab_kota","kabupaten_kota"])
     c_prov = pick_col(pk, ["PROVINSI","Provinsi","provinsi"])
 
     c_target_total = pick_col(pk, [
@@ -525,80 +517,113 @@ def load_default_files(force=False):
         "target_total_68","Target_Total_68","target_68","TARGET_68"
     ])
 
-    c_pop_total = pick_col(pk, [
-        "total_populasi","Total Populasi","POPULASI","populasi",
-        "jumlah_penduduk","Jumlah Penduduk","PENDUDUK","penduduk",
-        "total_penduduk","Total Penduduk","TOTAL_PENDUDUK","total_pend",
-        "jumlah_populasi","Jumlah Populasi","pop_total","Pop_Total",
-        "n_populasi","N_POPULASI","n_penduduk","N_PENDUDUK"
-    ])
+    # REAL kolom file user:
+    c_pop_umum = pick_col(pk, ["jumlah_populasi_umum","Jumlah_populasi_umum","JUMLAH_POPULASI_UMUM","POP_UMUM","pop_umum"])
+    c_target_umum = pick_col(pk, ["Sampel_umum_68%","Sampel_umum_68","SAMPEL_UMUM_68%","SAMPEL_UMUM_68","TARGET_UMUM_68"])
+
+    c_pop_sekolah = pick_col(pk, ["jumlah_populasi_sekolah","Jumlah_populasi_sekolah","JUMLAH_POPULASI_SEKOLAH","POP_SEKOLAH","pop_sekolah"])
+    c_target_sekolah = pick_col(pk, ["Sampel_sekolah_68%","Sampel_sekolah_68","SAMPEL_SEKOLAH_68%","SAMPEL_SEKOLAH_68","TARGET_SEKOLAH_68"])
 
     if c_kab is None or c_target_total is None:
         info = "❌ POP_KAB: wajib ada kolom Kab/Kota dan sampel_total (target 68%)."
-        _CACHE.update({"key": key, "df_all": None, "df_raw": None, "pop_kab": None, "pop_prov": None, "pop_khusus": None, "meta": {}, "info": info})
+        _CACHE.update({
+            "key": key, "df_all": None, "df_raw": None,
+            "pop_kab": None, "pop_prov": None, "pop_khusus": None,
+            "meta": {}, "info": info
+        })
         return None, None, None, None, None, {}, info
 
     pop_kab = pd.DataFrame({
         "Provinsi_Label": pk[c_prov].astype(str).str.strip() if c_prov else "",
         "Kab_Kota_Label": pk[c_kab].astype(str).str.strip(),
         "Target68_Total": pk[c_target_total].apply(coerce_num),
-        "Pop_Total": pk[c_pop_total].apply(coerce_num) if c_pop_total else np.nan,
+        "Pop_Umum": pk[c_pop_umum].apply(coerce_num) if c_pop_umum else np.nan,
+        "Target68_Umum": pk[c_target_umum].apply(coerce_num) if c_target_umum else np.nan,
+        "Pop_Sekolah": pk[c_pop_sekolah].apply(coerce_num) if c_pop_sekolah else np.nan,
+        "Target68_Sekolah": pk[c_target_sekolah].apply(coerce_num) if c_target_sekolah else np.nan,
     })
 
-    pop_kab["Pop_Total"] = pd.to_numeric(pop_kab["Pop_Total"], errors="coerce")
-    pop_kab["Target68_Total"] = pd.to_numeric(pop_kab["Target68_Total"], errors="coerce")
+    # fallback target per jenis dari pop
+    m = pop_kab["Target68_Umum"].isna() & pop_kab["Pop_Umum"].notna() & (pop_kab["Pop_Umum"] > 0)
+    pop_kab.loc[m, "Target68_Umum"] = pop_kab.loc[m, "Pop_Umum"] * float(FALLBACK_TARGET_RATIO)
+
+    m = pop_kab["Target68_Sekolah"].isna() & pop_kab["Pop_Sekolah"].notna() & (pop_kab["Pop_Sekolah"] > 0)
+    pop_kab.loc[m, "Target68_Sekolah"] = pop_kab.loc[m, "Pop_Sekolah"] * float(FALLBACK_TARGET_RATIO)
 
-    mask_need_pop = pop_kab["Pop_Total"].isna() & pop_kab["Target68_Total"].notna() & (pop_kab["Target68_Total"] > 0)
-    pop_kab.loc[mask_need_pop, "Pop_Total"] = pop_kab.loc[mask_need_pop, "Target68_Total"] / float(FALLBACK_TARGET_RATIO)
+    pop_kab["Pop_Total"] = (
+        pd.to_numeric(pop_kab["Pop_Umum"], errors="coerce").fillna(0.0)
+        + pd.to_numeric(pop_kab["Pop_Sekolah"], errors="coerce").fillna(0.0)
+    )
+
+    m_need_pop = (pop_kab["Pop_Total"] <= 0) & pop_kab["Target68_Total"].notna() & (pop_kab["Target68_Total"] > 0)
+    pop_kab.loc[m_need_pop, "Pop_Total"] = pop_kab.loc[m_need_pop, "Target68_Total"] / float(FALLBACK_TARGET_RATIO)
 
     pop_kab["kab_key"] = pop_kab["Kab_Kota_Label"].apply(norm_kab_label)
+
     pop_kab = pop_kab.groupby("kab_key", as_index=False).agg({
-        "Kab_Kota_Label":"first",
-        "Provinsi_Label":"first",
-        "Target68_Total":"max",
-        "Pop_Total":"max",
+        "Kab_Kota_Label": "first",
+        "Provinsi_Label": "first",
+        "Target68_Total": "max",
+        "Pop_Total": "max",
+        "Pop_Umum": "max",
+        "Target68_Umum": "max",
+        "Pop_Sekolah": "max",
+        "Target68_Sekolah": "max",
     })
 
     # =========================
-    # POP PROV
+    # POP PROV (KEEP PER-JENIS)
     # =========================
     pp = pd.read_excel(POP_PROV)
 
     c_pr = pick_col(pp, ["Provinsi","PROVINSI","provinsi","Propinsi","PROPINSI","propinsi"])
-    c_target_total = pick_col(pp, [
-        "total _sampel","total_sampel","TOTAL_SAMPEL","Total Sampel",
-        "target_total_68","Target_Total_68","target_68","TARGET_68"
-    ])
-    c_pop_total = pick_col(pp, [
-        "total_populasi","Total Populasi","POPULASI","populasi",
-        "jumlah_penduduk","Jumlah Penduduk","PENDUDUK","penduduk",
-        "total_penduduk","Total Penduduk","TOTAL_PENDUDUK","total_pend",
-        "total_pend_dukcapil","TOTAL_PEND_DUKCAPIL",
-        "pop_total","Pop_Total"
-    ])
+    c_target_total = pick_col(pp, ["total _sampel","total_sampel","TOTAL_SAMPEL","Total Sampel","target_total_68","Target_Total_68"])
+
+    # REAL kolom file user:
+    c_pop_sekolah = pick_col(pp, ["total_pend","TOTAL_PEND","total_penduduk","Total Penduduk"])
+    c_pop_umum = pick_col(pp, ["perpus_umum_prop","PERPUS_UMUM_PROP","Perpus_umum_prop"])
 
     if c_pr is None or c_target_total is None:
         info = "❌ POP_PROV: wajib ada kolom Provinsi dan total _sampel (target 68%)."
-        _CACHE.update({"key": key, "df_all": None, "df_raw": None, "pop_kab": None, "pop_prov": None, "pop_khusus": None, "meta": {}, "info": info})
+        _CACHE.update({
+            "key": key, "df_all": None, "df_raw": None,
+            "pop_kab": None, "pop_prov": None, "pop_khusus": None,
+            "meta": {}, "info": info
+        })
         return None, None, None, None, None, {}, info
 
     pop_prov = pd.DataFrame({
         "Provinsi_Label": pp[c_pr].astype(str).str.strip(),
         "Target68_Total_Prov": pp[c_target_total].apply(coerce_num),
-        "Pop_Total_Prov": pp[c_pop_total].apply(coerce_num) if c_pop_total else np.nan,
+
+        "Pop_Sekolah_Prov": pp[c_pop_sekolah].apply(coerce_num) if c_pop_sekolah else np.nan,
+        "Target68_Sekolah_Prov": pp[c_target_total].apply(coerce_num),  # sesuai file user
+
+        "Pop_Umum_Prov": pp[c_pop_umum].apply(coerce_num) if c_pop_umum else np.nan,
+        "Target68_Umum_Prov": np.nan,
     })
 
-    pop_prov["Pop_Total_Prov"] = pd.to_numeric(pop_prov["Pop_Total_Prov"], errors="coerce")
-    pop_prov["Target68_Total_Prov"] = pd.to_numeric(pop_prov["Target68_Total_Prov"], errors="coerce")
+    m = pop_prov["Target68_Umum_Prov"].isna() & pop_prov["Pop_Umum_Prov"].notna() & (pop_prov["Pop_Umum_Prov"] > 0)
+    pop_prov.loc[m, "Target68_Umum_Prov"] = pop_prov.loc[m, "Pop_Umum_Prov"] * float(FALLBACK_TARGET_RATIO)
+
+    pop_prov["Pop_Total_Prov"] = (
+        pd.to_numeric(pop_prov["Pop_Sekolah_Prov"], errors="coerce").fillna(0.0)
+        + pd.to_numeric(pop_prov["Pop_Umum_Prov"], errors="coerce").fillna(0.0)
+    )
 
-    mask_need_pop = pop_prov["Pop_Total_Prov"].isna() & pop_prov["Target68_Total_Prov"].notna() & (pop_prov["Target68_Total_Prov"] > 0)
-    pop_prov.loc[mask_need_pop, "Pop_Total_Prov"] = pop_prov.loc[mask_need_pop, "Target68_Total_Prov"] / float(FALLBACK_TARGET_RATIO)
+    m_need_pop = (pop_prov["Pop_Total_Prov"] <= 0) & pop_prov["Target68_Total_Prov"].notna() & (pop_prov["Target68_Total_Prov"] > 0)
+    pop_prov.loc[m_need_pop, "Pop_Total_Prov"] = pop_prov.loc[m_need_pop, "Target68_Total_Prov"] / float(FALLBACK_TARGET_RATIO)
 
     pop_prov["prov_key"] = pop_prov["Provinsi_Label"].apply(norm_prov_label)
+
     pop_prov = pop_prov.groupby("prov_key", as_index=False).agg({
-        "Provinsi_Label":"first",
-        "Target68_Total_Prov":"max",
-        "Pop_Total_Prov":"max",
+        "Provinsi_Label": "first",
+        "Target68_Total_Prov": "max",
+        "Pop_Total_Prov": "max",
+        "Pop_Sekolah_Prov": "max",
+        "Target68_Sekolah_Prov": "max",
+        "Pop_Umum_Prov": "max",
+        "Target68_Umum_Prov": "max",
     })
 
     # =========================
@@ -608,19 +633,22 @@ def load_default_files(force=False):
         pop_khusus = _parse_pop_khusus(POP_KHUSUS)
     except Exception as e:
         info = f"❌ POP_KHUSUS gagal dibaca: {repr(e)}"
-        _CACHE.update({"key": key, "df_all": None, "df_raw": None, "pop_kab": None, "pop_prov": None, "pop_khusus": None, "meta": {}, "info": info})
+        _CACHE.update({
+            "key": key, "df_all": None, "df_raw": None,
+            "pop_kab": None, "pop_prov": None, "pop_khusus": None,
+            "meta": {}, "info": info
+        })
         return None, None, None, None, None, {}, info
 
     df_all = prepare_global(df_raw)
-
     meta = dict(prov_col=prov_col, kab_col=kab_col, kew_col=kew_col, jenis_col=jenis_col, nama_col=nama_col)
 
     info = (
         f"✅ Mode NO UPLOAD (cache aktif)<br>"
         f"✅ DM: <b>{fp.name}</b> | Baris: {before} → dedup: {after}<br>"
-        f"✅ POP_KAB: <b>{Path(POP_KAB).name}</b> (n={len(pop_kab)}) — target 68% via <code>sampel_total</code> (Pop_Total auto fallback)<br>"
-        f"✅ POP_PROV: <b>{Path(POP_PROV).name}</b> (n={len(pop_prov)}) — target 68% via <code>total _sampel</code> (Pop_Total auto fallback)<br>"
-        f"✅ POP_KHUSUS: <b>{Path(POP_KHUSUS).name}</b> (n={len(pop_khusus)}) — format gabungan Provinsi/Kab/Kota (Target/Pop auto fallback)<br>"
+        f"✅ POP_KAB: <b>{Path(POP_KAB).name}</b> (n={len(pop_kab)}) — keep per-jenis (umum+sekolah)<br>"
+        f"✅ POP_PROV: <b>{Path(POP_PROV).name}</b> (n={len(pop_prov)}) — keep per-jenis (umum+sekolah)<br>"
+        f"✅ POP_KHUSUS: <b>{Path(POP_KHUSUS).name}</b> (n={len(pop_khusus)}) — khusus per kab + prov_key<br>"
         f"🕒 mtime: DM={time.ctime(_mtime(DATA_FILE))} | Kab={time.ctime(_mtime(POP_KAB))} | Prov={time.ctime(_mtime(POP_PROV))} | Khusus={time.ctime(_mtime(POP_KHUSUS))}"
     )
 
@@ -634,74 +662,35 @@ def load_default_files(force=False):
         "meta": meta,
         "info": info
     })
+
     return df_all, df_raw, pop_kab, pop_prov, pop_khusus, meta, info
 
 
 # ============================================================
-# 6) FAKTOR WILAYAH — PER JENIS (PATCH UTAMA)
+# 6) FAKTOR WILAYAH — PER JENIS
+#    - sekolah/umum: dari pop_kab/pop_prov (kolom per-jenis hasil loader)
+#    - khusus: dari pop_khusus (sum per wilayah)
 # ============================================================
 
 def _read_target_pop_per_jenis_from_pop(pop_df: pd.DataFrame, mode: str):
-    """
-    Mengambil mapping target/pop PER JENIS untuk sekolah & umum dari POP_KAB/POP_PROV
-    sesuai nama kolom REAL di file Excel user.
-
-    Return:
-      dict: {"sekolah": (target_col, pop_col), "umum": (target_col, pop_col)}
-    """
     if pop_df is None or pop_df.empty:
         return {"sekolah": (None, None), "umum": (None, None)}
 
-    # =========================
-    # POP KAB (Data_populasi_Kab_kota_fixed.xlsx)
-    # - umum: jumlah_populasi_umum, Sampel_umum_68%
-    # - sekolah: jumlah_populasi_sekolah, Sampel_sekolah_68%
-    # =========================
-    sekolah_target = pick_col(pop_df, [
-        "Sampel_sekolah_68%", "Sampel_sekolah_68", "SAMPEL_SEKOLAH_68%", "SAMPEL_SEKOLAH_68",
-        "TARGET_SEKOLAH_68", "Target_Sekolah_68", "target_sekolah_68",
-        "SAMPEL_SEKOLAH_68", "Sampel_Sekolah_68"
-    ])
-    sekolah_pop = pick_col(pop_df, [
-        "jumlah_populasi_sekolah", "Jumlah_populasi_sekolah", "JUMLAH_POPULASI_SEKOLAH",
-        "POP_SEKOLAH", "Pop_Sekolah", "pop_sekolah",
-        "POPULASI_SEKOLAH", "Populasi_Sekolah"
-    ])
+    mode = str(mode).upper()
 
-    umum_target = pick_col(pop_df, [
-        "Sampel_umum_68%", "Sampel_umum_68", "SAMPEL_UMUM_68%", "SAMPEL_UMUM_68",
-        "TARGET_UMUM_68", "Target_Umum_68", "target_umum_68",
-        "SAMPEL_UMUM_68", "Sampel_Umum_68"
-    ])
-    umum_pop = pick_col(pop_df, [
-        "jumlah_populasi_umum", "Jumlah_populasi_umum", "JUMLAH_POPULASI_UMUM",
-        "POP_UMUM", "Pop_Umum", "pop_umum",
-        "POPULASI_UMUM", "Populasi_Umum",
-        # POP PROV umum:
-        "perpus_umum_prop", "Perpus_umum_prop", "PERPUS_UMUM_PROP"
-    ])
-
-    # =========================
-    # POP PROV (Data_populasi_propinsi.xlsx)
-    # - sekolah: total_pend, total _sampel
-    # - umum: perpus_umum_prop, target dihitung jika tidak ada
-    # =========================
-    if str(mode).upper() == "PROV":
-        # override sekolah kalau ada kolom prov yang lebih spesifik
-        sekolah_pop2 = pick_col(pop_df, ["total_pend", "TOTAL_PEND", "total_penduduk", "Total Pend"])
-        sekolah_target2 = pick_col(pop_df, ["total _sampel", "total_sampel", "TOTAL_SAMPEL", "Total Sampel"])
-
-        if sekolah_pop2 is not None:
-            sekolah_pop = sekolah_pop2
-        if sekolah_target2 is not None:
-            sekolah_target = sekolah_target2
-
-        # umum target prov kadang tidak ada -> akan dihitung dari pop (0.68 * pop) di bawah
-        # (jadi umum_target boleh None)
+    if mode == "KAB":
+        sekolah_target = pick_col(pop_df, ["Target68_Sekolah"])
+        sekolah_pop = pick_col(pop_df, ["Pop_Sekolah"])
+        umum_target = pick_col(pop_df, ["Target68_Umum"])
+        umum_pop = pick_col(pop_df, ["Pop_Umum"])
+    else:
+        sekolah_target = pick_col(pop_df, ["Target68_Sekolah_Prov"])
+        sekolah_pop = pick_col(pop_df, ["Pop_Sekolah_Prov"])
+        umum_target = pick_col(pop_df, ["Target68_Umum_Prov"])
+        umum_pop = pick_col(pop_df, ["Pop_Umum_Prov"])
 
     return {"sekolah": (sekolah_target, sekolah_pop), "umum": (umum_target, umum_pop)}
 
-
 def build_faktor_wilayah_jenis(
     df_filtered: pd.DataFrame,
     pop_kab: pd.DataFrame,
@@ -709,13 +698,6 @@ def build_faktor_wilayah_jenis(
     pop_khusus: pd.DataFrame,
     kew_value: str
 ):
-    """
-    Output: faktor per (wilayah x jenis)
-    Kolom:
-      group_key, [Kab/Kota|Provinsi], Jenis,
-      n_jenis, target_total_68_jenis, pop_total_jenis,
-      coverage_jenis_%, faktor_penyesuaian_jenis, gap_target68_jenis
-    """
     if df_filtered is None or df_filtered.empty:
         return pd.DataFrame()
 
@@ -725,7 +707,6 @@ def build_faktor_wilayah_jenis(
     if df.empty:
         return pd.DataFrame()
 
-    # tentukan level
     if "PROV" in kew_norm:
         key_col, label_col, label_name, mode = "prov_key", "PROV_DISP", "Provinsi", "PROV"
         pop_base = pop_prov.set_index("prov_key") if (pop_prov is not None and not pop_prov.empty and "prov_key" in pop_prov.columns) else pd.DataFrame().set_index(pd.Index([]))
@@ -733,7 +714,6 @@ def build_faktor_wilayah_jenis(
         key_col, label_col, label_name, mode = "kab_key", "KAB_DISP", "Kab/Kota", "KAB"
         pop_base = pop_kab.set_index("kab_key") if (pop_kab is not None and not pop_kab.empty and "kab_key" in pop_kab.columns) else pd.DataFrame().set_index(pd.Index([]))
 
-    # hitung n per jenis
     base_n = (
         df.groupby([key_col, label_col, "_dataset"], dropna=False)
           .size()
@@ -742,75 +722,71 @@ def build_faktor_wilayah_jenis(
     )
     base_n["Jenis"] = base_n["Jenis"].astype(str).str.lower().str.strip()
 
-    # mapping kolom target/pop sesuai Excel user
-    tp_map = _read_target_pop_per_jenis_from_pop(pop_base.reset_index(), mode=mode)
-
-    # default 0 (biar tidak NaN)
     base_n["target_total_68_jenis"] = 0.0
     base_n["pop_total_jenis"] = 0.0
 
-    # =========================
-    # sekolah & umum dari POP_KAB / POP_PROV
-    # =========================
+    # sekolah & umum dari POP_KAB/POP_PROV
+    tp = _read_target_pop_per_jenis_from_pop(pop_base.reset_index(), mode=mode)
     for j in ["sekolah", "umum"]:
-        tcol, pcol = tp_map.get(j, (None, None))
+        tcol, pcol = tp.get(j, (None, None))
         if pop_base.empty:
             continue
 
-        # pop
         if pcol is not None and pcol in pop_base.columns:
             pser = pd.to_numeric(pop_base[pcol], errors="coerce").fillna(0.0)
         else:
             pser = pd.Series(0.0, index=pop_base.index)
 
-        # target (kalau tidak ada kolom target khusus—khususnya PROV untuk umum—hitung dari pop)
         if tcol is not None and tcol in pop_base.columns:
             tser = pd.to_numeric(pop_base[tcol], errors="coerce").fillna(0.0)
         else:
-            # fallback: target = 0.68 * pop (khusus PROV untuk umum biasanya)
             tser = (pser.astype(float) * float(FALLBACK_TARGET_RATIO)).fillna(0.0)
 
         mask = base_n["Jenis"].eq(j)
         base_n.loc[mask, "pop_total_jenis"] = base_n.loc[mask, "group_key"].map(pser).fillna(0.0).values
         base_n.loc[mask, "target_total_68_jenis"] = base_n.loc[mask, "group_key"].map(tser).fillna(0.0).values
 
-    # =========================
     # KHUSUS dari POP_KHUSUS (sum per wilayah)
-    # =========================
     if pop_khusus is not None and not pop_khusus.empty:
         pk = pop_khusus.copy()
-        pk["Target68_Total_Jenis"] = pd.to_numeric(pk.get("Target68_Total_Jenis", np.nan), errors="coerce").fillna(0.0)
-        pk["Pop_Total_Jenis"] = pd.to_numeric(pk.get("Pop_Total_Jenis", np.nan), errors="coerce").fillna(0.0)
+        pk["Target68_Total_Jenis"] = pd.to_numeric(pk.get("Target68_Total_Jenis", 0), errors="coerce").fillna(0.0)
+        pk["Pop_Total_Jenis"] = pd.to_numeric(pk.get("Pop_Total_Jenis", 0), errors="coerce").fillna(0.0)
 
         if mode == "PROV" and "prov_key" in pk.columns:
-            pk_map = pk.groupby("prov_key", as_index=False).agg(
-                target_total_68_jenis=("Target68_Total_Jenis", "sum"),
-                pop_total_jenis=("Pop_Total_Jenis", "sum"),
-            ).rename(columns={"prov_key": "group_key"})
+            pk_map = (
+                pk.groupby("prov_key", as_index=False)
+                  .agg(
+                      target_total_68_jenis=("Target68_Total_Jenis", "sum"),
+                      pop_total_jenis=("Pop_Total_Jenis", "sum"),
+                  )
+                  .rename(columns={"prov_key": "group_key"})
+            )
         elif mode == "KAB" and "kab_key" in pk.columns:
-            pk_map = pk.groupby("kab_key", as_index=False).agg(
-                target_total_68_jenis=("Target68_Total_Jenis", "sum"),
-                pop_total_jenis=("Pop_Total_Jenis", "sum"),
-            ).rename(columns={"kab_key": "group_key"})
+            pk_map = (
+                pk.groupby("kab_key", as_index=False)
+                  .agg(
+                      target_total_68_jenis=("Target68_Total_Jenis", "sum"),
+                      pop_total_jenis=("Pop_Total_Jenis", "sum"),
+                  )
+                  .rename(columns={"kab_key": "group_key"})
+            )
         else:
-            pk_map = pd.DataFrame(columns=["group_key","target_total_68_jenis","pop_total_jenis"])
+            pk_map = pd.DataFrame(columns=["group_key", "target_total_68_jenis", "pop_total_jenis"])
 
         if not pk_map.empty:
-            mask_khusus = base_n["Jenis"].eq("khusus")
-            tmp = base_n.loc[mask_khusus, ["group_key"]].merge(pk_map, on="group_key", how="left")
-            base_n.loc[mask_khusus, "target_total_68_jenis"] = pd.to_numeric(tmp["target_total_68_jenis"], errors="coerce").fillna(0.0).values
-            base_n.loc[mask_khusus, "pop_total_jenis"] = pd.to_numeric(tmp["pop_total_jenis"], errors="coerce").fillna(0.0).values
+            idx = pk_map.set_index("group_key")
+            mask = base_n["Jenis"].eq("khusus")
+            base_n.loc[mask, "target_total_68_jenis"] = base_n.loc[mask, "group_key"].map(idx["target_total_68_jenis"]).fillna(0.0).values
+            base_n.loc[mask, "pop_total_jenis"] = base_n.loc[mask, "group_key"].map(idx["pop_total_jenis"]).fillna(0.0).values
 
-    # =========================
-    # fallback pop dari target (kalau pop masih 0 tapi target ada)
-    # =========================
+    # fallback pop dari target
     base_n["target_total_68_jenis"] = pd.to_numeric(base_n["target_total_68_jenis"], errors="coerce").fillna(0.0)
     base_n["pop_total_jenis"] = pd.to_numeric(base_n["pop_total_jenis"], errors="coerce").fillna(0.0)
 
     m_need_pop = (base_n["pop_total_jenis"] <= 0) & (base_n["target_total_68_jenis"] > 0)
     base_n.loc[m_need_pop, "pop_total_jenis"] = base_n.loc[m_need_pop, "target_total_68_jenis"] / float(FALLBACK_TARGET_RATIO)
 
-    # faktor
+    # faktor, coverage, gap
     base_n["faktor_penyesuaian_jenis"] = [
         faktor_penyesuaian_total(n, t)
         for n, t in zip(
@@ -820,7 +796,7 @@ def build_faktor_wilayah_jenis(
     ]
 
     base_n["coverage_jenis_%"] = [
-        (safe_div(n, p) * 100) if (p is not None and not pd.isna(p) and float(p) > 0) else 0.0
+        (safe_div(n, p) * 100.0) if (p is not None and not pd.isna(p) and float(p) > 0) else 0.0
         for n, p in zip(
             pd.to_numeric(base_n["n_jenis"], errors="coerce").fillna(0).astype(float).tolist(),
             pd.to_numeric(base_n["pop_total_jenis"], errors="coerce").fillna(0).astype(float).tolist()
@@ -828,19 +804,20 @@ def build_faktor_wilayah_jenis(
     ]
 
     base_n["gap_target68_jenis"] = [
-        max(t - n, 0)
+        max(t - n, 0.0)
         for n, t in zip(
             pd.to_numeric(base_n["n_jenis"], errors="coerce").fillna(0).astype(float).tolist(),
             pd.to_numeric(base_n["target_total_68_jenis"], errors="coerce").fillna(0).astype(float).tolist()
         )
     ]
 
-    # DISPLAY sesuai request (target/pop int, coverage 2 desimal)
+    # display format
     base_n["target_total_68_jenis"] = pd.to_numeric(base_n["target_total_68_jenis"], errors="coerce").fillna(0).round(0).astype(int)
     base_n["pop_total_jenis"] = pd.to_numeric(base_n["pop_total_jenis"], errors="coerce").fillna(0).round(0).astype(int)
+    base_n["n_jenis"] = pd.to_numeric(base_n["n_jenis"], errors="coerce").fillna(0).round(0).astype(int)
+    base_n["gap_target68_jenis"] = pd.to_numeric(base_n["gap_target68_jenis"], errors="coerce").fillna(0).round(0).astype(int)
     base_n["coverage_jenis_%"] = pd.to_numeric(base_n["coverage_jenis_%"], errors="coerce").fillna(0.0).round(2)
     base_n["faktor_penyesuaian_jenis"] = pd.to_numeric(base_n["faktor_penyesuaian_jenis"], errors="coerce").fillna(1.0).round(3)
-    base_n["gap_target68_jenis"] = pd.to_numeric(base_n["gap_target68_jenis"], errors="coerce").fillna(0).round(0).astype(int)
 
     return base_n
 
@@ -923,7 +900,8 @@ def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, faktor_wilayah_jenis: pd.
 
     return agg
 # ============================================================
-# 8) AGREGAT WILAYAH (KESELURUHAN) — FIX: avg3 + tampilkan POP/TARGET/N per jenis
+# 8) AGREGAT WILAYAH (KESELURUHAN) — FIX: avg3 dari 3 jenis
+#     + tampilkan Pop/Target/Terkumpul per jenis & total
 # ============================================================
 
 def build_agg_wilayah_total_from_jenis(agg_jenis: pd.DataFrame, faktor_wilayah_jenis: pd.DataFrame, kew_value: str):
@@ -976,69 +954,59 @@ def build_agg_wilayah_total_from_jenis(agg_jenis: pd.DataFrame, faktor_wilayah_j
         Indeks_Final_Wilayah_0_100=("Indeks_Final_Agregat_0_100", "mean"),
     )
 
-    # --- tempel POP/TARGET/N/COVERAGE/FAKTOR per jenis ke agg_total ---
+    # tempel Pop/Target/Terkumpul per jenis & total
     if faktor_wilayah_jenis is not None and not faktor_wilayah_jenis.empty:
         fw = faktor_wilayah_jenis.copy()
         fw["Jenis"] = fw["Jenis"].astype(str).str.lower().str.strip()
 
-        # pivot per jenis
         piv = fw.pivot_table(
             index=["group_key", label_name],
             columns="Jenis",
-            values=[
-                "pop_total_jenis",
-                "target_total_68_jenis",
-                "n_jenis",
-                "coverage_jenis_%",
-                "faktor_penyesuaian_jenis",
-                "gap_target68_jenis"
-            ],
+            values=["pop_total_jenis", "target_total_68_jenis", "n_jenis", "gap_target68_jenis", "faktor_penyesuaian_jenis"],
             aggfunc="first"
         )
+
         piv.columns = [f"{v}_{k}" for v, k in piv.columns]
         piv = piv.reset_index()
 
         out = out.merge(piv, on=["group_key", label_name], how="left")
 
-        # rapihin NaN -> 0 + tipe
+        # NaN -> 0 / 1
         for j in ["sekolah", "umum", "khusus"]:
             for basecol in ["pop_total_jenis", "target_total_68_jenis", "n_jenis", "gap_target68_jenis"]:
                 c = f"{basecol}_{j}"
                 if c in out.columns:
                     out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0).round(0).astype(int)
 
-            c_cov = f"coverage_jenis_%_{j}"
-            if c_cov in out.columns:
-                out[c_cov] = pd.to_numeric(out[c_cov], errors="coerce").fillna(0.0).round(2)
-
-            c_fac = f"faktor_penyesuaian_jenis_{j}"
-            if c_fac in out.columns:
-                out[c_fac] = pd.to_numeric(out[c_fac], errors="coerce").fillna(0.0).round(3)
-
-        # === TOTAL UPDATE (sesuai data POP yang ada) ===
-        # Total Pop dan Target = sum 3 jenis (sekolah+umum+khusus)
-        def _sum3(a, b, c):
-            return (
-                pd.to_numeric(a, errors="coerce").fillna(0)
-                + pd.to_numeric(b, errors="coerce").fillna(0)
-                + pd.to_numeric(c, errors="coerce").fillna(0)
-            )
-
-        if ("pop_total_jenis_sekolah" in out.columns) and ("pop_total_jenis_umum" in out.columns) and ("pop_total_jenis_khusus" in out.columns):
-            out["Pop_Total_Update"] = _sum3(out["pop_total_jenis_sekolah"], out["pop_total_jenis_umum"], out["pop_total_jenis_khusus"]).round(0).astype(int)
-
-        if ("target_total_68_jenis_sekolah" in out.columns) and ("target_total_68_jenis_umum" in out.columns) and ("target_total_68_jenis_khusus" in out.columns):
-            out["Target68_Total_Update"] = _sum3(out["target_total_68_jenis_sekolah"], out["target_total_68_jenis_umum"], out["target_total_68_jenis_khusus"]).round(0).astype(int)
-
-        if ("n_jenis_sekolah" in out.columns) and ("n_jenis_umum" in out.columns) and ("n_jenis_khusus" in out.columns):
-            out["Terkumpul_Total_Update"] = _sum3(out["n_jenis_sekolah"], out["n_jenis_umum"], out["n_jenis_khusus"]).round(0).astype(int)
-
-        # coverage_total_update = min(terkumpul/target,1)*100
-        if ("Terkumpul_Total_Update" in out.columns) and ("Target68_Total_Update" in out.columns):
-            den = pd.to_numeric(out["Target68_Total_Update"], errors="coerce").fillna(0).astype(float)
-            num = pd.to_numeric(out["Terkumpul_Total_Update"], errors="coerce").fillna(0).astype(float)
-            cov = np.where(den > 0, np.minimum(num / den, 1.0) * 100.0, 0.0)
-            out["Coverage_Target68_Total_Update_%"] = pd.Series(cov).round(2)
+            cfac = f"faktor_penyesuaian_jenis_{j}"
+            if cfac in out.columns:
+                out[cfac] = pd.to_numeric(out[cfac], errors="coerce").fillna(1.0).round(3)
+
+        # TOTAL (sum 3 jenis)
+        out["pop_total_all"] = (
+            out.get("pop_total_jenis_sekolah", 0)
+            + out.get("pop_total_jenis_umum", 0)
+            + out.get("pop_total_jenis_khusus", 0)
+        ).astype(int)
+
+        out["target_total_68_all"] = (
+            out.get("target_total_68_jenis_sekolah", 0)
+            + out.get("target_total_68_jenis_umum", 0)
+            + out.get("target_total_68_jenis_khusus", 0)
+        ).astype(int)
+
+        out["terkumpul_all"] = (
+            out.get("n_jenis_sekolah", 0)
+            + out.get("n_jenis_umum", 0)
+            + out.get("n_jenis_khusus", 0)
+        ).astype(int)
+
+        out["coverage_target68_all_%"] = np.where(
+            pd.to_numeric(out["target_total_68_all"], errors="coerce").fillna(0).values > 0,
+            (pd.to_numeric(out["terkumpul_all"], errors="coerce").fillna(0).values / pd.to_numeric(out["target_total_68_all"], errors="coerce").fillna(0).values) * 100.0,
+            0.0
+        )
+        out["coverage_target68_all_%"] = pd.to_numeric(out["coverage_target68_all_%"], errors="coerce").fillna(0.0).round(2)
 
     # rounding index
     for c in [
@@ -1052,17 +1020,19 @@ def build_agg_wilayah_total_from_jenis(agg_jenis: pd.DataFrame, faktor_wilayah_j
         if c in out.columns:
             out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0.0).round(2)
 
-    # n_total integer
-    if "n_total" in out.columns:
-        out["n_total"] = pd.to_numeric(out["n_total"], errors="coerce").fillna(0).round(0).astype(int)
+    out["n_total"] = pd.to_numeric(out["n_total"], errors="coerce").fillna(0).round(0).astype(int)
 
     return out
 
+
 # ============================================================
-# 9) SUMMARY (PER JENIS) + KESELURUHAN (FIX ÷3 + tambah cakupan & penyesuaian)
+# 9) SUMMARY (PER JENIS) + KESELURUHAN
+#    - selalu 4 baris: sekolah, umum, khusus, keseluruhan
+#    - tampilkan Pop/Target/Terkumpul/Coverage per jenis
+#    - Penyesuaian_Poin = Final - Dasar
 # ============================================================
 
-def build_summary_per_jenis(agg_jenis: pd.DataFrame, agg_total: pd.DataFrame, faktor_wilayah_jenis: pd.DataFrame | None = None):
+def build_summary_per_jenis(agg_jenis: pd.DataFrame, faktor_wilayah_jenis: pd.DataFrame):
     jenis_list = ["sekolah", "umum", "khusus"]
 
     def _row_default(jenis):
@@ -1070,92 +1040,70 @@ def build_summary_per_jenis(agg_jenis: pd.DataFrame, agg_total: pd.DataFrame, fa
             "Jenis": jenis,
             "Jumlah_Wilayah": 0,
             "Total_Perpus": 0,
-
-            # POP/TARGET/N per jenis (sum nasional pada scope filter)
             "Pop_Total_Jenis": 0,
             "Target68_Total_Jenis": 0,
             "Terkumpul_Jenis": 0,
-            "Coverage_Target68_Jenis_%": 0.00,
-
-            # skor
+            "Coverage_Target68_Jenis_%": 0.0,
             "Rata2_sub_koleksi": 0.0,
             "Rata2_sub_sdm": 0.0,
             "Rata2_sub_pelayanan": 0.0,
             "Rata2_sub_pengelolaan": 0.0,
             "Rata2_dim_kepatuhan": 0.0,
             "Rata2_dim_kinerja": 0.0,
-
-            # dasar & final + penyesuaian poin
             "Indeks_Dasar_0_100": 0.0,
             "Indeks_Final_Disesuaikan_0_100": 0.0,
-            "Penyesuaian_Poin": 0.0,
+            "Penyesuaian_Poin": 0.0
         }
 
     rows_by_jenis = {j: _row_default(j) for j in jenis_list}
 
-    # ===== ambil POP/TARGET/N per jenis dari faktor_wilayah_jenis =====
-    fw_sum = {}
-    if faktor_wilayah_jenis is not None and (not faktor_wilayah_jenis.empty):
-        fw = faktor_wilayah_jenis.copy()
+    a = agg_jenis.copy() if (agg_jenis is not None) else pd.DataFrame()
+    if not a.empty:
+        a["Jenis"] = a["Jenis"].astype(str).str.lower().str.strip()
+
+    fw = faktor_wilayah_jenis.copy() if (faktor_wilayah_jenis is not None) else pd.DataFrame()
+    if not fw.empty:
         fw["Jenis"] = fw["Jenis"].astype(str).str.lower().str.strip()
 
-        for j in jenis_list:
-            sub = fw[fw["Jenis"] == j].copy()
-            if sub.empty:
-                fw_sum[j] = {"pop": 0, "target": 0, "n": 0, "cov": 0.0}
-                continue
-
-            pop = int(pd.to_numeric(sub.get("pop_total_jenis", 0), errors="coerce").fillna(0).sum())
-            target = int(pd.to_numeric(sub.get("target_total_68_jenis", 0), errors="coerce").fillna(0).sum())
-            n = int(pd.to_numeric(sub.get("n_jenis", 0), errors="coerce").fillna(0).sum())
-
-            cov = 0.0
-            if target > 0:
-                cov = float(min(n / float(target), 1.0) * 100.0)
-
-            fw_sum[j] = {"pop": pop, "target": target, "n": n, "cov": cov}
-
-    # ===== isi ringkasan dari agg_jenis =====
-    if agg_jenis is not None and not agg_jenis.empty:
-        for jenis in jenis_list:
-            sub = agg_jenis[agg_jenis["Jenis"].astype(str).str.lower() == jenis].copy()
-            if sub.empty:
-                # tetap isi pop/target/n kalau ada
-                if jenis in fw_sum:
-                    rows_by_jenis[jenis]["Pop_Total_Jenis"] = fw_sum[jenis]["pop"]
-                    rows_by_jenis[jenis]["Target68_Total_Jenis"] = fw_sum[jenis]["target"]
-                    rows_by_jenis[jenis]["Terkumpul_Jenis"] = fw_sum[jenis]["n"]
-                    rows_by_jenis[jenis]["Coverage_Target68_Jenis_%"] = fw_sum[jenis]["cov"]
-                continue
+    for jenis in jenis_list:
+        sub = a[a["Jenis"] == jenis].copy() if not a.empty else pd.DataFrame()
+        subfw = fw[fw["Jenis"] == jenis].copy() if not fw.empty else pd.DataFrame()
 
+        if not sub.empty:
             dasar = float(pd.to_numeric(sub["Indeks_Dasar_Agregat_0_100"], errors="coerce").fillna(0).mean())
             final = float(pd.to_numeric(sub["Indeks_Final_Agregat_0_100"], errors="coerce").fillna(0).mean())
 
-            rows_by_jenis[jenis] = {
-                "Jenis": jenis,
+            rows_by_jenis[jenis].update({
                 "Jumlah_Wilayah": int(sub.shape[0]),
                 "Total_Perpus": int(pd.to_numeric(sub["Jumlah"], errors="coerce").fillna(0).sum()),
-
-                "Pop_Total_Jenis": int(fw_sum.get(jenis, {}).get("pop", 0)),
-                "Target68_Total_Jenis": int(fw_sum.get(jenis, {}).get("target", 0)),
-                "Terkumpul_Jenis": int(fw_sum.get(jenis, {}).get("n", 0)),
-                "Coverage_Target68_Jenis_%": float(fw_sum.get(jenis, {}).get("cov", 0.0)),
-
                 "Rata2_sub_koleksi": float(pd.to_numeric(sub["Rata2_sub_koleksi"], errors="coerce").fillna(0).mean()),
                 "Rata2_sub_sdm": float(pd.to_numeric(sub["Rata2_sub_sdm"], errors="coerce").fillna(0).mean()),
                 "Rata2_sub_pelayanan": float(pd.to_numeric(sub["Rata2_sub_pelayanan"], errors="coerce").fillna(0).mean()),
                 "Rata2_sub_pengelolaan": float(pd.to_numeric(sub["Rata2_sub_pengelolaan"], errors="coerce").fillna(0).mean()),
                 "Rata2_dim_kepatuhan": float(pd.to_numeric(sub["Rata2_dim_kepatuhan"], errors="coerce").fillna(0).mean()),
                 "Rata2_dim_kinerja": float(pd.to_numeric(sub["Rata2_dim_kinerja"], errors="coerce").fillna(0).mean()),
-
                 "Indeks_Dasar_0_100": dasar,
                 "Indeks_Final_Disesuaikan_0_100": final,
-                "Penyesuaian_Poin": float(final - dasar),
-            }
+                "Penyesuaian_Poin": (final - dasar),
+            })
+
+        if not subfw.empty:
+            pop_j = int(pd.to_numeric(subfw["pop_total_jenis"], errors="coerce").fillna(0).sum())
+            tgt_j = int(pd.to_numeric(subfw["target_total_68_jenis"], errors="coerce").fillna(0).sum())
+            n_j = int(pd.to_numeric(subfw["n_jenis"], errors="coerce").fillna(0).sum())
+
+            cov = (n_j / tgt_j * 100.0) if tgt_j > 0 else 0.0
+
+            rows_by_jenis[jenis].update({
+                "Pop_Total_Jenis": pop_j,
+                "Target68_Total_Jenis": tgt_j,
+                "Terkumpul_Jenis": n_j,
+                "Coverage_Target68_Jenis_%": cov
+            })
 
     rows = [rows_by_jenis[j] for j in jenis_list]
 
-    # ===== keseluruhan = avg3 tetap ÷3 (missing=0) =====
+    # keseluruhan: avg3 (tetap ÷3)
     def _avg3(field):
         return (
             float(rows_by_jenis["sekolah"][field])
@@ -1163,43 +1111,58 @@ def build_summary_per_jenis(agg_jenis: pd.DataFrame, agg_total: pd.DataFrame, fa
             + float(rows_by_jenis["khusus"][field])
         ) / 3.0
 
-    final_all = _avg3("Indeks_Final_Disesuaikan_0_100")
-    dasar_all = _avg3("Indeks_Dasar_0_100")
-
-    total_perpus_all = int(rows_by_jenis["sekolah"]["Total_Perpus"] + rows_by_jenis["umum"]["Total_Perpus"] + rows_by_jenis["khusus"]["Total_Perpus"])
-    jumlah_wilayah_all = int(agg_total.shape[0]) if (agg_total is not None and not agg_total.empty) else int(max(rows_by_jenis["sekolah"]["Jumlah_Wilayah"], rows_by_jenis["umum"]["Jumlah_Wilayah"], rows_by_jenis["khusus"]["Jumlah_Wilayah"]))
-
-    # Total POP/TARGET/N keseluruhan = sum3 (bukan avg3), karena ini memang total cakupan
-    pop_all = int(rows_by_jenis["sekolah"]["Pop_Total_Jenis"] + rows_by_jenis["umum"]["Pop_Total_Jenis"] + rows_by_jenis["khusus"]["Pop_Total_Jenis"])
-    target_all = int(rows_by_jenis["sekolah"]["Target68_Total_Jenis"] + rows_by_jenis["umum"]["Target68_Total_Jenis"] + rows_by_jenis["khusus"]["Target68_Total_Jenis"])
-    n_all = int(rows_by_jenis["sekolah"]["Terkumpul_Jenis"] + rows_by_jenis["umum"]["Terkumpul_Jenis"] + rows_by_jenis["khusus"]["Terkumpul_Jenis"])
-    cov_all = float(min(n_all / float(target_all), 1.0) * 100.0) if target_all > 0 else 0.0
-
-    rows.append({
-        "Jenis": "keseluruhan",
-        "Jumlah_Wilayah": jumlah_wilayah_all,
-        "Total_Perpus": total_perpus_all,
-
-        "Pop_Total_Jenis": pop_all,
-        "Target68_Total_Jenis": target_all,
-        "Terkumpul_Jenis": n_all,
-        "Coverage_Target68_Jenis_%": cov_all,
-
-        "Rata2_sub_koleksi": _avg3("Rata2_sub_koleksi"),
-        "Rata2_sub_sdm": _avg3("Rata2_sub_sdm"),
-        "Rata2_sub_pelayanan": _avg3("Rata2_sub_pelayanan"),
-        "Rata2_sub_pengelolaan": _avg3("Rata2_sub_pengelolaan"),
-        "Rata2_dim_kepatuhan": _avg3("Rata2_dim_kepatuhan"),
-        "Rata2_dim_kinerja": _avg3("Rata2_dim_kinerja"),
-
-        "Indeks_Dasar_0_100": dasar_all,
-        "Indeks_Final_Disesuaikan_0_100": final_all,
-        "Penyesuaian_Poin": float(final_all - dasar_all),
-    })
+    keseluruhan = _row_default("keseluruhan")
+    keseluruhan["Jumlah_Wilayah"] = int(max(
+        rows_by_jenis["sekolah"]["Jumlah_Wilayah"],
+        rows_by_jenis["umum"]["Jumlah_Wilayah"],
+        rows_by_jenis["khusus"]["Jumlah_Wilayah"],
+    ))
+    keseluruhan["Total_Perpus"] = int(
+        rows_by_jenis["sekolah"]["Total_Perpus"]
+        + rows_by_jenis["umum"]["Total_Perpus"]
+        + rows_by_jenis["khusus"]["Total_Perpus"]
+    )
+
+    keseluruhan["Pop_Total_Jenis"] = int(
+        rows_by_jenis["sekolah"]["Pop_Total_Jenis"]
+        + rows_by_jenis["umum"]["Pop_Total_Jenis"]
+        + rows_by_jenis["khusus"]["Pop_Total_Jenis"]
+    )
+    keseluruhan["Target68_Total_Jenis"] = int(
+        rows_by_jenis["sekolah"]["Target68_Total_Jenis"]
+        + rows_by_jenis["umum"]["Target68_Total_Jenis"]
+        + rows_by_jenis["khusus"]["Target68_Total_Jenis"]
+    )
+    keseluruhan["Terkumpul_Jenis"] = int(
+        rows_by_jenis["sekolah"]["Terkumpul_Jenis"]
+        + rows_by_jenis["umum"]["Terkumpul_Jenis"]
+        + rows_by_jenis["khusus"]["Terkumpul_Jenis"]
+    )
+    keseluruhan["Coverage_Target68_Jenis_%"] = (
+        (keseluruhan["Terkumpul_Jenis"] / keseluruhan["Target68_Total_Jenis"] * 100.0)
+        if keseluruhan["Target68_Total_Jenis"] > 0 else 0.0
+    )
+
+    keseluruhan["Rata2_sub_koleksi"] = _avg3("Rata2_sub_koleksi")
+    keseluruhan["Rata2_sub_sdm"] = _avg3("Rata2_sub_sdm")
+    keseluruhan["Rata2_sub_pelayanan"] = _avg3("Rata2_sub_pelayanan")
+    keseluruhan["Rata2_sub_pengelolaan"] = _avg3("Rata2_sub_pengelolaan")
+    keseluruhan["Rata2_dim_kepatuhan"] = _avg3("Rata2_dim_kepatuhan")
+    keseluruhan["Rata2_dim_kinerja"] = _avg3("Rata2_dim_kinerja")
+    keseluruhan["Indeks_Dasar_0_100"] = _avg3("Indeks_Dasar_0_100")
+    keseluruhan["Indeks_Final_Disesuaikan_0_100"] = _avg3("Indeks_Final_Disesuaikan_0_100")
+    keseluruhan["Penyesuaian_Poin"] = keseluruhan["Indeks_Final_Disesuaikan_0_100"] - keseluruhan["Indeks_Dasar_0_100"]
+
+    rows.append(keseluruhan)
 
     out = pd.DataFrame(rows)
 
-    # rounding
+    # format display
+    for c in ["Jumlah_Wilayah","Total_Perpus","Pop_Total_Jenis","Target68_Total_Jenis","Terkumpul_Jenis"]:
+        out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0).round(0).astype(int)
+
+    out["Coverage_Target68_Jenis_%"] = pd.to_numeric(out["Coverage_Target68_Jenis_%"], errors="coerce").fillna(0.0).round(2)
+
     for c in [
         "Rata2_sub_koleksi","Rata2_sub_sdm","Rata2_sub_pelayanan","Rata2_sub_pengelolaan",
         "Rata2_dim_kepatuhan","Rata2_dim_kinerja"
@@ -1209,12 +1172,6 @@ def build_summary_per_jenis(agg_jenis: pd.DataFrame, agg_total: pd.DataFrame, fa
     for c in ["Indeks_Dasar_0_100","Indeks_Final_Disesuaikan_0_100","Penyesuaian_Poin"]:
         out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0.0).round(2)
 
-    # integer columns
-    for c in ["Jumlah_Wilayah","Total_Perpus","Pop_Total_Jenis","Target68_Total_Jenis","Terkumpul_Jenis"]:
-        out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0).round(0).astype(int)
-
-    out["Coverage_Target68_Jenis_%"] = pd.to_numeric(out["Coverage_Target68_Jenis_%"], errors="coerce").fillna(0.0).round(2)
-
     return out
 
 # ============================================================
@@ -1420,51 +1377,56 @@ def _make_bell_curve(dfp: pd.DataFrame, xcol: str, title: str, label_col: str |
 
 
 # ============================================================
-# 13) KPI DASHBOARD (PATCH: hanya FINAL & DASAR)
+# 13) KPI DASHBOARD
+#     - HAPUS: Cakupan Sampel & Penyesuaian Nilai dari dashboard
+#     - Dashboard hanya tampil: FINAL & DASAR
 # ============================================================
 
-def compute_dashboard_kpis(summary_jenis: pd.DataFrame, agg_total: pd.DataFrame, agg_jenis: pd.DataFrame):
-    def _get_val(j, col):
-        sub = summary_jenis[summary_jenis["Jenis"].astype(str).str.lower() == j]
-        if sub.empty:
-            return 0.0
-        return float(pd.to_numeric(sub[col], errors="coerce").fillna(0).iloc[0])
+def compute_dashboard_kpis(summary_jenis: pd.DataFrame):
+    if summary_jenis is None or summary_jenis.empty:
+        return {"final_all": 0.0, "dasar_all": 0.0}
 
-    final_all = _get_val("keseluruhan", "Indeks_Final_Disesuaikan_0_100")
-    dasar_all = _get_val("keseluruhan", "Indeks_Dasar_0_100")
+    s = summary_jenis.copy()
+    s["Jenis"] = s["Jenis"].astype(str).str.lower().str.strip()
 
-    return {"final_all": final_all, "dasar_all": dasar_all}
+    sub = s[s["Jenis"] == "keseluruhan"]
+    if sub.empty:
+        final_all = float(pd.to_numeric(s["Indeks_Final_Disesuaikan_0_100"], errors="coerce").fillna(0).mean())
+        dasar_all = float(pd.to_numeric(s["Indeks_Dasar_0_100"], errors="coerce").fillna(0).mean())
+    else:
+        final_all = float(pd.to_numeric(sub["Indeks_Final_Disesuaikan_0_100"], errors="coerce").fillna(0).iloc[0])
+        dasar_all = float(pd.to_numeric(sub["Indeks_Dasar_0_100"], errors="coerce").fillna(0).iloc[0])
 
+    return {"final_all": final_all, "dasar_all": dasar_all}
 
-def build_kpi_markdown(summary_jenis: pd.DataFrame, agg_total: pd.DataFrame, agg_jenis: pd.DataFrame, faktor_wilayah_jenis: pd.DataFrame | None = None) -> str:
-    # faktor_wilayah_jenis tetap diterima supaya pemanggil run_calc tidak perlu diubah banyak,
-    # tapi tidak dipakai lagi di KPI dashboard (dipindah ke tabel ringkasan).
+def build_kpi_markdown(summary_jenis: pd.DataFrame) -> str:
     if summary_jenis is None or summary_jenis.empty:
         return ""
 
-    k = compute_dashboard_kpis(summary_jenis, agg_total, agg_jenis)
+    k = compute_dashboard_kpis(summary_jenis)
 
     def fmt(x, nd=2):
         return "NA" if pd.isna(x) else f"{x:.{nd}f}"
 
     return f"""
 <div style="display:flex; gap:12px; flex-wrap:wrap;">
-  <div style="border:1px solid #333; border-radius:10px; padding:10px 12px; min-width:220px;">
+  <div style="border:1px solid #333; border-radius:10px; padding:10px 12px; min-width:240px;">
     <div style="opacity:0.8;">Indeks IPLM FINAL (Disesuaikan)</div>
     <div style="font-size:26px; font-weight:700;">{fmt(k["final_all"],2)}</div>
-    <div style="opacity:0.7;">Rata-rata 3 jenis (tetap ÷3) — sumber: Ringkasan</div>
+    <div style="opacity:0.7;">Sumber: baris "keseluruhan" (avg3 tetap ÷3)</div>
   </div>
 
-  <div style="border:1px solid #333; border-radius:10px; padding:10px 12px; min-width:220px;">
+  <div style="border:1px solid #333; border-radius:10px; padding:10px 12px; min-width:240px;">
     <div style="opacity:0.8;">Indeks Dasar (Tanpa Penyesuaian)</div>
     <div style="font-size:26px; font-weight:700;">{fmt(k["dasar_all"],2)}</div>
-    <div style="opacity:0.7;">Rata-rata 3 jenis (tetap ÷3)</div>
+    <div style="opacity:0.7;">Sumber: baris "keseluruhan" (avg3 tetap ÷3)</div>
   </div>
 </div>
 """.strip()
 
+
 # ============================================================
-# 14) LLM + WORD
+# 14) LLM + WORD (FIX: generate_llm_analysis pasti ada)
 # ============================================================
 
 _HF_CLIENT = None
@@ -1480,81 +1442,69 @@ def get_llm_client():
         _HF_CLIENT = None
         return None
 
-
-def build_context(summary_jenis: pd.DataFrame, agg_total: pd.DataFrame, verif_total: pd.DataFrame, wilayah: str, kew: str) -> str:
+def build_context(summary_jenis: pd.DataFrame, agg_total: pd.DataFrame, wilayah: str, kew: str) -> str:
     lines = []
     lines.append(f"Wilayah filter: {wilayah}")
     lines.append(f"Kewenangan: {kew}")
-    lines.append("Metode: Indeks dasar dihitung per entitas (Yeo-Johnson + MinMax nasional per indikator), lalu diagregasi per wilayah×jenis.")
-    lines.append("Penyesuaian: faktor = min(total_terkumpul / target_total_68, 1.0).")
-    lines.append("FIX keseluruhan: nilai keseluruhan = rata-rata 3 jenis (sekolah+umum+khusus) ÷ 3 (missing=0, tetap ÷3).")
+    lines.append("Metode: Indeks dasar dihitung per entitas (Yeo-Johnson + MinMax nasional), lalu agregat per wilayah×jenis.")
+    lines.append("Penyesuaian berbasis kecukupan sampel (target 68%) dihitung PER JENIS (sekolah/umum/khusus).")
+    lines.append("Keseluruhan wilayah (FIX): rata-rata 3 jenis (sekolah+umum+khusus) ÷ 3 (missing=0, tetap ÷3).")
 
     if summary_jenis is not None and not summary_jenis.empty:
         lines.append("\nRingkasan (jenis + keseluruhan):")
         for _, r in summary_jenis.iterrows():
-            try:
-                jenis = str(r.get("Jenis", "")).strip()
-                jw = int(pd.to_numeric(r.get("Jumlah_Wilayah", 0), errors="coerce") or 0)
-                tp = int(pd.to_numeric(r.get("Total_Perpus", 0), errors="coerce") or 0)
-                fin = float(pd.to_numeric(r.get("Indeks_Final_Disesuaikan_0_100", 0), errors="coerce") or 0)
-                das = float(pd.to_numeric(r.get("Indeks_Dasar_0_100", 0), errors="coerce") or 0)
-                cov = float(pd.to_numeric(r.get("Coverage_Target68_Jenis_%", 0), errors="coerce") or 0)
-                lines.append(f"- {jenis}: wilayah={jw}, total_perpus={tp}, dasar={das:.2f}, final={fin:.2f}, coverage_target68={cov:.2f}%")
-            except Exception:
-                continue
+            lines.append(
+                f"- {r['Jenis']}: wilayah={int(r['Jumlah_Wilayah'])}, total_perpus={int(r['Total_Perpus'])}, "
+                f"pop={int(r['Pop_Total_Jenis'])}, target68={int(r['Target68_Total_Jenis'])}, terkumpul={int(r['Terkumpul_Jenis'])}, "
+                f"coverage={float(r['Coverage_Target68_Jenis_%']):.2f}%, "
+                f"dasar={float(r['Indeks_Dasar_0_100']):.2f}, final={float(r['Indeks_Final_Disesuaikan_0_100']):.2f}"
+            )
 
     if agg_total is not None and not agg_total.empty:
         label_col = "Kab/Kota" if "Kab/Kota" in agg_total.columns else ("Provinsi" if "Provinsi" in agg_total.columns else None)
-        if label_col:
-            lines.append("\nTop 5 wilayah (Final tertinggi):")
-            top = agg_total.sort_values("Indeks_Final_Wilayah_0_100", ascending=False).head(5)
-            for _, r in top.iterrows():
-                wl = str(r.get(label_col, "(wilayah)"))
-                fin = float(pd.to_numeric(r.get("Indeks_Final_Wilayah_0_100", 0), errors="coerce") or 0)
-                lines.append(f"- {wl}: Final={fin:.2f}")
+        lines.append("\nTop 5 wilayah (Final tertinggi):")
+        top = agg_total.sort_values("Indeks_Final_Wilayah_0_100", ascending=False).head(5)
+        for _, r in top.iterrows():
+            wl = r.get(label_col, "(wilayah)") if label_col else "(wilayah)"
+            lines.append(f"- {wl}: Final={float(r['Indeks_Final_Wilayah_0_100']):.2f} | Dasar={float(r['Indeks_Dasar_Agregat_0_100']):.2f} | n_total={int(r.get('n_total', 0))}")
 
     return "\n".join(lines)
 
+def generate_llm_analysis(summary_jenis: pd.DataFrame, agg_total: pd.DataFrame, wilayah: str, kew: str) -> str:
+    ctx = build_context(summary_jenis, agg_total, wilayah, kew)
 
-def generate_llm_analysis(summary_jenis, agg_total, verif_total, wilayah, kew):
-    ctx = build_context(summary_jenis, agg_total, verif_total, wilayah, kew)
+    if (not USE_LLM) or (HF_TOKEN is None):
+        return "Analisis otomatis (LLM) nonaktif / token tidak tersedia."
 
-    # kalau LLM dimatikan / token gak ada -> return teks aman
     client = get_llm_client()
-    if (client is None) or (not USE_LLM):
-        return (
-            "Analisis otomatis (LLM) tidak tersedia.\n\n"
-            "Catatan: Set USE_LLM=True dan pastikan HF_TOKEN tersedia bila ingin mengaktifkan analisis LLM."
-        )
+    if client is None:
+        return "Analisis otomatis (LLM) tidak tersedia (client gagal dibuat)."
 
     system_prompt = (
         "Anda adalah analis kebijakan perpustakaan dan literasi di Indonesia. "
         "Tugas Anda menyusun analisis berbasis data IPLM secara formal, tajam, dan operasional."
     )
-
     user_prompt = f"""
 DATA RINGKAS IPLM:
 
 {ctx}
 
 TULISKAN ANALISIS BAHASA INDONESIA FORMAL, STRUKTUR:
-1) Gambaran umum hasil wilayah (1 paragraf).
-2) Analisis jenis sekolah, umum, khusus serta indeks keseluruhan (2 paragraf).
-3) Penjelasan makna penyesuaian berbasis target 68% (1 paragraf, netral).
-4) Rekomendasi program 3–5 tahun (2 paragraf, konkret dan dapat dieksekusi).
+1) Gambaran umum hasil (1 paragraf).
+2) Analisis per jenis (sekolah, umum, khusus) + keseluruhan (2 paragraf).
+3) Penjelasan pembacaan Pop/Target68/Terkumpul/Coverage (1 paragraf).
+4) Rekomendasi program 3–5 tahun (2 paragraf, konkret).
 
 ATURAN:
 - Jangan memakai label eksplisit "rendah/sedang/tinggi".
 - Gunakan frasa netral: "memerlukan penguatan", "memerlukan konsolidasi", dsb.
+- Fokus pada nilai agregat wilayah.
 """
 
     try:
         resp = client.chat_completion(
             model=LLM_MODEL_NAME,
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": user_prompt},
-            ],
+            messages=[{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}],
             max_tokens=1100,
             temperature=0.25,
             top_p=0.9,
@@ -1564,36 +1514,21 @@ ATURAN:
     except Exception as e:
         return f"⚠️ Error saat memanggil LLM: {repr(e)}"
 
-
-def generate_word_report(wilayah, summary_jenis, agg_total, agg_jenis, analysis_text):
+def generate_word_report(wilayah: str, summary_jenis: pd.DataFrame, agg_total: pd.DataFrame, analysis_text: str):
     doc = Document()
     doc.add_heading(f"Laporan IPLM — {wilayah}", level=1)
 
     doc.add_heading("Ringkasan Dashboard", level=2)
+    k = compute_dashboard_kpis(summary_jenis)
+    doc.add_paragraph(f"Indeks IPLM FINAL (Disesuaikan): {k['final_all']:.2f}")
+    doc.add_paragraph(f"Indeks Dasar (Tanpa Penyesuaian): {k['dasar_all']:.2f}")
 
-    # KPI hanya FINAL & DASAR (cakupan + penyesuaian dipindah ke tabel ringkasan)
-    k_final = 0.0
-    k_dasar = 0.0
-    try:
-        if summary_jenis is not None and (not summary_jenis.empty):
-            row_all = summary_jenis[summary_jenis["Jenis"].astype(str).str.lower() == "keseluruhan"]
-            if not row_all.empty:
-                k_final = float(pd.to_numeric(row_all["Indeks_Final_Disesuaikan_0_100"], errors="coerce").fillna(0).iloc[0])
-                k_dasar = float(pd.to_numeric(row_all["Indeks_Dasar_0_100"], errors="coerce").fillna(0).iloc[0])
-    except Exception:
-        k_final, k_dasar = 0.0, 0.0
-
-    doc.add_paragraph(f"Indeks IPLM FINAL (Disesuaikan): {k_final:.2f} (rata-rata 3 jenis, tetap ÷3; missing=0)")
-    doc.add_paragraph(f"Indeks Dasar (Tanpa Penyesuaian): {k_dasar:.2f} (rata-rata 3 jenis, tetap ÷3; missing=0)")
-
-    doc.add_paragraph("Ringkasan (Jenis + Keseluruhan) — termasuk Pop/Target68/Terkumpul/Coverage + Penyesuaian Poin:")
+    doc.add_heading("Ringkasan (Jenis + Keseluruhan)", level=2)
     show = summary_jenis.copy()
-
     preferred = [
-        "Jenis", "Jumlah_Wilayah", "Total_Perpus",
-        "Pop_Total_Jenis", "Target68_Total_Jenis", "Terkumpul_Jenis", "Coverage_Target68_Jenis_%",
-        "Rata2_dim_kepatuhan", "Rata2_dim_kinerja",
-        "Indeks_Dasar_0_100", "Indeks_Final_Disesuaikan_0_100", "Penyesuaian_Poin"
+        "Jenis","Jumlah_Wilayah","Total_Perpus",
+        "Pop_Total_Jenis","Target68_Total_Jenis","Terkumpul_Jenis","Coverage_Target68_Jenis_%",
+        "Indeks_Dasar_0_100","Indeks_Final_Disesuaikan_0_100","Penyesuaian_Poin"
     ]
     show = show[[c for c in preferred if c in show.columns]]
 
@@ -1608,32 +1543,36 @@ def generate_word_report(wilayah, summary_jenis, agg_total, agg_jenis, analysis_
             v = row[c]
             if pd.isna(v):
                 cells[i].text = ""
-            elif isinstance(v, (int, np.integer)):
-                cells[i].text = str(int(v))
             elif isinstance(v, (float, np.floating)):
-                if "Coverage" in c:
-                    cells[i].text = f"{float(v):.2f}"
-                elif "Rata2_" in c:
-                    cells[i].text = f"{float(v):.3f}"
-                elif "Indeks" in c or "Penyesuaian" in c:
+                if c.endswith("_%"):
                     cells[i].text = f"{float(v):.2f}"
                 else:
                     cells[i].text = f"{float(v):.2f}"
+            elif isinstance(v, (int, np.integer)):
+                cells[i].text = str(int(v))
             else:
                 cells[i].text = str(v)
 
-    doc.add_heading("Metodologi", level=2)
-    doc.add_paragraph(
-        "Indeks dasar dihitung per entitas menggunakan transformasi Yeo-Johnson dan normalisasi MinMax nasional per indikator. "
-        "Nilai kemudian diagregasi per wilayah×jenis."
-    )
-    doc.add_paragraph(
-        "Penyesuaian dilakukan berbasis kecukupan sampel minimum 68% pada level wilayah, "
-        "dengan rumus faktor = min(total_terkumpul / target_total_68, 1.0)."
-    )
-    doc.add_paragraph(
-        "Nilai keseluruhan (FIX) dihitung sebagai rata-rata 3 jenis (sekolah+umum+khusus) ÷ 3, dengan missing dianggap 0."
-    )
+    doc.add_heading("Agregat Wilayah (Keseluruhan)", level=2)
+    if agg_total is not None and not agg_total.empty:
+        cols = [c for c in agg_total.columns if c not in ["group_key"]]
+        t2 = doc.add_table(rows=1, cols=len(cols))
+        h2 = t2.rows[0].cells
+        for i, c in enumerate(cols):
+            h2[i].text = str(c)
+
+        for _, r in agg_total.head(50).iterrows():
+            rr = t2.add_row().cells
+            for i, c in enumerate(cols):
+                vv = r[c]
+                if pd.isna(vv):
+                    rr[i].text = ""
+                elif isinstance(vv, (float, np.floating)):
+                    rr[i].text = f"{float(vv):.2f}"
+                elif isinstance(vv, (int, np.integer)):
+                    rr[i].text = str(int(vv))
+                else:
+                    rr[i].text = str(vv)
 
     doc.add_heading("Analisis Naratif (LLM)", level=2)
     for p in (analysis_text or "").split("\n"):
@@ -1654,9 +1593,9 @@ def _empty_outputs(msg="⚠️ Data belum siap."):
     empty_fig = go.Figure()
     return (
         "",  # kpi_md
-        empty, empty, empty, empty, empty,
-        None, None, None, None, None,
-        empty_fig, empty_fig, empty_fig,
+        empty, empty, empty, empty, empty,  # summary, agg_total, agg_jenis_view, detail, verif
+        None, None, None, None, None,       # downloads
+        empty_fig, empty_fig, empty_fig,    # figs
         msg, "Analisis belum tersedia."
     )
 
@@ -1665,9 +1604,7 @@ def run_calc(prov_value, kab_value, kew_value, df_all, df_raw, pop_kab, pop_prov
         if df_all is None or df_all.empty or df_raw is None or df_raw.empty:
             return _empty_outputs("⚠️ Data belum ter-load. Pastikan file tersedia di repo/server.")
 
-        # =========================
         # FILTER ANALISIS (df_all)
-        # =========================
         df = df_all.copy()
         if prov_value and prov_value != "(Semua)":
             df = df[df["PROV_DISP"] == prov_value]
@@ -1679,71 +1616,44 @@ def run_calc(prov_value, kab_value, kew_value, df_all, df_raw, pop_kab, pop_prov
         if df.empty:
             return _empty_outputs("Tidak ada data untuk filter ini.")
 
-        # ==================================================
-        # PIPELINE BARU (FAKTOR 68% PER JENIS)
-        # ==================================================
+        # PIPELINE: faktor -> agg_jenis -> agg_total -> summary
         faktor_wilayah_jenis = build_faktor_wilayah_jenis(
-            df,
-            pop_kab,
-            pop_prov,
-            pop_khusus,
-            kew_value or "(Semua)"
+            df_filtered=df,
+            pop_kab=pop_kab,
+            pop_prov=pop_prov,
+            pop_khusus=pop_khusus,
+            kew_value=(kew_value or "(Semua)")
         )
 
-        agg_jenis_full = build_agg_wilayah_jenis(
-            df,
-            faktor_wilayah_jenis,
-            kew_value or "(Semua)"
-        )
-
-        agg_total = build_agg_wilayah_total_from_jenis(
-            agg_jenis_full,
-            faktor_wilayah_jenis,
-            kew_value or "(Semua)"
-        )
+        agg_jenis_full = build_agg_wilayah_jenis(df, faktor_wilayah_jenis, kew_value or "(Semua)")
+        agg_total = build_agg_wilayah_total_from_jenis(agg_jenis_full, faktor_wilayah_jenis, kew_value or "(Semua)")
+        summary_jenis = build_summary_per_jenis(agg_jenis_full, faktor_wilayah_jenis)
 
-        summary_jenis = build_summary_per_jenis(
-            agg_jenis_full,
-            agg_total,
-            faktor_wilayah_jenis=faktor_wilayah_jenis
-        )
-
-        verif_total = build_verif_jenis(
-            faktor_wilayah_jenis,
-            kew_value or "(Semua)"
-        )
+        verif_total = build_verif_jenis(faktor_wilayah_jenis, kew_value or "(Semua)")
+        detail_view = attach_final_to_detail(df, agg_total, meta, kew_value or "(Semua)")
 
-        detail_view = attach_final_to_detail(
-            df,
-            agg_total,
-            meta,
-            kew_value or "(Semua)"
-        )
-
-        # ==================================================
-        # UPDATE SESUAI PERMINTAAN (UI ONLY)
-        # Tabel Agregat Wilayah × Jenis cukup sampai Indeks_Dasar_Agregat_0_100
-        # ==================================================
+        # VIEW: Agregat Wilayah × Jenis (tampil sampai Indeks_Dasar_Agregat_0_100)
         if agg_jenis_full is None or agg_jenis_full.empty:
             agg_jenis_view = agg_jenis_full
         else:
             kew_norm = str(kew_value or "").upper()
-            label_name = "Kab/Kota" if ("KAB" in kew_norm or "KOTA" in kew_norm) else ("Provinsi" if "PROV" in kew_norm else "Kab/Kota")
+            label_name = "Kab/Kota"
+            if "PROV" in kew_norm:
+                label_name = "Provinsi"
+
             cols_upto = [
                 "group_key",
                 label_name,
                 "Jenis",
                 "Jumlah",
-                "Rata2_sub_koleksi", "Rata2_sub_sdm", "Rata2_sub_pelayanan", "Rata2_sub_pengelolaan",
-                "Rata2_dim_kepatuhan", "Rata2_dim_kinerja",
+                "Rata2_sub_koleksi","Rata2_sub_sdm","Rata2_sub_pelayanan","Rata2_sub_pengelolaan",
+                "Rata2_dim_kepatuhan","Rata2_dim_kinerja",
                 "Indeks_Dasar_Agregat_0_100",
             ]
             cols_upto = [c for c in cols_upto if c in agg_jenis_full.columns]
             agg_jenis_view = agg_jenis_full[cols_upto].copy()
 
-        # =========================
         # FILTER RAW DOWNLOAD (df_raw)
-        # =========================
         raw = df_raw.copy()
         if prov_value and prov_value != "(Semua)":
             raw = raw[raw["PROV_DISP"] == prov_value]
@@ -1752,13 +1662,11 @@ def run_calc(prov_value, kab_value, kew_value, df_all, df_raw, pop_kab, pop_prov
         if kew_value and kew_value != "(Semua)":
             raw = raw[raw["KEW_NORM"] == kew_value]
 
-        # =========================
-        # Bell curve per JENIS (per entitas)
-        # =========================
+        # Bell curve per jenis (per entitas)
         if detail_view is None or detail_view.empty:
             fig_sekolah = _make_bell_curve(pd.DataFrame(), "Indeks_Dasar_0_100", "Bell Curve — Jenis: Sekolah", min_points=2)
-            fig_umum    = _make_bell_curve(pd.DataFrame(), "Indeks_Dasar_0_100", "Bell Curve — Jenis: Umum", min_points=2)
-            fig_khusus  = _make_bell_curve(pd.DataFrame(), "Indeks_Dasar_0_100", "Bell Curve — Jenis: Khusus", min_points=2)
+            fig_umum = _make_bell_curve(pd.DataFrame(), "Indeks_Dasar_0_100", "Bell Curve — Jenis: Umum", min_points=2)
+            fig_khusus = _make_bell_curve(pd.DataFrame(), "Indeks_Dasar_0_100", "Bell Curve — Jenis: Khusus", min_points=2)
         else:
             xcol_ent = "Indeks_Dasar_0_100" if "Indeks_Dasar_0_100" in detail_view.columns else "Indeks_Final_0_100"
             label_col_e = "nm_perpustakaan" if "nm_perpustakaan" in detail_view.columns else None
@@ -1766,76 +1674,46 @@ def run_calc(prov_value, kab_value, kew_value, df_all, df_raw, pop_kab, pop_prov
 
             def _fig_jenis_ent(jenis_key: str, judul: str):
                 d = detail_view[detail_view["Jenis"].astype(str).str.lower() == jenis_key].copy()
-                return _make_bell_curve(
-                    d,
-                    xcol=xcol_ent,
-                    title=judul,
-                    label_col=label_col_e,
-                    hover_cols=hover_cols_e,
-                    min_points=2
-                )
+                return _make_bell_curve(d, xcol=xcol_ent, title=judul, label_col=label_col_e, hover_cols=hover_cols_e, min_points=2)
 
             fig_sekolah = _fig_jenis_ent("sekolah", "Bell Curve — Jenis: Sekolah (Indeks per Entitas)")
-            fig_umum    = _fig_jenis_ent("umum",    "Bell Curve — Jenis: Umum (Indeks per Entitas)")
-            fig_khusus  = _fig_jenis_ent("khusus",  "Bell Curve — Jenis: Khusus (Indeks per Entitas)")
-
-        # =========================
-        # KPI markdown (FINAL sumber Ringkasan) — hanya 2 kartu
-        # =========================
-        kpi_md = build_kpi_markdown(
-            summary_jenis,
-            agg_total,
-            agg_jenis_full,
-            faktor_wilayah_jenis=faktor_wilayah_jenis
-        )
+            fig_umum = _fig_jenis_ent("umum", "Bell Curve — Jenis: Umum (Indeks per Entitas)")
+            fig_khusus = _fig_jenis_ent("khusus", "Bell Curve — Jenis: Khusus (Indeks per Entitas)")
+
+        # KPI markdown: hanya FINAL & DASAR
+        kpi_md = build_kpi_markdown(summary_jenis)
 
-        # =========================
-        # SAVE OUTPUTS (Excel + Word)
-        # =========================
+        # Save downloads
         tmpdir = tempfile.mkdtemp()
         prov_slug = (_canon(prov_value or "SEMUA").upper() or "SEMUA")
-        kab_slug  = (_canon(kab_value  or "SEMUA").upper() or "SEMUA")
-        kew_slug  = (_canon(kew_value  or "SEMUA").upper() or "SEMUA")
+        kab_slug = (_canon(kab_value or "SEMUA").upper() or "SEMUA")
+        kew_slug = (_canon(kew_value or "SEMUA").upper() or "SEMUA")
 
         p_summary = str(Path(tmpdir) / f"IPLM_RingkasanJenisKeseluruhan_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
-        p_total   = str(Path(tmpdir) / f"IPLM_AgregatWilayah_Keseluruhan_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
-        p_jenis   = str(Path(tmpdir) / f"IPLM_RAW_DATA_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
-        p_detail  = str(Path(tmpdir) / f"IPLM_DetailEntitas_FinalMenempelWilayah_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
-        p_verif   = str(Path(tmpdir) / f"IPLM_KecukupanSampel68_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
+        p_total = str(Path(tmpdir) / f"IPLM_AgregatWilayah_Keseluruhan_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
+        p_raw = str(Path(tmpdir) / f"IPLM_RAW_DATA_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
+        p_detail = str(Path(tmpdir) / f"IPLM_DetailEntitas_FinalMenempelWilayah_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
+        p_verif = str(Path(tmpdir) / f"IPLM_KecukupanSampel68_PER_JENIS_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
 
         summary_jenis.to_excel(p_summary, index=False)
         agg_total.to_excel(p_total, index=False)
-        raw.to_excel(p_jenis, index=False)
+        raw.to_excel(p_raw, index=False)
         detail_view.to_excel(p_detail, index=False)
         verif_total.to_excel(p_verif, index=False)
 
         wilayah_txt = kab_value if (kab_value and kab_value != "(Semua)") else (prov_value if (prov_value and prov_value != "(Semua)") else "Nasional/All")
-
-        analysis_text = generate_llm_analysis(
-            summary_jenis,
-            agg_total,
-            verif_total,
-            wilayah_txt,
-            kew_value or "(Semua)"
-        )
-
-        word_path = generate_word_report(
-            wilayah_txt,
-            summary_jenis,
-            agg_total,
-            agg_jenis_full,
-            analysis_text
-        )
+        analysis_text = generate_llm_analysis(summary_jenis, agg_total, wilayah_txt, kew_value or "(Semua)")
+        word_path = generate_word_report(wilayah_txt, summary_jenis, agg_total, analysis_text)
 
         msg = (
-            f"✅ Selesai: raw={len(raw)} | entitas={len(detail_view)} | wilayah(keseluruhan)={len(agg_total)} | "
-            f"jenis(agregat)={len(agg_jenis_full)} | FIX: Agregat Wilayah (Keseluruhan) = avg3 dari 3 jenis (÷3)"
+            f"✅ Selesai: raw={len(raw)} | entitas={len(detail_view)} | wilayah(keseluruhan) & jenis dihitung | "
+            f"FIX: keseluruhan = avg3(3 jenis) ÷3 | Pop/Target/Terkumpul/Coverage ada di tabel Ringkasan"
         )
 
         return (
             kpi_md,
             summary_jenis, agg_total, agg_jenis_view, detail_view, verif_total,
-            p_summary, p_total, p_jenis, p_detail, word_path,
+            p_summary, p_total, p_raw, p_detail, word_path,
             fig_umum, fig_sekolah, fig_khusus,
             msg, analysis_text
         )
@@ -1843,13 +1721,13 @@ def run_calc(prov_value, kab_value, kew_value, df_all, df_raw, pop_kab, pop_prov
     except Exception as e:
         return _empty_outputs(f"⚠️ Runtime error: {repr(e)}")
 
-
 # ============================================================
 # 16) UI (NO UPLOAD)
 # ============================================================
 
 def ui_load(force=False):
     df_all, df_raw, pop_kab, pop_prov, pop_khusus, meta, info = load_default_files(force=force)
+
     if df_all is None or (isinstance(df_all, pd.DataFrame) and df_all.empty):
         return (
             None, None, None, None, None, {}, info,
@@ -1877,17 +1755,18 @@ def on_prov_change(prov_value):
     df_all, _, _, _, _, _, _ = load_default_files(force=False)
     if df_all is None or df_all.empty:
         return gr.update(choices=["(Semua)"], value="(Semua)")
+
     if prov_value is None or prov_value == "(Semua)":
         vals = df_all["KAB_DISP"].dropna().unique().tolist()
     else:
         vals = df_all.loc[df_all["PROV_DISP"] == prov_value, "KAB_DISP"].dropna().unique().tolist()
+
     vals = sorted([v for v in vals if v])
     return gr.update(choices=["(Semua)"] + vals, value="(Semua)")
 
-
 with gr.Blocks() as demo:
     gr.Markdown(f"""
-# IPLM 2025 — Final (Penyesuaian Berbasis Kecukupan Sampel 68%)
+# IPLM 2025 — Final (Penyesuaian Berbasis Kecukupan Sampel 68% PER JENIS)
 **Mode NO UPLOAD (cache aktif).** File dibaca dari repo/server:
 - `DATA_FILE`   = **{DATA_FILE}**
 - `POP_KAB`     = **{POP_KAB}**
@@ -1895,15 +1774,14 @@ with gr.Blocks() as demo:
 - `POP_KHUSUS`  = **{POP_KHUSUS}**
 
 **FIX UTAMA (konsistensi nilai):**
-- **Agregat Wilayah (Keseluruhan) = rata-rata 3 jenis (sekolah+umum+khusus) ÷ 3 (missing=0, tetap ÷3)**
+- **Keseluruhan wilayah = rata-rata 3 jenis (sekolah+umum+khusus) ÷ 3 (missing=0, tetap ÷3)**
 - Ringkasan selalu tampil **sekolah, umum, khusus, keseluruhan** (walau 0)
-- KPI dashboard hanya menampilkan **FINAL** dan **DASAR**
-- **Cakupan (Target 68%) dan Penyesuaian Poin dipindahkan ke tabel Ringkasan**
-- Download Data Mentah = RAW hasil filter
+- Dashboard KPI hanya: **FINAL** & **DASAR**
+- Pop/Target/Terkumpul/Coverage + Penyesuaian Poin dipindah ke tabel Ringkasan
 
 **UPDATE (tampilan):**
-- Tabel Ringkasan memuat: Pop/Target68/Terkumpul/Coverage per jenis + Penyesuaian Poin
-- Tabel Agregat Wilayah memuat: Pop/Target68/Terkumpul per jenis + Total Update (sum 3 jenis)
+- target_total_68 & pop_total ditampilkan integer
+- coverage ditampilkan 2 desimal
 - Tabel "Agregat Wilayah × Jenis" ditampilkan hanya sampai Indeks_Dasar_Agregat_0_100
 """)
 
@@ -1926,13 +1804,12 @@ with gr.Blocks() as demo:
     run_btn = gr.Button("Jalankan Perhitungan")
     msg_out = gr.Markdown()
 
-    # KPI dashboard (hanya 2 kartu)
     kpi_out = gr.Markdown()
 
     gr.Markdown("## Ringkasan (Jenis + Keseluruhan) — Pop/Target68/Terkumpul/Coverage + Penyesuaian")
     out_summary = gr.DataFrame(interactive=False)
 
-    gr.Markdown("## Agregat Wilayah (Keseluruhan) — FIX: avg3 dari 3 jenis + Pop/Target68/Terkumpul (per jenis & total)")
+    gr.Markdown("## Agregat Wilayah (Keseluruhan) — FIX: avg3 dari 3 jenis + Pop/Target/Terkumpul (per jenis & total)")
     out_agg_total = gr.DataFrame(interactive=False)
 
     gr.Markdown("## Agregat Wilayah × Jenis (Sekolah, Umum, Khusus) — (ditampilkan sampai Indeks_Dasar_Agregat_0_100)")
@@ -1941,7 +1818,7 @@ with gr.Blocks() as demo:
     gr.Markdown("## Detail Entitas (Final menempel dari wilayah)")
     out_detail = gr.DataFrame(interactive=False)
 
-    gr.Markdown("## Kecukupan Sampel 68% (tanpa angka koma)")
+    gr.Markdown("## Kecukupan Sampel 68% PER JENIS (tanpa angka koma)")
     out_verif = gr.DataFrame(interactive=False)
 
     gr.Markdown("## Bell Curve — per Jenis Perpustakaan (Indeks per Entitas)")
@@ -1960,7 +1837,7 @@ with gr.Blocks() as demo:
     with gr.Row():
         dl_summary = gr.DownloadButton(label="Download Ringkasan (.xlsx)")
         dl_total = gr.DownloadButton(label="Download Agregat Wilayah (.xlsx)")
-        dl_jenis = gr.DownloadButton(label="Download Data Mentah (.xlsx)")
+        dl_raw = gr.DownloadButton(label="Download Data Mentah (.xlsx)")
         dl_detail = gr.DownloadButton(label="Download Detail Entitas (.xlsx)")
         dl_word = gr.DownloadButton(label="Download Laporan Word (.docx)")
 
@@ -1970,7 +1847,7 @@ with gr.Blocks() as demo:
         outputs=[
             kpi_out,
             out_summary, out_agg_total, out_agg_jenis, out_detail, out_verif,
-            dl_summary, dl_total, dl_jenis, dl_detail, dl_word,
+            dl_summary, dl_total, dl_raw, dl_detail, dl_word,
             bell_umum, bell_sekolah, bell_khusus,
             msg_out, analysis_out
         ]
@@ -1983,3 +1860,4 @@ with gr.Blocks() as demo:
     )
 
 demo.launch()
+