Update app.py

app.py

@@ -1,39 +1,27 @@
-# app.py — 전 코드 기반(안정 치환) + lxml 기반 "단일 HWPX 병합" 출력
-import io
-import json
-import html
-import re
-import zipfile
-from typing import Dict, Tuple, List, Optional
-
-import pandas as pd
 import streamlit as st
+import pandas as pd
+import io, zipfile, re, html, json
+from typing import Dict, Tuple
 
-# =============== Streamlit ===============
-st.set_page_config(page_title="📦보존박스 라벨 생성기", layout="wide")
-st.title("📦 보존박스 라벨 생성기 📦")
-
+st.set_page_config(page_title="📦 보존상자 라벨 생성기", layout="wide")
+st.title("📦 보존상자 라벨 생성기 📦")
 
-# =============== 데이터 유틸 ===============
+# -------------------- 데이터 유틸 --------------------
 def _year_range(series: pd.Series) -> str:
     s = series.astype(str).fillna("")
     v = s[~s.isin(["", "0", "0000"])]
-    if v.empty:
-        return "0000-0000"
+    if v.empty: return "0000-0000"
     nums = pd.to_numeric(v, errors="coerce").dropna().astype(int)
-    if nums.empty:
-        return "0000-0000"
+    if nums.empty: return "0000-0000"
     return f"{nums.min():04d}-{nums.max():04d}"
 
-
 def build_rows(df: pd.DataFrame) -> pd.DataFrame:
-    """박스번호 기준 대표 메타 + 목록(여러 줄) + 생산연도 범위 생성"""
     df = df.copy()
     df["박스번호"] = df["박스번호"].astype(str).str.zfill(4)
     if "제목" in df.columns:
         df["제목"] = df["제목"].astype(str)
 
-    # 생산연도(범위)
+    # 생산연도(범위) = 종료연도 그룹 범위
     if "종료연도" in df.columns:
         yr = df.groupby("박스번호")["종료연도"].apply(_year_range).reset_index()
         yr.columns = ["박스번호", "생산연도"]
@@ -44,57 +32,116 @@ def build_rows(df: pd.DataFrame) -> pd.DataFrame:
     has_mgmt = "관리번호" in df.columns
     lists = []
     for b, g in df.groupby("박스번호"):
-        lines = [
-            f"- {r['관리번호']} {r.get('제목','')}" if has_mgmt else f"- {r.get('제목','')}"
-            for _, r in g.iterrows()
-        ]
+        lines = [f"- {r['관리번호']} {r.get('제목','')}" if has_mgmt else f"- {r.get('제목','')}"
+                 for _, r in g.iterrows()]
         lists.append({"박스번호": b, "목록": "\r\n".join(lines)})
     list_df = pd.DataFrame(lists)
 
     # 대표 메타
-    meta_cols = ["박스번호", "종료연도", "보존기간", "단위업무", "기록물철", "제목"]
+    meta_cols = ["박스번호","종료연도","보존기간","단위업무","기록물철","제목"]
     meta_exist = [c for c in meta_cols if c in df.columns]
-    if meta_exist:
-        meta = df.groupby("박스번호", as_index=False).first()[meta_exist]
-    else:
-        meta = pd.DataFrame({"박스번호": df["박스번호"].unique()})
+    meta = df.groupby("박스번호", as_index=False).first()[meta_exist] if meta_exist \
+          else pd.DataFrame({"박스번호": df["박스번호"].unique()})
 
     merged = meta.merge(list_df, on="박스번호", how="left").merge(yr, on="박스번호", how="left")
     return merged
 
-
-# =============== 치환 유틸 (전 코드의 안정 버전) ===============
+# -------------------- 치환 유틸 --------------------
 FIELD_PAIR_RE_TMPL = (
-    r'<(?P<prefix>[a-zA-Z0-9_]+):fieldBegin\b[^>]*\bname="{name}"[^>]*/>'
+    r'<(?P<fprefix>[a-zA-Z0-9_]+):fieldBegin\b[^>]*\bname="{name}"[^>]*/>'
     r'(.*?)'
-    r'<(?P=prefix):fieldEnd\b[^>]*/>'
+    r'<(?P=fprefix):fieldEnd\b[^>]*/>'
 )
 TOKEN_FMT = "{{{{{key}}}}}"
 
+# 문단(<*:p>) 탐색 패턴
+PARA_RE = re.compile(
+    r'<(?P<pprefix>[a-zA-Z0-9_]+):p(?P<pattrs>[^>]*)>(?P<pbody>.*?)</(?P=pprefix):p>',
+    re.DOTALL
+)
 
-def _run_for_plain(text: str) -> str:
+# 원본 run 스타일을 추출하는 함수
+def _extract_run_style(body: str, pprefix: str) -> str:
+    """문단 내용에서 첫 번째 run 요소의 스타일을 추출"""
+    run_pattern = re.compile(
+        rf'<{pprefix}:run[^>]*>.*?</{pprefix}:run>',
+        re.DOTALL
+    )
+    match = run_pattern.search(body)
+    if match:
+        return match.group(0)
+    return f'<{pprefix}:run><{pprefix}:t><//{pprefix}:t></{pprefix}:run>'
+
+# 문단 하나를 같은 스타일로 복제해주는 헬퍼 (스타일 보존)
+def _make_para_with_style(pprefix: str, pattrs: str, text: str, original_run: str) -> str:
+    esc = html.escape("" if text is None else str(text))
+    
+    # 원본 run에서 텍스트 부분만 교체
+    text_pattern = re.compile(rf'(<{pprefix}:t[^>]*>)[^<]*(</{pprefix}:t>)')
+    new_run = text_pattern.sub(rf'\g<1>{esc}\g<2>', original_run)
+    
+    # 만약 텍스트 노드가 없다면 기본 형태로
+    if new_run == original_run:
+        t_pattern = re.compile(rf'(<{pprefix}:run[^>]*>)(.*?)(</{pprefix}:run>)', re.DOTALL)
+        new_run = t_pattern.sub(rf'\g<1><{pprefix}:t>{esc}</{pprefix}:t>\g<3>', original_run)
+    
+    return f'<{pprefix}:p{pattrs}>{new_run}</{pprefix}:p>'
+
+def _split_lines(val) -> list:
+    if val is None: return [""]
+    return str(val).replace("\r\n","\n").split("\n")
+
+def _replace_para_multiline(xml: str, key: str, value: str, dbg: dict) -> str:
+    """
+    key가 포함된 '부모 문단 전체'를, 값의 각 줄을 담은 여러 문단으로 교체.
+    원본 스타일을 유지하면서 교체.
+    """
+    pair_pat = re.compile(FIELD_PAIR_RE_TMPL.format(name=re.escape(key)), re.DOTALL)
+    tnode_pat = re.compile(rf'<(?P<p>[a-zA-Z0-9_]+):t[^>]*>[^<]*{re.escape(key)}[^<]*</(?P=p):t>', re.DOTALL)
+    token_str = TOKEN_FMT.format(key=key)
+
+    def para_repl(m):
+        body = m.group("pbody")
+        if not (pair_pat.search(body) or tnode_pat.search(body) or (token_str in body)):
+            return m.group(0)
+
+        lines = _split_lines(value)
+        pprefix = m.group("pprefix")
+        pattrs  = m.group("pattrs")
+        
+        # 원본 run 스타일 추출
+        original_run = _extract_run_style(body, pprefix)
+        
+        # 각 줄에 대해 원본 스타일을 유지하면서 새 문단 생성
+        new_paras = "".join(_make_para_with_style(pprefix, pattrs, ln, original_run) for ln in lines)
+        dbg["para_hits"][key] = dbg["para_hits"].get(key, 0) + 1
+        return new_paras
+
+    xml2 = PARA_RE.sub(para_repl, xml)
+    if xml2 != xml:
+        dbg["touched"] = True
+    return xml2
+
+def _runs_plain(text: str) -> str:
     return f"<hp:run><hp:t>{html.escape('' if text is None else str(text))}</hp:t></hp:run>"
 
-
-def _run_for_list(text: str) -> str:
-    if text is None:
-        return ""
-    lines = str(text).replace("\r\n", "\n").split("\n")
-    parts = []
-    for i, ln in enumerate(lines):
-        if i > 0:
-            parts.append("<hp:lineBreak/>")
-        parts.append(f"<hp:run><hp:t>{html.escape(ln)}</hp:t></hp:run>")
-    return "".join(parts)
-
-
 def _apply_to_xml(xml: str, mapping: Dict[str, str], dbg: dict) -> str:
     changed_any = False
 
-    # 1) 필드쌍 치환 (접두어 와일드카드)
+    # 0) 다중줄 키는 먼저 "부모 문단 교체"로 처리 (업무명은 제외하여 폰트 문제 해결)
+    multi_key = re.compile(r"^(목록|list|제목)\d+$", re.IGNORECASE)
+    for k, v in mapping.items():
+        if multi_key.match(k):
+            xml_new = _replace_para_multiline(xml, k, v, dbg)
+            if xml_new != xml:
+                xml = xml_new
+                changed_any = True
+
+    # 1) 필드쌍(인라인) 치환 — 단일줄 키만
     for k, v in mapping.items():
-        is_list = bool(re.match(r"^(목록|list)\d+$", k, re.IGNORECASE))
-        replacement = _run_for_list(v) if is_list else _run_for_plain(v)
+        if multi_key.match(k):
+            continue
+        replacement = _runs_plain(v)
         pat = re.compile(FIELD_PAIR_RE_TMPL.format(name=re.escape(k)), re.DOTALL)
         xml_new, n = pat.subn(replacement, xml)
         if n:
@@ -102,16 +149,33 @@ def _apply_to_xml(xml: str, mapping: Dict[str, str], dbg: dict) -> str:
             xml = xml_new
             changed_any = True
 
-    # 2) 토큰 치환 ({{키}})
+    # 2) 순수 텍스트 자리표시자(<*:t>키</*:t>) 부분치환 — 단일줄 키만
+    tnode_all = re.compile(
+        r'(<(?P<prefix>[a-zA-Z0-9_]+):t[^>]*>)([^<]*?)</(?P=prefix):t>',
+        re.DOTALL
+    )
+    for k, v in mapping.items():
+        if multi_key.match(k):
+            continue
+        def repl_tnode(m):
+            text_node = m.group(3)
+            if k not in text_node:
+                return m.group(0)
+            new_text = html.escape(text_node.replace(k, "" if v is None else str(v)))
+            return f"{m.group(1)}{new_text}</{m.group('prefix')}:t>"
+        xml2 = tnode_all.sub(repl_tnode, xml)
+        if xml2 != xml:
+            dbg["text_hits"][k] = dbg["text_hits"].get(k, 0) + 1
+            xml = xml2
+            changed_any = True
+
+    # 3) 토큰 치환 — 단일줄 키만
     for k, v in mapping.items():
+        if multi_key.match(k):
+            continue
         tok = TOKEN_FMT.format(key=k)
         if tok in xml:
-            rep = (
-                _run_for_list(v)
-                if re.match(r"^(목록|list)\d+$", k, re.IGNORECASE)
-                else html.escape("" if v is None else str(v))
-            )
-            xml = xml.replace(tok, rep)
+            xml = xml.replace(tok, html.escape("" if v is None else str(v)))
             dbg["token_hits"][k] = dbg["token_hits"].get(k, 0) + 1
             changed_any = True
 
@@ -119,21 +183,25 @@ def _apply_to_xml(xml: str, mapping: Dict[str, str], dbg: dict) -> str:
         dbg["files_touched"] = True
     return xml
 
-
-def replace_in_hwpx(hwpx_bytes: bytes, mapping: Dict[str, str]) -> Tuple[bytes, dict]:
-    """HWPX(zip) 내부 모든 XML에 치환 적용 — 안정 버전"""
-    import time
-
-    dbg = {"field_hits": {}, "token_hits": {}, "touched_files": []}
+def replace_in_hwpx(hwpx_bytes: bytes, mapping: Dict[str,str]) -> Tuple[bytes, dict]:
+    import stat, time
+    dbg = {"para_hits":{}, "field_hits":{}, "text_hits":{}, "token_hits":{}, "touched_files": []}
     zin = zipfile.ZipFile(io.BytesIO(hwpx_bytes), "r")
     out_buf = io.BytesIO()
-    zout = zipfile.ZipFile(out_buf, "w")
+    zout = zipfile.ZipFile(out_buf, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=6)
+
+    # 현재 시간
+    now = time.localtime()
 
     # mimetype 무압축 + 맨앞
     names = zin.namelist()
     if "mimetype" in names:
         zi = zipfile.ZipInfo("mimetype")
         zi.compress_type = zipfile.ZIP_STORED
+        # 완전히 새로운 ZipInfo로 읽기전용 방지
+        zi.external_attr = 0o100666 << 16  # 일반 파일 + 모든 권한
+        zi.create_system = 0  # DOS/Windows
+        zi.date_time = now[:6]
         zout.writestr(zi, zin.read("mimetype"))
 
     for e in zin.infolist():
@@ -144,18 +212,22 @@ def replace_in_hwpx(hwpx_bytes: bytes, mapping: Dict[str, str]) -> Tuple[bytes,
             try:
                 s = data.decode("utf-8", errors="ignore")
                 before = s
-                s = _apply_to_xml(
-                    s,
-                    mapping,
-                    {"field_hits": dbg["field_hits"], "token_hits": dbg["token_hits"], "files_touched": False},
-                )
+                s = _apply_to_xml(s, mapping, {"para_hits":dbg["para_hits"], "field_hits":dbg["field_hits"],
+                                               "text_hits":dbg["text_hits"], "token_hits":dbg["token_hits"],
+                                               "files_touched":False})
                 if s != before:
                     dbg["touched_files"].append(e.filename)
                 data = s.encode("utf-8")
             except Exception:
                 pass
+        
+        # 완전히 새로운 ZipInfo 생성으로 읽기전용 방지
         zi = zipfile.ZipInfo(e.filename)
         zi.compress_type = zipfile.ZIP_DEFLATED
+        zi.external_attr = 0o100666 << 16  # 일반 파일 + 모든 권한
+        zi.create_system = 0  # DOS/Windows 시스템
+        zi.date_time = now[:6]  # 현재 시간
+        zi.flag_bits = 0  # 특별한 플래그 없음
         zout.writestr(zi, data)
 
     zout.close()
@@ -163,141 +235,27 @@ def replace_in_hwpx(hwpx_bytes: bytes, mapping: Dict[str, str]) -> Tuple[bytes,
     zin.close()
     return out_buf.getvalue(), dbg
 
-
-# =============== 단일 HWPX 병합(lxml) ===============
-def merge_filled_hwpx_list_to_single(hwpx_list: list[bytes]) -> bytes:
-    """
-    여러 개의 '이미 채워진' HWPX 바이트들을 받아
-    첫 번째 문서에 뒤 문서의 페이지와 본문 블록(<p> 등)을 안전하게 병합한다.
-    XPath는 local-name()을 사용하여 네임스페이스 이슈를 회피한다.
-    """
-    from lxml import etree
-    import io, zipfile
-
-    if not hwpx_list:
-        raise ValueError("병합할 HWPX가 없습니다.")
-
-    # 첫 문서를 베이스로 펼치기
-    base_zip = zipfile.ZipFile(io.BytesIO(hwpx_list[0]), "r")
-    base_files = {name: base_zip.read(name) for name in base_zip.namelist()}
-    base_zip.close()
-
-    # 섹션 파일 후보
-    section_names = [n for n in base_files.keys() if n.startswith("Contents/section") and n.endswith(".xml")]
-    if not section_names:
-        return hwpx_list[0]
-
-    parser = etree.XMLParser(remove_blank_text=False, recover=True)
-
-    def first_or_none(nodes):
-        return nodes[0] if nodes else None
-
-    def findall_by_local(root, name):
-        # 모든 네임스페이스를 무시하고 로컬 이름으로만 탐색
-        return root.xpath(f".//*[local-name()='{name}']")
-
-    def findfirst_by_local(root, name):
-        return first_or_none(findall_by_local(root, name))
-
-    # 문서별로 섹션 합치기
-    for idx in range(1, len(hwpx_list)):
-        add_zip = zipfile.ZipFile(io.BytesIO(hwpx_list[idx]), "r")
-        add_files = {name: add_zip.read(name) for name in add_zip.namelist()}
-        add_zip.close()
-
-        for sec in section_names:
-            if sec not in add_files or sec not in base_files:
-                continue
-
-            base_xml = base_files[sec].decode("utf-8", errors="ignore")
-            add_xml  = add_files[sec].decode("utf-8",  errors="ignore")
-
-            base_root = etree.fromstring(base_xml.encode("utf-8"), parser=parser)
-            add_root  = etree.fromstring(add_xml.encode("utf-8"),  parser=parser)
-
-            # 1) <pages> 병합: add의 <page>들을 base의 <pages> 뒤에 추가
-            base_pages = findfirst_by_local(base_root, "pages")
-            add_pages  = findfirst_by_local(add_root,  "pages")
-            if base_pages is not None and add_pages is not None:
-                for pg in list(add_pages):  # <page> 요소들
-                    base_pages.append(pg)
-
-            # 2) 본문 병합: <section> 아래 블록들을 이어붙임 + 사이에 pageBreak 문단 삽입
-            base_section = findfirst_by_local(base_root, "section")
-            add_section  = findfirst_by_local(add_root,  "section")
-            if base_section is not None and add_section is not None:
-                # hp 네임스페이스 URI 추출 (��으면 태그에서 뽑아내기)
-                def ns_of(el):
-                    if el is None or el.tag is None:
-                        return None
-                    if el.tag.startswith("{"):
-                        return el.tag.split("}")[0][1:]
-                    return None
-
-                # pages나 section의 태그에서 hp ns 추정
-                hp_ns = ns_of(base_pages) or ns_of(base_section)
-                def E(tag):
-                    return etree.Element(f"{{{hp_ns}}}{tag}") if hp_ns else etree.Element(tag)
-
-                # 페이지 구분용 pageBreak 문단
-                pagebreak_p = E("p")
-                run = E("run")
-                br = E("pageBreak")
-                run.append(br)
-                pagebreak_p.append(run)
-                base_section.append(pagebreak_p)
-
-                # add_section의 자식 블록들(보통 p)을 그대로 이어붙임
-                for child in list(add_section):
-                    base_section.append(child)
-
-            # 직렬화해서 되돌려쓰기
-            base_files[sec] = etree.tostring(base_root, encoding="utf-8", xml_declaration=False)
-
-    # 최종 zip 다시 만들기 (mimetype 무압축 + 맨앞)
-    out_buf = io.BytesIO()
-    zout = zipfile.ZipFile(out_buf, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=6)
-
-    if "mimetype" in base_files:
-        zi = zipfile.ZipInfo("mimetype"); zi.compress_type = zipfile.ZIP_STORED
-        zout.writestr(zi, base_files["mimetype"])
-        del base_files["mimetype"]
-
-    for name, data in base_files.items():
-        if isinstance(data, str):
-            data = data.encode("utf-8")
-        zi = zipfile.ZipInfo(name); zi.compress_type = zipfile.ZIP_DEFLATED
-        zout.writestr(zi, data)
-
-    zout.close()
-    out_buf.seek(0)
-    return out_buf.getvalue()
-
-# =============== UI ===============
+# -------------------- UI --------------------
 with st.expander("사용법", expanded=True):
-    st.markdown(
-        """
+    st.markdown("""
 1. 템플릿 파일을 업로드해주세요.
 2. 보존상자 정보가 들어있는 엑셀 파일을 업로드해주세요.
 3. 출력할 라벨 번호를 선택해주세요.
 4. 압축 파일을 다운받고, 압축해제 후 파일을 병합해주세요.
 5. 병합 후, 라벨을 출력하세요.
-
-- 단, 템플릿은 **.HWPX(한글)** 파일이어야 합니다. (.HWP 불가)  
-        """
-    )
+단, 템플릿은 .HWPX(한글) 파일이어야 합니다. (.HWP 불가)
+""")
 
 tpl = st.file_uploader("📄 HWPX 템플릿 업로드", type=["hwpx"])
 n_per_page = st.number_input("템플릿의 라벨 세트 개수(한 페이지 N개)", 1, 12, 3, 1)
-data = st.file_uploader("📊 데이터 업로드 (Excel/CSV)", type=["xlsx", "xls", "csv"])
+data = st.file_uploader("📊 데이터 업로드 (Excel/CSV)", type=["xlsx","xls","csv"])
 
 if tpl and data:
     tpl_bytes = tpl.read()
     df = pd.read_csv(data) if data.name.lower().endswith(".csv") else pd.read_excel(data)
 
     if "박스번호" not in df.columns:
-        st.error("❌ 필수 컬럼 '박스번호'가 없습니다.")
-        st.stop()
+        st.error("❌ 필수 컬럼 '박스번호'가 없습니다."); st.stop()
 
     st.success("✅ 위치 매핑 완료 (엑셀 측)")
     st.dataframe(df.head(10), use_container_width=True)
@@ -315,74 +273,55 @@ if tpl and data:
 
     # 1페이지 매핑 프리뷰
     st.subheader("🧪 1페이지 매핑 프리뷰")
-    keys = ["박스번호", "종료연도", "보존기간", "단위업무", "기록물철", "목록", "제목", "업무명"]
+    keys = ["박스번호","종료연도","보존기간","단위업무","기록물철","목록","제목","업무명"]
     mapping_preview = {}
     for i in range(int(n_per_page)):
         if i < len(records):
             r = records[i]
-            mapping_preview.update(
-                {
-                    f"박스번호{i+1}": r.get("박스번호", ""),
-                    f"종료연도{i+1}": r.get("생산연도", ""),
-                    f"보존기간{i+1}": r.get("보존기간", ""),
-                    f"단위업무{i+1}": r.get("단위업무", ""),
-                    f"기록물철{i+1}": r.get("기록물철", ""),
-                    f"목록{i+1}": r.get("목록", ""),
-                    f"제목{i+1}": r.get("제목", ""),
-                    f"업무명{i+1}": r.get("제목", ""),  # 템플릿이 '업무명X'을 쓰는 경우 대응
-                }
-            )
+            mapping_preview.update({
+                f"박스번호{i+1}": r.get("박스번호",""),
+                f"종료연도{i+1}": r.get("생산연도",""),
+                f"보존기간{i+1}": r.get("보존기간",""),
+                f"단위업무{i+1}": r.get("단위업무",""),
+                f"기록물철{i+1}": r.get("기록물철",""),
+                f"목록{i+1}": r.get("목록",""),
+                f"제목{i+1}": r.get("제목",""),
+                f"업무명{i+1}": r.get("제목",""),  # 템플릿이 '업무명1'을 쓰는 경우 대응
+            })
         else:
-            for k in keys:
-                mapping_preview[f"{k}{i+1}"] = ""
-    st.dataframe(
-        pd.DataFrame([{"키": k, "값 앞부분": str(v)[:120]} for k, v in sorted(mapping_preview.items())]),
-        use_container_width=True,
-        height=320,
-    )
+            for k in keys: mapping_preview[f"{k}{i+1}"] = ""
+    st.dataframe(pd.DataFrame([{"키":k, "값 앞부분":str(v)[:120]} for k,v in sorted(mapping_preview.items())]),
+                 use_container_width=True, height=320)
 
-    if st.button("🚀 단일 HWPX 생성 (병합 출력)"):
+    if st.button("🚀 라벨 생성 (페이지별 HWPX ZIP)"):
+        mem = io.BytesIO(); zout = zipfile.ZipFile(mem, "w", zipfile.ZIP_DEFLATED)
         pages = (len(records) + int(n_per_page) - 1) // int(n_per_page)
         debug_all = []
-        filled_pages: List[bytes] = []
 
         for p in range(pages):
-            chunk = records[p * int(n_per_page) : (p + 1) * int(n_per_page)]
-            mapping: Dict[str, str] = {}
+            chunk = records[p*int(n_per_page):(p+1)*int(n_per_page)]
+            mapping = {}
             for i in range(int(n_per_page)):
                 if i < len(chunk):
                     r = chunk[i]
-                    mapping[f"박스번호{i+1}"] = r.get("박스번호", "")
-                    mapping[f"종료연도{i+1}"] = r.get("생산연도", "")
-                    mapping[f"보존기간{i+1}"] = r.get("보존기간", "")
-                    mapping[f"단위업무{i+1}"] = r.get("단위업무", "")
-                    mapping[f"기록물철{i+1}"] = r.get("기록물철", "")
-                    mapping[f"목록{i+1}"] = r.get("목록", "")
-                    title_val = r.get("제목", "")
-                    mapping[f"제목{i+1}"] = title_val
+                    mapping[f"박스번호{i+1}"] = r.get("박스번호","")
+                    mapping[f"종료연도{i+1}"] = r.get("생산연도","")
+                    mapping[f"보존기간{i+1}"] = r.get("보존기간","")
+                    mapping[f"단위업무{i+1}"] = r.get("단위업무","")
+                    mapping[f"기록물철{i+1}"] = r.get("기록물철","")
+                    mapping[f"목록{i+1}"]   = r.get("목록","")
+                    title_val = r.get("제목","")
+                    mapping[f"제목{i+1}"]   = title_val
                     mapping[f"업무명{i+1}"] = title_val
                 else:
-                    for k in keys:
-                        mapping[f"{k}{i+1}"] = ""
+                    for k in keys: mapping[f"{k}{i+1}"] = ""
 
             out_hwpx, dbg = replace_in_hwpx(tpl_bytes, mapping)
-            debug_all.append({"page": p + 1, "stats": dbg})
-            filled_pages.append(out_hwpx)
-
-        # 🔥 단일 HWPX 병합 (lxml)
-        merged_hwpx = merge_filled_hwpx_list_to_single(filled_pages)
-
-        # 파일명
-        first_box = records[0].get("박스번호", "0000") if records else "0000"
-        last_box = records[-1].get("박스번호", "0000") if records else "0000"
-        filename = (
-            f"labels_{first_box}to{last_box}.hwpx" if first_box != last_box else f"labels_{first_box}.hwpx"
-        )
-
-        st.download_button(
-            "⬇️ 단일 HWPX 다운로드",
-            data=merged_hwpx,
-            file_name=filename,
-            mime="application/vnd.hancom.hwpx",
-        )
-    
+            debug_all.append({"page": p+1, "stats": dbg})
+            name = "_".join([r.get("박스번호","") for r in chunk]) if chunk else f"empty_{p+1}"
+            zout.writestr(f"label_{name}.hwpx", out_hwpx)
+
+        zout.close(); mem.seek(0)
+        st.download_button("⬇️ ZIP 다운로드", data=mem, file_name="labels_by_page.zip", mime="application/zip")
+        st.download_button("⬇️ 디버그(JSON)", data=json.dumps(debug_all, ensure_ascii=False, indent=2),
+                           file_name="debug.json", mime="application/json")