@jasy/pdf 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/elements/text-element.js

@@ -1,18 +1,16 @@
-// Import the renderer DIRECTLY, not via the "../renderer" barrel: the barrel pulls in
-// pdf-renderer (and every element) while this element module is still loading, which under
-// ESM (Vite/vitest, and the future framework bindings) duplicates the element classes and
-// breaks the constructor-keyed RendererRegistry. A direct import keeps the graph acyclic.
-import { TextRenderer } from "../renderer/text-renderer.js";
 import { DEFAULT_TEXT_STYLE } from "../text/text-style.js";
+import { BoxConstraints } from "../layout/box-constraints.js";
 import { applyTextTransform } from "../text/text-style.js";
 import { splitByFont } from "../text/font-fallback.js";
 import { runAdvance } from "../text/advance.js";
-import { singleLineWidth, MAX_SPACE_SHRINK, wrapStringIntoLines, breakSegmentsIntoLines, segmentLinesToSegments, } from "../text/line-breaker.js";
+import { singleLineWidth, MAX_SPACE_SHRINK, breakSegmentsIntoLines, } from "../text/line-breaker.js";
+import { hyphenPieces } from "../text/hyphen-breaks.js";
 import { adjustForOrphansWidows, DEFAULT_ORPHANS, DEFAULT_WIDOWS, } from "../text/orphans-widows.js";
-import { lineBoxForSegmentLine, lineBoxForString } from "../text/line-metrics.js";
+import { lineBoxForSegmentLine, textHeight } from "../text/line-metrics.js";
 import { HorizontalAlignment, SizedPDFElement } from "./pdf-element.js";
 import { normalizeContent } from "../text/whitespace.js";
 import { coverText } from "../text/glyph-coverage.js";
+import { pageOf } from "../common/diagnostics.js";
 /** How far a run sits off the baseline, as a fraction of its font size (up is positive). */
 export const VERTICAL_TEXT_SHIFT = {
     baseline: 0,
@@ -31,9 +29,14 @@ function finitePoints(value, name) {
     return value;
 }
 export class TextElement extends SizedPDFElement {
-    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, orphans, widows, overflow = "clip", lineHeight, underline, strikethrough, skipInk, letterSpacing, direction, fontFallback, textTransform, wordSpacing, textIndent, breakWord, hyphenate, ligatures, role, }) {
+    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, orphans, widows, overflow = "clip", lineHeight, underline, strikethrough, skipInk, letterSpacing, direction, fontFallback, textTransform, wordSpacing, textIndent, breakWord, hyphenate, ligatures, role, shownLines, }) {
         super({ x: 0, y: 0 });
+        /** What `covered` had to remove, reported where the text is laid out on its page (see
+         *  `calculateLayout`). A split paragraph's first piece carries its parent's, as `lostBefore`. */
+        this.lostGlyphs = [];
+        this.lostBefore = [];
         this.role = role;
+        this.shownLines = shownLines;
         this.rawFontSize = fontSize;
         this.rawFontFamily = fontFamily;
         this.rawFontStyle = fontStyle;
@@ -73,19 +76,39 @@ export class TextElement extends SizedPDFElement {
      * same width in most fonts).
      */
     display(metrics) {
+        const memo = this.displayed;
+        if (metrics &&
+            memo &&
+            memo.metrics === metrics &&
+            // A face registered since then changes what is drawable and how the fallback stack splits.
+            memo.epoch === (metrics.fontEpoch ?? 0) &&
+            memo.family === this.fontFamily &&
+            memo.style === this.fontStyle &&
+            memo.transform === this.textTransform &&
+            memo.fallback === this.fontFallback)
+            return memo.value;
         const cased = this.recased();
         // A SPAN may bring its own stack, so the element's being empty is not enough to skip the pass.
-        const anyStack = this.fontFallback.length > 0 ||
-            (typeof cased !== "string" && cased.some((seg) => (seg.fontFallback?.length ?? 0) > 0));
+        const anyStack = this.fontFallback.length > 0 || cased.some((seg) => (seg.fontFallback?.length ?? 0) > 0);
         if (!metrics)
             return cased;
+        const remember = (value) => {
+            this.displayed = {
+                metrics,
+                epoch: metrics.fontEpoch ?? 0,
+                family: this.fontFamily,
+                style: this.fontStyle,
+                transform: this.textTransform,
+                fallback: this.fontFallback,
+                value,
+            };
+            return value;
+        };
         if (!anyStack)
-            return this.covered(cased, metrics);
-        // Font fallback turns the content into spans - one per family - which every later pass already
-        // knows how to handle. Nothing new downstream.
-        const pieces = typeof cased === "string" ? [{ content: cased }] : cased;
+            return remember(this.covered(cased, metrics));
+        // Font fallback splits a span into more spans - one per family. Nothing new downstream.
         const out = [];
-        for (const seg of pieces) {
+        for (const seg of cased) {
             const runs = splitByFont(seg.content, seg.fontFamily ?? this.fontFamily, seg.fontFallback ?? this.fontFallback, seg.fontStyle ?? this.fontStyle, metrics);
             if (!runs)
                 out.push(seg);
@@ -93,7 +116,7 @@ export class TextElement extends SizedPDFElement {
                 for (const run of runs)
                     out.push({ ...seg, content: run.text, fontFamily: run.fontFamily });
         }
-        return this.covered(out, metrics);
+        return remember(this.covered(out, metrics));
     }
     /**
      * Drops or substitutes whatever the RESOLVED font cannot draw. Runs last, after the fallback stack
@@ -102,30 +125,26 @@ export class TextElement extends SizedPDFElement {
      * back unchanged, so an ordinary document is byte-identical.
      */
     covered(content, metrics) {
-        const report = (dropped) => metrics.reportMissingGlyph?.(dropped);
-        if (typeof content === "string") {
-            const { text, dropped } = coverText(content, this.fontFamily, this.fontStyle, metrics);
-            if (dropped.length > 0)
-                report(dropped);
-            return text;
-        }
-        return content.map((seg) => {
+        // Collected over every span: the element is reported once, with everything it lost, on the page it
+        // is laid out on - not here, which may be measuring it for an earlier page.
+        const lost = [];
+        const covered = content.map((seg) => {
             const { text, dropped } = coverText(seg.content, seg.fontFamily ?? this.fontFamily, seg.fontStyle ?? this.fontStyle, metrics);
-            if (dropped.length > 0)
-                report(dropped);
+            lost.push(...dropped);
             return text === seg.content ? seg : { ...seg, content: text };
         });
+        this.lostGlyphs = [...new Set(lost)];
+        return covered;
     }
-    /** The content with `text-transform` applied, and nothing else. */
+    /** The content as spans, with `text-transform` applied, and nothing else. */
     recased() {
+        // A string is one span: from here on, measuring, breaking and drawing know only spans.
+        const spans = typeof this.content === "string" ? [{ content: this.content }] : this.content;
         if (this.textTransform === "none")
-            return this.content;
-        if (typeof this.content === "string") {
-            return applyTextTransform(this.content, this.textTransform).text;
-        }
+            return spans;
         // The capitalisation state runs THROUGH the spans: `span("hel") + span("lo")` is one word.
         let atWordStart = true;
-        return this.content.map((seg) => {
+        return spans.map((seg) => {
             const done = applyTextTransform(seg.content, this.textTransform, atWordStart);
             atWordStart = done.atWordStart;
             return { ...seg, content: done.text };
@@ -139,6 +158,7 @@ export class TextElement extends SizedPDFElement {
             ligatures: this.ligatures,
             // Justified lines may be squeezed to keep a word; every other alignment gets no slack.
             shrink: this.textAlignment === HorizontalAlignment.justify ? MAX_SPACE_SHRINK : 0,
+            shownLines: this.shownLines,
         };
     }
     applyStyle(ts) {
@@ -165,43 +185,15 @@ export class TextElement extends SizedPDFElement {
      * Splits the paragraph at line boxes (Slice 1). The lines that fit in `maxHeight` stay;
      * the rest become a remainder `TextElement` re-wrapped on the next page. If not even one
      * line fits, nothing is forced here - the caller (the container) decides whether to move
-     * the whole element on for progress. Handles both plain strings and styled segments.
+     * the whole element on for progress.
      */
     fragment(maxHeight, width, ctx) {
         this.resolveStyle(ctx);
         const content = this.display(ctx.metrics);
-        return typeof content === "string"
-            ? this.fragmentString(content, maxHeight, width, ctx)
-            : this.fragmentSegments(content, maxHeight, width, ctx);
-    }
-    // Plain string: every wrapped line gets the same box (the same one calculateTextHeight uses),
-    // so `floor(maxHeight / lineBox)` lines fit.
-    fragmentString(content, maxHeight, width, ctx) {
-        const lines = wrapStringIntoLines(content, this.fontFamily, this.fontSize, this.fontStyle, width, ctx.metrics, this.maxLines, this.overflow, this.letterSpacing, this.lineOptions());
-        const box = lineBoxForString(ctx.metrics, this.fontFamily, this.fontStyle, this.fontSize, this.lineHeight);
-        const fittedLineCount = adjustForOrphansWidows(Math.floor(maxHeight / box.height), lines.length, this.breakRule());
-        if (fittedLineCount <= 0)
-            return { fitted: null, remainder: this };
-        if (fittedLineCount >= lines.length)
-            return { fitted: this, remainder: null };
-        return {
-            fitted: this.cloneWithContent(lines.slice(0, fittedLineCount).join(" ")),
-            // A continuation is no longer the paragraph's FIRST line, so it carries no indent.
-            remainder: this.cloneWithContent(lines.slice(fittedLineCount).join(" "), 0),
-        };
-    }
-    // Styled segments: each line's height comes from the fonts on it, so pack lines by cumulative
-    // box height. Rebuild the fitted/remainder halves back into TextSegment[].
-    fragmentSegments(content, maxHeight, width, ctx) {
-        const defaults = {
-            fontFamily: this.fontFamily,
-            fontSize: this.fontSize,
-            fontStyle: this.fontStyle,
-            letterSpacing: this.letterSpacing,
-            direction: this.direction,
-            wordSpacing: this.wordSpacing,
-            textIndent: this.textIndent,
-        };
+        // The SAME knobs measuring and drawing break with (`textHeight`, the renderer), or this
+        // would cut a paragraph at a line count it is never drawn with. Each line's height comes from
+        // the fonts on it, so lines are packed by their cumulative height.
+        const defaults = this.segmentDefaults();
         const lines = breakSegmentsIntoLines(content, defaults, width, ctx.metrics, this.maxLines, this.overflow);
         let used = 0;
         let packed = 0;
@@ -217,9 +209,35 @@ export class TextElement extends SizedPDFElement {
             return { fitted: null, remainder: this };
         if (fittedLineCount >= lines.length)
             return { fitted: this, remainder: null };
+        // A piece is a window onto the SAME text, not the lines glued back together: the first page draws
+        // the first lines of the whole paragraph (broken exactly as here, same text, same width), and the
+        // next one continues from where its first line starts in the source - inside its span, keeping
+        // that span's style. Hard breaks, a word split over the break and the justified last line on the
+        // page all survive that way. A continuation is no longer the paragraph's FIRST line, so it
+        // carries no indent; whatever is left of a line cap goes with it.
+        const { segment, offset } = lines[fittedLineCount].start;
+        const rest = [
+            { ...content[segment], content: content[segment].content.slice(offset) },
+            ...content.slice(segment + 1),
+        ];
+        const fitted = this.cloneWithContent(content, this.textIndent, { shownLines: fittedLineCount });
+        // The piece is cut from already-covered text, so it would find nothing missing itself.
+        fitted.lostBefore = [...this.lostBefore, ...this.lostGlyphs];
         return {
-            fitted: this.cloneWithContent(segmentLinesToSegments(lines.slice(0, fittedLineCount))),
-            remainder: this.cloneWithContent(segmentLinesToSegments(lines.slice(fittedLineCount)), 0),
+            fitted,
+            remainder: this.cloneWithContent(rest, 0, {
+                maxLines: this.maxLines === undefined ? undefined : this.maxLines - fittedLineCount,
+            }),
+        };
+    }
+    /** How the text is broken: the knobs `textHeight` and the renderer pass too. */
+    segmentDefaults() {
+        return {
+            fontFamily: this.fontFamily,
+            fontSize: this.fontSize,
+            fontStyle: this.fontStyle,
+            letterSpacing: this.letterSpacing,
+            ...this.lineOptions(),
         };
     }
     /** The orphan/widow minimums for this paragraph; unset means the CSS default of 2 lines each. */
@@ -231,7 +249,7 @@ export class TextElement extends SizedPDFElement {
     }
     // A copy carrying the same style but different (already-wrapped) content. Re-wrapping at
     // the same width reproduces exactly those lines (greedy is deterministic).
-    cloneWithContent(content, indent = this.textIndent) {
+    cloneWithContent(content, indent = this.textIndent, piece = {}) {
         return new TextElement({
             content,
             fontSize: this.fontSize,
@@ -239,7 +257,7 @@ export class TextElement extends SizedPDFElement {
             fontStyle: this.fontStyle,
             color: this.color,
             textAlignment: this.textAlignment,
-            maxLines: this.maxLines,
+            maxLines: piece.maxLines ?? this.maxLines,
             orphans: this.orphans,
             widows: this.widows,
             overflow: this.overflow,
@@ -252,45 +270,69 @@ export class TextElement extends SizedPDFElement {
             wordSpacing: this.wordSpacing,
             textIndent: indent,
             role: this.role,
-        }).adoptStructId(this); // a wrapped remainder is the SAME logical paragraph (one P across pages)
+            fontFallback: this.fontFallback,
+            // The content is cut from `display()`, already recased: `capitalize` again would capitalise
+            // the half of a word continued on the next page.
+            textTransform: "none",
+            breakWord: this.breakWord,
+            hyphenate: this.hyphenate,
+            ligatures: this.ligatures,
+            shownLines: piece.shownLines,
+        }).asPieceOf(this); // a wrapped remainder is the SAME logical paragraph (one P across pages)
     }
     calculateLayout(constraints, offset, ctx) {
+        // Bounded width (e.g. inside a Column) wraps to that width; an unbounded width
+        // (e.g. inside a Row) means the text takes its natural single-line width and does
+        // not wrap. Sized by `measure`, so a measured text and a laid-out one cannot differ. The style is
+        // resolved here too: a size from the cache skips `computeSize`, and drawing reads the style.
         this.resolveStyle(ctx);
+        const size = this.measure(constraints, ctx);
         this.x = offset.x;
         this.y = offset.y;
-        // Bounded width (e.g. inside a Column) wraps to that width; an unbounded width
-        // (e.g. inside a Row) means the text takes its natural single-line width and does
-        // not wrap. Columns always bound the width, so this leaves their layout untouched.
         this.resolved = this.display(ctx.metrics);
-        this.width = constraints.hasBoundedWidth
-            ? constraints.maxWidth
-            : this.naturalWidth(ctx.metrics);
-        const wrapWidth = this.width ?? 0;
-        this.height = TextRenderer.calculateTextHeight(this.resolved, this.fontSize, this.fontFamily, this.fontStyle, ctx.metrics, wrapWidth, this.maxLines, this.overflow, this.lineHeight, this.letterSpacing, this.lineOptions());
+        const lost = [...new Set([...this.lostBefore, ...this.lostGlyphs])];
+        if (lost.length > 0)
+            ctx.metrics.reportMissingGlyph?.(lost, this, pageOf(ctx));
+        this.width = size.width;
+        this.height = size.height;
         // Top-left coordinates (y = top of the text box). The baseline offset and the
         // Y-flip are applied downstream (the line-builder positions baselines, the seam
         // flips to PDF), so the element stays coordinate-system-blind.
-        return { width: wrapWidth, height: this.height };
+        return size;
+    }
+    /**
+     * The size `calculateLayout` would take, without placing anything. Resolving the inherited style
+     * and filling the memos below are its only writes, and both are a pure function of the context:
+     * the same inputs leave the same state, which a later layout reads back unchanged.
+     */
+    /** A text's size reads only the width it may take: it wraps to it, and a height bound never changes
+     *  the lines (a box that is too short cuts them, it does not reflow them). */
+    sizeInputs(constraints) {
+        return BoxConstraints.loose(constraints.maxWidth, Infinity);
+    }
+    computeSize(constraints, ctx) {
+        this.resolveStyle(ctx);
+        const content = this.display(ctx.metrics);
+        const width = constraints.hasBoundedWidth
+            ? constraints.maxWidth
+            : this.naturalWidth(ctx.metrics);
+        return { width, height: this.measuredHeight(ctx.metrics, width, content) };
+    }
+    measuredHeight(metrics, width, content) {
+        return textHeight(content, this.segmentDefaults(), width, metrics, this.maxLines, this.overflow, this.lineHeight);
     }
     /** The unwrapped single-line width of the content (used when width is unbounded, e.g. inside a Row).
-     *  Must match the LINE-BREAKER's one-line measure EXACTLY - not just algebraically but BIT-for-bit,
-     *  so a text laid out at this width never re-wraps inside its own natural-width box. The breaker
-     *  accumulates `currentWidth += wordWidth + spaceWidth`, grouping the word and its trailing space
-     *  into one term; we must group the same way. Adding word and space as two separate steps is
-     *  algebraically equal but, because floating-point addition is not associative, drifts by a sub-ULP
-     *  - enough to tip a borderline string (e.g. "20 Jun 2026", wider than "04 Jul 2026" only because
-     *  'n' beats 'l') one bit over its own width, dropping the last word onto a second line. */
+     *  Must match the breaker's one-line sum BIT for bit - it adds `width + (space + word)`, and the same
+     *  numbers grouped differently drift by a sub-ULP, enough to wrap a text inside its own natural-width
+     *  box. `singleLineWidth` is that sum. */
     naturalWidth(metrics) {
         // The breaker's own sum, to the last bit - see `singleLineWidth`.
-        const oneLine = (text, family, size, style, letterSpacing) => singleLineWidth(text, { fontFamily: family, fontSize: size, fontStyle: style }, metrics, letterSpacing, this.wordSpacing);
+        const oneLine = (text, family, size, style, letterSpacing) => singleLineWidth(text, 
+        // `ligatures` is part of the font: it decides which glyphs are drawn, hence the width.
+        { fontFamily: family, fontSize: size, fontStyle: style, ligatures: this.ligatures }, metrics, letterSpacing, this.wordSpacing);
         // The FIRST line starts `textIndent` in, so an unbounded box has to be that much wider.
         const indent = Math.max(0, this.textIndent);
-        const content = this.display(metrics);
-        if (typeof content === "string") {
-            return (indent +
-                oneLine(content, this.fontFamily, this.fontSize, this.fontStyle, this.letterSpacing));
-        }
-        return content.reduce((sum, seg) => sum +
+        return this.display(metrics).reduce((sum, seg) => sum +
             oneLine(seg.content, seg.fontFamily ?? this.fontFamily, seg.fontSize ?? this.fontSize, seg.fontStyle ?? this.fontStyle, seg.letterSpacing ?? this.letterSpacing), indent);
     }
     /**
@@ -317,14 +359,12 @@ export class TextElement extends SizedPDFElement {
                 fontStyle: style,
                 ligatures: this.ligatures,
             };
-            // Split on the same boundaries the breaker uses - a hard break ends a line too.
-            const pieces = this.breakWord || this.hyphenate ? [...text] : text.split(/[ \n]/);
+            // Split on the same boundaries the breaker uses - a hard break ends a line too, and so may a
+            // hyphen inside a word.
+            const pieces = this.breakWord || this.hyphenate ? [...text] : text.split(/[ \n]/).flatMap(hyphenPieces);
             return pieces.reduce((max, piece) => Math.max(max, runAdvance(metrics, piece, font, letterSpacing)), 0);
         };
         const content = this.display(metrics);
-        if (typeof content === "string") {
-            return widest(content, this.fontFamily, this.fontSize, this.fontStyle, this.letterSpacing);
-        }
         // Segments join without a space, so a word may straddle two of them; taking the widest piece per
         // segment can therefore UNDER-estimate. That errs towards squeezing a little too far, which lands
         // back on the old overflow behaviour rather than on something new.
@@ -340,7 +380,11 @@ export class TextElement extends SizedPDFElement {
             fontFamily: this.fontFamily,
             fontStyle: this.fontStyle,
             color: this.color,
-            content: this.resolved ?? this.content,
+            content: this.content,
+            /** The content as it is measured and drawn: spans, recased, split by font, drawable glyphs only. */
+            spans: this.resolved ?? this.display(),
+            /** How the text is broken - the settings it is measured with, so drawing breaks it the same. */
+            breaking: this.segmentDefaults(),
             textAlignment: this.textAlignment,
             maxLines: this.maxLines,
             orphans: this.orphans,
@@ -358,6 +402,7 @@ export class TextElement extends SizedPDFElement {
             ligatures: this.ligatures,
             hyphenate: this.hyphenate,
             role: this.role,
+            shownLines: this.shownLines,
         };
     }
 }

package/dist/forms/acroform.d.ts

@@ -19,6 +19,14 @@ export declare class AcroFormCollector {
     /** The size to draw a value at. A field may ask for `0` - the PDF convention for "auto-size"; we then
      *  fit the capitals comfortably inside the box, which is what a viewer's auto-size does. */
     private drawSize;
+    /**
+     * The font a field's baked appearance draws its text in: the font the field inherits when it is
+     * EMBEDDED, else the standard Helvetica. PDF/A and PDF/UA require every font that draws to be
+     * embedded, and a document that embeds its fonts means that. The /DA keeps naming Helvetica - it is
+     * what a viewer redraws with once someone types, and a subset font could not draw the new characters.
+     * Measuring and drawing both take the font from here.
+     */
+    private faceFont;
     /** Measure one line for the appearance generator. */
     private line;
     /** Bake a text field's value into an appearance stream; returns the XObject number. */
@@ -47,7 +55,7 @@ export declare class AcroFormCollector {
     private claimName;
     /** Emit the widget object for one form-field IR node, register it as a field, and return its object
      *  number so the PageRenderer can add it to that page's /Annots. */
-    addField(node: FormFieldNode, om: PDFObjectManager): number;
+    addField(node: FormFieldNode, om: PDFObjectManager, structParent?: number): number;
     /** A push button (/Btn, Pushbutton flag): no value, an optional action, and a baked caption. The
      *  caption is measured here (the appearance module stays free of font metrics) and drawn into an
      *  appearance stream that carries its own font resource. */

package/dist/forms/acroform.js

@@ -1,5 +1,6 @@
+import { coverText } from "../text/glyph-coverage.js";
 import { NORMAL_STYLE, escName, num2, pdfColor } from "./pdf.js";
-import { checkboxOff, checkboxOn, listBoxFace, pushButtonFace, radioOff, radioOn, signatureFace, fieldDrawSize, textFieldFace, wrapFieldValue, } from "./appearance.js";
+import { HELV, checkboxOff, checkboxOn, listBoxFace, pushButtonFace, radioOff, radioOn, signatureFace, fieldDrawSize, textFieldFace, wrapFieldValue, } from "./appearance.js";
 // AcroForm field flags (/Ff), by 1-based bit position per the PDF spec.
 const FF_READ_ONLY = 1 << 0; // bit 1
 const FF_REQUIRED = 1 << 1; // bit 2: must be filled in before the form is submitted
@@ -28,8 +29,12 @@ function boxChrome(node, extraMK = "") {
         out += ` /BS << /W ${num2(style.borderWidth)} /S /S >>`;
     return out;
 }
-/** The annotation flags (/F). Bit 2 = Hidden, bit 3 = Print. A widget prints by default; `hidden`
- *  removes it from screen AND print, `print: false` keeps it on screen only. */
+/** A widget in the structure tree (accessible tagging) names its slot in the ParentTree. */
+function withStructParent(dict, structParent) {
+    return structParent === undefined
+        ? dict
+        : dict.replace(/^<< /, `<< /StructParent ${structParent} `);
+}
 function annotFlags(f) {
     if (f.hidden)
         return 2;
@@ -162,9 +167,9 @@ function actionDict(a, om) {
         case "submit":
             // /Flags 4 = ExportFormat: post the field values as HTML form data rather than FDF, which is what
             // an ordinary web endpoint expects.
-            return `/A << /S /SubmitForm /F << /FS /URL /F ${om.pdfString(a.url)} >> /Flags 4 >>`;
+            return `/A << /S /SubmitForm /F << /FS /URL /F ${om.pdfUri(a.url)} >> /Flags 4 >>`;
         case "url":
-            return `/A << /S /URI /URI ${om.pdfString(a.url)} >>`;
+            return `/A << /S /URI /URI ${om.pdfUri(a.url)} >>`;
     }
 }
 /**
@@ -196,27 +201,66 @@ export class AcroFormCollector {
     drawSize(style, height, capHeight) {
         return fieldDrawSize(style.fontSize, height, style.borderWidth, capHeight);
     }
+    /**
+     * The font a field's baked appearance draws its text in: the font the field inherits when it is
+     * EMBEDDED, else the standard Helvetica. PDF/A and PDF/UA require every font that draws to be
+     * embedded, and a document that embeds its fonts means that. The /DA keeps naming Helvetica - it is
+     * what a viewer redraws with once someone types, and a subset font could not draw the new characters.
+     * Measuring and drawing both take the font from here.
+     */
+    faceFont(node, om) {
+        const inherited = node.font;
+        if (inherited && om.isCustomFont(inherited.family, inherited.style)) {
+            const { family, style } = inherited;
+            const resource = om.getCustomFontResource(family, style);
+            return {
+                family,
+                style,
+                // Drawn SHAPED (ligatures, joining forms) - the shaping `getStringWidth` measures with.
+                face: {
+                    res: `F${resource.fontIndex}`,
+                    encode: (text) => `<${om.encodeCustomText(family, text, style)}>`,
+                },
+                resources: `/Font << /F${resource.fontIndex} ${resource.resourceIndex} 0 R >>`,
+                // A glyph the font lacks would draw as .notdef, which PDF/A forbids.
+                cover: (text) => {
+                    const { text: drawable, dropped } = coverText(text, family, style, om, false);
+                    if (dropped.length > 0)
+                        om.reportMissingGlyph?.(dropped);
+                    return drawable;
+                },
+            };
+        }
+        return {
+            family: "Helvetica",
+            style: NORMAL_STYLE,
+            face: HELV,
+            resources: `/Font << /Helv ${this.helv(om)} 0 R >>`,
+            cover: (text) => text,
+        };
+    }
     /** Measure one line for the appearance generator. */
-    line(om, text, size) {
-        return { text, width: om.getStringWidth(text, "Helvetica", size, NORMAL_STYLE) };
+    line(om, font, text, size) {
+        return { text, width: om.getStringWidth(text, font.family, size, font.style) };
     }
     /** Bake a text field's value into an appearance stream; returns the XObject number. */
     bakeText(node, om) {
         const f = node.field;
         if (f.kind !== "text")
             throw new Error("bakeText: not a text field");
-        const { capHeight } = om.getFontDecoration("Helvetica", NORMAL_STYLE);
+        const font = this.faceFont(node, om);
+        const { capHeight } = om.getFontDecoration(font.family, font.style);
         const size = this.drawSize(node.style, node.height, capHeight);
         // A password field shows the mask, never the characters - the value still lives in /V.
-        const value = f.password ? "•".repeat([...(f.value ?? "")].length) : (f.value ?? "");
+        const value = font.cover(f.password ? "•".repeat([...(f.value ?? "")].length) : (f.value ?? ""));
         const innerWidth = Math.max(1, node.width - 2 * (2 + node.style.borderWidth));
         let lines = [];
         if (value) {
-            const texts = wrapFieldValue(value, "Helvetica", size, NORMAL_STYLE, innerWidth, om, f.multiline ?? false);
-            lines = texts.map((t) => this.line(om, t, size));
+            const texts = wrapFieldValue(value, font.family, size, font.style, innerWidth, om, f.multiline ?? false);
+            lines = texts.map((t) => this.line(om, font, t, size));
         }
-        const face = textFieldFace(node.width, node.height, node.style, lines, capHeight, size, "Helv", f.multiline ?? false, f.align);
-        return om.addFormXObject(`[0 0 ${num2(node.width)} ${num2(node.height)}]`, face, `/Font << /Helv ${this.helv(om)} 0 R >>`);
+        const face = textFieldFace(node.width, node.height, node.style, lines, capHeight, size, font.face, f.multiline ?? false, f.align);
+        return om.addFormXObject(`[0 0 ${num2(node.width)} ${num2(node.height)}]`, face, font.resources);
     }
     /** Bake a choice field: a combo shows its current value on one line, a list box shows its options
      *  with the selected rows highlighted. */
@@ -224,24 +268,27 @@ export class AcroFormCollector {
         const f = node.field;
         if (f.kind !== "choice")
             throw new Error("bakeChoice: not a choice");
-        const { capHeight } = om.getFontDecoration("Helvetica", NORMAL_STYLE);
+        const font = this.faceFont(node, om);
+        const { capHeight } = om.getFontDecoration(font.family, font.style);
         const size = this.drawSize(node.style, node.height, capHeight);
         const shown = (v) => f.options.find((o) => o.value === v)?.label ?? v;
         const chosen = choiceSelection(f);
         const selected = new Set(chosen);
         let face;
         if (f.combo) {
-            const current = chosen.length ? [this.line(om, shown(chosen[0]), size)] : [];
-            face = textFieldFace(node.width, node.height, node.style, current, capHeight, size, "Helv", false, f.align);
+            const current = chosen.length
+                ? [this.line(om, font, font.cover(shown(chosen[0])), size)]
+                : [];
+            face = textFieldFace(node.width, node.height, node.style, current, capHeight, size, font.face, false, f.align);
         }
         else {
             const rows = f.options.map((o) => ({
-                ...this.line(om, o.label ?? o.value, size),
+                ...this.line(om, font, font.cover(o.label ?? o.value), size),
                 selected: selected.has(o.value),
             }));
-            face = listBoxFace(node.width, node.height, node.style, rows, capHeight, size, "Helv", f.align);
+            face = listBoxFace(node.width, node.height, node.style, rows, capHeight, size, font.face, f.align);
         }
-        return om.addFormXObject(`[0 0 ${num2(node.width)} ${num2(node.height)}]`, face, `/Font << /Helv ${this.helv(om)} 0 R >>`);
+        return om.addFormXObject(`[0 0 ${num2(node.width)} ${num2(node.height)}]`, face, font.resources);
     }
     get isEmpty() {
         return this.fieldRefs.length === 0;
@@ -278,9 +325,9 @@ export class AcroFormCollector {
     }
     /** Emit the widget object for one form-field IR node, register it as a field, and return its object
      *  number so the PageRenderer can add it to that page's /Annots. */
-    addField(node, om) {
+    addField(node, om, structParent) {
         if (node.field.kind === "radio")
-            return this.addRadio(node, om);
+            return this.addRadio(node, om, structParent);
         this.claimName(node.field.name, node.field.kind);
         let dict;
         if (node.field.kind === "checkbox") {
@@ -307,7 +354,7 @@ export class AcroFormCollector {
             if (!this.bake)
                 this.needAppearances = true;
         }
-        const objNum = om.addObject(dict);
+        const objNum = om.addObject(withStructParent(dict, structParent));
         this.fieldRefs.push(objNum);
         return objNum;
     }
@@ -318,13 +365,15 @@ export class AcroFormCollector {
         const f = node.field;
         if (f.kind !== "pushbutton")
             throw new Error("buildPushButtonWidget: not a push button");
-        const { capHeight } = om.getFontDecoration("Helvetica", NORMAL_STYLE);
+        const font = this.faceFont(node, om);
+        const { capHeight } = om.getFontDecoration(font.family, font.style);
         // `fontSize: 0` means auto-size, here as everywhere: resolve it before measuring or drawing.
         const size = this.drawSize(node.style, node.height, capHeight);
-        const width = om.getStringWidth(f.label, "Helvetica", size, NORMAL_STYLE);
-        const fontNum = this.helv(om);
-        const face = pushButtonFace(node.width, node.height, node.style, f.label, width, capHeight, "Helv", size);
-        const apRef = om.addFormXObject(`[0 0 ${num2(node.width)} ${num2(node.height)}]`, face, `/Font << /Helv ${fontNum} 0 R >>`);
+        const caption = font.cover(f.label);
+        const width = om.getStringWidth(caption, font.family, size, font.style);
+        this.helv(om); // the /DA below names it
+        const face = pushButtonFace(node.width, node.height, node.style, caption, width, capHeight, font.face, size);
+        const apRef = om.addFormXObject(`[0 0 ${num2(node.width)} ${num2(node.height)}]`, face, font.resources);
         const parts = [`/Type /Annot /Subtype /Widget /FT /Btn`, `/T ${om.pdfString(f.name)}`];
         if (f.tooltip !== undefined)
             parts.push(`/TU ${om.pdfString(f.tooltip)}`);
@@ -343,7 +392,7 @@ export class AcroFormCollector {
     /** A radio button: one KID widget of its group's shared field. The group field is reserved on first
      *  sight (and added to /Fields); each button adds itself to that field's /Kids. Returns the kid widget
      *  number, which goes into the PAGE /Annots (the parent field does not). */
-    addRadio(node, om) {
+    addRadio(node, om, structParent) {
         const f = node.field;
         if (f.kind !== "radio")
             throw new Error("addRadio: not a radio");
@@ -375,7 +424,7 @@ export class AcroFormCollector {
             `/AS /${escName(as)}`,
             `/DA ${om.pdfString(`/ZaDb 0 Tf ${pdfColor(node.style.color)} rg`)}`,
         ];
-        const kidNum = om.addObject(`<< ${parts.join(" ")}${boxChrome(node)} >>`);
+        const kidNum = om.addObject(withStructParent(`<< ${parts.join(" ")}${boxChrome(node)} >>`, structParent));
         g.kids.push(kidNum);
         return kidNum;
     }
@@ -386,12 +435,12 @@ export class AcroFormCollector {
         if (f.kind !== "signature")
             throw new Error("buildSignatureWidget: not a signature");
         this.hasSignature = true;
-        const label = f.label ?? "";
-        const { capHeight } = om.getFontDecoration("Helvetica", NORMAL_STYLE);
+        const font = this.faceFont(node, om);
+        const label = font.cover(f.label ?? "");
+        const { capHeight } = om.getFontDecoration(font.family, font.style);
         const size = this.drawSize(node.style, node.height, capHeight);
-        const labelWidth = label ? om.getStringWidth(label, "Helvetica", size, NORMAL_STYLE) : 0;
-        const fontNum = this.helv(om);
-        const apRef = om.addFormXObject(`[0 0 ${num2(node.width)} ${num2(node.height)}]`, signatureFace(node.width, node.height, node.style, label, labelWidth, "Helv", size), `/Font << /Helv ${fontNum} 0 R >>`);
+        const labelWidth = label ? om.getStringWidth(label, font.family, size, font.style) : 0;
+        const apRef = om.addFormXObject(`[0 0 ${num2(node.width)} ${num2(node.height)}]`, signatureFace(node.width, node.height, node.style, label, labelWidth, font.face, size), font.resources);
         const parts = [`/Type /Annot /Subtype /Widget /FT /Sig`, `/T ${om.pdfString(f.name)}`];
         if (f.tooltip !== undefined)
             parts.push(`/TU ${om.pdfString(f.tooltip)}`);