diff --git a/crates/text/src/composer.rs b/crates/text/src/composer.rs
new file mode 100644
index 000000000..d6edd48d3
--- /dev/null
+++ b/crates/text/src/composer.rs
@@ -0,0 +1,364 @@
+//! Every-line composer: a Knuth–Plass style total-fit line breaker.
+//!
+//! Boxes are the paragraph's glyphs, glue is its spaces, and penalties are break opportunities
+//! after hyphens/dashes/CJK and at hyphenation points. The breaks minimise the sum of squared
+//! (badness + penalty) demerits over the whole paragraph, plus a demerit when neighbouring lines
+//! fall in fitness classes more than one apart (a tight line next to a loose one).
+//!
+//! - **Justified** lines: word spacing, letter spacing and glyph scaling may stretch and shrink
+//! within the paragraph's Justification options (each glyph's [`Flexibility`]); the badness comes from
+//! the stretch/shrink ratio, so loose lines are traded for evenly spaced ones.
+//! - **Ragged** lines (left/centre/right aligned): spaces keep their width, so a line never
+//! shrinks (it must fit). The badness comes from the line's leftover space measured against a
+//! rag zone of a sixth of the line width, so the rag is even rather than full lines followed by
+//! a short one, and hyphenating costs less. The last line costs nothing unless it is shorter
+//! than a third of the width (a word or two left dangling).
+
+/// Glyph measurements needed by the paragraph composer.
+pub trait Glyph {
+ fn advance(&self) -> f64;
+ fn is_space(&self) -> bool;
+ fn is_soft_hyphen(&self) -> bool;
+}
+
+/// Stretch and shrink available for a glyph.
+pub trait Flexibility {
+ fn stretch(&self) -> f64;
+ fn shrink(&self) -> f64;
+}
+
+const HYPHEN_PENALTY: f64 = 50.0;
+const DOUBLE_HYPHEN_DEMERITS: f64 = 3000.0;
+const LINE_PENALTY: f64 = 10.0;
+/// Demerits for adjacent lines whose fitness classes differ by more than one.
+const ADJ_DEMERITS_JUSTIFIED: f64 = 10_000.0;
+const ADJ_DEMERITS_RAGGED: f64 = 1_000.0;
+/// Ragged lines only gain from hyphenation by filling the rag, so it costs less than in
+/// justified text (where it also evens the word spacing).
+const HYPHEN_PENALTY_RAGGED: f64 = 25.0;
+/// Ragged text: leftover space is measured in units of this fraction of the line width.
+const RAG_ZONE: f64 = 1.0 / 6.0;
+/// Ragged text: a last line shorter than this fraction of the width is penalised, by how much
+/// shorter it is in units of `SHORT_LAST_ZONE` of the width.
+const SHORT_LAST: f64 = 1.0 / 3.0;
+const SHORT_LAST_ZONE: f64 = 1.0 / 3.0;
+/// Give up (fall back to the single-line composer) beyond this many active breakpoints.
+const MAX_ACTIVE: usize = 4096;
+const EPS: f64 = 1e-6;
+
+/// A place a line may end: glyph index `end` (exclusive), plus the width of the hyphen that is
+/// added when breaking there (0 = no hyphen).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Breakpoint {
+ pub end: usize,
+ pub hyphen: f64,
+}
+
+/// How a paragraph is composed.
+#[derive(Clone, Copy, Debug)]
+pub struct Params {
+ /// The last line is justified too (Justify All).
+ pub justify_last: bool,
+ /// Left/centre/right aligned text: spaces keep their width and lines are scored by their rag.
+ pub ragged: bool,
+ /// Maximum stretch ratio (justified) or leftover space in rag zones (ragged) of a line.
+ pub tolerance: f64,
+ /// Lines from this index on all have the same width, so their line numbers are interchangeable
+ /// (keeps the number of active breakpoints small).
+ pub uniform_from: usize,
+ /// Hyphen Limit: the most consecutive lines that may end with a hyphen before a hyphenation
+ /// point is no longer a break; 0 sets no limit. A soft hyphen stays a break and counts.
+ pub hyphen_limit: usize,
+}
+
+/// The search gave up: it ran past its budget ([`Measure::line`]).
+#[derive(Debug)]
+pub struct Exhausted;
+
+/// Where each line of a paragraph goes and how wide it is: the measure a line gets may depend on
+/// the lines set above it (their heights move it down a shaped frame, or past a wrap object).
+pub trait Measure {
+ /// What the measure of the next line depends on; breaks reached with equal states are
+ /// interchangeable from there on.
+ type State: Clone + PartialEq;
+ /// The state of the paragraph's first line.
+ fn first(&mut self) -> Self::State;
+ /// The width of the line of glyphs `pos..end` set from `state`, and the state of the line
+ /// after it; `Ok(None)` when the line can't be set (the frame is full), and [`Exhausted`] when
+ /// the search is to stop.
+ fn line(&mut self, state: &Self::State, pos: usize, end: usize) -> Result