rupdf 0.2.0__tar.gz → 0.2.2__tar.gz

{rupdf-0.2.0 → rupdf-0.2.2}/.gitignore

@@ -41,12 +41,16 @@ benchmarks/*.pdf
 benchmarks/*.json
 
 # Test assets directory (not versioned - provide your own images via CLI args)
-tests/
+# Root-anchored so python/tests/ stays tracked
+/tests/
 
 # Benchmark outputs
 benchmarks/results/
 *.bench.json
 
+# Specs (session planning docs — see stringking specs convention)
+.specs/
+
 # Secrets
 .env
 .env.*

{rupdf-0.2.0 → rupdf-0.2.2}/CHANGELOG.md

@@ -4,6 +4,40 @@ All notable changes to this project are documented here. The format is based
 on [Keep a Changelog](https://keepachangelog.com/), and this project adheres
 to [Semantic Versioning](https://semver.org/).
 
+## [0.2.2] - 2026-07-24
+
+### Added
+
+- **`strikethrough` option on text elements.** When `"strikethrough": true`,
+  a horizontal line is drawn through the text at the font's OS/2 strikeout
+  position, spanning the exact rendered run width, in the text color. Line
+  thickness also comes from the font's metrics; fonts lacking the OS/2
+  strikeout table fall back to mid cap-height position and a 1/18-em rule.
+  Because rupdf places the line using the same measured run width and
+  aligned left edge it uses to draw the glyphs, the strike tracks left-,
+  center-, and right-aligned text exactly. Defaults to `false`; applies to
+  single-line `text` elements (not `textbox`).
+
+## [0.2.1] - 2026-07-19
+
+### Fixed
+
+- **Textbox clipping no longer shears ascenders and descenders** in the
+  `capline` and `baseline` vertical alignment modes. `capline` aligns the
+  first line's cap top with the box top, placing ascenders (`b d f h k l`,
+  i/j dots, diacritics) above the box; `baseline` aligns the last line's
+  baseline with the box bottom, placing descenders (`g j p q y`) below it.
+  The clip rect previously matched the exact box, cutting that ink off
+  flat. The clip now extends by the overhang each mode implies
+  (`ascender − cap_height` above for `capline`, the descender depth below
+  for `baseline`), so mixed-case text renders whole. Line-overflow
+  clipping and the other alignment modes are unchanged.
+
+### Changed
+
+- `__version__` is read from package metadata instead of being hardcoded,
+  so it can no longer drift from the built wheel's version.
+
 ## [0.2.0] - 2026-05-13
 
 ### Added

{rupdf-0.2.0 → rupdf-0.2.2}/Cargo.lock

@@ -511,7 +511,7 @@ dependencies = [
 
 [[package]]
 name = "rupdf"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "image 0.24.9",
  "miniz_oxide 0.6.2",

{rupdf-0.2.0 → rupdf-0.2.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rupdf"
-version = "0.2.0"
+version = "0.2.2"
 edition = "2021"
 license = "MIT"
 description = "A fast, minimal PDF page renderer"

{rupdf-0.2.0 → rupdf-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rupdf
-Version: 0.2.0
+Version: 0.2.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -125,7 +125,8 @@ Common page sizes:
     "size": 12,                   # Font size in points
     "color": (0, 0, 0, 255),      # RGBA (optional, default black)
     "align": "left",              # "left", "center", or "right" (optional)
-    "vertical_anchor": "baseline" # "baseline", "capline", or "center" (optional)
+    "vertical_anchor": "baseline",# "baseline", "capline", or "center" (optional)
+    "strikethrough": False        # Draw a line through the text (optional)
 }
 ```
 
@@ -140,6 +141,11 @@ Common page sizes:
   - `"capline"`: y is the top of capital letters
   - `"center"`: y is the vertical center of capital letters
 
+**Strikethrough:** when `"strikethrough": True`, a horizontal line is drawn
+through the text at the font's strikeout position, spanning the exact rendered
+run width, in the text color. Position and thickness come from the font's
+metrics (with sensible fallbacks for fonts that lack them).
+
 ### TextBox
 
 Multi-line text with word wrapping, like Illustrator's "area type".

{rupdf-0.2.0 → rupdf-0.2.2}/README.md

@@ -102,7 +102,8 @@ Common page sizes:
     "size": 12,                   # Font size in points
     "color": (0, 0, 0, 255),      # RGBA (optional, default black)
     "align": "left",              # "left", "center", or "right" (optional)
-    "vertical_anchor": "baseline" # "baseline", "capline", or "center" (optional)
+    "vertical_anchor": "baseline",# "baseline", "capline", or "center" (optional)
+    "strikethrough": False        # Draw a line through the text (optional)
 }
 ```
 
@@ -117,6 +118,11 @@ Common page sizes:
   - `"capline"`: y is the top of capital letters
   - `"center"`: y is the vertical center of capital letters
 
+**Strikethrough:** when `"strikethrough": True`, a horizontal line is drawn
+through the text at the font's strikeout position, spanning the exact rendered
+run width, in the text color. Position and thickness come from the font's
+metrics (with sensible fallbacks for fonts that lack them).
+
 ### TextBox
 
 Multi-line text with word wrapping, like Illustrator's "area type".

{rupdf-0.2.0 → rupdf-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "rupdf"
-version = "0.2.0"
+version = "0.2.2"
 description = "A fast, minimal PDF page renderer"
 readme = "README.md"
 requires-python = ">=3.11"

rupdf-0.2.2/python/rupdf/__init__.py

@@ -0,0 +1,13 @@
+"""rupdf - A fast, minimal PDF page renderer."""
+
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+from rupdf._rupdf import render_pdf, RupdfError
+
+__all__ = ["render_pdf", "RupdfError"]
+
+try:
+    __version__ = _pkg_version("rupdf")
+except PackageNotFoundError:
+    # Editable or source install with no installed metadata; not worth failing.
+    __version__ = "unknown"

{rupdf-0.2.0 → rupdf-0.2.2}/python/rupdf/_rupdf.pyi

@@ -32,6 +32,9 @@ class TextElement(TypedDict, total=False):
     color: Color
     align: HAlign
     vertical_anchor: VerticalAnchor
+    # Draw a horizontal line through the text at the font's strikeout
+    # position, spanning the rendered run width, in the text color.
+    strikethrough: bool
 
 
 class TextBoxElement(TypedDict, total=False):

{rupdf-0.2.0 → rupdf-0.2.2}/python/tests/test_pdf_structure.py

@@ -4,6 +4,8 @@ Tests that generated PDFs have correct structure without
 comparing exact byte sequences.
 """
 
+import re
+
 import pytest
 import rupdf
 
@@ -389,6 +391,137 @@ class TestBarcodes:
         assert pdf.startswith(b"%PDF-")
 
 
+class TestTextBoxClipping:
+    """The textbox clip must not shear ink that alignment modes place
+    outside the box (capline: ascenders above the top; baseline:
+    descenders below the bottom)."""
+
+    # Box geometry in user coords: page 288x144, box at (18, 36), 252x72.
+    # In PDF coords (bottom-left origin): bottom = 144 - 36 - 72 = 36, top = 108.
+    BOX_BOTTOM = 36.0
+    BOX_TOP = 108.0
+
+    def _clip_rect(self, font_path, text_align_y):
+        doc = {
+            "pages": [{
+                "size": (288.0, 144.0),
+                "elements": [{
+                    "type": "textbox",
+                    "x": 18.0, "y": 36.0, "w": 252.0, "h": 72.0,
+                    "text": "Midfield",
+                    "font": "f", "size": 16.0,
+                    "text_align_y": text_align_y,
+                }],
+            }],
+            "resources": {"fonts": {"f": {"path": font_path}}},
+        }
+        pdf = rupdf.render_pdf(doc, compress=False)
+        m = re.search(rb"([-\d.]+) ([-\d.]+) ([-\d.]+) ([-\d.]+) re\nW\nn", pdf)
+        assert m is not None, "No clip rect found in content stream"
+        x, bottom, w, h = (float(v) for v in m.groups())
+        return x, bottom, w, h
+
+    def test_capline_clip_extends_above_box(self, font_path):
+        """Capline puts the cap top at the box top, so ascenders and i-dots
+        rise above it; the clip's top edge must extend up past the box."""
+        x, bottom, w, h = self._clip_rect(font_path, "capline")
+        assert bottom == pytest.approx(self.BOX_BOTTOM)
+        assert bottom + h > self.BOX_TOP
+        assert x == pytest.approx(18.0)
+        assert w == pytest.approx(252.0)
+
+    def test_baseline_clip_extends_below_box(self, font_path):
+        """Baseline puts the last baseline at the box bottom, so descenders
+        hang below it; the clip's bottom edge must extend down past the box."""
+        x, bottom, w, h = self._clip_rect(font_path, "baseline")
+        assert bottom < self.BOX_BOTTOM
+        assert bottom + h == pytest.approx(self.BOX_TOP)
+
+    @pytest.mark.parametrize("align", ["top", "center", "bottom"])
+    def test_other_modes_clip_exactly_to_box(self, font_path, align):
+        """Modes with no intentional overhang keep the exact box clip."""
+        x, bottom, w, h = self._clip_rect(font_path, align)
+        assert bottom == pytest.approx(self.BOX_BOTTOM)
+        assert h == pytest.approx(72.0)
+
+
+class TestStrikethrough:
+    """Struck text draws a horizontal line through the glyph run, placed by
+    the font's strikeout metrics and spanning the measured run width."""
+
+    # Page 400x200; text baseline-anchored at y=72 → PDF baseline_y = 128.
+    PAGE = (400.0, 200.0)
+    BASELINE_Y = 128.0
+    SIZE = 24.0
+    ANCHOR_X = 150.0
+
+    STRIKE_RE = re.compile(rb"([-\d.]+) ([-\d.]+) m\n([-\d.]+) ([-\d.]+) l\nS")
+
+    def _render(self, font_path, strikethrough, align="left", **extra):
+        element = {
+            "type": "text",
+            "x": self.ANCHOR_X, "y": 72.0,
+            "text": "$10.00",
+            "font": "f", "size": self.SIZE,
+            "align": align,
+            "vertical_anchor": "baseline",
+            **extra,
+        }
+        if strikethrough is not None:
+            element["strikethrough"] = strikethrough
+        doc = {
+            "pages": [{"size": self.PAGE, "elements": [element]}],
+            "resources": {"fonts": {"f": {"path": font_path}}},
+        }
+        return rupdf.render_pdf(doc, compress=False)
+
+    def _strike_line(self, font_path, align="left"):
+        pdf = self._render(font_path, True, align)
+        m = self.STRIKE_RE.search(pdf)
+        assert m is not None, "No stroked line found in content stream"
+        x1, y1, x2, y2 = (float(v) for v in m.groups())
+        return x1, y1, x2, y2
+
+    @pytest.mark.parametrize("strikethrough", [None, False], ids=["absent", "false"])
+    def test_no_strike_by_default(self, font_path, strikethrough):
+        pdf = self._render(font_path, strikethrough)
+        assert self.STRIKE_RE.search(pdf) is None
+
+    def test_strike_is_horizontal_above_baseline(self, font_path):
+        x1, y1, x2, y2 = self._strike_line(font_path)
+        assert y1 == y2
+        # Between the baseline and the top of the em box — i.e. through the text.
+        assert self.BASELINE_Y < y1 < self.BASELINE_Y + self.SIZE
+
+    def test_left_align_starts_at_anchor(self, font_path):
+        x1, y1, x2, y2 = self._strike_line(font_path, "left")
+        assert x1 == pytest.approx(self.ANCHOR_X)
+        assert x2 > x1
+
+    def test_center_align_centers_on_anchor(self, font_path):
+        x1, y1, x2, y2 = self._strike_line(font_path, "center")
+        assert (x1 + x2) / 2 == pytest.approx(self.ANCHOR_X, abs=0.01)
+
+    def test_right_align_ends_at_anchor(self, font_path):
+        x1, y1, x2, y2 = self._strike_line(font_path, "right")
+        assert x2 == pytest.approx(self.ANCHOR_X)
+        assert x1 < x2
+
+    def test_width_matches_run_across_alignments(self, font_path):
+        widths = {
+            align: (lambda p: p[2] - p[0])(self._strike_line(font_path, align))
+            for align in ("left", "center", "right")
+        }
+        assert widths["left"] == pytest.approx(widths["center"], abs=0.01)
+        assert widths["left"] == pytest.approx(widths["right"], abs=0.01)
+        # Sanity: roughly the width of a 6-glyph run, not the whole page.
+        assert 0.5 * self.SIZE < widths["left"] < 6 * self.SIZE
+
+    def test_strike_uses_text_color(self, font_path):
+        pdf = self._render(font_path, True, color=(255, 0, 0, 255))
+        assert b"1 0 0 RG" in pdf
+
+
 class TestPageDimensions:
     """Test page dimension handling."""
 

{rupdf-0.2.0 → rupdf-0.2.2}/scripts/generate_test_pdf.py

@@ -163,6 +163,28 @@ def build_document(fonts: dict, images: dict) -> dict:
         "size": 12,
         "color": (0, 0, 200, 255),
     })
+    y += 18
+
+    # Strikethrough text (superseded-price pattern)
+    elements_page1.append({
+        "type": "text",
+        "x": MARGIN,
+        "y": y,
+        "text": "$10.00 struck through",
+        "font": default_font,
+        "size": 12,
+        "color": (0, 0, 0, 255),
+        "strikethrough": True,
+    })
+    elements_page1.append({
+        "type": "text",
+        "x": MARGIN + 170,
+        "y": y,
+        "text": "$8.50 not struck",
+        "font": default_font,
+        "size": 12,
+        "color": (0, 0, 0, 255),
+    })
     y += 35
 
     # --- RECTANGLE SECTION ---

{rupdf-0.2.0 → rupdf-0.2.2}/src/pdf/writer.rs

@@ -452,6 +452,18 @@ impl<'a> PdfGenerator<'a> {
         }
         content.end_text();
 
+        // Paths can't go inside a BT/ET text object, so the strike is drawn
+        // after end_text but within the same save/restore so alpha still applies.
+        if text.strikethrough {
+            let strike_y = baseline_y + primary.strikeout_position_pts(text.size);
+            let thickness = primary.strikeout_thickness_pts(text.size);
+            content.set_stroke_rgb(r, g, b);
+            content.set_line_width(thickness);
+            content.move_to(x, strike_y);
+            content.line_to(x + total_width, strike_y);
+            content.stroke();
+        }
+
         content.restore_state();
 
         Ok(())
@@ -518,11 +530,24 @@ impl<'a> PdfGenerator<'a> {
             TextAlignY::Bottom => box_top + textbox.h - last_baseline_offset - descender,
         };
 
-        // Step 5: Set up clipping
+        // Step 5: Set up clipping. Capline/Baseline intentionally place ink
+        // outside the box (ascenders above the cap line, descenders below the
+        // baseline), so extend the clip by that overhang on the relevant edge;
+        // the clip only needs to cut off whole lines that don't fit.
         content.save_state();
 
-        let pdf_box_bottom = page_height - box_top - textbox.h;
-        content.rect(box_left, pdf_box_bottom, textbox.w, textbox.h);
+        let (clip_top_extra, clip_bottom_extra) = match textbox.text_align_y {
+            TextAlignY::Capline => ((ascender - cap_height).max(0.0), 0.0),
+            TextAlignY::Baseline => (0.0, descender),
+            _ => (0.0, 0.0),
+        };
+        let pdf_box_bottom = page_height - box_top - textbox.h - clip_bottom_extra;
+        content.rect(
+            box_left,
+            pdf_box_bottom,
+            textbox.w,
+            textbox.h + clip_top_extra + clip_bottom_extra,
+        );
         content.clip_nonzero();
         content.end_path();
 

{rupdf-0.2.0 → rupdf-0.2.2}/src/resources.rs

@@ -11,6 +11,8 @@ pub struct LoadedFont {
     pub ascender: i16,
     pub descender: i16,
     pub cap_height: i16,                   // Height of capital letters
+    pub strikeout_position: i16,           // Strikeout line position above baseline
+    pub strikeout_thickness: i16,          // Strikeout line thickness
     pub glyph_widths: HashMap<u16, u16>, // glyph_id -> advance width
     pub cmap: HashMap<char, u16>,         // char -> glyph_id
 }
@@ -43,6 +45,16 @@ impl LoadedFont {
             })
             .unwrap_or_else(|| (ascender as f32 * 0.7) as i16);
 
+        // Strikeout metrics from OS/2 table. Fallbacks: mid cap-height centers
+        // the strike on lining figures; thickness ~1/18 em is a typical rule.
+        let strikeout = face.strikeout_metrics();
+        let strikeout_position = strikeout
+            .map(|m| m.position)
+            .unwrap_or_else(|| (cap_height as f32 * 0.5) as i16);
+        let strikeout_thickness = strikeout
+            .map(|m| m.thickness)
+            .unwrap_or_else(|| (units_per_em as f32 / 18.0) as i16);
+
         // Extract PostScript name from name table (name_id 6)
         let postscript_name = face
             .names()
@@ -83,6 +95,8 @@ impl LoadedFont {
             ascender,
             descender,
             cap_height,
+            strikeout_position,
+            strikeout_thickness,
             glyph_widths,
             cmap,
         })
@@ -119,6 +133,16 @@ impl LoadedFont {
     pub fn descender_pts(&self, size: f32) -> f32 {
         self.descender as f32 * size / self.units_per_em as f32
     }
+
+    /// Strikeout line position above baseline, in points, for the given size.
+    pub fn strikeout_position_pts(&self, size: f32) -> f32 {
+        self.strikeout_position as f32 * size / self.units_per_em as f32
+    }
+
+    /// Strikeout line thickness, in points, for the given size.
+    pub fn strikeout_thickness_pts(&self, size: f32) -> f32 {
+        self.strikeout_thickness as f32 * size / self.units_per_em as f32
+    }
 }
 
 /// Loaded image data
@@ -221,3 +245,40 @@ impl LoadedResources {
             .ok_or_else(|| RupdfError::MissingImage(name.to_string()))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    fn load_sans() -> LoadedFont {
+        let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("assets")
+            .join("IBMPlexSans-Regular.otf");
+        LoadedFont::load("sans", &FontSource::Path(path.to_str().unwrap().to_string())).unwrap()
+    }
+
+    #[test]
+    fn strikeout_metrics_extracted_from_os2() {
+        let font = load_sans();
+        // IBM Plex Sans carries OS/2 strikeout metrics: the position sits
+        // above the baseline but below cap height, and the rule has weight.
+        assert!(font.strikeout_position > 0);
+        assert!(font.strikeout_position < font.cap_height);
+        assert!(font.strikeout_thickness > 0);
+    }
+
+    #[test]
+    fn strikeout_accessors_scale_by_size() {
+        let font = load_sans();
+        // At size == units_per_em, points equal raw font units.
+        let em = font.units_per_em as f32;
+        assert_eq!(font.strikeout_position_pts(em), font.strikeout_position as f32);
+        assert_eq!(font.strikeout_thickness_pts(em), font.strikeout_thickness as f32);
+        // Linear in size.
+        assert!(
+            (font.strikeout_position_pts(24.0) - 2.0 * font.strikeout_position_pts(12.0)).abs()
+                < 1e-4
+        );
+    }
+}

{rupdf-0.2.0 → rupdf-0.2.2}/src/types.rs

@@ -223,6 +223,7 @@ pub struct TextElement {
     pub color: Color,
     pub align: TextAlign,
     pub vertical_anchor: VerticalAnchor,
+    pub strikethrough: bool,
 }
 
 /// Rectangle element
@@ -526,6 +527,7 @@ impl Element {
                 color: with_element_context(opt_or(dict, "color", Color::black()), index)?,
                 align: with_element_context(opt_default(dict, "align"), index)?,
                 vertical_anchor: with_element_context(opt_default(dict, "vertical_anchor"), index)?,
+                strikethrough: with_element_context(opt_or(dict, "strikethrough", false), index)?,
             })),
 
             "textbox" => {

rupdf-0.2.0/.specs/2026-05-12-missing-glyph-hard-error.md

@@ -1,237 +0,0 @@
-# Font fallback chains for text + textbox
-
-## Summary
-
-`render_pdf` raises `RupdfError::MissingGlyph` the moment a text element
-contains a character absent from the chosen font's cmap. This blocks a
-P1 prod incident in StringKing (GarmentVin 239378 has `body_name = "Tony
-❤ Dorn"`; the heart aborts the whole label) and the same class of bug
-recurs for any non-Latin character — CJK, Arabic, Cyrillic, etc. — in
-user-supplied free-text fields.
-
-Fix: support per-element font fallback chains. The caller passes a
-primary font plus an ordered list of fallbacks, rupdf walks each
-character against the chain, builds contiguous same-font sub-runs, and
-renders/wraps with the per-character font assignments. Chars covered
-by no font in the chain are dropped by default (configurable to raise).
-
-## API
-
-### Text element
-
-```python
-{"type": "text",
- "text": "Tony ❤ 山田",
- "font": "body",                          # primary; drives metrics
- "font_fallback": ["emoji", "body_jp"],   # tried in order
- "missing_glyph_policy": "drop",          # "drop" (default) | "raise"
- "x": ..., "y": ..., "size": 12, "color": (0,0,0,255), ...}
-```
-
-### TextBox element
-
-Same `font` / `font_fallback` / `missing_glyph_policy` keys. Wrapping
-honors per-character advances from the resolved fonts.
-
-### Backwards compatibility
-
-- Existing `{font: "body"}` with no `font_fallback` keeps working
-  unchanged.
-- `font_fallback: []` is identical to omitting the key.
-- All fallback names must exist in `resources.fonts`. Unknown name →
-  `MissingFont` error (current behavior).
-
-## Semantics
-
-**Primary font drives metrics.** Line height, ascender, descender, cap
-height, and baseline computation all use the primary font's metrics
-regardless of which fallback covers a given character. Fallback chars
-render at the textbox's `size`, scaled to the same baseline as the
-primary. Rationale: a fallback that has a wildly different ascender
-(emoji fonts are notorious for this) must not shift the layout of the
-line it appears in.
-
-**Per-character resolution.** For each char in `text`, walk `[font,
-*font_fallback]` and assign the first font whose cmap contains the
-char. Control characters (`\n`, `\t`) are not looked up — they pass
-through.
-
-**No coverage.** When no font in the chain covers a char:
-- `missing_glyph_policy="drop"` (default): silently strip the char.
-- `missing_glyph_policy="raise"`: raise `MissingGlyph` (current
-  behavior).
-
-`drop` is the default because the immediate use case is label
-printing where tofu is unacceptable and any visible artifact looks
-broken. `raise` is one kwarg away for callers that want strict
-detection.
-
-**Internal sub-runs.** Contiguous same-font characters become a
-sub-run. `"Tony ❤ 山田"` against `["body", "emoji", "body_jp"]`
-resolves to:
-
-```
-[Run("Tony ", body), Run("❤", emoji), Run(" ", body), Run("山田", body_jp)]
-```
-
-The space between `❤` and `山田` is in `body` (every Latin font covers
-ASCII space) and stays in `body`.
-
-**Wrapping with mixed runs.** Word boundaries are still split on
-whitespace. A word's width is the sum of per-character advances from
-its resolved font(s). A word may straddle sub-runs — e.g. `"café"`
-where `é` falls back. Wrap decisions use the actual rendered width.
-
-**Emission.** Within a line, the content stream switches fonts at
-sub-run boundaries: emit a `Tf` operator with the new font alias, then
-the `Tj` for that sub-run's glyphs, then `Tf` again at the next
-boundary. Existing single-font fast path stays unchanged when no
-fallback resolves.
-
-## Implementation
-
-### Module shape
-
-Factor the resolver into a standalone reusable function so the future
-styled-runs API (see below) can call it per user-supplied run:
-
-```rust
-// src/runs.rs (new)
-
-pub struct ResolvedChar {
-    pub ch: char,
-    pub font_alias: String,   // which font in the chain covered it
-    pub glyph_id: u16,
-}
-
-pub struct ResolvedRun {
-    pub font_alias: String,
-    pub text: String,         // for ToUnicode reconstruction
-    pub glyphs: Vec<u16>,
-}
-
-pub fn resolve(
-    text: &str,
-    chain: &[&LoadedFont],
-    chain_names: &[&str],
-    policy: MissingGlyphPolicy,
-) -> Result<Vec<ResolvedRun>>;
-```
-
-This function is the only place that does cmap walking. `text_width`,
-`wrap_text`, `FontEmbedder::use_text`, and the emit path all consume
-the `Vec<ResolvedRun>` output.
-
-### Files touched
-
-| File | Change |
-| --- | --- |
-| `src/error.rs` | Keep `MissingGlyph`; add `MissingGlyphPolicy` enum |
-| `src/types.rs` | Add `font_fallback: Vec<String>` and `missing_glyph_policy: MissingGlyphPolicy` to `TextElement` / `TextBoxElement` parsers |
-| `src/resources.rs` | `LoadedFont::glyph_id_opt(ch) -> Option<u16>` primitive (no policy, no error) |
-| `src/runs.rs` | New — the resolver |
-| `src/pdf/fonts.rs` | `FontEmbedder::use_run(&ResolvedRun)` |
-| `src/pdf/writer.rs` | First pass iterates resolved runs per text/textbox to register glyphs in the right embedder; emit path switches fonts via `Tf` at sub-run boundaries |
-| `src/lib.rs` | No signature change to `render_pdf` (per-element control) |
-| `python/rupdf/_rupdf.pyi` | Add `font_fallback` and `missing_glyph_policy` to TextElement/TextBoxElement TypedDicts |
-| `python/tests/` | Coverage: emoji fallback, CJK fallback, drop vs raise, no-fallback unchanged |
-
-### Measurement
-
-`text_width(text, size, chain)` becomes:
-
-```rust
-let runs = runs::resolve(text, chain, ...)?;
-let mut width = 0.0;
-for run in &runs {
-    let scale = size / run.font.units_per_em as f32;
-    for &gid in &run.glyphs {
-        width += run.font.advance_width(gid) as f32 * scale;
-    }
-}
-Ok(width)
-```
-
-### Wrapping
-
-`wrap_text` is rewritten to operate on a `Vec<ResolvedRun>` instead of
-a `&str`. Word boundaries are detected by walking the original text
-char-by-char; a word's width sums advances regardless of which sub-run
-contributes each char. Line breaks split sub-runs as needed (a sub-run
-straddling a line break becomes two sub-runs, one per line).
-
-### Emission
-
-`render_textbox` and `render_text` iterate the per-line resolved
-sub-runs. For each sub-run on a line, emit:
-
-```
-/AliasN size Tf
-<hex-encoded glyphs> Tj
-```
-
-`Tj` positioning uses `Td` offsets within the same `BT`/`ET` block;
-font switches do not require a state reset.
-
-## Forward compatibility with styled runs
-
-The styled-runs API (deferred to a separate change) will look like:
-
-```python
-{"type": "textbox",
- "runs": [
-    {"text": "Order ", "font": "body", "size": 12, "color": (0,0,0,255)},
-    {"text": "G239378", "font": "body_bold", "size": 12, "color": (0,0,0,255)},
-    {"text": " — rush", "font": "body", "size": 12, "color": (200,0,0,255)},
- ],
- "font_fallback": ["emoji", "body_jp"],  # applies to every run
- ...}
-```
-
-Compatibility requirements honored by this spec:
-
-- Textbox-level `font_fallback` resolves uniformly against each
-  user-run's `font` — same `runs::resolve` function, called per user-run.
-- Line height with mixed sizes: deferred; current spec uses primary
-  font metrics, which works for the styled-runs case when the textbox
-  has a defaultable `font` field. Future change: max-ascender across
-  runs on each line.
-- The internal `ResolvedRun` type already carries the font alias; the
-  styled-runs change adds `size`, `color`, etc. to it without breaking
-  existing consumers.
-
-If we discover during implementation that a different internal
-representation makes styled-runs cleaner, fine to revisit — the
-external `font_fallback` API doesn't depend on the internal shape.
-
-## Out of scope
-
-- **Styled runs.** Designed for compatibility; implementation deferred
-  until a concrete consumer (sklib) needs inline styling. Tracked
-  separately when that need surfaces.
-- **Per-run fallback overrides.** Textbox-level fallback applies to
-  everything. If a future use case needs per-run override, additive
-  feature.
-- **Complex script shaping, ligatures, RTL.** Unrelated; rupdf doesn't
-  shape today and this change doesn't introduce it.
-- **Warning side-channel** for stripped chars. Nice-to-have. Sklib can
-  pre-walk cmaps if it wants visibility; not blocking prod.
-- **Bundled fonts.** rupdf continues to ship zero font assets. Callers
-  supply all fonts via `resources.fonts`.
-
-## Priority
-
-P1 — blocking sewing-ticket / package-label / garment-tag rendering in
-p1 prod for any order with a non-cmap-covered char in user-supplied
-text. At least one prod vin (G239378) stuck today; class of bug
-recurs on every customer name with emoji or non-Latin characters.
-
-## Previous direction (historical)
-
-This spec previously proposed "do nothing in rupdf; have sklib pre-strip
-chars upstream of layout." That plan was sufficient for emoji-only label
-content but doesn't address the broader CJK / Arabic / Cyrillic case,
-where the right behavior is to swap typefaces rather than drop characters.
-The current direction supersedes it. The sklib-side spec
-(`sklib/.specs/2026-05-12-pdf-missing-glyph-hard-error.md`) has been
-updated to match.

rupdf-0.2.0/python/rupdf/__init__.py

@@ -1,6 +0,0 @@
-"""rupdf - A fast, minimal PDF page renderer."""
-
-from rupdf._rupdf import render_pdf, RupdfError
-
-__all__ = ["render_pdf", "RupdfError"]
-__version__ = "0.1.0"