streamtex 0.7.44__tar.gz → 0.7.45__tar.gz

{streamtex-0.7.44/streamtex.egg-info → streamtex-0.7.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamtex
-Version: 0.7.44
+Version: 0.7.45
 Summary: AI-powered content framework for Streamlit — create presentations, courses, and web-books with Claude or Cursor, no coding required.
 Author-email: Nicolas Guelfi <nicolas.guelfi@laposte.net>
 License-Expression: BUSL-1.1

{streamtex-0.7.44 → streamtex-0.7.45}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "streamtex"
-version = "0.7.44"
+version = "0.7.45"
 description = "AI-powered content framework for Streamlit — create presentations, courses, and web-books with Claude or Cursor, no coding required."
 readme = "README.md"
 requires-python = ">=3.11"

{streamtex-0.7.44 → streamtex-0.7.45}/streamtex/ai/history.py

@@ -111,6 +111,13 @@ def save_version(
         base_image=base_image,
         revised_prompt=revised_prompt,
     )
+    if existing_meta:
+        # The display settings belong to the slot, not to one image: a new
+        # version keeps the author's zoom and size (#18).
+        meta.display_zoom = existing_meta.display_zoom
+        meta.display_width = existing_meta.display_width
+        meta.display_height = existing_meta.display_height
+        meta.display_keep_ratio = existing_meta.display_keep_ratio
     save_metadata(meta, current_json)
 
     return current

{streamtex-0.7.44 → streamtex-0.7.45}/streamtex/book.py

@@ -21,6 +21,7 @@ from .enums import Tags
 from .export import (
     ExportConfig,
     ExportMode,
+    apply_view_to_export_html,
     build_export_filename,
     generate_export_html,
     get_asset_collector,
@@ -215,7 +216,8 @@ def _resolve_pdf_base_url() -> str:
 
 def _offer_export_downloads(html: str, base_name: str,
                             pdf_config: PdfConfig | None = None,
-                            paginated: bool = False) -> None:
+                            paginated: bool = False,
+                            html_zoom: int = 0) -> None:
     """Render a 'Download as...' expander with export options and download buttons.
 
     Format checkboxes (HTML / PDF) live **outside** the form so they trigger
@@ -232,7 +234,7 @@ def _offer_export_downloads(html: str, base_name: str,
     # widget keys change, forcing Streamlit to create fresh widgets with
     # the new default values.  Old orphaned keys are harmless.
     _cfg_str = (f"{defaults.format}|{defaults.landscape}|{defaults.print_background}|"
-                f"{defaults.page_numbers}|{defaults.scale}|{defaults.content_width}|"
+                f"{defaults.page_numbers}|{defaults.scale}|{defaults.content_width}|{defaults.zoom}|"
                 f"{defaults.margin_top}|{defaults.margin_bottom}|"
                 f"{defaults.margin_left}|{defaults.margin_right}")
     _cfg_fp = hashlib.md5(_cfg_str.encode()).hexdigest()[:6]
@@ -287,7 +289,16 @@ def _offer_export_downloads(html: str, base_name: str,
             # ── HTML enrichment options ─────────────────────────
             enrich_nav = False
             enrich_title = ""
+            html_zoom_pct = 0
             if want_html:
+                html_zoom_pct = st.number_input(
+                    "Zoom HTML (%)", min_value=0, max_value=400,
+                    value=max(0, min(400, int(html_zoom or 0))), step=10,
+                    key=f"_stx_export_html_zoom_{_pk}_{html_zoom}",
+                    help="0 = the HTML file follows the view zoom (Settings › Zoom %). "
+                         "A value fixes the zoom of the HTML file whatever the screen "
+                         "shows; it replaces the view zoom (the PDF zoom multiplies it).",
+                )
                 st.markdown("**HTML navigation**")
                 enrich_nav = st.checkbox(
                     "Enriched navigation (TOC sidebar, markers, search)",
@@ -316,6 +327,7 @@ def _offer_export_downloads(html: str, base_name: str,
             pdf_background = defaults.print_background
             pdf_page_numbers = defaults.page_numbers
             pdf_scale = defaults.scale
+            pdf_zoom = defaults.zoom
             pdf_content_width = defaults.content_width
             m_top = _margin_mm(defaults.margin_top)
             m_bottom = _margin_mm(defaults.margin_bottom)
@@ -326,7 +338,8 @@ def _offer_export_downloads(html: str, base_name: str,
                 _cur_w = st.session_state.get(_PAGE_WIDTH_KEY, 100)
                 _cur_z = st.session_state.get(_ZOOM_KEY, 100)
                 st.markdown("**PDF layout**")
-                st.caption(f"Current view: Width {_cur_w}% · Zoom {_cur_z}%")
+                st.caption(f"Current view: Zoom {_cur_z}% (carried into the PDF, times Zoom below) · "
+                           f"Width {_cur_w}% (HTML only; the PDF uses Content width)")
                 _FORMAT_OPTIONS = [
                     "16:9", "16:10", "4:3",
                     "A4", "A3", "Letter", "Legal", "Tabloid",
@@ -370,8 +383,19 @@ def _offer_export_downloads(html: str, base_name: str,
                     "Scale (%)", min_value=10, max_value=500,
                     value=_scale_default, step=10,
                     key=f"_stx_pdf_scale_{_pk}",
+                    help="Chrome's print scale: shrinks sizes in pt/px and lets the "
+                         "text reflow; sizes in vw/vh stay proportional to the page. "
+                         "To shrink everything, use Zoom.",
                 )
                 pdf_scale = _pdf_scale_pct / 100.0
+                pdf_zoom = st.number_input(
+                    "Zoom (%)", min_value=10, max_value=400,
+                    value=max(10, min(400, int(defaults.zoom))), step=10,
+                    key=f"_stx_pdf_zoom_{_pk}",
+                    help="Shrinks or enlarges everything in the PDF, sizes in vw/vh "
+                         "included; multiplies with the view zoom (view 80 % x 70 % = 56 %). "
+                         "Scale only shrinks pt/px sizes.",
+                )
                 _cw_default = max(10, min(100, defaults.content_width))
                 pdf_content_width = st.number_input(
                     "Content width (%)", min_value=10, max_value=100,
@@ -404,11 +428,26 @@ def _offer_export_downloads(html: str, base_name: str,
                             rebuild_fn()
                         st.rerun()
                 if full_book_html:
-                    effective_html = full_book_html
+                    # Built once per session with the view of that moment:
+                    # carry the current view zoom and width (#110).
+                    effective_html = apply_view_to_export_html(
+                        full_book_html,
+                        built_view=st.session_state.get(_STX_FULL_EXPORT_VIEW_KEY),
+                        page_width=f"{st.session_state.get(_PAGE_WIDTH_KEY, 100)}%",
+                        zoom=st.session_state.get(_ZOOM_KEY, 100) / 100,
+                    )
 
             if want_html:
                 # Enrich a separate copy — keep effective_html raw for PDF
                 html_download = effective_html
+                if html_zoom_pct:
+                    # A fixed zoom for the HTML file only (#110); the PDF
+                    # keeps the view zoom times its own Zoom.
+                    html_download = apply_view_to_export_html(
+                        html_download,
+                        page_width=f"{st.session_state.get(_PAGE_WIDTH_KEY, 100)}%",
+                        zoom=html_zoom_pct / 100,
+                    )
                 if enrich_nav:
                     try:
                         from .export_enrich import enrich_export_html
@@ -464,6 +503,7 @@ def _offer_export_downloads(html: str, base_name: str,
                             margin_right=f"{m_right}mm",
                             print_background=pdf_background,
                             scale=pdf_scale,
+                            zoom=pdf_zoom,
                             content_width=pdf_content_width,
                             page_numbers=pdf_page_numbers,
                             header_template=defaults.header_template,
@@ -482,6 +522,9 @@ def _offer_export_downloads(html: str, base_name: str,
                                                     report=_report)
                         if _report.timed_out:  # shown with the download button
                             results["pdf_warning"] = _report.message(cfg.load_timeout_ms)
+                        _view_z = st.session_state.get(_ZOOM_KEY, 100)
+                        results["pdf_zoom_note"] = (
+                            f"PDF zoom: view {_view_z:g}% × {pdf_zoom:g}% = {_view_z * pdf_zoom / 100:g}%")
                     except Exception as exc:
                         st.error(f"PDF generation failed after {time.monotonic() - _t0:.0f} s: {exc}")
             st.session_state[state_key] = results
@@ -505,6 +548,8 @@ def _offer_export_downloads(html: str, base_name: str,
                 key=f"_stx_dl_html_{base_name}",
             )
         if "pdf" in results:
+            if results.get("pdf_zoom_note"):
+                st.caption(results["pdf_zoom_note"])
             if results.get("pdf_warning"):
                 st.warning(results["pdf_warning"])
             st.download_button(
@@ -639,7 +684,8 @@ def _st_book_impl(module_list, toc_config: TOCConfig = None, marker_config: Mark
             scale=None,
             block_args: tuple = (),
             block_kwargs: dict | None = None,
-            lang: str | None = None):
+            lang: str | None = None,
+            html_export_zoom: int = 0):
     """Generates a web page e-book from a list of block modules.
 
     :param separator: Optional module with a build() function, rendered between each block.
@@ -663,6 +709,10 @@ def _st_book_impl(module_list, toc_config: TOCConfig = None, marker_config: Mark
     :param page_width: Page width as % of browser width (default 90).
     :param zoom: Default zoom level as % (default 100).
     :param loading: If True (default), show a full-screen overlay with progress during loading.
+    :param html_export_zoom: Starting value of the "Zoom HTML (%)" field of the
+        export panel (#110). ``0`` (default) = the exported HTML follows the
+        view zoom (Settings › Zoom %); a value fixes the zoom of the HTML
+        file whatever the screen shows.
     :param scale: Optional ``ScaleConfig`` to override the indexed responsive
         font scale for this document only. When provided, an inline ``<style>``
         block is emitted after the default CSS load, redefining
@@ -908,6 +958,7 @@ def _st_book_impl(module_list, toc_config: TOCConfig = None, marker_config: Mark
                         pdf_config=pdf_config, exports=exports,
                         inspector=inspector,
                         page_width=page_width, zoom=zoom,
+                        html_export_zoom=html_export_zoom,
                         profile_names=profile_names,
                         active_profile=active_name,
                         profile_modified=_profile_modified,
@@ -1098,7 +1149,8 @@ def _st_book_impl(module_list, toc_config: TOCConfig = None, marker_config: Mark
             )
             if _show_manual:
                 with st.sidebar:
-                    _offer_export_downloads(full_html, base_name, pdf_config=pdf_config)
+                    _offer_export_downloads(full_html, base_name, pdf_config=pdf_config,
+                                            html_zoom=html_export_zoom)
 
     # --- Inspector panel (opt-in, rendered into reserved sidebar placeholder) ---
     if _inspector_placeholder is not None and st.session_state.get("_stx_inspector_open", False):
@@ -1612,6 +1664,7 @@ def _isolate_widget_keys():
 
 
 _STX_FULL_EXPORT_HTML_KEY = "_stx_full_export_html"
+_STX_FULL_EXPORT_VIEW_KEY = "_stx_full_export_view"  # (page_width, zoom) it was built with
 
 
 # Streamlit primitives whose DOM emission is suppressed during the
@@ -1789,6 +1842,7 @@ def _build_page_cache(module_list, toc_config, marker_config, separator,
         full_html = generate_export_html()
         if full_html:
             st.session_state[_STX_FULL_EXPORT_HTML_KEY] = full_html
+            st.session_state[_STX_FULL_EXPORT_VIEW_KEY] = (export_config.page_width, export_config.zoom)
         reset_export_buffer(ExportConfig(enabled=False))
 
     search_index = stop_collector() if use_search else None
@@ -2422,7 +2476,8 @@ def _paginated_book(module_list, toc_config, marker_config, separator,
                     profile_modified=False, all_profiles=None,
                     loading=False,
                     block_args: tuple = (),
-                    block_kwargs: dict | None = None):
+                    block_kwargs: dict | None = None,
+                    html_export_zoom: int = 0):
     """Paginated rendering — only renders one block per rerun."""
     start_time = time.time()
     logger.debug("Starting st_book (paginated)...")
@@ -2725,7 +2780,8 @@ def _paginated_book(module_list, toc_config, marker_config, separator,
             if _show_manual:
                 with st.sidebar:
                     _offer_export_downloads(section_html, base_name,
-                                            pdf_config=pdf_config, paginated=True)
+                                            pdf_config=pdf_config, paginated=True,
+                                            html_zoom=html_export_zoom)
 
     # --- Marker navigation widget (ALL markers, cross-page aware) ---
     # Skip the widget if the current page has no markers (e.g. footer)
@@ -2803,7 +2859,7 @@ def _paginated_book(module_list, toc_config, marker_config, separator,
 #: configuration only — nothing that reaches the content of a block.
 BOOK_DEFAULT_KEYS = frozenset({
     "paginate", "page_width", "zoom", "export", "export_title", "loading",
-    "chrome_banner", "banner_color", "doc_version", "lang",
+    "chrome_banner", "banner_color", "doc_version", "lang", "html_export_zoom",
 })
 
 

{streamtex-0.7.44 → streamtex-0.7.45}/streamtex/cli/deploy_cmd.py

@@ -113,6 +113,16 @@ sys.exit(1) if i < r else sys.exit(0)" || \\
 # Copy project files
 COPY . .
 
+# LaTeX for st_tikz (latex -> dvisvgm), only when the project's code uses it
+# (#17): about 540 MB. The image's own .venv also mentions st_tikz, hence
+# --exclude-dir.
+RUN if grep -rqs --include='*.py' --exclude-dir=.venv "st_tikz" . ; then \\
+        apt-get update && apt-get install -y --no-install-recommends \\
+            texlive-latex-base texlive-latex-recommended texlive-latex-extra \\
+            texlive-pictures dvisvgm ghostscript \\
+        && rm -rf /var/lib/apt/lists/* ; \\
+    fi
+
 # Install any [[packs]] type="local" declared in stx.toml with a relative path.
 # Absolute paths are skipped — handle them upstream via `stx deploy preflight`
 # or by promoting the pack to git (`stx component promote`).

{streamtex-0.7.44 → streamtex-0.7.45}/streamtex/export.py

@@ -465,8 +465,12 @@ class HtmlExportBuffer:
         body = self.get_body_html()
         css = _load_default_css()
         c = self.config
-        bg = c.theme_bg or _get_theme_color("theme.backgroundColor", "#fff")
-        text = c.theme_text or _get_theme_color("theme.textColor", "#333")
+        # ExportConfig > the session's theme (kept by st_book, as the PDF
+        # uses it; a runtime light/dark toggle will write there, #20) > config.
+        bg = (c.theme_bg or _session_theme_color("_stx_theme_bg")
+              or _get_theme_color("theme.backgroundColor", "#fff"))
+        text = (c.theme_text or _session_theme_color("_stx_theme_text")
+                or _get_theme_color("theme.textColor", "#333"))
         link = c.theme_primary or _get_theme_color("theme.primaryColor", "#1155cc")
         zoom_css = f"  zoom: {c.zoom};\n" if c.zoom != 1.0 else ""
         return (
@@ -552,6 +556,15 @@ def _escape_lang(lang: str | None) -> str:
     return "en"
 
 
+def _session_theme_color(key: str) -> str | None:
+    """A theme colour ``st_book`` keeps in session state, or None (no session)."""
+    try:
+        value = st.session_state.get(key)
+    except Exception:  # noqa: BLE001 — outside a Streamlit session
+        return None
+    return value if isinstance(value, str) and value else None
+
+
 def _get_theme_color(option: str, fallback: str) -> str:
     """Read a Streamlit theme color from config, with fallback.
 
@@ -678,6 +691,22 @@ def export_pop_wrapper(close_tag: str) -> None:
         _buffer.pop_wrapper(close_tag)
 
 
+def apply_view_to_export_html(html: str, *, built_view: Optional[tuple] = None,
+                              page_width: str, zoom: float) -> str:
+    """Give an already generated export the current view's page width and zoom.
+
+    The full-book HTML is built once per session; when the view changed
+    since (*built_view* = ``(page_width, zoom)`` it was built with), a later
+    rule on ``.streamtex-page`` replaces the old values (#110). Blocks never
+    read the view's width or zoom, only this page rule does, so no rebuild
+    is needed. Unchanged when the view is the same.
+    """
+    if built_view is not None and tuple(built_view) == (page_width, zoom):
+        return html
+    css = f".streamtex-page {{ max-width: {page_width}; zoom: {zoom:g}; }}"
+    return html.replace("</head>", f"<style>{css}</style>\n</head>", 1)
+
+
 def generate_export_html() -> Optional[str]:
     """Return the full HTML document, or None when export is inactive."""
     if _buffer is None:

{streamtex-0.7.44 → streamtex-0.7.45}/streamtex/image.py

@@ -168,7 +168,6 @@ def st_image(
         _zoom = _st.session_state.get(f"{_prefix}_zoom") if _st else None
         _dw = _st.session_state.get(f"{_prefix}_width") if _st else None
         _dh = _st.session_state.get(f"{_prefix}_height") if _st else None
-        # logger.warning("[DIAG:APPLY] '%s' already_init=%s, zoom=%s, dw=%s, dh=%s, original_width=%s", name, _already_init, _zoom, _dw, _dh, width)
         if _dw:
             width = _dw
         elif _zoom is not None and _zoom != 100:

{streamtex-0.7.44 → streamtex-0.7.45}/streamtex/image_editor.py

@@ -473,17 +473,17 @@ def _load_display_from_metadata(name: str, prefix: str) -> None:
     """Load persisted display settings from metadata JSON into session_state.
 
     Called once per session — if session_state already has values, skip.
+    A load that fails is retried on the next run (#18): the flag is set
+    only once the metadata was read, or found absent.
     """
     init_key = f"{prefix}_initialized"
     if st.session_state.get(init_key):
         return
-    st.session_state[init_key] = True
 
     try:
         from .ai.history import get_current_metadata
         meta = get_current_metadata(name)
         if meta:
-            # logger.warning("[DIAG:LOAD] '%s' zoom=%s width=%s", name, meta.display_zoom, meta.display_width)
             if meta.display_zoom is not None:
                 st.session_state.setdefault(f"{prefix}_zoom", meta.display_zoom)
             if meta.display_width is not None:
@@ -492,12 +492,11 @@ def _load_display_from_metadata(name: str, prefix: str) -> None:
                 st.session_state.setdefault(f"{prefix}_height", meta.display_height)
             if meta.display_keep_ratio is not None:
                 st.session_state.setdefault(f"{prefix}_keep_ratio", meta.display_keep_ratio)
+        st.session_state[init_key] = True
     except Exception:
-        # Best-effort load: if no metadata file exists yet, or it is unreadable,
-        # the image renders with its default display settings (no zoom/width
-        # restoration). Not surfaced to the user — saved settings are an
-        # enhancement, not a correctness requirement.
-        pass
+        # Best-effort load: the image renders with its default display
+        # settings this run, and the load is tried again on the next one.
+        logger.debug("Display settings of '%s' not loaded; will retry", name, exc_info=True)
 
 
 def _persist_display_to_metadata(name: str, prefix: str) -> None:
@@ -508,11 +507,11 @@ def _persist_display_to_metadata(name: str, prefix: str) -> None:
 
         current = get_current(name)
         if not current:
-            logger.warning("[DIAG:PERSIST] '%s' get_current() returned None — cannot persist zoom", name)
+            logger.warning("Display settings of '%s' not saved: no current image", name)
             return
         meta = get_current_metadata(name)
         if not meta:
-            logger.warning("[DIAG:PERSIST] '%s' get_current_metadata() returned None — cannot persist zoom", name)
+            logger.warning("Display settings of '%s' not saved: no metadata", name)
             return
 
         meta.display_zoom = st.session_state.get(f"{prefix}_zoom")
@@ -521,9 +520,8 @@ def _persist_display_to_metadata(name: str, prefix: str) -> None:
         meta.display_keep_ratio = st.session_state.get(f"{prefix}_keep_ratio", True)
         json_path = metadata_path_for(current)
         save_metadata(meta, json_path)
-        logger.warning("[DIAG:PERSIST] '%s' saved display_zoom=%s to %s", name, meta.display_zoom, json_path)
     except Exception:
-        logger.warning("[DIAG:PERSIST] '%s' EXCEPTION in _persist_display_to_metadata", name, exc_info=True)
+        logger.warning("Display settings of '%s' not saved", name, exc_info=True)
 
 
 def _render_display_tab(*, name, width, height, key_base):

{streamtex-0.7.44 → streamtex-0.7.45}/streamtex/media_overlay.py

@@ -34,6 +34,11 @@ _BADGE_BASE_CSS = (
     "pointer-events:none; z-index:2;"
 )
 
+# Opt-in proportional pill (#55): sized on the IMAGE width (container query
+# units resolve against the media box, declared a size container).
+_BADGE_PROPORTIONAL_CSS = _BADGE_BASE_CSS.replace(
+    "padding:2px 8px; font-size:12px;", "padding:0.15em 0.6em; font-size:clamp(9px, 7cqw, 22px);")
+
 # margin declarations carrying an ``auto`` value (centering).  They must be
 # transferred from the media style onto the wrapper — an auto margin left on
 # the media alone stops centering once the media is boxed in a wrapper.
@@ -51,12 +56,21 @@ class MediaOverlay:
         overrides it in cascade order) — e.g. a project convention.
     :param aria_label: Accessible disclosure text (e.g. AI-transparency
         wording, art. 50 AI Act); emitted as ``aria-label`` when non-empty.
+    :param proportional: Size the badge on the image rather than the
+        viewport (#55): the media box becomes a size container and the
+        default pill uses ``clamp(9px, 7cqw, 22px)``, so a thumbnail and a
+        hero get proportionate badges; ``cqw`` also works in ``css``. Needs
+        a definite width (``st_image``'s default ``100%`` or an explicit
+        one): with ``width="auto"`` the box is left as is (a size container
+        cannot shrink-wrap its image) and ``cqw`` falls back to the viewport.
+        Off by default: output byte-identical to earlier versions.
     """
 
     text: str
     position: str = "bottom-right"
     css: str = ""
     aria_label: str = ""
+    proportional: bool = False
 
     def __post_init__(self):
         if self.position not in _POSITION_CSS:
@@ -74,7 +88,8 @@ def build_overlay_span(overlay: MediaOverlay) -> str:
     guarantees the badge never intercepts clicks (link wrapping stays fully
     functional).
     """
-    badge_css = f"position:absolute; {_POSITION_CSS[overlay.position]} {_BADGE_BASE_CSS}"
+    base = _BADGE_PROPORTIONAL_CSS if overlay.proportional else _BADGE_BASE_CSS
+    badge_css = f"position:absolute; {_POSITION_CSS[overlay.position]} {base}"
     if overlay.css:
         badge_css = f"{badge_css} {overlay.css}"
     aria_attr = (
@@ -122,6 +137,8 @@ def wrap_media_overlay(
             f"position:relative; display:inline-block; width:{box_width}; "
             f"max-width:100%; line-height:0;"
         )
+    if overlay.proportional and box_width not in ("auto", "fit-content"):
+        box_css = f"{box_css} container-type:inline-size;"
     return (
         f'<span class="stx-media-box" style="{box_css}">'
         f"{inner_html}{build_overlay_span(overlay)}</span>"

{streamtex-0.7.44 → streamtex-0.7.45}/streamtex/pdf_export.py

@@ -68,7 +68,20 @@ class PdfConfig:
     """Include background colors and gradients in the PDF."""
 
     scale: float = 1.0
-    """Scale factor (0.1–2.0). 1.0 = 100%."""
+    """Chromium's print scale (0.1–2.0), like "Scale" in Chrome's print dialog.
+
+    Shrinks what is sized in ``pt``/``px`` and lets the text reflow on the
+    gained width; what is sized in ``vw``/``vh`` stays proportional to the
+    page (Chromium resolves viewport units against the printed page).  To
+    shrink everything uniformly, use :attr:`zoom`."""
+
+    zoom: int = 100
+    """Zoom of the whole document in the PDF, in percent (10–400; #110).
+
+    A CSS ``zoom`` on ``body``, so it scales ``px``, ``pt``, ``vw`` and ``vh``
+    alike, and it multiplies with the view zoom the exported HTML already
+    carries (view 80 % × PDF 70 % = 56 %).  The page still fills the paper
+    width; bookmarks and page breaks are unchanged.  ``100`` = no change."""
 
     content_width: int = 100
     """Content width as percentage of the page (10–100).
@@ -333,18 +346,34 @@ def _inject_content_width_css(html: str, content_width: int) -> str:
     cw = max(10, min(100, content_width))
     padding_pct = (100 - cw) / 2
 
+    # Left and right only (#110): a percentage padding resolves against the
+    # width, so on all four sides it also pushed the content down by the
+    # same amount (15 % of the page width at 70 %).
     css = (
         f".streamtex-page {{"
         f" max-width: 100% !important;"
         f" width: 100% !important;"
         f" margin: 0 !important;"
-        f" padding: {padding_pct:.1f}% !important;"
+        f" padding: 0 {padding_pct:.1f}% !important;"
         f" box-sizing: border-box !important;"
         f"}}"
     )
     return html.replace("</head>", f"<style>{css}</style>\n</head>")
 
 
+def _inject_zoom_css(html: str, zoom: int) -> str:
+    """Zoom the whole document by *zoom* percent (CSS ``zoom`` on ``body``).
+
+    ``body`` rather than ``.streamtex-page``: the page already carries the
+    view zoom, and zooms on nested elements multiply, where a second rule on
+    the same element would replace it.  No-op at 100.
+    """
+    z = max(10, min(400, int(zoom)))
+    if z == 100:
+        return html
+    return html.replace("</head>", f"<style>body {{ zoom: {z / 100:g}; }}</style>\n</head>")
+
+
 # ---------------------------------------------------------------------------
 # TOC → PDF Bookmarks
 # ---------------------------------------------------------------------------
@@ -532,6 +561,7 @@ def export_pdf(
 
     # Inject content-width CSS if narrower than 100%
     html = _inject_content_width_css(html, cfg.content_width)
+    html = _inject_zoom_css(html, cfg.zoom)
 
     # Inject TOC headings for PDF bookmark generation
     use_outline = False

{streamtex-0.7.44 → streamtex-0.7.45}/streamtex/static/default.css

@@ -68,6 +68,7 @@ a {
     --stx-GIANT-size: 196pt;
     --stx-Giant-size: 128pt;
     --stx-giant-size: 112pt;
+    --stx-HUGE-size: 104pt;
     --stx-Huge-size: 96pt;
     --stx-huge-size: 80pt;
     --stx-LARGE-size: 64pt;
@@ -130,6 +131,7 @@ a {
         --stx-GIANT-size: 128pt;
         --stx-Giant-size: 84pt;
         --stx-giant-size: 74pt;
+        --stx-HUGE-size: 69pt;
         --stx-Huge-size: 64pt;
         --stx-huge-size: 54pt;
         --stx-LARGE-size: 48pt;
@@ -192,6 +194,7 @@ a {
         --stx-GIANT-size: 80pt;
         --stx-Giant-size: 56pt;
         --stx-giant-size: 48pt;
+        --stx-HUGE-size: 45pt;
         --stx-Huge-size: 42pt;
         --stx-huge-size: 36pt;
         --stx-LARGE-size: 32pt;

{streamtex-0.7.44 → streamtex-0.7.45}/streamtex/styles/__init__.py

@@ -18,7 +18,7 @@ from .text import (
 from .container import (
     BackgroundColors, Paddings, Margins, ContainerSizes,
     Flex, Layouts, Borders, Positions,
-    ListStyles, GridStyles, Container,
+    ListStyles, GridStyles, CellAlignments, Container,
 )
 
 # Visibility

{streamtex-0.7.44 → streamtex-0.7.45}/streamtex/styles/base.py

@@ -26,6 +26,8 @@ class StxStyles:
     reset_bold = text.weights.normal_weight
     italic = text.decors.italic_text
     center_txt = text.alignments.center_align
+    cell_center = container.cells.center
+    """Grid cell content centered both ways (``Container.cells.center_middle``)."""
 
     reset = (text.colors.reset + BackgroundColors.reset_bg
              + text.weights.normal_weight + text.sizes.medium_size + text.alignments.left_align)
@@ -35,33 +37,33 @@ class StxStyles:
     ``st_mermaid``, or ``st_tikz`` to make diagrams readable on dark pages."""
 
     GIANT = text.sizes.GIANT_size
-    """196pt"""
+    """196pt on desktop (default.css)"""
     Giant = text.sizes.Giant_size
-    """160pt"""
+    """128pt on desktop (default.css)"""
     giant = text.sizes.giant_size
-    """128pt"""
+    """112pt on desktop (default.css)"""
     HUGE = text.sizes.HUGE_size
-    """96pt"""
+    """104pt on desktop (default.css)"""
     Huge = text.sizes.Huge_size
-    """80pt"""
+    """96pt on desktop (default.css)"""
     huge = text.sizes.huge_size
-    """64pt"""
+    """80pt on desktop (default.css)"""
     LARGE = text.sizes.LARGE_size
-    """48pt"""
+    """64pt on desktop (default.css)"""
     Large = text.sizes.Large_size
-    """32pt"""
+    """48pt on desktop (default.css)"""
     large = text.sizes.large_size
-    """24pt"""
+    """32pt on desktop (default.css)"""
     big = text.sizes.big_size
-    """16pt"""
+    """24pt on desktop (default.css)"""
     medium = text.sizes.medium_size
-    """12pt"""
+    """16pt on desktop (default.css)"""
     little = text.sizes.little_size
-    """8pt"""
+    """12pt on desktop (default.css)"""
     small = text.sizes.small_size
-    """6pt"""
+    """8pt on desktop (default.css)"""
     tiny = text.sizes.tiny_size
-    """4pt"""
+    """4pt on desktop (default.css)"""
 
     # --- Indexed responsive scale (subscript access) ---
     class _IndexedScale: