blocks — pass through untouched.
+ TS_OPEN, TS_CLOSE = "\x02", "\x03"
+
+ result = text
+
+ # 0. Stash raw Typst blocks; restore at the very end to bypass all escaping.
+ raw_typst: list[str] = []
+
+ def _stash_typst(m: re.Match) -> str:
+ raw_typst.append(m.group(1))
+ return f"{TS_OPEN}{len(raw_typst) - 1}{TS_CLOSE}"
+
+ result = _TYPST_BLOCK.sub(_stash_typst, result)
+
+ # 1. Display math → $ content $ (spaces = display/block in Typst).
+ # Inline math → $content$ (no spaces = inline in Typst, stays in text flow).
+ # Also split multi-letter variable products (e.g. bh → b h) inside math.
+ result = _MATH_TYPST_DISPLAY.sub(
+ lambda m: f"$ {_split_math_vars(m.group(1).strip())} $", result
+ )
+ result = _MATH_TYPST_INLINE.sub(
+ lambda m: f"${_split_math_vars(m.group(1).strip())}$", result
+ )
+
+ # 2. Bold / italic / sup / sub → function-call syntax.
+ # Function calls avoid word-boundary issues that break `_x_θ`-style emphasis.
+ result = _BOLD.sub(lambda m: f"{PH}strong[{m.group(1)}]", result)
+ result = _ITALIC.sub(lambda m: f"{PH}emph[{m.group(1)}]", result)
+ result = _SUP.sub(lambda m: f"{PH}super[{m.group(1)}]", result)
+ result = _SUB.sub(lambda m: f"{PH}sub[{m.group(1)}]", result)
+
+ # 3. Strip remaining unknown HTML tags (preserving < > inside $...$)
+ result = _strip_tags_outside_math(result)
+
+ # 4. Escape Typst-special chars in user content (outside math)
+ result = _escape_typst_outside_math(result, clean_math=True)
+
+ # 5. Restore # for our generated function calls
+ result = result.replace(PH, "#")
+
+ # 6. Restore raw Typst blocks; clean LLM mistakes inside $...$ math regions.
+ if raw_typst:
+
+ def _restore(m: re.Match) -> str:
+ content = raw_typst[int(m.group(1))]
+ content = content.replace("\\/", "/") # legacy prompt artifact
+ # Inside each inline $...$, run full math cleanup (LaTeX → Typst, var split).
+ return re.sub(
+ r"\$([^$]+?)\$",
+ lambda mm: _clean_math_chunk(f"${mm.group(1)}$"),
+ content,
+ flags=re.DOTALL,
+ )
+
+ result = re.sub(f"{TS_OPEN}(\\d+){TS_CLOSE}", _restore, result)
+
+ return result
+
+
+# ---------------------------------------------------------------------------
+# TOC parser
+# ---------------------------------------------------------------------------
+
+# Matches: title (non-greedy) + optional dot leaders + page_number
+# Lookahead: followed by whitespace+digit (next entry) or end of string.
+# Page numbers limited to 1-3 digits to avoid matching years like 2023.
+_TOC_BLOB_RE = re.compile(
+ r"(.+?)\s*(?:(?:\.\s*){2,})?\s*(\d{1,3})(?=\s+\d|\s*$)",
+ re.DOTALL,
+)
+_DOT_SEQ_RE = re.compile(r"\s*(?:\.\s*){2,}")
+
+
+def parse_toc_line(line: str) -> tuple[str, str] | None:
+ """Extract (title, page_number) from a single TOC line, or None."""
+ line = line.strip()
+ if not line:
+ return None
+ m = re.match(r"^(.*?)\s+(\d+)\s*$", line)
+ if m:
+ return m.group(1).strip(), m.group(2)
+ return None
+
+
+def parse_toc_entries(text: str) -> list[tuple[str, str | None]]:
+ """Parse TOC text into (title, page_num) pairs.
+
+ Handles both newline-separated lines and single-line blob format
+ (entries concatenated with dot leaders or bare spaces).
+ page_num is None for entries where no page number could be found.
+ """
+ lines = [line.strip() for line in text.split("\n") if line.strip()]
+ if len(lines) > 1:
+ result = []
+ for line in lines:
+ parsed = parse_toc_line(line)
+ result.append(parsed if parsed else (line, None))
+ return result
+
+ # Single-line blob: extract via regex, preserving gap text between matches
+ entries: list[tuple[str, str | None]] = []
+ prev_end = 0
+ for m in _TOC_BLOB_RE.finditer(text):
+ gap = text[prev_end : m.start()].strip()
+ if gap:
+ clean = _DOT_SEQ_RE.sub(" ", gap).strip()
+ if clean:
+ entries.append((clean, None))
+ title = m.group(1).strip()
+ if title:
+ entries.append((title, m.group(2)))
+ prev_end = m.end()
+ tail = _DOT_SEQ_RE.sub(" ", text[prev_end:]).strip()
+ if tail:
+ entries.append((tail, None))
+ return entries if entries else [(text.strip(), None)]
diff --git a/pdf2zh/render/overlay.py b/pdf2zh/render/overlay.py
new file mode 100644
index 0000000000000000000000000000000000000000..beda50eb241e27fc0bf865b04b4e269508d26203
--- /dev/null
+++ b/pdf2zh/render/overlay.py
@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import fitz
+
+logger = logging.getLogger(__name__)
+
+
+def composite_overlay(
+ original_pdf: Path,
+ overlay_pdf: Path,
+ output_pdf: Path,
+ pages: list[int] | None,
+) -> None:
+ """Stamp overlay_pdf transparently onto the selected pages of original_pdf.
+
+ The output contains ONLY the translated pages (those in ``pages``), in
+ ascending page order — not the whole original document. When ``pages`` is
+ None every page is kept. For scanned PDFs the original page image is the
+ background; the overlay PDF carries translated text and cover rects with
+ sampled bg colors. PyMuPDF's show_pdf_page() composites them in a single
+ vector operation.
+ """
+ src = fitz.open(str(original_pdf))
+ ov = fitz.open(str(overlay_pdf))
+
+ if pages is None:
+ selected = list(range(src.page_count))
+ else:
+ selected = sorted(p for p in pages if 0 <= p < src.page_count)
+
+ # Overlay page i corresponds to the i-th selected source page: source_builder
+ # emits rendered pages in ascending page_index order, matching sorted(pages).
+ # Guard a shorter overlay so a missing page never raises.
+ n = min(len(selected), ov.page_count)
+ if n < len(selected):
+ logger.warning(
+ "Overlay has fewer pages (%d) than selected (%d); stopping early",
+ ov.page_count,
+ len(selected),
+ )
+
+ out = fitz.open()
+ for i in range(n):
+ src_idx = selected[i]
+ out.insert_pdf(src, from_page=src_idx, to_page=src_idx)
+ out[i].show_pdf_page(out[i].rect, ov, i, overlay=True)
+ logger.debug(
+ "Composited overlay page %d → output page %d (source %d)", i, i, src_idx
+ )
+
+ ov.close()
+ src.close()
+ output_pdf.parent.mkdir(parents=True, exist_ok=True)
+ out.save(
+ str(output_pdf),
+ garbage=4,
+ deflate=True,
+ deflate_images=True,
+ deflate_fonts=True,
+ use_objstms=1,
+ clean=True,
+ )
+ out.close()
+ logger.info("Saved %s (%d pages)", output_pdf, n)
diff --git a/pdf2zh/render/renderer.py b/pdf2zh/render/renderer.py
new file mode 100644
index 0000000000000000000000000000000000000000..b8a2e9183821fe0e82bcc98ef51f1201a4a447ef
--- /dev/null
+++ b/pdf2zh/render/renderer.py
@@ -0,0 +1,359 @@
+from __future__ import annotations
+
+import logging
+import re
+import tempfile
+from pathlib import Path
+
+import fitz
+
+from .background import RGB, prepare_cover, sample_text_color
+from .compiler import _TYPST_LOCATION, TypstCompileError, compile_typst
+from .config import RenderConfig
+from .labels import skip_oversize_element
+from .markup import (
+ has_bare_latex,
+ has_malformed_typst_math,
+ has_unbalanced_math_tags,
+ is_pure_math_text,
+)
+from .overlay import composite_overlay
+from .sizing import assign_render_sizes
+from .source_builder import build_typst_source
+
+logger = logging.getLogger(__name__)
+
+# Element markup definitions emitted by source_builder: #let e__tm = [...],
+# #let e
__c_md = "...", etc. Used to map compile errors back to elements.
+_ELEMENT_LET_RE = re.compile(r"#let (e\d+_\d+(?:_c\d+)?)_(?:tm|md|body|cover) = ")
+
+# Safety cap for the compile-repair loop; each retry downgrades at least one
+# new element. Large documents (100+ pages of dense math) can have more than a
+# handful of independently-broken elements, so this stays generous — each
+# retry is cheap (one more typst compile) next to failing the whole render.
+_MAX_COMPILE_REPAIRS = 30
+
+
+def _failing_element_vars(source: str, stderr: str) -> set[str]:
+ """Map Typst error line numbers back to the element vars whose markup failed.
+
+ For each ``…overlay.typ:LINE:COL`` in stderr, scan upward from LINE to the
+ nearest ``#let e__…`` definition — that element's markup contains the
+ error. Errors outside any element definition are not attributed.
+ """
+ lines = source.splitlines()
+ found: set[str] = set()
+ for m in _TYPST_LOCATION.finditer(stderr):
+ line_no = min(int(m.group(1)), len(lines))
+ for idx in range(line_no - 1, -1, -1):
+ let_m = _ELEMENT_LET_RE.match(lines[idx])
+ if let_m:
+ found.add(let_m.group(1))
+ break
+ return found
+
+
+def render_document(
+ pdf_path: str | Path,
+ parsed: dict,
+ output_path: str | Path,
+ cfg: RenderConfig,
+) -> dict:
+ """Render translated PDF using Typst-based pipeline.
+
+ Steps:
+ 1. Assign consistent font sizes (cluster per label group).
+ 2. Sample background and text colors per element from original PDF.
+ 3. Build Typst source with absolute-positioned cover rects + text blocks.
+ 4. Compile Typst → overlay PDF.
+ 5. Composite overlay onto original via show_pdf_page.
+ 6. Subset fonts + compress.
+
+ Returns stats dict.
+ """
+ pdf_path = Path(pdf_path)
+ output_path = Path(output_path)
+
+ stats = {
+ "pages": 0,
+ "elements_rendered": 0,
+ "elements_skipped": 0,
+ "cells_rendered": 0,
+ "bg_samples": 0,
+ }
+
+ # 1. Assign sizes
+ sizes = assign_render_sizes(parsed, cfg.sizing)
+ logger.info("Sizing: %d size assignments", len(sizes))
+
+ # 2. Sample colors
+ bg_colors: dict[str, RGB] = {}
+ text_colors: dict[str, RGB] = {}
+ _sample_colors(pdf_path, parsed, cfg, sizes, bg_colors, text_colors, stats)
+
+ # 3. Count rendered/skipped
+ for page_idx, page in enumerate(parsed.get("pages", [])):
+ if cfg.pages is not None and page.get("page_index", page_idx) not in cfg.pages:
+ continue
+ stats["pages"] += 1
+ for elem_idx, elem in enumerate(page.get("elements", [])):
+ category = elem.get("category", "")
+ if category == "BYPASS":
+ continue
+ if category == "TABLE":
+ for cell in elem.get("cells", []):
+ cell_source = cell.get("source_text") or ""
+ if cell_source.strip() and cell.get("translated_text"):
+ stats["cells_rendered"] += 1
+ else:
+ stats["elements_skipped"] += 1
+ else:
+ translated = elem.get("translated_text") or ""
+ source = elem.get("source_text") or ""
+ if translated and translated != source:
+ stats["elements_rendered"] += 1
+ elif translated == source and category == "EQUATION":
+ stats["elements_skipped"] += 1
+ elif translated:
+ stats["elements_rendered"] += 1
+ else:
+ stats["elements_skipped"] += 1
+
+ # 4. Build Typst source
+ typst_source = build_typst_source(parsed, sizes, bg_colors, text_colors, cfg)
+
+ with tempfile.TemporaryDirectory() as tmp_dir:
+ work_dir = Path(tmp_dir)
+
+ if cfg.keep_typst_source:
+ source_path = output_path.with_suffix(".typ")
+ source_path.write_text(typst_source, encoding="utf-8")
+ logger.info("Typst source saved to %s", source_path)
+
+ overlay_pdf = work_dir / "overlay.pdf"
+
+ # 5. Compile — self-healing: if an element's markup breaks the build,
+ # rebuild with that element downgraded to plain text and retry.
+ fallback_vars: set[str] = set()
+ for attempt in range(_MAX_COMPILE_REPAIRS + 1):
+ try:
+ compile_typst(
+ typst_source,
+ font_paths=cfg.typst_font_paths,
+ output_pdf=overlay_pdf,
+ typst_bin=cfg.typst_binary,
+ work_dir=work_dir,
+ )
+ break
+ except TypstCompileError as exc:
+ bad_vars = (
+ _failing_element_vars(typst_source, exc.stderr) - fallback_vars
+ )
+ if not bad_vars or attempt == _MAX_COMPILE_REPAIRS:
+ raise
+ fallback_vars |= bad_vars
+ logger.warning(
+ "typst compile failed; retrying with plain-text fallback for: %s",
+ ", ".join(sorted(bad_vars)),
+ )
+ typst_source = build_typst_source(
+ parsed, sizes, bg_colors, text_colors, cfg, fallback_vars
+ )
+ if cfg.keep_typst_source:
+ output_path.with_suffix(".typ").write_text(
+ typst_source, encoding="utf-8"
+ )
+ if fallback_vars:
+ stats["elements_fallback"] = len(fallback_vars)
+
+ # 6. Redact native text layer if present (non-scanned PDFs)
+ base_pdf = pdf_path
+ if cfg.redact_native_text and _has_native_text(pdf_path):
+ redacted_pdf = work_dir / "redacted.pdf"
+ _redact_text_layer(pdf_path, parsed, bg_colors, cfg, redacted_pdf)
+ base_pdf = redacted_pdf
+ logger.info("Native text layer redacted → %s", redacted_pdf)
+
+ # 7. Composite
+ output_path.parent.mkdir(parents=True, exist_ok=True)
+ composite_overlay(base_pdf, overlay_pdf, output_path, cfg.pages)
+
+ logger.info(
+ "render_document done: pages=%d rendered=%d skipped=%d cells=%d",
+ stats["pages"],
+ stats["elements_rendered"],
+ stats["elements_skipped"],
+ stats["cells_rendered"],
+ )
+ return stats
+
+
+def _has_native_text(pdf_path: Path, max_pages: int = 3) -> bool:
+ doc = fitz.open(str(pdf_path))
+ try:
+ for i in range(min(max_pages, doc.page_count)):
+ if doc[i].get_text("text").strip():
+ return True
+ finally:
+ doc.close()
+ return False
+
+
+def _redact_text_layer(
+ pdf_path: Path,
+ parsed: dict,
+ bg_colors: dict[str, RGB],
+ cfg: RenderConfig,
+ out_path: Path,
+) -> None:
+ """Erase translatable elements from the original text layer via redaction."""
+ doc = fitz.open(str(pdf_path))
+ pad = cfg.background.eraser_padding_pt
+ try:
+ for page_idx, page_data in enumerate(parsed.get("pages", [])):
+ orig = page_data.get("page_index", page_idx)
+ if cfg.pages is not None and orig not in cfg.pages:
+ continue
+ if orig >= doc.page_count:
+ continue
+ page = doc[orig]
+ pw = page_data.get("page_width", page.rect.width)
+ ph = page_data.get("page_height", page.rect.height)
+ had_annot = False
+
+ for elem_idx, elem in enumerate(page_data.get("elements", [])):
+ category = elem.get("category", "")
+ if category == "BYPASS":
+ continue
+ uid = f"p{page_idx}:e{elem_idx}"
+
+ # Mirror the overlay's skip rule exactly: whatever the overlay
+ # will not redraw must not be redacted here, or the original is
+ # erased with nothing put back. Minor/structural elements that
+ # span most of the page are mis-detections — keep the original.
+ if skip_oversize_element(
+ elem.get("label", "Text"),
+ elem.get("bbox_pdf", [0, 0, 10, 10]),
+ pw,
+ ph,
+ ):
+ continue
+
+ if category == "TABLE":
+ for cell_idx, cell in enumerate(elem.get("cells", [])):
+ cell_source = cell.get("source_text") or ""
+ if not cell_source.strip() or not cell.get("translated_text"):
+ continue
+ cell_uid = f"{uid}:c{cell_idx}"
+ # Strip native text only over bbox_text (tight box), not
+ # the whole grid cell — mirrors the overlay's cover_rect
+ # and keeps the cell's borders/background intact.
+ cx0, cy0, cx1, cy1 = cell.get("bbox_text") or cell.get(
+ "bbox_pdf", elem.get("bbox_pdf", [0, 0, 10, 10])
+ )
+ fill = bg_colors.get(cell_uid, (255, 255, 255))
+ page.add_redact_annot(
+ fitz.Rect(cx0 - pad, cy0 - pad, cx1 + pad, cy1 + pad),
+ fill=[c / 255 for c in fill],
+ )
+ had_annot = True
+ else:
+ translated = elem.get("translated_text") or ""
+ source = elem.get("source_text") or ""
+ if not translated:
+ continue
+ if translated.strip() == source.strip():
+ continue
+ if (
+ is_pure_math_text(translated)
+ or has_unbalanced_math_tags(translated)
+ or has_bare_latex(translated)
+ or has_malformed_typst_math(translated)
+ ):
+ continue
+ x0, y0, x1, y1 = elem.get("bbox_pdf", [0, 0, 10, 10])
+ fill = bg_colors.get(uid, (255, 255, 255))
+ page.add_redact_annot(
+ fitz.Rect(x0 - pad, y0 - pad, x1 + pad, y1 + pad),
+ fill=[c / 255 for c in fill],
+ )
+ had_annot = True
+
+ if had_annot:
+ # IMAGE_NONE + LINE_ART_NONE: only strip text layer, don't rasterize
+ page.apply_redactions(
+ images=fitz.PDF_REDACT_IMAGE_NONE,
+ graphics=fitz.PDF_REDACT_LINE_ART_NONE,
+ )
+
+ doc.save(str(out_path), garbage=3, deflate=True)
+ finally:
+ doc.close()
+
+
+def _sample_colors(
+ pdf_path: Path,
+ parsed: dict,
+ cfg: RenderConfig,
+ sizes: dict[str, float],
+ bg_colors: dict[str, RGB],
+ text_colors: dict[str, RGB],
+ stats: dict,
+) -> None:
+ if not cfg.background.enabled and not cfg.text_color.enabled:
+ return
+
+ doc = fitz.open(str(pdf_path))
+ try:
+ for page_idx, page_data in enumerate(parsed.get("pages", [])):
+ orig = page_data.get("page_index", page_idx)
+ if cfg.pages is not None and orig not in cfg.pages:
+ continue
+ if orig >= doc.page_count:
+ continue
+ page = doc[orig]
+ pw = page_data.get("page_width", page.rect.width)
+ ph = page_data.get("page_height", page.rect.height)
+
+ for elem_idx, elem in enumerate(page_data.get("elements", [])):
+ category = elem.get("category", "")
+ if category == "BYPASS":
+ continue
+
+ uid = f"p{page_idx}:e{elem_idx}"
+ bbox = elem.get("bbox_pdf", [0, 0, 10, 10])
+
+ if category == "TABLE":
+ for cell_idx, cell in enumerate(elem.get("cells", [])):
+ cell_source = cell.get("source_text") or ""
+ if not cell_source.strip():
+ continue
+ cell_uid = f"{uid}:c{cell_idx}"
+ # renderer.py:270 — dùng bbox_text (đồng bộ với render/redact), fallback về bbox_pdf
+ cbbox = cell.get("bbox_text") or cell.get("bbox_pdf", bbox)
+ bg = prepare_cover(page, cbbox, pw, ph, cfg.background)
+ bg_colors[cell_uid] = bg.rgb
+ tc = sample_text_color(
+ page, cbbox, pw, ph, bg.rgb, cfg.text_color
+ )
+ text_colors[cell_uid] = tc
+ stats["bg_samples"] += 1
+ else:
+ # User-added boxes may carry explicit color overrides
+ # (review.add_element); honor them instead of sampling.
+ ov_bg = elem.get("bg_color")
+ ov_tc = elem.get("text_color")
+ if ov_bg:
+ bg_rgb = tuple(ov_bg)
+ else:
+ bg_rgb = prepare_cover(page, bbox, pw, ph, cfg.background).rgb
+ bg_colors[uid] = bg_rgb
+ if ov_tc:
+ text_colors[uid] = tuple(ov_tc)
+ else:
+ text_colors[uid] = sample_text_color(
+ page, bbox, pw, ph, bg_rgb, cfg.text_color
+ )
+ stats["bg_samples"] += 1
+ finally:
+ doc.close()
diff --git a/pdf2zh/render/sizing.py b/pdf2zh/render/sizing.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb42727cbffd07be94b62bf1654e57e9be26138a
--- /dev/null
+++ b/pdf2zh/render/sizing.py
@@ -0,0 +1,272 @@
+from __future__ import annotations
+
+import math
+import re
+
+from .config import SizingConfig
+from .labels import group_for_label, normalize_label
+
+_TAG_RE = re.compile(r"<[^>]+>")
+_TYPST_BLOCK_RE = re.compile(r"]*>.*?
", re.DOTALL | re.IGNORECASE)
+
+
+def _autofit(text: str, bbox_w: float, bbox_h: float, cfg: SizingConfig) -> float:
+ """Binary-search the largest font_size where `text` fits in (bbox_w × bbox_h).
+
+ More accurate than the closed-form sqrt model because it correctly handles
+ multi-line wrapping for both short texts (may only need 1 line) and long
+ texts (may need many lines).
+ """
+ n = max(1, len(_TAG_RE.sub("", text).strip()))
+ lo, hi = 4.0, bbox_h # upper bound: can't exceed bbox height
+
+ for _ in range(24): # converges to ~0.001pt precision
+ mid = (lo + hi) / 2.0
+ chars_per_line = max(1.0, bbox_w / (mid * cfg.char_width_ratio))
+ n_lines = math.ceil(n / chars_per_line)
+ needed_h = n_lines * mid * cfg.leading_ratio
+ if needed_h <= bbox_h:
+ lo = mid
+ else:
+ hi = mid
+
+ # Additional cap: autofit should never exceed cap_height_ratio × bbox_h
+ # (single-line glyph height is always a fraction of bbox height).
+ return min(lo, bbox_h * cfg.cap_height_ratio)
+
+
+def _estimate_height(
+ text: str, bbox_w: float, font_size: float, cfg: SizingConfig
+) -> float:
+ """Estimate rendered height of text at font_size in a bbox_w-wide column."""
+ n = max(1, len(_TAG_RE.sub("", text).strip()))
+ chars_per_line = max(1.0, bbox_w / (font_size * cfg.char_width_ratio))
+ n_lines = math.ceil(n / chars_per_line)
+ return n_lines * font_size * cfg.leading_ratio
+
+
+def _overflow_collides(
+ bbox: list[float],
+ text: str,
+ font_size: float,
+ cfg: SizingConfig,
+ other_bboxes: list[list[float]],
+) -> bool:
+ """True if text at font_size overflows bbox AND that overflow region hits another element.
+
+ Single-line elements (h < 2× font_size) overflow horizontally to the right;
+ multi-line elements overflow vertically downward.
+ """
+ x0, y0, x1, y1 = bbox
+ w = max(1.0, x1 - x0)
+ h = max(1.0, y1 - y0)
+ n = max(1, len(_TAG_RE.sub("", text).strip()))
+
+ if h < font_size * 2.0:
+ # Single-line: text extends to the right rather than wrapping down.
+ natural_w = n * font_size * cfg.char_width_ratio
+ if natural_w <= w:
+ return False
+ # Overflow zone: horizontal strip to the right of the bbox.
+ ov_x1 = x0 + natural_w
+ for ob in other_bboxes:
+ ox0, oy0, ox1, oy1 = ob
+ if ox0 < ov_x1 and ox1 > x1 and oy0 < y1 and oy1 > y0:
+ return True
+ return False
+ else:
+ # Multi-line: text wraps and extends downward.
+ needed_h = _estimate_height(text, w, font_size, cfg)
+ if needed_h <= h:
+ return False
+ ov_y0, ov_y1 = y1, y0 + needed_h
+ for ob in other_bboxes:
+ ox0, oy0, ox1, oy1 = ob
+ if ox0 < x1 and ox1 > x0 and oy0 < ov_y1 and oy1 > ov_y0:
+ return True
+ return False
+
+
+def assign_render_sizes(parsed: dict, cfg: SizingConfig) -> dict[str, float]:
+ """Return {uid: font_size_pt} for every element and cell.
+
+ Strategy:
+ 1. Cluster source_text autofits per label+page → source_canonical (the
+ representative size for that group, reflecting original layout intent).
+ 2. For each element: use source_canonical unless translated text overflows
+ AND the overflow region collides with another element on the same page.
+ Harmless overflow (into empty space) is allowed to preserve uniformity.
+ Table cells use one uniform size per table (the source cluster
+ canonical, like regular text) so a text-heavy cell can't shrink all.
+
+ uid format:
+ "p{page_idx}:e{elem_idx}" for elements
+ "p{page_idx}:e{elem_idx}:c{cell_idx}" for table cells
+ """
+ # bucket → [(uid, source_autofit)]
+ raw: dict[str, list[tuple[str, float]]] = {}
+ # uid → translated_text autofit ceiling
+ translated_ceiling: dict[str, float] = {}
+ # uid → {page_idx, bbox, translated} for collision check
+ elem_meta: dict[str, dict] = {}
+ # page_idx → all element bboxes on that page (for collision detection)
+ page_all_bboxes: dict[int, list[list[float]]] = {}
+
+ for page_idx, page in enumerate(parsed.get("pages", [])):
+ all_bboxes: list[list[float]] = []
+ for elem in page.get("elements", []):
+ bbox = elem.get("bbox_pdf")
+ if bbox:
+ all_bboxes.append(bbox)
+ page_all_bboxes[page_idx] = all_bboxes
+
+ for elem_idx, elem in enumerate(page.get("elements", [])):
+ uid = f"p{page_idx}:e{elem_idx}"
+ category = elem.get("category", "")
+ label = normalize_label(elem.get("label", ""))
+ group = group_for_label(label, cfg)
+
+ if category != "BYPASS" and group:
+ source = elem.get("source_text") or ""
+ translated = elem.get("translated_text") or ""
+ bbox = elem.get("bbox_pdf", [0, 0, 10, 10])
+ w = max(1.0, bbox[2] - bbox[0])
+ h = max(1.0, bbox[3] - bbox[1])
+
+ pdf_fs = float(elem.get("font_size") or 0.0)
+ src_fs = (
+ _autofit(source, w, h, cfg)
+ if source.strip()
+ else (pdf_fs if pdf_fs > 0 else cfg.fallback_size)
+ )
+ #