diff --git a/README.md b/README.md
index 1c35f15..c9afbf2 100644
--- a/README.md
+++ b/README.md
@@ -57,6 +57,10 @@ Field name to value. Names are the ones `iris-pdf fields` prints.
 
 Text fields take strings, checkboxes `true`/`false`, radio groups and lists one of their options. A wrong type, an unknown option or a value over the field's length limit stops the run before anything is written. Read-only fields are skipped and counted. Unchecking always writes `/Off`, whatever the source used for "off".
 
+### Flat forms
+
+A PDF with no form fields, such as a scanned form, gets them from the HTML: each `<input>`, `<select>` and `<textarea>` becomes a field on the blank beside its label (an underline, a box, a table cell, a check box or radio circle). A field is named by its `name`, else its `id`, else its label, with periods made dashes and a number added to a repeat (`date-2`). The report lists the names under `form.created`, and `--values` fills them by those names. A control whose blank is not found is warned `field_not_placed` and gets no field; its label is still read. A scan needs Tesseract for this: with its words placed approximately, no fields are made.
+
 ## How it works
 
 1. The page's original drawing is kept byte for byte and marked as an artifact. A PDF that is already tagged loses its old tags first (warning `retagged`); each retag adds to the file's size.
@@ -73,7 +77,7 @@ Then two checks run, and if either fails nothing is written (exit 2):
 
 A page that could not be tagged is left as it was, with a warning, and the run still exits 0. Read the report to catch it; the output then makes no PDF/UA-1 claim.
 
-`--report` writes JSON: per page, where the text came from and how many words matched; the structure written; fields set and skipped; the check results; and every warning. Warnings name what could not be done, for example `unmatched_text` (page text missing from the HTML, kept as a paragraph), `missing_alt`, `field_not_in_html`, `unmatched_link`, `duplicate_text_layer`, `page_not_in_html` (a blank page needs no HTML and is not warned), `page_not_tagged`, `no_text_positions` (a scan, with Tesseract missing or failing: tagged, but its text does not line up with its image), `no_title`, `font_not_embedded` (a source font has no embedded program, which PDF/UA-1 requires; the source drawing is not changed), `source_marked_content` (the page drawing has marked-content ids left from an earlier tag tree), `alignment_incomplete` (the page and the HTML differ too much to match every word in time; the rest is kept as unmatched text).
+`--report` writes JSON: per page, where the text came from and how many words matched; the structure written; fields set and skipped; the check results; and every warning. Warnings name what could not be done, for example `unmatched_text` (page text missing from the HTML, kept as a paragraph), `missing_alt`, `field_not_in_html`, `unmatched_link`, `duplicate_text_layer`, `page_not_in_html` (a blank page needs no HTML and is not warned), `page_not_tagged`, `no_text_positions` (a scan, with Tesseract missing or failing: tagged, but its text does not line up with its image), `no_title`, `field_not_placed` (a flat form's control with no blank found for it), `font_not_embedded` (a source font has no embedded program, which PDF/UA-1 requires; the source drawing is not changed), `source_marked_content` (the page drawing has marked-content ids left from an earlier tag tree), `alignment_incomplete` (the page and the HTML differ too much to match every word in time; the rest is kept as unmatched text).
 
 ## Review
 
@@ -106,7 +110,7 @@ Form values are personal data. They are never printed, logged, or put in the rep
 - A table that continues onto the next page is tagged as two tables.
 - `check` needs veraPDF installed.
 - `review` reads only structure tagged by this tool. Its findings are a model's judgment: check them before acting on them. Text in the document can mislead the model, so no findings does not prove a document accessible.
-- A form with no fields (a flat form) cannot be filled.
+- A flat form's fields are found from the page's lines, so a blank may be missed (`field_not_placed`). Their text is drawn in Helvetica, which is not embedded, so such an output does not claim PDF/UA-1.
 
 ## License
 
diff --git a/src/form/create.ts b/src/form/create.ts
new file mode 100644
index 0000000..24367de
--- /dev/null
+++ b/src/form/create.ts
@@ -0,0 +1,214 @@
+// A flat form's fields: each HTML control placed on its blank and made an
+// empty widget with no border, so the page looks as it did.
+import * as mupdf from "mupdf";
+import type { Box } from "../align/words.ts";
+import { isRun, type ControlType, type FormRef, type Node, type Word } from "../html/build.ts";
+import { widgetOf, type Widget } from "../pdf/widgets.ts";
+import type { Warning } from "../report.ts";
+import { cellAt, cellBlank, cellUnder, Ink, markBlank, rowsOf, textBlank } from "./find.ts";
+
+// What the alignment found of the HTML on a page. order: the HTML's words in
+// reading order; words: the page's own. null: the words are placed
+// approximately, which says nothing about where the blanks are.
+export type PageText = { matched: Set<Word>; order: Word[]; words: { norm: string; box: Box }[] };
+
+export type Created = { name: string; type: ControlType; page: number };
+
+export class FieldMaker {
+  readonly created: Created[] = [];
+  private names = new Set<string>();
+  private doc: mupdf.PDFDocument;
+  constructor(doc: mupdf.PDFDocument) { this.doc = doc; }
+
+  // Places and makes one page's fields. Each control placed gets its field's
+  // name; one not placed is marked so.
+  page(page: mupdf.PDFPage, index: number, plan: Node, text: PageText | null, warn: (w: Warning) => void): Widget[] {
+    const controls: { f: FormRef; td?: Node }[] = [], ths = new Map<string, Node>();
+    const visit = (n: Node, td?: Node) => {
+      if (n.form?.type) controls.push({ f: n.form, td });
+      if (n.type === "TH" && n.id) ths.set(n.id, n);
+      for (const k of n.kids) if (!isRun(k)) visit(k, n.type === "TD" ? n : td);
+    };
+    visit(plan);
+    const unplaced = (f: FormRef) => {
+      f.unplaced = true;
+      warn({ code: "field_not_placed", page: index + 1, detail: f.name || f.label || f.type! });
+    };
+    if (!text) return controls.forEach(({ f }) => unplaced(f)), [];
+    if (!controls.length) return [];
+
+    const { matched } = text, at = new Map(text.order.map((w, k) => [w, k]));
+    const ink = new Ink(page);
+    const toRect = mupdf.Matrix.invert(page.getTransform());
+    const obstacles = [...matched].map((w) => w.at!.box);
+    const rows = new Map<Node, number>(); // body cells seen under each column header
+    const groups = new Map<string, { name: string; parent: mupdf.PDFObject; states: Set<string> }>();
+    const made = new Set<number>();
+    for (const { f, td } of controls) {
+      const label = labelBox(f.labelWords, text, at);
+      const mark = f.type === "checkbox" || f.type === "radio";
+      let box = td && !mark ? this.cell(ink, td, ths, rows, matched, obstacles) : null;
+      if (!box && label) box = mark ? markBlank({ ink, label, obstacles }) : textBlank({ ink, label, obstacles }, f.type === "multiline");
+      if (!box) {
+        unplaced(f);
+        continue;
+      }
+      obstacles.push(box);
+      const rect = mupdf.Rect.transform(box, toRect);
+      const [w, h] = [rect[2] - rect[0], rect[3] - rect[1]];
+      const obj = page.createAnnotation("Widget").getObject();
+      obj.put("Rect", rect);
+      made.add(obj.asIndirect());
+      const s = (v: string) => this.doc.newString(v);
+      const n = (v: string) => this.doc.newName(v);
+      if (f.type === "radio") {
+        const key = f.name || f.group || "";
+        let g = key ? groups.get(key) : undefined;
+        if (!g) {
+          const name = this.unique(f.name || slug(f.group ?? "") || "choice");
+          const parent = this.doc.addObject({ FT: n("Btn"), Ff: (1 << 15) | (1 << 14), T: s(name), Kids: [] });
+          this.acroform().get("Fields").push(parent);
+          g = { name, parent, states: new Set() };
+          if (key) groups.set(key, g);
+          this.created.push({ name, type: "radio", page: index + 1 });
+        }
+        let state = (f.value || slug(f.label) || "option").replace(/^Off$/, "off");
+        for (let k = 2; g.states.has(state); k++) state = `${f.value || slug(f.label) || "option"}-${k}`;
+        g.states.add(state);
+        obj.put("Parent", g.parent);
+        g.parent.get("Kids").push(obj);
+        obj.put("AP", { N: { [state]: this.stream(dot(w, h), w, h), Off: this.stream("", w, h) } });
+        obj.put("AS", n("Off"));
+        f.name = g.name, f.value = state;
+        continue;
+      }
+      const name = this.unique(f.name || f.id || slug(f.label) || f.type!);
+      obj.put("T", s(name));
+      this.acroform().get("Fields").push(obj);
+      if (f.type === "checkbox") {
+        obj.put("FT", n("Btn"));
+        f.value = (f.value || "Yes").replace(/^Off$/, "off");
+        obj.put("AP", { N: { [f.value]: this.stream(cross(w, h), w, h), Off: this.stream("", w, h) } });
+        obj.put("AS", n("Off"));
+      } else {
+        const size = Math.max(6, Math.min(f.type === "multiline" ? 10 : 12, Math.floor(h * 0.7)));
+        obj.put("FT", n(f.type === "combobox" ? "Ch" : "Tx"));
+        obj.put("DA", s(`/Helv ${size} Tf 0 g`));
+        if (f.type === "multiline") obj.put("Ff", 1 << 12);
+        if (f.type === "combobox") {
+          obj.put("Ff", 1 << 17);
+          obj.put("Opt", (f.options ?? []).map(s));
+        }
+        obj.put("AP", { N: this.stream("", w, h) });
+      }
+      f.name = name;
+      this.created.push({ name, type: f.type!, page: index + 1 });
+    }
+    // A page loaded afresh sees the new widgets.
+    return this.doc.loadPage(index).getWidgets().filter((w) => made.has(w.getObject().asIndirect())).map((w) => widgetOf(w, index));
+  }
+
+  // A control in a table cell: the cell under its column header, on its row
+  // header's line, or else counted down from the header.
+  private cell(ink: Ink, td: Node, ths: Map<string, Node>, rows: Map<Node, number>, matched: Set<Word>, obstacles: Box[]): Box | null {
+    const heads = (td.headers ?? []).map((id) => ths.get(id)!).filter(Boolean);
+    const col = heads.filter((h) => h.attrs?.Scope !== "Row").at(-1), row = heads.find((h) => h.attrs?.Scope === "Row");
+    const colBox = col && lineBox(wordsOf(col), matched);
+    if (!col || !colBox) return null;
+    const x = (colBox[0] + colBox[2]) / 2, lh = colBox[3] - colBox[1];
+    let cell: Box | null;
+    if (row) {
+      const on = wordsOf(row).filter((w) => matched.has(w)).map((w) => w.at!.box);
+      const y = on.length ? (Math.min(...on.map((b) => b[1])) + Math.max(...on.map((b) => b[3]))) / 2 : -1;
+      const c = on.length ? cellAt(ink, [x, y]) : null;
+      cell = c && (rowsOf(ink, c, lh).find((r) => y >= r[1] && y <= r[3]) ?? null);
+    } else {
+      const k = rows.get(col) ?? 0, below: Box[] = [];
+      rows.set(col, k + 1);
+      for (let c = cellUnder(ink, [x, colBox[3]]); c && below.length <= k; c = cellUnder(ink, [x, c[3]])) {
+        const last = below.at(-1); // the column goes on only while its cells line up
+        if (last && (Math.abs(c[0] - last[0]) > lh || Math.abs(c[2] - last[2]) > lh || c[1] - last[3] > lh)) break;
+        below.push(...rowsOf(ink, c, lh));
+      }
+      cell = below[k] ?? null;
+    }
+    return cell && cellBlank({ ink, obstacles }, cell, lh);
+  }
+
+  private unique(base: string): string {
+    for (const name of fieldNames(base)) if (!this.names.has(name)) return this.names.add(name), name;
+    throw new Error("unreachable");
+  }
+
+  private stream(ops: string, w: number, h: number) {
+    return this.doc.addStream(ops, { Type: this.doc.newName("XObject"), Subtype: this.doc.newName("Form"), BBox: [0, 0, w, h] });
+  }
+
+  // The document's AcroForm, made if absent, with Helvetica for typed text.
+  private acroform(): mupdf.PDFObject {
+    const root = this.doc.getTrailer().get("Root");
+    if (!root.get("AcroForm").isDictionary()) root.put("AcroForm", this.doc.addObject({}));
+    const af = root.get("AcroForm");
+    if (!af.get("Fields").isArray()) af.put("Fields", this.doc.newArray());
+    if (!af.get("DA").isString()) af.put("DA", this.doc.newString("/Helv 0 Tf 0 g"));
+    if (!af.get("DR").isDictionary()) af.put("DR", this.doc.newDictionary());
+    if (!af.get("DR", "Font").isDictionary()) af.get("DR").put("Font", this.doc.newDictionary());
+    if (af.get("DR", "Font", "Helv").isNull()) {
+      const n = (v: string) => this.doc.newName(v);
+      af.get("DR", "Font").put("Helv", this.doc.addObject({ Type: n("Font"), Subtype: n("Type1"), BaseFont: n("Helvetica"), Encoding: n("WinAnsiEncoding") }));
+    }
+    return af;
+  }
+}
+
+// A label's line on the page: where its words are read once, in a row; else
+// where the alignment put them, if a word read near it in the HTML is near it on the page.
+function labelBox(label: Word[], text: PageText, at: Map<Word, number>): Box | null {
+  const norms = label.map((w) => w.norm).filter(Boolean), { words } = text;
+  const hits: Box[][] = [];
+  for (let i = 0; norms.length && i + norms.length <= words.length; i++) {
+    if (norms.every((n, k) => words[i + k].norm === n)) hits.push(words.slice(i, i + norms.length).map((w) => w.box));
+  }
+  const first = at.get(label[0]), last = at.get(label.at(-1)!);
+  if (first === undefined || last === undefined) return null;
+  const mine = new Set(label);
+  const near = [...text.order.slice(Math.max(0, first - 3), first), ...text.order.slice(last + 1, last + 4)]
+    .filter((w) => !mine.has(w) && text.matched.has(w)).map((w) => w.at!.box);
+  const fits = (box: Box | null) => !!box && (!near.length || near.some((b) => Math.abs((b[1] + b[3] - box[1] - box[3]) / 2) <= 6 * (box[3] - box[1])));
+  const box = hits.length === 1 ? line(hits[0]) : null;
+  if (fits(box)) return box;
+  const aligned = lineBox(label, text.matched);
+  return fits(aligned) ? aligned : null;
+}
+
+// The words of a label that were found on the page, on the line of its last one.
+function lineBox(words: Word[], matched: Set<Word>): Box | null {
+  return line(words.filter((w) => matched.has(w)).map((w) => w.at!.box));
+}
+
+// The boxes on the line of the last one, as one box.
+function line(on: Box[]): Box | null {
+  const last = on.at(-1);
+  if (!last) return null;
+  const l = on.filter((b) => (b[1] + b[3]) / 2 > last[1] && (b[1] + b[3]) / 2 < last[3]);
+  return [Math.min(...l.map((b) => b[0])), Math.min(...l.map((b) => b[1])), Math.max(...l.map((b) => b[2])), Math.max(...l.map((b) => b[3]))];
+}
+
+const wordsOf = (n: Node): Word[] => n.kids.flatMap((k) => (isRun(k) ? k.words : wordsOf(k)));
+// The names a field made for an HTML name may get, in turn. A period would
+// make it a child of a field named by what comes before.
+export function* fieldNames(base: string) {
+  const clean = base.replace(/\./g, "-");
+  yield clean;
+  for (let k = 2; ; k++) yield `${clean}-${k}`;
+}
+
+const slug = (s: string) => s.normalize("NFKD").toLowerCase().replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+
+// A check box's cross and a radio button's dot, drawn when chosen.
+const cross = (w: number, h: number) => `0 g 1 w ${w * 0.2} ${h * 0.2} m ${w * 0.8} ${h * 0.8} l ${w * 0.2} ${h * 0.8} m ${w * 0.8} ${h * 0.2} l S\n`;
+function dot(w: number, h: number): string {
+  const x = w / 2, y = h / 2, r = Math.min(w, h) * 0.3, k = r * 0.5523;
+  return `0 g ${x + r} ${y} m ${x + r} ${y + k} ${x + k} ${y + r} ${x} ${y + r} c ${x - k} ${y + r} ${x - r} ${y + k} ${x - r} ${y} c ` +
+    `${x - r} ${y - k} ${x - k} ${y - r} ${x} ${y - r} c ${x + k} ${y - r} ${x + r} ${y - k} ${x + r} ${y} c f\n`;
+}
diff --git a/src/form/find.ts b/src/form/find.ts
new file mode 100644
index 0000000..e5327a3
--- /dev/null
+++ b/src/form/find.ts
@@ -0,0 +1,291 @@
+// Where a flat form's blanks are. Iris gives no positions, so each is looked
+// for in the rendered page near its label: an underline or a box for text, a
+// small hollow square or circle for a check box or radio button, a table cell.
+// Nothing found with confidence is nothing placed: a field in the wrong place is worse than none.
+import * as mupdf from "mupdf";
+import type { Box } from "../align/words.ts";
+
+const SCALE = 2; // 144 dpi
+
+// The page's ink: pixels well darker than the paper, so tinted paper works too.
+export class Ink {
+  readonly w: number; readonly h: number;
+  private dark: Uint8Array;
+  private gray: Uint8Array;
+  private paper: number;
+  private x0: number; private y0: number;
+  constructor(page: mupdf.Page) {
+    const pix = page.toPixmap(mupdf.Matrix.scale(SCALE, SCALE), mupdf.ColorSpace.DeviceGray, false);
+    this.w = pix.getWidth(), this.h = pix.getHeight(), this.x0 = pix.getX(), this.y0 = pix.getY();
+    const px = pix.getPixels(), stride = pix.getStride();
+    const hist = new Uint32Array(256);
+    for (let y = 0; y < this.h; y++) for (let x = 0; x < this.w; x++) hist[px[y * stride + x]]++;
+    const paper = (this.paper = hist.indexOf(Math.max(...hist))); // the commonest shade
+    this.dark = new Uint8Array(this.w * this.h);
+    this.gray = new Uint8Array(this.w * this.h);
+    for (let y = 0; y < this.h; y++) for (let x = 0; x < this.w; x++) {
+      const g = (this.gray[y * this.w + x] = px[y * stride + x]);
+      this.dark[y * this.w + x] = g < paper * 0.7 ? 1 : 0;
+    }
+    pix.destroy();
+  }
+  at(x: number, y: number): boolean {
+    return x >= 0 && y >= 0 && x < this.w && y < this.h && this.dark[y * this.w + x] === 1;
+  }
+  // Ink too light to stop a ray, as a table's dotted or gray row lines are.
+  faint(x: number, y: number): boolean {
+    return x >= 0 && y >= 0 && x < this.w && y < this.h && this.gray[y * this.w + x] < this.paper * 0.93;
+  }
+  toPx(b: Box): Box { return [b[0] * SCALE - this.x0, b[1] * SCALE - this.y0, b[2] * SCALE - this.x0, b[3] * SCALE - this.y0].map(Math.round) as Box; }
+  toPage(b: Box): Box { return [(b[0] + this.x0) / SCALE, (b[1] + this.y0) / SCALE, (b[2] + this.x0) / SCALE, (b[3] + this.y0) / SCALE]; }
+}
+
+const inside = (b: Box, x: number, y: number) => x >= b[0] && x <= b[2] && y >= b[1] && y <= b[3];
+const meets = (a: Box, b: Box) => a[0] < b[2] && b[0] < a[2] && a[1] < b[3] && b[1] < a[3];
+
+// A horizontal rule through a dark pixel, followed both ways through small gaps
+// and a pixel of drift per step, as a scan's lines have. ys: its row at each column.
+type Rule = { x0: number; x1: number; ys: Map<number, number> };
+function rule(ink: Ink, x: number, y: number): Rule {
+  const ys = new Map([[x, y]]);
+  let x0 = x, x1 = x;
+  for (const dir of [1, -1]) {
+    let cx = x, cy = y, gap = 0;
+    while (gap <= 3 && cx > 0 && cx < ink.w - 1) {
+      cx += dir;
+      const dy = [0, -1, 1].find((d) => ink.at(cx, cy + d));
+      if (dy === undefined) { gap++; continue; }
+      cy += dy, gap = 0;
+      ys.set(cx, cy);
+      if (dir > 0) x1 = cx; else x0 = cx;
+    }
+  }
+  return { x0, x1, ys };
+}
+
+// Thin where it runs: not a line of text whose letters happen to touch.
+function thin(ink: Ink, r: Rule, most: number): boolean {
+  let ok = 0, n = 0;
+  for (const [x, y] of r.ys) {
+    if (x % 3) continue;
+    let top = y, bottom = y;
+    while (ink.at(x, top - 1) && y - top < most + 1) top--;
+    while (ink.at(x, bottom + 1) && bottom - y < most + 1) bottom++;
+    n++;
+    if (bottom - top + 1 <= most) ok++;
+  }
+  return n > 0 && ok / n >= 0.85;
+}
+
+// A line from `from` to `to`, followed both ways from (start, at) with a pixel
+// of drift per step, as a skewed scan's lines have: how much of it is ink, and
+// where it is halfway.
+function along(ink: (t: number, c: number) => boolean, at: number, start: number, from: number, to: number) {
+  let hit = 0, mid = at;
+  for (const dir of [1, -1]) {
+    for (let t = dir > 0 ? start : start - 1, c = at; dir > 0 ? t <= to : t >= from; t += dir) {
+      const d = [0, -1, 1].find((d) => ink(t, c + d));
+      if (d !== undefined) c += d, hit++;
+      if (t === Math.round((from + to) / 2)) mid = c;
+    }
+  }
+  return { share: to > from ? hit / (to - from + 1) : 0, mid };
+}
+
+// A box's edge, found by a ray at `start`: most of it must be ink.
+function edge(ink: Ink, horizontal: boolean, at: number, start: number, from: number, to: number): boolean {
+  const dark = horizontal ? (t: number, c: number) => ink.at(t, c) : (t: number, c: number) => ink.at(c, t);
+  return along(dark, at, start, from, to).share >= 0.8;
+}
+
+// The box drawn around a light seed pixel, as [left, top, right, bottom] lines, or null.
+export function enclosure(ink: Ink, sx: number, sy: number): Box | null {
+  if (ink.at(sx, sy)) return null;
+  const ray = (dx: number, dy: number) => {
+    let x = sx, y = sy;
+    for (;;) {
+      x += dx, y += dy;
+      if (x < 0 || y < 0 || x >= ink.w || y >= ink.h) return null;
+      // Three pixels wide, so a dotted line still stops it.
+      if (ink.at(x, y) || ink.at(x + dy, y + dx) || ink.at(x - dy, y - dx)) return dx ? x : y;
+    }
+  };
+  const l = ray(-1, 0), r = ray(1, 0), t = ray(0, -1), b = ray(0, 1);
+  if (l === null || r === null || t === null || b === null) return null;
+  const sides = edge(ink, true, t, sx, l, r) && edge(ink, true, b, sx, l, r) && edge(ink, false, l, sy, t, b) && edge(ink, false, r, sy, t, b);
+  return sides ? [l, t, r, b] : null;
+}
+
+export type Find = {
+  ink: Ink;
+  label: Box; // page space
+  obstacles: Box[]; // page space: words of the page's text, and fields already placed
+};
+
+// A text field's blank: an underline beside or under its label, else a box to its right or below.
+export function textBlank(f: Find, multiline = false): Box | null {
+  const { ink } = f;
+  const L = ink.toPx(f.label), lh = Math.max(8, L[3] - L[1]);
+  const obstacles = f.obstacles.map((o) => ink.toPx(o)).filter((o) => !meets(o, L));
+  // The search stops at the next word along the label's line.
+  const limit = Math.min(ink.w - 1, ...obstacles.filter((o) => o[0] > L[2] && o[1] < L[3] && o[3] > L[1]).map((o) => o[0]));
+  const pad = Math.round(lh * 0.3);
+  const fits = (b: Box) => b[2] - b[0] >= 2 * lh && !obstacles.some((o) => meets(o, b));
+
+  const seen = new Set<number>();
+  let best: { box: Box; score: number } | null = null;
+  for (let y = Math.round(L[3] - lh * 0.5); y <= L[3] + lh * 1.5; y++) {
+    for (let x = L[0]; x <= Math.min(limit, L[2] + 8 * lh); x++) {
+      if (!ink.at(x, y) || seen.has(y * ink.w + x) || obstacles.some((o) => inside(o, x, y))) continue;
+      const r = rule(ink, x, y);
+      for (const [rx, ry] of r.ys) seen.add(ry * ink.w + rx);
+      if (r.x1 < L[2] + 2 * lh || !thin(ink, r, Math.max(5, lh * 0.35))) continue;
+      const at = Math.min(...r.ys.values());
+      const e = enclosure(ink, Math.round((r.x0 + r.x1) / 2), at - 3);
+      if (e && Math.abs(e[3] - at) <= 3) continue; // a box's bottom: the box is the blank
+      const box: Box = [Math.max(r.x0, L[2] + pad), Math.round(at - lh * 1.25), r.x1, at - 1];
+      // Clip at the next word over the rule: it is the next label.
+      const next = obstacles.filter((o) => meets(o, [box[0], box[1], box[2], box[3]]) && o[0] > box[0]).map((o) => o[0]);
+      if (next.length) box[2] = Math.min(...next) - pad;
+      if (!fits(box)) continue;
+      const score = Math.max(0, r.x0 - L[2]) + 2 * Math.abs(at - L[3]);
+      if (!best || score < best.score) best = { box, score };
+    }
+  }
+  if (best) return ink.toPage(best.box);
+
+  // A box: seeded just right of the label, or just inside the line below it.
+  const my = Math.round((L[1] + L[3]) / 2), seeds: [number, number][] = [[L[2] + pad, my]];
+  let x = L[2] + pad; // past the next line to the right, a box's left side
+  while (x < Math.min(limit, L[2] + 8 * lh) && !ink.at(x, my)) x++;
+  while (ink.at(x, my)) x++;
+  seeds.push([x + 2, my]);
+  for (let y = L[3] + 1, cx = Math.round((L[0] + L[2]) / 2); y < L[3] + 2 * lh; y++) {
+    if (!ink.at(cx, y)) continue;
+    while (ink.at(cx, y) && y < L[3] + 3 * lh) y++;
+    seeds.push([cx, y + 3]);
+    break;
+  }
+  for (const [sx, sy] of seeds) {
+    const e = enclosure(ink, sx, sy);
+    if (!e) continue;
+    const box: Box = [Math.max(e[0], inside(e, L[0], L[1]) ? L[2] : e[0]) + pad, e[1] + 2, e[2] - 2, e[3] - 2];
+    const tall = box[3] - box[1];
+    if (tall >= 0.9 * lh && tall <= (multiline ? 30 : 4) * lh && fits(box)) return ink.toPage(box);
+  }
+  return null;
+}
+
+// The cell around a point, its lines in page space.
+export function cellAt(ink: Ink, p: [number, number]): Box | null {
+  const [sx, sy] = ink.toPx([p[0], p[1], p[0], p[1]]);
+  const e = enclosure(ink, sx, sy);
+  return e && ink.toPage(e);
+}
+
+// A cell's rows, split at lines too faint to stop a ray. lh: the text height.
+export function rowsOf(ink: Ink, cell: Box, lh: number): Box[] {
+  const [l, t, r, b] = ink.toPx(cell), min = lh * 0.9 * SCALE;
+  const ys: number[] = [], faint = (x: number, y: number) => ink.faint(x, y);
+  for (let y = t + 3; y <= b - 3; y++) {
+    let x = l + 3; // trace from the row's first ink
+    while (x <= r - 3 && !faint(x, y)) x++;
+    const { share, mid } = along(faint, y, x, l + 3, r - 3);
+    if (x <= r - 3 && share >= 0.6 && mid > t + min / 2 && mid < b - min / 2) ys.push(mid); // not the cell's own border
+  }
+  ys.sort((a, b) => a - b);
+  const cuts: number[] = []; // the middle of each line
+  for (let k = 0, s = 0; k < ys.length; k++) if (!(ys[k + 1] - ys[k] <= 3)) cuts.push(Math.round((ys[s] + ys[k]) / 2)), (s = k + 1);
+  const edges = [t, ...cuts, b];
+  const rows = edges.slice(1).map((y, k): Box => [l, edges[k], r, y]);
+  return rows.every((x) => x[3] - x[1] >= min) ? rows.map((x) => ink.toPage(x)) : [cell];
+}
+
+// The cell under a point: down to the next line, then past it.
+export function cellUnder(ink: Ink, p: [number, number]): Box | null {
+  const [x, top] = ink.toPx([p[0], p[1], p[0], p[1]]);
+  const line = (y: number) => ink.at(x - 1, y) || ink.at(x, y) || ink.at(x + 1, y);
+  // The first ink may be the label's own letters: try each line in turn.
+  for (let y = top, end = Math.min(ink.h - 1, top + 100); y < end; ) {
+    while (y < end && !line(y)) y++;
+    const from = y;
+    while (y < from + 8 && line(y)) y++;
+    if (y >= end || line(y)) return null;
+    // A scan's line is ragged or skewed: seeds just past it may still touch it.
+    for (let d = 1; d <= 12 && !line(y + d); d++) {
+      const e = enclosure(ink, x, y + d);
+      if (e) return ink.toPage(e);
+    }
+  }
+  return null;
+}
+
+// A table cell's blank: inside its lines, if nothing is written there. lh: the text height.
+export function cellBlank(f: Omit<Find, "label">, cell: Box, lh: number): Box | null {
+  const box: Box = [cell[0] + 1.5, cell[1] + 1.5, cell[2] - 1.5, cell[3] - 1.5];
+  if (box[3] - box[1] < lh * 0.9 || box[2] - box[0] < lh * 2 || f.obstacles.some((o) => meets(o, box))) return null;
+  return box;
+}
+
+// A check box or radio button: a small hollow mark, roughly square, just left
+// of its label, else just right of it.
+export function markBlank(f: Find): Box | null {
+  const { ink } = f;
+  const L = ink.toPx(f.label), lh = Math.max(8, L[3] - L[1]), cy = (L[1] + L[3]) / 2;
+  const all = f.obstacles.map((o) => ink.toPx(o)), others = all.filter((o) => !meets(o, L));
+  // Left of the label, then right, then at its start: OCR may read the mark as part of the word.
+  for (const side of [-1, 1, 0]) {
+    const win: Box = side < 0 ? [L[0] - 3 * lh, cy - 1.2 * lh, L[0] - 1, cy + 1.2 * lh]
+      : side > 0 ? [L[2] + 1, cy - 1.2 * lh, L[2] + 3 * lh, cy + 1.2 * lh] : [L[0], cy - 1.2 * lh, L[0] + 1.7 * lh, cy + 1.2 * lh];
+    const words = side ? all : others;
+    const m = Math.round(lh * 0.5), outer: Box = [win[0] - m, win[1] - m, win[2] + m, win[3] + m];
+    const seen = new Set<number>();
+    let best: { box: Box; d: number } | null = null;
+    for (let y = Math.round(win[1]); y <= win[3]; y++) {
+      for (let x = Math.round(win[0]); x <= win[2]; x++) {
+        if (!ink.at(x, y) || seen.has(y * ink.w + x)) continue;
+        const c = component(ink, x, y, outer, seen);
+        if (!c) continue;
+        const [x0, y0, x1, y1] = c.box, w = x1 - x0 + 1, h = y1 - y0 + 1;
+        const ok = w >= 0.6 * lh && h >= 0.6 * lh && w <= 2.2 * lh && h <= 2.2 * lh && w / h >= 0.6 && w / h <= 1.6 &&
+          c.count / (w * h) < 0.5 && hollow(ink, c.box) && !words.some((o) => meets(o, c.box));
+        // A letter at the word's start is followed closely by the next one.
+        if (!ok || (!side && !clear(ink, [x1 + 1, y0, x1 + Math.round(0.15 * lh), y1]))) continue;
+        const d = side < 0 ? L[0] - x1 : x0 - L[2];
+        if (!best || d < best.d) best = { box: c.box, d };
+      }
+    }
+    if (best) return ink.toPage(best.box);
+  }
+  return null;
+}
+
+// The 8-connected ink around (x, y), or null if it runs out of the window.
+function component(ink: Ink, x: number, y: number, win: Box, seen: Set<number>): { box: Box; count: number } | null {
+  const stack = [[x, y]], box: Box = [x, y, x, y];
+  let count = 0, out = false;
+  seen.add(y * ink.w + x);
+  while (stack.length) {
+    const [cx, cy] = stack.pop()!;
+    count++;
+    if (!inside(win, cx, cy)) { out = true; continue; }
+    box[0] = Math.min(box[0], cx), box[1] = Math.min(box[1], cy), box[2] = Math.max(box[2], cx), box[3] = Math.max(box[3], cy);
+    for (let dy = -1; dy <= 1; dy++) for (let dx = -1; dx <= 1; dx++) {
+      const nx = cx + dx, ny = cy + dy, k = ny * ink.w + nx;
+      if (ink.at(nx, ny) && !seen.has(k)) { seen.add(k); stack.push([nx, ny]); }
+    }
+  }
+  return out ? null : { box, count };
+}
+
+const clear = (ink: Ink, b: Box) => {
+  for (let y = b[1]; y <= b[3]; y++) for (let x = b[0]; x <= b[2]; x++) if (ink.at(x, y)) return false;
+  return true;
+};
+
+// No ink in the middle third.
+function hollow(ink: Ink, b: Box): boolean {
+  const w = b[2] - b[0], h = b[3] - b[1];
+  for (let y = Math.round(b[1] + h / 3); y <= b[3] - h / 3; y++) for (let x = Math.round(b[0] + w / 3); x <= b[2] - w / 3; x++) if (ink.at(x, y)) return false;
+  return true;
+}
diff --git a/src/html/build.ts b/src/html/build.ts
index 0fc5fd1..04a3993 100644
--- a/src/html/build.ts
+++ b/src/html/build.ts
@@ -9,7 +9,14 @@ import type { Warning } from "../report.ts";
 export type Placed = { box: Box; baseline: number; size: number };
 export type Word = { text: string; norm: string; space?: boolean; at?: Placed }; // space: one follows
 export type Run = { words: Word[] };
-export type FormRef = { name: string; value?: string; label: string; group?: string };
+// A form control. type is null for one that holds no value (a button). labelWords: its
+// label's words, to find it on the page; group: its fieldset's legend, or a radio group's question.
+export type ControlType = "text" | "multiline" | "checkbox" | "radio" | "combobox";
+export type FormRef = {
+  name: string; id?: string; value?: string; label: string; group?: string;
+  type: ControlType | null; options?: string[]; labelWords: Word[];
+  unplaced?: boolean; // a flat form's control whose blank was not found
+};
 
 export type Node = {
   type: string;
@@ -31,9 +38,14 @@ type Ctx = {
   lang: string;
   prefix: string; // keeps ids unique across pages
   labels: Map<string, string>; // input id -> its label's text
+  labelWords: Map<string, Word[]>; // input id -> its label's words, filled as they are built
+  questions: Map<string, string>; // radio name -> the text before its first button
   notes: Set<string>; // ids that internal links point at
   label?: string; // text of an enclosing <label>
   legend?: string; // text of an enclosing <fieldset>'s legend
+  collect: Word[][]; // label word lists that the text being built belongs to
+  wrapped?: Word[]; // an enclosing <label>'s words
+  ths: { n: number }; // TH cells numbered so far, so their ids are unique on the page
   warn: (w: Warning) => void;
 };
 
@@ -45,7 +57,7 @@ export function buildPage(html: string, lang: string, prefix: string, warn: (w:
     if (e.tag === "a" && e.attrs.href?.startsWith("#")) notes.add(e.attrs.href.slice(1));
   });
   const top: Node = { type: "#root", kids: [] };
-  const ctx: Ctx = { lang, prefix, labels, notes, warn };
+  const ctx: Ctx = { lang, prefix, labels, notes, warn, labelWords: new Map(), questions: new Map(), collect: [], ths: { n: 0 } };
   for (const k of root.kids) build(k, top, ctx);
   // Text directly in the fragment, outside any block, becomes a paragraph.
   top.kids = top.kids.map((k) => (isRun(k) ? { type: "P", kids: [k] } : k));
@@ -53,10 +65,14 @@ export function buildPage(html: string, lang: string, prefix: string, warn: (w:
 }
 
 function build(e: Elem | string, parent: Node, ctx: Ctx) {
-  if (typeof e === "string") return addText(parent, e);
+  if (typeof e === "string") return addText(parent, e, ctx.collect);
   if (SKIP.has(e.tag)) return;
   const kids = (into: Node, c: Ctx = ctx) => e.kids.forEach((k) => build(k, into, c));
-  if (e.tag === "label") return kids(parent, { ...ctx, label: clean(textOf(e)) });
+  if (e.tag === "label") {
+    const words = e.attrs.for ? labelWords(ctx, e.attrs.for) : [];
+    const wrapped = e.attrs.for ? ctx.wrapped : words;
+    return kids(parent, { ...ctx, label: clean(textOf(e)), collect: [...ctx.collect, words], wrapped });
+  }
   if (e.tag === "a" && !e.attrs.href) return kids(parent);
   if (TRANSPARENT.has(e.tag)) return kids(parent);
 
@@ -110,11 +126,19 @@ function build(e: Elem | string, parent: Node, ctx: Ctx) {
     case "input": case "select": case "textarea": {
       const type = (e.attrs.type ?? "").toLowerCase();
       if (type === "hidden") return;
-      if (!e.attrs.name) return ctx.warn({ code: "field_without_name", detail: e.tag });
-      const label = (e.attrs.id && ctx.labels.get(e.attrs.id)) || ctx.label || e.attrs["aria-label"] || e.attrs.title || "";
+      const { id, name = "" } = e.attrs;
+      const label = (id && ctx.labels.get(id)) || ctx.label || e.attrs["aria-label"] || e.attrs.title || "";
+      const words = (id && ctx.labels.has(id) ? labelWords(ctx, id) : ctx.wrapped) ?? [];
       const f = add("Form");
-      f.form = { name: e.attrs.name, label, group: ctx.legend };
+      f.form = { name, id, label, group: ctx.legend, type: controlType(e.tag, type), labelWords: words };
       if (type === "radio" || type === "checkbox") f.form.value = e.attrs.value;
+      if (type === "radio" && !ctx.legend && name) {
+        if (!ctx.questions.has(name)) ctx.questions.set(name, clean(textOfNode(parent)));
+        f.form.group = ctx.questions.get(name) || undefined;
+      }
+      if (e.tag === "select") {
+        f.form.options = e.kids.flatMap((o) => (typeof o !== "string" && o.tag === "option" ? [o.attrs.value ?? clean(textOf(o))] : []));
+      }
       if (label) f.alt = label;
       return;
     }
@@ -132,7 +156,7 @@ function build(e: Elem | string, parent: Node, ctx: Ctx) {
     case "table": {
       const table = add("Table");
       kids(table, inner);
-      return tableHeaders(table, ctx.prefix);
+      return tableHeaders(table, ctx.prefix, ctx.ths);
     }
     case "th": case "td": {
       const cell = add(STRUCT[e.tag]);
@@ -174,7 +198,7 @@ const scope = (s: string) => ({ row: "Row", rowgroup: "Row", col: "Column", colg
 
 // Every TH gets an /ID and every TD a /Headers list naming the TH cells above
 // it in its column and before it in its row.
-function tableHeaders(table: Node, prefix: string) {
+function tableHeaders(table: Node, prefix: string, ths: { n: number }) {
   const rows: { cells: Node[]; head: boolean }[] = [];
   const collect = (n: Node, head: boolean) => {
     for (const k of n.kids) {
@@ -185,7 +209,6 @@ function tableHeaders(table: Node, prefix: string) {
   };
   collect(table, false);
   const grid: Node[][] = [];
-  let ids = 0;
   rows.forEach(({ cells, head }, r) => {
     grid[r] ??= [];
     let c = 0;
@@ -194,7 +217,7 @@ function tableHeaders(table: Node, prefix: string) {
       const [cs, rs] = cell.span!;
       for (let dr = 0; dr < rs; dr++) for (let dc = 0; dc < cs; dc++) (grid[r + dr] ??= [])[c + dc] = cell;
       if (cell.type === "TH") {
-        cell.id = `${prefix}th${++ids}`;
+        cell.id = `${prefix}th${++ths.n}`;
         cell.attrs ??= { O: "Table", Scope: head || r === 0 ? "Column" : "Row" };
       }
       const a: Record<string, unknown> = { O: "Table", ...cell.attrs };
@@ -213,8 +236,20 @@ function tableHeaders(table: Node, prefix: string) {
   }));
 }
 
-function addText(parent: Node, text: string) {
+const TEXT = new Set(["", "text", "email", "tel", "number", "date", "url", "search", "password", "time", "month", "week", "datetime-local"]);
+function controlType(tag: string, type: string): ControlType | null {
+  if (tag === "select") return "combobox";
+  if (tag === "textarea") return "multiline";
+  if (type === "checkbox" || type === "radio") return type;
+  return TEXT.has(type) ? "text" : null;
+}
+
+const labelWords = (ctx: Ctx, id: string) => ctx.labelWords.get(id) ?? (ctx.labelWords.set(id, []), ctx.labelWords.get(id)!);
+const textOfNode = (n: Node | Run): string => (isRun(n) ? n.words.map((w) => w.text).join(" ") : n.kids.map(textOfNode).join(" "));
+
+function addText(parent: Node, text: string, collect: Word[][] = []) {
   const words = splitWords(text).map((w) => ({ ...word(w.text), space: w.space }));
+  for (const list of collect) list.push(...words);
   if (/^\s/.test(text)) { const w = lastWord(parent); if (w) w.space = true; } // "<a>form</a> for"
   if (!words.length) return;
   const last = parent.kids.at(-1);
diff --git a/src/pdf/widgets.ts b/src/pdf/widgets.ts
index b051224..6509da0 100644
--- a/src/pdf/widgets.ts
+++ b/src/pdf/widgets.ts
@@ -27,16 +27,18 @@ export type FormValue = string | boolean | string[];
 export function allWidgets(doc: mupdf.PDFDocument): Widget[] {
   const out: Widget[] = [];
   for (let i = 0; i < doc.countPages(); i++) {
-    for (const widget of doc.loadPage(i).getWidgets()) {
-      const obj = widget.getObject();
-      // A widget with no /T of its own is one of its parent field's widgets.
-      const field = obj.get("T").isNull() && !obj.get("Parent").isNull() ? obj.get("Parent") : obj;
-      out.push({ name: widget.getName(), page: i, widget, field });
-    }
+    for (const widget of doc.loadPage(i).getWidgets()) out.push(widgetOf(widget, i));
   }
   return out;
 }
 
+export function widgetOf(widget: mupdf.PDFWidget, page: number): Widget {
+  const obj = widget.getObject();
+  // A widget with no /T of its own is one of its parent field's widgets.
+  const field = obj.get("T").isNull() && !obj.get("Parent").isNull() ? obj.get("Parent") : obj;
+  return { name: widget.getName(), page, widget, field };
+}
+
 // A button widget's states, from its normal appearances: the on-states, never Off.
 export function onStates(widget: mupdf.PDFWidget): string[] {
   const states: string[] = [];
diff --git a/src/report.ts b/src/report.ts
index 4f74422..9af118b 100644
--- a/src/report.ts
+++ b/src/report.ts
@@ -28,7 +28,8 @@ export type Report = {
   };
   pages: PageReport[];
   structure: { elements: number; byType: Record<string, number> };
-  form: { fields: number; set: number; skippedReadOnly: number; unresolved: string[] };
+  // created: the fields made for a flat form, from its HTML.
+  form: { fields: number; set: number; skippedReadOnly: number; unresolved: string[]; created: { name: string; type: string; page: number }[] };
   verification: {
     pixels: "identical-outside-fields" | "failed" | "off";
     differingPixels: number;
@@ -46,7 +47,7 @@ export function newReport(): Report {
     source: { pages: 0, encrypted: false, signed: false, acroform: false, xfa: false, hadTextLayer: [] },
     pages: [],
     structure: { elements: 0, byType: {} },
-    form: { fields: 0, set: 0, skippedReadOnly: 0, unresolved: [] },
+    form: { fields: 0, set: 0, skippedReadOnly: 0, unresolved: [], created: [] },
     verification: { pixels: "off", differingPixels: 0, textPreserved: null },
     pdfua: { checked: false },
     sizeIncreaseBytes: 0,
diff --git a/src/tag.ts b/src/tag.ts
index c0692a5..ed95200 100644
--- a/src/tag.ts
+++ b/src/tag.ts
@@ -9,10 +9,11 @@ import { setDocumentInfo } from "./pdf/metadata.ts";
 import { textLayerWords } from "./pdf/words.ts";
 import { allWidgets, checkValues, inventory, onStates, setValues, type FormValue, type Widget } from "./pdf/widgets.ts";
 import { buildPage, isRun, wordsInOrder, type Node, type Placed, type Run, type Word } from "./html/build.ts";
-import { joinHyphenated, type Box, type PageWord } from "./align/words.ts";
+import { joinHyphenated, normalize, type Box, type PageWord } from "./align/words.ts";
 import { align, MAX_WORDS } from "./align/align.ts";
 import { isFurniture } from "./align/classify.ts";
 import { ocrWords } from "./ocr/tesseract.ts";
+import { FieldMaker, fieldNames } from "./form/create.ts";
 import { comparePixels } from "./verify/pixels.ts";
 import { compareText } from "./verify/text.ts";
 import { EXIT, IrisPdfError, newReport, type PageReport, type Report, type Warning } from "./report.ts";
@@ -51,17 +52,21 @@ export function tag(pdf: Uint8Array, input: PagesInput, opts: TagOptions = {}, r
   const title = input.title || opts.title || doc.getMetaData("info:Title");
   if (!title) warn({ code: "no_title", detail: "No document title. Pass --title." });
 
-  // Forms: check every value, then set them, then flatten if asked.
-  const fields = inventory(doc);
+  // Forms: check every value, then set them, then flatten if asked. A form
+  // with no fields gets them from its HTML, page by page, and is filled after.
+  let fields = inventory(doc);
   const values = opts.values ?? {};
-  checkValues(fields, values).forEach(warn);
-  const filled = setValues(doc, fields, values);
-  report.form = { fields: fields.length, set: filled.set, skippedReadOnly: filled.skippedReadOnly, unresolved: [] };
+  const maker = !fields.length && !opts.flatten ? new FieldMaker(doc) : undefined;
+  let filled = { set: 0, skippedReadOnly: 0, changed: new Map<number, Box[]>() };
+  if (!maker) {
+    checkValues(fields, values).forEach(warn);
+    filled = setValues(doc, fields, values);
+  }
   const widgets = allWidgets(doc).map((w) => ({ ...w, box: w.widget.getBounds() as Box, used: false }));
   if (opts.flatten) doc.bake(false, true);
 
   // The source's own fonts must be embedded for the file to be PDF/UA. We do not rewrite them.
-  const unembedded = unembeddedFonts(doc);
+  let unembedded = unembeddedFonts(doc);
   if (unembedded.length) warn({ code: "font_not_embedded", detail: `${unembedded.join(", ")}; the output does not claim PDF/UA-1.` });
   const marked = pagesWithMcids(doc);
   if (marked.length) warn({ code: "source_marked_content", detail: `Pages ${marked.join(", ")} carry marked-content ids from an earlier tag tree, or could not be checked; the output does not claim PDF/UA-1.` });
@@ -82,8 +87,8 @@ export function tag(pdf: Uint8Array, input: PagesInput, opts: TagOptions = {}, r
       continue;
     }
     const r = tagPage(page, i, html.get(i)!, {
-      doc, struct, fonts, lang, flatten: !!opts.flatten, warn,
-      widgets: widgets.filter((w) => w.page === i), allWidgets: widgets, values, fields,
+      doc, struct, fonts, lang, flatten: !!opts.flatten, warn, maker,
+      widgets: widgets.filter((w) => w.page === i), allWidgets: widgets,
     });
     report.pages.push(r.report);
     if (r.untagged) untagged++;
@@ -97,6 +102,17 @@ export function tag(pdf: Uint8Array, input: PagesInput, opts: TagOptions = {}, r
     }
   }
   for (const w of widgets) if (!w.used) report.form.unresolved.push(w.name);
+  if (maker) {
+    fields = inventory(doc);
+    checkValues(fields, values).forEach(warn);
+    filled = setValues(doc, fields, values);
+    report.form.created = maker.created;
+    // Typed text is drawn in Helvetica, which is not embedded.
+    const more = unembeddedFonts(doc).filter((f) => !unembedded.includes(f));
+    if (more.length) warn({ code: "font_not_embedded", detail: `${more.join(", ")}, for the filled fields; the output does not claim PDF/UA-1.` });
+    unembedded = [...unembedded, ...more];
+  }
+  Object.assign(report.form, { fields: fields.length, set: filled.set, skippedReadOnly: filled.skippedReadOnly });
 
   // Fonts go in last, as one subset holding every glyph the overlays use.
   const fontRefs = fonts.embed(doc, written.map((w) => w.overlay));
@@ -136,8 +152,7 @@ type PageCtx = {
   warn: (w: Warning) => void;
   widgets: (Widget & { box: Box; used: boolean })[]; // this page's
   allWidgets: (Widget & { box: Box; used: boolean })[];
-  values: Record<string, FormValue>;
-  fields: ReturnType<typeof inventory>;
+  maker?: FieldMaker; // a flat form: its fields are made from the HTML
 };
 
 // One page: find its words, align Iris's words to them, write the overlay and
@@ -174,12 +189,14 @@ function tagPage(page: mupdf.PDFPage, i: number, html: string, ctx: PageCtx): {
   const { match, complete } = align(ordered.map((o) => o.word.norm), tokens.map((t) => t.norm));
   if (!complete) warn({ code: "alignment_incomplete", detail: "The page and the HTML differ too much to match every word in time." });
   const blockOf = new Map<number, number>();
+  const matched = new Set<Word>();
   match.forEach((t, k) => {
     if (t < 0) {
       if (ordered[k].word.norm) report.addedFromHtml++; // punctuation is not a word
       return;
     }
     report.matched++;
+    matched.add(ordered[k].word);
     ordered[k].word.at = placed(words[tokens[t].words[0]]);
     blockOf.set(t, ordered[k].block);
   });
@@ -187,6 +204,16 @@ function tagPage(page: mupdf.PDFPage, i: number, html: string, ctx: PageCtx): {
   // With no page words, each block starts a new line, so blocks do not run together.
   const breaks = new Set(words.length ? [] : ordered.filter((o, k) => k && o.newLine).map((o) => o.word));
   fillPositions(ordered.map((o) => o.word), bounds, (s) => ctx.fonts.width(s), breaks);
+  if (ctx.maker) {
+    const made = ctx.maker.page(page, i, plan, report.textSource === "approximate" ? null : {
+      matched, order: ordered.map((o) => o.word), words: words.map((w) => ({ norm: normalize(w.text), box: w.box })),
+    }, warn);
+    for (const w of made) {
+      const entry = { ...w, box: w.widget.getBounds() as Box, used: false };
+      ctx.widgets.push(entry);
+      ctx.allWidgets.push(entry);
+    }
+  }
 
   // Page words Iris left out: furniture, or lost content reported and kept as a P.
   const lost = new Map<number, Run[]>(); // after which top-level block
@@ -321,7 +348,16 @@ function linkAnnotation(n: Node, elem: mupdf.PDFObject, e: Emitter) {
 // Flattened, the widget is gone and a P carries the value instead.
 function emitField(n: Node, parent: mupdf.PDFObject, e: Emitter) {
   const f = n.form!;
-  const mine = e.widgets.filter((w) => w.name === f.name && !w.used && (!f.value || onStates(w.widget).includes(f.value)));
+  if (f.unplaced) return;
+  if (e.maker && !f.type) return; // a button: nothing to fill
+  if (!f.name) return e.warn({ code: "field_without_name", detail: f.label || "a form control" });
+  const free = (name: string) => e.widgets.filter((w) => w.name === name && !w.used && (!f.value || onStates(w.widget).includes(f.value)));
+  let mine = free(f.name);
+  // Retagging our own output: a field we made may carry a changed name.
+  for (const name of fieldNames(f.name)) {
+    if (mine.length || !e.allWidgets.some((w) => w.name === name)) break;
+    mine = free(name);
+  }
   if (!mine.length) {
     const code = e.allWidgets.some((w) => w.name === f.name) ? "field_on_other_page" : "field_not_in_pdf";
     return e.warn({ code, detail: f.name });
@@ -335,7 +371,8 @@ function emitField(n: Node, parent: mupdf.PDFObject, e: Emitter) {
     return writeRun("P", elem, [{ text, norm: "", at }], e);
   }
   const elem = e.struct.add(parent, "Form", f.label ? { Alt: e.doc.newString(f.label) } : {});
-  const name = f.group || f.label;
+  // A radio button's label names one choice; its group's legend or question names the field.
+  const name = (f.type === "radio" && f.group) || f.label || f.group || "";
   for (const w of mine) {
     e.struct.objr(elem, e.pageObj, w.widget.getObject());
     nameField(w, name, e.doc);
diff --git a/test/document.test.ts b/test/document.test.ts
index c57070c..e3eae08 100644
--- a/test/document.test.ts
+++ b/test/document.test.ts
@@ -31,7 +31,7 @@ test("refuses what it cannot safely change, each with its own code", () => {
     ["owner forbids edits", readFixture("restricted.pdf"), {}, "permissions_denied", 1],
     ["signed", readFixture("signed.pdf"), {}, "signed", 1],
     ["26 pages", blankPdf(26), {}, "too_many_pages", 1],
-    ["value for a flat form", readFixture("form-flat.pdf"), { values: { name: "Ada" } }, "no_acroform_field", 1],
+    ["value for a field the form lacks", readFixture("form-flat.pdf"), { values: { name: "Ada" } }, "no_acroform_field", 1],
   ];
   for (const [what, pdf, opts, code, exit] of cases) {
     assert.deepEqual((({ code, exit }) => ({ code, exit }))(refusal(pdf, opts)), { code, exit }, what);
diff --git a/test/fixtures/form-lines.pages.json b/test/fixtures/form-lines.pages.json
new file mode 100644
index 0000000..9df3d69
--- /dev/null
+++ b/test/fixtures/form-lines.pages.json
@@ -0,0 +1,10 @@
+{
+  "lang": "en",
+  "title": "Test document",
+  "pages": [
+    {
+      "sourcePage": 1,
+      "html": "<h1>Library Card</h1><form><fieldset><legend>About you</legend><p><label for=\"n\">Full name</label><input id=\"n\" name=\"name\"></p><p><label for=\"e\">Email</label><input id=\"e\" name=\"email\" type=\"email\"></p></fieldset><p><label><input type=\"checkbox\" name=\"news\"> Send me news</label></p><p>Card type: <label><input type=\"radio\" name=\"card\" value=\"adult\"> Adult</label> <label><input type=\"radio\" name=\"card\" value=\"child\"> Child</label></p><table><thead><tr><th>Book</th><th>Due</th></tr></thead><tbody><tr><td><input aria-label=\"Book\" name=\"book1\"></td><td><input aria-label=\"Due\" name=\"due1\"></td></tr><tr><td><input aria-label=\"Book\" name=\"book2\"></td><td><input aria-label=\"Due\" name=\"due2\"></td></tr></tbody></table><p><label for=\"p\">Phone</label><input id=\"p\" name=\"phone\" type=\"tel\"></p></form>"
+    }
+  ]
+}
diff --git a/test/fixtures/form-lines.pdf b/test/fixtures/form-lines.pdf
new file mode 100644
index 0000000..90c46ae
Binary files /dev/null and b/test/fixtures/form-lines.pdf differ
diff --git a/test/fixtures/form-scan-skewed.pages.json b/test/fixtures/form-scan-skewed.pages.json
new file mode 100644
index 0000000..9df3d69
--- /dev/null
+++ b/test/fixtures/form-scan-skewed.pages.json
@@ -0,0 +1,10 @@
+{
+  "lang": "en",
+  "title": "Test document",
+  "pages": [
+    {
+      "sourcePage": 1,
+      "html": "<h1>Library Card</h1><form><fieldset><legend>About you</legend><p><label for=\"n\">Full name</label><input id=\"n\" name=\"name\"></p><p><label for=\"e\">Email</label><input id=\"e\" name=\"email\" type=\"email\"></p></fieldset><p><label><input type=\"checkbox\" name=\"news\"> Send me news</label></p><p>Card type: <label><input type=\"radio\" name=\"card\" value=\"adult\"> Adult</label> <label><input type=\"radio\" name=\"card\" value=\"child\"> Child</label></p><table><thead><tr><th>Book</th><th>Due</th></tr></thead><tbody><tr><td><input aria-label=\"Book\" name=\"book1\"></td><td><input aria-label=\"Due\" name=\"due1\"></td></tr><tr><td><input aria-label=\"Book\" name=\"book2\"></td><td><input aria-label=\"Due\" name=\"due2\"></td></tr></tbody></table><p><label for=\"p\">Phone</label><input id=\"p\" name=\"phone\" type=\"tel\"></p></form>"
+    }
+  ]
+}
diff --git a/test/fixtures/form-scan-skewed.pdf b/test/fixtures/form-scan-skewed.pdf
new file mode 100644
index 0000000..2b497c1
Binary files /dev/null and b/test/fixtures/form-scan-skewed.pdf differ
diff --git a/test/fixtures/form-scan.pages.json b/test/fixtures/form-scan.pages.json
new file mode 100644
index 0000000..9df3d69
--- /dev/null
+++ b/test/fixtures/form-scan.pages.json
@@ -0,0 +1,10 @@
+{
+  "lang": "en",
+  "title": "Test document",
+  "pages": [
+    {
+      "sourcePage": 1,
+      "html": "<h1>Library Card</h1><form><fieldset><legend>About you</legend><p><label for=\"n\">Full name</label><input id=\"n\" name=\"name\"></p><p><label for=\"e\">Email</label><input id=\"e\" name=\"email\" type=\"email\"></p></fieldset><p><label><input type=\"checkbox\" name=\"news\"> Send me news</label></p><p>Card type: <label><input type=\"radio\" name=\"card\" value=\"adult\"> Adult</label> <label><input type=\"radio\" name=\"card\" value=\"child\"> Child</label></p><table><thead><tr><th>Book</th><th>Due</th></tr></thead><tbody><tr><td><input aria-label=\"Book\" name=\"book1\"></td><td><input aria-label=\"Due\" name=\"due1\"></td></tr><tr><td><input aria-label=\"Book\" name=\"book2\"></td><td><input aria-label=\"Due\" name=\"due2\"></td></tr></tbody></table><p><label for=\"p\">Phone</label><input id=\"p\" name=\"phone\" type=\"tel\"></p></form>"
+    }
+  ]
+}
diff --git a/test/fixtures/form-scan.pdf b/test/fixtures/form-scan.pdf
new file mode 100644
index 0000000..bc9d7b6
Binary files /dev/null and b/test/fixtures/form-scan.pdf differ
diff --git a/test/fixtures/make.ts b/test/fixtures/make.ts
index deb9bb9..d5a1995 100644
--- a/test/fixtures/make.ts
+++ b/test/fixtures/make.ts
@@ -258,6 +258,38 @@ pagesJson("form-flat.pages.json", [{
   sourcePage: 1, html: '<h1>Permit Application</h1><form><p><label for="n">Full name</label> <input id="n" name="name"></p></form>',
 }]);
 
+// --- form-lines: a flat form with each kind of blank: an underline, a box, a
+// check box, radio circles, a table with a faint row line, and a label with
+// no blank. form-scan and form-scan-skewed are it scanned.
+const circle = (x: number, y: number, r: number) => {
+  const k = r * 0.5523;
+  return `${x + r} ${y} m ${x + r} ${y + k} ${x + k} ${y + r} ${x} ${y + r} c ${x - k} ${y + r} ${x - r} ${y + k} ${x - r} ${y} c ` +
+    `${x - r} ${y - k} ${x - k} ${y - r} ${x} ${y - r} c ${x + k} ${y - r} ${x + r} ${y - k} ${x + r} ${y} c S\n`;
+};
+const formLines = textDoc([
+  show(20, 360, 14, "Library Card", "F2") + show(20, 340, 9, "About you", "F2") +
+  show(20, 322, 9, "Full name") + "0 G 0.8 w 75 320 m 290 320 l S\n" +
+  show(20, 300, 9, "Email") + "75 294 215 16 re S\n" +
+  "20 272 8 8 re S\n" + show(32, 273, 9, "Send me news") +
+  show(20, 250, 9, "Card type:") + circle(84, 253, 4) + show(92, 250, 9, "Adult") + circle(134, 253, 4) + show(142, 250, 9, "Child") +
+  "20 160 270 70 re S 155 160 m 155 230 l S 20 212 m 290 212 l S\n" + show(30, 218, 9, "Book", "F2") + show(165, 218, 9, "Due", "F2") +
+  "q 0.75 G 0.5 w 20 186 m 290 186 l S Q\n" +
+  show(20, 130, 9, "Phone"),
+]);
+const formHtml = '<h1>Library Card</h1><form><fieldset><legend>About you</legend>' +
+  '<p><label for="n">Full name</label><input id="n" name="name"></p>' +
+  '<p><label for="e">Email</label><input id="e" name="email" type="email"></p></fieldset>' +
+  '<p><label><input type="checkbox" name="news"> Send me news</label></p>' +
+  '<p>Card type: <label><input type="radio" name="card" value="adult"> Adult</label> <label><input type="radio" name="card" value="child"> Child</label></p>' +
+  '<table><thead><tr><th>Book</th><th>Due</th></tr></thead><tbody>' +
+  '<tr><td><input aria-label="Book" name="book1"></td><td><input aria-label="Due" name="due1"></td></tr>' +
+  '<tr><td><input aria-label="Book" name="book2"></td><td><input aria-label="Due" name="due2"></td></tr></tbody></table>' +
+  '<p><label for="p">Phone</label><input id="p" name="phone" type="tel"></p></form>';
+save("form-lines.pdf", formLines);
+save("form-scan.pdf", scanDoc([formLines]));
+save("form-scan-skewed.pdf", scanDoc([formLines], 1.5));
+for (const name of ["form-lines", "form-scan", "form-scan-skewed"]) pagesJson(`${name}.pages.json`, [{ sourcePage: 1, html: formHtml }]);
+
 // --- encrypted: needs a password to open. restricted: opens, but the owner
 // has forbidden changes (permissions: print, copy, extract only).
 save("encrypted.pdf", textDoc([simple]), "encrypt=aes-256,user-password=open,owner-password=owner");
diff --git a/test/forms.test.ts b/test/forms.test.ts
index 4528c12..45c38e3 100644
--- a/test/forms.test.ts
+++ b/test/forms.test.ts
@@ -1,8 +1,16 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import * as mupdf from "mupdf";
 import { fields, tag, newReport, type FormValue } from "../src/index.ts";
-import { find, pagesOf, readFixture, structTree, tagFixture } from "./helpers.ts";
+import type { Box } from "../src/align/words.ts";
+import { tesseractInstalled } from "../src/ocr/tesseract.ts";
+import { find, fixture, pagesOf, readFixture, structTree, tagFixture } from "./helpers.ts";
+
+const noOcr = !tesseractInstalled() && "Tesseract is not installed";
 
 const pdf = readFixture("form-acroform.pdf");
 const pages = pagesOf("form-acroform");
@@ -120,3 +128,72 @@ test("a field the HTML does not name keeps its own name, a button its caption, a
   assert.equal(out.get("state")![0].getLabel(), "State of residence");
   assert.equal(out.get("Office (dd.mm)")![0].getLabel(), "Office (dd.mm)");
 });
+
+// A flat form: each blank's place on the page (top down), from make.ts.
+const blanks: Record<string, Box[]> = {
+  name: [[75, 62, 290, 76]], email: [[75, 86, 290, 102]], news: [[20, 116, 28, 124]],
+  card: [[80, 139, 88, 147], [130, 139, 138, 147]],
+  book1: [[20, 184, 155, 210]], due1: [[155, 184, 290, 210]], book2: [[20, 210, 155, 236]], due2: [[155, 210, 290, 236]],
+};
+const grow = (b: Box, d: number): Box => [b[0] - d, b[1] - d, b[2] + d, b[3] + d];
+const within = (a: Box, b: Box) => a[0] >= b[0] && a[1] >= b[1] && a[2] <= b[2] && a[3] <= b[3];
+
+for (const [name, scan] of [["form-lines", false], ["form-scan", true], ["form-scan-skewed", true]] as const) {
+  test(`${name}: a flat form gets a field on each blank the HTML names`, { skip: scan && noOcr }, () => {
+    const { doc, report } = tagFixture(name);
+    assert.deepEqual(report.form.created.map((c) => [c.name, c.type, c.page]), [
+      ["name", "text", 1], ["email", "text", 1], ["news", "checkbox", 1], ["card", "radio", 1],
+      ["book1", "text", 1], ["due1", "text", 1], ["book2", "text", 1], ["due2", "text", 1],
+    ]);
+    assert.deepEqual(report.warnings.filter((w) => w.code === "field_not_placed"), [{ code: "field_not_placed", page: 1, detail: "phone" }]);
+    for (const [field, ws] of widgets(doc)) {
+      const want = blanks[field];
+      assert.equal(ws.length, want.length, field);
+      ws.forEach((w, k) => {
+        const b = w.getBounds() as Box, c: Box = [(b[0] + b[2]) / 2, (b[1] + b[3]) / 2, (b[0] + b[2]) / 2, (b[1] + b[3]) / 2];
+        // A scan's blanks move a little, and a skewed one's more; drawn ones do not.
+        assert.ok(scan ? within(c, grow(want[k], 5)) : within(b, grow(want[k], 1.5)), `${field} at ${b.map((v) => v.toFixed(1))}`);
+      });
+    }
+    assert.equal(find(structTree(doc), "Form").length, 9); // 8 fields, the radio group has 2 widgets
+    assert.equal(report.verification.differingPixels, 0);
+  });
+}
+
+test("a flat form's made fields are filled and named for a screen reader", () => {
+  const { doc, report } = tagFixture("form-lines", { values: { name: "Ada Lovelace", card: "child", news: true, book1: "Emma" } });
+  const w = widgets(doc);
+  assert.equal(w.get("name")![0].getValue(), "Ada Lovelace");
+  assert.equal(w.get("book1")![0].getValue(), "Emma");
+  assert.deepEqual(w.get("card")!.map(state), ["Off", "child"]);
+  assert.notEqual(state(w.get("news")![0]), "Off");
+  assert.equal(report.form.set, 4);
+  assert.equal(w.get("name")![0].getLabel(), "Full name", "a field in a fieldset is named by its own label");
+  assert.equal(w.get("card")![0].getLabel(), "Card type:");
+  assert.equal(w.get("book2")![0].getLabel(), "Book");
+  assert.equal(report.verification.pixels, "identical-outside-fields");
+  assert.throws(() => tag(readFixture("form-lines.pdf"), pagesOf("form-lines"), { values: { phone: "555" } }), { code: "no_acroform_field" });
+});
+
+test("a scan whose words are placed approximately gets no fields", () => {
+  const dir = mkdtempSync(join(tmpdir(), "iris-pdf-")), out = join(dir, "o.pdf"), json = join(dir, "o.json");
+  const cli = new URL("../src/cli.ts", import.meta.url).pathname;
+  const r = spawnSync(process.execPath, [cli, "tag", "--pdf", fixture("form-scan.pdf"), "--pages", fixture("form-scan.pages.json"), "--out", out, "--report", json], { encoding: "utf8", env: { PATH: "" } });
+  assert.equal(r.status, 0, r.stderr);
+  const report = JSON.parse(readFileSync(json, "utf8"));
+  assert.deepEqual(report.form.created, []);
+  assert.equal(report.warnings.filter((w: { code: string }) => w.code === "field_not_placed").length, 10); // every control, a radio button each
+  assert.equal(new mupdf.PDFDocument(readFileSync(out)).loadPage(0).getWidgets().length, 0);
+});
+
+test("a flat form's made fields keep their tags when the output is tagged again", () => {
+  // A check box with a value, a dotted name and a repeated one: each made field's name or state differs from the HTML.
+  const html = pagesOf("form-lines").pages[0].html.replace('name="news"', 'name="news" value="yes"').replace('name="name"', 'name="you.name"').replace('name="due2"', 'name="due1"');
+  const pages = { ...pagesOf("form-lines"), pages: [{ sourcePage: 1, html }] };
+  const first = newReport(), out = tag(readFixture("form-lines.pdf"), pages, { values: { news: true } }, first);
+  assert.deepEqual(first.form.created.map((c) => c.name), ["you-name", "email", "news", "card", "book1", "due1", "book2", "due1-2"]);
+  const again = newReport(), doc = new mupdf.PDFDocument(tag(out, pages, {}, again));
+  assert.deepEqual(again.warnings.filter((w) => w.code.startsWith("field_")).map((w) => w.code), ["field_not_in_pdf"]); // phone
+  assert.equal(find(structTree(doc), "Form").length, 9);
+  assert.equal(state(widgets(doc).get("news")![0]), "yes");
+});
diff --git a/test/html.test.ts b/test/html.test.ts
index 516f934..2cef8a8 100644
--- a/test/html.test.ts
+++ b/test/html.test.ts
@@ -1,6 +1,6 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { buildPage, isRun, wordsInOrder, type Node } from "../src/html/build.ts";
+import { buildPage, isRun, wordsInOrder, type FormRef, type Node } from "../src/html/build.ts";
 import type { Warning } from "../src/report.ts";
 
 function build(html: string) {
@@ -61,18 +61,44 @@ test("form controls take their label from for=, an enclosing label, or aria-labe
     '<fieldset><legend>Contact</legend><label for="e">Email</label><input id="e" name="contact" type="radio" value="email"></fieldset>' +
     '<label>Name <input name="name"></label><input name="state" aria-label="State"><input type="hidden" name="h"><input>',
   );
-  const forms: Node[] = [];
-  const walk = (n: Node) => { if (n.type === "Form") forms.push(n); n.kids.forEach((k) => isRun(k) || walk(k)); };
-  walk(top);
-  assert.deepEqual(forms.map((f) => f.form), [
-    { name: "contact", label: "Email", group: "Contact", value: "email" },
-    { name: "name", label: "Name", group: undefined },
-    { name: "state", label: "State", group: undefined },
+  const forms = formsOf(top).map(({ name, label, group, value, type }) => ({ name, label, group, value, type }));
+  assert.deepEqual(forms, [
+    { name: "contact", label: "Email", group: "Contact", value: "email", type: "radio" },
+    { name: "name", label: "Name", group: undefined, value: undefined, type: "text" },
+    { name: "state", label: "State", group: undefined, value: undefined, type: "text" },
+    { name: "", label: "", group: undefined, value: undefined, type: "text" }, // reported when it is tagged
   ]);
   assert.equal((top.kids[0] as Node).title, "Contact");
-  assert.deepEqual(warnings.map((w) => w.code), ["field_without_name"]);
+  assert.deepEqual(warnings, []);
+});
+
+test("form controls keep their label's words, a radio group's question, and a list's options", () => {
+  const { top } = build(
+    '<p>Do you own a home? <label><input type="radio" name="own" value="y"> Yes</label><label><input type="radio" name="own" value="n"> No</label></p>' +
+    '<label for="c">Your city:</label><select id="c" name="city"><option value="a">Ames</option><option>Boone</option></select><textarea name="notes"></textarea>',
+  );
+  const [yes, no, city, notes] = formsOf(top);
+  assert.deepEqual([yes.group, no.group], ["Do you own a home?", "Do you own a home?"]);
+  assert.deepEqual(no.labelWords.map((w) => w.text), ["No"]);
+  assert.deepEqual(city.labelWords.map((w) => w.text), ["Your", "city:"]);
+  assert.deepEqual([city.type, city.options], ["combobox", ["a", "Boone"]]);
+  assert.equal(notes.type, "multiline");
 });
 
+test("header ids are unique across a page's tables", () => {
+  const { top } = build("<table><tr><th>A</th></tr><tr><td>1</td></tr></table><table><tr><th>B</th></tr><tr><td>2</td></tr></table>");
+  const ids: string[] = [], walk = (n: Node) => { if (n.id) ids.push(n.id); n.kids.forEach((k) => isRun(k) || walk(k)); };
+  walk(top);
+  assert.deepEqual(ids, ["p1-th1", "p1-th2"]);
+});
+
+function formsOf(top: Node) {
+  const forms: FormRef[] = [];
+  const walk = (n: Node) => { if (n.form) forms.push(n.form); n.kids.forEach((k) => isRun(k) || walk(k)); };
+  walk(top);
+  return forms;
+}
+
 test("tables: header ids, scope and each cell's headers", () => {
   const { top } = build(
     "<table><thead><tr><th></th><th>Q1</th><th>Q2</th></tr></thead>" +