@peripheries/renderer 0.17.0 → 0.20.0

package/dist/types/print/print-layout.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Writing the pagination decision back as CSS, so the browser breaks where the
+ * host decided.
+ *
+ * ── The gap this closes ─────────────────────────────────────────────────────
+ *
+ * The host has been able to say where pages should break for a while:
+ * `collectBlocks` measures the document's rows, `paginate` assigns them to
+ * pages, and the result reconciles exactly against the measured height. None of
+ * it reached the paper. Layout mode *drew* the breaks; Chrome went on choosing
+ * its own from `break-inside` alone.
+ *
+ * The owner, three times, in their own words: the layout button should switch to
+ * a mode that **adjusts the breaks, not just shows them**, and the result should
+ * be what prints. Each time I answered with a better instrument. The step I had
+ * not taken is this one, and it is small: emit `break-before: page` on the first
+ * row of every page, and the browser's choices become the host's choices.
+ *
+ * ── Why a stylesheet and not inline styles ─────────────────────────────────
+ *
+ * The element that must carry the break is the cell's grid item, and
+ * `CellRenderer` writes that element's `style` attribute itself
+ * (`grid-column`, `break-inside`, `position`, `container`). Mutating it from an
+ * effect means racing React for the same attribute: it wins on the next render
+ * and the breaks vanish with no error. It is also the exact defect that defeated
+ * the bundle's cover fix — an inline style no author rule could beat.
+ *
+ * So the decision becomes a `<style>` element. React does not manage it, a
+ * re-render cannot clobber it, and it is part of the document that gets printed.
+ *
+ * `:has(> [data-cell-id="x"])` selects that grid item without needing a class on
+ * it, because the item is exactly *the parent of the cell* and CSS has no parent
+ * combinator otherwise. Chrome has supported `:has()` since 105; this route is
+ * Chrome-only in practice (it is what prints and what a render service drives).
+ *
+ * `!important` throughout, and not as a reflex: the grid item's own inline
+ * `break-inside: avoid` would otherwise outrank a `break-before` rule in the
+ * cascade, and an inline `height` on a scaled row would outrank the height that
+ * makes the scale add up.
+ *
+ * ── Resizing, which is the owner's other requirement ───────────────────────
+ *
+ * *"If it's not a text component or something that can be split across pages
+ * and still look good then we need to figure out how to resize the component to
+ * fit a page."*
+ *
+ * A row taller than a whole page is scaled by `k = pageHeight / rowHeight`. The
+ * row's box is shortened to `k × height` and its contents scaled from the top
+ * left, so the visual geometry is preserved exactly and the layout box shrinks
+ * with it. This is what print engines have always done with an oversized figure.
+ *
+ * **There is a floor.** Below it, type stops being readable and a shrunk
+ * component is a worse outcome than a reported one — the honest answer there is
+ * that the component needs a print variant from its owner. A silently
+ * illegible page is the failure this whole thread keeps producing in other
+ * forms: something that looks finished and misleads.
+ *
+ * ── What this still does NOT do ────────────────────────────────────────────
+ *
+ * It does not verify that Chrome honours the breaks. Nothing available here can:
+ * `@media print` is inert outside printing, there is no print emulation, and no
+ * PDF has been opened by anyone but the owner. The rules are asserted to be
+ * *emitted and correct*; whether the paper agrees is one look away and has not
+ * been taken.
+ */
+import type { Band } from './page-map.js';
+import type { PageMap } from './paginate.js';
+import { type SectionMarker } from './running-header.js';
+export interface PrintLayoutOptions {
+    /** Usable page height in CSS px — the sheet minus its top and bottom margins. */
+    textBlockPx: number;
+    /**
+     * Also emit a `@media screen` block that separates the pages visually.
+     *
+     * On by default. Without it the print view is a single long column on screen
+     * that breaks correctly on paper — which is precisely the disconnect this
+     * whole feature exists to remove: *"the layout button would switch to a
+     * layout mode that adjusts the breaks not just shows them"*. If the screen
+     * cannot show the pages, the mode is still only telling you about them.
+     *
+     * Screen-only, and that scoping is load-bearing: the separation is margin,
+     * and margin on paper would shift every subsequent break — the layout would
+     * be wrong in exactly the way it is being fixed.
+     */
+    screenSeparators?: boolean;
+    /**
+     * Smallest scale a row may be shrunk to before it is refused instead.
+     *
+     * 0.6 by default: a 12px label becomes 7.2px, which is about the floor of
+     * comfortable print. Below that, shrinking produces a page nobody can read
+     * and hides the problem from the person who could fix it.
+     */
+    scaleFloor?: number;
+    /**
+     * What a deliberate blank page says. Default is the printer's convention.
+     *
+     * A blank sheet with nothing on it reads as a printing fault, and the reader
+     * concluding that is the failure this text exists to prevent.
+     */
+    blankPageNotice?: string;
+    /**
+     * The `[data-cell-id]` element IS the fragmentation box (the host's cell frame, which is the grid
+     * item), rather than the box's only child (the PWA's `.cell-renderer`). Rules then target the
+     * frame, and a scale shrinks the frame's children.
+     */
+    cellIsBox?: boolean;
+    /**
+     * Emit per-page running headers and footers.
+     *
+     * `slots` places a running slot name at a margin-box position, in the same
+     * `region -> side` shape a document profile uses. `markers` are the section
+     * headings, resolved from the rendered document by the caller.
+     *
+     * Absent means no running content, which is the state of every document that
+     * has not asked for one.
+     */
+    running?: {
+        slots: RunningSlotPlacement[];
+        markers: readonly SectionMarker[];
+        /** `' (continued)'` by default. */
+        continuedSuffix?: string;
+        /** Font and colour for the margin boxes, matching `buildPageStylesheet`. */
+        marginFont?: string;
+        marginColor?: string;
+    };
+}
+/** Where a running slot goes: which margin box, and which slot fills it. */
+export interface RunningSlotPlacement {
+    edge: 'top' | 'bottom';
+    side: 'left' | 'center' | 'right';
+    /** `section-title` or `section-title-continued`. */
+    slot: string;
+}
+export interface ScaledRow {
+    /** The band id — member cell ids joined by `+`. */
+    id: string;
+    heightPx: number;
+    /** The factor applied. Always < 1. */
+    scale: number;
+    scaledHeightPx: number;
+}
+export interface RefusedRow {
+    id: string;
+    heightPx: number;
+    /** The scale it would have needed. Below the floor. */
+    requiredScale: number;
+}
+export interface PrintLayout {
+    /**
+     * The stylesheet to put in the document. Empty string when there is nothing
+     * to say.
+     *
+     * Contains both the print typesetting and a `@media screen` block that makes
+     * the same page boundaries VISIBLE on screen — see `screenSeparators`.
+     */
+    css: string;
+    /** Rows that will be broken to a fresh page, in page order. Excludes page 1. */
+    pageStartCellIds: string[];
+    scaled: ScaledRow[];
+    /** Too tall to scale within the floor — these need a print variant. */
+    refused: RefusedRow[];
+    /** Per-page running content, for a consumer that wants to show it. */
+    runningByPage: Array<{
+        page: number;
+        sectionTitle?: string;
+        continued: boolean;
+    }>;
+    /** Rows given the whole sheet as their box, in page order. */
+    fullPageCellIds: string[];
+    /** Rows that carry a deliberate blank page before them, in page order. */
+    blankPageBeforeCellIds: string[];
+    /**
+     * How far below such a row's box top its own content begins, on screen.
+     *
+     * Published rather than re-derived: the hover affordances are positioned
+     * against the box and would otherwise be drawn on top of the blank page —
+     * the owner's *"there are no options that show up on hover"*. They were
+     * there, a page above where anyone would look.
+     */
+    blankPageScreenOffsetPx: number;
+    /**
+     * How much taller `css` makes the document on SCREEN.
+     *
+     * Two contributions: the page separators, which are margin, border and
+     * padding and therefore real height; and the floor put under a full-page row,
+     * which grows its box to the sheet.
+     *
+     * A caller that re-measures the document after applying this stylesheet must
+     * add this back, or it will conclude the document changed when only the
+     * stylesheet did — see `map-staleness.ts` for what that cost.
+     */
+    screenExtraPx: number;
+}
+/** What one separator adds to the document's screen height. */
+/**
+ * What the line BELOW a blank page adds on screen — margin plus border.
+ *
+ * No padding: `box-sizing: border-box` would absorb it into the blank page's
+ * own height instead of adding to it, so counting it would overstate the
+ * document by 16px per blank page and re-open the staleness oscillation.
+ */
+export declare const BLANK_PAGE_SEPARATOR_PX: number;
+export declare const SEPARATOR_TOTAL_PX: number;
+/**
+ * Turn a page map into the CSS that makes it real.
+ *
+ * @param map   From `paginate`, at the same geometry as `options.textBlockPx`.
+ * @param bands From `collectBlocks`, so a band id can be resolved to the cell
+ *              whose box carries the rule. The map alone cannot do this: its
+ *              block ids are joined band ids, and the selector needs one member.
+ */
+export declare function buildPrintLayout(map: PageMap, bands: readonly Band[], { textBlockPx, scaleFloor, screenSeparators, running, blankPageNotice, cellIsBox }: PrintLayoutOptions): PrintLayout;

package/dist/types/print/print-lint.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Pagination rule 08, as the check the specification asks it to be.
+ *
+ * `Document System.pdf` p11, rule 08: *"No element is positioned fixed, and no
+ * length is in viewport units"* — annotated `lint rule`, the only one of the
+ * eight the spec describes as a check rather than as a CSS property. Its
+ * reason: *"Fixed elements stamp every sheet and viewport units mis-size at
+ * print."*
+ *
+ * ── The two halves need two different sources, and that is the whole point ──
+ *
+ * `position: fixed` is visible in computed style. `fixed` is never what an
+ * element resolves to for free, so reading it back is sound.
+ *
+ * **Viewport units are NOT visible in computed style, and this is the same
+ * defect that hid `break-inside` for a fortnight**. `max-height:
+ * 100vh` computes to `806px` — a resolved value with no trace of how it was
+ * written. A check that read computed style would find zero violations on a
+ * document full of them and report a clean bill.
+ *
+ * It is not hypothetical here either. `max-height: 100vh` on the bundle's cover plate
+ * is exactly why the cover printed as a small card in the top third of an empty
+ * sheet, and `806` — the number I chased for an afternoon — was my
+ * own `innerHeight` resolved into the cascade.
+ *
+ * So viewport units are found by reading the DECLARED text of the stylesheets
+ * and the inline `style` attributes. Nothing else can see them.
+ *
+ * ── Why this reports rather than fixes ─────────────────────────────────────
+ *
+ * Most violations will be in a component repo's components, which are not this repo's to
+ * edit. The deliverable for a cross-repo defect is a precise list — selector,
+ * property, declared value — that the owner can act on. A host that silently
+ * rewrote another repo's CSS would be worse than the bug.
+ */
+/** One rule-08 violation, named precisely enough for its owner to find it. */
+export interface PrintLintViolation {
+    rule: 'position-fixed' | 'viewport-unit';
+    /** A CSS selector, or a `[data-cell-id]` for an element found in the DOM. */
+    where: string;
+    /** `position` for the first rule; the offending property for the second. */
+    property: string;
+    /** The DECLARED value — `100vh`, not the `806px` it resolved to. */
+    value: string;
+}
+/**
+ * Scan declared CSS text for viewport units.
+ *
+ * Exported for its own tests, and because the stylesheet walk that feeds it is
+ * inherently untestable without a browser — the parsing is where the mistakes
+ * live, so the parsing is what gets tested directly.
+ */
+export declare function viewportUnitsIn(cssText: string, where: string): PrintLintViolation[];
+/**
+ * Can a rule under this media condition reach PAPER?
+ *
+ * ── Why the question is about print, not about "the current media" ─────────
+ *
+ * A review found this check media-blind: it walked `CSSMediaRule` children
+ * happily, so a rule that cannot apply reported identically to one that does.
+ * That finding is right and this is the fix — but the fix is NOT to filter to
+ * the media the browser is currently in, which is what a first reading suggests.
+ *
+ * The print route renders in **screen** media. Filtering to the current media
+ * would discard everything inside `@media print` — and a viewport unit inside
+ * `@media print` is not the harmless case, it is **the dangerous one**. It is
+ * the declaration that is guaranteed to be live at exactly the moment rule 08
+ * is about it: *"viewport units mis-size at print."*
+ *
+ * On the specific case that prompted this: the bundle's
+ * `.cover-solo .cover-plate { max-height: 100vh }` was print-only. Under
+ * "current media" it is a false positive. Under "reaches paper" it is the single
+ * most reportable declaration in the sheet. FEC removed it for a better reason
+ * than either — the plate's 17/22 ratio resolves to 851px against a 946px page,
+ * so the backstop could never fire — but the lint rule matters beyond that one
+ * declaration.
+ *
+ * So: **screen-only is skipped; everything else is kept.** Conservative in the
+ * direction that matters, since a false positive is reviewable and a silent
+ * drop is not.
+ *
+ * Deliberately textual rather than `window.matchMedia`, which evaluates against
+ * the browser's CURRENT media and would answer the wrong question confidently.
+ */
+export declare function mediaReachesPrint(condition: string | null | undefined): boolean;
+export interface PrintLintOptions {
+    /** Resolve an element's computed style. Injected — jsdom has no layout. */
+    computedStyle: (el: Element) => {
+        position?: string;
+    };
+    /**
+     * The CSS rules that APPLY to this document, as `[label, declarations]`.
+     *
+     * Text rather than `CSSStyleSheet` objects because a cross-origin sheet
+     * throws on `.cssRules` with no way to ask first, and because flattening a
+     * whole sheet to text destroys the at-rule nesting a caller has to walk
+     * anyway.
+     *
+     * ── "APPLY" is load-bearing, and it cost a wrong number ────────────────────
+     *
+     * The first version took whole stylesheets. Run against the real document it
+     * reported **42** violations; **40** of them were Tailwind utility classes
+     * (`h-[85vh]`, `h-screen`, `100dvh` under an `@supports`) sitting unused in
+     * the host's global chunk. The document's actual count was **two**.
+     *
+     * Forty false positives do not read as noise — they read as a document in
+     * serious trouble, and they would have been handed to FEC as a list to fix.
+     * A wrongly-scoped measurement reads as PRECISE rather than as wrong, which
+     * is the fourth time that has happened on this project.
+     *
+     * So the caller filters to rules that match something under `root` — it has
+     * the DOM and can ask `root.querySelector(selectorText)`, which this pure
+     * function cannot. A rule that matches nothing cannot mis-size anything.
+     */
+    rules: ReadonlyArray<readonly [string, string]>;
+}
+/**
+ * Audit a rendered document against rule 08.
+ *
+ * Returns violations in the order found, most-specific label first. An empty
+ * array means the document conforms — and unlike a computed-style check, that
+ * emptiness is load-bearing rather than structural.
+ */
+export declare function auditPrintLint(root: Element | null, { computedStyle, rules }: PrintLintOptions): PrintLintViolation[];

package/dist/types/print/print-policy.d.ts

@@ -0,0 +1,210 @@
+/**
+ * `@printPolicy` — parsing, composition, and the CSS it becomes.
+ *
+ * FEC declares a component's paper behaviour as a JSDoc tag; their
+ * `scripts/check-print-policy.mts` proves each key against the CSS the
+ * component actually emits, and the values reach us on
+ * `ComponentDeclaration.print_policy`. This is the host half: read them,
+ * compose them down a nesting chain, and emit the styles.
+ *
+ * Grammar and composition rules from the document-components contract (v1).
+ *
+ * ── Two classes of key, and only one of them composes ───────────────────────
+ *
+ * **Constraints** answer *"how may this break"*. They are monotonic: a child may
+ * tighten what its parent permits and never loosen it. `orphans`/`widows`
+ * compose as `max`, which is that same rule on a threshold instead of an enum.
+ *
+ * **With one exception, added 2026-09-03: a FORCED break.**
+ * `breakAfter: 'page'` is an instruction at a point, not a property of a
+ * subtree, and it is not monotonic — it does not tighten an ancestor's `avoid`,
+ * it contradicts it. CSS Fragmentation §3.2 settles the conflict in favour of
+ * the forced break, and `composeConstraints` follows CSS rather than inventing
+ * a rule, because CSS is what actually decides it on paper.
+ *
+ * It lives on the constraint keys anyway, because CSS models prohibition and
+ * instruction as one property with both values in its domain. A third class
+ * here would read cleaner and disagree with the enforcer.
+ *
+ * **Placements** answer *"where does this render"*. They do NOT compose, and
+ * applying the constraint rule to them returns a confident wrong answer —
+ * FEC's words. `region: page-footer` lifts an element out of its parent
+ * entirely, so the parent's atomicity has nothing to say about it.
+ * `display: none` is monotonic in the OPPOSITE direction: a hidden parent
+ * removes the subtree and a visible child cannot un-hide itself.
+ *
+ * That distinction is the whole reason this file has two functions instead of
+ * one, and it is a known failure in miniature — a sound rule applied to a set it was
+ * not written for.
+ *
+ * ── Values are strings on the wire, numerics included ───────────────────────
+ *
+ * `"3"`, not `3`. FEC offered to emit typed values; coercing here is one line,
+ * where changing their emitter is a shipped-contract change that would also
+ * strand every already-built bundle. So the coercion lives at this parser and
+ * `print_policy` stays `Record<string, string>` on the wire.
+ */
+export type BreakInside = 'avoid' | 'auto';
+/**
+ * A break edge is bivalent: a prohibition or an instruction.
+ *
+ * A review found that the grammar could only ever FORBID a break — every
+ * constraint key was `avoid`, `auto`, or a threshold — so `PageBreak`, the one
+ * component in the document bundle that exists solely to force a break, could not be
+ * described by the contract at all. Its whole implementation is
+ * `style={{ breakAfter: 'page' }}`, and this parser rejected that value as
+ * unrecognised.
+ *
+ * `page` is added here rather than deferred to the paginator because **CSS
+ * enforces it today**. `break-after: page` is honoured by Chromium in print
+ * with no host pagination whatsoever, so this reaches paper by the same path as
+ * `avoid` — `printPolicyToStyle` onto the cell wrapper. A key that only a
+ * future paginator could honour would be the declared-and-unread shape this
+ * whole effort exists to end.
+ */
+export type BreakEdge = 'avoid' | 'page';
+/** "How may this break." Monotonic — a child may only tighten. */
+export interface PrintConstraints {
+    breakInside?: BreakInside;
+    /**
+     * `avoid` prohibits a break; `page` FORCES one. Both live on this one key
+     * because CSS models them as one property (`break-after`) with both values in
+     * its domain, and splitting them would fight the enforcer. See
+     * `composeConstraints` for the precedence rule when they conflict.
+     */
+    breakAfter?: BreakEdge;
+    breakBefore?: BreakEdge;
+    orphans?: number;
+    widows?: number;
+    /** Never split, at any depth. Implemented in FEC's checker, declared by nothing yet. */
+    atomic?: boolean;
+}
+/** "Where does this render." Does NOT compose like a constraint. */
+export interface PrintPlacements {
+    /** Lift out of flow into the page's footer region, repeated per page. */
+    region?: 'page-footer';
+    /** Omit from paper entirely. */
+    display?: 'none';
+}
+export interface ParsedPrintPolicy {
+    constraints: PrintConstraints;
+    placements: PrintPlacements;
+    /**
+     * Keys or values this parser did not recognise, as `key=value` strings.
+     *
+     * **Reported, never silently dropped.** A tag FEC ships that the host quietly
+     * ignores is the exact failure `print_policy` spent a month in — declared on
+     * ten components and read by nothing. An unknown key means the vocabularies
+     * have diverged, and the only way that surfaces is if someone says so.
+     */
+    unrecognised: string[];
+}
+export declare function parsePrintPolicy(raw: Record<string, string> | null | undefined): ParsedPrintPolicy;
+/**
+ * Compose a chain of CONSTRAINTS, outermost first.
+ *
+ * A child may tighten and never loosen:
+ *   - `breakInside`: any `avoid` in the chain wins over every `auto`
+ *   - `breakAfter` / `breakBefore`: set by anyone, cleared by no one — and a
+ *     `page` (forced) beats an `avoid` in either order, per CSS Fragmentation
+ *     §3.2, which is what decides it on paper
+ *   - `orphans` / `widows`: `max`
+ *   - `atomic`: any `true` wins, and it also forces `breakInside: avoid`,
+ *     because "never split at any depth" is strictly stronger
+ *
+ * **Placements are deliberately absent from this function.** See the header —
+ * they answer a different question and composing them here would be wrong in
+ * two different directions at once.
+ */
+export declare function composeConstraints(chain: ReadonlyArray<PrintConstraints | undefined | null>): PrintConstraints;
+/**
+ * Resolve PLACEMENT down a chain, outermost first.
+ *
+ * Not a compose — a resolution, and the two keys resolve oppositely:
+ *   - `display: none` on ANY ancestor hides the subtree; a child cannot
+ *     un-hide itself, so the outermost `none` is absolute
+ *   - `region` belongs to the element that declares it. An ancestor's region
+ *     does not push a descendant into the footer, so the INNERMOST declaration
+ *     is the one that applies
+ *
+ * **Innermost-wins for `region` is inferred, not specified.** FEC said region
+ * *"belongs to the element that declares it"*, which settles the ancestor case
+ * but not two competing declarations — and with `page-footer` as the only legal
+ * value that case cannot arise, so no real data can distinguish it. Pinned by a
+ * cast in the tests so the rule survives a refactor; flag to FEC if a second
+ * region value is ever added.
+ */
+export declare function resolvePlacement(chain: ReadonlyArray<PrintPlacements | undefined | null>): PrintPlacements;
+/**
+ * The effective policy as print CSS.
+ *
+ * Emitted only where it says something: `breakInside: auto` is the CSS default,
+ * so writing it changes nothing and would make an unspecified element
+ * indistinguishable from a deliberately-splittable one in the DOM. FEC checks
+ * `auto` as a positive assertion for that same reason.
+ *
+ * `region: page-footer` is NOT handled here. Lifting an element into a `@page`
+ * margin box is a paginator operation, not a style — and Chromium does not
+ * implement GCPM `string()`, so the host resolves footer content to literals at
+ * build time (`print-stylesheet.ts`). Returning a style for it would look like
+ * support for something that does not work.
+ */
+export declare function printPolicyToStyle(constraints: PrintConstraints, placements?: PrintPlacements): Record<string, string | number>;
+/**
+ * The attribute the renderers stamp the DECLARED policy onto.
+ *
+ * ── Why the DOM needs this when it already carries the CSS ─────────────────
+ *
+ * Because CSS is lossy in exactly the place the packer reads it. Three
+ * declarations that mean different things arrive at `getComputedStyle` as one
+ * value:
+ *
+ *   a bundle declared `breakInside: 'auto'` -> computed `auto`
+ *   a bundle declared nothing at all        -> computed `auto`   (initial value)
+ *   nobody has ever considered the component -> computed `auto`
+ *
+ * `paginate`'s `mayNotSplit` treats an explicit `auto` as PERMISSION to split
+ * and absence as a prohibition — *"absence is not permission"*, its own header
+ * says — and the DOM had made that rule unachievable. Every band on a real
+ * document read back as splittable, including the 44 untagged components the
+ * conservative default exists for.
+ *
+ * `orphans`/`widows` are worse: their computed value is `2` in Chrome whether
+ * or not anyone said so, so `constraintsFromComputedStyle` had to drop them
+ * entirely — which is why the spec's pagination rule 05 (`orphans: 3;
+ * widows: 3`) could not be enforced no matter what a bundle declared.
+ *
+ * So the renderer, which HAS the declaration, writes it down. This is not a
+ * second resolution path: the same `parsePrintPolicy` output that becomes the
+ * style becomes the attribute, one line apart. The paginator reads the
+ * declaration where there is one and falls back to computed style where there
+ * is not, so a page rendered by anything else still paginates as before.
+ */
+export declare const PRINT_POLICY_ATTR = "data-oa-print-policy";
+/**
+ * Constraints as an attribute value: `breakAfter=avoid;orphans=3`.
+ *
+ * Key=value pairs rather than JSON because this is read in devtools far more
+ * often than by code, and a quoted-and-escaped object in an attribute is
+ * unreadable at exactly the moment someone is asking why a row broke.
+ *
+ * Deterministic key order, so a DOM diff shows a real change and not a
+ * reordering. Empty in, empty out — the caller omits the attribute rather than
+ * writing `""`, because an empty attribute is a declaration of nothing and
+ * would be indistinguishable from a declaration this parser failed to render.
+ */
+export declare function serializeConstraints(c: PrintConstraints | undefined | null): string;
+/**
+ * Read an attribute written by `serializeConstraints` back to constraints.
+ *
+ * **Routed through `parsePrintPolicy` on purpose.** A private parser here would
+ * be a second implementation of the grammar, free to drift from the one that
+ * validates FEC's tags — and the whole reason this attribute exists is that two
+ * representations of one fact with no shared reader diverge silently. Anything
+ * this function accepts, `parsePrintPolicy` accepted first.
+ *
+ * Returns `undefined` for absent, empty, or entirely-unrecognised input, which
+ * is what the packer needs: `undefined` means "no declaration", and that is a
+ * different state from "declared, and it permits nothing".
+ */
+export declare function deserializeConstraints(value: string | null | undefined): PrintConstraints | undefined;