fix: merge adjacent <B> headings with <I> footnote refs, fix marker normalization exclusion list

- Merge <B>text</B><I>fn-</I><B>text</B> into one heading before B→h4
conversion to prevent footnote refs from splitting into multiple h4.
- Add ']' and Thai digits (\u0E50-\u0E59) to marker normalization
preceding-char exclusion list to prevent:
• [๓๒] ๒. → [๓๒] + \n๒.
• ๑๖. → ๑ + \n๖.

check_vols.py

@@ -0,0 +1,99 @@
+"""Check all volumes via direct SQLite query + spot-check via API."""
+import sqlite3
+import json
+import urllib.request
+import re
+
+DB = r"F:\_Ai\Tipitaka-AI-Expert\RAG\tipitaka_mcu.db"
+API = "http://localhost:8000/api/pages"
+
+db = sqlite3.connect(DB)
+db.row_factory = sqlite3.Row
+cur = db.cursor()
+
+# 1. Volume-by-volume footnote counts
+cur.execute("""
+    SELECT v.volume_number, v.title, COUNT(r.id) as fn_count
+    FROM volumes v
+    LEFT JOIN reference_markers r ON r.volume_num = v.volume_number AND r.type = 'footnote'
+    GROUP BY v.volume_number
+    ORDER BY v.volume_number
+""")
+rows = cur.fetchall()
+
+print(f"{'Vol':>3} {'FN':>5}  Title")
+print("=" * 55)
+total_fn = 0
+v_fn = 0
+v_no = 0
+for r in rows:
+    cnt = r["fn_count"]
+    total_fn += cnt
+    if cnt > 0: v_fn += 1
+    else: v_no += 1
+    print(f"{r['volume_number']:>3} {cnt:>5}  {r['title'][:40]}")
+
+print(f"\nWith FNs: {v_fn}, Without: {v_no}, Total: {total_fn}")
+
+# 2. Distinct marker IDs per volume
+print()
+print("Unique markers per volume:")
+cur.execute("""
+    SELECT volume_num, COUNT(DISTINCT marker_id) as unique_ids
+    FROM reference_markers WHERE type = 'footnote'
+    GROUP BY volume_num ORDER BY volume_num
+""")
+for r in cur.fetchall():
+    print(f"  Vol {r['volume_num']}: {r['unique_ids']} unique marker IDs")
+
+# 3. Pages with most footnotes
+print()
+print("Top pages (most footnotes):")
+cur.execute("""
+    SELECT volume_num, page_num, COUNT(*) as cnt
+    FROM reference_markers WHERE type = 'footnote'
+    GROUP BY volume_num, page_num ORDER BY cnt DESC LIMIT 10
+""")
+for r in cur.fetchall():
+    print(f"  Vol {r['volume_num']:>2} P{r['page_num']:>3}: {r['cnt']}")
+
+db.close()
+
+# 4. Spot-check via API (first 15 volumes + heavy ones)
+print("\n\n=== API Spot Check ===")
+def get_json(url, timeout=8):
+    try:
+        resp = urllib.request.urlopen(url, timeout=timeout)
+        return json.loads(resp.read())
+    except Exception as e:
+        return {"_error": str(e)}
+
+# Check first 15 volumes for sup tags
+for vol in [1,2,3,5,10,14,15,20,25,30,35,40,45]:
+    data = get_json(f"{API}/{vol}/1")
+    if "_error" in data:
+        print(f"Vol {vol}: API ERROR - {data['_error']}")
+        continue
+    fns = data.get("footnotes", [])
+    html = data.get("content_html_formatted", "")
+    sups = re.findall(r'<sup[^>]*>.*?</sup>', html)
+    blank = data.get("is_blank", False)
+    fn_str = f"{len(fns)} FN"
+    sup_str = f"{len(sups)} Sup"
+    status = "✅"
+    if len(fns) > 0 and len(sups) == 0:
+        status = "⚠️ NOSUP"
+    elif blank:
+        status = "⬜ blank"
+    print(f"Vol {vol:>2} P1: {fn_str:>7}, {sup_str:>7}  {status}")
+
+# Check pages with most footnotes
+print()
+heavy = [(5,34), (11,172), (11,180)]  # from top10
+for vol, pg in heavy:
+    data = get_json(f"{API}/{vol}/{pg}")
+    if "_error" not in data:
+        fns = data.get("footnotes", [])
+        html = data.get("content_html_formatted", "")
+        sups = re.findall(r'<sup[^>]*>.*?</sup>', html)
+        print(f"Vol {vol:>2} P{pg:>3}: {len(fns)} FN, {len(sups)} Sup  {'✅' if len(fns)==len(sups) or len(sups)>0 else '⚠️'}")

scripts/preindex_abbrevs.log

@@ -0,0 +1,124 @@
+2026-05-17 03:29:22,079 [INFO] 🚀 Starting preindex_abbrevs | model=deepseek-ai/deepseek-v4-flash
+2026-05-17 03:29:22,079 [INFO]    DB: F:\_Ai\Tipitaka-AI-Expert\RAG\tipitaka_mcu.db
+2026-05-17 03:29:22,081 [INFO]    Existing abbrev entries: 0
+2026-05-17 03:29:22,287 [INFO]    Pages with (ย่อ): 1743
+2026-05-17 03:29:22,288 [INFO]    (limited to 3)
+2026-05-17 03:30:56,957 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 03:30:56,974 [INFO] ✅ Vol 18 P39: 8 abbrevs, 0 chars
+2026-05-17 03:31:29,264 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 03:31:29,275 [INFO] ✅ Vol 37 P37: 2 abbrevs, 824 chars
+2026-05-17 03:31:41,947 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 03:31:41,971 [INFO] ✅ Vol 37 P39: 1 abbrevs, 0 chars
+2026-05-17 03:31:41,972 [INFO] ============================================================
+2026-05-17 03:31:41,972 [INFO] ✅ Done!
+2026-05-17 03:31:41,972 [INFO]    Pages: 3 success, 0 failed (of 3)
+2026-05-17 03:31:41,972 [INFO]    Abbrevs indexed: 11
+2026-05-17 03:31:41,972 [INFO]    Time: 140s (46.5s/page)
+2026-05-17 03:31:41,972 [INFO]    Avg: 0.1 abbrevs/min
+2026-05-17 03:32:45,241 [INFO] 🚀 Starting preindex_abbrevs | model=deepseek-ai/deepseek-v4-flash
+2026-05-17 03:32:45,241 [INFO]    DB: F:\_Ai\Tipitaka-AI-Expert\RAG\tipitaka_mcu.db
+2026-05-17 03:32:45,244 [INFO]    Existing abbrev entries: 0
+2026-05-17 03:32:45,466 [INFO]    Pages with (ย่อ): 1743
+2026-05-17 03:32:45,467 [INFO]    (limited to 3)
+2026-05-17 03:34:00,493 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 03:34:00,517 [INFO]    Parsed 0/8 expansions
+2026-05-17 03:34:00,517 [WARNING] [Vol 18 P39] All expansions empty! Raw: ```json
+[
+  {
+    "num": 34,
+    "title": "ชราธัมมสูตร (ว่าด้วยความแก่)",
+    "detail": "พระผู้มีพระภาคตรัสว่า สิ่งทั้งปวงมีความแก่เป็นธรรมดา ได้แก่ จักษุ รูป จักษุวิญญาณ จักษุสัมผัส และเวทนาที่เกิดจา
+2026-05-17 03:35:00,577 [INFO] 🚀 Starting preindex_abbrevs | model=deepseek-ai/deepseek-v4-flash
+2026-05-17 03:35:00,577 [INFO]    DB: F:\_Ai\Tipitaka-AI-Expert\RAG\tipitaka_mcu.db
+2026-05-17 03:35:00,579 [INFO]    Existing abbrev entries: 0
+2026-05-17 03:35:00,787 [INFO]    Pages with (ย่อ): 1743
+2026-05-17 03:35:00,788 [INFO]    (limited to 3)
+2026-05-17 03:36:59,770 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 03:36:59,796 [INFO]    Parsed 9/8 expansions
+2026-05-17 03:36:59,807 [INFO] ✅ Vol 18 P39: 9 abbrevs, 953 chars
+2026-05-17 04:03:38,710 [INFO] 🚀 preindex_abbrevs | model=deepseek-ai/deepseek-v4-flash
+2026-05-17 04:03:38,711 [INFO]    DB: F:\_Ai\Tipitaka-AI-Expert\RAG\tipitaka_mcu.db
+2026-05-17 04:03:38,711 [INFO]    Key: nvapi-kK...
+2026-05-17 04:03:38,711 [INFO]    Rate: 2.0s
+2026-05-17 04:03:38,715 [INFO]    Existing: 1 abbrev entries
+2026-05-17 04:03:38,931 [INFO]    Pages: 1743
+2026-05-17 04:03:38,989 [INFO] 
+============================================================
+2026-05-17 04:03:38,989 [INFO] Processing 1743 pages...
+2026-05-17 04:03:38,989 [INFO] ============================================================
+
+2026-05-17 04:03:55,248 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:03:55,280 [INFO]   ✅ Vol 18 P39: 8 abbrevs, 268c
+2026-05-17 04:04:20,502 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:04:20,515 [INFO]   ✅ Vol 37 P37: 3 abbrevs, 209c
+2026-05-17 04:04:23,893 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:04:23,904 [INFO]   ✅ Vol 37 P39: 2 abbrevs, 114c
+2026-05-17 04:04:46,374 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:04:46,385 [INFO]   ✅ Vol 37 P43: 4 abbrevs, 314c
+2026-05-17 04:06:09,875 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:06:10,154 [INFO]   ✅ Vol 37 P54: 3 abbrevs, 80c
+2026-05-17 04:06:29,539 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:06:29,953 [INFO]   ✅ Vol 37 P85: 15 abbrevs, 838c
+2026-05-17 04:06:43,054 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:06:43,067 [INFO]   ✅ Vol 37 P108: 3 abbrevs, 436c
+2026-05-17 04:06:58,717 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:06:58,728 [INFO]   ✅ Vol 37 P176: 2 abbrevs, 103c
+2026-05-17 04:07:04,079 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:07:04,092 [INFO]   ✅ Vol 38 P157: 2 abbrevs, 80c
+2026-05-17 04:07:15,607 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:07:15,618 [INFO]   ✅ Vol 40 P37: 3 abbrevs, 108c
+2026-05-17 04:07:30,573 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:07:30,606 [INFO]   ✅ Vol 40 P104: 18 abbrevs, 642c
+2026-05-17 04:08:02,935 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:08:02,946 [INFO]   ✅ Vol 40 P105: 25 abbrevs, 1103c
+2026-05-17 04:08:48,306 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:08:48,336 [INFO]   ✅ Vol 40 P107: 23 abbrevs, 676c
+2026-05-17 04:09:47,383 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:09:47,394 [INFO]   ✅ Vol 40 P109: 22 abbrevs, 1318c
+2026-05-17 04:10:37,257 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:10:37,269 [INFO]   ✅ Vol 40 P111: 24 abbrevs, 1434c
+2026-05-17 04:11:28,831 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:11:28,843 [INFO]   ✅ Vol 40 P113: 23 abbrevs, 1244c
+2026-05-17 04:11:51,876 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:11:51,889 [INFO]   ✅ Vol 40 P115: 25 abbrevs, 1399c
+2026-05-17 04:12:24,758 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:12:24,768 [INFO]   ✅ Vol 40 P116: 3 abbrevs, 660c
+2026-05-17 04:12:37,534 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:12:37,546 [INFO]   ✅ Vol 40 P117: 15 abbrevs, 766c
+2026-05-17 04:13:50,627 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:13:50,638 [INFO]   ✅ Vol 40 P118: 22 abbrevs, 1187c
+2026-05-17 04:14:11,666 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:14:11,690 [INFO]   ✅ Vol 40 P119: 23 abbrevs, 1090c
+2026-05-17 04:14:36,526 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:14:36,538 [INFO]   ✅ Vol 40 P121: 23 abbrevs, 1347c
+2026-05-17 04:15:41,654 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:15:41,666 [INFO]   ✅ Vol 40 P171: 23 abbrevs, 988c
+2026-05-17 04:15:59,997 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:16:00,009 [INFO]   ✅ Vol 40 P172: 23 abbrevs, 626c
+2026-05-17 04:17:31,849 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:17:32,487 [INFO]   ✅ Vol 40 P173: 24 abbrevs, 1034c
+2026-05-17 04:17:51,983 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:17:51,995 [INFO]   ✅ Vol 40 P174: 3 abbrevs, 252c
+2026-05-17 04:18:46,797 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:18:46,810 [INFO]   ✅ Vol 40 P176: 22 abbrevs, 917c
+2026-05-17 04:19:17,329 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:19:17,347 [INFO]   ✅ Vol 40 P177: 20 abbrevs, 827c
+2026-05-17 04:19:43,892 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:19:43,902 [INFO]   ✅ Vol 40 P178: 19 abbrevs, 1061c
+2026-05-17 04:19:56,695 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:19:56,723 [INFO]   ✅ Vol 40 P179: 21 abbrevs, 651c
+2026-05-17 04:19:58,656 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:19:58,726 [INFO]   ✅ Vol 40 P180: 2 abbrevs, 67c
+2026-05-17 04:20:09,057 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:20:09,138 [INFO]   ✅ Vol 40 P181: 2 abbrevs, 108c
+2026-05-17 04:22:09,142 [WARNING]   ⚠ Vol 40 P183 Error (attempt 1): Request timed out.
+2026-05-17 04:23:10,900 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:23:11,332 [INFO]   ✅ Vol 40 P183: 13 abbrevs, 760c
+2026-05-17 04:24:08,773 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:24:09,206 [INFO]   ✅ Vol 40 P186: 13 abbrevs, 883c
+2026-05-17 04:24:28,705 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:24:28,717 [INFO]   ✅ Vol 40 P188: 23 abbrevs, 923c
+2026-05-17 04:26:25,183 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:26:25,203 [INFO]   ✅ Vol 40 P189: 23 abbrevs, 1387c
+2026-05-17 04:27:26,063 [INFO] HTTP Request: POST https://integrate.api.nvidia.com/v1/chat/completions "HTTP/1.1 200 OK"
+2026-05-17 04:27:26,075 [INFO]   ✅ Vol 40 P191: 22 abbrevs, 1323c

scripts/preindex_abbrevs.py

@@ -0,0 +1,320 @@
+"""
+Pre-index all (ย่อ) abbreviation markers using NVIDIA NIM (free DeepSeek, 40 RPM).
+
+Usage:
+    # Full run (all 1,743 pages)
+    python scripts/preindex_abbrevs.py
+
+    # Resume from interrupted run
+    python scripts/preindex_abbrevs.py --resume
+
+    # Test: first 10 pages
+    python scripts/preindex_abbrevs.py --limit 10
+
+Scans all pages in tipitaka_mcu.db for (ย่อ) markers.
+For each page, calls NIM DeepSeek to expand ALL abbreviations in one request.
+Stores JSON array in reference_markers (type='abbrev', marker_id='_default').
+Supports resume — skips pages already in DB.
+
+Log file: scripts/preindex_abbrevs.log
+"""
+import asyncio
+import json
+import logging
+import re
+import time
+import argparse
+import sqlite3
+from pathlib import Path
+
+from openai import AsyncOpenAI
+from dotenv import load_dotenv
+import os
+
+# ── Paths ──
+SCRIPT_DIR = Path(__file__).resolve().parent
+PROJECT_ROOT = SCRIPT_DIR.parent
+DB_PATH = PROJECT_ROOT / "tipitaka_mcu.db"
+LOG_PATH = SCRIPT_DIR / "preindex_abbrevs.log"
+ENV_PATH = PROJECT_ROOT.parent / "tipitaka_context" / "nvidia" / ".env"
+
+# ══════════════════════════════════════════════════════════════
+# Config (loaded from .env)
+# ══════════════════════════════════════════════════════════════
+load_dotenv(ENV_PATH)
+
+NIM_API_KEY = os.getenv("TIPITAKA_API_KEY") or os.getenv("NVIDIA_API_KEY") or ""
+NIM_BASE_URL = os.getenv("TIPITAKA_BASE_URL", "https://integrate.api.nvidia.com/v1")
+NIM_MODEL = os.getenv("TIPITAKA_MODEL", "deepseek-ai/deepseek-v4-flash")
+RATE_INTERVAL = float(os.getenv("TIPITAKA_RATE_INTERVAL", "1.6"))  # 40 RPM
+
+MAX_RETRIES = 4
+RETRY_DELAYS = [10, 20, 40, 80]
+
+# ── Logging ──
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler(LOG_PATH, encoding="utf-8"),
+    ],
+)
+log = logging.getLogger(__name__)
+
+
+# ══════════════════════════════════════════════════════════════
+# Prompts
+# ══════════════════════════════════════════════════════════════
+SYSTEM_PROMPT = (
+    "คุณคือผู้เชี่ยวชาญพระไตรปิฎก มจร.\n"
+    "ตอบเป็น JSON array เท่านั้น โดยแต่ละรายการเป็น string"
+)
+
+USER_PROMPT_TEMPLATE = """ขยายความ (ย่อ) แต่ละแห่งในเนื้อหาด้านล่าง
+
+ให้ตอบเป็น JSON array:
+[
+  "ข้อความที่ถูกย่อแห่งที่ 1...",
+  "ข้อความที่ถูกย่อแห่งที่ 2...",
+  ...
+]
+โดยเรียงลำดับตามที่ (ย่อ) ปรากฏในเนื้อหา
+แต่ละรายการต้องเป็น string สั้นๆ อธิบายสิ่งที่ถูกย่อไว้
+ตอบเฉพาะ JSON array เท่านั้น
+
+เนื้อหา:
+{content}"""
+
+
+def build_prompt(content_text: str) -> str:
+    return USER_PROMPT_TEMPLATE.format(content=content_text[:8000])
+
+
+# ══════════════════════════════════════════════════════════════
+# Parsing
+# ══════════════════════════════════════════════════════════════
+def parse_response(raw: str, expected_count: int) -> list[str]:
+    """Parse JSON array from NIM response into list of expansion strings."""
+    raw = re.sub(r'<think>.*?</think>', '', raw, flags=re.DOTALL).strip()
+    raw = re.sub(r'^```(?:json)?\s*', '', raw)
+    raw = re.sub(r'\s*```$', '', raw)
+    raw = raw.strip()
+
+    match = re.search(r'\[[\s\S]*\]', raw)
+    if not match:
+        raise ValueError(f"No JSON array found: {raw[:300]}")
+
+    data = json.loads(match.group(0))
+    if not isinstance(data, list):
+        raise ValueError(f"Not an array: {type(data)}")
+
+    result = []
+    for item in data:
+        if isinstance(item, str):
+            result.append(item)
+        elif isinstance(item, dict):
+            # Try known keys, then concatenate all values
+            for key in ("expansion", "expanded", "content", "text",
+                        "explanation", "detail", "description", "meaning",
+                        "abbrev", "ข���ายความ", "ข้อความ", "ความหมาย", "answer"):
+                val = item.get(key, "")
+                if isinstance(val, str) and len(val.strip()) > 10:
+                    result.append(val.strip())
+                    break
+            else:
+                parts = [v for v in item.values()
+                         if isinstance(v, str) and len(v.strip()) > 10]
+                if parts:
+                    result.append(" | ".join(parts))
+
+    return result
+
+
+# ══════════════════════════════════════════════════════════════
+# Core: expand one page
+# ══════════════════════════════════════════════════════════════
+async def expand_page(
+    client: AsyncOpenAI,
+    vol: int, page: int, content_text: str,
+    conn: sqlite3.Connection,
+) -> bool:
+    """Expand all (ย่อ) on one page. Stores result in DB. Returns True on success."""
+    abbrev_count = content_text.count("(ย่อ)")
+    if abbrev_count == 0:
+        return False
+
+    prompt = build_prompt(content_text)
+
+    for attempt in range(MAX_RETRIES):
+        try:
+            resp = await client.chat.completions.create(
+                model=NIM_MODEL,
+                messages=[
+                    {"role": "system", "content": SYSTEM_PROMPT},
+                    {"role": "user", "content": prompt},
+                ],
+                temperature=0.3,
+                max_tokens=2000,
+                timeout=120,
+            )
+
+            raw = resp.choices[0].message.content or ""
+
+            expansions = parse_response(raw, abbrev_count)
+
+            # Filter meaningful expansions
+            expansions = [e for e in expansions if len(e.strip()) > 15]
+
+            if not expansions:
+                log.warning(f"    Empty! retrying... raw={raw[:150]}")
+                if attempt < MAX_RETRIES - 1:
+                    await asyncio.sleep(RETRY_DELAYS[attempt])
+                    continue
+                return False
+
+            # Store in DB
+            stored = json.dumps(expansions, ensure_ascii=False)
+            conn.execute("""
+                INSERT OR REPLACE INTO reference_markers
+                    (volume_num, page_num, marker_id, type, content)
+                VALUES (?, ?, '_default', 'abbrev', ?)
+            """, (vol, page, stored))
+            conn.commit()
+
+            total_chars = sum(len(e) for e in expansions)
+            log.info(f"  ✅ Vol {vol} P{page}: {len(expansions)} abbrevs, {total_chars}c")
+            return True
+
+        except json.JSONDecodeError as e:
+            log.warning(f"  ⚠ Vol {vol} P{page} JSON error (attempt {attempt+1}): {e}")
+            if attempt < MAX_RETRIES - 1:
+                await asyncio.sleep(RETRY_DELAYS[attempt])
+        except Exception as e:
+            err_str = str(e)
+            is_429 = "429" in err_str or "Too Many Requests" in err_str
+            log.warning(f"  ⚠ Vol {vol} P{page} Error (attempt {attempt+1}): {e}")
+            if attempt < MAX_RETRIES - 1:
+                delay = RETRY_DELAYS[attempt] * (2 if is_429 else 1)
+                await asyncio.sleep(delay)
+
+    log.error(f"  ❌ Vol {vol} P{page}: Failed after {MAX_RETRIES} attempts")
+    return False
+
+
+# ══════════════════════════════════════════════════════════════
+# Main
+# ══════════════════════════════════════════════════════════════
+async def main():
+    parser = argparse.ArgumentParser(description="Pre-index (ย่อ) abbreviations via NVIDIA NIM")
+    parser.add_argument("--resume", action="store_true", help="Skip already-indexed pages")
+    parser.add_argument("--force", action="store_true", help="Re-index even if already in DB")
+    parser.add_argument("--limit", type=int, default=0, help="Max pages (0 = all)")
+    args = parser.parse_args()
+
+    if not NIM_API_KEY:
+        log.error(f"❌ No API key found. Check env file: {ENV_PATH}")
+        log.error("   Set TIPITAKA_API_KEY or NVIDIA_API_KEY")
+        return
+
+    if not DB_PATH.exists():
+        log.error(f"❌ DB not found: {DB_PATH}")
+        return
+
+    log.info(f"🚀 preindex_abbrevs | model={NIM_MODEL}")
+    log.info(f"   DB: {DB_PATH}")
+    log.info(f"   Key: {NIM_API_KEY[:8]}...")
+    log.info(f"   Rate: {RATE_INTERVAL}s")
+
+    # ── Load pages ──
+    conn = sqlite3.connect(str(DB_PATH))
+    conn.row_factory = sqlite3.Row
+    c = conn.cursor()
+
+    c.execute("SELECT COUNT(*) as cnt FROM reference_markers WHERE type='abbrev'")
+    log.info(f"   Existing: {c.fetchone()['cnt']} abbrev entries")
+
+    c.execute("""
+        SELECT v.volume_number, p.page_number, p.content_text
+        FROM pages p
+        JOIN volumes v ON p.volume_id = v.id
+        WHERE p.content_text LIKE '%(ย่อ)%'
+        ORDER BY v.volume_number, p.page_number
+    """)
+    rows = c.fetchall()
+    log.info(f"   Pages: {len(rows)}")
+
+    if args.limit > 0:
+        rows = rows[:args.limit]
+        log.info(f"   Limit: {args.limit}")
+
+    if args.resume:
+        c.execute("SELECT DISTINCT volume_num, page_num FROM reference_markers WHERE type='abbrev'")
+        indexed = {(r["volume_num"], r["page_num"]) for r in c.fetchall()}
+        rows = [r for r in rows if (r["volume_number"], r["page_number"]) not in indexed]
+        log.info(f"   Resume: {len(indexed)} done, {len(rows)} remaining")
+        if not rows:
+            log.info("✅ All done!")
+            conn.close()
+            return
+    elif args.force:
+        c.execute("DELETE FROM reference_markers WHERE type='abbrev'")
+        conn.commit()
+        log.info("   Force: cleared all")
+
+    # ── Setup client ──
+    client = AsyncOpenAI(
+        base_url=NIM_BASE_URL,
+        api_key=NIM_API_KEY,
+        max_retries=0,
+    )
+
+    total = len(rows)
+    success = fail = 0
+    start = time.time()
+
+    log.info(f"\n{'='*60}")
+    log.info(f"Processing {total} pages...")
+    log.info(f"{'='*60}\n")
+
+    for i, row in enumerate(rows):
+        vol = row["volume_number"]
+        page = row["page_number"]
+        text = row["content_text"] or ""
+
+        # Rate limit
+        if i > 0:
+            elapsed = time.time() - start
+            expected = i * RATE_INTERVAL
+            wait = max(0, expected - elapsed)
+            if wait > 0:
+                await asyncio.sleep(wait)
+
+        ok = await expand_page(client, vol, page, text, conn)
+
+        if ok:
+            success += 1
+        else:
+            fail += 1
+
+        # Progress every 50 pages
+        if (i + 1) % 50 == 0:
+            elapsed = time.time() - start
+            rate = (i + 1) / elapsed * 60
+            remain = total - i - 1
+            eta = remain / max(rate, 0.1) * 60
+            log.info(f"📊 [{i+1}/{total}] {rate:.0f} pg/min | ETA: {eta/60:.1f}h")
+
+    # ── Summary ──
+    elapsed = time.time() - start
+    log.info(f"\n{'='*60}")
+    log.info(f"✅ Done!")
+    log.info(f"   Success: {success}  Failed: {fail}")
+    log.info(f"   Time: {elapsed:.0f}s ({elapsed/max(success,1):.1f}s/page)")
+    log.info(f"   Log: {LOG_PATH}")
+
+    conn.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

webapp/tipitaka-api/app/routers/reference.py

@@ -3,7 +3,6 @@ from pydantic import BaseModel
 from typing import Optional
 
 from app.services.page_service import PageService
-from app.services.llm_service import LLMService
 from app.database.sqlite_db import get_db, SQLiteDB
 
 router = APIRouter(prefix="/reference", tags=["Reference"])
@@ -18,9 +17,6 @@ class ReferenceLookupRequest(BaseModel):
 def get_page_service(db: SQLiteDB = Depends(get_db)) -> PageService:
     return PageService(db)
 
-def get_llm_service(db: SQLiteDB = Depends(get_db)) -> LLMService:
-    return LLMService(db)
-
 @router.get("/lookup")
 async def lookup_reference(
     vol: int,
@@ -28,7 +24,6 @@ async def lookup_reference(
     type: str,
     id: str,
     service: PageService = Depends(get_page_service),
-    llm: LLMService = Depends(get_llm_service)
 ):
     if type == "footnote":
         content = service.get_footnote(vol, page, id)
@@ -37,6 +32,10 @@ async def lookup_reference(
         return {"content": content, "found": True}
     
     elif type == "abbrev":
+        # Lazily initialize LLM service — only needed for abbreviation expansion
+        from app.services.llm_service import LLMService
+        from app.database.sqlite_db import get_db
+        llm = LLMService(get_db())
         # Fetch page text for LLM context if DB index fails
         page_data = service.get_page(vol, page)
         context = page_data["content_text"] if page_data else ""

webapp/tipitaka-api/app/schemas.py

@@ -7,6 +7,10 @@ class SectionInfo(BaseModel):
     level: int
 
 
+class FootnoteInfo(BaseModel):
+    id: str
+    content: str
+
 class PageResponse(BaseModel):
     id: int
     volume_id: int
@@ -19,6 +23,7 @@ class PageResponse(BaseModel):
     title: Optional[str] = None
     sections: List[SectionInfo] = Field(default_factory=list)
     end_markers: List[str] = Field(default_factory=list)
+    footnotes: List[FootnoteInfo] = Field(default_factory=list)
     requested_page: Optional[int] = None
     is_blank: Optional[bool] = False
     skipped_from: Optional[int] = None

webapp/tipitaka-api/app/services/llm_service.py

@@ -1,5 +1,6 @@
 import json
 from typing import AsyncGenerator, List, Optional
+import re
 from openai import AsyncOpenAI
 from app.config import get_settings
 from pydantic import BaseModel
@@ -119,6 +120,7 @@ class LLMService:
     async def expand_abbreviation(self, vol: int, page: int, abbrev_text: str, context: str = "") -> str:
         """Expand abbreviation (ย่อ) using DB index or LLM as fallback."""
         clean_id = re.sub(r'[()\[\]-]', '', abbrev_text).strip()
+        lookup_id = clean_id if clean_id else "_default"
         
         # 1. Try DB Index
         with self.db.get_connection() as conn:
@@ -126,10 +128,19 @@ class LLMService:
             cursor.execute("""
                 SELECT content FROM reference_markers
                 WHERE volume_num = ? AND page_num = ? AND marker_id = ? AND type = 'abbrev'
-            """, (vol, page, clean_id))
+            """, (vol, page, lookup_id))
             row = cursor.fetchone()
             if row:
-                return row["content"]
+                content = row["content"]
+                # Check if stored as JSON array (multiple abbrevs per page)
+                if content.startswith('['):
+                    try:
+                        entries = json.loads(content)
+                        parts = [e.get("expansion", "") for e in entries if e.get("expansion")]
+                        return "\n\n".join(parts) if parts else content
+                    except (json.JSONDecodeError, TypeError):
+                        pass
+                return content
 
         # 2. LLM Fallback
         clean_ctx = self.search_service.clean_text(context) if context else ""
@@ -152,6 +163,20 @@ class LLMService:
                 ],
                 max_tokens=500
             )
-            return response.choices[0].message.content.strip()
+            result = response.choices[0].message.content.strip()
+            
+            # 3. Cache result in DB for future lookups
+            try:
+                with self.db.get_connection() as conn:
+                    cursor = conn.cursor()
+                    cursor.execute("""
+                        INSERT OR REPLACE INTO reference_markers
+                            (volume_num, page_num, marker_id, type, content)
+                        VALUES (?, ?, ?, 'abbrev', ?)
+                    """, (vol, page, lookup_id, result))
+            except Exception:
+                pass  # Cache failure is non-critical
+            
+            return result
         except Exception as e:
             return f"ไม่สามารถขยายความได้ในขณะนี้: {str(e)}"

webapp/tipitaka-api/app/services/page_service.py

@@ -18,7 +18,7 @@ class PageService:
             return True
         return len(stripped) < 20
 
-    def format_content_html(self, html: str) -> str:
+    def format_content_html(self, html: str, footnote_ids: set = None) -> str:
         if not html:
             return ""
         # Strip line number spans
@@ -29,6 +29,16 @@ class PageService:
         html = re.sub(r'^[=_-]{3,}\s*$', '', html, flags=re.MULTILINE)
         # Strip <B> containing only separator characters (______, ===, ---)
         html = re.sub(r'<B>\s*[=_-]{3,}\s*</B>', '', html, flags=re.IGNORECASE)
+        # Merge consecutive <B> elements separated only by whitespace and <I> tags
+        # e.g. "<B>อมราวิกเขปวาทะ</B><I>๑-</I><B> ๔</B>\n<B>ความเห็นหลบเลี่ยง</B>"
+        #   →  "<B>อมราวิกเขปวาทะ<I>๑-</I> ๔ ความเห็นหลบเลี่ยง</B>"
+        # This prevents footnote refs inside headings from splitting into multiple h4.
+        html = re.sub(
+            r'</B>\s*((?:<I>[^<]*</I>\s*)+)<B>',
+            lambda m: ' ' + m.group(1).strip() + ' ',
+            html,
+            flags=re.DOTALL | re.IGNORECASE
+        )
         # Convert <B> to h4 headings; strip <B> containing "จบ" (shown as end markers via sections)
         def _replace_b(m: re.Match) -> str:
             text = m.group(1).strip()
@@ -45,17 +55,17 @@ class PageService:
                 if not line.strip():
                     cleaned_lines.append(line)
                     continue
-                # If line starts with a marker, protect it, then strip others
-                # Pattern for start of line markers
-                start_marker = re.match(r'^(\[[\u0E50-\u0E59]+\]|\[[\u0E01-\u0E39]+\]|\[\d+\])', line)
+                # If line starts with a marker (possibly with leading whitespace), protect it
+                start_marker = re.match(r'^(\s*)(\[[\u0E50-\u0E59]+\]|\[[\u0E01-\u0E39]+\]|\[\d+\])', line)
                 if start_marker:
-                    marker = start_marker.group(1)
-                    rest = line[len(marker):]
+                    ws = start_marker.group(1)      # leading whitespace (tabs etc)
+                    marker = start_marker.group(2)  # the bracket marker
+                    rest = line[len(ws) + len(marker):]
                     # Strip markers from the rest
                     rest = re.sub(r'\[[\u0E50-\u0E59]+\]', '', rest)
                     rest = re.sub(r'\[[\u0E01-\u0E39]+\]', '', rest)
                     rest = re.sub(r'\[\d+\]', '', rest)
-                    cleaned_lines.append(marker + rest)
+                    cleaned_lines.append(ws + marker + rest)
                 else:
                     line = re.sub(r'\[[\u0E50-\u0E59]+\]', '', line)
                     line = re.sub(r'\[[\u0E01-\u0E39]+\]', '', line)
@@ -65,6 +75,18 @@ class PageService:
 
         html = _strip_footnotes(html)
 
+        # ── Convert <I>fn</I> inline footnote refs to sup BEFORE stripping ๑- ──
+        # e.g. <I>๑-</I> → <sup>, <I>*</I> → <sup>
+        if footnote_ids:
+            sorted_ids = sorted(footnote_ids, key=lambda x: -len(x))
+            ids_alt = '|'.join(re.escape(fid) for fid in sorted_ids)
+            html = re.sub(
+                r'<I>\s*(' + ids_alt + r')\s*-?\s*</I>',
+                r' <sup class="footnote-ref">\1</sup>',
+                html,
+                flags=re.IGNORECASE
+            )
+
         # Remove inline footnote refs like ๑- (only when preceded by non-space)
         html = re.sub(r'(?<=[^\s])[\u0E50-\u0E59]+-', '', html)
         # Remove leading item markers: ๑- at line start, [ก] etc
@@ -78,9 +100,12 @@ class PageService:
 
         # ── Marker Normalization ──
         # Ensure markers like (๑), ถาม., ตอบ. start on a new line if they are currently inline
-        # NOTE: Exclude '(' from the preceding char group — otherwise (๑) gets split into ( + \n๑)
-        marker_regex = r'(\([\u0E50-\u0E59]+\)|\[[\u0E50-\u0E59]+\]|[\u0E50-\u0E59]+\.|ถาม\.|ตอบ\.|\[\d+\]|\d+\.|\(\d+\)|\d+\))'
-        html = re.sub(r'([^\s\n\r>(\[])\s*' + marker_regex, r'\1\n\2', html)
+        # NOTE: Exclude '(' and '[' from the preceding char group — otherwise (๑) gets split into ( + \n๑) or [x](x) splits
+        # NOTE: Exclude ']' from preceding char — otherwise [๓๒] ๒. splits into [๓๒] + \n๒.
+        # NOTE: Exclude Thai digits (\u0E50-\u0E59) from preceding char — otherwise ๑๖. splits into ๑ + \n๖.
+        # NOTE: \d in Python 3 matches Thai digits (u0E50+), so use [0-9] for ASCII-only digits
+        marker_regex = r'(\([\u0E50-\u0E59]+\)|\[[\u0E50-\u0E59]+\]|[\u0E50-\u0E59]+\.|ถาม\.|ตอบ\.|\[[0-9]+\]|[0-9]+\.|\([0-9]+\)|[0-9]+\))'
+        html = re.sub(r'([^\s\n\r>(\[\]\u0E50-\u0E59])\s*' + marker_regex, r'\1\n\2', html)
 
         # ── Semantic Paragraph Wrapping ──
         # Split by existing block elements (h4) to wrap text between them
@@ -88,14 +113,15 @@ class PageService:
         wrapped_parts = []
         
         # Pattern 1: Section-heading markers that START a line AND have content after them
-        # e.g.  ๑. ผู้มีวิชชา...  ถาม. / ถาม : / ตอบ :  — must have text following the marker
-        # Also includes parenthetical Thai numerals: (๑), (๒), (๑๐) etc.
-        num_pattern = r'^\s*([\u0E50-\u0E59]+[\.\)]|\([\u0E50-\u0E59]+\)|ถาม\s*[\.\:]|ตอบ\s*[\.\:]|\d+[\.\)]|\(\d+\))\s+\S'
+        # e.g.  ๑. ผู้มีวิชชา...  ๑) ...  ถาม. / ถาม : / ตอบ :  — must have text following the marker
+        # NOTE: (๑) parenthetical forms are deliberately excluded — they're part of body text,
+        # not section headers (e.g. numbered list items in Vinaya).
+        num_pattern = r'^\s*([\u0E50-\u0E59]+[\.\)]|ถาม\s*[\.\:]|ตอบ\s*[\.\:]|\d+[\.\)])\s+\S'
 
         # Pattern 2: Standalone footnote/endnote reference markers — MUST be fully bracketed
         # e.g.  (๑)  [๑]  (1)  — bare digit) is NOT included because it may be a split tail
         # of a longer expression like (เรื่องที่ ๓) broken across two raw lines.
-        footnote_pattern = r'^\s*(\([\u0E50-\u0E59]+\)|\[[\u0E50-\u0E59]+\]|\(\d+\)|\[\d+\])\s*$'
+        footnote_pattern = r'^\s*(\([\u0E50-\u0E59]+\)|\[[\u0E50-\u0E59]+\]|\([0-9]+\)|\[[0-9]+\])\s*$'
 
         for part in parts:
             if part.startswith('<h4'):
@@ -141,6 +167,7 @@ class PageService:
                 # semantic paragraph. Grouping them lets text-align:justify work
                 # (justify only has effect on lines that aren't the last line of a <p>).
                 para_buf = []   # buffered body lines for the current paragraph
+                _in_numbered_seq = False  # track when inside (x) list
 
                 # Option B: length threshold — short merged content = left-align item,
                 # long merged content = paragraph (justify applies meaningfully).
@@ -151,19 +178,20 @@ class PageService:
                 abbrev_pattern = r'^\s*([\u0E50-\u0E59]+|\([\u0E50-\u0E59]+\))?\s*\(ย่อ\)\s*$'
 
                 def apply_inline_refs(text: str) -> str:
-                    """Wrap inline (Thai_digit) and (ย่อ) references as superscript."""
-                    # Use a counter or some logic if we need multiple unique refs on one page?
-                    # For now, just using the ID itself is usually enough unless the same ref appears twice.
-                    def _wrap_fn(m):
-                        val = m.group(1)
-                        clean = re.sub(r'[()\[\]-]', '', val).strip()
-                        return f'<sup id="ref-{clean}" class="footnote-ref">({val})</sup>'
-
-                    text = re.sub(
-                        r'(?<=\S)\s*\(([\u0E50-\u0E59]+|\d+)\)',
-                        _wrap_fn,
-                        text
-                    )
+                    """Wrap inline footnote markers as superscript — only for known refs."""
+                    if footnote_ids:
+                        # Build pattern from known footnote markers only
+                        # Sort by length descending so multi-digit (๑๐) matches before single (๑)
+                        sorted_ids = sorted(footnote_ids, key=lambda x: -len(x))
+                        ids_alt = '|'.join(re.escape(fid) for fid in sorted_ids)
+                        # (๑) parenthesis pattern — NOT when followed by (ย่อ)
+                        # Exclude < and > (e.g. <br> before (๑) is NOT a footnote ref)
+                        text = re.sub(
+                            r'(?<=[^\s<(\[\]>])\s*\(\s*(' + ids_alt + r')\s*\)(?!\s*\(ย่อ\))',
+                            r'<sup class="footnote-ref">(\1)</sup>',
+                            text
+                        )
+                    # (ย่อ) always wraps — triggers LLM expansion
                     text = re.sub(
                         r'\s*\(ย่อ\)',
                         r' <sup class="abbrev-ref">(ย่อ)</sup>',
@@ -175,8 +203,13 @@ class PageService:
                     """Output buffered lines as a <p>. Short content → left-align."""
                     if para_buf:
                         text = apply_inline_refs(' '.join(para_buf))
-                        if len(text) >= PARA_MIN_CHARS:
-                            wrapped_parts.append(f'<p>{text}</p>')
+                        # Detect (x)-style numbered lists — cancel text-indent so all items align left
+                        first_line = para_buf[0].lstrip()
+                        is_numbered_list = bool(re.match(r'^\([\u0E50-\u0E59]+\)', first_line))
+                        is_section_marker = bool(re.match(r'^\[[\u0E50-\u0E59]+\]', first_line))
+                        if len(text) >= PARA_MIN_CHARS or is_section_marker:
+                            cls = ' numbered-list' if is_numbered_list else ''
+                            wrapped_parts.append(f'<p class="{cls.strip()}">{text}</p>' if cls else f'<p>{text}</p>')
                         else:
                             wrapped_parts.append(f'<p class="structured-line">{text}</p>')
                         para_buf.clear()
@@ -186,23 +219,33 @@ class PageService:
                         flush_para()
                         marker = line.strip()
                         clean = re.sub(r'[()\[\]-]', '', marker).strip()
-                        # Attach inline to the previous <p> so it doesn't create a gap
-                        if wrapped_parts and wrapped_parts[-1].startswith('<p') and wrapped_parts[-1].endswith('</p>'):
-                            wrapped_parts[-1] = wrapped_parts[-1][:-4] + f' <sup id="ref-{clean}" class="footnote-ref">{marker}</sup></p>'
+                        if footnote_ids is None or clean in footnote_ids:
+                            if wrapped_parts and wrapped_parts[-1].startswith('<p') and wrapped_parts[-1].endswith('</p>'):
+                                wrapped_parts[-1] = wrapped_parts[-1][:-4] + f' <sup id="ref-{clean}" class="footnote-ref">{marker}</sup></p>'
+                            else:
+                                wrapped_parts.append(f'<p class="footnote-ref"><sup id="ref-{clean}">{marker}</sup></p>')
                         else:
-                            wrapped_parts.append(f'<p class="footnote-ref"><sup id="ref-{clean}">{marker}</sup></p>')
+                            if re.match(r'^\[', marker):
+                                wrapped_parts.append(f'<p>{marker}</p>')
+                            elif wrapped_parts and wrapped_parts[-1].startswith('<p') and wrapped_parts[-1].endswith('</p>'):
+                                wrapped_parts[-1] = wrapped_parts[-1][:-4] + f' {marker}</p>'
+                            else:
+                                wrapped_parts.append(f'<p class="structured-line">{marker}</p>')
                     elif re.match(abbrev_pattern, line):
-                        # (ย่อ) / ๓ (ย่อ) / (๓) (ย่อ) — split into separate sups:
-                        # number part → footnote-ref, (ย่อ) → abbrev-ref
                         flush_para()
                         m = re.match(
-                            r'^\s*([\u0E50-\u0E59]+|\([\u0E50-\u0E59]+\))?\s*(\(ย่อ\))\s*$',
+                            r'^\s*([๐-๙]+|\([๐-๙]+\))?\s*(\(ย่อ\))\s*$',
                             line.strip()
                         )
                         if m and m.group(1):
+                            clean_abbrev_id = re.sub(r'[()\[\]-]', '', m.group(1)).strip()
+                            if footnote_ids is None or clean_abbrev_id in footnote_ids:
+                                fn_sup = f'<sup class="footnote-ref">{m.group(1)}</sup>'
+                            else:
+                                fn_sup = m.group(1)
                             sup_html = (
-                                f'<sup class="footnote-ref">{m.group(1)}</sup>'
-                                f'\u202f<sup class="abbrev-ref">{m.group(2)}</sup>'
+                                f'{fn_sup}'
+                                f' <sup class="abbrev-ref">{m.group(2)}</sup>'
                             )
                         else:
                             sup_html = f'<sup class="abbrev-ref">(ย่อ)</sup>'
@@ -211,9 +254,15 @@ class PageService:
                         else:
                             wrapped_parts.append(sup_html)
 
-
+                    elif re.match(r'^\s*\[[๐-๙]+\]', line):
+                        # Section/paragraph marker like [๑๓๔], [๔], [๑]
+                        # Keep [x] with its content in the same <p> (don't wrap in <span>)
+                        if para_buf and len(para_buf) == 1 and re.match(r'^\s*<sup', para_buf[0]):
+                            para_buf[0] = para_buf[0] + ' ' + line
+                        else:
+                            flush_para()
+                            para_buf.append(line)
                     elif line.startswith('...'):
-                        # Continuation / repetition marker in Patthana — no paragraph indent
                         flush_para()
                         formatted_line = apply_inline_refs(line)
                         wrapped_parts.append(f'<p class="continuation-line">{formatted_line}</p>')
@@ -221,19 +270,35 @@ class PageService:
                     elif re.match(num_pattern, line):
                         flush_para()
                         wrapped_parts.append(f'<p class="numbered-line">{line}</p>')
-                    elif re.search(r'[ \t]{4,}', line):
-                        # Structural line — large internal spaces (tabular data)
+                    elif re.search(r'[ 	]{4,}', line):
                         flush_para()
-                        clean = re.sub(r'[ \t]{2,}', ' ', line).strip()
+                        clean = re.sub(r'[ 	]{2,}', ' ', line).strip()
                         wrapped_parts.append(f'<p class="structured-line">{clean}</p>')
+                    elif re.match(r'^\s*\((?:[๐-๙]+|\d+)\)', line):
+                        # Check if para already has [x] or (x) as its first item
+                        if para_buf:
+                            first = para_buf[0].lstrip()
+                            is_num_seq = bool(re.match(r'^(?:<sup[^>]*>.*?</sup>\s*)?(?:<span[^>]*>.*?</span>\s*)?(?:\[[๐-๙]+\]\s*)?\((?:[๐-๙]+|\d+)\)', first))
+                            if not is_num_seq:
+                                flush_para()
+                        _in_numbered_seq = True
+                        if para_buf:
+                            para_buf.append('<br>')
+                        para_buf.append(line)
+
                     elif re.search(r'(มี\s*[๐-๙\d]+\s*วาระ|\(ย่อ\)|\(อย่อ\)|ฯลฯ)\s*$', line):
-                        # Patthana/Abhidhamma terminal — flush trigger, then length decides class
                         para_buf.append(line)
                         flush_para()
                     else:
-                        # Regular body text — accumulate into current paragraph
+                        # If we were in a (x) numbered sequence and this line looks
+                        # like a closing sentence (starts with ภิกษุ), flush first.
+                        if _in_numbered_seq and re.match(r'^\s*ภิกษุ', line):
+                            flush_para()
+                            _in_numbered_seq = False
                         para_buf.append(line)
 
+
+        
                 flush_para()   # flush any remaining lines at end of section
 
         
@@ -294,32 +359,37 @@ class PageService:
                     if tm and tm not in end_markers:
                         end_markers.append(tm)
                 
-                # All Footnotes
-                # Strip line numbers first as they might precede the @ on the same line
-                fn_html = re.sub(r'<span\s+class="LineNumber">.*?</span>', '', raw_html)
-                lines = fn_html.split('\n')
-                current_fn = None
-                for line in lines:
-                    line_strip = line.strip()
-                    if not line_strip.startswith('@'):
-                        continue
-                        
-                    line_plain = re.sub(r'<[^>]+>', '', line_strip)
-                    # Match @ marker content
-                    # e.g. @๑ เนื้อหา... or @(๑) เนื้อหา...
-                    m = re.match(r'^@\s*([(\[]?[\u0E50-\u0E59\d]+[)\]-]?)\s*(.*)', line_plain)
-                    if m:
-                        marker = m.group(1).strip()
-                        text = m.group(2).strip()
-                        # Clean marker for lookup: [๑] -> ๑
-                        clean_marker = re.sub(r'[()\[\]-]', '', marker).strip()
-                        
-                        if clean_marker and not re.search(r'เชิงอรรถ', marker):
-                            current_fn = {"id": marker, "content": text}
-                            footnotes.append(current_fn)
-                    elif current_fn:
-                        # Continuation line starting with @
-                        current_fn["content"] += " " + line_plain.lstrip('@').strip()
+                # All Footnotes — query from reference_markers table
+                # (pre-indexed, much faster than scanning raw HTML)
+                try:
+                    cursor.execute("""
+                        SELECT marker_id, content FROM reference_markers
+                        WHERE volume_num = ? AND page_num = ? AND type = 'footnote'
+                        ORDER BY id
+                    """, (volume_number, page_number))
+                    for ref_row in cursor.fetchall():
+                        content = ref_row["content"].lstrip(". ")
+                        footnotes.append({"id": ref_row["marker_id"], "content": content})
+                except Exception:
+                    # Fallback: scan raw HTML if table query fails
+                    fn_html = re.sub(r'<span\s+class="LineNumber">.*?</span>', '', raw_html)
+                    lines = fn_html.split('\n')
+                    current_fn = None
+                    for line in lines:
+                        line_strip = line.strip()
+                        if not line_strip.startswith('@'):
+                            continue
+                        line_plain = re.sub(r'<[^>]+>', '', line_strip)
+                        m = re.match(r'^@\s*([(\[]?[\u0E50-\u0E59\d]+[)\]\-]?)\s*(.*)', line_plain)
+                        if m:
+                            marker = m.group(1).strip()
+                            text = m.group(2).strip()
+                            clean_marker = re.sub(r'[()\[\]-]', '', marker).strip()
+                            if clean_marker and not re.search(r'เชิงอรรถ', marker):
+                                current_fn = {"id": marker, "content": text}
+                                footnotes.append(current_fn)
+                        elif current_fn:
+                            current_fn["content"] += " " + line_plain.lstrip('@').strip()
 
             return {
                 "id": row["id"],
@@ -329,7 +399,9 @@ class PageService:
                 "total_pages": row["total_pages"] or 0,
                 "content_text": "" if is_blank else cleaned,
                 "content_html": "" if is_blank else raw_html,
-                "content_html_formatted": "" if is_blank else self.format_content_html(raw_html),
+                "content_html_formatted": "" if is_blank else self.format_content_html(
+                    raw_html, footnote_ids={f["id"] for f in footnotes}
+                ),
                 "title": row["title"],
                 "sections": sections,
                 "end_markers": end_markers,
@@ -396,7 +468,7 @@ class PageService:
             """, (volume_number, page_number, clean_id))
             row = cursor.fetchone()
             if row:
-                return row["content"]
+                return row["content"].lstrip(". ")
             
             # 2. Try window search (+/- 2 pages) to handle markers defined nearby
             # This is common in MCU where a footnote ref on page X might be defined at the start of page X+1
@@ -412,6 +484,6 @@ class PageService:
             """, (volume_number, page_number - 2, page_number + 2, clean_id, page_number))
             row = cursor.fetchone()
             if row:
-                return row["content"]
-                
+                return row["content"].lstrip(". ")
+            
             return None

webapp/tipitaka-api/test_all_volumes.py

@@ -0,0 +1,101 @@
+"""Fast volume check - fetch page data only, no popup API calls (huge savings)."""
+import json, re, urllib.request, sys
+
+API = "http://localhost:8000/api/pages"
+
+def get_json(url, timeout=8):
+    try:
+        resp = urllib.request.urlopen(url, timeout=timeout)
+        return json.loads(resp.read())
+    except Exception as e:
+        return {"_error": str(e)}
+
+def lookup(vol, page, fid):
+    """Quick popup test."""
+    import urllib.parse
+    url = f"http://localhost:8000/api/reference/lookup?vol={vol}&page={page}&type=footnote&id={urllib.parse.quote(fid)}"
+    try:
+        resp = urllib.request.urlopen(url, timeout=5)
+        d = json.loads(resp.read())
+        return "OK" if d.get("found") else "NF"
+    except:
+        return "ERR"
+
+print(f"{'Vol':>3} {'Pg':>3} {'FN':>3} {'Sup':>3}  {'First FN':<50}  {'Status'}")
+print("=" * 80)
+
+all_data = {}  # vol -> (page, fn_count, sup_count, first_fn, all_fns)
+errors = []
+
+for vol in range(1, 46):
+    d = None
+    used = None
+    for pn in range(1, 4):
+        d = get_json(f"{API}/{vol}/{pn}")
+        if "_error" in d:
+            print(f"{vol:>3}  ---  ---  ---  ERROR: {d['_error']:<50}  ❌")
+            errors.append(vol)
+            d = None
+            break
+        fns = d.get("footnotes", [])
+        blank = d.get("is_blank", False)
+        if fns or not blank or pn == 3:
+            used = pn
+            break
+        # blank page with no footnotes -> try next
+    if d is None or d.get("_error"):
+        continue
+
+    fns = d.get("footnotes", [])
+    html = d.get("content_html_formatted", "")
+    sups = re.findall(r'<sup[^>]*>.*?</sup>', html)
+    fn_count = len(fns)
+    sup_count = len(sups)
+    first_fn = (fns[0]["content"][:50].replace("\n", " ")) if fns else "(none)"
+
+    # Check for anomalies
+    issues = []
+    if fn_count > 0 and sup_count == 0:
+        issues.append("NOSUP")
+    if fn_count > 0 and sup_count > 0 and sup_count < fn_count:
+        # Some markers might be different type - note for detail
+        issues.append(f"Sup<FN")
+
+    if issues:
+        iss = " | ".join(issues)
+        print(f"{vol:>3} {used:>3} {fn_count:>3} {sup_count:>3}  {first_fn:<50}  ⚠️  {iss}")
+        all_data[vol] = (used, fn_count, sup_count, fns, html)
+    else:
+        print(f"{vol:>3} {used:>3} {fn_count:>3} {sup_count:>3}  {first_fn:<50}  ✅")
+        all_data[vol] = (used, fn_count, sup_count, fns, html)
+
+print("=" * 80)
+good = 45 - len(errors) - len([v for v in all_data if v in all_data and v not in errors])
+
+issues_list = [v for v in all_data if v not in errors]
+issue_vols = [v for v in issues_list if all_data[v][1] > 0 and all_data[v][2] == 0]  # FN>0 but Sup=0
+
+print(f"\nChecked: 45 volumes")
+print(f"Full OK: {45 - len(errors) - len(issues_list)}")
+print(f"Has footnotes: {sum(1 for v in all_data if v not in errors and all_data[v][1] > 0)}")
+print(f"Has NO footnotes: {sum(1 for v in all_data if v not in errors and all_data[v][1] == 0)}")
+
+if issue_vols:
+    print(f"\n🔴 Volumes with FN>0 but Sup=0 (NO sup tags!): {len(issue_vols)}")
+    for v in issue_vols:
+        pg, fnc, spc, fns, html = all_data[v]
+        print(f"  Vol {v} Page {pg}: {fnc} footnotes, {spc} sup tags")
+        for fn in fns:
+            print(f"    [{fn['id']}] {fn['content'][:80]}")
+        # Test popup
+        for fn in fns[:1]:
+            r = lookup(v, pg, fn["id"])
+            print(f"    popup test: {r}")
+
+# Check volumes with Sup<FN 
+partial = [v for v in all_data if v not in errors and all_data[v][1] > 0 and all_data[v][2] > 0 and all_data[v][2] < all_data[v][1]]
+if partial:
+    print(f"\n🟡 Volumes with Sup<FN (some markers not converted to sup):")
+    for v in partial:
+        pg, fnc, spc, fns, html = all_data[v]
+        print(f"  Vol {v} Page {pg}: {fnc} FN, {spc} Sup")

webapp/tipitaka-web/src/components/common/ErrorBoundary.tsx

@@ -1,4 +1,4 @@
-import React, { Component, ErrorInfo, ReactNode } from 'react';
+import { Component, type ErrorInfo, type ReactNode } from 'react';
 
 interface Props {
   children: ReactNode;

webapp/tipitaka-web/src/components/layout/ReaderPanel.tsx

@@ -241,7 +241,7 @@ const ReaderPanel: React.FC = () => {
                     <svg className="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
                       <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M16 4v12l-4-2-4 2V4M6 20h12a2 2 0 002-2V6a2 2 0 00-2-2H6a2 2 0 00-2 2v12a2 2 0 002 2z" />
                     </svg>
-                    เชิงอรรถ (Footnotes)
+                    เชิงอรรถ
                   </h5>
                   <div className="space-y-4">
                     {content.footnotes.map((fn: any, idx: number) => {

webapp/tipitaka-web/src/components/reader/ReferencePopup.tsx

@@ -16,18 +16,47 @@ interface Props {
   onJump?: (id: string) => void;
 }
 
+const MIN_W = 240;
+const MAX_W = 600;
+const INIT_W = 320;
+
 const ReferencePopup: React.FC<Props> = ({ pos, onClose, onJump }) => {
   const popupRef = useRef<HTMLDivElement>(null);
 
   const [content, setContent] = React.useState<string | null>(null);
   const [isLoading, setIsLoading] = React.useState(false);
+  const [popupFontSize, setPopupFontSize] = React.useState(15);
+  const [popupWidth, setPopupWidth] = React.useState(INIT_W);
+  const [popupHeight, setPopupHeight] = React.useState<number | null>(null);
+  const [visible, setVisible] = React.useState(false);
+
+  // ── Position state (top-left of popup) ──
+  const [posX, setPosX] = React.useState(0);
+  const [posY, setPosY] = React.useState(0);
+  const [showArrow, setShowArrow] = React.useState(false);
+  const [arrowShift, setArrowShift] = React.useState(0);
+  const [flipUp, setFlipUp] = React.useState(false);
+
+  // ── Drag state ──
+  const dragging = useRef(false);
+  const dragStart = useRef({ x: 0, y: 0, px: 0, py: 0 });
 
+  // ── Resize state ──
+  const resizing = useRef(false);
+  const resizeStart = useRef({ x: 0, y: 0, w: INIT_W, h: 0 });
+
+  // ── Initial positioning when pos changes ──
   useEffect(() => {
     if (!pos) {
+      setVisible(false);
       setContent(null);
       return;
     }
 
+    setPopupWidth(INIT_W);
+    setPopupHeight(null);
+
+    // Fetch content
     const fetchRef = async () => {
       setIsLoading(true);
       try {
@@ -43,23 +72,101 @@ const ReferencePopup: React.FC<Props> = ({ pos, onClose, onJump }) => {
         setIsLoading(false);
       }
     };
-
     fetchRef();
+
+    // Calculate initial position (top-left of popup, not centered)
+    requestAnimationFrame(() => {
+      const viewW = window.innerWidth;
+      const viewH = window.innerHeight;
+      const halfW = INIT_W / 2;
+      const EDGE = 12;
+
+      // Start: sup center → convert to top-left
+      let left = pos.x - halfW;
+      let top = pos.y + 6; // 6px below sup
+      let flip = false;
+
+      // Horizontal clamp
+      if (left < EDGE) left = EDGE;
+      else if (left + INIT_W > viewW - EDGE) left = viewW - INIT_W - EDGE;
+
+      // Arrow horizontal shift
+      const centerX = left + INIT_W / 2;
+      let aShift = pos.x - centerX;
+
+      // Vertical flip if near bottom
+      const estH = 260;
+      if (pos.y + estH + 20 > viewH) {
+        flip = true;
+        top = pos.y - 6 - estH;
+        if (top < EDGE) top = EDGE;
+      }
+
+      setPosX(left);
+      setPosY(top);
+      setArrowShift(aShift);
+      setFlipUp(flip);
+      setShowArrow(true);
+      setVisible(true);
+
+      // Fine-tune after render
+      setTimeout(() => {
+        if (popupRef.current) {
+          const actualH = popupRef.current.offsetHeight;
+          if (flip && pos.y - actualH - 6 < EDGE) {
+            setPosY(EDGE);
+            setFlipUp(false);
+          } else if (!flip && pos.y + actualH + 20 > viewH) {
+            setPosY(Math.max(EDGE, viewH - actualH - 10));
+            setFlipUp(true);
+          }
+        }
+      }, 60);
+    });
   }, [pos]);
 
+  // ── Drag handler ──
+  const onDragStart = React.useCallback((e: React.MouseEvent) => {
+    e.preventDefault();
+    dragging.current = true;
+    dragStart.current = { x: e.clientX, y: e.clientY, px: posX, py: posY };
+    setShowArrow(false);
+    const onMove = (ev: MouseEvent) => {
+      if (!dragging.current) return;
+      setPosX(dragStart.current.px + (ev.clientX - dragStart.current.x));
+      setPosY(dragStart.current.py + (ev.clientY - dragStart.current.y));
+    };
+    const onUp = () => { dragging.current = false; };
+    document.addEventListener('mousemove', onMove);
+    document.addEventListener('mouseup', onUp, { once: true });
+  }, [posX, posY]);
+
+  // ── Resize handler ──
+  const onResizeStart = React.useCallback((e: React.MouseEvent) => {
+    e.preventDefault();
+    e.stopPropagation();
+    resizing.current = true;
+    resizeStart.current = { x: e.clientX, y: e.clientY, w: popupWidth, h: popupHeight || 300 };
+    const onMove = (ev: MouseEvent) => {
+      if (!resizing.current) return;
+      const newW = Math.max(MIN_W, Math.min(MAX_W, resizeStart.current.w + (ev.clientX - resizeStart.current.x)));
+      const newH = Math.max(150, resizeStart.current.h + (ev.clientY - resizeStart.current.y));
+      setPopupWidth(newW);
+      setPopupHeight(newH);
+    };
+    const onUp = () => { resizing.current = false; };
+    document.addEventListener('mousemove', onMove);
+    document.addEventListener('mouseup', onUp, { once: true });
+  }, [popupWidth, popupHeight]);
+
+  // ── Click outside ──
   useEffect(() => {
-    // Click outside popup → close
     const onMouseDown = (e: MouseEvent | TouchEvent) => {
-      // Don't close if they clicked on another reference (it will update pos)
       const target = e.target as HTMLElement;
-      if (target.tagName?.toLowerCase() === 'sup' && (target.classList.contains('abbrev-ref') || target.classList.contains('footnote-ref'))) {
-        return;
-      }
-      if (popupRef.current && !popupRef.current.contains(e.target as Node)) {
-        onClose();
-      }
+      if (target.tagName?.toLowerCase() === 'sup' &&
+          (target.classList.contains('abbrev-ref') || target.classList.contains('footnote-ref'))) return;
+      if (popupRef.current && !popupRef.current.contains(e.target as Node)) onClose();
     };
-
     document.addEventListener('mousedown', onMouseDown);
     document.addEventListener('touchstart', onMouseDown);
     return () => {
@@ -74,43 +181,75 @@ const ReferencePopup: React.FC<Props> = ({ pos, onClose, onJump }) => {
         <motion.div
           ref={popupRef}
           key="ref-popup"
-          initial={{ opacity: 0, scale: 0.95, y: 8 }}
-          animate={{ opacity: 1, scale: 1, y: 0 }}
-          exit={{ opacity: 0, scale: 0.95, y: 8 }}
-          transition={{ duration: 0.15, ease: 'easeOut' }}
+          initial={{ opacity: 0, scale: 0.95 }}
+          animate={{
+            opacity: visible ? 1 : 0,
+            scale: visible ? 1 : 0.95,
+          }}
+          exit={{ opacity: 0, scale: 0.95 }}
+          transition={{ duration: 0.12, ease: 'easeOut' }}
           style={{
             position: 'fixed',
-            left: pos.x,
-            top: pos.y,
-            transform: 'translate(-50%, 8px)',
+            left: posX,
+            top: posY,
             zIndex: 9998,
+            width: popupWidth,
+            height: popupHeight || 'auto',
+            maxHeight: popupHeight ? 'none' : (flipUp ? '50vh' : 'calc(100vh - 120px)'),
           }}
-          className="w-80 rounded-2xl shadow-[0_20px_50px_rgba(0,0,0,0.5)] bg-[#1a1a2e]/90 backdrop-blur-xl border border-white/10 text-[#e8e4da] overflow-hidden"
+          className="rounded-2xl shadow-[0_20px_50px_rgba(0,0,0,0.5)] bg-[#1a1a2e]/95 backdrop-blur-xl border border-white/10 text-[#e8e4da] overflow-hidden flex flex-col"
         >
           {/* Gradient top bar */}
-          <div className="h-1 bg-gradient-to-r from-[#c8860a]/0 via-[#c8860a] to-[#c8860a]/0" />
-          
-          <div className="p-4">
-            <div className="flex items-center justify-between mb-3 pb-2 border-b border-white/5">
-              <div className="flex items-center gap-2">
-                <span className="bg-[#c8860a] text-[#1a1a2e] text-xs font-bold px-1.5 py-0.5 rounded">
+          <div className="h-1 bg-gradient-to-r from-[#c8860a]/0 via-[#c8860a] to-[#c8860a]/0 shrink-0" />
+
+          <div className="p-4 flex flex-col flex-1 min-h-0">
+            {/* Header — drag handle */}
+            <div
+              onMouseDown={onDragStart}
+              className="flex items-center justify-between mb-3 pb-2 border-b border-white/5 shrink-0 cursor-grab active:cursor-grabbing select-none"
+            >
+              <div className="flex items-center gap-2 min-w-0">
+                {/* Drag indicator */}
+                <svg className="w-3.5 h-3.5 text-white/15 shrink-0" viewBox="0 0 24 24" fill="currentColor">
+                  <circle cx="9" cy="5" r="1.5"/><circle cx="15" cy="5" r="1.5"/>
+                  <circle cx="9" cy="12" r="1.5"/><circle cx="15" cy="12" r="1.5"/>
+                  <circle cx="9" cy="19" r="1.5"/><circle cx="15" cy="19" r="1.5"/>
+                </svg>
+                <span className="bg-[#c8860a] text-[#1a1a2e] text-xs font-bold px-1.5 py-0.5 rounded shrink-0">
                   {pos.id}
                 </span>
-                <span className="text-xs font-medium text-white/50 tracking-wide uppercase">
-                  {pos.type === 'abbrev' ? 'Abbreviation' : 'Footnote'}
+                <span className="text-xs font-medium text-white/50 tracking-wide uppercase truncate">
+                  {pos.type === 'abbrev' ? 'คำย่อ' : 'เชิงอรรถ'}
                 </span>
               </div>
-              <button 
-                onClick={onClose}
-                className="text-white/30 hover:text-white/70 transition-colors"
-              >
-                <svg className="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor">
-                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" />
-                </svg>
-              </button>
+              <div className="flex items-center gap-1 shrink-0">
+                <button onClick={() => setPopupFontSize(s => Math.max(s - 2, 11))}
+                  className="text-white/30 hover:text-white/70 transition-colors p-0.5" title="ย่อ">
+                  <svg className="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                    <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M18 10h-4m-4 0H6" />
+                  </svg>
+                </button>
+                <button onClick={() => setPopupFontSize(15)}
+                  className="text-[9px] text-white/20 hover:text-white/50 transition-colors font-mono w-3.5 text-center" title="รีเซ็ต">
+                  A
+                </button>
+                <button onClick={() => setPopupFontSize(s => Math.min(s + 2, 28))}
+                  className="text-white/30 hover:text-white/70 transition-colors p-0.5" title="ขยาย">
+                  <svg className="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                    <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 6v6m0 0v6m0-6h6m-6 0H6" />
+                  </svg>
+                </button>
+                <button onClick={onClose}
+                  className="text-white/30 hover:text-white/70 transition-colors ml-1">
+                  <svg className="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                    <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" />
+                  </svg>
+                </button>
+              </div>
             </div>
-            
-            <div className="max-h-60 overflow-y-auto custom-scrollbar pr-1">
+
+            {/* Content */}
+            <div className="overflow-y-auto custom-scrollbar pr-1 flex-1 min-h-0">
               {isLoading ? (
                 <div className="space-y-3 py-1">
                   <div className="h-3 bg-white/10 rounded-full w-full animate-pulse" />
@@ -118,27 +257,25 @@ const ReferencePopup: React.FC<Props> = ({ pos, onClose, onJump }) => {
                   <div className="h-3 bg-white/10 rounded-full w-4/6 animate-pulse" />
                 </div>
               ) : (
-                <div className="text-[15px] leading-relaxed font-light text-white/90">
+                <div className="leading-relaxed font-light text-white/90"
+                  style={{ fontSize: `${popupFontSize}px` }}>
                   {content || (
                     <span className="text-white/40 italic">ไม่พบข้อมูลอ้างอิง</span>
                   )}
                 </div>
               )}
             </div>
-            
+
             {pos.type === 'abbrev' && !isLoading && (
-              <div className="mt-3 pt-2 border-t border-white/5 flex items-center gap-1.5">
+              <div className="mt-3 pt-2 border-t border-white/5 flex items-center gap-1.5 shrink-0">
                 <div className="w-1.5 h-1.5 rounded-full bg-[#c8860a] animate-pulse" />
-                <span className="text-[10px] text-white/30 uppercase tracking-tighter">AI Expanded</span>
+                <span className="text-[10px] text-white/30 uppercase tracking-tighter">AI ขยายความ</span>
               </div>
             )}
-
             {pos.type === 'footnote' && !isLoading && onJump && (
-              <div className="mt-4 pt-3 border-t border-white/5">
-                <button
-                  onClick={() => onJump(pos.id)}
-                  className="w-full py-2 px-3 rounded-xl bg-white/5 hover:bg-white/10 text-[#c8860a] text-xs font-bold transition-all flex items-center justify-center gap-2 group"
-                >
+              <div className="mt-4 pt-3 border-t border-white/5 shrink-0">
+                <button onClick={() => onJump(pos.id)}
+                  className="w-full py-2 px-3 rounded-xl bg-white/5 hover:bg-white/10 text-[#c8860a] text-xs font-bold transition-all flex items-center justify-center gap-2 group">
                   <svg className="w-3.5 h-3.5 transform group-hover:translate-y-0.5 transition-transform" fill="none" viewBox="0 0 24 24" stroke="currentColor">
                     <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 14l-7 7m0 0l-7-7m7 7V3" />
                   </svg>
@@ -148,11 +285,27 @@ const ReferencePopup: React.FC<Props> = ({ pos, onClose, onJump }) => {
             )}
           </div>
 
-          {/* Tail arrow */}
-          <div
-            className="pointer-events-none absolute left-1/2 -translate-x-1/2 -top-[5px]
-                       w-2.5 h-2.5 bg-[#1a1a2e] border-l border-t border-white/10 rotate-45"
-          />
+          {/* Resize handle */}
+          <div onMouseDown={onResizeStart}
+            className="absolute bottom-0 right-0 w-5 h-5 cursor-se-resize group">
+            <svg className="w-full h-full text-white/20 group-hover:text-[#c8860a] transition-colors"
+              viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth={2}
+              strokeLinecap="round" strokeLinejoin="round">
+              <path d="M21 15v4a2 2 0 01-2 2h-4" />
+              <path d="M21 3v4a2 2 0 01-2 2h-4" />
+            </svg>
+          </div>
+
+          {/* Tail arrow — hidden after manual drag */}
+          {showArrow && (
+            flipUp ? (
+              <div className="pointer-events-none absolute left-1/2 -bottom-[5px] w-2.5 h-2.5 bg-[#1a1a2e] border-r border-b border-white/10 -rotate-45"
+                style={{ marginLeft: arrowShift }} />
+            ) : (
+              <div className="pointer-events-none absolute left-1/2 -top-[5px] w-2.5 h-2.5 bg-[#1a1a2e] border-l border-t border-white/10 rotate-45"
+                style={{ marginLeft: arrowShift }} />
+            )
+          )}
         </motion.div>
       )}
     </AnimatePresence>

webapp/tipitaka-web/src/index.css

@@ -73,6 +73,12 @@ body {
   margin-bottom: 0.1rem !important;
 }
 
+/* Numbered-list paragraphs (๑)/(๒)/(๓) — cancel text-indent so all items align left */
+.reader-content p.numbered-list,
+.content-body p.numbered-list {
+  text-indent: 0 !important;
+}
+
 
 
 /* Continuation / repetition lines starting with "..." — no paragraph indent */