fullbleed 2.2.4__tar.gz → 2.2.5__tar.gz

{fullbleed-2.2.4 → fullbleed-2.2.5}/Cargo.lock

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

{fullbleed-2.2.4 → fullbleed-2.2.5}/Cargo.toml

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

{fullbleed-2.2.4 → fullbleed-2.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fullbleed
-Version: 2.2.4
+Version: 2.2.5
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: MacOS
@@ -136,7 +136,7 @@ size-changing records render 200x faster. See
 [`docs/performance-architecture.md`](docs/performance-architecture.md) for the packed vector IR,
 typed-binding, virtual-linker, and shader roadmap.
 
-Fullbleed 2.2.4 adds a third compiler lane for
+Fullbleed 2.2.5 hardens the third compiler lane introduced in 2.2.4 for
 size-changing records: `CompiledDocument.render_pdf_reflow_bindings(...)`. It parses and recovers
 the template DOM once and compiles encountered structural flow variants into guarded fixed-point
 display programs. Matching records bind directly into those programs; workers execute pre-shaped
@@ -144,15 +144,17 @@ text/TJ paint slots, cached static PDF page segments, page-local Deflate, and on
 Explicit trusted structural slots use `data-fb-bind-html="slot"`. A value that no compiled variant
 can safely place runs ordinary fixed-point layout once to add another variant.
 
-On the independent 1,000-distinct-record case study, the final ABI3 wheel's 29-sample hot
-direct-file run had a 168.839 ms median: **5,923 records/s and 10,365 pages/s**, with a 12,510
-pages/s best. It produced
+On the independent 1,000-distinct-record case study, the 29-sample hot direct-file median was
+216.160 ms: **4,626 records/s and 8,096 pages/s**. The 168.995 ms best sample reached **5,917
+records/s and 10,355 pages/s**. It produced
 the exact 1,750-page 500/300/150/50 reflow distribution and verified all 24,900 markers. The
 throughput-tuned 6,870,320-byte PDF was deterministic across all samples. With the compact
 compression setting, compiled output was also byte-for-byte identical to ordinary rendering:
 5,298,961 bytes and SHA-256 `bb3c441313a08fb00d3bd15f23a567981f3bbbd550908e3a9fe7a07ca5d7f138`.
-This is a hot compiled-variant result, not a claim for previously unseen structure; the first
-compile-on-demand batch measured 407.521 ms (4,294 pages/s).
+This is a hot compiled-variant result, not a claim for previously unseen structure. The first
+variant-discovery render measured 0.509 s (3,437 pages/s), and the fully cold job including setup,
+bindings, compilation, discovery, and write measured 0.588 s (2,975 pages/s). The independently
+observed hot-median speedup over the ordinary path was 43.8x.
 
 ## Install
 
@@ -165,7 +167,7 @@ python -m pip install fullbleed
 From a local wheel:
 
 ```bash
-python -m pip install C:\path\to\fullbleed-2.2.4-cp310-abi3-win_amd64.whl
+python -m pip install C:\path\to\fullbleed-2.2.5-cp310-abi3-win_amd64.whl
 ```
 
 From a source checkout with Rust installed, no Python build package is needed:
@@ -618,7 +620,8 @@ Machine discovery:
 fullbleed capabilities --json
 ```
 
-Inspect the `svg` object in `fullbleed.capabilities.v1` for SVG support metadata.
+Inspect the `svg` object in `fullbleed.capabilities.v1` for SVG support metadata. The `engine`
+object also reports compiled-document/reflow availability and supported per-call compression modes.
 It reports the compiled `svg_raster` build feature plus a feature matrix for
 native-vector SVG, raster-fallback-required SVG, and unsupported/known-loss SVG
 features.
@@ -977,6 +980,7 @@ Module exports:
 
 - `PdfEngine`
 - `CompiledDocument`
+- `CompiledFlowCompression`
 - `AssetBundle`
 - `Asset`
 - `AssetKind`
@@ -1025,8 +1029,8 @@ Module exports:
 | `render_pdf_batch(copies, deterministic_hash=None)` | `bytes` |
 | `render_pdf_bindings(bindings, deterministic_hash=None)` | `bytes` |
 | `render_pdf_bindings_to_file(bindings, path, deterministic_hash=None)` | `int` |
-| `render_pdf_reflow_bindings(bindings, deterministic_hash=None)` | `bytes` |
-| `render_pdf_reflow_bindings_to_file(bindings, path, deterministic_hash=None)` | `int` |
+| `render_pdf_reflow_bindings(bindings, deterministic_hash=None, *, compression="throughput")` | `bytes` |
+| `render_pdf_reflow_bindings_to_file(bindings, path, deterministic_hash=None, *, compression="throughput")` | `int` |
 
 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
@@ -1038,7 +1042,10 @@ The reflow binding methods use the same exact-column contract but execute the co
 program. `{{slot}}` values are literal text and may reshape, wrap, resize blocks, and change page
 counts. Empty elements can opt into trusted generated markup with
 `data-fb-bind-html="slot"`; those values replace the element's children. One DOM is reused per
-native worker and record output is linked in input order through a bounded queue. See
+native worker and record output is linked in input order through a bounded queue. Structural slot
+values are parsed as trusted markup: sanitize untrusted input or use scalar `{{slot}}` bindings,
+which remain literal text. Choose `CompiledFlowCompression.Throughput` (default) or
+`CompiledFlowCompression.Compact` per render; modes can be mixed safely in one process. See
 [`docs/python-api.md`](docs/python-api.md) for the trust boundary and current limitations.
 
 When `deterministic_hash` is set, engine writes PDF SHA-256 to the provided file path.

{fullbleed-2.2.4 → fullbleed-2.2.5}/README.md

@@ -99,7 +99,7 @@ size-changing records render 200x faster. See
 [`docs/performance-architecture.md`](docs/performance-architecture.md) for the packed vector IR,
 typed-binding, virtual-linker, and shader roadmap.
 
-Fullbleed 2.2.4 adds a third compiler lane for
+Fullbleed 2.2.5 hardens the third compiler lane introduced in 2.2.4 for
 size-changing records: `CompiledDocument.render_pdf_reflow_bindings(...)`. It parses and recovers
 the template DOM once and compiles encountered structural flow variants into guarded fixed-point
 display programs. Matching records bind directly into those programs; workers execute pre-shaped
@@ -107,15 +107,17 @@ text/TJ paint slots, cached static PDF page segments, page-local Deflate, and on
 Explicit trusted structural slots use `data-fb-bind-html="slot"`. A value that no compiled variant
 can safely place runs ordinary fixed-point layout once to add another variant.
 
-On the independent 1,000-distinct-record case study, the final ABI3 wheel's 29-sample hot
-direct-file run had a 168.839 ms median: **5,923 records/s and 10,365 pages/s**, with a 12,510
-pages/s best. It produced
+On the independent 1,000-distinct-record case study, the 29-sample hot direct-file median was
+216.160 ms: **4,626 records/s and 8,096 pages/s**. The 168.995 ms best sample reached **5,917
+records/s and 10,355 pages/s**. It produced
 the exact 1,750-page 500/300/150/50 reflow distribution and verified all 24,900 markers. The
 throughput-tuned 6,870,320-byte PDF was deterministic across all samples. With the compact
 compression setting, compiled output was also byte-for-byte identical to ordinary rendering:
 5,298,961 bytes and SHA-256 `bb3c441313a08fb00d3bd15f23a567981f3bbbd550908e3a9fe7a07ca5d7f138`.
-This is a hot compiled-variant result, not a claim for previously unseen structure; the first
-compile-on-demand batch measured 407.521 ms (4,294 pages/s).
+This is a hot compiled-variant result, not a claim for previously unseen structure. The first
+variant-discovery render measured 0.509 s (3,437 pages/s), and the fully cold job including setup,
+bindings, compilation, discovery, and write measured 0.588 s (2,975 pages/s). The independently
+observed hot-median speedup over the ordinary path was 43.8x.
 
 ## Install
 
@@ -128,7 +130,7 @@ python -m pip install fullbleed
 From a local wheel:
 
 ```bash
-python -m pip install C:\path\to\fullbleed-2.2.4-cp310-abi3-win_amd64.whl
+python -m pip install C:\path\to\fullbleed-2.2.5-cp310-abi3-win_amd64.whl
 ```
 
 From a source checkout with Rust installed, no Python build package is needed:
@@ -581,7 +583,8 @@ Machine discovery:
 fullbleed capabilities --json
 ```
 
-Inspect the `svg` object in `fullbleed.capabilities.v1` for SVG support metadata.
+Inspect the `svg` object in `fullbleed.capabilities.v1` for SVG support metadata. The `engine`
+object also reports compiled-document/reflow availability and supported per-call compression modes.
 It reports the compiled `svg_raster` build feature plus a feature matrix for
 native-vector SVG, raster-fallback-required SVG, and unsupported/known-loss SVG
 features.
@@ -940,6 +943,7 @@ Module exports:
 
 - `PdfEngine`
 - `CompiledDocument`
+- `CompiledFlowCompression`
 - `AssetBundle`
 - `Asset`
 - `AssetKind`
@@ -988,8 +992,8 @@ Module exports:
 | `render_pdf_batch(copies, deterministic_hash=None)` | `bytes` |
 | `render_pdf_bindings(bindings, deterministic_hash=None)` | `bytes` |
 | `render_pdf_bindings_to_file(bindings, path, deterministic_hash=None)` | `int` |
-| `render_pdf_reflow_bindings(bindings, deterministic_hash=None)` | `bytes` |
-| `render_pdf_reflow_bindings_to_file(bindings, path, deterministic_hash=None)` | `int` |
+| `render_pdf_reflow_bindings(bindings, deterministic_hash=None, *, compression="throughput")` | `bytes` |
+| `render_pdf_reflow_bindings_to_file(bindings, path, deterministic_hash=None, *, compression="throughput")` | `int` |
 
 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
@@ -1001,7 +1005,10 @@ The reflow binding methods use the same exact-column contract but execute the co
 program. `{{slot}}` values are literal text and may reshape, wrap, resize blocks, and change page
 counts. Empty elements can opt into trusted generated markup with
 `data-fb-bind-html="slot"`; those values replace the element's children. One DOM is reused per
-native worker and record output is linked in input order through a bounded queue. See
+native worker and record output is linked in input order through a bounded queue. Structural slot
+values are parsed as trusted markup: sanitize untrusted input or use scalar `{{slot}}` bindings,
+which remain literal text. Choose `CompiledFlowCompression.Throughput` (default) or
+`CompiledFlowCompression.Compact` per render; modes can be mixed safely in one process. See
 [`docs/python-api.md`](docs/python-api.md) for the trust boundary and current limitations.
 
 When `deterministic_hash` is set, engine writes PDF SHA-256 to the provided file path.

{fullbleed-2.2.4 → fullbleed-2.2.5}/pyproject.toml

@@ -5,7 +5,7 @@ backend-path = ["build_backend"]
 
 [project]
 name = "fullbleed"
-version = "2.2.4"
+version = "2.2.5"
 description = "Deterministic static HTML/CSS-to-PDF renderer built in Rust"
 readme = "README.md"
 requires-python = ">=3.10"

{fullbleed-2.2.4 → fullbleed-2.2.5}/python/fullbleed/_abi.py

@@ -54,6 +54,16 @@ class AssetKind(metaclass=_NativeFacadeType):
         raise TypeError("No constructor defined for AssetKind")
 
 
+class CompiledFlowCompression(metaclass=_NativeFacadeType):
+    """Per-call size/speed policy for compiled content-reflow PDF streams."""
+
+    Throughput = "throughput"
+    Compact = "compact"
+
+    def __new__(cls, /, *args, **kwargs):
+        raise TypeError("No constructor defined for CompiledFlowCompression")
+
+
 class Asset(metaclass=_NativeFacadeType):
     __slots__ = ("_handle",)
 
@@ -219,25 +229,42 @@ class CompiledDocument(metaclass=_NativeFacadeType):
             deterministic_hash,
         )
 
-    def render_pdf_reflow_bindings(self, /, bindings, deterministic_hash=None):
+    def render_pdf_reflow_bindings(
+        self,
+        /,
+        bindings,
+        deterministic_hash=None,
+        *,
+        compression=CompiledFlowCompression.Throughput,
+    ):
         """Render columnar text bindings with content-driven layout and pagination."""
+        _require_string(compression, "compression")
         return _call(
             self._handle,
             "CompiledDocument.render_pdf_reflow_bindings",
             bindings,
             deterministic_hash,
+            compression,
         )
 
     def render_pdf_reflow_bindings_to_file(
-        self, /, bindings, path, deterministic_hash=None
+        self,
+        /,
+        bindings,
+        path,
+        deterministic_hash=None,
+        *,
+        compression=CompiledFlowCompression.Throughput,
     ):
         """Stream a compiled content-reflow batch directly to ``path``."""
+        _require_string(compression, "compression")
         return _call(
             self._handle,
             "CompiledDocument.render_pdf_reflow_bindings_to_file",
             bindings,
             path,
             deterministic_hash,
+            compression,
         )
 
 
@@ -579,7 +606,9 @@ class PdfEngine(metaclass=_NativeFacadeType):
         )
 
     def render_pdf(self, /, html, css, deterministic_hash=None):
-        return _call(self._handle, "PdfEngine.render_pdf", html, css, deterministic_hash)
+        return _call(
+            self._handle, "PdfEngine.render_pdf", html, css, deterministic_hash
+        )
 
     def compile_pdf(self, /, html, css):
         handle = _call(self._handle, "PdfEngine.compile_pdf", html, css)
@@ -747,7 +776,9 @@ class PdfEngine(metaclass=_NativeFacadeType):
             deterministic_hash,
         )
 
-    def render_pdf_batch_to_file(self, /, html_list, css, path, deterministic_hash=None):
+    def render_pdf_batch_to_file(
+        self, /, html_list, css, path, deterministic_hash=None
+    ):
         return _call(
             self._handle,
             "PdfEngine.render_pdf_batch_to_file",
@@ -897,6 +928,7 @@ def audit_sparse_page_visual_pair(source_png_path, render_png_path):
 __all__ = [
     "PdfEngine",
     "CompiledDocument",
+    "CompiledFlowCompression",
     "AssetKind",
     "Asset",
     "AssetBundle",
@@ -925,6 +957,7 @@ __all__ = [
 _CLASS_NAMES = {
     "PdfEngine",
     "CompiledDocument",
+    "CompiledFlowCompression",
     "AssetKind",
     "Asset",
     "AssetBundle",

{fullbleed-2.2.4 → fullbleed-2.2.5}/python/fullbleed_cli/cli.py

@@ -2793,6 +2793,8 @@ def cmd_capabilities(args):
             build_features = {}
     svg_raster_available = bool(build_features.get("svg_raster", False))
     pdf_engine = getattr(fullbleed, "PdfEngine", None)
+    compiled_document = getattr(fullbleed, "CompiledDocument", None)
+    compression_modes = list(build_features.get("compiled_flow_compression_modes", []))
 
     commands = [
         "render",
@@ -2828,6 +2830,14 @@ def cmd_capabilities(args):
             "--repro-check",
         ],
         "engine": {
+            "compiled_document": bool(pdf_engine and hasattr(pdf_engine, "compile_pdf")),
+            "compiled_reflow_bindings": bool(
+                build_features.get("compiled_reflow", False)
+                and pdf_engine
+                and compiled_document
+                and hasattr(compiled_document, "render_pdf_reflow_bindings")
+            ),
+            "compiled_flow_compression_modes": compression_modes,
             "batch_render": bool(pdf_engine and hasattr(pdf_engine, "render_pdf_batch")),
             "batch_render_parallel": bool(
                 pdf_engine and hasattr(pdf_engine, "render_pdf_batch_parallel")
@@ -3677,5 +3687,3 @@ if __name__ == "__main__":
     raise SystemExit(main())
 
 
-
-

{fullbleed-2.2.4 → fullbleed-2.2.5}/src/flate_native.rs

@@ -1,6 +1,4 @@
 use std::cell::RefCell;
-use std::sync::OnceLock;
-
 const ADLER_BASE: u32 = 65_521;
 const DEFAULT_ADLER_CHUNK: usize = 1 << 20;
 const ADLER_NMAX: usize = 5_552;
@@ -425,15 +423,14 @@ pub(crate) fn zlib_deflate_parallel(data: &[u8]) -> Vec<u8> {
     zlib_deflate_with_chain(data, MAX_CHAIN_STEPS)
 }
 
-pub(crate) fn zlib_deflate_compiled_flow(data: &[u8]) -> Vec<u8> {
-    static COMPILED_FLOW_CHAIN_STEPS: OnceLock<usize> = OnceLock::new();
-    let steps = *COMPILED_FLOW_CHAIN_STEPS.get_or_init(|| {
-        std::env::var("FULLBLEED_COMPILED_FLOW_DEFLATE_CHAIN")
-            .ok()
-            .and_then(|value| value.parse::<usize>().ok())
-            .unwrap_or(DEFAULT_COMPILED_FLOW_CHAIN_STEPS)
-            .clamp(1, MAX_CHAIN_STEPS)
-    });
+pub(crate) fn zlib_deflate_compiled_flow(
+    data: &[u8],
+    compression: crate::pdf::CompiledFlowCompression,
+) -> Vec<u8> {
+    let steps = match compression {
+        crate::pdf::CompiledFlowCompression::Throughput => DEFAULT_COMPILED_FLOW_CHAIN_STEPS,
+        crate::pdf::CompiledFlowCompression::Compact => MAX_CHAIN_STEPS,
+    };
     let steps = if data.len() < COMPILED_FLOW_THROUGHPUT_MIN_BYTES {
         MAX_CHAIN_STEPS
     } else {
@@ -923,6 +920,32 @@ mod tests {
         }
     }
 
+    #[test]
+    fn compiled_flow_compression_modes_are_per_call_and_deterministic() {
+        use crate::pdf::CompiledFlowCompression::{Compact, Throughput};
+
+        let src = (0..8_000)
+            .map(|index| format!("BT /F1 10 Tf 72 720 Td [(RECORD-{index:05})] TJ ET\n"))
+            .collect::<String>()
+            .into_bytes();
+        let throughput = zlib_deflate_compiled_flow(&src, Throughput);
+        let compact = zlib_deflate_compiled_flow(&src, Compact);
+        assert_eq!(throughput, zlib_deflate_compiled_flow(&src, Throughput));
+        assert_eq!(compact, zlib_deflate_compiled_flow(&src, Compact));
+        assert_eq!(
+            zlib_inflate(&throughput, src.len()).expect("throughput roundtrip"),
+            src
+        );
+        assert_eq!(
+            zlib_inflate(&compact, src.len()).expect("compact roundtrip"),
+            src
+        );
+        assert!(
+            compact.len() <= throughput.len(),
+            "compact search should not produce a larger representative stream"
+        );
+    }
+
     #[test]
     fn zlib_lz77_roundtrip_empty() {
         let src: Vec<u8> = Vec::new();

{fullbleed-2.2.4 → fullbleed-2.2.5}/src/flowable.rs

@@ -33108,8 +33108,20 @@ impl Flowable for ContainerFlowable {
                 && sibling_boundary_context
                 && combined_occupied_height - remaining_height <= Pt::from_milli_i64(1_500)
                 && child.has_paint_only_fixed_height_tail(content_width, child_available_height);
+            // Relax `break-inside: avoid` before deferring an oversized box.
+            // The UA stylesheet gives tables this value too, so suppressing a
+            // split merely because earlier siblings were placed orphaned a
+            // kept heading and moved a long, splittable table to the next
+            // page. The same behavior wasted the remainder before an
+            // oversized authored keep-together block. Avoidance is only
+            // actionable when the complete box can fit a fresh fragmentainer.
+            let fresh_size =
+                avoids_page_break.then(|| child.wrap(content_width, available_content_height));
+            let fits_fresh_fragmentainer =
+                fresh_size.is_some_and(|fresh| fresh.height <= available_content_height);
             let child_split = if paint_only_edge_overhang
                 || (avoids_page_break
+                    && fits_fresh_fragmentainer
                     && ((!placed.is_empty() && !follows_only_table_captions)
                         || size.height <= available_content_height))
             {