texsmith 0.0.2.dev0__py3-none-any.whl

texsmith/fragments/fonts/fragment.toml

@@ -0,0 +1,3 @@
+name = "ts-fonts"
+description = "Font selection driven by fonts.family (XeLaTeX/LuaLaTeX compatible)."
+entrypoint = "texsmith.fragments.fonts:fragment"

texsmith/fragments/fonts/ts-fonts.jinja.sty

@@ -0,0 +1,292 @@
+\BLOCK{ set font_family = fonts_family | default("lm") }
+\BLOCK{ set fallback = fonts.get("fallback") if fonts is defined and fonts else {} }
+\ProvidesPackage{ts-fonts}[2025/01/10 TeXSmith font selection (generated)]
+
+\RequirePackage{iftex}
+% Fallback definition replaced when emoji fonts are available.
+\providecommand{\texsmithEmoji}[1]{\textbf{!}}
+\catcode"2135=\active
+\protected\def^^^^2135{\ensuremath{\aleph}}
+
+\ifPDFTeX
+  \PackageError{ts-fonts}{ts-fonts requires XeLaTeX or LuaLaTeX}{Switch to xelatex or lualatex.}
+\else
+  \RequirePackage{fontspec}
+  \defaultfontfeatures{Ligatures = TeX, Scale = MatchLowercase}
+
+  \makeatletter
+  \newcommand{\tsDeclareFontSet}[2]{%
+    \expandafter\gdef\csname tssetupfonts@#1\endcsname{#2}%
+  }
+  \newcommand{\tsUseFontSet}[1]{%
+    \@ifundefined{tssetupfonts@#1}{%
+      \PackageError{ts-fonts}{Unknown font family '#1'}%
+        {Use one of: lm, lm-sans, bonum, libertinus, pagella, termes, schola, heros, adventor, cursor, plex, pennstander.}%
+    }{%
+      \csname tssetupfonts@#1\endcsname
+    }%
+  }
+  \makeatother
+
+  % Latin Modern (lm)
+  \tsDeclareFontSet{lm}{%
+    \ifLuaTeX
+      \setmainfont{Latin Modern Roman}%
+      \setsansfont{Latin Modern Sans}%
+      \setmonofont{Latin Modern Mono}%
+    \else
+      \setmainfont{lmroman10}[%
+        Extension       = .otf,
+        UprightFont     = lmroman10-regular,
+        ItalicFont      = lmroman10-italic,
+        BoldFont        = lmroman10-bold,
+        BoldItalicFont  = lmroman10-bolditalic,
+        SmallCapsFont   = lmromancaps10-regular,
+        SlantedFont     = lmromanslant10-regular,
+        BoldSlantedFont = lmromanslant10-bold,
+        Ligatures       = TeX,
+      ]%
+      \setsansfont{lmsans10}[%
+        Extension      = .otf,
+        UprightFont    = *-regular,
+        ItalicFont     = *-oblique,
+        BoldFont       = *-bold,
+        BoldItalicFont = *-boldoblique,
+      ]%
+      \setmonofont{lmmono10}[%
+        Extension      = .otf,
+        UprightFont    = *-regular,
+        ItalicFont     = *-italic,
+        BoldFont       = *-regular,
+        BoldFeatures   = {FakeBold=2},
+        BoldItalicFont = *-italic,
+        BoldItalicFeatures = {FakeBold=2},
+        SmallCapsFont   = lmmonocaps10-regular,
+        SmallCapsFeatures = {Letters=SmallCaps},
+      ]%
+    \fi
+  }
+
+  % Latin Modern Sans Serif (lm-sans)
+  \tsDeclareFontSet{lm-sans}{%
+    \ifLuaTeX
+      \setmainfont{Latin Modern Sans}%
+      \setsansfont{Latin Modern Sans}%
+      \setmonofont{Latin Modern Mono}%
+    \else
+      \setmainfont{lmsans10}[%
+        Extension      = .otf,
+        UprightFont    = *-regular,
+        ItalicFont     = *-oblique,
+        BoldFont       = *-bold,
+        BoldItalicFont = *-boldoblique,
+        Ligatures      = TeX,
+      ]%
+      \setsansfont{lmsans10}[%
+        Extension      = .otf,
+        UprightFont    = *-regular,
+        ItalicFont     = *-oblique,
+        BoldFont       = *-bold,
+        BoldItalicFont = *-boldoblique,
+      ]%
+      \setmonofont{IBMPlexMono}[%
+        Extension      = .otf,
+        UprightFont    = *-Regular,
+        ItalicFont     = *-Italic,
+        BoldFont       = *-Bold,
+        BoldItalicFont = *-BoldItalic,
+        Scale=0.90,
+        FakeStretch    = 0.92,
+      ]%
+    \fi
+  }
+
+  % Tex Gyre Bonum (bonum)
+  \tsDeclareFontSet{bonum}{%
+    \RequirePackage{bonum-otf}%
+  }
+
+  % Libertinus (libertinus)
+  \tsDeclareFontSet{libertinus}{%
+    \RequirePackage{libertinus}%
+  }
+
+  % Tex Gyre Pagella (pagella)
+  \tsDeclareFontSet{pagella}{%
+    \RequirePackage{pagella-otf}%
+  }
+
+  % Tex Gyre Termes (termes)
+  \tsDeclareFontSet{termes}{%
+    \RequirePackage{termes-otf}%
+  }
+
+  % TeX Gyre Schola (schola)
+  \tsDeclareFontSet{schola}{%
+    \RequirePackage{schola-otf}%
+  }
+
+  % TeX Gyre Heros (heros)
+  \tsDeclareFontSet{heros}{%
+    \RequirePackage{heros-otf}%
+  }
+
+  % TeX Gyre Adventor (adventor)
+  \tsDeclareFontSet{adventor}{%
+    \RequirePackage{adventor-otf}%
+  }
+
+  % TeX Gyre Cursor (cursor)
+  \tsDeclareFontSet{cursor}{%
+    \RequirePackage{cursor-otf}%
+  }
+
+  % IBM Plex (plex)
+  \tsDeclareFontSet{plex}{%
+    \setmainfont{IBMPlexSerif}[%
+      Path=./fonts/plex-otf/,%
+      UprightFont=*-Regular,%
+      ItalicFont=*-Italic,%
+      BoldFont=*-Bold,%
+      BoldItalicFont=*-BoldItalic,%
+    ]%
+    \setsansfont{IBMPlexSans}[%
+      Path=./fonts/plex-otf/,%
+      UprightFont=*-Regular,%
+      ItalicFont=*-Italic,%
+      BoldFont=*-Bold,%
+      BoldItalicFont=*-BoldItalic,%
+    ]%
+    \setmonofont{IBMPlexMono}[%
+      Path=./fonts/plex-otf/,%
+      UprightFont=*-Regular,%
+      ItalicFont=*-Italic,%
+      BoldFont=*-Bold,%
+      BoldItalicFont=*-BoldItalic,%
+    ]%
+  }
+
+  % Penn Stander (pennstander)
+  \tsDeclareFontSet{pennstander}{%
+    \setmainfont{Latin Modern Roman}%
+    \setsansfont{Latin Modern Sans}%
+    \setmonofont{Latin Modern Mono}%
+  }
+
+  \tsUseFontSet{\VAR{font_family}}
+
+  \BLOCK{- if fallback and fallback.get("entries") }
+  % Fallback script fonts
+  \makeatletter
+  \BLOCK{ for entry in fallback.entries }
+  \BLOCK{ set font_cmd = '\\' + entry.font_command }
+  \BLOCK{ set text_cmd = '\\' + entry.text_command }
+    % Declare font family for \VAR{entry.font_name}
+    \newfontfamily\VAR{font_cmd}[
+      Path = fonts/,
+      Extension = \VAR{entry.extension},
+      UprightFont = \VAR{entry.upright},
+\BLOCK{ if entry.has_bold }
+      BoldFont = \VAR{entry.bold},
+\BLOCK{ else }
+      FakeBold = 2,
+\BLOCK{ endif }
+      Scale = MatchLowercase
+    ]{\VAR{entry.font_name}}%
+    \DeclareRobustCommand\VAR{text_cmd}[1]{{\VAR{font_cmd}#1}}%
+
+  \BLOCK{ endfor }
+  \makeatother
+
+\BLOCK{- if fallback and fallback.get("entries") }
+  % Ensure hyperref can build PDF strings without font selection commands.
+  \makeatletter
+  \AtBeginDocument{%
+  \BLOCK{ for entry in fallback.entries }
+    \BLOCK{ set text_cmd = '\\' + entry.text_command }
+      \pdfstringdefDisableCommands{%
+        \def\VAR{text_cmd}#1{#1}%
+      }%
+  \BLOCK{ endfor }
+  }
+  \makeatother
+\BLOCK{- endif }
+
+\BLOCK{- if fallback and fallback.get("missing_commands") }
+  % Define no-op wrappers for scripts without an available fallback font.
+  \BLOCK{ for text_cmd in fallback.missing_commands }
+    \providecommand\VAR{'\\' + text_cmd}[1]{#1}%
+  \BLOCK{ endfor }
+\BLOCK{- endif }
+
+  \ifLuaTeX
+    \directlua{
+      luaotfload.add_fallback("texsmith-fallback-reg", {
+    \BLOCK{ for font in fallback.lua_regular }
+        "[fonts/\VAR{font}]:mode=harf",
+    \BLOCK{ endfor }
+      })
+      luaotfload.add_fallback("texsmith-fallback-bold", {
+    \BLOCK{ for font in fallback.lua_bold }
+        "[fonts/\VAR{font}]:mode=harf",
+    \BLOCK{ endfor }
+      })
+    }
+    \defaultfontfeatures{
+      Renderer           = HarfBuzz,
+      RawFeature         = {fallback=texsmith-fallback-reg},
+      BoldFeatures       = {RawFeature={fallback=texsmith-fallback-bold}},
+      ItalicFeatures     = {RawFeature={fallback=texsmith-fallback-reg}},
+      BoldItalicFeatures = {RawFeature={fallback=texsmith-fallback-bold}},
+    }
+    \addfontfeatures{RawFeature={fallback=texsmith-fallback-reg}}
+    \ExplSyntaxOn
+    \cs_new_protected:Npn \texsmith_apply_fallback_to_family:nn #1#2
+      {
+        \prop_get:cnNTF { g__fontspec_fontinfo_ #2 _prop } { fontname } \l_tmpa_tl
+          {
+            #1[
+              RawFeature         = {fallback=texsmith-fallback-reg},
+              BoldFeatures       = {RawFeature={fallback=texsmith-fallback-bold}},
+              ItalicFeatures     = {RawFeature={fallback=texsmith-fallback-reg}},
+              BoldItalicFeatures = {RawFeature={fallback=texsmith-fallback-bold}},
+            ]{\l_tmpa_tl}
+          }{}
+      }
+    \texsmith_apply_fallback_to_family:nn \setmainfont \rmdefault
+    \texsmith_apply_fallback_to_family:nn \setsansfont \sfdefault
+    \texsmith_apply_fallback_to_family:nn \setmonofont \ttdefault
+    \ExplSyntaxOff
+  \else\ifXeTeX
+  \BLOCK{- if fallback and fallback.get("transitions") }
+  \BLOCK{ set uc_options = ['Latin'] + (fallback.package_options if fallback else []) + ['Devanagari'] }
+    \RequirePackage[
+      \VAR{ uc_options | join(',\n      ') }
+    ]{ucharclasses}
+    \makeatletter
+    \newcommand{\texsmithFallbackFamily}{\rmfamily}
+    \newcommand{\texsmithSetFallbackFamily}[1]{\def\texsmithFallbackFamily{#1}}
+    \g@addto@macro\rmfamily{\texsmithSetFallbackFamily{\rmfamily}}
+    \g@addto@macro\sffamily{\texsmithSetFallbackFamily{\sffamily}}
+    \g@addto@macro\ttfamily{\texsmithSetFallbackFamily{\ttfamily}}
+    \BLOCK{ for entry in fallback.entries }
+      \expandafter\g@addto@macro\csname \VAR{entry.font_command}\endcsname{%
+        \texsmithSetFallbackFamily{\csname \VAR{entry.font_command}\endcsname}%
+      }
+    \BLOCK{ endfor }
+    \makeatother
+    \texsmithSetFallbackFamily{\rmfamily}
+    \setDefaultTransitions{\texsmithFallbackFamily}{\texsmithFallbackFamily}%
+    \BLOCK{ for transition in fallback.transitions }
+    \VAR{transition}
+    \BLOCK{ endfor }
+    \enableTransitionRules
+    \ifdefined\XeTeXinterchartoksstate
+      \XeTeXinterchartoksstate=1%
+      \AtBeginDocument{\XeTeXinterchartoksstate=1}%
+    \fi
+    \AtBeginDocument{\enableTransitionRules}%
+  \BLOCK{- endif }
+  \fi\fi
+  \BLOCK{- endif }
+\fi

texsmith/fragments/frame/__init__.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any, ClassVar
+
+from pydantic import BaseModel, ConfigDict, Field, ValidationError, field_validator, model_validator
+
+from texsmith.core.fragments.base import BaseFragment, FragmentPiece
+from texsmith.core.templates.manifest import TemplateAttributeSpec, TemplateError
+
+
+_DEFAULT_MARGIN = "0pt"
+_DEFAULT_FOLD_SIZE = "10mm"
+
+
+def _coerce_bool(value: Any, *, default: bool = False) -> bool:
+    if value is None:
+        return default
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, (int, float)):
+        return bool(value)
+    if isinstance(value, str):
+        token = value.strip().lower()
+        if not token:
+            return default
+        if token in {"true", "yes", "on", "1", "dogear"}:
+            return True
+        if token in {"false", "no", "off", "0", "border"}:
+            return False
+    return default
+
+
+class FrameConfig(BaseModel):
+    """Validated representation of the press.frame options."""
+
+    model_config = ConfigDict(extra="ignore", populate_by_name=True)
+
+    enabled: bool = False
+    dogear: bool = False
+    margin: str | None = None
+    fold_size: str | None = Field(default=None, alias="fold-size")
+
+    @model_validator(mode="before")
+    @classmethod
+    def _coerce_payload(cls, data: Any) -> Any:
+        if isinstance(data, FrameConfig):
+            return data.model_dump()
+        if data is None:
+            return {"enabled": False}
+        if isinstance(data, Mapping):
+            payload = dict(data)
+            enabled = _coerce_bool(payload.get("enabled"), default=True)
+            mode = payload.get("mode")
+            dogear_value = payload.get("dogear")
+            if isinstance(mode, str):
+                token = mode.strip().lower()
+                if token == "border":
+                    dogear_value = False
+                    enabled = True
+                elif token in {"dogear", "fold"}:
+                    dogear_value = True
+                    enabled = True
+            dogear_flag = _coerce_bool(dogear_value, default=True)
+            fold_size = payload.get("fold-size") or payload.get("fold_size") or payload.get("fold")
+            margin = payload.get("margin")
+            if not enabled:
+                return {"enabled": False}
+            return {
+                "enabled": True,
+                "dogear": dogear_flag,
+                "margin": margin,
+                "fold_size": fold_size,
+            }
+        if isinstance(data, (bool, int, float)):
+            flag = bool(data)
+            return {"enabled": flag, "dogear": flag}
+        if isinstance(data, str):
+            token = data.strip().lower()
+            if not token or token in {"false", "off", "no", "0", "none"}:
+                return {"enabled": False}
+            if token == "border":
+                return {"enabled": True, "dogear": False}
+            if token in {"dogear", "true", "yes", "on", "1"}:
+                return {"enabled": True, "dogear": True}
+            raise TemplateError("press.frame accepts false, true, 'border', or 'dogear'.")
+        raise TemplateError("press.frame must be a boolean, string, or mapping.")
+
+    @field_validator("margin", "fold_size", mode="before")
+    @classmethod
+    def _normalise_length(cls, value: Any) -> str | None:
+        if value is None:
+            return None
+        if isinstance(value, (int, float)):
+            return f"{value}mm"
+        if isinstance(value, str):
+            trimmed = value.strip()
+            return trimmed or None
+        return str(value)
+
+    @model_validator(mode="after")
+    def _disable_when_empty(self) -> FrameConfig:
+        if not self.enabled:
+            object.__setattr__(self, "dogear", False)
+        return self
+
+    def effective_margin(self) -> str:
+        return self.margin or _DEFAULT_MARGIN
+
+    def effective_fold_size(self) -> str:
+        return self.fold_size or _DEFAULT_FOLD_SIZE
+
+
+class FrameFragment(BaseFragment[FrameConfig]):
+    """Optional page frame with an optional folded corner."""
+
+    name: ClassVar[str] = "ts-frame"
+    description: ClassVar[str] = "Draw a page frame (with optional dogear) on each page."
+    pieces: ClassVar[list[FragmentPiece]] = [
+        FragmentPiece(
+            template_path=Path(__file__).with_name("ts-frame.tex.jinja"),
+            kind="inline",
+            slot="extra_packages",
+        )
+    ]
+    attributes: ClassVar[dict[str, TemplateAttributeSpec]] = {
+        "frame_spec": TemplateAttributeSpec(
+            default=None,
+            sources=["frame"],
+        )
+    }
+    config_cls: ClassVar[type[FrameConfig]] = FrameConfig
+    source: ClassVar[Path] = Path(__file__).with_name("ts-frame.tex.jinja")
+    context_defaults: ClassVar[dict[str, Any]] = {
+        "ts_frame_enabled": False,
+        "ts_frame_dogear": False,
+        "ts_frame_margin": _DEFAULT_MARGIN,
+        "ts_frame_fold_size": _DEFAULT_FOLD_SIZE,
+    }
+
+    def build_config(
+        self, context: Mapping[str, Any], overrides: Mapping[str, Any] | None = None
+    ) -> FrameConfig:
+        _ = overrides
+        raw_value = context.get("frame_spec") or context.get("frame")
+        try:
+            return self.config_cls.model_validate(raw_value)
+        except ValidationError as exc:
+            raise TemplateError(f"Invalid frame settings: {exc}") from exc
+
+    def inject(
+        self,
+        config: FrameConfig,
+        context: dict[str, Any],
+        overrides: Mapping[str, Any] | None = None,
+    ) -> None:
+        _ = overrides
+        context["ts_frame_enabled"] = config.enabled
+        context["ts_frame_dogear"] = bool(config.enabled and config.dogear)
+        context["ts_frame_margin"] = config.effective_margin()
+        context["ts_frame_fold_size"] = config.effective_fold_size()
+
+    def should_render(self, config: FrameConfig) -> bool:
+        return bool(config.enabled)
+
+
+fragment = FrameFragment()
+
+__all__ = ["FrameConfig", "FrameFragment", "fragment"]

texsmith/fragments/frame/fragment.toml

@@ -0,0 +1,3 @@
+name = "ts-frame"
+description = "Optional page frame with an optional folded corner."
+entrypoint = "texsmith.fragments.frame:fragment"

texsmith/fragments/frame/ts-frame.tex.jinja

@@ -0,0 +1,49 @@
+% Page frame fragment (ts-frame)
+\usepackage{tikz}
+\usetikzlibrary{calc}
+\usepackage{tikzpagenodes}
+
+\newif\iftsframe
+\newif\iftsframedogear
+\BLOCK{ if ts_frame_enabled }\tsframetrue\BLOCK{ else }\tsframefalse\BLOCK{ endif }
+\BLOCK{ if ts_frame_dogear }\tsframedogeartrue\BLOCK{ else }\tsframedogearfalse\BLOCK{ endif }
+
+\newlength\TSFrameInset
+\setlength\TSFrameInset{\VAR{ts_frame_margin|default('0pt')}}
+\newlength\TSFrameFoldSize
+\setlength\TSFrameFoldSize{\VAR{ts_frame_fold_size|default('10mm')}}
+\newcommand\TSFrameColor{black}
+\newcommand\TSFrameLineWidth{0.6pt}
+
+\AddToHook{shipout/background}{%
+  \iftsframe
+    \begin{tikzpicture}[remember picture,overlay]
+      \coordinate (A) at ($(current page.north west)+(\TSFrameInset,-\TSFrameInset)$);
+      \coordinate (B) at ($(current page.north east)+(-\TSFrameInset,-\TSFrameInset)$);
+      \coordinate (C) at ($(current page.south east)+(-\TSFrameInset,\TSFrameInset)$);
+      \coordinate (D) at ($(current page.south west)+(\TSFrameInset,\TSFrameInset)$);
+
+      \coordinate (Bdown)  at ($(B)-(0,\TSFrameFoldSize)$);
+      \coordinate (Bleft)  at ($(B)-(\TSFrameFoldSize,0)$);
+      \coordinate (Corner) at ($(B)-(\TSFrameFoldSize,\TSFrameFoldSize)$);
+
+      \iftsframedogear
+        \draw[line width=\TSFrameLineWidth,draw=\TSFrameColor]
+          (A) -- (Bleft) -- (Bdown) -- (C) -- (D) -- cycle;
+        \draw[line width=\TSFrameLineWidth,draw=\TSFrameColor]
+          (Corner)
+          .. controls ($(Corner)+(0.3*\TSFrameFoldSize,0.1*\TSFrameFoldSize)$)
+               and ($(Bdown)+(-0.3*\TSFrameFoldSize,-0.1*\TSFrameFoldSize)$) ..
+          (Bdown);
+        \draw[line width=\TSFrameLineWidth,draw=\TSFrameColor]
+          (Bleft)
+          .. controls ($(Bleft)+(0.1*\TSFrameFoldSize,-0.3*\TSFrameFoldSize)$)
+               and ($(Corner)+(-0.1*\TSFrameFoldSize,0.3*\TSFrameFoldSize)$) ..
+          (Corner);
+      \else
+        \draw[line width=\TSFrameLineWidth,draw=\TSFrameColor]
+          (A) rectangle (C);
+      \fi
+    \end{tikzpicture}%
+  \fi
+}

texsmith/fragments/geometry/__init__.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any, ClassVar
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from texsmith.core.fragments.base import BaseFragment, FragmentPiece
+from texsmith.core.templates.base import _build_environment
+
+from .paper import (
+    GeometryResolution,
+    _coerce_marks_flag,
+    inject_geometry_context,
+    resolve_geometry_settings,
+)
+
+
+class GeometryFragmentConfig(BaseModel):
+    """Validated payload accepted by the ts-geometry fragment."""
+
+    paper: Mapping[str, Any] | None = None
+    geometry: dict[str, Any] = Field(default_factory=dict)
+    duplex: bool | None = None
+    margin: Any | None = None
+    orientation: Any | None = None
+    binding: Any | None = None
+    marks: bool | None = None
+    watermark: str | None = None
+
+    model_config = ConfigDict(extra="allow")
+
+    @model_validator(mode="before")
+    @classmethod
+    def _fold_paper(cls, data: Any) -> Any:
+        if data is None:
+            return {}
+        if not isinstance(data, Mapping):
+            return {"paper": data}
+
+        payload = dict(data)
+        paper_payload = payload.get("paper")
+        if isinstance(paper_payload, Mapping):
+            paper_data: dict[str, Any] = dict(paper_payload)
+        elif paper_payload is None:
+            paper_data = {}
+        else:
+            paper_data = {"format": paper_payload}
+
+        if "frame" in payload and "marks" not in payload:
+            payload["marks"] = payload.pop("frame")
+
+        for key in ("margin", "orientation", "binding", "marks", "watermark", "duplex"):
+            if key in payload and key not in paper_data:
+                paper_data[key] = payload[key]
+
+        extra_payload = payload.get("geometry") or payload.get("extra")
+        if isinstance(extra_payload, Mapping):
+            merged_extra = dict(paper_data.get("extra") or {})
+            merged_extra.update(extra_payload)
+            paper_data["extra"] = merged_extra
+
+        payload["paper"] = paper_data
+        return payload
+
+    def to_context(self) -> dict[str, Any]:
+        """Return a context mapping suitable for ``resolve_geometry_settings``."""
+        context: dict[str, Any] = {}
+        if self.paper is not None:
+            context["paper"] = self.paper
+        if self.geometry:
+            context["geometry"] = self.geometry
+        if self.duplex is not None:
+            context["duplex"] = self.duplex
+        if self.margin is not None:
+            context["margin"] = self.margin
+        if self.orientation is not None:
+            context["orientation"] = self.orientation
+        if self.binding is not None:
+            context["binding"] = self.binding
+        if self.marks is not None:
+            context["marks"] = self.marks
+        if self.watermark is not None:
+            context["watermark"] = self.watermark
+        return context
+
+    def resolve(self) -> GeometryResolution:
+        """Return a resolved geometry payload for this configuration."""
+        return resolve_geometry_settings(self.to_context())
+
+
+class GeometryFragment(BaseFragment[GeometryFragmentConfig]):
+    """Programmatic renderer and fragment adapter for the ts-geometry fragment."""
+
+    name: ClassVar[str] = "ts-geometry"
+    description: ClassVar[str] = "Page layout setup driven by press.paper."
+    pieces: ClassVar[list[FragmentPiece]] = [
+        FragmentPiece(
+            template_path=Path(__file__).with_name("ts_geometry.tex.jinja"),
+            kind="inline",
+            slot="extra_packages",
+        )
+    ]
+    attributes: ClassVar[dict[str, Any]] = {}
+    config_cls: ClassVar[type[GeometryFragmentConfig]] = GeometryFragmentConfig
+    source: ClassVar[Path] = Path(__file__).with_name("ts_geometry.tex.jinja")
+    context_defaults: ClassVar[dict[str, Any]] = {
+        "extra_packages": "",
+        "documentclass_options": "",
+        "geometry_options": "",
+        "geometry_options_list": [],
+        "geometry_extra_options": "",
+        "geometry_duplex": True,
+        "paper": {"format": "a4"},
+    }
+
+    def __init__(self, payload: Any | None = None) -> None:
+        self.config = GeometryFragmentConfig.model_validate(payload or {})
+        self.template_path = Path(__file__).with_name("ts_geometry.tex.jinja")
+
+    def build_config(
+        self, context: Mapping[str, Any], overrides: Mapping[str, Any] | None = None
+    ) -> GeometryFragmentConfig:
+        _ = overrides
+        payload: dict[str, Any] = {}
+        for key in ("paper", "geometry", "duplex", "margin", "orientation", "binding", "watermark"):
+            if key in context:
+                payload[key] = context.get(key)
+        marks_flag = _coerce_marks_flag(context.get("marks"))
+        if marks_flag is not None:
+            payload["marks"] = marks_flag
+        return self.config_cls.model_validate(payload)
+
+    def inject(
+        self,
+        config: GeometryFragmentConfig,
+        context: dict[str, Any],
+        overrides: Mapping[str, Any] | None = None,
+    ) -> None:
+        # Ensure raw config fields are present before resolution.
+        context.update(config.to_context())
+        inject_geometry_context(context, overrides)
+
+    def should_render(self, config: GeometryFragmentConfig) -> bool:
+        _ = config
+        return True
+
+    # Convenience renderer for direct use
+    def render(self) -> str:
+        context = self.config.to_context()
+        inject_geometry_context(context)
+        environment = _build_environment(self.template_path.parent)
+        template = environment.get_template(self.template_path.name)
+        return template.render(**context)
+
+    def get_latex(self) -> str:
+        """Return the rendered LaTeX fragment."""
+        return self.render()
+
+    def getLatex(self) -> str:  # noqa: N802 - API compatibility
+        """CamelCase alias for front-end callers."""
+        return self.render()
+
+
+fragment = GeometryFragment()
+
+
+__all__ = ["GeometryFragment", "GeometryFragmentConfig", "fragment"]

texsmith/fragments/geometry/fragment.toml

@@ -0,0 +1,3 @@
+name = "ts-geometry"
+description = "Page layout setup driven by press.paper."
+entrypoint = "texsmith.fragments.geometry:fragment"