Update app.py

app.py

@@ -2,39 +2,58 @@
 """
 IPLM 2025 — Final (Target Sampel 33.88% per Jenis) — TANPA Kinerja Relatif / Percentile
 
-VERSI TULIS ULANG (lebih sederhana & rapi)
-- Mode NO UPLOAD: baca file dari repo/server (env DATA_FILE/POP_*)
-- Pipeline:
-  1) Normalisasi indikator di LEVEL ENTITAS:
-     Yeo-Johnson per indikator → MinMax global (0-1)
-     sub-indeks → dimensi → Indeks_Dasar_0_100
-  2) Penyesuaian kecukupan sampel per wilayah×jenis:
-     faktor = min(n_jenis / target_33.88_jenis, 1.0)
-     Indeks_Final_Agregat_0_100 = Indeks_Dasar_Agregat_0_100 * faktor
-  3) Agregat Wilayah (Keseluruhan) = avg3 (sekolah+umum+khusus), missing dianggap 0 dan tetap /3
-
-UI:
-- KPI Dashboard: hanya 2 kartu (Indeks Final & Indeks Dasar)
-- Bell curve: Indeks_Dasar_0_100 per entitas per jenis + hover nama perpustakaan
-- Analisis LLM: tampil dalam format tabel "Format Data Pendukung IPLM" (No/Dimensi/Nilai/Interpretasi/Rekomendasi)
+───────────────────────────────────────────────────────────────────────────────
+KONSEP / DOKUMENTASI
+
+A. Skor ABSOLUT (untuk akuntabilitas)
+------------------------------------
+1) Indeks_Dasar_0_100
+   - Dihitung pada LEVEL ENTITAS (baris perpustakaan) dari indikator:
+     Yeo-Johnson transform (per indikator) → MinMax global (0–1) → sub-indeks → dimensi → indeks.
+   - Rumus:
+     dim_kepatuhan = mean(sub_koleksi, sub_sdm)
+     dim_kinerja   = mean(sub_pelayanan, sub_pengelolaan)
+     Indeks_Dasar_0_100 = 100 * (W_KEPATUHAN*dim_kepatuhan + W_KINERJA*dim_kinerja)
+
+2) Penyesuaian kecukupan sampel berbasis TARGET 33.88% (per JENIS)
+   - TARGET_RATIO = 0.3388
+   - Untuk setiap wilayah × jenis:
+     pop_total_jenis = populasi perpustakaan jenis tsb (dari tabel POP)
+     target_total_33_88_jenis = pop_total_jenis * TARGET_RATIO
+     n_jenis = jumlah entitas (baris) terkumpul pada wilayah × jenis
+     faktor_penyesuaian_jenis = min(n_jenis / target_total_33_88_jenis, 1.0)
+   - Indeks_Final_Agregat_0_100 (wilayah×jenis):
+     Indeks_Final_Agregat_0_100 = Indeks_Dasar_Agregat_0_100 * faktor_penyesuaian_jenis
+
+3) AGREGAT WILAYAH (KESELURUHAN) = rata-rata 3 jenis (FIX)
+   - Keseluruhan wajib avg3:
+     Indeks_Dasar_Agregat_0_100(keseluruhan) = (dasar_sekolah + dasar_umum + dasar_khusus) / 3
+     Indeks_Final_Wilayah_0_100(keseluruhan) = (final_sekolah + final_umum + final_khusus) / 3
+   - Missing jenis dianggap 0 tetapi tetap dibagi 3 (sesuai requirement).
+
+B. UI (Permintaan)
+------------------
+✅ Dashboard KPI: hanya 2 kartu (Indeks Final & Indeks Dasar)
+❌ Tidak ada KPI Coverage di dashboard
+✅ Bell curve: kembali menampilkan Indeks_Dasar_0_100 per entitas per jenis
+✅ Hover bell curve menampilkan nama perpustakaan (nm_perpustakaan) per jenis
+
+───────────────────────────────────────────────────────────────────────────────
 """
 
 import os
 import re
 import time
-import json
 import tempfile
 from pathlib import Path
 
+import gradio as gr
 import numpy as np
 import pandas as pd
 import plotly.graph_objects as go
-import gradio as gr
 from sklearn.preprocessing import PowerTransformer
 
-# =========================
-# OPTIONAL: python-docx
-# =========================
+# python-docx opsional (di HF Space kadang belum ter-install)
 DOCX_AVAILABLE = True
 try:
     from docx import Document
@@ -42,9 +61,7 @@ except Exception:
     DOCX_AVAILABLE = False
     Document = None
 
-# =========================
-# OPTIONAL: HuggingFace LLM
-# =========================
+# huggingface client opsional
 HF_AVAILABLE = True
 try:
     from huggingface_hub import InferenceClient
@@ -52,6 +69,7 @@ except Exception:
     HF_AVAILABLE = False
     InferenceClient = None
 
+
 # ============================================================
 # 1) KONFIGURASI
 # ============================================================
@@ -64,8 +82,10 @@ POP_KHUSUS  = os.getenv("POP_KHUSUS",  "Data_populasi_perp_khusus.xlsx")
 W_KEPATUHAN = float(os.getenv("W_KEPATUHAN", "0.30"))
 W_KINERJA   = float(os.getenv("W_KINERJA",   "0.70"))
 
+# ✅ target sampel 33.88% per jenis
 TARGET_RATIO = float(os.getenv("TARGET_RATIO", "0.3388"))
 
+# LLM opsional
 USE_LLM = True
 LLM_MODEL_NAME = os.getenv("LLM_MODEL_NAME", "meta-llama/Meta-Llama-3-8B-Instruct")
 HF_TOKEN = (
@@ -75,13 +95,14 @@ HF_TOKEN = (
     or os.getenv("HF_API_TOKEN")
 )
 
+
 # ============================================================
-# 2) UTIL KECIL
+# 2) UTIL
 # ============================================================
 
-def _mtime(p: str):
-    pp = Path(p)
-    return pp.stat().st_mtime if pp.exists() else None
+def _mtime(path_str: str):
+    p = Path(path_str)
+    return p.stat().st_mtime if p.exists() else None
 
 def _canon(s: str) -> str:
     return re.sub(r"[^a-z0-9]+", "", str(s).lower())
@@ -92,19 +113,17 @@ def _disp_text(x):
     t = str(x).strip().upper()
     return " ".join(t.split())
 
-def pick_col(df: pd.DataFrame, candidates: list[str]):
+def pick_col(df, candidates):
     if df is None or df.empty:
         return None
-    # exact match
     for c in candidates:
         if c in df.columns:
             return c
-    # canon match
-    m = {_canon(c): c for c in df.columns}
+    can_map = {_canon(c): c for c in df.columns}
     for c in candidates:
         k = _canon(c)
-        if k in m:
-            return m[k]
+        if k in can_map:
+            return can_map[k]
     return None
 
 def coerce_num(val):
@@ -125,16 +144,17 @@ def coerce_num(val):
         t = t.replace(",", ".")
     else:
         t = t.replace(",", "")
+
     try:
         return float(t)
     except Exception:
         return np.nan
 
-def minmax_norm(series: pd.Series) -> pd.Series:
-    x = pd.to_numeric(series, errors="coerce").astype(float)
+def minmax_norm(s: pd.Series) -> pd.Series:
+    x = pd.to_numeric(s, errors="coerce").astype(float)
     mn, mx = x.min(skipna=True), x.max(skipna=True)
     if pd.isna(mn) or pd.isna(mx) or mx == mn:
-        return pd.Series(0.0, index=series.index)
+        return pd.Series(0.0, index=s.index)
     return (x - mn) / (mx - mn)
 
 def norm_kew(v):
@@ -152,24 +172,31 @@ def norm_kew(v):
 def norm_prov_disp(s):
     if pd.isna(s):
         return None
-    t = str(s).strip().upper().replace("\u00a0", " ")
-    t = " ".join(t.split()).replace("PROPINSI", "PROVINSI")
+    t = str(s).strip().upper()
+    t = t.replace("\u00a0", " ")
+    t = " ".join(t.split())
+    t = t.replace("PROPINSI", "PROVINSI")
+    while t.startswith("PROVINSI PROVINSI "):
+        t = t.replace("PROVINSI PROVINSI ", "PROVINSI ", 1)
     if t.startswith("PROVINSI "):
         name = t[len("PROVINSI "):].strip()
     else:
         name = t
     name = " ".join(name.split())
-    return f"PROVINSI {name}" if name else None
+    if not name:
+        return None
+    return f"PROVINSI {name}"
 
-def norm_prov_key(s):
+def norm_prov_label(s):
     if pd.isna(s):
         return None
     t = str(s).strip().upper().replace("\u00a0", " ")
-    t = " ".join(t.split()).replace("PROPINSI", "PROVINSI")
+    t = " ".join(t.split())
+    t = t.replace("PROPINSI", "PROVINSI")
     t = t.replace("PROVINSI", "").strip()
     return re.sub(r"[^A-Z0-9]+", "", t)
 
-def norm_kab_key(s):
+def norm_kab_label(s):
     if pd.isna(s):
         return None
     t = str(s).upper()
@@ -181,15 +208,25 @@ def norm_kab_key(s):
     t = " ".join(t.split())
     return re.sub(r"[^A-Z0-9]+", "", t)
 
-def faktor_penyesuaian(n: float, target: float) -> float:
-    if target is None or pd.isna(target) or float(target) <= 0:
+def safe_div(num, den):
+    if den is None or pd.isna(den) or float(den) <= 0:
+        return np.nan
+    return float(num) / float(den)
+
+def faktor_penyesuaian_total(n_total: float, target_total: float) -> float:
+    """
+    faktor = min(n / target, 1.0)
+    - Jika target <= 0 → default 1.0 (tidak menghukum)
+    """
+    if target_total is None or pd.isna(target_total) or float(target_total) <= 0:
         return 1.0
-    if n is None or pd.isna(n) or float(n) < 0:
-        n = 0.0
-    return float(min(float(n) / float(target), 1.0))
+    if n_total is None or pd.isna(n_total) or float(n_total) < 0:
+        n_total = 0.0
+    return float(min(float(n_total) / float(target_total), 1.0))
+
 
 # ============================================================
-# 3) INDIKATOR IPLM + ALIAS
+# 3) INDIKATOR IPLM
 # ============================================================
 
 koleksi_cols = [
@@ -214,6 +251,7 @@ pengelolaan_cols = [
 ]
 all_indicators = koleksi_cols + sdm_cols + pelayanan_cols + pengelolaan_cols
 
+# alias kolom DM → nama baku indikator
 alias_map_raw = {
     "j_judul_koleksi_tercetak": "JudulTercetak",
     "j_eksemplar_koleksi_tercetak": "EksemplarTercetak",
@@ -243,11 +281,12 @@ alias_map_raw = {
 }
 alias_map = {_canon(k): v for k, v in alias_map_raw.items()}
 
+
 # ============================================================
-# 4) PREPARE GLOBAL (LEVEL ENTITAS)
+# 4) PIPELINE NASIONAL (LEVEL ENTITAS)
 # ============================================================
 
-def _mean_norm_cols(row: pd.Series, cols: list[str]) -> float:
+def _mean_norm_cols(row, cols):
     vals = []
     for c in cols:
         k = f"norm_{c}"
@@ -260,11 +299,12 @@ def _mean_norm_cols(row: pd.Series, cols: list[str]) -> float:
 
 def prepare_global(df_src: pd.DataFrame) -> pd.DataFrame:
     """
-    - Rename indikator via alias
-    - Coerce numeric
-    - Yeo-Johnson (standardize=False) per indikator
-    - MinMax global (0-1)
-    - sub/dim dan Indeks_Dasar_0_100
+    Transform + normalisasi indikator pada level entitas:
+    - rename kolom indikator (alias)
+    - coerce numeric
+    - Yeo-Johnson per indikator (standardize=False)
+    - MinMax global 0-1
+    - hitung sub_*, dim_*, Indeks_Dasar_0_100
     """
     if df_src is None or df_src.empty:
         return df_src
@@ -289,17 +329,16 @@ def prepare_global(df_src: pd.DataFrame) -> pd.DataFrame:
     for c in available:
         df[c] = df[c].apply(coerce_num)
 
+    # YJ per indikator + MinMax global
     for c in available:
         x = pd.to_numeric(df[c], errors="coerce").astype(float).values
         mask = ~np.isnan(x)
         transformed = np.full_like(x, np.nan, dtype=float)
-
         if mask.sum() > 1:
             pt = PowerTransformer(method="yeo-johnson", standardize=False)
             transformed[mask] = pt.fit_transform(x[mask].reshape(-1, 1)).ravel()
         else:
             transformed[mask] = x[mask]
-
         df[f"norm_{c}"] = minmax_norm(pd.Series(transformed, index=df.index))
 
     df["sub_koleksi"]     = df.apply(lambda r: _mean_norm_cols(r, [c for c in koleksi_cols if c in available]), axis=1)
@@ -307,23 +346,42 @@ def prepare_global(df_src: pd.DataFrame) -> pd.DataFrame:
     df["sub_pelayanan"]   = df.apply(lambda r: _mean_norm_cols(r, [c for c in pelayanan_cols if c in available]), axis=1)
     df["sub_pengelolaan"] = df.apply(lambda r: _mean_norm_cols(r, [c for c in pengelolaan_cols if c in available]), axis=1)
 
-    df["dim_kepatuhan"] = df[["sub_koleksi", "sub_sdm"]].mean(axis=1)
-    df["dim_kinerja"]   = df[["sub_pelayanan", "sub_pengelolaan"]].mean(axis=1)
+    df["dim_kepatuhan"] = df[["sub_koleksi","sub_sdm"]].mean(axis=1)
+    df["dim_kinerja"]   = df[["sub_pelayanan","sub_pengelolaan"]].mean(axis=1)
 
-    df["Indeks_Dasar_0_100"] = 100.0 * (W_KEPATUHAN * df["dim_kepatuhan"] + W_KINERJA * df["dim_kinerja"])
+    df["Indeks_Dasar_0_100"] = 100 * (W_KEPATUHAN * df["dim_kepatuhan"] + W_KINERJA * df["dim_kinerja"])
 
     for c in ["sub_koleksi","sub_sdm","sub_pelayanan","sub_pengelolaan","dim_kepatuhan","dim_kinerja","Indeks_Dasar_0_100"]:
         df[c] = pd.to_numeric(df[c], errors="coerce").fillna(0.0)
 
     return df
 
+
 # ============================================================
-# 5) LOAD FILES + CACHE
+# 5) CACHE LOADER (NO UPLOAD)
 # ============================================================
 
-_CACHE = {"key": None, "df_all": None, "df_raw": None, "pop_kab": None, "pop_prov": None, "pop_khusus": None, "meta": None, "info": None}
+_CACHE = {
+    "key": None,
+    "df_all": None,
+    "df_raw": None,
+    "pop_kab": None,
+    "pop_prov": None,
+    "pop_khusus": None,
+    "meta": None,
+    "info": None
+}
 
 def _parse_pop_khusus(path_xlsx: str) -> pd.DataFrame:
+    """
+    POP_KHUSUS format campuran:
+    - Baris 'PROVINSI X' → level PROV
+    - Baris berikutnya → KAB/KOTA dibawah prov tsb
+    Output standar:
+    LEVEL: PROV / KAB
+    prov_key / kab_key
+    Pop_Total_Jenis
+    """
     df = pd.read_excel(path_xlsx)
     if df is None or df.empty:
         return pd.DataFrame()
@@ -374,32 +432,40 @@ def _parse_pop_khusus(path_xlsx: str) -> pd.DataFrame:
         return pop
 
     pop["Pop_Total_Jenis"] = pd.to_numeric(pop["Pop_Total_Jenis"], errors="coerce").fillna(0.0)
-    pop["prov_key"] = pop["Provinsi_Label"].apply(norm_prov_key)
-    pop["kab_key"] = pop["Kab_Kota_Label"].apply(norm_kab_key) if "Kab_Kota_Label" in pop.columns else None
+    pop["prov_key"] = pop["Provinsi_Label"].apply(norm_prov_label)
+    pop["kab_key"] = pop["Kab_Kota_Label"].apply(norm_kab_label) if "Kab_Kota_Label" in pop.columns else None
     return pop
 
-def load_default_files(force: bool = False):
+def load_default_files(force=False):
+    """
+    Load 4 file:
+    - DM (DATA_FILE) multi-sheet → concat
+    - POP_KAB, POP_PROV, POP_KHUSUS
+    + Standarisasi kolom wilayah & jenis
+    + Dedup baris DM
+    + prepare_global() (YJ+MinMax+Indeks_Dasar)
+    """
     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"]
 
     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}"
+            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})
             return None, None, None, None, None, {}, info
 
-    # DM multi-sheet -> concat
     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", "kab_kota"])
+    kab_col   = pick_col(df_raw, ["kab/kota", "Kab/Kota", "Kab_Kota", "KAB/KOTA", "kabupaten_kota", "Kabupaten/Kota", "kabupaten kota", "kota", "kab_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"])
@@ -410,11 +476,11 @@ def load_default_files(force: bool = False):
     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)}"
+        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})
         return None, None, None, None, None, {}, info
 
-    # map jenis -> sekolah/umum/khusus
+    # mapping jenis → baku (sekolah/umum/khusus)
     val_map_jenis = {
         "PERPUSTAKAAN SEKOLAH": "sekolah", "SEKOLAH": "sekolah",
         "PERPUSTAKAAN UMUM": "umum", "UMUM": "umum", "PERPUSTAKAAN DAERAH": "umum",
@@ -425,10 +491,10 @@ def load_default_files(force: bool = False):
     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_key)
-    df_raw["kab_key"]   = df_raw["KAB_DISP"].apply(norm_kab_key)
+    df_raw["prov_key"]  = df_raw["PROV_DISP"].apply(norm_prov_label)
+    df_raw["kab_key"]   = df_raw["KAB_DISP"].apply(norm_kab_label)
 
-    # dedup aman (prov,kab,kew,jenis,nama)
+    # Dedup aman berdasarkan (prov,kab,kew,jenis,nama_perpus)
     if nama_col and nama_col in df_raw.columns:
         kcols = [prov_col, kab_col, kew_col, jenis_col, nama_col]
     else:
@@ -440,178 +506,241 @@ def load_default_files(force: bool = False):
     df_raw = df_raw.drop_duplicates(subset=["_row_key"], keep="first").copy()
     after = len(df_raw)
 
-    # POP_KAB
+    # POP KAB
     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_prov = pick_col(pk, ["PROVINSI","Provinsi","provinsi"])
     if c_kab is None:
-        info = "POP_KAB: kolom Kab/Kota tidak ditemukan."
+        info = "❌ POP_KAB: wajib ada kolom Kab/Kota."
         _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 = pk.copy()
     pop_kab["Kab_Kota_Label"] = pk[c_kab].astype(str).str.strip()
     pop_kab["Provinsi_Label"] = pk[c_prov].astype(str).str.strip() if c_prov else ""
-    pop_kab["kab_key"] = pop_kab["Kab_Kota_Label"].apply(norm_kab_key)
+    pop_kab["kab_key"] = pop_kab["Kab_Kota_Label"].apply(norm_kab_label)
     pop_kab = pop_kab.groupby("kab_key", as_index=False).first()
 
-    # POP_PROV
+    # POP PROV
     pp = pd.read_excel(POP_PROV)
     c_pr = pick_col(pp, ["Provinsi","PROVINSI","provinsi","Propinsi","PROPINSI","propinsi"])
     if c_pr is None:
-        info = "POP_PROV: kolom Provinsi tidak ditemukan."
+        info = "❌ POP_PROV: wajib ada kolom Provinsi."
         _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 = pp.copy()
     pop_prov["Provinsi_Label"] = pp[c_pr].astype(str).str.strip()
-    pop_prov["prov_key"] = pop_prov["Provinsi_Label"].apply(norm_prov_key)
+    pop_prov["prov_key"] = pop_prov["Provinsi_Label"].apply(norm_prov_label)
     pop_prov = pop_prov.groupby("prov_key", as_index=False).first()
 
-    # POP_KHUSUS
+    # POP KHUSUS
     try:
         pop_khusus = _parse_pop_khusus(POP_KHUSUS)
     except Exception as e:
-        info = f"POP_KHUSUS gagal dibaca: {repr(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})
         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)\n"
-        f"DM: {fp.name} | baris {before} -> dedup {after}\n"
-        f"POP_KAB: {Path(POP_KAB).name} (n={len(pop_kab)})\n"
-        f"POP_PROV: {Path(POP_PROV).name} (n={len(pop_prov)})\n"
-        f"POP_KHUSUS: {Path(POP_KHUSUS).name} (n={len(pop_khusus)})\n"
-        f"TARGET per jenis: {TARGET_RATIO*100:.2f}%\n"
-        f"mtime: DM={time.ctime(_mtime(DATA_FILE))}"
+        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)})<br>"
+        f"✅ POP_PROV: <b>{Path(POP_PROV).name}</b> (n={len(pop_prov)})<br>"
+        f"✅ POP_KHUSUS: <b>{Path(POP_KHUSUS).name}</b> (n={len(pop_khusus)}) — (PROV row ikut dihitung)<br>"
+        f"✅ TARGET sampel per jenis: <b>{TARGET_RATIO*100:.2f}%</b><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))}"
     )
 
-    _CACHE.update({"key": key, "df_all": df_all, "df_raw": df_raw, "pop_kab": pop_kab, "pop_prov": pop_prov, "pop_khusus": pop_khusus, "meta": meta, "info": info})
+    _CACHE.update({
+        "key": key,
+        "df_all": df_all,
+        "df_raw": df_raw,
+        "pop_kab": pop_kab,
+        "pop_prov": pop_prov,
+        "pop_khusus": pop_khusus,
+        "meta": meta,
+        "info": info
+    })
     return df_all, df_raw, pop_kab, pop_prov, pop_khusus, meta, info
 
+
 # ============================================================
-# 6) FAKTOR WILAYAH×JENIS (TARGET 33.88%)
+# 6) FAKTOR WILAYAH — PER JENIS (TARGET 33.88%)
 # ============================================================
 
-def build_faktor_wilayah_jenis(df: pd.DataFrame, pop_kab: pd.DataFrame, pop_prov: pd.DataFrame, pop_khusus: pd.DataFrame, kew_value: str):
-    if df is None or df.empty:
+def build_faktor_wilayah_jenis(
+    df_filtered: pd.DataFrame,
+    pop_kab: pd.DataFrame,
+    pop_prov: pd.DataFrame,
+    pop_khusus: pd.DataFrame,
+    kew_value: str
+):
+    """
+    Output tabel:
+    group_key + (Kab/Kota atau Provinsi) + Jenis
+    n_jenis, pop_total_jenis, target_total_33_88_jenis,
+    coverage_jenis_%, faktor_penyesuaian_jenis, gap_target33_88_jenis
+    """
+    if df_filtered is None or df_filtered.empty:
         return pd.DataFrame()
 
     kew_norm = str(kew_value or "").upper()
+    df = df_filtered.copy()
     df = df[df["_dataset"].isin(["sekolah", "umum", "khusus"])].copy()
     if df.empty:
         return pd.DataFrame()
 
     jenis_list = ["sekolah", "umum", "khusus"]
 
+    # tentukan level berdasarkan kewenangan
     if "PROV" in kew_norm:
         key_col, label_col, label_name, mode = "prov_key", "PROV_DISP", "Provinsi", "PROV"
         base_pop = pop_prov.copy() if (pop_prov is not None and not pop_prov.empty) else pd.DataFrame()
         if not base_pop.empty and "prov_key" not in base_pop.columns:
-            base_pop["prov_key"] = base_pop["Provinsi_Label"].apply(norm_prov_key)
+            base_pop["prov_key"] = base_pop["Provinsi_Label"].apply(norm_prov_label) if "Provinsi_Label" in base_pop.columns else base_pop.iloc[:, 0].apply(norm_prov_label)
         base_pop = base_pop.set_index("prov_key") if (not base_pop.empty and "prov_key" in base_pop.columns) else pd.DataFrame().set_index(pd.Index([]))
     else:
         key_col, label_col, label_name, mode = "kab_key", "KAB_DISP", "Kab/Kota", "KAB"
         base_pop = pop_kab.copy() if (pop_kab is not None and not pop_kab.empty) else pd.DataFrame()
         if not base_pop.empty and "kab_key" not in base_pop.columns:
-            base_pop["kab_key"] = base_pop["Kab_Kota_Label"].apply(norm_kab_key)
+            base_pop["kab_key"] = base_pop["Kab_Kota_Label"].apply(norm_kab_label) if "Kab_Kota_Label" in base_pop.columns else base_pop.iloc[:, 0].apply(norm_kab_label)
         base_pop = base_pop.set_index("kab_key") if (not base_pop.empty and "kab_key" in base_pop.columns) else pd.DataFrame().set_index(pd.Index([]))
 
+    # GRID: semua wilayah × 3 jenis (berdasarkan yang muncul di data filter)
     base_keys = df[[key_col, label_col]].drop_duplicates().rename(columns={key_col: "group_key", label_col: label_name})
-    full = base_keys.assign(_tmp=1).merge(pd.DataFrame({"Jenis": jenis_list, "_tmp": 1}), on="_tmp").drop(columns="_tmp")
+    full = base_keys.assign(_tmp=1).merge(
+        pd.DataFrame({"Jenis": jenis_list, "_tmp": 1}),
+        on="_tmp"
+    ).drop(columns="_tmp")
 
+    # count entitas per wilayah×jenis
     cnt = (
         df.groupby([key_col, label_col, "_dataset"], dropna=False)
-          .size().reset_index(name="n_jenis")
+          .size()
+          .reset_index(name="n_jenis")
           .rename(columns={key_col: "group_key", label_col: label_name, "_dataset": "Jenis"})
     )
     cnt["Jenis"] = cnt["Jenis"].astype(str).str.lower().str.strip()
 
-    out = full.merge(cnt, on=["group_key", label_name, "Jenis"], how="left")
-    out["n_jenis"] = pd.to_numeric(out["n_jenis"], errors="coerce").fillna(0).astype(int)
+    base_n = full.merge(cnt, on=["group_key", label_name, "Jenis"], how="left")
+    base_n["n_jenis"] = pd.to_numeric(base_n["n_jenis"], errors="coerce").fillna(0).astype(int)
 
-    out["pop_total_jenis"] = 0.0
-    out["target_total_33_88_jenis"] = 0.0
+    base_n["target_total_33_88_jenis"] = 0.0
+    base_n["pop_total_jenis"] = 0.0
 
-    # sekolah & umum dari pop_kab/pop_prov
+    # SEKOLAH + UMUM dari POP_KAB/POP_PROV
     if not base_pop.empty:
         if mode == "KAB":
             pop_sekolah = pd.to_numeric(base_pop.get("jumlah_populasi_sekolah", 0), errors="coerce").fillna(0.0)
             pop_umum    = pd.to_numeric(base_pop.get("jumlah_populasi_umum", 0), errors="coerce").fillna(0.0)
+
+            tgt_sekolah = pop_sekolah * float(TARGET_RATIO)
+            tgt_umum    = pop_umum * float(TARGET_RATIO)
         else:
+            # PROV: sekolah = sma + smk + slb (sesuai pola file Anda)
             sma = pd.to_numeric(base_pop.get("sma ", base_pop.get("sma", 0)), errors="coerce").fillna(0.0)
             smk = pd.to_numeric(base_pop.get("smk", 0), errors="coerce").fillna(0.0)
             slb = pd.to_numeric(base_pop.get("slb", 0), errors="coerce").fillna(0.0)
+
             pop_sekolah = sma + smk + slb
-            pop_umum    = pd.to_numeric(base_pop.get("perpus_umum_prop", 0), errors="coerce").fillna(0.0)
+            tgt_sekolah = pop_sekolah * float(TARGET_RATIO)
 
-        tgt_sekolah = pop_sekolah * float(TARGET_RATIO)
-        tgt_umum    = pop_umum * float(TARGET_RATIO)
+            pop_umum = pd.to_numeric(base_pop.get("perpus_umum_prop", 0), errors="coerce").fillna(0.0)
+            tgt_umum = pop_umum * float(TARGET_RATIO)
 
-        m = out["Jenis"].eq("sekolah")
-        out.loc[m, "pop_total_jenis"] = out.loc[m, "group_key"].map(pop_sekolah).fillna(0.0).values
-        out.loc[m, "target_total_33_88_jenis"] = out.loc[m, "group_key"].map(tgt_sekolah).fillna(0.0).values
+        m = base_n["Jenis"].eq("sekolah")
+        base_n.loc[m, "pop_total_jenis"] = base_n.loc[m, "group_key"].map(pop_sekolah).fillna(0.0).values
+        base_n.loc[m, "target_total_33_88_jenis"] = base_n.loc[m, "group_key"].map(tgt_sekolah).fillna(0.0).values
 
-        m = out["Jenis"].eq("umum")
-        out.loc[m, "pop_total_jenis"] = out.loc[m, "group_key"].map(pop_umum).fillna(0.0).values
-        out.loc[m, "target_total_33_88_jenis"] = out.loc[m, "group_key"].map(tgt_umum).fillna(0.0).values
+        m = base_n["Jenis"].eq("umum")
+        base_n.loc[m, "pop_total_jenis"] = base_n.loc[m, "group_key"].map(pop_umum).fillna(0.0).values
+        base_n.loc[m, "target_total_33_88_jenis"] = base_n.loc[m, "group_key"].map(tgt_umum).fillna(0.0).values
 
-    # khusus dari pop_khusus
+    # KHUSUS dari POP_KHUSUS
     if pop_khusus is not None and not pop_khusus.empty:
         pk = pop_khusus.copy()
         pk["Pop_Total_Jenis"] = pd.to_numeric(pk.get("Pop_Total_Jenis", 0), errors="coerce").fillna(0.0)
 
         if mode == "PROV":
-            pk2 = pk[pk["LEVEL"].astype(str).str.upper() == "PROV"].copy()
-            pop_series = pk2.groupby("prov_key")["Pop_Total_Jenis"].sum()
+            pk_prov = pk[pk["LEVEL"].astype(str).str.upper() == "PROV"].copy()
+            pk_map = pk_prov.groupby("prov_key", as_index=True).agg(pop=("Pop_Total_Jenis", "sum"))
+            pop_series = pk_map["pop"]
         else:
-            pk2 = pk[pk["LEVEL"].astype(str).str.upper() == "KAB"].copy()
-            pop_series = pk2.groupby("kab_key")["Pop_Total_Jenis"].sum()
+            pk_kab = pk[pk["LEVEL"].astype(str).str.upper() == "KAB"].copy()
+            pk_map = pk_kab.groupby("kab_key", as_index=True).agg(pop=("Pop_Total_Jenis", "sum"))
+            pop_series = pk_map["pop"]
 
         tgt_series = pop_series * float(TARGET_RATIO)
 
-        m = out["Jenis"].eq("khusus")
-        out.loc[m, "pop_total_jenis"] = out.loc[m, "group_key"].map(pop_series).fillna(0.0).values
-        out.loc[m, "target_total_33_88_jenis"] = out.loc[m, "group_key"].map(tgt_series).fillna(0.0).values
+        m = base_n["Jenis"].eq("khusus")
+        base_n.loc[m, "pop_total_jenis"] = base_n.loc[m, "group_key"].map(pop_series).fillna(0.0).values
+        base_n.loc[m, "target_total_33_88_jenis"] = base_n.loc[m, "group_key"].map(tgt_series).fillna(0.0).values
+
+    base_n["target_total_33_88_jenis"] = pd.to_numeric(base_n["target_total_33_88_jenis"], errors="coerce").fillna(0.0)
+    base_n["pop_total_jenis"] = pd.to_numeric(base_n["pop_total_jenis"], errors="coerce").fillna(0.0)
 
-    out["pop_total_jenis"] = pd.to_numeric(out["pop_total_jenis"], errors="coerce").fillna(0.0)
-    out["target_total_33_88_jenis"] = pd.to_numeric(out["target_total_33_88_jenis"], errors="coerce").fillna(0.0)
+    # fallback pop jika 0 tapi target ada
+    m_need_pop = (base_n["pop_total_jenis"] <= 0) & (base_n["target_total_33_88_jenis"] > 0)
+    base_n.loc[m_need_pop, "pop_total_jenis"] = base_n.loc[m_need_pop, "target_total_33_88_jenis"] / float(TARGET_RATIO)
 
-    out["faktor_penyesuaian_jenis"] = [
-        faktor_penyesuaian(n, t)
-        for n, t in zip(out["n_jenis"].astype(float), out["target_total_33_88_jenis"].astype(float))
+    # faktor penyesuaian
+    base_n["faktor_penyesuaian_jenis"] = [
+        faktor_penyesuaian_total(n, t)
+        for n, t in zip(
+            pd.to_numeric(base_n["n_jenis"], errors="coerce").fillna(0).astype(float),
+            pd.to_numeric(base_n["target_total_33_88_jenis"], errors="coerce").fillna(0).astype(float),
+        )
     ]
 
-    out["coverage_jenis_%"] = np.where(
-        out["pop_total_jenis"].values > 0,
-        (out["n_jenis"].astype(float).values / out["pop_total_jenis"].values) * 100.0,
-        0.0
-    )
+    base_n["coverage_jenis_%"] = [
+        (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),
+            pd.to_numeric(base_n["pop_total_jenis"], errors="coerce").fillna(0).astype(float),
+        )
+    ]
 
-    out["gap_target33_88_jenis"] = np.maximum(out["target_total_33_88_jenis"].values - out["n_jenis"].astype(float).values, 0.0)
+    base_n["gap_target33_88_jenis"] = [
+        max(float(t) - float(n), 0.0)
+        for n, t in zip(
+            pd.to_numeric(base_n["n_jenis"], errors="coerce").fillna(0).astype(float),
+            pd.to_numeric(base_n["target_total_33_88_jenis"], errors="coerce").fillna(0).astype(float),
+        )
+    ]
 
-    # format
-    out["pop_total_jenis"] = out["pop_total_jenis"].round(0).astype(int)
-    out["target_total_33_88_jenis"] = out["target_total_33_88_jenis"].round(0).astype(int)
-    out["coverage_jenis_%"] = pd.to_numeric(out["coverage_jenis_%"], errors="coerce").fillna(0.0).round(2)
-    out["faktor_penyesuaian_jenis"] = pd.to_numeric(out["faktor_penyesuaian_jenis"], errors="coerce").fillna(1.0).round(3)
-    out["gap_target33_88_jenis"] = pd.to_numeric(out["gap_target33_88_jenis"], errors="coerce").fillna(0.0).round(0).astype(int)
+    # display formatting
+    base_n["target_total_33_88_jenis"] = pd.to_numeric(base_n["target_total_33_88_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["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_target33_88_jenis"]    = pd.to_numeric(base_n["gap_target33_88_jenis"], errors="coerce").fillna(0).round(0).astype(int)
+
+    return base_n
 
-    return out
 
 # ============================================================
-# 7) AGREGAT WILAYAH×JENIS
+# 7) AGREGAT WILAYAH × JENIS
 # ============================================================
 
-def build_agg_wilayah_jenis(df: pd.DataFrame, faktor_wj: pd.DataFrame, kew_value: str):
-    if df is None or df.empty:
+def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, faktor_wilayah_jenis: pd.DataFrame, kew_value: str):
+    """
+    Agregasi:
+    wilayah × jenis:
+      - Jumlah (n entitas)
+      - rata-rata sub/dim
+      - Indeks_Dasar_Agregat_0_100 = mean(Indeks_Dasar_0_100)
+      - Indeks_Final_Agregat_0_100 = Indeks_Dasar_Agregat_0_100 * faktor_penyesuaian_jenis
+    """
+    if df_filtered is None or df_filtered.empty:
         return pd.DataFrame()
 
     kew_norm = str(kew_value or "").upper()
+    df = df_filtered.copy()
+
     if "PROV" in kew_norm:
         key_col, label_col, label_name = "prov_key", "PROV_DISP", "Provinsi"
     else:
@@ -623,9 +752,14 @@ def build_agg_wilayah_jenis(df: pd.DataFrame, faktor_wj: pd.DataFrame, kew_value
 
     jenis_list = ["sekolah", "umum", "khusus"]
 
+    # GRID semua wilayah × 3 jenis
     base_keys = df[[key_col, label_col]].drop_duplicates().rename(columns={key_col: "group_key", label_col: label_name})
-    full = base_keys.assign(_tmp=1).merge(pd.DataFrame({"Jenis": jenis_list, "_tmp": 1}), on="_tmp").drop(columns="_tmp")
+    full = base_keys.assign(_tmp=1).merge(
+        pd.DataFrame({"Jenis": jenis_list, "_tmp": 1}),
+        on="_tmp"
+    ).drop(columns="_tmp")
 
+    # agregat real
     agg_real = df.groupby([key_col, label_col, "_dataset"], dropna=False).agg(
         Jumlah=("Indeks_Dasar_0_100", "size"),
         Rata2_sub_koleksi=("sub_koleksi", "mean"),
@@ -639,71 +773,106 @@ def build_agg_wilayah_jenis(df: pd.DataFrame, faktor_wj: pd.DataFrame, kew_value
 
     agg_real["Jenis"] = agg_real["Jenis"].astype(str).str.lower().str.strip()
 
-    out = full.merge(agg_real, on=["group_key", label_name, "Jenis"], how="left")
-    for c in ["Jumlah","Rata2_sub_koleksi","Rata2_sub_sdm","Rata2_sub_pelayanan","Rata2_sub_pengelolaan","Rata2_dim_kepatuhan","Rata2_dim_kinerja","Indeks_Dasar_Agregat_0_100"]:
-        out[c] = pd.to_numeric(out.get(c, 0), errors="coerce").fillna(0.0)
-
-    out["Jumlah"] = out["Jumlah"].round(0).astype(int)
-
-    # merge faktor
-    if faktor_wj is None or faktor_wj.empty:
-        out["faktor_penyesuaian_jenis"] = 1.0
-        out["pop_total_jenis"] = 0
-        out["target_total_33_88_jenis"] = 0
-        out["n_jenis"] = 0
-        out["coverage_jenis_%"] = 0.0
-        out["gap_target33_88_jenis"] = 0
+    agg = full.merge(agg_real, on=["group_key", label_name, "Jenis"], how="left")
+    for c in ["Jumlah","Rata2_sub_koleksi","Rata2_sub_sdm","Rata2_sub_pelayanan","Rata2_sub_pengelolaan",
+              "Rata2_dim_kepatuhan","Rata2_dim_kinerja","Indeks_Dasar_Agregat_0_100"]:
+        if c in agg.columns:
+            agg[c] = pd.to_numeric(agg[c], errors="coerce").fillna(0.0)
+
+    agg["Jumlah"] = agg["Jumlah"].round(0).astype(int)
+
+    # merge faktor jenis
+    if faktor_wilayah_jenis is None or faktor_wilayah_jenis.empty:
+        agg["faktor_penyesuaian_jenis"] = 1.0
+        agg["target_total_33_88_jenis"] = 0
+        agg["pop_total_jenis"] = 0
+        agg["coverage_jenis_%"] = 0.0
+        agg["gap_target33_88_jenis"] = 0
+        agg["n_jenis"] = 0
     else:
-        fw = faktor_wj.copy()
+        fw = faktor_wilayah_jenis.copy()
         fw["Jenis"] = fw["Jenis"].astype(str).str.lower().str.strip()
-        keep = ["group_key", label_name, "Jenis","faktor_penyesuaian_jenis","pop_total_jenis","target_total_33_88_jenis","n_jenis","coverage_jenis_%","gap_target33_88_jenis"]
+
+        keep = ["group_key", label_name, "Jenis",
+                "faktor_penyesuaian_jenis", "target_total_33_88_jenis", "pop_total_jenis",
+                "coverage_jenis_%", "gap_target33_88_jenis", "n_jenis"]
         fw = fw[[c for c in keep if c in fw.columns]].copy()
-        out = out.merge(fw, on=["group_key", label_name, "Jenis"], how="left")
 
-        out["faktor_penyesuaian_jenis"] = pd.to_numeric(out["faktor_penyesuaian_jenis"], errors="coerce").fillna(1.0)
-        for c in ["pop_total_jenis","target_total_33_88_jenis","n_jenis","gap_target33_88_jenis"]:
-            out[c] = pd.to_numeric(out.get(c, 0), errors="coerce").fillna(0).round(0).astype(int)
-        out["coverage_jenis_%"] = pd.to_numeric(out.get("coverage_jenis_%", 0), errors="coerce").fillna(0.0).round(2)
+        agg = agg.merge(fw, on=["group_key", label_name, "Jenis"], how="left")
+        agg["faktor_penyesuaian_jenis"] = pd.to_numeric(agg["faktor_penyesuaian_jenis"], errors="coerce").fillna(1.0)
+
+        for c in ["target_total_33_88_jenis","pop_total_jenis","gap_target33_88_jenis","n_jenis"]:
+            if c in agg.columns:
+                agg[c] = pd.to_numeric(agg[c], errors="coerce").fillna(0).round(0).astype(int)
 
-    out["Indeks_Final_Agregat_0_100"] = out["Indeks_Dasar_Agregat_0_100"] * out["faktor_penyesuaian_jenis"]
+        if "coverage_jenis_%" in agg.columns:
+            agg["coverage_jenis_%"] = pd.to_numeric(agg["coverage_jenis_%"], errors="coerce").fillna(0.0).round(2)
+
+    # Indeks FINAL per jenis
+    agg["Indeks_Final_Agregat_0_100"] = (
+        pd.to_numeric(agg["Indeks_Dasar_Agregat_0_100"], errors="coerce").fillna(0.0)
+        * pd.to_numeric(agg["faktor_penyesuaian_jenis"], errors="coerce").fillna(1.0)
+    )
 
     # rounding
-    for c in ["Rata2_sub_koleksi","Rata2_sub_sdm","Rata2_sub_pelayanan","Rata2_sub_pengelolaan","Rata2_dim_kepatuhan","Rata2_dim_kinerja"]:
-        out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0.0).round(3)
-    out["Indeks_Dasar_Agregat_0_100"] = pd.to_numeric(out["Indeks_Dasar_Agregat_0_100"], errors="coerce").fillna(0.0).round(2)
-    out["Indeks_Final_Agregat_0_100"] = pd.to_numeric(out["Indeks_Final_Agregat_0_100"], errors="coerce").fillna(0.0).round(2)
-    out["faktor_penyesuaian_jenis"] = pd.to_numeric(out["faktor_penyesuaian_jenis"], errors="coerce").fillna(1.0).round(3)
+    for c in [
+        "Rata2_sub_koleksi","Rata2_sub_sdm","Rata2_sub_pelayanan","Rata2_sub_pengelolaan",
+        "Rata2_dim_kepatuhan","Rata2_dim_kinerja"
+    ]:
+        if c in agg.columns:
+            agg[c] = pd.to_numeric(agg[c], errors="coerce").fillna(0.0).round(3)
+
+    for c in ["Indeks_Dasar_Agregat_0_100","Indeks_Final_Agregat_0_100"]:
+        if c in agg.columns:
+            agg[c] = pd.to_numeric(agg[c], errors="coerce").fillna(0.0).round(2)
+
+    agg["faktor_penyesuaian_jenis"] = pd.to_numeric(agg["faktor_penyesuaian_jenis"], errors="coerce").fillna(1.0).round(3)
+    return agg
 
-    return out
 
 # ============================================================
-# 8) AGREGAT WILAYAH KESELURUHAN — avg3 FIX
+# 8) AGREGAT WILAYAH (KESELURUHAN) — avg3 dari 3 jenis
 # ============================================================
 
-def build_agg_wilayah_total_from_jenis(agg_jenis: pd.DataFrame, kew_value: str):
+def build_agg_wilayah_total_from_jenis(agg_jenis: pd.DataFrame, faktor_wilayah_jenis: pd.DataFrame, kew_value: str):
+    """
+    Membentuk tabel wilayah keseluruhan dari agg_jenis, dengan FIX avg3:
+      Indeks_Dasar_Agregat_0_100 (keseluruhan) = mean(dasar_3jenis)  [missing=0, tetap /3]
+      Indeks_Final_Wilayah_0_100 (keseluruhan) = mean(final_3jenis)  [missing=0, tetap /3]
+    """
     if agg_jenis is None or agg_jenis.empty:
         return pd.DataFrame()
 
     kew_norm = str(kew_value or "").upper()
     label_name = "Provinsi" if "PROV" in kew_norm else "Kab/Kota"
+    jenis_list = ["sekolah", "umum", "khusus"]
 
     a = agg_jenis.copy()
     a["Jenis"] = a["Jenis"].astype(str).str.lower().str.strip()
 
-    jenis_list = ["sekolah", "umum", "khusus"]
     base_keys = a[["group_key", label_name]].drop_duplicates()
-    full = base_keys.assign(_tmp=1).merge(pd.DataFrame({"Jenis": jenis_list, "_tmp": 1}), on="_tmp").drop(columns="_tmp")
+    full = base_keys.assign(_tmp=1).merge(
+        pd.DataFrame({"Jenis": jenis_list, "_tmp": 1}),
+        on="_tmp"
+    ).drop(columns="_tmp")
 
-    cols = [
+    cols_need = [
         "Jumlah",
         "Rata2_sub_koleksi","Rata2_sub_sdm","Rata2_sub_pelayanan","Rata2_sub_pengelolaan",
         "Rata2_dim_kepatuhan","Rata2_dim_kinerja",
-        "Indeks_Dasar_Agregat_0_100","Indeks_Final_Agregat_0_100"
+        "Indeks_Dasar_Agregat_0_100",
+        "Indeks_Final_Agregat_0_100",
     ]
-    full = full.merge(a[["group_key", label_name, "Jenis"] + cols], on=["group_key", label_name, "Jenis"], how="left")
+    cols_present = [c for c in cols_need if c in a.columns]
 
-    for c in cols:
-        full[c] = pd.to_numeric(full.get(c, 0), errors="coerce").fillna(0.0)
+    full = full.merge(
+        a[["group_key", label_name, "Jenis"] + cols_present],
+        on=["group_key", label_name, "Jenis"],
+        how="left"
+    )
+
+    for c in cols_present:
+        full[c] = pd.to_numeric(full[c], errors="coerce").fillna(0.0)
 
     out = full.groupby(["group_key", label_name], as_index=False).agg(
         n_total=("Jumlah", "sum"),
@@ -717,78 +886,186 @@ def build_agg_wilayah_total_from_jenis(agg_jenis: pd.DataFrame, kew_value: str):
         Indeks_Final_Wilayah_0_100=("Indeks_Final_Agregat_0_100", "mean"),
     )
 
-    for c in ["Rata2_sub_koleksi","Rata2_sub_sdm","Rata2_sub_pelayanan","Rata2_sub_pengelolaan","Rata2_dim_kepatuhan","Rata2_dim_kinerja"]:
-        out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0.0).round(3)
+    # Tempel info Pop/Target/N per jenis + total (tetap ada untuk verif/ekspor, meski dashboard coverage dihapus)
+    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()
 
-    out["Indeks_Dasar_Agregat_0_100"] = pd.to_numeric(out["Indeks_Dasar_Agregat_0_100"], errors="coerce").fillna(0.0).round(2)
-    out["Indeks_Final_Wilayah_0_100"] = pd.to_numeric(out["Indeks_Final_Wilayah_0_100"], errors="coerce").fillna(0.0).round(2)
-    out["n_total"] = pd.to_numeric(out["n_total"], errors="coerce").fillna(0).round(0).astype(int)
+        piv = fw.pivot_table(
+            index=["group_key", label_name],
+            columns="Jenis",
+            values=["pop_total_jenis", "target_total_33_88_jenis", "n_jenis", "gap_target33_88_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")
+
+        for j in ["sekolah", "umum", "khusus"]:
+            for basecol in ["pop_total_jenis", "target_total_33_88_jenis", "n_jenis", "gap_target33_88_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)
+            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)
+
+        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_33_88_all"] = (
+            out.get("target_total_33_88_jenis_sekolah", 0)
+            + out.get("target_total_33_88_jenis_umum", 0)
+            + out.get("target_total_33_88_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_target33_88_all_%"] = np.where(
+            pd.to_numeric(out["target_total_33_88_all"], errors="coerce").fillna(0).values > 0,
+            (pd.to_numeric(out["terkumpul_all"], errors="coerce").fillna(0).values / pd.to_numeric(out["target_total_33_88_all"], errors="coerce").fillna(0).values) * 100.0,
+            0.0
+        )
+        out["coverage_target33_88_all_%"] = pd.to_numeric(out["coverage_target33_88_all_%"], 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"
+    ]:
+        if c in out.columns:
+            out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0.0).round(3)
 
+    for c in ["Indeks_Dasar_Agregat_0_100","Indeks_Final_Wilayah_0_100"]:
+        if c in out.columns:
+            out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0.0).round(2)
+
+    out["n_total"] = pd.to_numeric(out["n_total"], errors="coerce").fillna(0).round(0).astype(int)
     return out
 
+
 # ============================================================
-# 9) SUMMARY (PER JENIS + KESELURUHAN)
+# 9) SUMMARY (PER JENIS) + KESELURUHAN
 # ============================================================
 
 def build_summary_per_jenis(agg_jenis: pd.DataFrame, agg_total: pd.DataFrame):
     jenis_list = ["sekolah", "umum", "khusus"]
-    rows = []
 
-    if agg_jenis is None or agg_jenis.empty:
-        for j in jenis_list:
-            rows.append({
-                "Jenis": j,
-                "Jumlah_Wilayah": 0,
-                "Total_Perpus": 0,
-                "Indeks_Dasar_0_100": 0.0,
-                "Indeks_Final_Disesuaikan_0_100": 0.0,
-                "Penyesuaian_Poin": 0.0
-            })
-    else:
+    def _row_default(jenis):
+        return {
+            "Jenis": jenis,
+            "Jumlah_Wilayah": 0,
+            "Total_Perpus": 0,
+            "Pop_Total_Jenis": 0,
+            "Target33_88_Total_Jenis": 0,
+            "Terkumpul_Jenis": 0,
+            "Coverage_Target33_88_Jenis_%": 0.0,
+            "Indeks_Dasar_0_100": 0.0,
+            "Indeks_Final_Disesuaikan_0_100": 0.0,
+            "Penyesuaian_Poin": 0.0,
+        }
+
+    rows_by_jenis = {j: _row_default(j) for j in jenis_list}
+
+    if agg_jenis is not None and not agg_jenis.empty:
         a = agg_jenis.copy()
         a["Jenis"] = a["Jenis"].astype(str).str.lower().str.strip()
 
-        for j in jenis_list:
-            sub = a[a["Jenis"] == j].copy()
+        for c in ["Jumlah","Indeks_Dasar_Agregat_0_100","Indeks_Final_Agregat_0_100","pop_total_jenis","target_total_33_88_jenis"]:
+            if c in a.columns:
+                a[c] = pd.to_numeric(a[c], errors="coerce").fillna(0)
+
+        for jenis in jenis_list:
+            sub = a[a["Jenis"] == jenis].copy()
+            if sub.empty:
+                continue
+
             jumlah_wilayah = int(sub.shape[0])
-            total_perpus = int(pd.to_numeric(sub["Jumlah"], errors="coerce").fillna(0).sum())
-            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.append({
-                "Jenis": j,
-                "Jumlah_Wilayah": jumlah_wilayah,
-                "Total_Perpus": total_perpus,
-                "Indeks_Dasar_0_100": round(dasar, 2),
-                "Indeks_Final_Disesuaikan_0_100": round(final, 2),
-                "Penyesuaian_Poin": round(final - dasar, 2),
-            })
+            terkumpul = int(pd.to_numeric(sub.get("Jumlah", 0), errors="coerce").fillna(0).sum())
+            pop_total = int(pd.to_numeric(sub.get("pop_total_jenis", 0), errors="coerce").fillna(0).sum())
+            target3388 = int(pd.to_numeric(sub.get("target_total_33_88_jenis", 0), errors="coerce").fillna(0).sum())
 
-    # keseluruhan = avg3 FIX
-    dasar_all = (rows[0]["Indeks_Dasar_0_100"] + rows[1]["Indeks_Dasar_0_100"] + rows[2]["Indeks_Dasar_0_100"]) / 3.0
-    final_all = (rows[0]["Indeks_Final_Disesuaikan_0_100"] + rows[1]["Indeks_Final_Disesuaikan_0_100"] + rows[2]["Indeks_Final_Disesuaikan_0_100"]) / 3.0
+            coverage = (terkumpul / target3388 * 100.0) if target3388 > 0 else 0.0
+            dasar = float(pd.to_numeric(sub.get("Indeks_Dasar_Agregat_0_100", 0), errors="coerce").fillna(0).mean())
+            final = float(pd.to_numeric(sub.get("Indeks_Final_Agregat_0_100", 0), errors="coerce").fillna(0).mean())
 
-    jumlah_wilayah_all = int(agg_total.shape[0]) if (agg_total is not None and not agg_total.empty) else int(max(rows[0]["Jumlah_Wilayah"], rows[1]["Jumlah_Wilayah"], rows[2]["Jumlah_Wilayah"]))
-    total_perpus_all = int(rows[0]["Total_Perpus"] + rows[1]["Total_Perpus"] + rows[2]["Total_Perpus"])
+            rows_by_jenis[jenis] = {
+                "Jenis": jenis,
+                "Jumlah_Wilayah": jumlah_wilayah,
+                "Total_Perpus": terkumpul,
+                "Pop_Total_Jenis": pop_total,
+                "Target33_88_Total_Jenis": target3388,
+                "Terkumpul_Jenis": terkumpul,
+                "Coverage_Target33_88_Jenis_%": float(coverage),
+                "Indeks_Dasar_0_100": float(dasar),
+                "Indeks_Final_Disesuaikan_0_100": float(final),
+                "Penyesuaian_Poin": float(final - dasar),
+            }
+
+    rows = [rows_by_jenis[j] for j in jenis_list]
+
+    dasar_all = (rows_by_jenis["sekolah"]["Indeks_Dasar_0_100"]
+                 + rows_by_jenis["umum"]["Indeks_Dasar_0_100"]
+                 + rows_by_jenis["khusus"]["Indeks_Dasar_0_100"]) / 3.0
+
+    final_all = (rows_by_jenis["sekolah"]["Indeks_Final_Disesuaikan_0_100"]
+                 + rows_by_jenis["umum"]["Indeks_Final_Disesuaikan_0_100"]
+                 + rows_by_jenis["khusus"]["Indeks_Final_Disesuaikan_0_100"]) / 3.0
+
+    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"]["Target33_88_Total_Jenis"]
+                     + rows_by_jenis["umum"]["Target33_88_Total_Jenis"]
+                     + rows_by_jenis["khusus"]["Target33_88_Total_Jenis"])
+
+    terkumpul_all = int(rows_by_jenis["sekolah"]["Terkumpul_Jenis"]
+                        + rows_by_jenis["umum"]["Terkumpul_Jenis"]
+                        + rows_by_jenis["khusus"]["Terkumpul_Jenis"])
+
+    coverage_all = (terkumpul_all / target_all * 100.0) if target_all > 0 else 0.0
+
+    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"])
+    )
 
     rows.append({
         "Jenis": "keseluruhan",
         "Jumlah_Wilayah": jumlah_wilayah_all,
-        "Total_Perpus": total_perpus_all,
-        "Indeks_Dasar_0_100": round(dasar_all, 2),
-        "Indeks_Final_Disesuaikan_0_100": round(final_all, 2),
-        "Penyesuaian_Poin": round(final_all - dasar_all, 2),
+        "Total_Perpus": terkumpul_all,
+        "Pop_Total_Jenis": pop_all,
+        "Target33_88_Total_Jenis": target_all,
+        "Terkumpul_Jenis": terkumpul_all,
+        "Coverage_Target33_88_Jenis_%": float(coverage_all),
+        "Indeks_Dasar_0_100": float(dasar_all),
+        "Indeks_Final_Disesuaikan_0_100": float(final_all),
+        "Penyesuaian_Poin": float(final_all - dasar_all),
     })
 
     out = pd.DataFrame(rows)
-    out["Jumlah_Wilayah"] = pd.to_numeric(out["Jumlah_Wilayah"], errors="coerce").fillna(0).astype(int)
-    out["Total_Perpus"] = pd.to_numeric(out["Total_Perpus"], errors="coerce").fillna(0).astype(int)
-    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)
+
+    for c in ["Jumlah_Wilayah","Total_Perpus","Pop_Total_Jenis","Target33_88_Total_Jenis","Terkumpul_Jenis"]:
+        if c in out.columns:
+            out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0).round(0).astype(int)
+
+    for c in ["Coverage_Target33_88_Jenis_%","Indeks_Dasar_0_100","Indeks_Final_Disesuaikan_0_100","Penyesuaian_Poin"]:
+        if c in out.columns:
+            out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0.0).round(2)
 
     return out
 
+
 # ============================================================
-# 10) DETAIL ENTITAS (Final menempel dari wilayah)
+# 10) DETAIL ENTITAS: Final menempel dari agg_total (wilayah)
 # ============================================================
 
 def attach_final_to_detail(df_filtered: pd.DataFrame, agg_total: pd.DataFrame, meta: dict, kew_value: str):
@@ -798,7 +1075,12 @@ def attach_final_to_detail(df_filtered: pd.DataFrame, agg_total: pd.DataFrame, m
     kew_norm = str(kew_value or "").upper()
     df = df_filtered.copy()
 
-    key_col = "prov_key" if "PROV" in kew_norm else "kab_key"
+    if "PROV" in kew_norm:
+        key_col = "prov_key"
+        label_cols = ("PROV_DISP", "KAB_DISP")
+    else:
+        key_col = "kab_key"
+        label_cols = ("PROV_DISP", "KAB_DISP")
 
     if agg_total is None or agg_total.empty:
         df["Indeks_Final_0_100"] = df["Indeks_Dasar_0_100"]
@@ -808,31 +1090,77 @@ def attach_final_to_detail(df_filtered: pd.DataFrame, agg_total: pd.DataFrame, m
         df["Indeks_Final_0_100"] = df["Indeks_Final_Wilayah_0_100"].fillna(df["Indeks_Dasar_0_100"])
         df = df.drop(columns=[c for c in ["group_key","Indeks_Final_Wilayah_0_100"] if c in df.columns])
 
+    base_cols = [label_cols[0], label_cols[1], "KEW_NORM", "_dataset"]
     if meta.get("nama_col") and meta["nama_col"] in df.columns:
         df["nm_perpustakaan"] = df[meta["nama_col"]].astype(str)
-    else:
-        df["nm_perpustakaan"] = ""
+        base_cols.insert(2, "nm_perpustakaan")
 
-    out = df[[
-        "PROV_DISP","KAB_DISP","KEW_NORM","_dataset","nm_perpustakaan",
+    keep = base_cols + [
         "sub_koleksi","sub_sdm","sub_pelayanan","sub_pengelolaan",
         "dim_kepatuhan","dim_kinerja",
-        "Indeks_Dasar_0_100","Indeks_Final_0_100"
-    ]].copy()
+        "Indeks_Dasar_0_100",
+        "Indeks_Final_0_100",
+    ]
+    keep = [c for c in keep if c in df.columns]
+
+    out = df[keep].copy()
+    out = out.rename(columns={label_cols[0]:"Provinsi", label_cols[1]:"Kab/Kota", "_dataset":"Jenis"})
 
-    out = out.rename(columns={"PROV_DISP":"Provinsi","KAB_DISP":"Kab/Kota","_dataset":"Jenis"})
     for c in ["sub_koleksi","sub_sdm","sub_pelayanan","sub_pengelolaan","dim_kepatuhan","dim_kinerja"]:
-        out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0.0).round(3)
+        if c in out.columns:
+            out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0.0).round(3)
     for c in ["Indeks_Dasar_0_100","Indeks_Final_0_100"]:
-        out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0.0).round(2)
+        if c in out.columns:
+            out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0.0).round(2)
+
+    return out
+
+
+# ============================================================
+# 11) VERIFIKASI PER JENIS (TARGET 33.88%)
+# ============================================================
+
+def build_verif_jenis(faktor_wilayah_jenis: pd.DataFrame, kew_value: str):
+    if faktor_wilayah_jenis is None or faktor_wilayah_jenis.empty:
+        return pd.DataFrame()
+
+    kew_norm = str(kew_value or "").upper()
+    label_col = "Provinsi" if "PROV" in kew_norm else "Kab/Kota"
+
+    out = faktor_wilayah_jenis.copy()
+    keep = [c for c in [
+        label_col, "Jenis",
+        "pop_total_jenis", "target_total_33_88_jenis", "n_jenis",
+        "coverage_jenis_%", "faktor_penyesuaian_jenis", "gap_target33_88_jenis"
+    ] if c in out.columns]
+
+    out = out[keep].copy()
+
+    for c in ["pop_total_jenis", "target_total_33_88_jenis", "n_jenis", "gap_target33_88_jenis"]:
+        if c in out.columns:
+            out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0).round(0).astype(int)
+
+    if "coverage_jenis_%" in out.columns:
+        out["coverage_jenis_%"] = pd.to_numeric(out["coverage_jenis_%"], errors="coerce").fillna(0.0).round(2)
+
+    if "faktor_penyesuaian_jenis" in out.columns:
+        out["faktor_penyesuaian_jenis"] = pd.to_numeric(out["faktor_penyesuaian_jenis"], errors="coerce").fillna(1.0).round(3)
 
     return out
 
+
 # ============================================================
-# 11) BELL CURVE (ENTITAS) + HOVER NAMA
+# 12) BELL CURVE — Indeks Dasar per Entitas (per Jenis) + Hover Nama Perpus
 # ============================================================
 
-def make_bell_curve_entitas(df: pd.DataFrame, title: str):
+def _make_bell_curve_entitas(
+    dfp: pd.DataFrame,
+    title: str,
+    xcol: str = "Indeks_Dasar_0_100",
+    label_col: str = "nm_perpustakaan",
+    hover_cols: list | None = None,
+    min_points: int = 2
+):
     fig = go.Figure()
     fig.update_layout(
         title=title,
@@ -840,58 +1168,67 @@ def make_bell_curve_entitas(df: pd.DataFrame, title: str):
         yaxis_title="Kepadatan",
         hovermode="closest",
         margin=dict(l=40, r=20, t=60, b=40),
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="left", x=0),
     )
 
-    if df is None or df.empty or "Indeks_Dasar_0_100" not in df.columns:
-        fig.add_annotation(text="Tidak ada data.", x=0.5, y=0.5, xref="paper", yref="paper", showarrow=False)
+    if dfp is None or dfp.empty or xcol not in dfp.columns:
+        fig.add_annotation(text="Tidak ada data untuk ditampilkan.", x=0.5, y=0.5, xref="paper", yref="paper", showarrow=False)
         fig.update_xaxes(range=[0, 100])
         fig.update_yaxes(rangemode="tozero")
         return fig
 
-    d = df.dropna(subset=["Indeks_Dasar_0_100"]).copy()
+    d = dfp.dropna(subset=[xcol]).copy()
     if d.empty:
-        fig.add_annotation(text="Tidak ada data.", x=0.5, y=0.5, xref="paper", yref="paper", showarrow=False)
+        fig.add_annotation(text="Tidak ada data untuk ditampilkan.", x=0.5, y=0.5, xref="paper", yref="paper", showarrow=False)
         fig.update_xaxes(range=[0, 100])
         fig.update_yaxes(rangemode="tozero")
         return fig
 
-    x = pd.to_numeric(d["Indeks_Dasar_0_100"], errors="coerce").astype(float)
+    x = pd.to_numeric(d[xcol], errors="coerce").astype(float)
     d = d.loc[x.notna()].copy()
     x = x.loc[x.notna()].values
     if len(x) < 1:
-        fig.add_annotation(text="Tidak ada data.", x=0.5, y=0.5, xref="paper", yref="paper", showarrow=False)
+        fig.add_annotation(text="Tidak ada data untuk ditampilkan.", x=0.5, y=0.5, xref="paper", yref="paper", showarrow=False)
         fig.update_xaxes(range=[0, 100])
         fig.update_yaxes(rangemode="tozero")
         return fig
 
+    hover_cols = hover_cols or []
+    def _val(row, col):
+        if col not in row.index:
+            return ""
+        v = row[col]
+        return "" if pd.isna(v) else str(v)
+
     hover_text = []
-    for _, r in d.iterrows():
-        nm = str(r.get("nm_perpustakaan", "") or "")
-        prov = str(r.get("Provinsi", "") or "")
-        kab = str(r.get("Kab/Kota", "") or "")
-        jenis = str(r.get("Jenis", "") or "")
-        val = float(pd.to_numeric(r.get("Indeks_Dasar_0_100", 0), errors="coerce") or 0.0)
+    for _, row in d.iterrows():
         lines = []
-        if nm.strip():
+        nm = _val(row, label_col) if (label_col and label_col in d.columns) else ""
+        if nm:
             lines.append(f"<b>{nm}</b>")
-        if prov.strip():
-            lines.append(f"Provinsi: {prov}")
-        if kab.strip():
-            lines.append(f"Kab/Kota: {kab}")
-        if jenis.strip():
-            lines.append(f"Jenis: {jenis}")
-        lines.append(f"Indeks_Dasar_0_100: {val:.2f}")
+        lines.append(f"{xcol}: {float(pd.to_numeric(row[xcol], errors='coerce')):.2f}")
+        for hc in hover_cols:
+            vv = _val(row, hc)
+            if vv:
+                lines.append(f"{hc}: {vv}")
         hover_text.append("<br>".join(lines))
 
-    if len(x) < 2:
-        xs = [float(x[0])]
-        fig.add_trace(go.Scatter(x=xs, y=[0], mode="markers", hovertext=hover_text, hoverinfo="text", showlegend=False))
+    if len(x) < min_points:
+        x_single = float(x[0])
+        fig.add_trace(go.Scatter(
+            x=[x_single], y=[0],
+            mode="markers", showlegend=False,
+            hovertext=[hover_text[0]] if hover_text else None,
+            hoverinfo="text"
+        ))
+        fig.add_vline(x=x_single, line_width=1, line_dash="dash", annotation_text=f"Nilai: {x_single:.1f}", annotation_position="top")
         fig.update_xaxes(range=[0, 100])
         fig.update_yaxes(rangemode="tozero")
         return fig
 
+    # fit normal curve (untuk visual)
     mu = float(np.mean(x))
-    sigma = float(np.std(x, ddof=1))
+    sigma = float(np.std(x, ddof=1)) if len(x) > 1 else 1.0
     sigma = max(sigma, 1e-3)
 
     xmin = max(0.0, float(np.min(x)) - 5.0)
@@ -900,51 +1237,69 @@ def make_bell_curve_entitas(df: pd.DataFrame, title: str):
     pdf = (1.0 / (sigma * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((xs - mu) / sigma) ** 2)
 
     fig.add_trace(go.Scatter(x=xs, y=pdf, mode="lines", name="Kurva Normal (fit)"))
-    fig.add_trace(go.Scatter(x=x, y=np.zeros_like(x), mode="markers", hovertext=hover_text, hoverinfo="text", showlegend=False))
+    fig.add_trace(go.Scatter(
+        x=x, y=np.zeros_like(x),
+        mode="markers", showlegend=False,
+        hovertext=hover_text if hover_text else None,
+        hoverinfo="text"
+    ))
 
     q1, q2, q3 = np.percentile(x, [25, 50, 75])
-    for xv, lab in [(q1, "Q1"), (q2, "Q2"), (q3, "Q3"), (mu, "Mean")]:
+    for xv, lab in [(q1, "Q1"), (q2, "Q2 (Median)"), (q3, "Q3"), (mu, "Mean")]:
         fig.add_vline(x=float(xv), line_width=1, line_dash="dash", annotation_text=f"{lab}: {xv:.1f}", annotation_position="top")
 
     fig.update_xaxes(range=[0, 100])
     fig.update_yaxes(rangemode="tozero")
     return fig
 
+
 # ============================================================
-# 12) KPI DASHBOARD (2 kartu saja)
+# 13) KPI DASHBOARD (HANYA 2 KARTU: FINAL + DASAR)
 # ============================================================
 
+def _safe_first(df, col, default=0.0, where=None):
+    if df is None or df.empty or col not in df.columns:
+        return default
+    sub = df
+    if where is not None:
+        sub = df.loc[where]
+    if sub is None or sub.empty:
+        return default
+    return float(pd.to_numeric(sub[col], errors="coerce").fillna(default).iloc[0])
+
+def compute_dashboard_kpis(summary_jenis: pd.DataFrame):
+    final_all = _safe_first(summary_jenis, "Indeks_Final_Disesuaikan_0_100", 0.0, where=summary_jenis["Jenis"].astype(str).str.lower().eq("keseluruhan"))
+    dasar_all = _safe_first(summary_jenis, "Indeks_Dasar_0_100", 0.0, where=summary_jenis["Jenis"].astype(str).str.lower().eq("keseluruhan"))
+    return {"final_all": final_all, "dasar_all": dasar_all}
+
 def build_kpi_markdown(summary_jenis: pd.DataFrame) -> str:
     if summary_jenis is None or summary_jenis.empty:
         return ""
 
-    m = summary_jenis["Jenis"].astype(str).str.lower().eq("keseluruhan")
-    if not m.any():
-        final_all = 0.0
-        dasar_all = 0.0
-    else:
-        final_all = float(pd.to_numeric(summary_jenis.loc[m, "Indeks_Final_Disesuaikan_0_100"], errors="coerce").fillna(0).iloc[0])
-        dasar_all = float(pd.to_numeric(summary_jenis.loc[m, "Indeks_Dasar_0_100"], errors="coerce").fillna(0).iloc[0])
+    k = compute_dashboard_kpis(summary_jenis)
 
-    def fmt(x): return f"{x:.2f}"
+    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:280px;">
+  <div style="border:1px solid #333; border-radius:10px; padding:10px 12px; min-width:260px;">
     <div style="opacity:0.8;">Indeks IPLM FINAL (Disesuaikan 33.88%)</div>
-    <div style="font-size:26px; font-weight:700;">{fmt(final_all)}</div>
+    <div style="font-size:26px; font-weight:700;">{fmt(k["final_all"],2)}</div>
     <div style="opacity:0.7;">Skor absolut (untuk akuntabilitas)</div>
   </div>
-  <div style="border:1px solid #333; border-radius:10px; padding:10px 12px; min-width:280px;">
+
+  <div style="border:1px solid #333; border-radius:10px; padding:10px 12px; min-width:260px;">
     <div style="opacity:0.8;">Indeks Dasar (Tanpa Penyesuaian)</div>
-    <div style="font-size:26px; font-weight:700;">{fmt(dasar_all)}</div>
+    <div style="font-size:26px; font-weight:700;">{fmt(k["dasar_all"],2)}</div>
     <div style="opacity:0.7;">Sebelum faktor kecukupan sampel</div>
   </div>
 </div>
 """.strip()
 
+
 # ============================================================
-# 13) LLM OUTPUT: FORMAT DATA PENDUKUNG (tabel seperti gambar)
+# 14) LLM + WORD (OPSIONAL)
 # ============================================================
 
 _HF_CLIENT = None
@@ -963,199 +1318,83 @@ def get_llm_client():
         _HF_CLIENT = None
         return None
 
-def _safe_float(x, default=0.0):
-    try:
-        if x is None or pd.isna(x):
-            return float(default)
-        return float(x)
-    except Exception:
-        return float(default)
-
-def _pick_wilayah_row(agg_total: pd.DataFrame, prov_value: str, kab_value: str):
-    """
-    Ambil 1 baris agg_total sesuai dropdown.
-    Kalau tidak ketemu -> buat pseudo-row dari mean numeric.
-    """
-    if agg_total is None or agg_total.empty:
-        return None
-
-    cols = agg_total.columns.tolist()
-    has_kab = "Kab/Kota" in cols
-    has_prov = "Provinsi" in cols
-
-    if kab_value and kab_value != "(Semua)" and has_kab:
-        sub = agg_total[agg_total["Kab/Kota"].astype(str) == str(kab_value)]
-        if not sub.empty:
-            return sub.iloc[0]
-
-    if prov_value and prov_value != "(Semua)" and has_prov:
-        sub = agg_total[agg_total["Provinsi"].astype(str) == str(prov_value)]
-        if not sub.empty:
-            return sub.iloc[0]
-
-    # fallback mean row
-    num = agg_total.select_dtypes(include=[np.number]).mean(numeric_only=True)
-    row = pd.Series({**{c: None for c in agg_total.columns}, **num.to_dict()})
-    return row
-
-def build_table_rows_ipml(summary_jenis: pd.DataFrame, agg_total: pd.DataFrame, prov_value: str, kab_value: str):
-    """
-    NILAI diambil dari hasil hitung (bukan LLM):
-    - Kepatuhan/Kinerja dari agg_total (Rata2_dim_*)
-    - Variabel dari agg_total (Rata2_sub_*)
-    - Nilai IPLM dari summary_jenis (keseluruhan) (final)
-    sub/dim (0-1) dikonversi ke 0-100 supaya konsisten.
-    """
-    row = _pick_wilayah_row(agg_total, prov_value, kab_value)
-    if row is None:
-        kep = kin = sub_kol = sub_sdm = sub_pel = sub_png = 0.0
-    else:
-        kep = 100.0 * _safe_float(row.get("Rata2_dim_kepatuhan", 0))
-        kin = 100.0 * _safe_float(row.get("Rata2_dim_kinerja", 0))
-        sub_kol = 100.0 * _safe_float(row.get("Rata2_sub_koleksi", 0))
-        sub_sdm = 100.0 * _safe_float(row.get("Rata2_sub_sdm", 0))
-        sub_pel = 100.0 * _safe_float(row.get("Rata2_sub_pelayanan", 0))
-        sub_png = 100.0 * _safe_float(row.get("Rata2_sub_pengelolaan", 0))
-
-    nilai_iplm = 0.0
-    if summary_jenis is not None and not summary_jenis.empty:
-        m = summary_jenis["Jenis"].astype(str).str.lower().eq("keseluruhan")
-        if m.any():
-            nilai_iplm = _safe_float(summary_jenis.loc[m, "Indeks_Final_Disesuaikan_0_100"].iloc[0], 0.0)
-
-    rows = [
-        {"no": "1",   "dimensi": "Kepatuhan",                          "nilai": f"{kep:.2f}",      "interpretasi": "", "rekomendasi": ""},
-        {"no": "1.1", "dimensi": "Variabel Koleksi",                   "nilai": f"{sub_kol:.2f}",  "interpretasi": "", "rekomendasi": ""},
-        {"no": "1.2", "dimensi": "Variabel Tenaga Perpustakaan",       "nilai": f"{sub_sdm:.2f}",  "interpretasi": "", "rekomendasi": ""},
-        {"no": "2",   "dimensi": "Kinerja",                            "nilai": f"{kin:.2f}",      "interpretasi": "", "rekomendasi": ""},
-        {"no": "2.1", "dimensi": "Variabel Pelayanan",                 "nilai": f"{sub_pel:.2f}",  "interpretasi": "", "rekomendasi": ""},
-        {"no": "2.2", "dimensi": "Variabel Penyelenggaraan/Pengelolaan","nilai": f"{sub_png:.2f}",  "interpretasi": "", "rekomendasi": ""},
-        {"no": "4",   "dimensi": "Nilai IPLM",                         "nilai": f"{nilai_iplm:.2f}","interpretasi": "", "rekomendasi": ""},
-    ]
-    return rows
-
-def llm_fill_interpretasi_rekomendasi(rows: list[dict], wilayah_txt: str, kew: str):
-    """
-    LLM hanya mengisi interpretasi + rekomendasi.
-    Output wajib JSON agar gampang diparsing.
-    """
+def generate_llm_analysis(summary_jenis, agg_total, verif_total, wilayah, kew):
     client = get_llm_client()
     if client is None or (not USE_LLM):
-        for r in rows:
-            r["interpretasi"] = "—"
-            r["rekomendasi"] = "—"
-        return rows
-
-    payload = {"wilayah": wilayah_txt, "kewenangan": kew, "rows_input": [{"no": r["no"], "dimensi": r["dimensi"], "nilai": r["nilai"]} for r in rows]}
-    system = (
-        "Anda adalah analis kebijakan perpustakaan di Indonesia.\n"
-        "Isi kolom 'interpretasi' dan 'rekomendasi' secara NETRAL dan DESKRIPTIF.\n"
-        "DILARANG memakai label normatif: baik/buruk, tinggi/sedang/rendah, maju/tertinggal.\n"
-        "Interpretasi: 1–2 kalimat menjelaskan apa yang tercermin dari nilai.\n"
-        "Rekomendasi: 1–2 kalimat tindakan operasional.\n"
-        "Keluaran: JSON valid saja dengan format:\n"
-        "{\"rows\":[{\"no\":\"1\",\"interpretasi\":\"...\",\"rekomendasi\":\"...\"}, ...]}\n"
-    )
+        return "Analisis otomatis (LLM) tidak digunakan / tidak tersedia."
+    ctx = f"Wilayah={wilayah} | Kewenangan={kew} | Target={TARGET_RATIO*100:.2f}%"
     try:
         resp = client.chat_completion(
             model=LLM_MODEL_NAME,
             messages=[
-                {"role": "system", "content": system},
-                {"role": "user", "content": json.dumps(payload, ensure_ascii=False)}
+                {"role":"system","content":"Anda adalah analis kebijakan perpustakaan di Indonesia. Tulis analisis ringkas berbasis data tanpa menyebut angka hanya deskripsi saja namun tanpa memberikan penilaian tinggi ."},
+                {"role":"user","content":f"{ctx}\nBuat analisis 3 paragraf: (1) indeks dasar, (2) penyesuaian 33.88% dan implikasinya, (3) rekomendasi singkat."}
             ],
-            max_tokens=750,
+            max_tokens=500,
             temperature=0.25,
             top_p=0.9,
         )
-        text = (resp.choices[0].message.content or "").strip()
-        text = text.replace("```json", "").replace("```", "").strip()
-        obj = json.loads(text)
-
-        mp = {str(x.get("no","")).strip(): x for x in obj.get("rows", [])}
-        for r in rows:
-            k = str(r["no"]).strip()
-            rr = mp.get(k, {})
-            r["interpretasi"] = str(rr.get("interpretasi", "—") or "—").strip()
-            r["rekomendasi"] = str(rr.get("rekomendasi", "—") or "—").strip()
-        return rows
-    except Exception:
-        for r in rows:
-            r["interpretasi"] = "—"
-            r["rekomendasi"] = "—"
-        return rows
-
-def render_format_data_pendukung_markdown(rows: list[dict], wilayah_txt: str, tahun_txt: str = "2025"):
-    md = []
-    md.append("**KOP SURAT**  ")
-    md.append(f"**DINAS PERPUSTAKAAN DAN ARSIP {wilayah_txt}**  ")
-    md.append("**INDEKS PEMBANGUNAN LITERASI MASYARAKAT**  ")
-    md.append(f"**TAHUN {tahun_txt}**")
-    md.append("")
-    md.append("| No | Dimensi | Nilai | Interpretasi | Rekomendasi |")
-    md.append("|---:|---|---:|---|---|")
-    for r in rows:
-        md.append(f"| {r['no']} | {r['dimensi']} | {r['nilai']} | {r['interpretasi']} | {r['rekomendasi']} |")
-    return "\n".join(md)
-
-# ============================================================
-# 14) WORD REPORT (opsional)
-# ============================================================
+        text = resp.choices[0].message.content.strip()
+        return text if text else "LLM mengembalikan respon kosong."
+    except Exception as e:
+        return f"⚠️ Error LLM: {repr(e)}"
 
-def generate_word_report(wilayah_txt: str, kpi_md: str, summary_jenis: pd.DataFrame, format_table_md: str):
+def generate_word_report(wilayah, summary_jenis, analysis_text):
     if (not DOCX_AVAILABLE) or (Document is None):
         return None
-
     doc = Document()
-    doc.add_heading(f"Laporan IPLM — {wilayah_txt}", level=1)
+    doc.add_heading(f"Laporan IPLM — {wilayah}", level=1)
     doc.add_paragraph(f"Target sampel per jenis: {TARGET_RATIO*100:.2f}%")
-
-    doc.add_heading("KPI", level=2)
-    doc.add_paragraph("Indeks Final (Disesuaikan 33.88%) dan Indeks Dasar (tanpa penyesuaian) ditampilkan pada dashboard.")
-
     doc.add_heading("Ringkasan (Jenis + Keseluruhan)", level=2)
     if summary_jenis is not None and not summary_jenis.empty:
-        tbl = doc.add_table(rows=1, cols=len(summary_jenis.columns))
-        for i, c in enumerate(summary_jenis.columns):
-            tbl.rows[0].cells[i].text = str(c)
-        for _, rr in summary_jenis.iterrows():
-            cells = tbl.add_row().cells
-            for i, c in enumerate(summary_jenis.columns):
-                v = rr[c]
+        show = summary_jenis.copy()
+        table = doc.add_table(rows=1, cols=len(show.columns))
+        for i, c in enumerate(show.columns):
+            table.rows[0].cells[i].text = str(c)
+        for _, row in show.iterrows():
+            cells = table.add_row().cells
+            for i, c in enumerate(show.columns):
+                v = row[c]
                 if pd.isna(v):
                     cells[i].text = ""
                 elif isinstance(v, (float, np.floating)):
                     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("Format Data Pendukung (LLM)", level=2)
-    # simpan markdown sebagai teks (sederhana)
-    doc.add_paragraph(format_table_md)
-
+    doc.add_heading("Analisis (opsional)", level=2)
+    for p in (analysis_text or "").split("\n"):
+        if p.strip():
+            doc.add_paragraph(p.strip())
     outpath = tempfile.mktemp(suffix=".docx")
     doc.save(outpath)
     return outpath
 
+
 # ============================================================
 # 15) CORE RUN
 # ============================================================
 
-def empty_outputs(msg="Data belum siap."):
+def _empty_outputs(msg="⚠️ Data belum siap."):
     empty = pd.DataFrame()
     empty_fig = go.Figure()
     return (
-        "",                 # kpi_md
-        empty, empty, empty, empty,
+        "",  # kpi_md
+        empty, empty, empty, empty, empty,
+        None, None, None, None, None,
         empty_fig, empty_fig, empty_fig,
-        msg,
-        ""                  # format_data_pendukung_md
+        msg, "Analisis belum tersedia."
     )
 
 def run_calc(prov_value, kab_value, kew_value, df_all, df_raw, pop_kab, pop_prov, pop_khusus, meta):
     try:
-        if df_all is None or df_all.empty:
-            return empty_outputs("Data belum ter-load. Pastikan file tersedia di server/repo.")
+        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.")
 
+        # =========================================================
+        # 1) FILTER df_all (entitas) sesuai dropdown
+        # =========================================================
         df = df_all.copy()
         if prov_value and prov_value != "(Semua)":
             df = df[df["PROV_DISP"] == prov_value]
@@ -1165,52 +1404,137 @@ def run_calc(prov_value, kab_value, kew_value, df_all, df_raw, pop_kab, pop_prov
             df = df[df["KEW_NORM"] == kew_value]
 
         if df.empty:
-            return empty_outputs("Tidak ada data untuk filter ini.")
+            return _empty_outputs("Tidak ada data untuk filter ini.")
 
+        # =========================================================
+        # 2) PIPELINE FILTER → faktor → agg_jenis → agg_total
+        # =========================================================
         kew_norm = kew_value if (kew_value and kew_value != "(Semua)") else "(Semua)"
-
-        # faktor -> agg jenis -> agg total -> summary -> detail
-        faktor_wj = build_faktor_wilayah_jenis(df, pop_kab, pop_prov, pop_khusus, kew_norm)
-        agg_jenis = build_agg_wilayah_jenis(df, faktor_wj, kew_norm)
-        agg_total = build_agg_wilayah_total_from_jenis(agg_jenis, kew_norm)
-        summary_jenis = build_summary_per_jenis(agg_jenis, agg_total)
-        detail = attach_final_to_detail(df, agg_total, meta, kew_norm)
-
-        # KPI md
+        faktor_wilayah_jenis = build_faktor_wilayah_jenis(df, pop_kab, pop_prov, pop_khusus, kew_norm)
+        agg_jenis_full = build_agg_wilayah_jenis(df, faktor_wilayah_jenis, kew_norm)
+        agg_total = build_agg_wilayah_total_from_jenis(agg_jenis_full, faktor_wilayah_jenis, kew_norm)
+
+        # =========================================================
+        # 3) OUTPUT TABLES
+        # =========================================================
+        summary_jenis = build_summary_per_jenis(agg_jenis_full, agg_total)
+        verif_total = build_verif_jenis(faktor_wilayah_jenis, kew_norm)
+        detail_view = attach_final_to_detail(df, agg_total, meta, kew_norm)
+
+        # =========================================================
+        # 4) agg_jenis view (UI hanya sampai indeks dasar)
+        # =========================================================
+        if agg_jenis_full is None or agg_jenis_full.empty:
+            agg_jenis_view = agg_jenis_full
+        else:
+            kew_norm2 = str(kew_norm).upper()
+            label_name = "Kab/Kota" if ("KAB" in kew_norm2 or "KOTA" in kew_norm2) else ("Provinsi" if "PROV" in kew_norm2 else "Kab/Kota")
+            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",
+                "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()
+
+        # =========================================================
+        # 5) FILTER RAW DOWNLOAD (harus raw hasil filter)
+        # =========================================================
+        raw = df_raw.copy()
+        if prov_value and prov_value != "(Semua)":
+            raw = raw[raw["PROV_DISP"] == prov_value]
+        if kab_value and kab_value != "(Semua)":
+            raw = raw[raw["KAB_DISP"] == kab_value]
+        if kew_value and kew_value != "(Semua)":
+            raw = raw[raw["KEW_NORM"] == kew_value]
+
+        # =========================================================
+        # 6) Bell curve — kembali ke Indeks_Dasar_0_100 per entitas per jenis
+        #     + hover nama perpustakaan
+        # =========================================================
+        if detail_view is None or detail_view.empty:
+            fig_umum = _make_bell_curve_entitas(pd.DataFrame(), "Bell Curve — Jenis: Umum")
+            fig_sekolah = _make_bell_curve_entitas(pd.DataFrame(), "Bell Curve — Jenis: Sekolah")
+            fig_khusus = _make_bell_curve_entitas(pd.DataFrame(), "Bell Curve — Jenis: Khusus")
+        else:
+            hover_cols = []
+            for hc in ["Provinsi", "Kab/Kota", "Jenis"]:
+                if hc in detail_view.columns:
+                    hover_cols.append(hc)
+
+            def _fig(j):
+                d = detail_view[detail_view["Jenis"].astype(str).str.lower() == j].copy()
+                return _make_bell_curve_entitas(
+                    d,
+                    title=f"Bell Curve — Jenis: {j.title()} (Skor: Indeks_Dasar_0_100)",
+                    xcol="Indeks_Dasar_0_100",
+                    label_col=("nm_perpustakaan" if "nm_perpustakaan" in d.columns else "nm_perpustakaan"),
+                    hover_cols=hover_cols,
+                    min_points=2
+                )
+
+            fig_sekolah = _fig("sekolah")
+            fig_umum = _fig("umum")
+            fig_khusus = _fig("khusus")
+
+        # =========================================================
+        # 7) KPI (HANYA FINAL + DASAR)
+        # =========================================================
         kpi_md = build_kpi_markdown(summary_jenis)
 
-        # bell curves per jenis
-        d = detail.copy() if (detail is not None and not detail.empty) else pd.DataFrame()
-        fig_umum = make_bell_curve_entitas(d[d["Jenis"].astype(str).str.lower()=="umum"], "Bell Curve — Perpustakaan Umum (Indeks_Dasar_0_100)")
-        fig_sek  = make_bell_curve_entitas(d[d["Jenis"].astype(str).str.lower()=="sekolah"], "Bell Curve — Perpustakaan Sekolah (Indeks_Dasar_0_100)")
-        fig_khu  = make_bell_curve_entitas(d[d["Jenis"].astype(str).str.lower()=="khusus"], "Bell Curve — Perpustakaan Khusus (Indeks_Dasar_0_100)")
+        # =========================================================
+        # 8) Export (xlsx + opsional docx)
+        # =========================================================
+        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")
+
+        p_summary = str(Path(tmpdir) / f"IPLM_RingkasanJenisKeseluruhan_33_88_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
+        p_total   = str(Path(tmpdir) / f"IPLM_AgregatWilayah_Keseluruhan_33_88_{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_KecukupanSampel_33_88_{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_raw, index=False)
+        detail_view.to_excel(p_detail, index=False)
+        verif_total.to_excel(p_verif, index=False)
 
-        # Format Data Pendukung (LLM)
         wilayah_txt = kab_value if (kab_value and kab_value != "(Semua)") else (prov_value if (prov_value and prov_value != "(Semua)") else "Nasional/All")
-        rows = build_table_rows_ipml(summary_jenis, agg_total, prov_value, kab_value)
-        rows = llm_fill_interpretasi_rekomendasi(rows, wilayah_txt, kew_norm)
-        format_md = render_format_data_pendukung_markdown(rows, wilayah_txt, tahun_txt="2025")
+        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, analysis_text)
 
-        msg = f"Selesai. Entitas={len(detail)} | Wilayah(keseluruhan)={len(agg_total)} | Wilayah×Jenis={len(agg_jenis)}"
+        msg = (
+            f"✅ Selesai (TARGET {TARGET_RATIO*100:.2f}%): raw={len(raw)} | entitas={len(detail_view)} | "
+            f"wilayah(keseluruhan)={len(agg_total)} | jenis(agregat)={len(agg_jenis_full)}"
+            + ("" if DOCX_AVAILABLE else "<br>⚠️ python-docx tidak tersedia → laporan Word dimatikan.")
+        )
 
         return (
             kpi_md,
-            summary_jenis, agg_total, agg_jenis, detail,
-            fig_umum, fig_sek, fig_khu,
-            msg,
-            format_md
+            summary_jenis, agg_total, agg_jenis_view, detail_view, verif_total,
+            p_summary, p_total, p_raw, p_detail, (word_path if word_path else None),
+            fig_umum, fig_sekolah, fig_khusus,
+            msg, analysis_text
         )
 
     except Exception as e:
-        return empty_outputs(f"Runtime error: {repr(e)}")
+        return _empty_outputs(f"⚠️ Runtime error: {repr(e)}")
+
 
 # ============================================================
-# 16) UI
+# 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 df_all.empty:
+    if df_all is None or (isinstance(df_all, pd.DataFrame) and df_all.empty):
         return (
             None, None, None, None, None, {}, info,
             gr.update(choices=["(Semua)"], value="(Semua)"),
@@ -1218,11 +1542,12 @@ def ui_load(force=False):
             gr.update(choices=["(Semua)"], value="(Semua)"),
         )
 
-    prov_vals = [v for v in df_all["PROV_DISP"].dropna().astype(str).tolist() if v and v.strip()]
+    prov_vals = df_all["PROV_DISP"].dropna().astype(str).tolist()
+    prov_vals = [v for v in prov_vals if v and v.strip()]
     prov_choices = ["(Semua)"] + sorted(set(prov_vals))
+
     kab_choices = ["(Semua)"] + sorted([x for x in df_all["KAB_DISP"].dropna().unique().tolist() if x])
     kew_choices = ["(Semua)"] + sorted([x for x in df_all["KEW_NORM"].dropna().unique().tolist() if x])
-
     default_kew = "KAB/KOTA" if "KAB/KOTA" in kew_choices else ("PROVINSI" if "PROVINSI" in kew_choices else "(Semua)")
 
     return (
@@ -1233,7 +1558,7 @@ def ui_load(force=False):
     )
 
 def on_prov_change(prov_value):
-    df_all, *_ = load_default_files(force=False)
+    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)":
@@ -1243,18 +1568,24 @@ def on_prov_change(prov_value):
     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 (Target Sampel {TARGET_RATIO*100:.2f}% per Jenis) — TANPA Kinerja Relatif / Percentile
+# IPLM 2025 — Final (Target Sampel **33.88%** per Jenis) — TANPA Kinerja Relatif / Percentile
+**Mode NO UPLOAD (cache aktif).** File dibaca dari repo/server:
+- `DATA_FILE`   = **{DATA_FILE}**
+- `POP_KAB`     = **{POP_KAB}**
+- `POP_PROV`    = **{POP_PROV}**
+- `POP_KHUSUS`  = **{POP_KHUSUS}**
+
+**TARGET RATIO (per jenis): {TARGET_RATIO*100:.2f}%**
 
-Mode NO UPLOAD (cache). File dibaca dari server/repo:
-- DATA_FILE  = {DATA_FILE}
-- POP_KAB    = {POP_KAB}
-- POP_PROV   = {POP_PROV}
-- POP_KHUSUS = {POP_KHUSUS}
+✅ Dashboard KPI hanya menampilkan:
+- Indeks IPLM FINAL (disesuaikan 33.88%)
+- Indeks Dasar (tanpa penyesuaian)
 
-Dashboard KPI: hanya Indeks Final + Indeks Dasar  
-Analisis LLM: format tabel "Format Data Pendukung IPLM" (No/Dimensi/Nilai/Interpretasi/Rekomendasi)
+✅ Bell Curve kembali menampilkan:
+- Indeks_Dasar_0_100 per entitas (per jenis), hover menampilkan nama perpustakaan.
 """)
 
     state_df = gr.State(None)
@@ -1268,8 +1599,8 @@ Analisis LLM: format tabel "Format Data Pendukung IPLM" (No/Dimensi/Nilai/Interp
 
     with gr.Row():
         dd_prov = gr.Dropdown(label="Provinsi", choices=["(Semua)"], value="(Semua)")
-        dd_kab  = gr.Dropdown(label="Kab/Kota", choices=["(Semua)"], value="(Semua)")
-        dd_kew  = gr.Dropdown(label="Kewenangan", choices=["(Semua)"], value="(Semua)")
+        dd_kab = gr.Dropdown(label="Kab/Kota", choices=["(Semua)"], value="(Semua)")
+        dd_kew = gr.Dropdown(label="Kewenangan", choices=["(Semua)"], value="(Semua)")
 
     dd_prov.change(fn=on_prov_change, inputs=[dd_prov], outputs=dd_kab)
 
@@ -1278,33 +1609,51 @@ Analisis LLM: format tabel "Format Data Pendukung IPLM" (No/Dimensi/Nilai/Interp
 
     kpi_out = gr.Markdown()
 
-    gr.Markdown("## Ringkasan (Jenis + Keseluruhan)")
+    gr.Markdown("## Ringkasan (Jenis + Keseluruhan) — Pop/Target33.88/Terkumpul/Coverage + Penyesuaian")
     out_summary = gr.DataFrame(interactive=False)
 
     gr.Markdown("## Agregat Wilayah (Keseluruhan) — FIX avg3")
     out_agg_total = gr.DataFrame(interactive=False)
 
-    gr.Markdown("## Agregat Wilayah × Jenis")
+    gr.Markdown("## Agregat Wilayah × Jenis — (ditampilkan sampai Indeks_Dasar_Agregat_0_100)")
     out_agg_jenis = gr.DataFrame(interactive=False)
 
     gr.Markdown("## Detail Entitas (Final menempel dari wilayah)")
     out_detail = gr.DataFrame(interactive=False)
 
-    gr.Markdown("## Bell Curve — Indeks Dasar per Entitas (per Jenis)")
+    gr.Markdown("## Kecukupan Sampel 33.88% (tanpa angka koma untuk integer)")
+    out_verif = gr.DataFrame(interactive=False)
+
+    gr.Markdown("## Bell Curve — Indeks Dasar per Entitas (per Jenis) + Nama Perpustakaan")
     gr.Markdown("### Perpustakaan Umum")
     bell_umum = gr.Plot(scale=1)
+
     gr.Markdown("### Perpustakaan Sekolah")
     bell_sekolah = gr.Plot(scale=1)
+
     gr.Markdown("### Perpustakaan Khusus")
     bell_khusus = gr.Plot(scale=1)
 
-    gr.Markdown("## Format Data Pendukung (LLM)")
-    format_md_out = gr.Markdown()
+    gr.Markdown("## Analisis Otomatis (opsional)")
+    analysis_out = gr.Markdown()
+
+    with gr.Row():
+        dl_summary = gr.DownloadButton(label="Download Ringkasan (.xlsx)")
+        dl_total = gr.DownloadButton(label="Download Agregat Wilayah (.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)" if DOCX_AVAILABLE else "Download Laporan Word (OFF)")
 
     run_btn.click(
         fn=run_calc,
         inputs=[dd_prov, dd_kab, dd_kew, state_df, state_raw, state_pop_kab, state_pop_prov, state_pop_khusus, state_meta],
-        outputs=[kpi_out, out_summary, out_agg_total, out_agg_jenis, out_detail, bell_umum, bell_sekolah, bell_khusus, msg_out, format_md_out]
+        outputs=[
+            kpi_out,
+            out_summary, out_agg_total, out_agg_jenis, out_detail, out_verif,
+            dl_summary, dl_total, dl_raw, dl_detail, dl_word,
+            bell_umum, bell_sekolah, bell_khusus,
+            msg_out, analysis_out
+        ]
     )
 
     demo.load(