fullbleed 2.3.0__tar.gz → 2.3.1__tar.gz

{fullbleed-2.3.0 → fullbleed-2.3.1}/Cargo.lock

@@ -4,7 +4,7 @@ version = 4
 
 [[package]]
 name = "fullbleed"
-version = "2.3.0"
+version = "2.3.1"
 dependencies = [
  "fullbleed_audit_contract",
  "subsetter",

{fullbleed-2.3.0 → fullbleed-2.3.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fullbleed"
-version = "2.3.0"
+version = "2.3.1"
 edition = "2024"
 rust-version = "1.85"
 license = "MIT"

{fullbleed-2.3.0 → fullbleed-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fullbleed
-Version: 2.3.0
+Version: 2.3.1
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: MacOS
@@ -170,6 +170,11 @@ Fixed-geometry slots may remain inside immutable page-space transforms and clips
 captures that active coordinate-state program once and replays it in each compact record overlay;
 it does not rerun layout or clone the complete page display list.
 
+Base-14/WinAnsi slot paint keeps the measured byte-patch linker. Registered embedded fonts use a
+command-level overlay program so each bound value is shaped and included in the font subset while
+the compiled layout, pagination, and static page stream remain shared. The throughput figures above
+describe the Base-14 fast lane; they are not claims for registered-font shaping.
+
 The fixed-copy result remains scoped to identical content; the variable-data result is scoped to
 paint-only text whose geometry does not reflow. Neither is a claim that arbitrary new HTML or
 size-changing records render 200x faster. See
@@ -208,7 +213,7 @@ python -m pip install fullbleed
 From a local wheel:
 
 ```bash
-python -m pip install C:\path\to\fullbleed-2.3.0-cp310-abi3-win_amd64.whl
+python -m pip install C:\path\to\fullbleed-2.3.1-cp310-abi3-win_amd64.whl
 ```
 
 From a source checkout with Rust installed, no Python build package is needed:
@@ -1079,8 +1084,9 @@ Module exports:
 The compiled lane runs parsing/layout once. `render_pdf_batch` virtualizes identical untagged page
 content. The fixed binding methods accept columnar `dict[str, list[str]]` data and emit distinct
 fixed-geometry text overlays per record while sharing static paint. They require exact slot keys,
-equal non-zero column lengths, page-local WinAnsi-compatible text, and an untagged profile; bound
-values do not trigger reflow.
+equal non-zero column lengths, page-local text, and an untagged profile. Base-14 text uses the
+direct byte-patch lane; registered fonts are shaped into a command-level overlay. Bound values do
+not trigger layout or reflow.
 
 The reflow binding methods use the same exact-column contract but execute the compiled parsed-DOM
 program. `{{slot}}` values are literal text and may reshape, wrap, resize blocks, and change page

{fullbleed-2.3.0 → fullbleed-2.3.1}/README.md

@@ -127,6 +127,11 @@ Fixed-geometry slots may remain inside immutable page-space transforms and clips
 captures that active coordinate-state program once and replays it in each compact record overlay;
 it does not rerun layout or clone the complete page display list.
 
+Base-14/WinAnsi slot paint keeps the measured byte-patch linker. Registered embedded fonts use a
+command-level overlay program so each bound value is shaped and included in the font subset while
+the compiled layout, pagination, and static page stream remain shared. The throughput figures above
+describe the Base-14 fast lane; they are not claims for registered-font shaping.
+
 The fixed-copy result remains scoped to identical content; the variable-data result is scoped to
 paint-only text whose geometry does not reflow. Neither is a claim that arbitrary new HTML or
 size-changing records render 200x faster. See
@@ -165,7 +170,7 @@ python -m pip install fullbleed
 From a local wheel:
 
 ```bash
-python -m pip install C:\path\to\fullbleed-2.3.0-cp310-abi3-win_amd64.whl
+python -m pip install C:\path\to\fullbleed-2.3.1-cp310-abi3-win_amd64.whl
 ```
 
 From a source checkout with Rust installed, no Python build package is needed:
@@ -1036,8 +1041,9 @@ Module exports:
 The compiled lane runs parsing/layout once. `render_pdf_batch` virtualizes identical untagged page
 content. The fixed binding methods accept columnar `dict[str, list[str]]` data and emit distinct
 fixed-geometry text overlays per record while sharing static paint. They require exact slot keys,
-equal non-zero column lengths, page-local WinAnsi-compatible text, and an untagged profile; bound
-values do not trigger reflow.
+equal non-zero column lengths, page-local text, and an untagged profile. Base-14 text uses the
+direct byte-patch lane; registered fonts are shaped into a command-level overlay. Bound values do
+not trigger layout or reflow.
 
 The reflow binding methods use the same exact-column contract but execute the compiled parsed-DOM
 program. `{{slot}}` values are literal text and may reshape, wrap, resize blocks, and change page

{fullbleed-2.3.0 → fullbleed-2.3.1}/fullbleed-agent-contract.json

@@ -3640,7 +3640,7 @@
     "license": "MIT",
     "name": "Fullbleed PDF Engine",
     "python_package": "fullbleed",
-    "version": "2.3.0"
+    "version": "2.3.1"
   },
   "profiles": {
     "pdf": {

{fullbleed-2.3.0 → fullbleed-2.3.1}/llms.txt

@@ -1,6 +1,6 @@
 # Fullbleed PDF Engine
 
-> Fullbleed 2.3.0 is a deterministic, self-contained document-generation runtime for Python and Rust. It turns structured data plus static HTML/CSS into validated PDF documents without a browser.
+> Fullbleed 2.3.1 is a deterministic, self-contained document-generation runtime for Python and Rust. It turns structured data plus static HTML/CSS into validated PDF documents without a browser.
 
 The installed runtime is authoritative. Do not infer its API from this file or from remembered release knowledge. Start with:
 

{fullbleed-2.3.0 → fullbleed-2.3.1}/pyproject.toml

@@ -5,7 +5,7 @@ backend-path = ["build_backend"]
 
 [project]
 name = "fullbleed"
-version = "2.3.0"
+version = "2.3.1"
 description = "Deterministic Python PDF engine for reports, invoices, accessible documents, print-ready output, and compiled VDP"
 readme = "README.md"
 requires-python = ">=3.10"

{fullbleed-2.3.0 → fullbleed-2.3.1}/src/flowable.rs

@@ -5600,6 +5600,7 @@ fn draw_registered_text_run(
     y: Pt,
     text: String,
 ) {
+    let contains_binding_slot = !crate::binding_slot_names(&text).is_empty();
     let text = crate::text_shape::encode_shape_options(&text, text_shape_options(style));
     let synthetic_bold = style.font_synthesis_weight
         && !style.font_face_satisfies_weight
@@ -5614,6 +5615,17 @@ fn draw_registered_text_run(
         && registry.requires_synthetic_italic(font_name);
     let strength = (style.font_size * (1.0 / 32.0)).max(Pt::from_f32(0.25));
     let italic_shear = synthetic_italic_shear(style.font_style);
+    // Fixed VDP substitutes slot values after layout. Keep binding-bearing
+    // text as a patchable text command instead of compiling the placeholder's
+    // glyph IDs into the reusable Type 3 synthetic-bold shader.
+    if contains_binding_slot && synthetic_bold {
+        if synthetic_italic {
+            canvas.draw_string_synthetic_bold_italic(x, y, text, strength, italic_shear);
+        } else {
+            canvas.draw_string_synthetic_bold(x, y, text, strength);
+        }
+        return;
+    }
     match (synthetic_bold, synthetic_italic) {
         (true, true) if style.css_pixel_snap_metrics => {
             if draw_registered_synthetic_bold_outline_run(

{fullbleed-2.3.0 → fullbleed-2.3.1}/src/lib.rs

@@ -14264,6 +14264,63 @@ h1 { font-size: 20pt; }
         ));
     }
 
+    #[test]
+    fn compiled_document_binds_registered_identity_h_fonts_without_literal_slots() {
+        let mut bundle = AssetBundle::default();
+        bundle.add(Asset::new(
+            "VdpCustom".to_string(),
+            AssetKind::Font,
+            std::fs::read(repo_font_path("NotoSans-Regular.ttf")).expect("read custom font"),
+            None,
+            true,
+        ));
+        let engine = FullBleed::builder()
+            .register_bundle(bundle)
+            .build()
+            .expect("engine");
+        let compiled = engine
+            .compile_document(
+                "<main><h1>{{attendee}}</h1><p>{{role}}</p><strong>{{seat}}</strong></main>",
+                "@page { size: 260pt 140pt; margin: 12pt; } body { margin: 0; font-family: VdpCustom; font-weight: 400; } h1 { font-size: 20pt; font-weight: 700; }",
+            )
+            .expect("compile registered-font template");
+        let bindings = std::collections::HashMap::from([
+            (
+                "attendee".to_string(),
+                vec!["ADA RIVERA".to_string(), "GRACE HOPPER".to_string()],
+            ),
+            (
+                "role".to_string(),
+                vec!["RESEARCHER".to_string(), "ENGINEER".to_string()],
+            ),
+            (
+                "seat".to_string(),
+                vec!["A12".to_string(), "B07".to_string()],
+            ),
+        ]);
+        let pdf = compiled
+            .render_bindings_to_buffer(&bindings)
+            .expect("registered-font fixed bindings");
+        let inspection = inspect_pdf_bytes(&pdf).expect("inspect binding output");
+        assert_eq!(inspection.page_count, 2);
+
+        let parsed = crate::pdf_native::Document::load_mem(&pdf).expect("parse binding PDF");
+        let page_numbers = parsed.get_pages().keys().copied().collect::<Vec<_>>();
+        let text = parsed
+            .extract_text_chunks(&page_numbers)
+            .into_iter()
+            .collect::<crate::pdf_native::Result<Vec<_>>>()
+            .expect("extract registered-font bindings")
+            .join("\n");
+        assert!(text.contains("ADA RIVERA"));
+        assert!(text.contains("GRACE HOPPER"));
+        assert!(text.contains("RESEARCHER"));
+        assert!(text.contains("ENGINEER"));
+        assert!(text.contains("A12"));
+        assert!(text.contains("B07"));
+        assert!(!text.contains("{{"));
+    }
+
     #[test]
     fn compiled_reflow_bindings_reuse_dom_and_generate_variable_page_counts() {
         let engine = FullBleed::builder().build().expect("engine");

{fullbleed-2.3.0 → fullbleed-2.3.1}/src/pdf.rs

@@ -438,14 +438,21 @@ struct BindingPageProgram {
     static_content_id: usize,
     static_content_len: usize,
     geometry: PageGeometry,
-    dynamic_segments: Vec<BindingContentSegment>,
-    dynamic_capacity: usize,
-    dynamic_slot_occurrences: usize,
+    dynamic: BindingDynamicProgram,
+}
+
+enum BindingDynamicProgram {
+    Patched {
+        segments: Vec<BindingContentSegment>,
+        capacity: usize,
+    },
+    Commands(Page),
 }
 
 struct CompiledBindingPage {
     static_page: Page,
     overlay_page: Page,
+    dynamic_slot_occurrences: usize,
 }
 
 /// Immutable command partition produced once for a compiled template.
@@ -558,10 +565,102 @@ fn instantiate_binding_content(
     }
 }
 
+fn instantiate_binding_text(
+    template: &str,
+    slot_lookup: &HashMap<String, usize>,
+    columns: &[&[String]],
+    row: usize,
+) -> String {
+    let spans = crate::binding_slot_spans(template);
+    if spans.is_empty() {
+        return template.to_string();
+    }
+
+    let mut output = String::with_capacity(template.len().saturating_add(32));
+    let mut cursor = 0usize;
+    for (start, end, name) in spans {
+        output.push_str(&template[cursor..start]);
+        if let Some(slot_index) = slot_lookup.get(name) {
+            output.push_str(&columns[*slot_index][row]);
+        } else {
+            output.push_str(&template[start..end]);
+        }
+        cursor = end;
+    }
+    output.push_str(&template[cursor..]);
+    output
+}
+
+fn instantiate_binding_overlay_page(
+    template: &Page,
+    slot_lookup: &HashMap<String, usize>,
+    columns: &[&[String]],
+    row: usize,
+) -> Page {
+    let commands = template
+        .commands
+        .iter()
+        .map(|command| match command {
+            Command::DrawString { x, y, text } => Command::DrawString {
+                x: *x,
+                y: *y,
+                text: instantiate_binding_text(text, slot_lookup, columns, row),
+            },
+            Command::DrawStringTransformed {
+                x,
+                y,
+                text,
+                m00,
+                m01,
+                m10,
+                m11,
+            } => Command::DrawStringTransformed {
+                x: *x,
+                y: *y,
+                text: instantiate_binding_text(text, slot_lookup, columns, row),
+                m00: *m00,
+                m01: *m01,
+                m10: *m10,
+                m11: *m11,
+            },
+            _ => command.clone(),
+        })
+        .collect();
+    Page { commands }
+}
+
+fn binding_overlay_uses_registered_font(page: &Page, registry: Option<&FontRegistry>) -> bool {
+    let Some(registry) = registry else {
+        return false;
+    };
+    let mut font_name = "Helvetica".to_string();
+    let mut stack = Vec::new();
+    for command in &page.commands {
+        match command {
+            Command::SaveState => stack.push(font_name.clone()),
+            Command::RestoreState => {
+                if let Some(saved) = stack.pop() {
+                    font_name = saved;
+                }
+            }
+            Command::SetFontName(value) => font_name.clone_from(value),
+            Command::DrawString { text, .. } | Command::DrawStringTransformed { text, .. }
+                if !crate::binding_slot_names(text).is_empty()
+                    && registry.resolve(&font_name).is_some() =>
+            {
+                return true;
+            }
+            _ => {}
+        }
+    }
+    false
+}
+
 #[derive(Clone)]
 struct BindingPaintState {
     font_name: String,
     font_size: Pt,
+    line_width: Pt,
     fill: Color,
     stroke: Color,
     opacity_fill: f32,
@@ -575,6 +674,7 @@ impl Default for BindingPaintState {
         Self {
             font_name: "Helvetica".to_string(),
             font_size: Pt::from_f32(12.0),
+            line_width: Pt::from_f32(1.0),
             fill: Color::BLACK,
             stroke: Color::BLACK,
             opacity_fill: 1.0,
@@ -683,6 +783,7 @@ fn binding_overlay_commands(
             Command::SetBlendMode { mode } => state.blend_mode = *mode,
             Command::SetFontName(value) => state.font_name.clone_from(value),
             Command::SetFontSize(value) => state.font_size = *value,
+            Command::SetLineWidth(value) => state.line_width = *value,
             Command::SetTextRenderingMode(value) => state.text_rendering_mode = *value,
             Command::DefineForm { commands, .. } | Command::DefineIsolatedForm { commands, .. }
                 if commands_contain_binding_marker(commands) =>
@@ -724,6 +825,7 @@ fn binding_overlay_commands(
                 }
                 overlay.push(Command::SetFontName(state.font_name.clone()));
                 overlay.push(Command::SetFontSize(state.font_size));
+                overlay.push(Command::SetLineWidth(state.line_width));
                 if state.text_rendering_mode != 0 {
                     overlay.push(Command::SetTextRenderingMode(state.text_rendering_mode));
                 }
@@ -774,6 +876,7 @@ fn binding_overlay_commands(
                 }
                 overlay.push(Command::SetFontName(state.font_name.clone()));
                 overlay.push(Command::SetFontSize(state.font_size));
+                overlay.push(Command::SetLineWidth(state.line_width));
                 if state.text_rendering_mode != 0 {
                     overlay.push(Command::SetTextRenderingMode(state.text_rendering_mode));
                 }
@@ -812,7 +915,11 @@ pub(crate) fn compile_binding_plan(
         let (overlay_commands, page_slot_counts) =
             binding_overlay_commands(&page.commands, &slot_lookup)?;
         let static_commands = binding_static_commands(&page.commands, &slot_lookup);
-        for (total, count) in total_slot_counts.iter_mut().zip(page_slot_counts) {
+        let dynamic_slot_occurrences = page_slot_counts.iter().copied().sum();
+        for (total, count) in total_slot_counts
+            .iter_mut()
+            .zip(page_slot_counts.iter().copied())
+        {
             *total = total.saturating_add(count);
         }
         static_command_count = static_command_count.saturating_add(static_commands.len());
@@ -824,6 +931,7 @@ pub(crate) fn compile_binding_plan(
             overlay_page: Page {
                 commands: overlay_commands,
             },
+            dynamic_slot_occurrences,
         });
     }
 
@@ -1587,47 +1695,64 @@ impl<'a, W: Write> PdfStreamWriter<'a, W> {
             self.write_content_stream_object(static_content_id, "", static_content.as_bytes())?;
             self.page_content_stream_count = self.page_content_stream_count.saturating_add(1);
 
-            let overlay_template =
-                self.render_page_sized(&page.overlay_page, page_index, geometry)?;
-            let (dynamic_segments, dynamic_slot_occurrences, dynamic_static_bytes) =
-                compile_binding_content_segments(&overlay_template, &binding_plan.slot_lookup);
-            if dynamic_slot_occurrences == 0 {
-                return Err(io::Error::new(
-                    io::ErrorKind::InvalidInput,
-                    "compiled slot overlay could not be lowered to patchable WinAnsi text",
-                ));
-            }
+            let dynamic = if binding_overlay_uses_registered_font(&page.overlay_page, self.registry)
+            {
+                BindingDynamicProgram::Commands(page.overlay_page.clone())
+            } else {
+                let overlay_template =
+                    self.render_page_sized(&page.overlay_page, page_index, geometry)?;
+                let (segments, occurrences, static_bytes) =
+                    compile_binding_content_segments(&overlay_template, &binding_plan.slot_lookup);
+                if occurrences == page.dynamic_slot_occurrences {
+                    BindingDynamicProgram::Patched {
+                        segments,
+                        capacity: static_bytes.saturating_add(128),
+                    }
+                } else {
+                    BindingDynamicProgram::Commands(page.overlay_page.clone())
+                }
+            };
             programs.push(BindingPageProgram {
                 static_content_id,
                 static_content_len: static_content.len(),
                 geometry,
-                dynamic_segments,
-                dynamic_capacity: dynamic_static_bytes.saturating_add(128),
-                dynamic_slot_occurrences,
+                dynamic,
             });
         }
 
         let max_dynamic_capacity = programs
             .iter()
-            .map(|program| program.dynamic_capacity)
+            .filter_map(|program| match &program.dynamic {
+                BindingDynamicProgram::Patched { capacity, .. } => Some(*capacity),
+                BindingDynamicProgram::Commands(_) => None,
+            })
             .max()
             .unwrap_or(0);
         let mut dynamic_content = Vec::with_capacity(max_dynamic_capacity);
         for row in 0..record_count {
             for program in &programs {
-                instantiate_binding_content(
-                    &program.dynamic_segments,
-                    columns,
-                    row,
-                    &mut dynamic_content,
-                );
+                match &program.dynamic {
+                    BindingDynamicProgram::Patched { segments, .. } => {
+                        instantiate_binding_content(segments, columns, row, &mut dynamic_content);
+                    }
+                    BindingDynamicProgram::Commands(template) => {
+                        let overlay = instantiate_binding_overlay_page(
+                            template,
+                            &binding_plan.slot_lookup,
+                            columns,
+                            row,
+                        );
+                        dynamic_content = self
+                            .render_page_sized(&overlay, self.page_ids.len(), program.geometry)?
+                            .into_bytes();
+                    }
+                }
                 self.add_bound_page(
                     program.static_content_id,
                     program.static_content_len,
                     &dynamic_content,
                     program.geometry,
                 )?;
-                debug_assert!(program.dynamic_slot_occurrences > 0);
             }
         }
         Ok(())