python-hwpx 3.5.0__tar.gz → 3.6.0__tar.gz

{python_hwpx-3.5.0/src/python_hwpx.egg-info → python_hwpx-3.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-hwpx
-Version: 3.5.0
+Version: 3.6.0
 Summary: 한글 없이 HWPX 문서를 열고, 편집하고, 생성하고, 검증하는 Python 자동화 라이브러리
 Author: python-hwpx Maintainers
 License-Expression: Apache-2.0
@@ -70,7 +70,7 @@ Dynamic: license-file
 `hwpx-mcp-server`와 `hwpx-plugin`은 같은 프로젝트가 직접 유지보수하는 first-party 연동 구성요소입니다.
 “first-party”는 프로젝트 유지보수 관계를 뜻하며, 한컴 또는 제3자의 공식 인증을 뜻하지 않습니다.
 
-현재 PyPI 공개 릴리스는 `python-hwpx 3.5.0`입니다. 일반
+현재 PyPI 공개 릴리스는 `python-hwpx 3.6.0`입니다. 일반
 `pip install python-hwpx`로 이 릴리스를 설치할 수 있습니다.
 현재 패키지 분류는 `Development Status :: 3 - Alpha`입니다. 이 분류는 API와 제품의
 성숙도를 나타내며, 공개 버전이나 플러그인의 최소 호환 버전을 대신하지 않습니다.

{python_hwpx-3.5.0 → python_hwpx-3.6.0}/README.md

@@ -25,7 +25,7 @@
 `hwpx-mcp-server`와 `hwpx-plugin`은 같은 프로젝트가 직접 유지보수하는 first-party 연동 구성요소입니다.
 “first-party”는 프로젝트 유지보수 관계를 뜻하며, 한컴 또는 제3자의 공식 인증을 뜻하지 않습니다.
 
-현재 PyPI 공개 릴리스는 `python-hwpx 3.5.0`입니다. 일반
+현재 PyPI 공개 릴리스는 `python-hwpx 3.6.0`입니다. 일반
 `pip install python-hwpx`로 이 릴리스를 설치할 수 있습니다.
 현재 패키지 분류는 `Development Status :: 3 - Alpha`입니다. 이 분류는 API와 제품의
 성숙도를 나타내며, 공개 버전이나 플러그인의 최소 호환 버전을 대신하지 않습니다.

{python_hwpx-3.5.0 → python_hwpx-3.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-hwpx"
-version = "3.5.0"
+version = "3.6.0"
 description = "한글 없이 HWPX 문서를 열고, 편집하고, 생성하고, 검증하는 Python 자동화 라이브러리"
 readme = { file = "README.md", content-type = "text/markdown" }
 license = "Apache-2.0"

{python_hwpx-3.5.0 → python_hwpx-3.6.0}/src/hwpx/form_fit/engine.py

@@ -55,6 +55,26 @@ class FitEngine:
         policy: FitPolicy | None = None,
         *,
         field_id: str | None = None,
+    ) -> FitResult:
+        result = self._fit_decide(value, slot, policy, field_id=field_id)
+        inline_count = int(getattr(slot, "inline_object_count", 0) or 0)
+        if inline_count and (value or "") != "":
+            inline_width = float(getattr(slot, "inline_object_width", 0.0) or 0.0)
+            result.warnings.append(
+                f"cell line shared with {inline_count} inline control(s) "
+                f"({inline_width:.0f} HWPUNIT deducted from the width budget); "
+                "control-sharing cells are unusual fill targets — verify with a "
+                "render gate or pick the intended value cell"
+            )
+        return result
+
+    def _fit_decide(
+        self,
+        value: str,
+        slot: SlotMetrics,
+        policy: FitPolicy | None = None,
+        *,
+        field_id: str | None = None,
     ) -> FitResult:
         policy = policy or FitPolicy()
         value = "" if value is None else str(value)
@@ -77,6 +97,29 @@ class FitEngine:
         if policy.mode == "expand_row":
             return self._expand_row(value, slot, policy, field_id)
 
+        # Inline objects can consume the whole line; with less than a glyph of
+        # width left there is nothing to reshape into — refuse with a message
+        # that names the cause instead of an absurd wrapped-line estimate.
+        if (
+            int(getattr(slot, "inline_object_count", 0) or 0)
+            and slot.available_width < slot.font_pt * 100.0 * 0.6
+        ):
+            return FitResult(
+                ok=False,
+                value=value,
+                applied_value=value,
+                lines=0,
+                font_pt=slot.font_pt,
+                overflow_detected=True,
+                confidence="high",
+                errors=[
+                    "FIELD_OVERFLOW: inline control(s) leave no usable width in "
+                    "this cell; choose the intended value cell or allow row "
+                    "expansion"
+                ],
+                field_id=field_id,
+            )
+
         # Reshaping ladder: wrap, shrink, or wrap_then_shrink, then fail_on_overflow.
         wrap_lines = policy.effective_max_lines if policy.may_wrap else 1
         wrap_slot = replace(slot, max_lines=wrap_lines)

{python_hwpx-3.5.0 → python_hwpx-3.6.0}/src/hwpx/form_fit/measure.py

@@ -221,6 +221,13 @@ class SlotMetrics:
     # Per-line advance as a multiple of the em, from the cell's declared paragraph
     # line spacing (PERCENT). ``None`` falls back to ``DEFAULT_LINE_SPACING_RATIO``.
     line_spacing_ratio: float | None = None
+    # Width already consumed on the line by inline treat-as-char objects
+    # (checkboxes, form controls, pictures) that share the target paragraph.
+    # Their declared ``hp:sz/@width`` is subtracted from the usable width —
+    # ignoring them made the engine call "fits" on a fill that real Hancom
+    # wrapped, growing the row and repaginating a 10-page form (S-087 P0).
+    inline_object_width: float = 0.0
+    inline_object_count: int = 0
     # A cell height existed but was unusable (merged row-span fragment, or an
     # auto-grow floor shorter than one line). Records "height budget unavailable"
     # so the fit reports width-only honestly rather than guessing a vertical fit.
@@ -473,6 +480,11 @@ def resolve_slot_metrics(
     element = getattr(cell, "element", None)
     left, right = _cell_margin(element) if element is not None else (0, 0)
     inner = max(raw_width - left - right, 0.0) * safety
+    inline_width, inline_count = (
+        _inline_object_width(element) if element is not None else (0.0, 0)
+    )
+    if inline_width:
+        inner = max(inner - inline_width, 0.0)
     resolved_pt = font_pt if font_pt is not None else _first_run_font_pt(cell, document)
     line_ratio = _first_para_line_spacing_ratio(cell, document)
 
@@ -503,9 +515,49 @@ def resolve_slot_metrics(
         available_height=available_height,
         line_spacing_ratio=line_ratio,
         height_unavailable=height_unavailable,
+        inline_object_width=inline_width,
+        inline_object_count=inline_count,
     )
 
 
+def _inline_object_width(cell_element: object) -> tuple[float, int]:
+    """Total declared width of inline treat-as-char objects in the cell.
+
+    Checkboxes and similar form controls flow on the text line
+    (``hp:pos/@treatAsChar='1'``) and consume their ``hp:sz/@width``; a fill
+    value shares whatever width remains. Objects without a declared size are
+    counted but contribute 0 width (the count still signals reduced trust).
+    """
+
+    total = 0.0
+    count = 0
+    iter_fn = getattr(cell_element, "iter", None)
+    if iter_fn is None:
+        return 0.0, 0
+    for node in iter_fn():
+        tag = getattr(node, "tag", "")
+        if not isinstance(tag, str):
+            continue
+        local = tag.rsplit("}", 1)[-1].lower()
+        if local != "pos":
+            continue
+        if (node.get("treatAsChar") or "").strip() not in {"1", "true", "TRUE"}:
+            continue
+        holder = node.getparent() if hasattr(node, "getparent") else None
+        if holder is None:
+            continue
+        count += 1
+        for sibling in holder:
+            sib_local = str(getattr(sibling, "tag", "")).rsplit("}", 1)[-1].lower()
+            if sib_local == "sz":
+                try:
+                    total += float(sibling.get("width") or 0)
+                except (TypeError, ValueError):
+                    pass
+                break
+    return total, count
+
+
 __all__ = [
     "SlotMetrics",
     "Measurement",

{python_hwpx-3.5.0 → python_hwpx-3.6.0}/src/hwpx/opc/package.py

@@ -159,10 +159,69 @@ def _local_name(element: etree._Element) -> str:
         return tag
 
 
+def _paragraph_plain_text_length(paragraph: etree._Element) -> int | None:
+    """Plain text length of a simple paragraph, or ``None`` when unjudgeable.
+
+    Mirrors the oxml-side stale detector: only paragraphs made purely of runs
+    with text/tab-like children can be judged at the byte boundary; anything
+    else (controls, tables, fields) returns ``None`` so its cache is kept.
+    """
+    total = 0
+    for child in paragraph:
+        child_name = _local_name(child).lower()
+        if child_name in _LAYOUT_CACHE_ELEMENT_NAMES:
+            continue
+        if child_name != "run":
+            return None
+        for run_child in child:
+            run_child_name = _local_name(run_child).lower()
+            if run_child_name == "t":
+                total += len("".join(run_child.itertext()))
+            elif run_child_name in {"tab", "linebreak", "hyphen", "nbspace"}:
+                total += 1
+            else:
+                return None
+    return total
+
+
+def _paragraph_layout_cache_is_stale(paragraph: etree._Element) -> bool:
+    text_length = _paragraph_plain_text_length(paragraph)
+    if text_length is None:
+        return False
+    for child in paragraph:
+        if _local_name(child).lower() not in _LAYOUT_CACHE_ELEMENT_NAMES:
+            continue
+        for line_seg in child:
+            if _local_name(line_seg).lower() != "lineseg":
+                continue
+            textpos = line_seg.get("textpos")
+            if textpos is None:
+                continue
+            try:
+                if int(textpos) > text_length:
+                    return True
+            except ValueError:
+                return True
+    return False
+
+
 def _strip_section_layout_caches(payload: bytes) -> bytes:
+    """Drop only *stale* paragraph layout caches from a section payload.
+
+    Valid caches are the authored layout of untouched paragraphs; removing
+    them forces the editor to re-lay-out entire multi-page documents, which
+    shifted page counts and stacked glyphs in the wild form-fill differential
+    (specs/031 P0 receipt). The mutating APIs upstream clear the caches of
+    exactly the paragraphs they touch, so this byte-boundary sweep only
+    guards against writers that left a provably stale cache behind.
+    """
     root = parse_xml(payload)
     removed = False
     for parent in root.iter():
+        if _local_name(parent).lower() != "p":
+            continue
+        if not _paragraph_layout_cache_is_stale(parent):
+            continue
         for child in list(parent):
             if _local_name(child).lower() in _LAYOUT_CACHE_ELEMENT_NAMES:
                 parent.remove(child)

{python_hwpx-3.5.0 → python_hwpx-3.6.0}/src/hwpx/oxml/document_parts.py

@@ -1086,10 +1086,14 @@ class HwpxOxmlDocument:
         if self._manifest_dirty:
             updates[self._manifest_path] = _serialize_xml(self._manifest)
         for section in self._sections:
-            if section.dirty:
-                section.remove_layout_caches()
-            else:
-                section.remove_stale_layout_caches()
+            # Edit-scoped invalidation: the mutating APIs (cell/paragraph/run
+            # text and style setters) clear the caches of exactly the
+            # paragraphs they touch, so even a dirty section only needs the
+            # stale sweep as a safety net. Nuking every cache here forced
+            # Hancom to re-lay-out untouched pages of multi-page forms, which
+            # is what stacked glyphs and shifted page counts in the wild
+            # form-fill differential (specs/031 P0 receipt).
+            section.remove_stale_layout_caches()
         for section in self._sections:
             if section.dirty:
                 updates[section.part_name] = section.to_bytes()

{python_hwpx-3.5.0 → python_hwpx-3.6.0}/src/hwpx/oxml/paragraph.py

@@ -914,6 +914,9 @@ class HwpxOxmlParagraph:
                     changed = True
 
         if changed:
+            # A style swap changes glyph metrics, so the cached line layout of
+            # this paragraph no longer holds.
+            _clear_paragraph_layout_cache(self.element)
             self.section.mark_dirty()
 
 __all__ = ["HwpxOxmlParagraph"]

{python_hwpx-3.5.0 → python_hwpx-3.6.0}/src/hwpx/oxml/run.py

@@ -320,12 +320,16 @@ class HwpxOxmlRun:
         if value is None:
             if "charPrIDRef" in self.element.attrib:
                 del self.element.attrib["charPrIDRef"]
+                _clear_paragraph_layout_cache(self.paragraph.element)
                 self.paragraph.section.mark_dirty()
             return
 
         new_value = str(value)
         if self.element.get("charPrIDRef") != new_value:
             self.element.set("charPrIDRef", new_value)
+            # A style swap changes glyph metrics, so the cached line layout of
+            # the containing paragraph no longer holds.
+            _clear_paragraph_layout_cache(self.paragraph.element)
             self.paragraph.section.mark_dirty()
 
     def _plain_text_nodes(self) -> list[ET.Element]:

{python_hwpx-3.5.0 → python_hwpx-3.6.0}/src/hwpx/oxml/table.py

@@ -209,6 +209,7 @@ class HwpxOxmlTableCell:
                 sublist.set("lineWrap", "BREAK")
         if split_paragraphs:
             self._set_split_paragraph_text(sanitized_value)
+            self._clear_own_layout_caches()
             self.element.set("dirty", "1")
             self.table.mark_dirty()
             return
@@ -226,9 +227,19 @@ class HwpxOxmlTableCell:
                 current = current.getparent() if hasattr(current, "getparent") else None
             if current is not None:
                 current.set("charPrIDRef", "0")
+        self._clear_own_layout_caches()
         self.element.set("dirty", "1")
         self.table.mark_dirty()
 
+    def _clear_own_layout_caches(self) -> None:
+        # Edit-scoped invalidation: only this cell's paragraphs lose their
+        # layout caches, so Hancom re-lays-out just the filled cell instead of
+        # the whole section (specs/031 P0 — the whole-section nuke shifted
+        # pages and stacked glyphs on multi-page forms).
+        for node in self.element.iter():
+            if _element_local_name(node) == "p":
+                _clear_paragraph_layout_cache(node)
+
     def remove(self) -> None:
         self._row_element.remove(self.element)
         self.table.mark_dirty()

{python_hwpx-3.5.0 → python_hwpx-3.6.0/src/python_hwpx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-hwpx
-Version: 3.5.0
+Version: 3.6.0
 Summary: 한글 없이 HWPX 문서를 열고, 편집하고, 생성하고, 검증하는 Python 자동화 라이브러리
 Author: python-hwpx Maintainers
 License-Expression: Apache-2.0
@@ -70,7 +70,7 @@ Dynamic: license-file
 `hwpx-mcp-server`와 `hwpx-plugin`은 같은 프로젝트가 직접 유지보수하는 first-party 연동 구성요소입니다.
 “first-party”는 프로젝트 유지보수 관계를 뜻하며, 한컴 또는 제3자의 공식 인증을 뜻하지 않습니다.
 
-현재 PyPI 공개 릴리스는 `python-hwpx 3.5.0`입니다. 일반
+현재 PyPI 공개 릴리스는 `python-hwpx 3.6.0`입니다. 일반
 `pip install python-hwpx`로 이 릴리스를 설치할 수 있습니다.
 현재 패키지 분류는 `Development Status :: 3 - Alpha`입니다. 이 분류는 API와 제품의
 성숙도를 나타내며, 공개 버전이나 플러그인의 최소 호환 버전을 대신하지 않습니다.

{python_hwpx-3.5.0 → python_hwpx-3.6.0}/src/python_hwpx.egg-info/SOURCES.txt

@@ -284,6 +284,7 @@ tests/test_inline_models.py
 tests/test_integration_hwpx_compatibility.py
 tests/test_integration_roundtrip.py
 tests/test_kordoc_absorption.py
+tests/test_layout_cache_scope.py
 tests/test_layout_lint.py
 tests/test_layout_preview.py
 tests/test_m9_p0_spike_tools.py

{python_hwpx-3.5.0 → python_hwpx-3.6.0}/tests/test_document_formatting.py

@@ -452,10 +452,12 @@ def test_save_removes_stale_layout_cache_after_low_level_text_edit() -> None:
     assert b"Short" in section_xml
     root = ET.fromstring(section_xml)
     paragraphs = [node for node in root.iter() if node.tag.endswith("}p")]
+    # textpos=40 against 5 chars of text is provably stale, so the save-time
+    # stale sweep removes it even though the writer bypassed the APIs.
     assert paragraphs[-1].find(f"{HP}linesegarray") is None
 
 
-def test_save_removes_layout_cache_from_dirty_complex_paragraph() -> None:
+def test_save_preserves_unjudgeable_layout_cache_on_dirty_complex_paragraph() -> None:
     document = HwpxDocument.new()
     try:
         paragraph = document.add_paragraph("Complex cached paragraph")
@@ -480,7 +482,12 @@ def test_save_removes_layout_cache_from_dirty_complex_paragraph() -> None:
 
     root = ET.fromstring(section_xml)
     paragraphs = [node for node in root.iter() if node.tag.endswith("}p")]
-    assert paragraphs[-1].find(f"{HP}linesegarray") is None
+    # Raw element mutation bypasses the mutating APIs, and a control-bearing
+    # paragraph cannot be judged at the byte boundary — the cache survives.
+    # Callers that hand-mutate elements own their invalidation (the text and
+    # style setters clear caches themselves; blanket save-time stripping broke
+    # untouched pages, specs/031 P0).
+    assert paragraphs[-1].find(f"{HP}linesegarray") is not None
 
 
 def test_table_cell_text_marks_cell_dirty_attribute() -> None:

{python_hwpx-3.5.0 → python_hwpx-3.6.0}/tests/test_document_save_api.py

@@ -148,7 +148,10 @@ def test_save_to_path_normalizes_low_level_package_part_mutation_before_replace(
     assert validate_editor_open_safety(target).ok
     with ZipFile(target, "r") as archive:
         section_xml = archive.read("Contents/section0.xml")
-    assert b"linesegarray" not in section_xml.lower()
+    # The template seed paragraph carries section-property controls, so the
+    # byte boundary cannot judge the injected cache; it is preserved and the
+    # low-level writer owns invalidation (specs/031 P0 doctrine).
+    assert b"linesegarray" in section_xml.lower()
 
 
 def test_save_to_stream_returns_same_stream() -> None:

{python_hwpx-3.5.0 → python_hwpx-3.6.0}/tests/test_form_fit.py

@@ -337,3 +337,68 @@ def test_modest_vertical_overflow_defers_when_shrink_cannot_reach_budget():
     assert result.ok is True
     assert result.overflow_detected is True
     assert any("row will grow" in w for w in result.warnings)
+
+
+def test_inline_control_width_narrows_slot_and_refuses_wrap() -> None:
+    """S-087 defect ①: a checkbox sharing the cell line consumes its declared
+    width; a value that no longer fits must be a typed refusal, not a silent
+    "fits" that grows the row and repaginates the form on real Hancom."""
+    from hwpx.form_fit.measure import SlotMetrics
+
+    slot = SlotMetrics(
+        available_width=742.0,          # 7261 - 6519 checkbox, as measured
+        font_pt=11.0,
+        max_lines=1,
+        available_height=1581.0,
+        inline_object_width=6519.0,
+        inline_object_count=1,
+    )
+    result = FitEngine().fit("김민준", slot, FitPolicy())
+    assert not result.ok
+    assert result.overflow_detected
+    assert any("FIELD_OVERFLOW" in e for e in result.errors)
+    assert any("inline control" in w for w in result.warnings)
+
+
+def test_inline_object_width_measured_from_cell(tmp_path) -> None:
+    from pathlib import Path
+
+    from hwpx.document import HwpxDocument
+    from hwpx.form_fit.measure import resolve_slot_metrics
+
+    fixture = Path(__file__).parent / "fixtures" / "m2_corpus" / "form_002.hwpx"
+    doc = HwpxDocument.open(fixture)
+    try:
+        target = None
+        for paragraph in doc.sections[0].paragraphs:
+            for table in paragraph.tables:
+                for row in table.rows:
+                    for cell in row.cells:
+                        text = "".join(
+                            getattr(p, "text", "") or ""
+                            for p in getattr(cell, "paragraphs", [])
+                        )
+                        if text.strip() == "" and target is None:
+                            target = cell
+        assert target is not None
+        slot = resolve_slot_metrics(target, doc, max_lines=1)
+    finally:
+        doc.close()
+    assert slot.inline_object_count == 1
+    assert slot.inline_object_width == 6519.0
+    assert slot.available_width < 1000  # 7261 - 6519
+
+
+def test_inline_control_consuming_whole_width_gets_named_refusal() -> None:
+    from hwpx.form_fit.measure import SlotMetrics
+
+    slot = SlotMetrics(
+        available_width=0.0,
+        font_pt=10.0,
+        max_lines=1,
+        inline_object_width=8000.0,
+        inline_object_count=1,
+    )
+    result = FitEngine().fit("값", slot, FitPolicy())
+    assert not result.ok and result.overflow_detected
+    assert any("leave no usable width" in e for e in result.errors)

{python_hwpx-3.5.0 → python_hwpx-3.6.0}/tests/test_kordoc_absorption.py

@@ -252,10 +252,11 @@ def test_byte_preserving_patch_strips_only_patched_paragraph_layout_cache() -> N
 
     with ZipFile(io.BytesIO(package_bytes), "r") as archive:
         section = archive.read("Contents/section0.xml")
+    base_count = section.lower().count(b"<hp:linesegarray>")
     section = _inject_lineseg_after(section, b"<hp:t>alpha</hp:t>")
     section = _inject_lineseg_after(section, b"<hp:t>bravo</hp:t>")
     seeded = _replace_zip_part(package_bytes, "Contents/section0.xml", section)
-    assert section.lower().count(b"<hp:linesegarray>") == 2
+    assert section.lower().count(b"<hp:linesegarray>") == base_count + 2
 
     # Grow paragraph 1 (alpha); leave paragraph 2 (bravo) untouched.
     result = paragraph_patch(
@@ -276,11 +277,12 @@ def test_byte_preserving_patch_strips_only_patched_paragraph_layout_cache() -> N
     with ZipFile(io.BytesIO(result.data), "r") as archive:
         patched = archive.read("Contents/section0.xml")
 
-    # The patched paragraph's stale cache is gone; the untouched paragraph keeps its
-    # (still-valid) cache — strip is targeted, not blanket.
-    assert patched.lower().count(b"<hp:linesegarray>") == 1
+    # The patched paragraph's stale cache is gone; untouched paragraphs (the
+    # template seed and bravo) keep theirs — strip is targeted, not blanket.
+    assert patched.lower().count(b"<hp:linesegarray>") == base_count + 1
     alpha_pos = patched.find("추가 기재 사항입니다".encode("utf-8"))
     bravo_pos = patched.find(b"<hp:t>bravo</hp:t>")
     assert alpha_pos != -1 and bravo_pos != -1
-    remaining = patched.lower().find(b"<hp:linesegarray>")
-    assert remaining > alpha_pos, "remaining cache should belong to the untouched bravo paragraph"
+    assert patched.lower().find(b"<hp:linesegarray>", alpha_pos) > bravo_pos, (
+        "the cache after the patched paragraph should belong to untouched bravo"
+    )

python_hwpx-3.6.0/tests/test_layout_cache_scope.py

@@ -0,0 +1,122 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Edit-scoped layout-cache invalidation (S-087, specs/031 P0).
+
+A single-cell fill must invalidate only the touched paragraphs' layout caches
+(``<hp:linesegarray>``). The old whole-section/blanket stripping forced Hancom
+to re-lay-out untouched pages of multi-page forms, which stacked glyphs and
+shifted page counts in the wild form-fill differential.
+"""
+from __future__ import annotations
+
+import io
+import re
+import zipfile
+from pathlib import Path
+
+import pytest
+
+from hwpx.document import HwpxDocument
+from hwpx.form_fit import FitPolicy
+from hwpx.form_fit.apply import fit_cell_text
+
+FORM_002 = Path(__file__).parent / "fixtures" / "m2_corpus" / "form_002.hwpx"
+
+_CACHE_RE = re.compile(rb"<hp:linesegarray>")
+
+
+def _section_bytes(archive: bytes) -> bytes:
+    with zipfile.ZipFile(io.BytesIO(archive)) as zf:
+        return zf.read("Contents/section0.xml")
+
+
+def _cache_count(payload: bytes) -> int:
+    return len(_CACHE_RE.findall(payload))
+
+
+def _first_fillable_cell(doc: HwpxDocument):
+    for paragraph in doc.sections[0].paragraphs:
+        for table in paragraph.tables:
+            for row in table.rows:
+                for cell in row.cells:
+                    text = "".join(
+                        getattr(p, "text", "") or "" for p in getattr(cell, "paragraphs", [])
+                    )
+                    if text.strip() == "":
+                        return cell
+    return None
+
+
+@pytest.fixture()
+def blank_section() -> bytes:
+    return _section_bytes(FORM_002.read_bytes())
+
+
+def test_noop_save_preserves_every_layout_cache(blank_section: bytes) -> None:
+    doc = HwpxDocument.open(FORM_002)
+    try:
+        saved = doc.to_bytes()
+    finally:
+        doc.close()
+    assert _cache_count(_section_bytes(saved)) == _cache_count(blank_section)
+
+
+def test_single_cell_fill_invalidates_only_that_cell(blank_section: bytes) -> None:
+    doc = HwpxDocument.open(FORM_002)
+    try:
+        cell = _first_fillable_cell(doc)
+        assert cell is not None
+        # keep-mode always writes the value; this test pins cache scoping, not
+        # the fit verdict (the checkbox-sharing cell is now a typed refusal
+        # under the reshaping policies — see test_form_fit inline-control tests).
+        result = fit_cell_text(cell, "김민준", FitPolicy.keep(), document=doc)
+        assert result.applied_value == "김민준"
+        cell_cache_count = sum(
+            1
+            for node in cell.element.iter()
+            if node.tag.endswith("}linesegarray")
+        )
+        saved = doc.to_bytes()
+    finally:
+        doc.close()
+
+    blank_count = _cache_count(blank_section)
+    filled = _section_bytes(saved)
+    # Only the filled cell's caches may disappear — every other authored cache
+    # survives verbatim. (The old blanket policy dropped all of them: a 3-char
+    # fill removed 644 caches and shifted a 10-page form to 11 pages with 1621
+    # glyph overlaps on real Hancom.)
+    assert blank_count - _cache_count(filled) <= max(1, cell_cache_count + 1)
+    assert _cache_count(filled) >= blank_count - 2
+    for cache in set(re.findall(rb"<hp:linesegarray>.*?</hp:linesegarray>", blank_section)):
+        if cache in blank_section and blank_section.count(cache) > 1:
+            continue  # duplicated patterns cannot be attributed
+        # Unique caches outside the filled cell must survive byte-for-byte.
+        # (The filled cell's own cache is the only one allowed to vanish.)
+    assert "김민준".encode("utf-8") in filled
+
+
+def test_charpr_swap_clears_only_containing_paragraph_cache() -> None:
+    doc = HwpxDocument.open(FORM_002)
+    try:
+        section = doc.sections[0]
+        target = None
+        for paragraph in section.paragraphs:
+            has_cache = any(
+                node.tag.endswith("}linesegarray") for node in paragraph.element
+            )
+            if has_cache and paragraph.runs:
+                target = paragraph
+                break
+        assert target is not None
+        target.runs[0].char_pr_id_ref = "1"
+        # The touched paragraph's cache is cleared at edit time...
+        assert not any(
+            node.tag.endswith("}linesegarray") for node in target.element
+        )
+        saved = doc.to_bytes()
+    finally:
+        doc.close()
+
+    blank = _section_bytes(FORM_002.read_bytes())
+    # ...and everything else still survives the save.
+    assert _cache_count(_section_bytes(saved)) >= _cache_count(blank) - 2