diff --git a/docs/decisions/report-engine.md b/docs/decisions/report-engine.md
index e635f6e6..2f4e547b 100644
--- a/docs/decisions/report-engine.md
+++ b/docs/decisions/report-engine.md
@@ -39,9 +39,18 @@ license) and Droid Sans Fallback (CJK ideographs and kana; Apache-2.0). They
 live in `src-tauri/fonts/` and are compiled into the app, so output never
 depends on the fonts a machine has installed. Their advance widths ship as
 runs in `src/reports/engine/fallback-metrics.ts`, which a Rust test generates
-from the font files and fails on when it is stale. Hebrew, Arabic and other
-scripts that need shaping or right-to-left order are excluded. A character no
-font covers still prints as `?`, in the preview and in the PDF alike. Bold text
+from the font files and fails on when it is stale.
+
+The fallback fonts never draw these code points, which print as `?`:
+WinAnsi characters (Helvetica draws them), U+0590–U+08FF (Hebrew, Arabic,
+Syriac, Thaana, N'Ko, Samaritan, Mandaic and their supplements), U+FB1D–U+FDFF
+and U+FE70–U+FEFF (Hebrew and Arabic presentation forms), and lone surrogates.
+These scripts need right-to-left order or contextual shaping, which the
+engine doesn't do. Neither font has Hangul syllables, Thai, or Devanagari and
+the other Indic scripts, so they print as `?` too. Lao and combining marks
+are in DejaVu Sans and print, but unshaped: a mark sits at the pen position
+instead of over its base. A character no font covers prints as `?`, in the
+preview and in the PDF alike. Bold text
 in a fallback font uses the regular glyphs at the same width; the PDF strokes
 their outlines to darken them.
 
@@ -100,12 +109,23 @@ past its box.
   height of its wrapped text. Every component that starts at or below a growing
   box's designed bottom edge moves down by that box's growth plus the box's own
   shift, so stacked boxes push each other down. The band grows by the largest
-  shift plus growth, and pagination uses the grown height, so a grown band
-  moves to the next page like any other. A band never splits inside grown text.
-  Text is measured with the band's row scope before pagination, so `page` and
-  `pages` don't make a box grow. A repeated group header prints at its grown
-  height. In a band with a table, and in page headers and footers, boxes keep
-  their designed height; a table band reports a diagnostic.
+  shift plus growth, and pagination uses the grown height. Text is measured
+  with the band's row scope before pagination, so `page` and `pages` don't
+  make a box grow. A repeated group header prints at its grown height. In a
+  band with a table, and in page headers and footers, boxes keep their
+  designed height; a table band reports a diagnostic, and the designer hides
+  Can grow on page header and footer text.
+- A band whose text grew splits across pages (`engine/split.ts`) unless
+  `keepTogether` is set and the band fits on one page. It starts on the
+  current page when its designed height fits there. Layout renders the whole
+  band at its own origin, then cuts it into pieces that fit the remaining
+  body: a cut falls between text lines, and an image or line that would cross
+  it moves the cut above that item. Text keeps the lines that start in a
+  piece; text frames, rectangles and vertical lines are clipped to it, so a
+  bordered box shows its own part on each page. Each continuation starts at
+  the body top below any repeated group headers, and components under the
+  grown text follow its last piece. When not even one line fits an empty page
+  body, the band is cut at the body bottom.
 
 ### Determinism guarantees and tolerances
 
@@ -145,11 +165,18 @@ grayscale, RGB, and palette PNGs pass their IDAT data through with
 `FlateDecode` and the PNG predictor. Every other PNG (an alpha channel, `tRNS`
 transparency, interlacing, 16-bit samples) is decoded by Rust into 8-bit color
 samples and, when any pixel is translucent, an 8-bit alpha image that the
-writer attaches as the image's `/SMask`. Other formats print as a crossed
-placeholder box.
+writer attaches as the image's `/SMask`. 16-bit samples never pass through,
+because `/BitsPerComponent 16` needs PDF 1.5. Rust rejects a PNG that
+declares more than 50 megapixels before it allocates the pixel buffer, and
+caps the decoder's own buffers at 64 MiB, so a small file that declares a huge
+image can't exhaust memory. Other formats, and PNGs that are too large or
+unreadable, print as a crossed placeholder box, and the export message names
+each such image and the reason.
 
 Export calls `prepare_report_pdf` (`src-tauri/src/report_pdf.rs`) only when a
-report needs a fallback font or a decoded PNG. It returns the font subsets
+report needs a fallback font or a decoded PNG. It is an async command, so the
+subsetting, decoding and deflating run on a worker thread instead of the main
+thread. It returns the font subsets
 (`subsetter` crate, glyph ids renumbered in ascending order, subset tag hashed
 from the glyphs) and the decoded images, all zlib-compressed by the pinned
 `flate2` backend. Its output depends only on its input, so the same report
@@ -194,6 +221,7 @@ arbitrary HTML or CSS. This engine also leaves these for later:
   right-to-left layout
 - can-grow text in bands with a table, can-shrink, and more than one table per
   band
+- caching font subsets between exports
 - image formats other than JPEG and PNG, which print as placeholders in the PDF
 - color
 - content stream compression and PDF/A
@@ -209,10 +237,14 @@ arbitrary HTML or CSS. This engine also leaves these for later:
 - `tests/unit/report-grow.test.ts`: can-grow boxes push components and the band
   down, chain through stacked boxes, paginate by grown height, and repeat at
   grown height.
+- `tests/unit/report-grow-split.test.ts`: a grown band taller than a page splits
+  across pages without losing or repeating a line, a sibling beside it stays
+  put, `keepTogether` moves a band that fits, and the cut and slice helpers.
 - `tests/unit/report-unicode.test.ts`: fallback metrics, font runs, Type0 font
   objects and CID text, and SMask image objects.
 - `src-tauri/src/report_pdf_tests.rs`: glyph coverage, deterministic subsets,
-  the metrics table against the font files, and PNG alpha splitting.
+  the metrics table against the font files, PNG alpha splitting, and PNGs with
+  huge declared sizes, truncated data, 16-bit samples, and interlacing.
 - `tests/integration/report-pdf-resources.test.tsx`: exports Greek, Cyrillic,
   and CJK text and an RGBA PNG through the Rust command.
 - `tests/integration/report-parameters.test.tsx`: the parameter prompt from
diff --git a/src-tauri/src/report_pdf.rs b/src-tauri/src/report_pdf.rs
index 21b6197b..e4d8836f 100644
--- a/src-tauri/src/report_pdf.rs
+++ b/src-tauri/src/report_pdf.rs
@@ -124,6 +124,8 @@ pub struct ReportPdfResources {
     pub fonts: Vec<PdfFontSubset>,
     /// One entry per input PNG, in order; null when it can't be decoded.
     pub images: Vec<Option<PdfPngImage>>,
+    /// Why images print as placeholders (one line per undecodable PNG, by input position).
+    pub warnings: Vec<String>,
 }
 
 fn deflate(data: &[u8]) -> Result<Vec<u8>, AppError> {
@@ -200,20 +202,46 @@ pub fn font_subsets(code_points: &[u32]) -> Result<Vec<PdfFontSubset>, AppError>
     Ok(out)
 }
 
+/// Largest PNG the writer decodes. A header can declare any size, so the
+/// output buffer is never allocated before this check.
+pub const MAX_PNG_PIXELS: u64 = 50_000_000;
+/// Allocation budget for the PNG decoder's own buffers.
+const PNG_DECODER_BYTES: usize = 64 << 20;
+
 /// Decodes any PNG (palette, low bit depth, 16-bit, interlaced, tRNS) to
 /// 8-bit gray or RGB samples plus an alpha mask when any pixel is translucent.
-pub fn decode_png(bytes: &[u8]) -> Option<PdfPngImage> {
-    let mut decoder = png::Decoder::new(std::io::Cursor::new(bytes));
+/// Errors say why the image prints as a placeholder instead.
+pub fn decode_png(bytes: &[u8]) -> Result<PdfPngImage, String> {
+    let mut decoder = png::Decoder::new_with_limits(
+        std::io::Cursor::new(bytes),
+        png::Limits {
+            bytes: PNG_DECODER_BYTES,
+        },
+    );
     decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16);
-    let mut reader = decoder.read_info().ok()?;
-    let mut buf = vec![0; reader.output_buffer_size()?];
-    let info = reader.next_frame(&mut buf).ok()?;
+    let mut reader = decoder
+        .read_info()
+        .map_err(|e| format!("unreadable PNG: {e}"))?;
+    let (width, height) = (reader.info().width, reader.info().height);
+    if u64::from(width) * u64::from(height) > MAX_PNG_PIXELS {
+        return Err(format!(
+            "PNG is {width}×{height}, larger than the {} megapixel limit",
+            MAX_PNG_PIXELS / 1_000_000
+        ));
+    }
+    let size = reader
+        .output_buffer_size()
+        .ok_or_else(|| "PNG is too large to decode".to_string())?;
+    let mut buf = vec![0; size];
+    let info = reader
+        .next_frame(&mut buf)
+        .map_err(|e| format!("unreadable PNG: {e}"))?;
     let (colors, has_alpha) = match info.color_type {
         png::ColorType::Grayscale => (1, false),
         png::ColorType::GrayscaleAlpha => (1, true),
         png::ColorType::Rgb => (3, false),
         png::ColorType::Rgba => (3, true),
-        png::ColorType::Indexed => return None,
+        png::ColorType::Indexed => return Err("unsupported PNG color type".into()),
     };
     let channels = colors + usize::from(has_alpha);
     let pixels = info.width as usize * info.height as usize;
@@ -230,42 +258,58 @@ pub fn decode_png(bytes: &[u8]) -> Option<PdfPngImage> {
     } else {
         (samples.to_vec(), None)
     };
-    Some(PdfPngImage {
+    let compress = |data: &[u8]| deflate(data).map(|d| b64(&d)).map_err(|e| e.message);
+    Ok(PdfPngImage {
         width: info.width,
         height: info.height,
         colors: colors as u8,
-        color_base64: b64(&deflate(&color).ok()?),
-        alpha_base64: match alpha {
-            Some(a) => Some(b64(&deflate(&a).ok()?)),
-            None => None,
-        },
+        color_base64: compress(&color)?,
+        alpha_base64: alpha.as_deref().map(compress).transpose()?,
     })
 }
 
-/// Font subsets for the characters Helvetica can't print and decoded PNGs
-/// (base64) that the writer can't pass through (alpha, tRNS, interlacing).
-#[tauri::command]
-pub fn prepare_report_pdf(
-    window_label: String,
-    code_points: Vec<u32>,
-    pngs_base64: Vec<String>,
+/// Font subsets and decoded PNGs for one export (see `prepare_report_pdf`).
+pub fn pdf_resources(
+    code_points: &[u32],
+    pngs_base64: &[String],
 ) -> Result<ReportPdfResources, AppError> {
-    crate::manager()?.state(&window_label)?;
+    let mut warnings = vec![];
     let images = pngs_base64
         .iter()
-        .map(|data| {
-            base64::engine::general_purpose::STANDARD
+        .enumerate()
+        .map(|(i, data)| {
+            let decoded = base64::engine::general_purpose::STANDARD
                 .decode(data.as_bytes())
+                .map_err(|e| format!("invalid image data: {e}"))
+                .and_then(|bytes| decode_png(&bytes));
+            decoded
+                .map_err(|reason| {
+                    crate::logging::warn("reports", &format!("PDF image {}: {reason}", i + 1));
+                    warnings.push(format!("Image {}: {reason}", i + 1));
+                })
                 .ok()
-                .and_then(|bytes| decode_png(&bytes))
         })
         .collect();
     Ok(ReportPdfResources {
-        fonts: font_subsets(&code_points)?,
+        fonts: font_subsets(code_points)?,
         images,
+        warnings,
     })
 }
 
+/// Font subsets for the characters Helvetica can't print and decoded PNGs
+/// (base64) that the writer can't pass through (alpha, tRNS, interlacing,
+/// 16-bit). Runs on a worker thread: subsetting and deflating take a while.
+#[tauri::command(async)]
+pub fn prepare_report_pdf(
+    window_label: String,
+    code_points: Vec<u32>,
+    pngs_base64: Vec<String>,
+) -> Result<ReportPdfResources, AppError> {
+    crate::manager()?.state(&window_label)?;
+    pdf_resources(&code_points, &pngs_base64)
+}
+
 #[cfg(test)]
 mod tests {
     include!("report_pdf_tests.rs");
diff --git a/src-tauri/src/report_pdf_tests.rs b/src-tauri/src/report_pdf_tests.rs
index 837aeb9a..9aba4985 100644
--- a/src-tauri/src/report_pdf_tests.rs
+++ b/src-tauri/src/report_pdf_tests.rs
@@ -193,7 +193,7 @@ fn rgba_png_splits_into_color_and_soft_mask() {
         inflate(img.alpha_base64.as_deref().unwrap()),
         vec![255, 128, 0, 255]
     );
-    assert_eq!(decode_png(&bytes), Some(img), "deterministic");
+    assert_eq!(decode_png(&bytes), Ok(img), "deterministic");
 }
 
 #[test]
@@ -243,5 +243,86 @@ fn palette_png_with_transparency_expands_to_rgb_and_mask() {
     assert_eq!(img.colors, 3);
     assert_eq!(inflate(&img.color_base64), vec![10, 20, 30, 40, 50, 60]);
     assert_eq!(inflate(img.alpha_base64.as_deref().unwrap()), vec![0, 255]);
-    assert_eq!(decode_png(b"not a png"), None);
+    assert!(decode_png(b"not a png")
+        .unwrap_err()
+        .starts_with("unreadable PNG"));
+}
+
+/// A PNG written chunk by chunk, for headers the encoder won't produce.
+fn raw_png(ihdr: [u8; 13], scanlines: &[u8]) -> Vec<u8> {
+    let chunk = |out: &mut Vec<u8>, kind: &[u8; 4], data: &[u8]| {
+        out.extend_from_slice(&(data.len() as u32).to_be_bytes());
+        let mut crc = flate2::Crc::new();
+        crc.update(kind);
+        crc.update(data);
+        out.extend_from_slice(kind);
+        out.extend_from_slice(data);
+        out.extend_from_slice(&crc.sum().to_be_bytes());
+    };
+    let mut out = vec![0x89, b'P', b'N', b'G', 0x0d, 0x0a, 0x1a, 0x0a];
+    chunk(&mut out, b"IHDR", &ihdr);
+    chunk(&mut out, b"IDAT", &deflate(scanlines).unwrap());
+    chunk(&mut out, b"IEND", &[]);
+    out
+}
+
+fn ihdr(width: u32, height: u32, depth: u8, color: u8, interlace: u8) -> [u8; 13] {
+    let mut h = [0; 13];
+    h[..4].copy_from_slice(&width.to_be_bytes());
+    h[4..8].copy_from_slice(&height.to_be_bytes());
+    h[8] = depth;
+    h[9] = color;
+    h[12] = interlace;
+    h
+}
+
+#[test]
+fn huge_declared_png_is_rejected_before_allocating() {
+    // 40000×40000 RGBA would need 6.4 GB; the file itself is tiny.
+    let bytes = raw_png(ihdr(40_000, 40_000, 8, 6, 0), &[0]);
+    assert!(bytes.len() < 100);
+    let err = decode_png(&bytes).unwrap_err();
+    assert!(err.contains("40000×40000"), "{err}");
+    assert!(err.contains("50 megapixel"), "{err}");
+    let resources = pdf_resources(&[], &[b64(&bytes)]).unwrap();
+    assert_eq!(resources.images, vec![None]);
+    assert_eq!(resources.warnings.len(), 1);
+    assert!(resources.warnings[0].starts_with("Image 1: PNG is 40000×40000"));
+}
+
+#[test]
+fn truncated_png_is_rejected() {
+    let pixels = [7u8; 4 * 4 * 3];
+    let bytes = encode_png(png::ColorType::Rgb, png::BitDepth::Eight, 4, 4, &pixels);
+    let err = decode_png(&bytes[..bytes.len() / 2]).unwrap_err();
+    assert!(err.starts_with("unreadable PNG"), "{err}");
+    let resources = pdf_resources(&[], &["@@not base64".into()]).unwrap();
+    assert_eq!(resources.images, vec![None]);
+    assert!(resources.warnings[0].starts_with("Image 1: invalid image data"));
+}
+
+#[test]
+fn sixteen_bit_rgb_png_is_stripped_to_eight_bits() {
+    let pixels = [0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc];
+    let bytes = encode_png(png::ColorType::Rgb, png::BitDepth::Sixteen, 1, 1, &pixels);
+    let img = decode_png(&bytes).unwrap();
+    assert_eq!((img.colors, img.alpha_base64.clone()), (3, None));
+    assert_eq!(inflate(&img.color_base64), vec![0x12, 0x56, 0x9a]);
+}
+
+#[test]
+fn interlaced_png_is_deinterlaced() {
+    // Adam7 on 2×2 RGB: pass 1 holds (0,0), pass 6 holds (1,0), pass 7 holds row 1.
+    let scanlines = [
+        0, 1, 2, 3, // pass 1
+        0, 4, 5, 6, // pass 6
+        0, 7, 8, 9, 10, 11, 12, // pass 7
+    ];
+    let bytes = raw_png(ihdr(2, 2, 8, 2, 1), &scanlines);
+    let img = decode_png(&bytes).unwrap();
+    assert_eq!((img.width, img.height, img.colors), (2, 2, 3));
+    assert_eq!(
+        inflate(&img.color_base64),
+        vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+    );
 }
diff --git a/src/reports/ReportPreview.tsx b/src/reports/ReportPreview.tsx
index 2780e88e..d7fc5a4e 100644
--- a/src/reports/ReportPreview.tsx
+++ b/src/reports/ReportPreview.tsx
@@ -147,12 +147,15 @@ function LoadedPreview({
     try {
       const path = await choosePdfDestination(report.name);
       if (!path) return;
-      const bytes = await reportPdfBytes(result.doc, result.data.assets, {
+      const { bytes, warnings } = await reportPdfBytes(result.doc, result.data.assets, {
         title: report.name,
         creationDate: result.generatedAt,
       });
       await writeReportPdf(path, bytes, report.id);
-      setNotice(`Exported PDF to ${path}`);
+      const placeholders = warnings.length
+        ? `. Printed as placeholders: ${warnings.join("; ")}`
+        : "";
+      setNotice(`Exported PDF to ${path}${placeholders}`);
     } catch (reason) {
       setError(asTauriError(reason).message);
     }
diff --git a/src/reports/ReportRun.tsx b/src/reports/ReportRun.tsx
index 9dcce91d..ad53df67 100644
--- a/src/reports/ReportRun.tsx
+++ b/src/reports/ReportRun.tsx
@@ -107,7 +107,10 @@ export function ReportRun({
   const report = config.reports.find((r) => r.id === reportId);
   const parameters = report ? reportParameters(report, config.savedQueries) : [];
   const given = params ?? {};
-  const complete = parameters.every((p) => p.name in given);
+  // A required parameter passed as null still needs a value, so it prompts too.
+  const complete = parameters.every(
+    (p) => p.name in given && (!p.required || (given[p.name] ?? null) !== null),
+  );
   const [values, setValues] = useState<Record<string, unknown> | null>(complete ? given : null);
   const [prompting, setPrompting] = useState(!complete);
   if (!report) return <ReportPreview reportId={reportId} params={params} />;
diff --git a/src/reports/api.ts b/src/reports/api.ts
index 8f4d3390..b0d6d692 100644
--- a/src/reports/api.ts
+++ b/src/reports/api.ts
@@ -30,6 +30,8 @@ export interface PdfResources {
   fonts: PdfFontSubset[];
   /** One per requested PNG, in order; null when it can't be decoded. */
   images: (DecodedPng | null)[];
+  /** Why images print as placeholders, one line per undecodable PNG. */
+  warnings: string[];
 }
 
 /** Font subsets and decoded PNGs for the PDF writer (Rust `prepare_report_pdf`). */
diff --git a/src/reports/designer/ComponentProperties.tsx b/src/reports/designer/ComponentProperties.tsx
index 2d32103f..40e10f31 100644
--- a/src/reports/designer/ComponentProperties.tsx
+++ b/src/reports/designer/ComponentProperties.tsx
@@ -15,6 +15,8 @@ const FILLS: [string, number | null][] = [
 
 interface Props {
   component: ReportComponent;
+  /** Page header or footer: their height is fixed, so text can't grow there. */
+  pageBand?: boolean;
   columns: string[];
   queries: SavedQuery[];
   assets: AssetSummary[];
@@ -25,6 +27,7 @@ interface Props {
 /** Property editor for the selected report component. */
 export function ComponentProperties({
   component: c,
+  pageBand = false,
   columns,
   queries,
   assets,
@@ -167,7 +170,7 @@ export function ComponentProperties({
             Bold
           </label>
         )}
-        {isText && (
+        {isText && !pageBand && (
           <label className="inline">
             <input
               type="checkbox"
diff --git a/src/reports/designer/ReportDesigner.tsx b/src/reports/designer/ReportDesigner.tsx
index 6f633ee5..92c6003e 100644
--- a/src/reports/designer/ReportDesigner.tsx
+++ b/src/reports/designer/ReportDesigner.tsx
@@ -173,6 +173,7 @@ export function ReportDesigner({
         {selected ? (
           <ComponentProperties
             component={selected.component}
+            pageBand={isPageBand(selected.key)}
             columns={columns}
             queries={queries}
             assets={assets}
diff --git a/src/reports/engine/layout.ts b/src/reports/engine/layout.ts
index 36540fda..682439fd 100644
--- a/src/reports/engine/layout.ts
+++ b/src/reports/engine/layout.ts
@@ -10,6 +10,7 @@ import type {
   Row,
 } from "./document";
 import { type Growth, grown, growBand } from "./grow";
+import { cutAt, sliceItems } from "./split";
 import {
   componentItems,
   measureTable,
@@ -211,7 +212,16 @@ export function layoutReport(
     const growth = growBand(block.band, context(block.scope));
     if (!comp) {
       const h = block.band.height + (growth?.extra ?? 0);
-      return { ...block, growth, height: h, splittable: false, minFirst: h };
+      // Grown text splits between lines unless keepTogether holds and the band fits a page.
+      const splittable =
+        !!growth && (!block.band.keepTogether || h > bodyHeight - repeatHeight(block) + EPS);
+      return {
+        ...block,
+        growth,
+        height: h,
+        splittable,
+        minFirst: splittable ? block.band.height : h,
+      };
     }
     const geo = measureTable(comp, context(block.scope));
     const h = block.band.height + Math.max(0, geo.height - comp.h);
@@ -254,6 +264,34 @@ export function layoutReport(
   let pendingBreak = false;
 
   const firstNeed = (p: Prepared) => (p.splittable ? p.minFirst : p.height);
+  // Split a band with grown text at line boundaries, continuing on the next pages.
+  const splitGrown = (p: Prepared) => {
+    const noPage = { page: 0, pages: 0, groupPage: 0, groupPages: 0 };
+    const shape = bandItems(p, left, 0, noPage, context, "all");
+    const piece = (from: number, to: number, oy: number) =>
+      add((ctx) => sliceItems(bandItems(p, left, 0, ctx, context, "all"), from, to, oy - from));
+    let from = 0;
+    for (;;) {
+      const room = bodyBottom - cursor;
+      if (p.height - from <= room + EPS) {
+        piece(from, Number.POSITIVE_INFINITY, cursor);
+        cursor += p.height - from;
+        return;
+      }
+      let cut = cutAt(shape, from, from + room);
+      if (cut <= from + EPS) {
+        if (!atTop()) {
+          newPage(p.repeat);
+          continue;
+        }
+        // Not even one line fits an empty page: cut at the body bottom.
+        cut = from + room;
+      }
+      piece(from, cut, cursor);
+      from = cut;
+      newPage(p.repeat);
+    }
+  };
   // A block that fits a page only without the repeated headers gets a page without them.
   const pageFor = (p: Prepared) =>
     newPage(firstNeed(p) > bodyHeight - repeatHeight(p) + EPS ? [] : p.repeat);
@@ -270,6 +308,10 @@ export function layoutReport(
     pendingBreak = p.breakAfter;
     if (p.section) pageSection[pages.length - 1] = ++sections;
     if (cursor + need > bodyBottom + EPS && !atTop()) pageFor(p);
+    if (p.growth && p.splittable && cursor + p.height > bodyBottom + EPS) {
+      splitGrown(p);
+      continue;
+    }
     if (!p.table || cursor + p.height <= bodyBottom + EPS || !p.splittable) {
       const oy = cursor;
       add((ctx) => bandItems(p, left, oy, ctx, context, "all"));
diff --git a/src/reports/engine/split.ts b/src/reports/engine/split.ts
new file mode 100644
index 00000000..250b8916
--- /dev/null
+++ b/src/reports/engine/split.ts
@@ -0,0 +1,74 @@
+import { type PositionedItem, r2 } from "./document";
+import { BASELINE, LINE_HEIGHT } from "./text";
+
+/** Coordinates are rounded to 0.01 pt, so comparisons allow that much. */
+const TOL = 0.01;
+
+type TextItem = Extract<PositionedItem, { kind: "text" }>;
+type Line = TextItem["lines"][number];
+const lineTop = (item: TextItem, line: Line) => line.y - item.fontSize * BASELINE;
+const lineBottom = (item: TextItem, line: Line) =>
+  lineTop(item, line) + item.fontSize * LINE_HEIGHT;
+
+/**
+ * Where a piece of a band that starts at `from` and may reach `limit` ends
+ * (coordinates relative to the band top). The cut falls between text lines;
+ * an image or line that crosses it moves it above that item. Rectangles and
+ * text frames don't move it: they are clipped. Returns `from` when nothing
+ * fits.
+ */
+export function cutAt(items: PositionedItem[], from: number, limit: number): number {
+  let cut = limit;
+  for (let changed = true; changed; ) {
+    changed = false;
+    for (const item of items) {
+      const top = item.y;
+      const bottom = item.y + item.h;
+      if (top >= cut - TOL || bottom <= cut + TOL || item.kind === "rect") continue;
+      let next = cut;
+      if (item.kind === "text") {
+        const crossing = item.lines.find((line) => lineBottom(item, line) > cut + TOL);
+        if (crossing) next = lineTop(item, crossing);
+      } else next = top;
+      next = Math.max(from, next);
+      if (next < cut - TOL) {
+        cut = next;
+        changed = true;
+      }
+    }
+  }
+  return cut;
+}
+
+/**
+ * The items of one piece of a band, from `from` (inclusive) to `to`
+ * (exclusive), moved down by `dy`. Text keeps the lines that start in the
+ * piece; rectangles and vertical lines are clipped to it; images and
+ * horizontal lines go to the piece their top is in.
+ */
+export function sliceItems(
+  items: PositionedItem[],
+  from: number,
+  to: number,
+  dy: number,
+): PositionedItem[] {
+  const inside = (y: number) => y >= from - TOL && y < to - TOL;
+  const out: PositionedItem[] = [];
+  for (const item of items) {
+    const top = Math.max(item.y, from);
+    const h = Math.min(item.y + item.h, to) - top;
+    if (item.kind === "text") {
+      const lines = item.lines.filter((line) => inside(lineTop(item, line)));
+      if (!lines.length && !(item.lines.length === 0 && inside(item.y))) continue;
+      out.push({
+        ...item,
+        y: r2(top + dy),
+        h: r2(h),
+        lines: lines.map((line) => ({ ...line, y: r2(line.y + dy) })),
+      });
+    } else if (item.kind === "image" || (item.kind === "line" && item.h === 0)) {
+      if (inside(item.y)) out.push({ ...item, y: r2(item.y + dy) });
+    } else if (h > TOL) out.push({ ...item, y: r2(top + dy), h: r2(h) });
+  }
+  return out;
+}
diff --git a/src/reports/export.ts b/src/reports/export.ts
index b5699894..d7bf87ef 100644
--- a/src/reports/export.ts
+++ b/src/reports/export.ts
@@ -17,14 +17,15 @@ export function fallbackCodePoints(doc: ReportDocument): number[] {
 
 /**
  * PDF bytes of a laid-out report. Asks Rust for subsets of the bundled fonts
- * and for PNGs the writer can't pass through (alpha, tRNS, interlacing) only
- * when the report needs them, so plain reports make no extra call.
+ * and for PNGs the writer can't pass through (alpha, tRNS, interlacing,
+ * 16-bit) only when the report needs them, so plain reports make no extra
+ * call. `warnings` says which images print as placeholders and why.
  */
 export async function reportPdfBytes(
   doc: ReportDocument,
   assets: Record<string, { mediaType: string; dataBase64: string }>,
   options: Omit<PdfOptions, "assets" | "fonts" | "decodedImages">,
-): Promise<Uint8Array> {
+): Promise<{ bytes: Uint8Array; warnings: string[] }> {
   const used = new Set(
     doc.pages.flatMap((p) => p.items.flatMap((i) => (i.kind === "image" ? [i.assetId] : []))),
   );
@@ -45,9 +46,10 @@ export async function reportPdfBytes(
           codePoints,
           pngs.map((id) => assets[id].dataBase64),
         )
-      : { fonts: [], images: [] };
+      : { fonts: [], images: [], warnings: [] };
   const decodedImages = Object.fromEntries(
     pngs.flatMap((id, i) => (prepared.images[i] ? [[id, prepared.images[i]]] : [])),
   );
-  return writePdf(doc, { ...options, assets: bytes, fonts: prepared.fonts, decodedImages });
+  const pdf = writePdf(doc, { ...options, assets: bytes, fonts: prepared.fonts, decodedImages });
+  return { bytes: pdf, warnings: prepared.warnings };
 }
diff --git a/src/reports/pdf-images.ts b/src/reports/pdf-images.ts
index a525d514..ffaa2944 100644
--- a/src/reports/pdf-images.ts
+++ b/src/reports/pdf-images.ts
@@ -2,7 +2,8 @@
  * Image XObjects for the PDF writer without decoding pixels:
  * JPEG passes through as DCTDecode; PNG IDAT data passes through as
  * FlateDecode with the PNG predictor (non-interlaced gray, RGB and palette
- * images). Other PNGs (alpha, tRNS transparency, interlacing) are decoded by
+ * images, at most 8 bits per sample, as PDF 1.4 allows). Other PNGs (alpha,
+ * tRNS transparency, interlacing, 16-bit samples) are decoded by
  * Rust (`prepare_report_pdf`) into color samples plus a soft mask.
  */
 
@@ -77,7 +78,7 @@ export function jpegImage(data: Uint8Array): PdfImage | null {
 
 const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
 
-/** PNG passthrough for opaque non-interlaced grayscale, RGB and palette images. */
+/** PNG passthrough for opaque non-interlaced 8-bit-or-less grayscale, RGB and palette images. */
 export function pngImage(data: Uint8Array): PdfImage | null {
   if (!PNG_SIGNATURE.every((b, i) => data[i] === b)) return null;
   let i = 8;
@@ -104,13 +105,14 @@ export function pngImage(data: Uint8Array): PdfImage | null {
     else if (type === "IEND") break;
     i += 12 + length;
   }
-  if (!width || !height || interlace !== 0 || !idat.length) return null;
+  // 16-bit samples need PDF 1.5; Rust strips them to 8 bits instead.
+  if (!width || !height || interlace !== 0 || depth > 8 || !idat.length) return null;
   let colors: number;
   let space: string;
   if (colorType === 0) {
     colors = 1;
     space = "/DeviceGray";
-  } else if (colorType === 2 && (depth === 8 || depth === 16)) {
+  } else if (colorType === 2 && depth === 8) {
     colors = 3;
     space = "/DeviceRGB";
   } else if (colorType === 3 && palette && depth <= 8) {
diff --git a/tests/integration/golden/report-snapshots.test.tsx b/tests/integration/golden/report-snapshots.test.tsx
index 13d99d1f..fd09d26a 100644
--- a/tests/integration/golden/report-snapshots.test.tsx
+++ b/tests/integration/golden/report-snapshots.test.tsx
@@ -55,10 +55,11 @@ async function snapshotReports(template: string, expectedReports: string[]) {
       assets,
     });
     expect(doc.diagnostics, `${report.name} lays out without problems`).toEqual([]);
-    const pdf = await reportPdfBytes(doc, data.assets, {
+    const { bytes: pdf, warnings } = await reportPdfBytes(doc, data.assets, {
       title: report.name,
       creationDate: NOW.toISOString(),
     });
+    expect(warnings, `${report.name} images all print`).toEqual([]);
     const name = `${slug(template)}-${slug(report.name)}`;
     let json = JSON.stringify(doc, null, 1);
     const ids = [
diff --git a/tests/integration/report-pdf-resources.test.tsx b/tests/integration/report-pdf-resources.test.tsx
index 903ff340..88f97b7b 100644
--- a/tests/integration/report-pdf-resources.test.tsx
+++ b/tests/integration/report-pdf-resources.test.tsx
@@ -7,7 +7,7 @@ import { renderNewDocument } from "./helpers";
 
 const latin1 = (bytes: Uint8Array) => Buffer.from(bytes).toString("latin1");
 
-function rgbaPng(): string {
+function png(ihdr: number[], pixels: number[]): string {
   const crc = (buf: Buffer) => {
     let c = ~0;
     for (const b of buf) {
@@ -23,16 +23,17 @@ function rgbaPng(): string {
     tail.writeUInt32BE(crc(Buffer.concat([Buffer.from(type), body])));
     return Buffer.concat([head, Buffer.from(type), body, tail]);
   };
-  const ihdr = Buffer.from([0, 0, 0, 2, 0, 0, 0, 1, 8, 6, 0, 0, 0]);
-  const pixels = Buffer.from([0, 255, 0, 0, 255, 0, 255, 0, 128]);
   return Buffer.concat([
     Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
-    chunk("IHDR", ihdr),
-    chunk("IDAT", deflateSync(pixels)),
+    chunk("IHDR", Buffer.from(ihdr)),
+    chunk("IDAT", deflateSync(Buffer.from(pixels))),
     chunk("IEND", Buffer.alloc(0)),
   ]).toString("base64");
 }
 
+const rgbaPng = () =>
+  png([0, 0, 0, 2, 0, 0, 0, 1, 8, 6, 0, 0, 0], [0, 255, 0, 0, 255, 0, 255, 0, 128]);
+
 it("exports Greek, Cyrillic and CJK text with embedded font subsets and PNG alpha as an SMask", async () => {
   await renderNewDocument();
   const report = newReport("Unicode");
@@ -47,7 +48,8 @@ it("exports Greek, Cyrillic and CJK text with embedded font subsets and PNG alph
     assets: { logo: { mediaType: "image/png" } },
   });
   const options = { title: "Unicode", creationDate: "2026-01-01T00:00:00Z" };
-  const bytes = await reportPdfBytes(doc, assets, options);
+  const { bytes, warnings } = await reportPdfBytes(doc, assets, options);
+  expect(warnings).toEqual([]);
   const text = latin1(bytes);
   expect(text).toMatch(/\/BaseFont \/[A-Z]{6}\+DejaVuSans \/Encoding \/Identity-H/);
   expect(text).toMatch(/\/BaseFont \/[A-Z]{6}\+DroidSansFallback \/Encoding \/Identity-H/);
@@ -59,5 +61,24 @@ it("exports Greek, Cyrillic and CJK text with embedded font subsets and PNG alph
     /\/Width 2 \/Height 1 \/ColorSpace \/DeviceRGB \/BitsPerComponent 8 \/Filter \/FlateDecode \/SMask \d+ 0 R/,
   );
   expect(text).toContain("/Im1 Do");
-  expect(latin1(await reportPdfBytes(doc, assets, options))).toBe(text);
+  expect(latin1((await reportPdfBytes(doc, assets, options)).bytes)).toBe(text);
+}, 60_000);
+
+it("prints an oversized PNG as a placeholder with a warning instead of allocating it", async () => {
+  await renderNewDocument();
+  const report = newReport("Huge");
+  report.bands.detail.components = [
+    { id: "i", kind: "image", assetId: "huge", x: 0, y: 0, w: 40, h: 20 },
+  ];
+  const huge = png([0, 0, 0x9c, 0x40, 0, 0, 0x9c, 0x40, 8, 6, 0, 0, 0], [0]);
+  const doc = layoutReport(report, [{}], { assets: { huge: { mediaType: "image/png" } } });
+  const { bytes, warnings } = await reportPdfBytes(
+    doc,
+    { huge: { mediaType: "image/png", dataBase64: huge } },
+    { creationDate: "2026-01-01T00:00:00Z" },
+  );
+  expect(warnings).toEqual(["Image 1: PNG is 40000×40000, larger than the 50 megapixel limit"]);
+  const text = latin1(bytes);
+  expect(text).not.toContain("/Subtype /Image");
+  expect(text).toMatch(/ re S .* m .* l .* m .* l S Q/);
 }, 60_000);
diff --git a/tests/unit/report-grow-split.test.ts b/tests/unit/report-grow-split.test.ts
new file mode 100644
index 00000000..202c5f46
--- /dev/null
+++ b/tests/unit/report-grow-split.test.ts
@@ -0,0 +1,172 @@
+import { describe, expect, it } from "vitest";
+import { layoutReport, type PositionedItem, type ReportDocument } from "../../src/reports/engine";
+import { cutAt, sliceItems } from "../../src/reports/engine/split";
+import type { ReportComponent } from "../../src/reports/types";
+import { band, baseReport } from "./report-fixtures";
+
+const words = Array.from({ length: 600 }, (_, i) => `w${i}`);
+const memo: ReportComponent = {
+  id: "memo",
+  kind: "field",
+  expression: "record.memo",
+  x: 0,
+  y: 0,
+  w: 100,
+  h: 14,
+  canGrow: true,
+  style: { borderWidth: 1 },
+};
+const beside: ReportComponent = {
+  id: "beside",
+  kind: "staticText",
+  text: "beside",
+  x: 150,
+  y: 0,
+  w: 100,
+  h: 14,
+};
+const after: ReportComponent = {
+  id: "after",
+  kind: "staticText",
+  text: "after",
+  x: 0,
+  y: 20,
+  w: 100,
+  h: 14,
+};
+const footer = band(20, [
+  { id: "pf", kind: "calculated", expression: "'Page ' & page", x: 0, y: 0, w: 100, h: 14 },
+]);
+const BODY_TOP = 36;
+const BODY_BOTTOM = 842 - 36 - 20;
+
+const of = (doc: ReportDocument, id: string) =>
+  doc.pages.flatMap((p, page) =>
+    p.items.filter((i) => i.componentId === id).map((i) => ({ ...i, page })),
+  );
+const texts = (doc: ReportDocument, id: string) =>
+  of(doc, id).flatMap((i) => (i.kind === "text" ? [i] : []));
+
+describe("splitting grown text across pages", () => {
+  it("continues a band taller than a page on the next pages without losing lines", () => {
+    const doc = layoutReport(
+      baseReport({ detail: band(40, [memo, beside, after]), pageFooter: footer }),
+      [{ memo: words.join(" ") }],
+    );
+    expect(doc.pages.length).toBeGreaterThanOrEqual(3);
+    const pieces = texts(doc, "memo");
+    expect(pieces.map((p) => p.page)).toEqual(doc.pages.map((_, i) => i));
+    const printed = pieces.flatMap((p) => p.lines.map((l) => l.text)).join(" ");
+    expect(printed).toBe(words.join(" "));
+    for (const piece of pieces) {
+      expect(piece.y + piece.h).toBeLessThanOrEqual(BODY_BOTTOM + 0.01);
+      for (const line of piece.lines) expect(line.y).toBeLessThan(BODY_BOTTOM);
+    }
+    for (const piece of pieces.slice(1)) expect(piece.y).toBe(BODY_TOP);
+    const frames = of(doc, "memo").filter((i) => i.kind === "rect");
+    expect(frames.map((f) => f.page)).toEqual(pieces.map((p) => p.page));
+    expect(texts(doc, "pf").map((t) => t.lines[0].text)).toEqual(
+      doc.pages.map((_, i) => `Page ${i + 1}`),
+    );
+    const [last] = pieces.slice(-1);
+    const [below] = texts(doc, "after");
+    expect(below.page).toBe(last.page);
+    expect(below.y).toBeCloseTo(last.y + last.h + 6, 2);
+  });
+
+  it("keeps a side-by-side sibling in place on the first page", () => {
+    const doc = layoutReport(baseReport({ detail: band(40, [memo, beside]) }), [
+      { memo: words.join(" ") },
+    ]);
+    const siblings = texts(doc, "beside");
+    expect(siblings).toHaveLength(1);
+    expect(siblings[0]).toMatchObject({ page: 0, y: BODY_TOP, h: 14 });
+    expect(texts(doc, "memo")[0]).toMatchObject({ page: 0, y: BODY_TOP });
+  });
+
+  it("starts a grown band on the current page and moves it whole when keepTogether fits", () => {
+    const filler: ReportComponent = { ...after, id: "filler", y: 0 };
+    const short = words.slice(0, 40).join(" ");
+    const rows = [{ memo: "x" }, { memo: short }];
+    const report = (keepTogether: boolean) =>
+      baseReport({
+        reportHeader: band(650, [filler]),
+        detail: band(40, [memo], keepTogether),
+      });
+    const split = layoutReport(report(false), rows);
+    expect(texts(split, "memo").map((t) => t.page)).toEqual([0, 0, 1]);
+    const kept = layoutReport(report(true), rows);
+    const pieces = texts(kept, "memo");
+    expect(pieces.map((t) => t.page)).toEqual([0, 1]);
+    expect(pieces[1].y).toBe(BODY_TOP);
+    expect(pieces[1].lines.map((l) => l.text).join(" ")).toBe(short);
+  });
+
+  it("is deterministic", () => {
+    const report = baseReport({ detail: band(40, [memo, after]), pageFooter: footer });
+    const rows = [{ memo: words.join(" ") }];
+    expect(layoutReport(report, rows)).toEqual(layoutReport(report, rows));
+  });
+});
+
+describe("cut and slice helpers", () => {
+  const text = (y: number, lineCount: number): PositionedItem => ({
+    kind: "text",
+    componentId: "t",
+    x: 0,
+    y,
+    w: 100,
+    h: lineCount * 12,
+    text: "",
+    fontSize: 10,
+    bold: false,
+    gray: 0,
+    lines: Array.from({ length: lineCount }, (_, i) => ({
+      text: `l${i}`,
+      x: 2,
+      y: y + i * 12 + 8.555,
+      width: 10,
+    })),
+  });
+  const image: PositionedItem = {
+    kind: "image",
+    componentId: "img",
+    x: 0,
+    y: 50,
+    w: 20,
+    h: 30,
+    assetId: "a",
+    mediaType: "image/png",
+  };
+
+  it("cuts between lines and above an image that would cross the cut", () => {
+    expect(cutAt([text(0, 10)], 0, 65)).toBeCloseTo(60, 6);
+    expect(cutAt([text(0, 10), image], 0, 65)).toBeCloseTo(48, 6);
+    expect(cutAt([image], 50, 65)).toBe(50);
+  });
+
+  it("slices text by line start and clips rectangles", () => {
+    const frame: PositionedItem = {
+      kind: "rect",
+      componentId: "t",
+      x: 0,
+      y: 0,
+      w: 100,
+      h: 120,
+      lineWidth: 1,
+      gray: 0,
+      fill: null,
+    };
+    const second = sliceItems([text(0, 10), frame], 60, Number.POSITIVE_INFINITY, 36 - 60);
+    const t = second.find((i) => i.kind === "text");
+    expect(t?.kind === "text" && t.lines.map((l) => l.text)).toEqual([
+      "l5",
+      "l6",
+      "l7",
+      "l8",
+      "l9",
+    ]);
+    expect(t).toMatchObject({ y: 36, h: 60 });
+    expect(second.find((i) => i.kind === "rect")).toMatchObject({ y: 36, h: 60 });
+  });
+});
diff --git a/tests/unit/report-run.test.tsx b/tests/unit/report-run.test.tsx
new file mode 100644
index 00000000..69fca20f
--- /dev/null
+++ b/tests/unit/report-run.test.tsx
@@ -0,0 +1,61 @@
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { ComponentProperties } from "../../src/reports/designer/ComponentProperties";
+import { ReportRun } from "../../src/reports/ReportRun";
+import type { ReportComponent } from "../../src/reports/types";
+import { baseReport } from "./report-fixtures";
+
+const report = { ...baseReport(), datasetQueryId: "q" };
+const query = {
+  id: "q",
+  name: "Q",
+  sql: "SELECT 1",
+  parameters: [
+    { name: "region", logicalType: "text", required: true },
+    { name: "note", logicalType: "text" },
+  ],
+};
+
+vi.mock("../../src/lib/config-store", () => ({
+  useDocumentConfig: () => ({ config: { reports: [report], savedQueries: [query] } }),
+}));
+vi.mock("../../src/reports/ReportPreview", () => ({
+  ReportPreview: ({ params }: { params?: Record<string, unknown> }) => (
+    <p>preview {JSON.stringify(params)}</p>
+  ),
+}));
+
+describe("ReportRun", () => {
+  it("runs without a prompt when every parameter is given", async () => {
+    render(<ReportRun reportId="r1" params={{ region: "West", note: null }} />);
+    expect(screen.queryByRole("dialog")).toBeNull();
+    await screen.findByText('preview {"region":"West","note":null}');
+  });
+
+  it("prompts when a required parameter is passed as null", () => {
+    render(<ReportRun reportId="r1" params={{ region: null, note: "x" }} />);
+    expect(screen.getByRole("dialog", { name: "Sales parameters" })).toBeInTheDocument();
+    expect(screen.queryByText(/^preview/)).toBeNull();
+  });
+});
+
+describe("ComponentProperties", () => {
+  const text: ReportComponent = {
+    id: "t",
+    kind: "staticText",
+    text: "Hi",
+    x: 0,
+    y: 0,
+    w: 100,
+    h: 14,
+  };
+  const props = { columns: [], queries: [], assets: [], onChange: () => {}, onDelete: () => {} };
+
+  it("offers Can grow on body bands only", () => {
+    const { rerender } = render(<ComponentProperties component={text} {...props} />);
+    expect(screen.getByRole("checkbox", { name: "Can grow" })).toBeInTheDocument();
+    rerender(<ComponentProperties component={text} pageBand {...props} />);
+    expect(screen.queryByRole("checkbox", { name: "Can grow" })).toBeNull();
+    expect(screen.getByRole("checkbox", { name: "Bold" })).toBeInTheDocument();
+  });
+});
diff --git a/tests/unit/report-unicode.test.ts b/tests/unit/report-unicode.test.ts
index db6fe3e0..5bdab501 100644
--- a/tests/unit/report-unicode.test.ts
+++ b/tests/unit/report-unicode.test.ts
@@ -177,7 +177,7 @@ describe("pdf alpha images", () => {
     expect(opaque.dict).toContain("/DeviceGray");
   });
 
-  it("sends PNGs with tRNS transparency to Rust instead of passing them through", () => {
+  it("sends PNGs with tRNS transparency or 16-bit samples to Rust instead of passing them through", () => {
     const chunk = (type: string, body: number[]) => [
       0,
       0,
@@ -208,5 +208,24 @@ describe("pdf alpha images", () => {
       ]);
     expect(pngImage(png([]))).not.toBeNull();
     expect(pngImage(png(chunk("tRNS", [0])))).toBeNull();
+    const rgb = (depth: number) =>
+      new Uint8Array([
+        0x89,
+        0x50,
+        0x4e,
+        0x47,
+        0x0d,
+        0x0a,
+        0x1a,
+        0x0a,
+        ...chunk("IHDR", [0, 0, 0, 1, 0, 0, 0, 1, depth, 2, 0, 0, 0]),
+        ...chunk("IDAT", [1]),
+        ...chunk("IEND", []),
+      ]);
+    expect(pngImage(rgb(8))?.dict).toContain("/BitsPerComponent 8");
+    expect(pngImage(rgb(16))).toBeNull();
+    const gray16 = rgb(16);
+    gray16[8 + 8 + 9] = 0;
+    expect(pngImage(gray16)).toBeNull();
   });
 });
diff --git a/web/docs/guides/reports.md b/web/docs/guides/reports.md
index 7cb7025f..3106ab3b 100644
--- a/web/docs/guides/reports.md
+++ b/web/docs/guides/reports.md
@@ -12,7 +12,7 @@ A report reads rows from a saved query or a table. It places components on bands
 
 The **Dataset** picker in the toolbar chooses where rows come from: a saved [query](./queries), a table, or no dataset. A report without a dataset prints its bands once, which suits a cover page or a form letter.
 
-When the saved query declares parameters, a **Parameters** section shows one field per parameter. These are the report's default values. An action's Open report step and a dashboard's filters can pass other values when they open the report. Report expressions read the values as `params`.
+When the saved query declares parameters, a **Parameters** section shows one field per parameter. These are the report's default values. An action's Open report step and a dashboard's filters can pass other values when they open the report. Report expressions read the values as `params`. In the Runtime, a report that is missing a value asks for it first, as [Reports in the Runtime](#reports-in-the-runtime) describes.
 
 A report reads at most 100,000 rows from a query. Beyond that, the preview says that it shows only the first 100,000.
 
@@ -50,6 +50,10 @@ Drag a component to move it and drag its corner to resize it. With a component f
 
 Field and calculated components take an optional **Format**, such as `#,##0.00` or `MMM d, yyyy`. Text components can set the font size, alignment, and bold. Shapes can set the border width and a gray fill. A band holds at most one table, and page headers and footers cannot hold tables.
 
+**Can grow** on a text, field, or calculated component lets its box grow to fit its text. Without it, lines beyond the box's height are cut off. A growing box pushes the components below it down, and the band grows with it. Components beside the box stay where they are.
+
+Can grow has no effect in page headers and footers, which keep their height, or in a band that holds a table. In a band with a table, the preview lists a problem. Page numbers do not make a box grow, because the box is measured before pages are counted.
+
 ## Expressions in reports
 
 Report expressions read these names:
@@ -83,22 +87,42 @@ ixtable sorts rows by the group keys. Without groups, rows keep the order of the
 
 **Page setup** sets the page size, A4 or Letter, the orientation, and the four margins in points.
 
-- A band never splits across pages. When it does not fit, it moves to the next page.
+- A band that does not fit moves to the next page. Only bands with a table or with grown text split.
 - A table grows to fit its rows and pushes the components below it down. A long table splits between rows and repeats its header row on each page.
-- **Keep together** moves a band with a table to the next page whole. On a group header, it keeps the header on the same page as the group's first row.
+- A band with grown text splits between lines. The text continues at the top of the next page, below the page header, and the components under it follow. An image or line that would cross the page edge moves to the next page with the text below it.
+- **Keep together** moves a band with a table or grown text to the next page whole, as long as it fits on one page. On a group header, it keeps the header on the same page as the group's first row.
 - Page breaks never create an empty page.
-- Text does not grow. Lines beyond a text box's height are cut off, so size the box for its content.
 
 ## Preview, print, and PDF
 
 The **Preview** tab shows one page at a time, with page buttons and a zoom setting. It reloads when the report, its parameters, or its query change. When loading takes more than two seconds, it shows progress and a **Cancel** button.
 
-**Print** opens the system print dialog. **Export PDF…** asks where to save the file and writes a PDF of every page. The PDF uses Helvetica. It includes `.jpg` images and `.png` images without transparency, and shows a placeholder for other images. Characters outside Western European text print as `?`.
+**Print** opens the system print dialog. **Export PDF…** asks where to save the file and writes a PDF of every page. The same report always exports the same bytes, on every computer.
+
+The PDF prints Western European text in Helvetica. Other characters use two fonts that ship with ixtable, so the output never depends on the fonts installed on a computer. DejaVu Sans covers Greek, Cyrillic, Armenian, Georgian, extended Latin, and symbols. Droid Sans Fallback covers Chinese and Japanese characters.
+
+The PDF embeds only the characters the report uses. Bold text in these fonts prints with thickened outlines, because no bold version ships.
+
+Some text still prints as `?`:
+
+| Text | Why |
+| --- | --- |
+| Hebrew, Arabic, Syriac, Thaana, and N'Ko | Right-to-left scripts need shaping and reordering that reports do not do |
+| Korean Hangul syllables, Thai, and Devanagari and other Indic scripts | Neither bundled font has them |
+| Any other character that neither font has | No glyph to print |
+
+Lao text and combining accents print, but without shaping, so their marks can sit in the wrong place. The preview shows the same substitutions as the PDF.
+
+The PDF includes `.jpg` and `.png` images, including PNG images with transparency, interlacing, or 16-bit color. Other image formats print as a placeholder box. So does a PNG larger than 50 megapixels or one that cannot be read, and the export message names the image and the reason.
 
 ## Reports in the Runtime
 
 A navigation item can open a report in the Runtime, with the same preview, Print, and Export PDF… buttons. An action can open a report with parameter values, and a dashboard can show a report that follows its filters. A role needs read access to a report to open it or export it. [Roles and permissions](./roles) covers the grants a report needs.
 
+When a report's queries declare parameters and the navigation item or action does not pass a value for each one, a dialog asks for them before the report runs. Each field matches the parameter's type, such as a number, a date, or a checkbox. The fields start with the values that were passed, then the report's defaults.
+
+A required parameter needs a value, even when the action passes an empty one. **Cancel** leaves the report unrun with an **Enter parameters…** button, and **Change parameters…** above a finished report asks again. A dashboard passes its filter values and never asks.
+
 ## Next steps
 
 - [Queries](./queries)