@cardanvil/frame-kit 0.5.0 → 0.7.0

package/dist/schema/frame.js

@@ -1,28 +1,56 @@
 import { z } from "zod";
 import { AssetUrlSchema } from "./assetUrl.js";
+import { CollectorInfoLineSchema } from "./collectorInfo.js";
+import { RenderConditionSchema } from "./condition.js";
 import { FrameAssetsSchema, FrameColorEnum, LayoutMasksSchema, } from "./frameAssets.js";
 import { LayoutEnum } from "./layout.js";
+import { GradientSchema, HexColorSchema, SlidingBoxEnum, TintedImageSchema, } from "./paint.js";
 export const BoundsSchema = z.object({
     x: z.number(),
     y: z.number(),
     width: z.number(),
     height: z.number(),
 });
-export const TextBoxSchema = BoundsSchema.extend({
+const TextBoxFieldsSchema = BoundsSchema.extend({
     fontSize: z.number(),
     color: z.string().optional(),
     outlineColor: z.string().optional(),
     outlineWidth: z.number().optional(),
     verticalAlign: z.enum(["top", "center"]).optional(),
     textAlign: z.enum(["left", "center", "right"]).optional(),
+    /** Extra spacing between characters, in px (Konva `letterSpacing`),
+     * expressed at the box's own `fontSize` — each run scales it by its font
+     * size so it reads as constant tracking. Non-zero spacing switches Konva
+     * to per-character drawing with kerning off; the canvas measurement path
+     * mirrors that so measured widths match the render. */
+    letterSpacing: z.number().optional(),
     /** Per-box font family override. When set, the renderer uses this instead
      * of the language-resolved default (e.g. title font). */
     fontFamily: z.string().optional(),
     opacity: z.number().min(0).max(1).optional(),
-    /** Whether mana-cost symbols in this box get a drop-shadow. Defaults to
-     * true when omitted (matches the original behavior). Set to false to
-     * disable the shadow (e.g. flipside mana-cost badges on light backgrounds). */
+    /**
+     * Whether this box's content gets a drop-shadow.
+     *
+     * For symbol boxes (mana cost, and symbols embedded in rules/abilities
+     * text) this defaults to true when omitted, matching the original
+     * behavior — set to false to disable it (e.g. flipside mana-cost badges on
+     * light backgrounds).
+     *
+     * For plain-text boxes (title, type, P/T, etc., rendered via
+     * `buildOutlinedText`) there is no legacy default: omitting this leaves
+     * them exactly as before, and it only takes effect once set to true. It
+     * has no effect together with `outlineColor`/`outlineWidth` — an outline
+     * always wins.
+     */
     shadow: z.boolean().optional(),
+    /** Overrides the drop-shadow's default offset (in the box's own `fontSize`
+     * units, same convention as the default formula). Only meaningful when
+     * `shadow` is true. */
+    shadowOffsetX: z.number().optional(),
+    shadowOffsetY: z.number().optional(),
+    /** How far the drop-shadow is blurred, in px. Defaults to 0, a hard edge.
+     * Plain-text boxes only, and only meaningful when `shadow` is true. */
+    shadowBlur: z.number().nonnegative().optional(),
     /** Shaped-text mask: a full-canvas-sized PNG whose opaque pixels define the
      * region text in this box may occupy. Alpha is what matters (any pixel with
      * alpha > ~12% counts as inside), so color is irrelevant. Each wrapped line
@@ -35,17 +63,111 @@ export const TextBoxSchema = BoundsSchema.extend({
      * width. */
     mask: AssetUrlSchema.optional(),
 });
+/**
+ * One conditional restyle of a text box: when every condition in `when` holds
+ * for a render, `style` is merged over the box. A condition left out matches
+ * anything.
+ */
+export const TextBoxOverrideSchema = z.object({
+    when: RenderConditionSchema,
+    /**
+     * The fields to replace. Style only: parts of the app read box geometry
+     * without resolving overrides, so a conditional size or position would put
+     * them out of step with the render.
+     */
+    style: TextBoxFieldsSchema.pick({
+        color: true,
+        outlineColor: true,
+        outlineWidth: true,
+        shadow: true,
+        shadowOffsetX: true,
+        shadowOffsetY: true,
+        shadowBlur: true,
+        opacity: true,
+    }),
+});
+const textBoxSchema = TextBoxFieldsSchema.extend({
+    /**
+     * Conditional restyles, applied in order at render time — where two matches
+     * set the same field, the later one wins. This is how a box adapts to the
+     * border settings: the renderer never restyles text on its own. Text printed
+     * on the border ring wants `onBorderTextOverrides`, which
+     * `withCollectorInfoDefaults` gives collector info unless its bounds bring
+     * their own — `[]` for none.
+     */
+    overrides: z.array(TextBoxOverrideSchema).readonly().optional(),
+});
+export const TextBoxSchema = textBoxSchema;
+export const CollectorInfoBoxSchema = TextBoxSchema.extend({
+    /**
+     * What the collector box prints, top line first. The renderer draws the
+     * default two-line layout (`defaultCollectorInfoLines`) when this is left
+     * out; `withCollectorInfoDefaults` fills that same default in. Build one from
+     * scratch for a frame with its own collector line, or start from
+     * `retroCollectorInfoLines`.
+     */
+    lines: z.array(CollectorInfoLineSchema).readonly().optional(),
+});
+/**
+ * Where the set symbol goes. The symbol is fitted into the box, right-aligned
+ * and vertically centered. An outline is drawn around its silhouette only when
+ * both `outlineColor` and `outlineWidth` are set, centered on the edge like a
+ * text outline, so it reaches `outlineWidth / 2` past the symbol.
+ */
+export const SetSymbolBoxSchema = BoundsSchema.extend({
+    outlineColor: z.string().optional(),
+    outlineWidth: z.number().optional(),
+});
+/**
+ * How far a card is turned, in degrees clockwise, to read a box set. See
+ * `rotation` on `CardBoxesSchema`.
+ */
+export const RotationSchema = z.union([
+    z.literal(90),
+    z.literal(180),
+    z.literal(270),
+]);
 export const CardBoxesSchema = z.object({
+    /**
+     * How far the card is turned, in degrees clockwise, to read this set: 90 for
+     * a battle or a split card, whose text runs up the sheet. Left out, the set
+     * reads upright.
+     *
+     * A turned set's boxes — `art` included — are measured on the sheet as it
+     * lies after that turn, so a text box stays the upright rectangle it is
+     * everywhere else. At 90 or 270 the default sheet is therefore 4440 wide and
+     * 3264 tall. The art is drawn turned with the set.
+     *
+     * `collectorInfo` is the exception: a card prints it upright along the
+     * sheet's bottom edge whichever way the text above it reads, so it is always
+     * measured on the unturned sheet. Frame art and masks never turn either —
+     * they are the sheet as printed.
+     */
+    rotation: RotationSchema.optional(),
     art: BoundsSchema,
+    /**
+     * Where the card's first art goes once it has a second one, which goes in
+     * the second face's `art` (see `SecondFaceBoxesSchema`). Left out, the first
+     * art keeps `art`. A card has one art until a second is added, so `art` is
+     * still what every card is imported with.
+     */
+    firstArt: BoundsSchema.optional(),
     mana: TextBoxSchema,
     title: TextBoxSchema,
     type: TextBoxSchema,
-    setSymbol: BoundsSchema,
+    setSymbol: SetSymbolBoxSchema,
     rules: TextBoxSchema.optional(),
     abilities: TextBoxSchema.optional(),
     pt: TextBoxSchema.optional(),
     ptImage: z.object({ x: z.number(), y: z.number() }).optional(),
-    collectorInfo: TextBoxSchema.optional(),
+    /**
+     * Power and toughness each in a box of its own, for a frame that prints
+     * them apart rather than as one `power/toughness`. Both are needed; with
+     * them, `pt` is not drawn.
+     */
+    power: TextBoxSchema.optional(),
+    toughness: TextBoxSchema.optional(),
+    collectorInfo: CollectorInfoBoxSchema.optional(),
     startingLoyalty: TextBoxSchema.optional(),
     nicknameTitle: TextBoxSchema.optional(),
     keyword: TextBoxSchema.optional(),
@@ -61,6 +183,62 @@ export const CardBoxesSchema = z.object({
     // when the other face is a land — lands have no mana cost, so the
     // flipsideManaCost badge is empty and the rules text fills that space.
     flipsideRules: TextBoxSchema.optional(),
+    // Adventure, Omen and Prepare cards print a second spell in a smaller frame
+    // inset within the text box. Its name, mana cost, type line and rules text
+    // come from the card's second face; `title`, `mana`, `type` and `rules` keep
+    // describing the card itself, with `rules` narrowed to the column the inset
+    // leaves free. Which side the inset sits on is the layout's own geometry —
+    // left for an Adventure or an Omen, right for a Prepare card — so the
+    // renderer draws these wherever they are put.
+    insetTitle: TextBoxSchema.optional(),
+    insetMana: TextBoxSchema.optional(),
+    insetType: TextBoxSchema.optional(),
+    insetRules: TextBoxSchema.optional(),
+    // A battle's defense, printed where a creature's power and toughness would
+    // be. Rules text wraps around it the way it does around `pt`.
+    defense: TextBoxSchema.optional(),
+    // A Fuse card prints its Fuse line once, in a bar under both halves, though
+    // Scryfall repeats it at the end of each half's rules. With this box the
+    // line is drawn here and dropped from both; without it, it stays in each
+    // half's rules.
+    fuse: TextBoxSchema.optional(),
+});
+/**
+ * Where a card's second face goes when it is printed on the same side as the
+ * first: the other half of a split card, the sideways half of an aftermath
+ * card, the upside-down half of a flip card. Its name, mana cost, type line,
+ * rules text and power/toughness come from the card's second face, each drawn
+ * where its box is and left out where there is none.
+ *
+ * A set of its own rather than more members of `CardBoxes` because it can be
+ * turned on its own: `rotation` means what it does there, and is likewise
+ * measured against the sheet, not against the first face's set. A split card
+ * turns both sets 90; an aftermath card leaves the first upright and turns
+ * this one 270; a flip card turns this one 180.
+ *
+ * The card has one art, placed by the first face's `art`, unless this set has
+ * an `art` of its own and the card has been given a second art.
+ */
+export const SecondFaceBoxesSchema = z.object({
+    rotation: RotationSchema.optional(),
+    /**
+     * Where a second art goes: measured like the rest of this set, and drawn
+     * turned with it, so it reads the way this face's text does. A layout whose
+     * second face has one can take a second art; while a card has one, its first
+     * art moves to the first face's `firstArt`. The two are split where they
+     * meet — a straight seam midway between them — and each runs on past its
+     * other edges under the frame, as a lone art does.
+     */
+    art: BoundsSchema.optional(),
+    title: TextBoxSchema,
+    mana: TextBoxSchema.optional(),
+    type: TextBoxSchema,
+    setSymbol: SetSymbolBoxSchema.optional(),
+    rules: TextBoxSchema.optional(),
+    pt: TextBoxSchema.optional(),
+    /** Power and toughness apart, as on the first face's set. */
+    power: TextBoxSchema.optional(),
+    toughness: TextBoxSchema.optional(),
 });
 /**
  * Configuration for planeswalker ability rendering.
@@ -77,17 +255,91 @@ export const PlaneswalkerRenderConfigSchema = z.object({
     staticTextPaddingX: z.number(),
     /** Right padding for all ability text in pixels */
     textPaddingRight: z.number().optional(),
-    /** Top padding before the first ability in pixels (background still fills from box top) */
+    /**
+     * Top padding before the first ability in pixels. Unused since 1.12: the
+     * abilities are spaced by `abilityFill`.
+     */
     topPadding: z.number().optional(),
-    /** Bottom padding after the last ability in pixels (background still fills to box bottom) */
-    bottomPadding: z.number().optional(),
     /**
-     * Fraction of the available height at which the shrink loop starts
-     * shrinking the font. 1.0 = only shrink when text literally doesn't fit.
-     * Set lower (e.g. 0.85) to shrink sooner when abilities have more text,
-     * giving more breathing room between bands. Defaults to 1.0.
+     * Bottom padding after the last ability in pixels. Unused since 1.12: see
+     * `loyaltyReserve`.
      */
+    bottomPadding: z.number().optional(),
+    /** Unused since 1.12: the font is fitted to `abilityFill`. */
     textFillThreshold: z.number().optional(),
+    /**
+     * The most of the abilities' height their text may take, 0–1, at
+     * `abilityFillSize`; the rest is shared out evenly as padding around each
+     * ability. The font shrinks in quarter printed points (3.125 of the sheet's
+     * points), from the largest at or below the abilities box's `fontSize` down
+     * to `minFontSize`, until the text fits it. Printed M15 planeswalkers fill
+     * about 0.62 at 88. Defaults to 0.62.
+     */
+    abilityFill: z.number().optional(),
+    /**
+     * The size `abilityFill` holds at, in points. Smaller text may fill more of
+     * the height and larger text less, in proportion: printed M15 planeswalkers
+     * with little text set it larger, with more room around it. Defaults to 88.
+     */
+    abilityFillSize: z.number().optional(),
+    /** The smallest size the abilities' font shrinks to, in points. Defaults to 70. */
+    minFontSize: z.number().optional(),
+    /**
+     * The abilities' line height as a multiple of their font size. Printed M15
+     * planeswalkers set about 1.32. Defaults to 1.32.
+     */
+    lineHeightRatio: z.number().optional(),
+    /**
+     * The least height a loyalty ability takes, in px, however short its text,
+     * so its badge has room. Defaults to 200.
+     */
+    badgeSlotHeight: z.number().optional(),
+    /**
+     * Height at the abilities box's bottom, in px, that the abilities are laid
+     * out above: the room beside the starting loyalty. The last ability's band
+     * still reaches the box's bottom, and its text can run into the reserve
+     * where it clears the badge. Defaults to 60.
+     */
+    loyaltyReserve: z.number().optional(),
+    /**
+     * How far each separator sits below where its two bands meet, in px. The
+     * separator's wave is the top edge a band shows, so this moves where an
+     * ability looks to start inside its band; its text stays put. Defaults to
+     * 24, where printed M15 planeswalkers have it.
+     */
+    separatorOffsetY: z.number().optional(),
+    /**
+     * Draw the translucent bands (and separators) behind the abilities.
+     * Defaults to true. Turn it off for a frame whose art shows through the
+     * ability box, and give the abilities box an outline so the text reads.
+     */
+    abilityBacking: z.boolean().optional(),
+    /**
+     * A rule painted where each two abilities meet, as a layout's `gradients`
+     * are: over the art, under the text. Its `y` is measured from where they
+     * meet rather than from the sheet's top, so `-height / 2` centers it there.
+     * For a frame without bands, whose art shows through the ability box.
+     */
+    abilityDivider: GradientSchema.omit({
+        anchor: true,
+        slides: true,
+        when: true,
+    }).optional(),
+    /**
+     * How far each loyalty badge sits below the center of its ability, in px.
+     * Defaults suit M15's badges — plus 0, minus 34, zero 16 — so a badge whose
+     * point hangs below its body sits low enough for the body to center.
+     */
+    plusBadgeOffsetY: z.number().optional(),
+    minusBadgeOffsetY: z.number().optional(),
+    zeroBadgeOffsetY: z.number().optional(),
+    /**
+     * How far the loyalty cost on each badge sits below the center of its
+     * ability, in px — moves the number alone, not its badge. Defaults to 0.
+     */
+    plusCostOffsetY: z.number().optional(),
+    minusCostOffsetY: z.number().optional(),
+    zeroCostOffsetY: z.number().optional(),
 });
 /**
  * Default planeswalker render config values, used when a frame template
@@ -129,6 +381,92 @@ export const defaultSagaConfig = {
     textPaddingX: 220,
     badgeWidth: 180,
 };
+/**
+ * Configuration for a column of sections — a Class's levels, a Case's steps.
+ * Frame templates provide this via LayoutConfig.sectionConfig.
+ */
+export const SectionRenderConfigSchema = z.object({
+    /**
+     * Leave out a Class's opening reminder ("Gain the next level as a sorcery
+     * to add its ability.") and start the column at level 1, as
+     * `SagaRenderConfig.skipReminder` does for a Saga's.
+     */
+    skipReminder: z.boolean().optional(),
+});
+/**
+ * Where one of a layout's fixed dividers goes: the frame's `sectionDivider`,
+ * drawn `length` long from (`x`, `y`) — rightwards for a horizontal one,
+ * downwards for a vertical one, turned a quarter. `x`, `y` is on the line's
+ * centre across its thickness, which the divider's own aspect ratio sets.
+ * Measured on the sheet.
+ */
+export const SectionDividerPlacementSchema = z.object({
+    x: z.number(),
+    y: z.number(),
+    length: z.number(),
+    orientation: z.enum(["horizontal", "vertical"]).optional(),
+});
+/**
+ * Moves the boxes above the rules text down when the text leaves room, so
+ * short text shows more art — in whole `step`s, never more than `maxSteps`.
+ *
+ * The room is the `rules` box's height less the fitted text's and `padding`.
+ * The listed `boxes`, every gradient anchored to one of them, and every
+ * gradient and tinted image marked `slides`, go down by the slide; the
+ * `rules` box's top goes down with them while its bottom stays, so the text,
+ * centered in it, goes down by half. Everything else — collector info, power
+ * and toughness — stays put.
+ *
+ * Only a card whose rules are drawn in the `rules` box slides: not a
+ * planeswalker, Saga, Class or Case.
+ */
+export const RulesSlideSchema = z.object({
+    padding: z.number().nonnegative(),
+    step: z.number().positive(),
+    maxSteps: z.number().int().nonnegative(),
+    boxes: z.array(SlidingBoxEnum).readonly(),
+});
+/**
+ * Power and toughness laid out as a row from its right edge, for a frame that
+ * prints them apart: the toughness ends at `right`, its symbol sits `gap`
+ * left of it, the power ends `spacing` left of that symbol, and the power's
+ * symbol sits `gap` left of the power. A wider number — `10`, `100`, `*`
+ * — moves everything left of it.
+ *
+ * The symbols are the tinted images marked `ptSlot`. The `power` and
+ * `toughness` boxes still give each number's font, size, color and height;
+ * only their `x` and `width` are worked out. First face only, as tinted
+ * images are.
+ *
+ * With no symbol drawn in either slot, say when a setting turns them off, the
+ * two print as one `P/T` ending at `right`, in the `toughness` box's style.
+ */
+export const PowerToughnessRowSchema = z.object({
+    right: z.number(),
+    gap: z.number(),
+    spacing: z.number(),
+});
+/** The five colors and colorless, the keys of a mana symbol color map. */
+export const ManaColorEnum = z.enum(["W", "U", "B", "R", "G", "C"]);
+/**
+ * How the card's mana symbols are drawn, wherever they appear: the mana cost,
+ * rules text, abilities, and the keyword and flipside boxes alike.
+ */
+export const ManaSymbolStyleSchema = z.object({
+    /**
+     * `"filled"` is the usual solid pip. `"hollow"` draws the same symbols as a
+     * ring with the glyph inside it, and a hybrid as two half rings.
+     */
+    style: z.enum(["filled", "hollow"]).optional(),
+    /** The pip (or ring) color per mana color, in place of the app's. */
+    colors: z.partialRecord(ManaColorEnum, HexColorSchema).optional(),
+    /**
+     * The glyph color per mana color, in place of the app's black. `C` is also
+     * the glyph color of every symbol of no color: generic mana, `{C}`, `{T}`,
+     * `{X}` and the like.
+     */
+    glyphColors: z.partialRecord(ManaColorEnum, HexColorSchema).optional(),
+});
 const CrownRenderConfigSchema = z.object({
     x: z.number(),
     y: z.number(),
@@ -155,25 +493,35 @@ export const defaultNicknameConfig = {
     x: 378,
     y: 577,
 };
+/**
+ * A hint rendered under a template setting's control, for anything the label
+ * alone can't carry — what the setting changes, or when to reach for it.
+ * Optional everywhere; a setting without one renders exactly as before.
+ */
+const helperText = z.string().optional();
 export const TemplateSettingConfigSchema = z.union([
     z.object({
         type: z.literal("boolean"),
         label: z.string(),
+        helperText,
         defaultValue: z.boolean(),
     }),
     z.object({
         type: z.literal("string"),
         label: z.string(),
+        helperText,
         defaultValue: z.string(),
     }),
     z.object({
         type: z.literal("number"),
         label: z.string(),
+        helperText,
         defaultValue: z.string(),
     }),
     z.object({
         type: z.literal("select"),
         label: z.string(),
+        helperText,
         defaultValue: z.string(),
         options: z.array(z.string()),
     }),
@@ -184,10 +532,37 @@ export const LayoutConfigSchema = z.object({
     tallBoxes: CardBoxesSchema.optional(),
     /** Boxes for 2-ability planeswalkers (overrides `boxes` when set). */
     twoAbilityBoxes: CardBoxesSchema.optional(),
+    /**
+     * The second face of a card that prints both faces on one side — split,
+     * aftermath and flip cards. Drawn alongside `boxes`, which keeps describing
+     * the first face. See `SecondFaceBoxesSchema`.
+     */
+    secondFaceBoxes: SecondFaceBoxesSchema.optional(),
     frameAssets: FrameAssetsSchema,
     masks: LayoutMasksSchema.optional(),
+    /**
+     * Masks for the planeswalker tall frame, used instead of `masks` wherever
+     * `tallBoxes` is. The tall frame draws no color overlays, so `noBorder` is
+     * the one that matters.
+     */
+    tallMasks: LayoutMasksSchema.optional(),
     planeswalkerConfig: PlaneswalkerRenderConfigSchema.optional(),
     sagaConfig: SagaRenderConfigSchema.optional(),
+    sectionConfig: SectionRenderConfigSchema.optional(),
+    /**
+     * Dividers that stay put whatever the card says — an inset spell's rules
+     * set off from its name and type line, and the inset from the card's own
+     * rules beside it. Drawn with `frameAssets.sectionDivider`, so a layout
+     * without one draws none.
+     */
+    sectionDividers: z.array(SectionDividerPlacementSchema).optional(),
+    /** Painted over the art and under the text, in order. See `GradientSchema`. */
+    gradients: z.array(GradientSchema).readonly().optional(),
+    /** Shapes painted in the card's colors. See `TintedImageSchema`. */
+    tintedImages: z.array(TintedImageSchema).readonly().optional(),
+    rulesSlide: RulesSlideSchema.optional(),
+    powerToughnessRow: PowerToughnessRowSchema.optional(),
+    manaSymbols: ManaSymbolStyleSchema.optional(),
     crownConfig: CrownRenderConfigSchema.optional(),
     nicknameConfig: NicknameRenderConfigSchema.optional(),
     templateSettings: TemplateSettingsConfigSchema.optional(),
@@ -300,12 +675,39 @@ export const TemplateConfigSchema = z.object({
     // opt-in variants — each entry is a full `LayoutConfig` for a layout that
     // already exists in `layouts`, the same way `saga_creature` is a full
     // standalone config. The active variant is chosen by the `frameVariant`
-    // template setting; see `getLayoutConfig`.
+    // template setting; see `getLayoutConfig`. A layout's own select setting
+    // can name one too, for that layout alone: Borderless's "Adventure" setting
+    // set to "inset" draws an Adventure from `alternateLayouts.inset.adventure`.
+    // The frame variant wins where both name a config for the card's layout.
     alternateLayouts: z
         .record(z.string(), z.partialRecord(LayoutEnum, LayoutConfigSchema))
         .optional(),
     disabledFields: z.array(z.enum(["setSymbol", "collectorInfo"])).optional(),
 });
+/**
+ * A font the frame ships, for its text boxes to name in `fontFamily`.
+ *
+ * `family` is the frame's own name for it and only means something inside
+ * this frame: the app keeps each frame's fonts apart, so a frame can neither
+ * replace a font the app has (a `family` of "Beleren" is still the frame's
+ * file, not the app's) nor clash with another frame's. A box naming a family
+ * the frame does not ship gets the app's font of that name, as before.
+ *
+ * Ship only a font whose license lets it be redistributed. One entry per
+ * weight and style; a family with a bold face lists it as a second entry.
+ */
+export const FrameFontSchema = z.object({
+    family: z.string().min(1),
+    src: AssetUrlSchema,
+    weight: z.enum(["normal", "bold"]).optional(),
+    style: z.enum(["normal", "italic"]).optional(),
+    /**
+     * The font's PostScript name, which a PSD export names its text layers by
+     * so Photoshop finds the font when it is installed. Left out, a PSD export
+     * leaves text in this font as pixels rather than a text layer.
+     */
+    postScriptName: z.string().optional(),
+});
 export const FrameSchema = z.object({
     name: z.string(),
     description: z.string(),
@@ -313,6 +715,8 @@ export const FrameSchema = z.object({
     tags: z.array(z.string()),
     disabled: z.boolean().optional(),
     templateSettings: TemplateSettingsConfigSchema.optional(),
+    /** Fonts the frame ships. See `FrameFontSchema`. */
+    fonts: z.array(FrameFontSchema).readonly().optional(),
     config: TemplateConfigSchema,
 });
 /** Whether a frame exposes any template settings (frame-level or per-layout). */