//! Export to `.fig` (experimental, best effort), from the same public format knowledge as the
//! import: the inverse of its mapping ([`super::map`]).
//!
//! The file is the zip the import reads: `canvas.fig` (the fig-kiwi header, then the binary schema
//! and the message, each a raw-deflate chunk), `meta.json`, an optional `thumbnail.png` and
//! `images/<hash>`. The schema travels in the file, so it describes only the fields written here
//! ([`SCHEMA`]). The message lists one node change per layer (its id, its parent and its position
//! among the siblings, then its fields), parents first, plus blobs (vector networks and outlines).
//! Instances are written as their main, the fields they and their layers override (by id path) and
//! what follows from those (derived data: sizes, places, outlines), like the files the import
//! reads. Shared styles, variable collections and variables are nodes of their own on a hidden
//! page; layers, paints, effects and layout grids name the ones they use. What the format can't
//! carry yet (Dev Mode data, comments, …) is left out and listed in the warnings. Round trips
//! through our own importer are tested, and written files were opened in other software
//! (`docs/file-format-parity.md` says what was checked); other apps may not open every file.

use std::collections::BTreeMap;
use std::io::Write;
use std::sync::Arc;

use figcraft_doc::color::{BlendMode, Color, GradientKind, ImageScaleMode, Paint, PaintKind};
use figcraft_doc::geom::kurbo::PathEl;
use figcraft_doc::geom::{Affine, BezPath};
use figcraft_doc::proto::{
    Action, Direction, Easing, GAMEPAD_BUTTONS, Interaction, KeyMods, Overflow, OverlayPosition, ScrollPosition, Transition, Trigger,
};
use figcraft_doc::{
    AutoLayout, BoolOp, ContentAlign, CrossAlign, Document, EffectKind, ExportSize, GridAlign, GridKind, HConstraint, LayoutMode, LetterSpacing,
    LineHeight, ListStyle, MainAlign, MaskType, Node, NodeId, NodeKind, NoiseMode, PropDef, Sizing, StrokeAlign, StrokeCap, StrokeJoin, StyleKind,
    TextAlignH, TextAlignV, TextAutoResize, TextCase, TextData, TextDecoration, TextStyle, VConstraint, VariableType, VariableValue, VectorNetwork,
    WindingRule,
};
use serde_json::Value;

use super::kiwi::{Kv, Schema, encode};
use super::network;
use crate::FormatError;

/// Most layers written, and deepest nesting followed (the import's limits).
const MAX_NODES: usize = crate::rest::MAX_NODES;
const MAX_DEPTH: usize = 256;
/// Largest `canvas.fig` and image written (what the import reads).
const MAX_CANVAS: u64 = super::MAX_CANVAS;
const MAX_IMAGE: u64 = super::MAX_IMAGE;
/// Largest whole file written.
const MAX_FILE: u64 = 2 * 1024 * 1024 * 1024;
/// Most characters of one text layer, and vertices + segments + loop entries of one vector
/// network (what the import reads).
const MAX_CHARS: usize = 1 << 20;
const MAX_NETWORK: usize = 200_000;
/// Largest magnitude written for a float (the format stores 32-bit floats).
const MAX_FLOAT: f64 = 1e30;
/// The version number in the `canvas.fig` header.
const VERSION: u32 = 101;
/// Session ids of the GUIDs: layers, and grid tracks and component properties.
const LAYERS: u32 = 1;
const AUX: u32 = 2;

/// The schema written into every file: `enum Name A=value …`, `struct Name type field, …` (every
/// field, in order) and `message Name type field=id, …`, with the names, kinds and numbers the
/// format gives them. Only what the export writes.
pub(super) const SCHEMA: &str = "
enum MessageType JOIN_START=0 NODE_CHANGES=1
enum NodePhase CREATED=0 REMOVED=1
enum NodeType NONE=0 DOCUMENT=1 CANVAS=2 GROUP=3 FRAME=4 BOOLEAN_OPERATION=5 VECTOR=6 STAR=7 LINE=8 ELLIPSE=9 RECTANGLE=10 REGULAR_POLYGON=11 ROUNDED_RECTANGLE=12 TEXT=13 SLICE=14 SYMBOL=15 INSTANCE=16 SECTION=25 VARIABLE=28 VARIABLE_SET=31
enum BlendMode PASS_THROUGH=0 NORMAL=1 DARKEN=2 MULTIPLY=3 LINEAR_BURN=4 COLOR_BURN=5 LIGHTEN=6 SCREEN=7 LINEAR_DODGE=8 COLOR_DODGE=9 OVERLAY=10 SOFT_LIGHT=11 HARD_LIGHT=12 DIFFERENCE=13 EXCLUSION=14 HUE=15 SATURATION=16 COLOR=17 LUMINOSITY=18
enum PaintType SOLID=0 GRADIENT_LINEAR=1 GRADIENT_RADIAL=2 GRADIENT_ANGULAR=3 GRADIENT_DIAMOND=4 IMAGE=5
enum ImageScaleMode STRETCH=0 FIT=1 FILL=2 TILE=3
enum WindingRule NONZERO=0 ODD=1
enum StrokeAlign CENTER=0 INSIDE=1 OUTSIDE=2
enum StrokeCap NONE=0 ROUND=1 SQUARE=2 ARROW_LINES=3 ARROW_EQUILATERAL=4 TRIANGLE_FILLED=6 DIAMOND_FILLED=5 CIRCLE_FILLED=14
enum StrokeJoin MITER=0 BEVEL=1 ROUND=2
enum ConstraintType MIN=0 CENTER=1 MAX=2 STRETCH=3 SCALE=4
enum StackMode NONE=0 HORIZONTAL=1 VERTICAL=2 GRID=3
enum StackAlign MIN=0 CENTER=1 MAX=2 BASELINE=3
enum StackJustify MIN=0 CENTER=1 MAX=2 SPACE_EVENLY=3 SPACE_BETWEEN=4 SPACE_AROUND=5
enum StackCounterAlign MIN=0 CENTER=1 MAX=2 STRETCH=3 AUTO=4 BASELINE=5
enum StackSize FIXED=0 RESIZE_TO_FIT=1
enum StackWrap NO_WRAP=0 WRAP=1
enum StackCounterAlignContent AUTO=0 SPACE_BETWEEN=1
enum StackPositioning AUTO=0 ABSOLUTE=1
enum EffectType INNER_SHADOW=0 DROP_SHADOW=1 FOREGROUND_BLUR=2 BACKGROUND_BLUR=3 NOISE=7 GRAIN=6 GLASS=8
enum BlurOpType NORMAL=0 PROGRESSIVE=1
enum NoiseType MONOTONE=1 DUOTONE=2 MULTITONE=0
enum TextAlignHorizontal LEFT=0 CENTER=1 RIGHT=2 JUSTIFIED=3
enum TextAlignVertical TOP=0 CENTER=1 BOTTOM=2
enum TextAutoResize NONE=0 WIDTH_AND_HEIGHT=1 HEIGHT=2
enum TextTruncation DISABLED=0 ENDING=1
enum TextCase ORIGINAL=0 UPPER=1 LOWER=2 TITLE=3 SMALL_CAPS=4
enum TextDecoration NONE=0 UNDERLINE=1 STRIKETHROUGH=2
enum NumberUnits RAW=0 PIXELS=1 PERCENT=2
enum LineType PLAIN=0 ORDERED_LIST=1 UNORDERED_LIST=2
enum SourceDirectionality AUTO=0 LTR=1 RTL=2
enum DocumentColorProfile LEGACY=0 SRGB=1 DISPLAY_P3=2
enum EmojiImageSet APPLE=0 NOTO=1
enum MaskType ALPHA=0 OUTLINE=1 LUMINANCE=2
enum VariableResolvedDataType BOOLEAN=0 FLOAT=1 STRING=2 COLOR=4 SYMBOL_ID=6 TEXT_DATA=8
enum VectorMirror NONE=0 ANGLE=1 ANGLE_AND_LENGTH=2
enum BooleanOperation UNION=0 INTERSECT=1 SUBTRACT=2 XOR=3
enum LayoutGridType MIN=0 CENTER=1 STRETCH=2 MAX=3
enum LayoutGridPattern STRIPES=0 GRID=1
enum Axis X=0 Y=1
enum ImageType PNG=0 JPEG=1 SVG=2 PDF=3
enum ExportConstraintType CONTENT_SCALE=0 CONTENT_WIDTH=1 CONTENT_HEIGHT=2
enum ComponentPropType BOOL=0 TEXT=1 INSTANCE_SWAP=3 VARIANT=4
enum VariableField MISSING=0 CORNER_RADIUS=1 PARAGRAPH_SPACING=2 PARAGRAPH_INDENT=3 STROKE_WEIGHT=4 STACK_SPACING=5 STACK_PADDING_LEFT=6 STACK_PADDING_TOP=7 STACK_PADDING_RIGHT=8 STACK_PADDING_BOTTOM=9 VISIBLE=10 TEXT_DATA=11 WIDTH=12 HEIGHT=13 RECTANGLE_TOP_LEFT_CORNER_RADIUS=14 RECTANGLE_TOP_RIGHT_CORNER_RADIUS=15 RECTANGLE_BOTTOM_LEFT_CORNER_RADIUS=16 RECTANGLE_BOTTOM_RIGHT_CORNER_RADIUS=17 BORDER_TOP_WEIGHT=18 BORDER_BOTTOM_WEIGHT=19 BORDER_LEFT_WEIGHT=20 BORDER_RIGHT_WEIGHT=21 STACK_COUNTER_SPACING=23 MIN_WIDTH=24 MAX_WIDTH=25 MIN_HEIGHT=26 MAX_HEIGHT=27 FONT_FAMILY=28 FONT_STYLE=29 OPACITY=31 FONT_SIZE=32 LETTER_SPACING=34 LINE_HEIGHT=36 OVERRIDDEN_SYMBOL_ID=37
enum VariableDataType BOOLEAN=0 FLOAT=1 STRING=2 ALIAS=3 COLOR=4 PROP_REF=13
enum VariableScope ALL_SCOPES=0 TEXT_CONTENT=1 CORNER_RADIUS=2 WIDTH_HEIGHT=3 GAP=4 ALL_FILLS=5 FRAME_FILL=6 SHAPE_FILL=7 TEXT_FILL=8 STROKE=9 STROKE_FLOAT=10 EFFECT_FLOAT=11 EFFECT_COLOR=12 OPACITY=13 FONT_STYLE=14 FONT_FAMILY=15 FONT_SIZE=16 LINE_HEIGHT=17 LETTER_SPACING=18 PARAGRAPH_SPACING=19 PARAGRAPH_INDENT=20
enum StyleType NONE=0 FILL=1 STROKE=2 TEXT=3 EFFECT=4 EXPORT=5 GRID=6
enum InteractionType ON_CLICK=0 DRAG=9 ON_HOVER=4 ON_PRESS=7 MOUSE_IN=2 MOUSE_OUT=3 MOUSE_DOWN=5 MOUSE_UP=6 AFTER_TIMEOUT=1 ON_KEY_DOWN=10
enum TriggerDevice KEYBOARD=0 UNKNOWN_CONTROLLER=1
enum ConnectionType NONE=0 INTERNAL_NODE=1 URL=2 BACK=3 CLOSE=4
enum NavigationType NAVIGATE=0 OVERLAY=1 SWAP=2 SWAP_STATE=3 SCROLL_TO=4
enum TransitionType INSTANT_TRANSITION=0 DISSOLVE=1 SMART_ANIMATE=24 SLIDE_FROM_LEFT=3 SLIDE_FROM_RIGHT=4 SLIDE_FROM_TOP=5 SLIDE_FROM_BOTTOM=6 PUSH_FROM_LEFT=7 PUSH_FROM_RIGHT=8 PUSH_FROM_TOP=9 PUSH_FROM_BOTTOM=10 MOVE_FROM_LEFT=11 MOVE_FROM_RIGHT=12 MOVE_FROM_TOP=13 MOVE_FROM_BOTTOM=14 SLIDE_OUT_TO_LEFT=15 SLIDE_OUT_TO_RIGHT=16 SLIDE_OUT_TO_TOP=17 SLIDE_OUT_TO_BOTTOM=18 MOVE_OUT_TO_LEFT=19 MOVE_OUT_TO_RIGHT=20 MOVE_OUT_TO_TOP=21 MOVE_OUT_TO_BOTTOM=22
enum EasingType IN_CUBIC=0 OUT_CUBIC=1 INOUT_CUBIC=2 LINEAR=3 IN_BACK_CUBIC=4 OUT_BACK_CUBIC=5 INOUT_BACK_CUBIC=6 CUSTOM_CUBIC=7 GENTLE_SPRING=9
enum ScrollDirection NONE=0 HORIZONTAL=1 VERTICAL=2 BOTH=3
enum ScrollBehavior SCROLLS=0 FIXED_WHEN_CHILD_OF_SCROLLING_FRAME=1 STICKY_SCROLLS=2
enum OverlayPositionType CENTER=0 TOP_LEFT=1 TOP_CENTER=2 TOP_RIGHT=3 BOTTOM_LEFT=4 BOTTOM_CENTER=5 BOTTOM_RIGHT=6 MANUAL=7
enum OverlayBackgroundInteraction NONE=0 CLOSE_ON_CLICK_OUTSIDE=1
enum OverlayBackgroundType NONE=0 SOLID_COLOR=1
struct GUID uint sessionID, uint localID
struct Color float r, float g, float b, float a
struct Vector float x, float y
struct Matrix float m00, float m01, float m02, float m10, float m11, float m12
struct ColorStop Color color, float position
struct ParentIndex GUID guid, string position
message Image byte[] hash=1, string name=2
message VariableWidthPoint float position=1, float ascent=2, float descent=3
message PluginData string pluginID=1, string value=2, string key=3
message StyleId GUID guid=1
message VariableID GUID guid=1
message VariableSetID GUID guid=1
message ColorStopVar Color color=1, VariableData colorVar=2, float position=3
message Paint PaintType type=1, Color color=2, float opacity=3, bool visible=4, BlendMode blendMode=5, ColorStop[] stops=6, Matrix transform=7, Image image=8, ImageScaleMode imageScaleMode=10, float rotation=11, float scale=12, VariableData colorVar=21, ColorStopVar[] stopsVar=23
message Effect EffectType type=1, Color color=2, Vector offset=3, float radius=4, bool visible=5, BlendMode blendMode=6, float spread=7, bool showShadowBehindNode=8, BlurOpType blurOpType=19, float startRadius=21, Vector startOffset=20, Vector endOffset=28, NoiseType noiseType=26, Vector noiseSize=22, float density=25, float opacity=27, Color secondaryColor=24, bool clipToShape=23, VariableData radiusVar=9, VariableData colorVar=10, VariableData spreadVar=11, VariableData xVar=12, VariableData yVar=13, VariableData startRadiusVar=45
struct FontName string family, string style, string postscript
struct Number float value, NumberUnits units
message Hyperlink string url=1
message TextLineData LineType lineType=1, int styleId=10, int indentationLevel=2, SourceDirectionality sourceDirectionality=9, int listStartOffset=7, bool isFirstLineOfList=8
message TextData string characters=1, uint[] characterStyleIDs=2, NodeChange[] styleOverrideTable=3, TextLineData[] lines=12
message Path WindingRule windingRule=1, uint commandsBlob=2, uint styleID=3
message VectorData uint vectorNetworkBlob=1, Vector normalizedSize=2, NodeChange[] styleOverrideTable=3
message ArcData float startingAngle=1, float endingAngle=2, float innerRadius=3
message OptionalVector Vector value=1
message LayoutGrid LayoutGridType type=1, Axis axis=2, bool visible=3, int numSections=4, float offset=5, float sectionSize=6, float gutterSize=7, Color color=8, LayoutGridPattern pattern=9, VariableData numSectionsVar=10, VariableData offsetVar=11, VariableData sectionSizeVar=12, VariableData gutterSizeVar=13
struct ExportConstraint ExportConstraintType type, float value
message ExportSettings string suffix=1, ImageType imageType=2, ExportConstraint constraint=3
message GUIDPath GUID[] guids=1
message SymbolData GUID symbolID=1, NodeChange[] symbolOverrides=2, float uniformScaleFactor=3
message ComponentPropValue bool boolValue=1, TextData textValue=2, GUID guidValue=3
message ComponentPropDef GUID id=1, string name=2, ComponentPropValue initialValue=3, ComponentPropType type=6
message ComponentPropAssignment GUID defID=1, ComponentPropValue value=2
message PropRefValue GUID defId=1
message VariableAnyValue bool boolValue=1, string textValue=2, float floatValue=3, VariableID alias=4, Color colorValue=5, PropRefValue propRefValue=13
message VariableData VariableAnyValue value=1, VariableDataType dataType=2, VariableResolvedDataType resolvedDataType=3
message VariableDataMapEntry uint nodeField=1, VariableData variableData=2, VariableField variableField=3
message VariableDataMap VariableDataMapEntry[] entries=1
message VariableModeBySetMapEntry VariableSetID variableSetID=1, GUID variableModeID=2
message VariableModeBySetMap VariableModeBySetMapEntry[] entries=1
message VariableSetMode GUID id=1, string name=2, string sortPosition=3
message VariableDataValuesEntry GUID modeID=1, VariableData variableData=2
message VariableDataValues VariableDataValuesEntry[] entries=1
message KeyTrigger int[] keyCodes=1, TriggerDevice triggerDevice=2
message PrototypeEvent InteractionType interactionType=1, float transitionTimeout=6, KeyTrigger keyTrigger=4
message PrototypeAction GUID transitionNodeID=1, TransitionType transitionType=2, float transitionDuration=3, EasingType easingType=4, float[] easingFunction=12, ConnectionType connectionType=7, Vector overlayRelativePosition=9, NavigationType navigationType=10, string connectionURL=8, bool transitionPreserveScroll=11
message PrototypeInteraction PrototypeEvent event=2, PrototypeAction[] actions=3
message PrototypeStartingPoint string name=1, string position=3
message OverlayBackgroundAppearance OverlayBackgroundType backgroundType=1, Color backgroundColor=2
message GUIDPositionMapEntry GUID id=1, string position=2
message GUIDPositionMap GUIDPositionMapEntry[] entries=1
message NodeChange GUID guid=1, NodePhase phase=2, ParentIndex parentIndex=3, NodeType type=4, string name=5, bool visible=6, bool locked=7, float opacity=8, BlendMode blendMode=9, Vector size=11, Matrix transform=12, bool mask=16, MaskType maskType=317, float backgroundOpacity=19, bool backgroundEnabled=15, bool internalOnly=142, string description=318, StyleType styleType=163, string sortPosition=320, StyleId styleIdForFill=332, StyleId styleIdForStrokeFill=333, StyleId styleIdForText=334, StyleId styleIdForEffect=335, StyleId styleIdForGrid=336, VariableDataMap variableConsumptionMap=307, VariableModeBySetMap variableModeBySetMap=316, VariableSetMode[] variableSetModes=312, VariableSetID variableSetID=313, VariableResolvedDataType variableResolvedType=314, VariableDataValues variableDataValues=315, VariableScope[] variableScopes=353, DocumentColorProfile documentColorProfile=349, Paint[] fillPaints=38, Paint[] strokePaints=39, float strokeWeight=26, StrokeAlign strokeAlign=29, StrokeJoin strokeJoin=31, StrokeCap strokeCap=30, float[] dashPattern=13, float miterLimit=25, bool borderStrokeWeightsIndependent=299, float borderTopWeight=295, float borderRightWeight=298, float borderBottomWeight=296, float borderLeftWeight=297, Effect[] effects=43, float cornerRadius=20, float cornerSmoothing=160, bool rectangleCornerRadiiIndependent=149, float rectangleTopLeftCornerRadius=145, float rectangleTopRightCornerRadius=146, float rectangleBottomRightCornerRadius=148, float rectangleBottomLeftCornerRadius=147, ConstraintType horizontalConstraint=28, ConstraintType verticalConstraint=37, bool frameMaskDisabled=115, bool resizeToFit=117, bool isStateGroup=225, bool sectionContentsHidden=283, Color backgroundColor=50, StackMode stackMode=105, float stackSpacing=107, float stackCounterSpacing=324, StackWrap stackWrap=323, StackCounterAlignContent stackCounterAlignContent=343, float stackHorizontalPadding=209, float stackVerticalPadding=210, float stackPaddingRight=233, float stackPaddingBottom=234, StackJustify stackPrimaryAlignItems=230, StackAlign stackCounterAlignItems=231, StackSize stackPrimarySizing=229, StackSize stackCounterSizing=221, bool bordersTakeSpace=294, bool stackReverseZIndex=271, float gridColumnGap=438, float gridRowGap=437, GUIDPositionMap gridColumns=436, GUIDPositionMap gridRows=435, float stackChildPrimaryGrow=232, StackCounterAlign stackChildAlignSelf=236, StackPositioning stackPositioning=269, OptionalVector minSize=325, OptionalVector maxSize=326, GUID gridColumnAnchor=440, GUID gridRowAnchor=439, uint gridColumnSpan=442, uint gridRowSpan=441, LayoutGrid[] layoutGrids=47, ExportSettings[] exportSettings=45, TextData textData=42, FontName fontName=41, float fontSize=21, Number lineHeight=40, Number letterSpacing=165, TextCase textCase=34, TextDecoration textDecoration=35, TextAlignHorizontal textAlignHorizontal=32, TextAlignVertical textAlignVertical=33, TextAutoResize textAutoResize=46, TextTruncation textTruncation=280, int maxLines=351, float paragraphSpacing=23, float paragraphIndent=22, Hyperlink hyperlink=223, bool autoRename=14, bool fontVariantCommonLigatures=127, bool fontVariantContextualLigatures=128, string fontVersion=202, uint textUserLayoutVersion=203, uint textExplicitLayoutVersion=396, uint textBidiVersion=279, float textTracking=27, bool textDecorationSkipInk=412, EmojiImageSet emojiImageSet=391, uint styleID=49, Path[] fillGeometry=51, Path[] strokeGeometry=52, VectorData vectorData=48, VectorMirror handleMirroring=44, uint count=10, float starInnerScale=24, ArcData arcData=195, BooleanOperation booleanOperation=36, string symbolDescription=144, VariableWidthPoint[] variableWidthPoints=447, PluginData[] pluginData=204, SymbolData symbolData=113, NodeChange[] derivedSymbolData=125, GUID overriddenSymbolID=143, ComponentPropDef[] componentPropDefs=266, ComponentPropAssignment[] componentPropAssignments=268, VariableDataMap parameterConsumptionMap=445, GUIDPath guidPath=111, PrototypeInteraction[] prototypeInteractions=226, PrototypeStartingPoint prototypeStartingPoint=249, ScrollDirection scrollDirection=159, ScrollBehavior scrollBehavior=186, OverlayPositionType overlayPositionType=198, OverlayBackgroundInteraction overlayBackgroundInteraction=200, OverlayBackgroundAppearance overlayBackgroundAppearance=201
struct Blob byte[] bytes
message Message MessageType type=1, uint sessionID=2, NodeChange[] nodeChanges=4, Blob[] blobs=6
";

/// Write `doc` as a `.fig` file, with `thumbnail` (a PNG) when given. Returns the bytes and the
/// warnings about what was left out or approximated.
pub fn export(doc: &Document, thumbnail: Option<&[u8]>) -> Result<(Vec<u8>, Vec<String>), FormatError> {
    let mut x = Exporter::new(doc);
    let message = x.message();
    let fail = |e: super::kiwi::KiwiError| FormatError::Io(format!(".fig export: {e}"));
    let schema = Schema::parse(SCHEMA).map_err(fail)?;
    let root = schema.find("Message").ok_or_else(|| FormatError::Io(".fig export: the schema has no Message".into()))?;
    let body = encode::message(&schema, root, &message).map_err(fail)?;
    let canvas = canvas(&encode::schema(&schema), &body)?;
    let background = doc.pages.first().and_then(|p| doc.node(*p)).and_then(|p| match &p.kind {
        NodeKind::Page { background, .. } => Some(*background),
        _ => None,
    });
    let bytes = archive(&doc.name, background.unwrap_or(Color::WHITE), &canvas, &x.files, thumbnail)?;
    Ok((bytes, x.warnings))
}

fn too_large() -> FormatError {
    FormatError::Io("the document is too large for a .fig file".into())
}

/// `canvas.fig`: the magic, the version and the two deflated chunks, each after its length.
fn canvas(schema: &[u8], message: &[u8]) -> Result<Vec<u8>, FormatError> {
    let mut out = b"fig-kiwi".to_vec();
    out.extend_from_slice(&VERSION.to_le_bytes());
    for chunk in [schema, message] {
        let mut z = flate2::write::DeflateEncoder::new(Vec::new(), flate2::Compression::default());
        z.write_all(chunk).map_err(crate::io_err)?;
        let c = z.finish().map_err(crate::io_err)?;
        let len = u32::try_from(c.len()).map_err(|_| too_large())?;
        out.extend_from_slice(&len.to_le_bytes());
        out.extend_from_slice(&c);
    }
    if out.len() as u64 > MAX_CANVAS {
        return Err(too_large());
    }
    Ok(out)
}

/// The zip around `canvas.fig`.
fn archive(
    name: &str,
    background: Color,
    canvas: &[u8],
    images: &[(String, Arc<Vec<u8>>)],
    thumbnail: Option<&[u8]>,
) -> Result<Vec<u8>, FormatError> {
    let mut buf = std::io::Cursor::new(Vec::new());
    {
        let mut z = zip::ZipWriter::new(&mut buf);
        let stored = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
        crate::put(&mut z, "canvas.fig", stored, canvas)?;
        if let Some(t) = thumbnail {
            crate::put(&mut z, "thumbnail.png", stored, t)?;
        }
        let mut client = serde_json::json!({"background_color": {"r": background.r, "g": background.g, "b": background.b, "a": background.a}});
        // A PNG says its size right after its signature and header chunk name.
        let be = |at: usize| thumbnail.and_then(|t| t.get(at..at + 4)).and_then(|b| b.try_into().ok()).map(u32::from_be_bytes);
        if let (Some(w), Some(h)) = (be(16), be(20)) {
            client["thumbnail_size"] = serde_json::json!({"width": w, "height": h});
        }
        let meta = serde_json::to_vec(&serde_json::json!({"client_meta": client, "file_name": name})).map_err(crate::io_err)?;
        crate::put(&mut z, "meta.json", crate::json_options(), &meta)?;
        let mut total = canvas.len() as u64;
        for (hash, bytes) in images {
            total += bytes.len() as u64;
            if total > MAX_FILE {
                return Err(too_large());
            }
            crate::put(&mut z, &format!("images/{hash}"), stored, bytes)?;
        }
        z.finish().map_err(crate::io_err)?;
    }
    Ok(buf.into_inner())
}

type Fields = Vec<(&'static str, Kv<'static>)>;

fn o(f: Fields) -> Kv<'static> {
    Kv::Object(f)
}
fn arr(v: Vec<Kv<'static>>) -> Kv<'static> {
    Kv::Array(v)
}
/// A float the format can hold: finite (non-finite values become 0) and within range.
fn fl(x: f64) -> Kv<'static> {
    Kv::Float(if x.is_finite() { x.clamp(-MAX_FLOAT, MAX_FLOAT) as f32 } else { 0.0 })
}
fn u(x: u32) -> Kv<'static> {
    Kv::Uint(u64::from(x))
}
fn int(x: i64) -> Kv<'static> {
    Kv::Int(x.clamp(i64::from(i32::MIN), i64::from(i32::MAX)))
}
fn e(name: &'static str) -> Kv<'static> {
    Kv::Enum(name)
}
fn s(x: &str) -> Kv<'static> {
    Kv::Str(x.to_string())
}
fn b(x: bool) -> Kv<'static> {
    Kv::Bool(x)
}
fn guid(session: u32, local: u32) -> Kv<'static> {
    o(vec![("sessionID", u(session)), ("localID", u(local))])
}
fn xy(x: f64, y: f64) -> Kv<'static> {
    o(vec![("x", fl(x)), ("y", fl(y))])
}
fn color(c: Color) -> Kv<'static> {
    o(vec![("r", fl(c.r.into())), ("g", fl(c.g.into())), ("b", fl(c.b.into())), ("a", fl(c.a.into()))])
}
fn matrix(m: Affine) -> Kv<'static> {
    let [a, b, c, d, e, f] = m.as_coeffs();
    o(vec![("m00", fl(a)), ("m01", fl(c)), ("m02", fl(e)), ("m10", fl(b)), ("m11", fl(d)), ("m12", fl(f))])
}
/// What the document and its pages say besides their names: left out, a reader takes them as
/// hidden and fully transparent, and draws nothing below them.
fn root_fields() -> Fields {
    vec![
        ("visible", b(true)),
        ("opacity", fl(1.0)),
        ("transform", matrix(Affine::IDENTITY)),
        ("strokeWeight", fl(0.0)),
        ("strokeAlign", e("CENTER")),
        ("strokeJoin", e("BEVEL")),
    ]
}
/// A finite coordinate (vector network blobs store raw floats).
fn finite(x: f64) -> f64 {
    if x.is_finite() { x.clamp(-MAX_FLOAT, MAX_FLOAT) } else { 0.0 }
}

/// A position string that sorts as child `i` does among its siblings (fixed width, printable).
fn position(i: usize) -> String {
    let mut out = [0u8; 4];
    let mut v = i;
    for c in out.iter_mut().rev() {
        *c = b'!' + (v % 94) as u8;
        v /= 94;
    }
    String::from_utf8_lossy(&out).into_owned()
}

/// The format's name of a blend mode: the one the import reads back as `m`.
fn blend_name(m: BlendMode) -> &'static str {
    const NAMES: [&str; 19] = [
        "PASS_THROUGH",
        "NORMAL",
        "DARKEN",
        "MULTIPLY",
        "LINEAR_BURN",
        "COLOR_BURN",
        "LIGHTEN",
        "SCREEN",
        "LINEAR_DODGE",
        "COLOR_DODGE",
        "OVERLAY",
        "SOFT_LIGHT",
        "HARD_LIGHT",
        "DIFFERENCE",
        "EXCLUSION",
        "HUE",
        "SATURATION",
        "COLOR",
        "LUMINOSITY",
    ];
    NAMES.into_iter().find(|n| crate::rest::props::blend_mode(n) == Some(m)).unwrap_or("NORMAL")
}

fn cap_name(c: StrokeCap) -> &'static str {
    match c {
        StrokeCap::None => "NONE",
        StrokeCap::Round => "ROUND",
        StrokeCap::Square => "SQUARE",
        StrokeCap::LineArrow => "ARROW_LINES",
        StrokeCap::TriangleArrow | StrokeCap::ReversedTriangle => "ARROW_EQUILATERAL",
        StrokeCap::CircleFilled => "CIRCLE_FILLED",
        StrokeCap::DiamondFilled => "DIAMOND_FILLED",
    }
}

fn join_name(j: StrokeJoin) -> &'static str {
    match j {
        StrokeJoin::Miter => "MITER",
        StrokeJoin::Bevel => "BEVEL",
        StrokeJoin::Round => "ROUND",
    }
}

/// A geometry blob (the import's `svg_path` reads it): commands `0` close, `1` move, `2` line,
/// `3` quadratic, `4` cubic, each followed by its points as little-endian `f32` pairs.
fn path_blob(p: &BezPath) -> Vec<u8> {
    let mut out = Vec::new();
    let mut put = |cmd: u8, pts: &[figcraft_doc::geom::Point]| {
        out.push(cmd);
        for q in pts {
            out.extend_from_slice(&(finite(q.x) as f32).to_le_bytes());
            out.extend_from_slice(&(finite(q.y) as f32).to_le_bytes());
        }
    };
    for el in p.elements() {
        match *el {
            PathEl::MoveTo(a) => put(1, &[a]),
            PathEl::LineTo(a) => put(2, &[a]),
            PathEl::QuadTo(a, c) => put(3, &[a, c]),
            PathEl::CurveTo(a, c, d) => put(4, &[a, c, d]),
            PathEl::ClosePath => put(0, &[]),
        }
    }
    out
}

/// Settings an overlay's destination carries.
struct Overlay {
    position: OverlayPosition,
    close_on_outside: bool,
    background: Option<Color>,
}

struct Exporter<'d> {
    doc: &'d Document,
    /// Layer → local id of its GUID (session [`LAYERS`]).
    ids: BTreeMap<NodeId, u32>,
    nodes: Vec<Kv<'static>>,
    /// Blob bytes → index (identical blobs are written once).
    blobs: BTreeMap<Vec<u8>, u32>,
    blob_bytes: u64,
    /// Image key → its hash (lowercase hex) once written, `None` when its bytes aren't there.
    images: BTreeMap<String, Option<String>>,
    /// `images/<hash>` members.
    files: Vec<(String, Arc<Vec<u8>>)>,
    /// Component property (name, type) → local id of its definition's GUID (session [`AUX`]).
    defs: BTreeMap<(String, &'static str), u32>,
    /// Grid tracks of written grid frames: (columns, rows) local ids (session [`AUX`]).
    tracks: BTreeMap<NodeId, (Vec<u32>, Vec<u32>)>,
    aux: u32,
    overlays: BTreeMap<NodeId, Overlay>,
    /// Flow starting points: layer → (order, name).
    starts: BTreeMap<NodeId, (usize, String)>,
    /// Shared styles, variable collections and variables → local id of their node's GUID (session
    /// [`LAYERS`], after the layers'), and (collection, mode) → local id of the mode's GUID
    /// (session [`AUX`]).
    style_ids: BTreeMap<&'d str, u32>,
    set_ids: BTreeMap<&'d str, u32>,
    var_ids: BTreeMap<&'d str, u32>,
    mode_ids: BTreeMap<(&'d str, &'d str), u32>,
    warnings: Vec<String>,
}

/// The variables bound to one layer, as the fields that carry them: paints by (fills?, index),
/// gradient stops by (fills?, paint, stop), effect and layout grid fields by (index, field), and
/// the entries of the layer's own map.
#[derive(Default)]
struct Bound {
    paints: BTreeMap<(bool, usize), Kv<'static>>,
    stops: BTreeMap<(bool, usize, usize), Kv<'static>>,
    effects: BTreeMap<(usize, &'static str), Kv<'static>>,
    grids: BTreeMap<(usize, &'static str), Kv<'static>>,
    entries: Vec<Kv<'static>>,
}

impl<'d> Exporter<'d> {
    fn new(doc: &'d Document) -> Self {
        Self {
            doc,
            ids: BTreeMap::new(),
            nodes: Vec::new(),
            blobs: BTreeMap::new(),
            blob_bytes: 0,
            images: BTreeMap::new(),
            files: Vec::new(),
            defs: BTreeMap::new(),
            tracks: BTreeMap::new(),
            aux: 0,
            overlays: BTreeMap::new(),
            starts: BTreeMap::new(),
            style_ids: BTreeMap::new(),
            set_ids: BTreeMap::new(),
            var_ids: BTreeMap::new(),
            mode_ids: BTreeMap::new(),
            warnings: Vec::new(),
        }
    }

    fn warn(&mut self, w: &str) {
        if !self.warnings.iter().any(|x| x == w) {
            self.warnings.push(w.to_string());
        }
    }

    fn next_aux(&mut self) -> u32 {
        self.aux += 1;
        self.aux
    }

    fn guid_of(&self, id: NodeId) -> Option<Kv<'static>> {
        self.ids.get(&id).map(|l| guid(LAYERS, *l))
    }

    /// The message: the document, its pages and their layers, and the blobs.
    fn message(&mut self) -> Kv<'static> {
        let doc = self.doc;
        self.assign();
        let profile = if doc.color_profile == figcraft_doc::color::ColorProfile::DisplayP3 { "DISPLAY_P3" } else { "SRGB" };
        let mut root: Fields = vec![("guid", guid(0, 0)), ("phase", e("CREATED")), ("type", e("DOCUMENT")), ("name", s(&doc.name))];
        root.extend(root_fields());
        root.push(("documentColorProfile", e(profile)));
        self.nodes.push(o(root));
        for (i, p) in doc.pages.iter().enumerate() {
            self.emit(*p, guid(0, 0), i, None, 0);
        }
        self.assets(doc.pages.len());
        if !doc.comments.is_empty() {
            self.warn("comments were left out");
        }
        let mut blobs: Vec<(u32, Vec<u8>)> = std::mem::take(&mut self.blobs).into_iter().map(|(bytes, i)| (i, bytes)).collect();
        blobs.sort_by_key(|x| x.0);
        o(vec![
            ("type", e("NODE_CHANGES")),
            ("sessionID", u(0)),
            ("nodeChanges", arr(std::mem::take(&mut self.nodes))),
            ("blobs", arr(blobs.into_iter().map(|(_, bytes)| o(vec![("bytes", Kv::Bytes(bytes))])).collect())),
        ])
    }

    /// GUIDs for every layer (pages first, then depth-first), component property definitions,
    /// flow starting points and overlay settings, before anything refers to them.
    fn assign(&mut self) {
        let doc = self.doc;
        let mut stack: Vec<NodeId> = doc.pages.iter().rev().copied().collect();
        while let Some(id) = stack.pop() {
            let Some(n) = doc.node(id) else { continue };
            if self.ids.len() >= MAX_NODES {
                self.warn("the document has more layers than a .fig file is read with; the rest were left out");
                break;
            }
            let local = u32::try_from(self.ids.len() + 1).unwrap_or(u32::MAX);
            self.ids.insert(id, local);
            // An instance's layers aren't written (its main says them), so nothing may refer to them.
            let mirrored = matches!(&n.kind, NodeKind::Instance { component, .. } if doc.node(*component).is_some_and(|c| matches!(c.kind, NodeKind::Component { .. })));
            if !mirrored {
                stack.extend(n.children.iter().rev());
            }
            match &n.kind {
                NodeKind::Component { props, .. } => {
                    for (name, d) in props {
                        if let Some(ty) = prop_type(d) {
                            let key = (name.clone(), ty);
                            if !self.defs.contains_key(&key) {
                                let id = self.next_aux();
                                self.defs.insert(key, id);
                            }
                        }
                    }
                }
                NodeKind::Page { flows, .. } => {
                    for (i, f) in flows.iter().enumerate() {
                        self.starts.entry(f.start).or_insert((i, f.name.clone()));
                    }
                }
                _ => {}
            }
            for a in n.interactions.iter().flat_map(|it| figcraft_doc::proto::walk(&it.actions)) {
                if let Action::OpenOverlay { dest, position, close_on_outside, background, .. } = a {
                    let o = Overlay { position: *position, close_on_outside: *close_on_outside, background: *background };
                    match self.overlays.get(dest) {
                        Some(old) if (old.position, old.close_on_outside, old.background) != (o.position, o.close_on_outside, o.background) => {
                            self.warn("overlays opened with different settings keep the first one's");
                        }
                        Some(_) => {}
                        None => {
                            self.overlays.insert(*dest, o);
                        }
                    }
                }
            }
        }
        // The page that holds styles and variables takes the next id, then their nodes.
        let mut next = u32::try_from(self.ids.len() + 1).unwrap_or(u32::MAX);
        let mut node = || {
            next = next.saturating_add(1);
            next
        };
        for st in &doc.styles {
            self.style_ids.entry(st.id.as_str()).or_insert_with(&mut node);
        }
        for c in &doc.variables.collections {
            self.set_ids.entry(c.id.as_str()).or_insert_with(&mut node);
        }
        for v in &doc.variables.variables {
            if self.set_ids.contains_key(v.collection.as_str()) {
                self.var_ids.entry(v.id.as_str()).or_insert_with(&mut node);
            }
        }
        for c in &doc.variables.collections {
            for m in &c.modes {
                if !self.mode_ids.contains_key(&(c.id.as_str(), m.id.as_str())) {
                    let id = self.next_aux();
                    self.mode_ids.insert((c.id.as_str(), m.id.as_str()), id);
                }
            }
        }
    }

    /// The hidden page after the `pages` real ones that holds the shared styles, the variable
    /// collections and the variables, each a node of its own.
    fn assets(&mut self, pages: usize) {
        let doc = self.doc;
        if self.style_ids.is_empty() && self.set_ids.is_empty() {
            return;
        }
        let page = u32::try_from(self.ids.len() + 1).unwrap_or(u32::MAX);
        let mut f: Fields = vec![
            ("guid", guid(LAYERS, page)),
            ("phase", e("CREATED")),
            ("parentIndex", o(vec![("guid", guid(0, 0)), ("position", s(&position(pages)))])),
            ("type", e("CANVAS")),
            ("name", s("Internal Only Canvas")),
        ];
        f.extend(root_fields().into_iter().map(|(k, v)| if k == "visible" { (k, b(false)) } else { (k, v) }));
        f.push(("internalOnly", b(true)));
        self.nodes.push(o(f));
        let mut index = 0usize;
        let mut head = |local: u32, ty: &'static str, name: &str| -> Fields {
            index += 1;
            vec![
                ("guid", guid(LAYERS, local)),
                ("phase", e("CREATED")),
                ("parentIndex", o(vec![("guid", guid(LAYERS, page)), ("position", s(&position(index)))])),
                ("type", e(ty)),
                ("name", s(name)),
                ("sortPosition", s(&position(index))),
            ]
        };
        for st in &doc.styles {
            let Some(&local) = self.style_ids.get(st.id.as_str()) else { continue };
            // A sample layer that shows the style: a square for paints and effects, a frame for
            // grids, two letters for text.
            let (ty, kind) = match &st.kind {
                StyleKind::Paint { .. } => ("ROUNDED_RECTANGLE", "FILL"),
                StyleKind::Effect { .. } => ("ROUNDED_RECTANGLE", "EFFECT"),
                StyleKind::Grid { .. } => ("FRAME", "GRID"),
                StyleKind::Text { .. } => ("TEXT", "TEXT"),
            };
            let mut f = head(local, ty, &st.name);
            f.extend([
                ("styleType", e(kind)),
                ("visible", b(true)),
                ("opacity", fl(1.0)),
                ("size", xy(100.0, 100.0)),
                ("transform", matrix(Affine::IDENTITY)),
                ("strokeWeight", fl(0.0)),
                ("strokeAlign", e("INSIDE")),
                ("strokeJoin", e("MITER")),
            ]);
            if !st.description.is_empty() {
                f.push(("description", s(&st.description)));
            }
            // The style's variable bindings ride on its sample layer, as a layer's do.
            let none = if st.bound.is_empty() {
                Bound::default()
            } else {
                let mut sample = Node::new(NodeId(0), NodeKind::Rectangle, "", 0.0, 0.0);
                if let StyleKind::Text { style } = &st.kind {
                    sample.kind = NodeKind::Text(TextData { style: style.as_text_style(), ..TextData::new("Ag") });
                }
                sample.bound.clone_from(&st.bound);
                self.bound(&sample)
            };
            let entries = none.entries.clone();
            if !entries.is_empty() {
                f.push(("variableConsumptionMap", o(vec![("entries", arr(entries))])));
            }
            match &st.kind {
                StyleKind::Paint { paints } => f.push(("fillPaints", self.paints(paints, true, &none))),
                StyleKind::Effect { effects } => {
                    let list = effects.iter().enumerate().map(|(i, x)| self.effect(x, i, &none)).collect();
                    f.extend([("fillPaints", arr(Vec::new())), ("effects", arr(list))]);
                }
                StyleKind::Grid { grids } => {
                    let list = grids.iter().enumerate().map(|(i, g)| layout_grid(g, i, &none)).collect();
                    f.extend([("fillPaints", arr(Vec::new())), ("layoutGrids", arr(list))]);
                }
                StyleKind::Text { style } => {
                    let td = TextData { style: style.as_text_style(), ..TextData::new("Ag") };
                    let fills = [Paint::solid(Color::BLACK)];
                    f.push(("fillPaints", self.paints(style.fills.as_deref().unwrap_or(&fills), true, &none)));
                    self.text(&td, &fills, &mut f);
                }
            }
            self.nodes.push(o(f));
        }
        for c in &doc.variables.collections {
            let Some(&local) = self.set_ids.get(c.id.as_str()) else { continue };
            let mut f = head(local, "VARIABLE_SET", &c.name);
            let modes = c.modes.iter().enumerate().filter_map(|(i, m)| {
                let id = self.mode_ids.get(&(c.id.as_str(), m.id.as_str()))?;
                Some(o(vec![("id", guid(AUX, *id)), ("name", s(&m.name)), ("sortPosition", s(&position(i)))]))
            });
            f.push(("variableSetModes", arr(modes.collect())));
            self.nodes.push(o(f));
            if c.extends.is_some() {
                self.warn("extended variable collections were written as collections of their own");
            }
        }
        for v in &doc.variables.variables {
            let ids = (self.var_ids.get(v.id.as_str()), self.set_ids.get(v.collection.as_str()));
            let (Some(&local), Some(&set), Some(c)) = (ids.0, ids.1, doc.variables.collections.iter().find(|c| c.id == v.collection)) else {
                self.warn("variables whose collection isn't in the document were left out");
                continue;
            };
            let resolved = resolved_type(v.kind);
            let mut values = Vec::new();
            for m in &c.modes {
                let (Some(mode), Some(val)) = (self.mode_ids.get(&(c.id.as_str(), m.id.as_str())), v.values.get(&m.id)) else { continue };
                let (ty, value) = match val {
                    VariableValue::Color(x) => ("COLOR", ("colorValue", color(*x))),
                    VariableValue::Number(x) => ("FLOAT", ("floatValue", fl(*x))),
                    // NULs can't be stored in a string.
                    VariableValue::String(x) => ("STRING", ("textValue", s(&x.replace('\0', "")))),
                    VariableValue::Boolean(x) => ("BOOLEAN", ("boolValue", b(*x))),
                    VariableValue::Alias(a) => match self.var_ids.get(a.as_str()) {
                        Some(t) => ("ALIAS", ("alias", o(vec![("guid", guid(LAYERS, *t))]))),
                        None => {
                            self.warn("variable aliases to variables that aren't in the document were left out");
                            continue;
                        }
                    },
                };
                let data = o(vec![("value", o(vec![value])), ("dataType", e(ty)), ("resolvedDataType", e(resolved))]);
                values.push(o(vec![("modeID", guid(AUX, *mode)), ("variableData", data)]));
            }
            let mut f = head(local, "VARIABLE", &v.name);
            f.extend([
                ("variableSetID", o(vec![("guid", guid(LAYERS, set))])),
                ("variableResolvedType", e(resolved)),
                ("variableDataValues", o(vec![("entries", arr(values))])),
            ]);
            if !v.description.is_empty() {
                f.push(("description", s(&v.description)));
            }
            if let Some(scopes) = &v.scopes {
                let known: Vec<Kv> = scopes.iter().filter_map(|sc| scope_name(sc)).map(e).collect();
                if known.len() < scopes.len() {
                    self.warn("variable scopes the format has no name for were left out");
                }
                f.push(("variableScopes", arr(known)));
            }
            if v.hidden_from_publishing || !v.code_syntax.is_empty() || v.extends.is_some() {
                self.warn("variables' publishing, code syntax and inheritance settings were left out");
            }
            self.nodes.push(o(f));
        }
    }

    /// A reference to variable `var` (its id or name) as variable data.
    fn alias(&mut self, var: &str) -> Option<Kv<'static>> {
        let found = self.doc.variables.get(var).and_then(|v| Some((v.kind, *self.var_ids.get(v.id.as_str())?)));
        let Some((kind, local)) = found else {
            self.warn("bindings to variables that aren't in the document were written as their values");
            return None;
        };
        Some(o(vec![
            ("value", o(vec![("alias", o(vec![("guid", guid(LAYERS, local))]))])),
            ("dataType", e("ALIAS")),
            ("resolvedDataType", e(resolved_type(kind))),
        ]))
    }

    /// Layer `n`'s variable bindings, sorted into the fields that carry them. What the format has
    /// no field for stays as the value the layer already shows, with a warning.
    fn bound(&mut self, n: &Node) -> Bound {
        const BAKED: &str = "variables bound to properties the format has no field for were written as their values";
        let mut out = Bound::default();
        for (key, var) in &n.bound {
            let parts: Vec<&str> = key.split('/').collect();
            let index = |i: &str| i.parse::<usize>().ok().filter(|_| i.bytes().all(|c| c.is_ascii_digit()));
            let fields: &[&'static str] = match (parts.as_slice(), key.as_str()) {
                (_, "fill" | "fills" | "fills/0" | "stroke") => {
                    if let Some(a) = self.alias(var) {
                        out.paints.insert((key != "stroke", 0), a);
                    }
                    continue;
                }
                ([list @ ("fills" | "strokes"), i, "color"], _) => {
                    if let (Some(i), Some(a)) = (index(i), self.alias(var)) {
                        out.paints.insert((*list == "fills", i), a);
                    }
                    continue;
                }
                ([list @ ("fills" | "strokes"), i, "stops", j, "color"], _) => {
                    if let (Some(i), Some(j), Some(a)) = (index(i), index(j), self.alias(var)) {
                        out.stops.insert((*list == "fills", i, j), a);
                    }
                    continue;
                }
                ([list @ ("effects" | "layoutGrids"), i, field], _) => {
                    let names: &[&'static str] = if *list == "effects" {
                        &["color", "radius", "spread", "offsetX", "offsetY", "startRadius"]
                    } else {
                        &["size", "count", "gutter", "offset"]
                    };
                    match (index(i), names.iter().find(|f| *f == field)) {
                        (Some(i), Some(name)) => {
                            if let Some(a) = self.alias(var) {
                                if *list == "effects" { &mut out.effects } else { &mut out.grids }.insert((i, *name), a);
                            }
                        }
                        _ => self.warn(BAKED),
                    }
                    continue;
                }
                (_, "width") => &["WIDTH"],
                (_, "height") => &["HEIGHT"],
                (_, "gap") => &["STACK_SPACING"],
                (_, "crossGap") => &["STACK_COUNTER_SPACING"],
                (_, "paddingLeft") => &["STACK_PADDING_LEFT"],
                (_, "paddingTop") => &["STACK_PADDING_TOP"],
                (_, "paddingRight") => &["STACK_PADDING_RIGHT"],
                (_, "paddingBottom") => &["STACK_PADDING_BOTTOM"],
                (_, "paddingHorizontal") => &["STACK_PADDING_LEFT", "STACK_PADDING_RIGHT"],
                (_, "paddingVertical") => &["STACK_PADDING_TOP", "STACK_PADDING_BOTTOM"],
                (_, "padding") => &["STACK_PADDING_LEFT", "STACK_PADDING_TOP", "STACK_PADDING_RIGHT", "STACK_PADDING_BOTTOM"],
                (_, "cornerRadius") => &[
                    "CORNER_RADIUS",
                    "RECTANGLE_TOP_LEFT_CORNER_RADIUS",
                    "RECTANGLE_TOP_RIGHT_CORNER_RADIUS",
                    "RECTANGLE_BOTTOM_LEFT_CORNER_RADIUS",
                    "RECTANGLE_BOTTOM_RIGHT_CORNER_RADIUS",
                ],
                (_, "topLeftRadius") => &["RECTANGLE_TOP_LEFT_CORNER_RADIUS"],
                (_, "topRightRadius") => &["RECTANGLE_TOP_RIGHT_CORNER_RADIUS"],
                (_, "bottomLeftRadius") => &["RECTANGLE_BOTTOM_LEFT_CORNER_RADIUS"],
                (_, "bottomRightRadius") => &["RECTANGLE_BOTTOM_RIGHT_CORNER_RADIUS"],
                (_, "opacity") => &["OPACITY"],
                (_, "visible") => &["VISIBLE"],
                (_, "characters") => &["TEXT_DATA"],
                (_, "strokeWeight") => &["STROKE_WEIGHT"],
                (_, "strokeTopWeight") => &["BORDER_TOP_WEIGHT"],
                (_, "strokeRightWeight") => &["BORDER_RIGHT_WEIGHT"],
                (_, "strokeBottomWeight") => &["BORDER_BOTTOM_WEIGHT"],
                (_, "strokeLeftWeight") => &["BORDER_LEFT_WEIGHT"],
                (_, "minWidth") => &["MIN_WIDTH"],
                (_, "maxWidth") => &["MAX_WIDTH"],
                (_, "minHeight") => &["MIN_HEIGHT"],
                (_, "maxHeight") => &["MAX_HEIGHT"],
                (_, "fontSize") => &["FONT_SIZE"],
                (_, "fontFamily") => &["FONT_FAMILY"],
                (_, "fontStyle") => &["FONT_STYLE"],
                (_, "letterSpacing") => &["LETTER_SPACING"],
                (_, "lineHeight") => &["LINE_HEIGHT"],
                (_, "paragraphSpacing") => &["PARAGRAPH_SPACING"],
                (_, "paragraphIndent") => &["PARAGRAPH_INDENT"],
                _ => {
                    self.warn(BAKED);
                    continue;
                }
            };
            // Each entry names the bound property and the number of the layer field that holds it.
            for field in fields {
                if let Some(a) = self.alias(var) {
                    let mut entry: Fields = node_field(field).into_iter().map(|id| ("nodeField", u(id))).collect();
                    entry.extend([("variableData", a), ("variableField", e(field))]);
                    out.entries.push(o(entry));
                }
            }
        }
        out
    }

    /// Write layer `id` (child `index` of the layer with GUID `parent_guid`) and its subtree.
    fn emit(&mut self, id: NodeId, parent_guid: Kv<'static>, index: usize, parent: Option<&Node>, depth: usize) {
        let doc = self.doc;
        let (Some(&local), Some(n)) = (self.ids.get(&id), doc.node(id)) else { return };
        if depth > MAX_DEPTH {
            self.warn("layers nested deeper than 256 levels were left out");
            return;
        }
        let mut f: Fields = vec![
            ("guid", guid(LAYERS, local)),
            ("phase", e("CREATED")),
            ("parentIndex", o(vec![("guid", parent_guid), ("position", s(&position(index)))])),
        ];
        let children = if let NodeKind::Page { background, guides, prototype, .. } = &n.kind {
            f.extend([("type", e("CANVAS")), ("name", s(&n.name))]);
            f.extend(root_fields());
            f.extend([("backgroundColor", color(*background)), ("backgroundOpacity", fl(background.a.into())), ("backgroundEnabled", b(true))]);
            if !guides.is_empty() {
                self.warn("ruler guides were left out");
            }
            if *prototype != Default::default() {
                self.warn("prototype device settings were left out");
            }
            self.modes(n, &mut f);
            true
        } else {
            self.layer(n, parent, &mut f, false)
        };
        self.nodes.push(o(f));
        if children {
            for (i, c) in n.children.iter().enumerate() {
                self.emit(*c, guid(LAYERS, local), i, Some(n), depth + 1);
            }
        }
    }

    /// The fields of layer `n` (whose parent is `parent`). `nested`: for an instance's override
    /// (no type, no instance or component data). Returns whether its children are written as
    /// layers (an instance's come from its main).
    fn layer(&mut self, n: &Node, parent: Option<&Node>, f: &mut Fields, nested: bool) -> bool {
        let doc = self.doc;
        if let Some((outline, original)) = outlined(n) {
            // The format's variable width is the same on both sides of the path: a stroke wider on
            // one side is written as the area it paints, with the stroke itself kept as plugin data
            // (which the import puts back).
            self.warn("strokes wider on one side of their path were written as filled outlines (the stroke itself is kept for FigCraft)");
            let children = self.layer(&outline, parent, f, nested);
            f.push(("pluginData", arr(vec![o(vec![("pluginID", s(STASH.0)), ("value", s(&original)), ("key", s(STASH.1))])])));
            return children;
        }
        let main = match &n.kind {
            NodeKind::Instance { component, .. } => {
                let found = self.ids.contains_key(component) && doc.node(*component).is_some_and(|c| matches!(c.kind, NodeKind::Component { .. }));
                if !found && !nested {
                    self.warn("instances of components that aren't in the file were written as frames");
                }
                found.then_some(*component)
            }
            _ => None,
        };
        let ty = match &n.kind {
            NodeKind::Page { .. } | NodeKind::Frame | NodeKind::Group | NodeKind::ComponentSet { .. } => "FRAME",
            NodeKind::Instance { .. } if main.is_none() => "FRAME",
            NodeKind::Section { .. } => "SECTION",
            NodeKind::Rectangle => "ROUNDED_RECTANGLE",
            NodeKind::Ellipse { .. } => "ELLIPSE",
            NodeKind::Polygon { .. } => "REGULAR_POLYGON",
            NodeKind::Star { .. } => "STAR",
            NodeKind::Line => "LINE",
            NodeKind::Vector { .. } => "VECTOR",
            NodeKind::Text(_) => "TEXT",
            NodeKind::BooleanOp { .. } => "BOOLEAN_OPERATION",
            NodeKind::Component { .. } => "SYMBOL",
            NodeKind::Instance { .. } => "INSTANCE",
            NodeKind::Slice => "SLICE",
        };
        if !nested {
            f.push(("type", e(ty)));
        }
        f.push(("name", s(&n.name)));
        self.common(n, parent, f);
        match &n.kind {
            NodeKind::Group => f.push(("resizeToFit", b(true))),
            NodeKind::Section { contents_hidden } => f.push(("sectionContentsHidden", b(*contents_hidden))),
            NodeKind::Ellipse { start, sweep, inner } => {
                f.push(("arcData", o(vec![("startingAngle", fl(*start)), ("endingAngle", fl(start + sweep)), ("innerRadius", fl(*inner))])))
            }
            NodeKind::Polygon { count } => f.push(("count", u(*count))),
            NodeKind::Star { count, inner_ratio } => f.extend([("count", u(*count)), ("starInnerScale", fl(*inner_ratio))]),
            NodeKind::Vector { network } => self.vector(n, network, f),
            NodeKind::Text(td) => self.text(td, &n.fills, f),
            NodeKind::BooleanOp { op } => {
                let name = match op {
                    BoolOp::Union => "UNION",
                    BoolOp::Subtract => "SUBTRACT",
                    BoolOp::Intersect => "INTERSECT",
                    BoolOp::Exclude => "XOR",
                };
                f.push(("booleanOperation", e(name)));
                if n.children.iter().filter_map(|c| doc.node(*c)).any(|c| c.bool_op.is_some()) {
                    self.warn("boolean groups whose layers combine in different ways use the group's operation");
                }
            }
            NodeKind::Component { description, props } if !nested => {
                let defs: Vec<Kv> = props.iter().filter_map(|(name, d)| self.prop_def(name, d)).collect();
                if !defs.is_empty() {
                    f.push(("componentPropDefs", arr(defs)));
                }
                if props.values().any(|d| matches!(d, PropDef::Slot { .. })) {
                    self.warn("slot properties were left out");
                }
                if !description.is_empty() {
                    f.push(("symbolDescription", s(description)));
                }
            }
            NodeKind::ComponentSet { description } if !nested => {
                f.push(("isStateGroup", b(true)));
                if !description.is_empty() {
                    f.push(("symbolDescription", s(description)));
                }
            }
            NodeKind::Instance { props, .. } if !nested => {
                if let Some(main) = main {
                    self.instance(n, main, props, f);
                }
            }
            _ => {}
        }
        let boxy = n.kind.is_frame_like() || matches!(n.kind, NodeKind::Rectangle | NodeKind::Section { .. });
        if (boxy || matches!(n.kind, NodeKind::Ellipse { .. } | NodeKind::Polygon { .. } | NodeKind::Star { .. }))
            && let Some(p) = figcraft_doc::geometry::shape_path(n)
        {
            self.geometry("fillGeometry", &p, WindingRule::NonZero, f);
        }
        self.stroke_geometry(n, boxy, f);
        main.is_none()
    }

    /// Fields every layer kind shares.
    fn common(&mut self, n: &Node, parent: Option<&Node>, f: &mut Fields) {
        f.extend([
            ("visible", b(n.visible)),
            ("locked", b(n.locked)),
            ("opacity", fl(n.opacity.into())),
            ("blendMode", e(blend_name(n.blend))),
            ("size", xy(n.width, n.height)),
            ("transform", matrix(n.transform)),
        ]);
        if n.is_mask {
            let ty = match n.mask_type {
                MaskType::Alpha => "ALPHA",
                MaskType::Vector => "OUTLINE",
                MaskType::Luminance => "LUMINANCE",
            };
            f.extend([("mask", b(true)), ("maskType", e(ty))]);
        }
        let bound = self.bound(n);
        // Text whose own style sets fills paints with them (the layer's fills only show through
        // runs); a variable bound to the layer's fill colours the layer's.
        let fills = match &n.kind {
            NodeKind::Text(TextData { style: TextStyle { fills: Some(own), .. }, .. }) => self.paints(own, true, &Bound::default()),
            _ => self.paints(&n.fills, true, &bound),
        };
        let strokes = self.paints(&n.strokes, false, &bound);
        f.extend([("fillPaints", fills), ("strokePaints", strokes)]);
        self.stroke(n, f);
        if !n.effects.is_empty() {
            let effects = n.effects.iter().enumerate().map(|(i, x)| self.effect(x, i, &bound)).collect();
            f.push(("effects", arr(effects)));
        }
        if n.kind.has_corner_radius() {
            let r = n.corners.radii;
            f.push(("cornerRadius", fl(r[0])));
            let differ = r.iter().any(|x| *x != r[0]);
            if n.kind.has_independent_corners() && (differ || r[0] > 0.0) {
                f.extend(differ.then(|| ("rectangleCornerRadiiIndependent", b(true))));
                f.extend([
                    ("rectangleTopLeftCornerRadius", fl(r[0])),
                    ("rectangleTopRightCornerRadius", fl(r[1])),
                    ("rectangleBottomRightCornerRadius", fl(r[2])),
                    ("rectangleBottomLeftCornerRadius", fl(r[3])),
                ]);
            }
            if n.corners.smoothing > 0.0 {
                f.push(("cornerSmoothing", fl(n.corners.smoothing)));
            }
        }
        let h = match n.constraints.horizontal {
            HConstraint::Left => "MIN",
            HConstraint::Right => "MAX",
            HConstraint::LeftRight => "STRETCH",
            HConstraint::Center => "CENTER",
            HConstraint::Scale => "SCALE",
        };
        let v = match n.constraints.vertical {
            VConstraint::Top => "MIN",
            VConstraint::Bottom => "MAX",
            VConstraint::TopBottom => "STRETCH",
            VConstraint::Center => "CENTER",
            VConstraint::Scale => "SCALE",
        };
        f.extend([("horizontalConstraint", e(h)), ("verticalConstraint", e(v))]);
        if n.kind.is_frame_like() || matches!(n.kind, NodeKind::Section { .. }) {
            f.push(("frameMaskDisabled", b(!n.clip)));
        }
        if n.kind.is_frame_like() {
            if let Some(l) = &n.layout {
                self.auto_layout(n, l, f);
            }
            if !n.grids.is_empty() {
                f.push(("layoutGrids", arr(n.grids.iter().enumerate().map(|(i, g)| layout_grid(g, i, &bound)).collect())));
            }
        }
        self.child_layout(n, parent, f);
        if !n.exports.is_empty() {
            if n.exports.iter().any(|x| x.format == figcraft_doc::ExportFormat::Webp) {
                self.warn("WebP export settings were written as PNG");
            }
            f.push(("exportSettings", arr(n.exports.iter().map(export_setting).collect())));
        }
        self.prototype(n, f);
        let refs: Vec<Kv> = n.prop_refs.iter().filter_map(|(field, prop)| self.prop_ref(field, prop)).collect();
        if !refs.is_empty() {
            f.push(("parameterConsumptionMap", o(vec![("entries", arr(refs))])));
        }
        let text = matches!(n.kind, NodeKind::Text(_));
        let links = [
            ("styleIdForFill", &n.styles.fill, true),
            ("styleIdForStrokeFill", &n.styles.stroke, true),
            ("styleIdForEffect", &n.styles.effect, true),
            ("styleIdForGrid", &n.styles.grid, n.kind.is_frame_like()),
            ("styleIdForText", &n.styles.text, text),
        ];
        for (key, id, fits) in links {
            let Some(id) = id else { continue };
            match self.style_ids.get(id.as_str()).filter(|_| fits) {
                Some(local) => f.push((key, o(vec![("guid", guid(LAYERS, *local))]))),
                None => self.warn("links to shared styles that aren't in the document were left out (their layers keep the values)"),
            }
        }
        if let NodeKind::Text(td) = &n.kind
            && n.styles.text.is_none()
            && std::iter::once(&td.style).chain(td.runs.iter().map(|r| &r.style)).any(|st| st.style_id.is_some())
        {
            self.warn("text styles applied to part of a text were written as their values");
        }
        if !bound.entries.is_empty() {
            f.push(("variableConsumptionMap", o(vec![("entries", arr(bound.entries))])));
        }
        self.modes(n, f);
        if !n.guides.is_empty() {
            self.warn("ruler guides were left out");
        }
        if !n.annotations.is_empty() || !n.dev_resources.is_empty() || !n.code_links.is_empty() || !n.dev_status.is_none() {
            self.warn("Dev Mode annotations, statuses, resources and code links were left out");
        }
        if !n.plugin_data.is_empty() {
            self.warn("plugin data was left out");
        }
    }

    /// The variable modes layer (or page) `n` sets for what is in it.
    fn modes(&mut self, n: &Node, f: &mut Fields) {
        let mut entries = Vec::new();
        for (coll, mode) in &n.var_modes {
            match (self.set_ids.get(coll.as_str()), self.mode_ids.get(&(coll.as_str(), mode.as_str()))) {
                (Some(set), Some(mode)) => {
                    entries.push(o(vec![("variableSetID", o(vec![("guid", guid(LAYERS, *set))])), ("variableModeID", guid(AUX, *mode))]));
                }
                _ => self.warn("variable modes of collections that aren't in the document were left out"),
            }
        }
        if !entries.is_empty() {
            f.push(("variableModeBySetMap", o(vec![("entries", arr(entries))])));
        }
    }

    /// A paint list: a layer's fills (`fills`) or strokes with the variables `bound` to them.
    fn paints(&mut self, list: &[Paint], fills: bool, bound: &Bound) -> Kv<'static> {
        arr(list.iter().enumerate().filter_map(|(i, p)| self.paint(p, (fills, i), bound)).collect())
    }

    fn paint(&mut self, p: &Paint, at: (bool, usize), bound: &Bound) -> Option<Kv<'static>> {
        let mut f: Fields = vec![("visible", b(p.visible)), ("blendMode", e(blend_name(p.blend)))];
        let mut opacity = f64::from(p.opacity);
        match &p.kind {
            PaintKind::Solid { color: c } => {
                opacity *= f64::from(c.a);
                f.extend([("type", e("SOLID")), ("color", color(c.with_alpha(1.0)))]);
                f.extend(bound.paints.get(&at).map(|a| ("colorVar", a.clone())));
            }
            PaintKind::Gradient(g) => {
                let ty = match g.kind {
                    GradientKind::Linear => "GRADIENT_LINEAR",
                    GradientKind::Radial => "GRADIENT_RADIAL",
                    GradientKind::Angular => "GRADIENT_ANGULAR",
                    GradientKind::Diamond => "GRADIENT_DIAMOND",
                };
                // The handles in the unit box come from the inverse of the paint transform: it maps
                // (0, ½) → start, (1, ½) → end, (0, 1) → width for linear gradients, and the centre
                // (½, ½) and the points half a box away from it for the others.
                let (from, to, width) = (g.from, g.to, g.width);
                let (ax, ay) =
                    if g.kind == GradientKind::Linear { (to.0 - from.0, to.1 - from.1) } else { (2.0 * (to.0 - from.0), 2.0 * (to.1 - from.1)) };
                let (cx, cy) = (2.0 * (width.0 - from.0), 2.0 * (width.1 - from.1));
                let (ex, ey) = if g.kind == GradientKind::Linear {
                    (from.0 - 0.5 * cx, from.1 - 0.5 * cy)
                } else {
                    (from.0 - 0.5 * (ax + cx), from.1 - 0.5 * (ay + cy))
                };
                let handles = Affine::new([ax, ay, cx, cy, ex, ey]);
                let t = if handles.determinant().abs() > 1e-12 && handles.as_coeffs().iter().all(|x| x.is_finite()) {
                    handles.inverse()
                } else {
                    self.warn("gradients with handles on one line were written with the default direction");
                    Affine::IDENTITY
                };
                let stops = g.stops.iter().map(|st| o(vec![("color", color(st.color)), ("position", fl(st.position.into()))])).collect();
                f.extend([("type", e(ty)), ("stops", arr(stops)), ("transform", matrix(t))]);
                // Stops bound to variables: every stop again, the bound ones with their variable.
                if bound.stops.range((at.0, at.1, 0)..=(at.0, at.1, usize::MAX)).next().is_some() {
                    let vars = g.stops.iter().enumerate().map(|(j, st)| {
                        let mut sf: Fields = vec![("color", color(st.color))];
                        sf.extend(bound.stops.get(&(at.0, at.1, j)).map(|a| ("colorVar", a.clone())));
                        sf.push(("position", fl(st.position.into())));
                        o(sf)
                    });
                    f.push(("stopsVar", arr(vars.collect())));
                }
            }
            PaintKind::Image(img) => {
                let hash = self.image(&img.image);
                let mode = match img.scale_mode {
                    ImageScaleMode::Fill => "FILL",
                    ImageScaleMode::Fit => "FIT",
                    ImageScaleMode::Crop => "STRETCH",
                    ImageScaleMode::Tile => "TILE",
                };
                f.extend([
                    ("type", e("IMAGE")),
                    ("image", o(vec![("hash", Kv::Bytes(hash)), ("name", s(""))])),
                    ("imageScaleMode", e(mode)),
                    ("rotation", fl(f64::from(img.rotation.rem_euclid(4)) * 90.0)),
                    ("scale", fl(img.scale)),
                ]);
                if let (ImageScaleMode::Crop, Some(c)) = (img.scale_mode, img.crop) {
                    f.push(("transform", matrix(Affine::new(c))));
                }
                if img.filters != Default::default() {
                    self.warn("image adjustments (exposure, contrast, …) were left out");
                }
            }
            PaintKind::Pattern(_) => {
                self.warn("pattern fills were left out");
                return None;
            }
        }
        f.push(("opacity", fl(opacity)));
        Some(o(f))
    }

    /// The hash bytes of image `key`, writing its file once (empty when its bytes aren't there).
    fn image(&mut self, key: &str) -> Vec<u8> {
        let hex = match self.images.get(key) {
            Some(h) => h.clone(),
            None => {
                let h = match self.doc.images.get(key) {
                    Some(img) if img.bytes.len() as u64 <= MAX_IMAGE => {
                        let h = crate::image_hash(&img.bytes);
                        if !self.files.iter().any(|(x, _)| *x == h) {
                            self.files.push((h.clone(), img.bytes.clone()));
                        }
                        Some(h)
                    }
                    Some(_) => {
                        self.warn("images larger than 256 MB were left out");
                        None
                    }
                    None => {
                        self.warn("image fills whose image isn't in the document were written without one");
                        None
                    }
                };
                self.images.insert(key.to_string(), h.clone());
                h
            }
        };
        let hex = hex.unwrap_or_default();
        (0..hex.len() / 2).filter_map(|i| hex.get(2 * i..2 * i + 2).and_then(|d| u8::from_str_radix(d, 16).ok())).collect()
    }

    fn stroke(&mut self, n: &Node, f: &mut Fields) {
        let sp = &n.stroke;
        let align = match sp.align {
            StrokeAlign::Inside => "INSIDE",
            StrokeAlign::Center => "CENTER",
            StrokeAlign::Outside => "OUTSIDE",
        };
        f.extend([
            ("strokeWeight", fl(sp.weight)),
            ("strokeAlign", e(align)),
            ("strokeJoin", e(join_name(sp.join))),
            ("strokeCap", e(cap_name(sp.cap_start))),
            ("miterLimit", fl(sp.miter_limit)),
        ]);
        if !sp.dashes.is_empty() {
            f.push(("dashPattern", arr(sp.dashes.iter().map(|d| fl(*d)).collect())));
        }
        if let Some([t, r, bo, l]) = sp.sides {
            f.extend([
                ("borderStrokeWeightsIndependent", b(true)),
                ("borderTopWeight", fl(t)),
                ("borderRightWeight", fl(r)),
                ("borderBottomWeight", fl(bo)),
                ("borderLeftWeight", fl(l)),
            ]);
        }
        // A variable width: how far the stroke reaches on each side of the path at positions along
        // its length, as a share of the stroke weight (half of it each for the full weight). The
        // two sides are the same: a reader draws nothing for a point with unequal sides.
        if let Some(p) = sp.profile().filter(|_| sp.weight.is_finite() && sp.weight > 0.0) {
            let point = |q: &figcraft_doc::WidthPoint| o(vec![("position", fl(q.t)), ("ascent", fl(q.scale / 2.0)), ("descent", fl(q.scale / 2.0))]);
            let p = p.sanitized();
            if one_sided(&p) {
                self.warn("strokes wider on one side of their path were written with that width on both sides");
            }
            f.push(("variableWidthPoints", arr(p.points.iter().map(point).collect())));
        }
        if sp.brush.is_some() {
            self.warn("brush strokes were written as plain strokes");
        }
        if [sp.cap_start, sp.cap_end].contains(&StrokeCap::ReversedTriangle) {
            self.warn("reversed triangle stroke ends were written as triangle arrows");
        }
        // Vectors keep each end's cap on their end points; other layers have one cap.
        if sp.cap_start != sp.cap_end && !matches!(n.kind, NodeKind::Vector { .. }) {
            self.warn("lines with different stroke ends use the start's at both ends");
        }
    }

    /// Effect `index` of a layer, with the variables `bound` to its fields.
    fn effect(&mut self, x: &figcraft_doc::Effect, index: usize, bound: &Bound) -> Kv<'static> {
        let mut f: Fields = vec![("visible", b(x.visible))];
        let vars = [
            ("color", "colorVar"),
            ("radius", "radiusVar"),
            ("spread", "spreadVar"),
            ("offsetX", "xVar"),
            ("offsetY", "yVar"),
            ("startRadius", "startRadiusVar"),
        ];
        f.extend(vars.into_iter().filter_map(|(ours, key)| Some((key, bound.effects.get(&(index, ours))?.clone()))));
        let blur = |f: &mut Fields, ty: &'static str, bl: &figcraft_doc::Blur| {
            f.extend([("type", e(ty)), ("radius", fl(bl.radius))]);
            if bl.blur_type == figcraft_doc::BlurType::Progressive {
                f.extend([
                    ("blurOpType", e("PROGRESSIVE")),
                    ("startRadius", fl(bl.start_radius)),
                    ("startOffset", xy(bl.start.0, bl.start.1)),
                    ("endOffset", xy(bl.end.0, bl.end.1)),
                ]);
            }
        };
        let grain = |size: f64, size_y: Option<f64>| xy(size, size_y.unwrap_or(size));
        match &x.kind {
            EffectKind::DropShadow(sh) | EffectKind::InnerShadow(sh) => {
                let ty = if matches!(x.kind, EffectKind::DropShadow(_)) { "DROP_SHADOW" } else { "INNER_SHADOW" };
                f.extend([
                    ("type", e(ty)),
                    ("color", color(sh.color)),
                    ("offset", xy(sh.offset.0, sh.offset.1)),
                    ("radius", fl(sh.radius)),
                    ("spread", fl(sh.spread)),
                    ("blendMode", e(blend_name(sh.blend))),
                    ("showShadowBehindNode", b(sh.show_behind)),
                ]);
            }
            EffectKind::LayerBlur(bl) => blur(&mut f, "FOREGROUND_BLUR", bl),
            EffectKind::BackgroundBlur(bl) => blur(&mut f, "BACKGROUND_BLUR", bl),
            EffectKind::Noise(nz) => {
                let mode = match nz.mode {
                    NoiseMode::Mono => "MONOTONE",
                    NoiseMode::Duo => "DUOTONE",
                    NoiseMode::Multi => "MULTITONE",
                };
                f.extend([
                    ("type", e("NOISE")),
                    ("noiseType", e(mode)),
                    ("noiseSize", grain(nz.size, nz.size_y)),
                    ("density", fl(nz.density)),
                    ("color", color(nz.color)),
                    ("secondaryColor", color(nz.secondary)),
                    ("opacity", fl(nz.opacity.into())),
                    ("blendMode", e(blend_name(nz.blend))),
                ]);
            }
            EffectKind::Texture(t) => {
                f.extend([
                    ("type", e("GRAIN")),
                    ("noiseSize", grain(t.size, t.size_y)),
                    ("radius", fl(t.radius)),
                    ("clipToShape", b(t.clip_to_shape)),
                ]);
            }
            EffectKind::Glass(g) => {
                self.warn("glass effects keep only their frost");
                f.extend([("type", e("GLASS")), ("radius", fl(g.frost))]);
            }
        }
        o(f)
    }

    fn auto_layout(&mut self, n: &Node, l: &AutoLayout, f: &mut Fields) {
        let grid = l.mode == LayoutMode::Grid;
        let mode = match l.mode {
            LayoutMode::Horizontal => "HORIZONTAL",
            LayoutMode::Vertical => "VERTICAL",
            LayoutMode::Grid => "GRID",
        };
        let [top, right, bottom, left] = l.padding;
        let main = match l.main_align {
            MainAlign::Min => "MIN",
            MainAlign::Center => "CENTER",
            MainAlign::Max => "MAX",
            MainAlign::SpaceBetween => "SPACE_BETWEEN",
            MainAlign::SpaceAround => "SPACE_AROUND",
            MainAlign::SpaceEvenly => "SPACE_EVENLY",
        };
        let cross = match l.cross_align {
            CrossAlign::Min => "MIN",
            CrossAlign::Center => "CENTER",
            CrossAlign::Max => "MAX",
            CrossAlign::Baseline => "BASELINE",
        };
        // The main axis is the width for horizontal and grid layouts.
        let (main_hug, cross_hug) = {
            let (h, v) = (n.child_layout.sizing_h == Sizing::Hug, n.child_layout.sizing_v == Sizing::Hug);
            if l.mode == LayoutMode::Vertical { (v, h) } else { (h, v) }
        };
        let size = |hug: bool| e(if hug { "RESIZE_TO_FIT" } else { "FIXED" });
        f.extend([
            ("stackMode", e(mode)),
            ("stackWrap", e(if l.wrap { "WRAP" } else { "NO_WRAP" })),
            ("stackHorizontalPadding", fl(left)),
            ("stackVerticalPadding", fl(top)),
            ("stackPaddingRight", fl(right)),
            ("stackPaddingBottom", fl(bottom)),
            ("stackPrimaryAlignItems", e(main)),
            ("stackCounterAlignItems", e(cross)),
            ("stackPrimarySizing", size(main_hug)),
            ("stackCounterSizing", size(cross_hug)),
            ("bordersTakeSpace", b(l.strokes_included)),
            ("stackReverseZIndex", b(l.reverse_z)),
        ]);
        if grid {
            // Instance layers share their main layer's track ids, so unchanged tracks and the cells
            // their layers sit in still match.
            let key = self.main_layer(n.id);
            let (want_c, want_r) = (l.grid_columns.min(1000) as usize, l.grid_rows.min(1000) as usize);
            let (cols, rows) = match self.tracks.get(&key) {
                Some((c, r)) if (c.len(), r.len()) == (want_c, want_r) => (c.clone(), r.clone()),
                _ => ((0..want_c).map(|_| self.next_aux()).collect(), (0..want_r).map(|_| self.next_aux()).collect()),
            };
            let map = |ids: &[u32]| {
                o(vec![(
                    "entries",
                    arr(ids.iter().enumerate().map(|(i, t)| o(vec![("id", guid(AUX, *t)), ("position", s(&position(i)))])).collect()),
                )])
            };
            f.extend([("gridColumnGap", fl(l.gap)), ("gridRowGap", fl(l.cross_gap)), ("gridColumns", map(&cols)), ("gridRows", map(&rows))]);
            if l.column_tracks.iter().chain(&l.row_tracks).any(|t| t.sizing != Sizing::Fill) {
                self.warn("grid tracks of fixed or content size were written as equal tracks");
            }
            self.tracks.insert(key, (cols, rows));
        } else {
            let spread = l.content_align == ContentAlign::SpaceBetween;
            f.extend([
                ("stackSpacing", fl(l.gap)),
                ("stackCounterSpacing", fl(l.cross_gap)),
                ("stackCounterAlignContent", e(if spread { "SPACE_BETWEEN" } else { "AUTO" })),
            ]);
        }
    }

    /// How a layer sizes and sits in its auto layout parent. Min/max sizes are the layer's own
    /// and are written whatever its parent is.
    fn child_layout(&mut self, n: &Node, parent: Option<&Node>, f: &mut Fields) {
        let cl = &n.child_layout;
        for (key, w, h) in [("minSize", cl.min_w, cl.min_h), ("maxSize", cl.max_w, cl.max_h)] {
            if w.is_some() || h.is_some() {
                f.push((key, o(vec![("value", xy(w.unwrap_or(0.0), h.unwrap_or(0.0)))])));
            }
        }
        let Some(pl) = parent.and_then(|p| p.layout.as_ref()) else { return };
        let (fill_h, fill_v) = (cl.sizing_h == Sizing::Fill, cl.sizing_v == Sizing::Fill);
        let (grow, stretch) = if pl.mode == LayoutMode::Vertical { (fill_v, fill_h) } else { (fill_h, fill_v) };
        if grow {
            f.push(("stackChildPrimaryGrow", fl(1.0)));
        }
        if stretch {
            f.push(("stackChildAlignSelf", e("STRETCH")));
        }
        if cl.absolute {
            f.push(("stackPositioning", e("ABSOLUTE")));
        }
        if pl.mode == LayoutMode::Grid
            && let Some((cols, rows)) = parent.and_then(|p| self.tracks.get(&self.main_layer(p.id)))
        {
            let anchor = |ids: &[u32], i: Option<u32>| i.and_then(|i| ids.get(i as usize)).map(|t| guid(AUX, *t));
            let (c, r) = (anchor(cols, cl.grid_column), anchor(rows, cl.grid_row));
            f.extend(c.map(|g| ("gridColumnAnchor", g)));
            f.extend(r.map(|g| ("gridRowAnchor", g)));
            if cl.grid_column_span > 0 {
                f.push(("gridColumnSpan", int(cl.grid_column_span.into())));
            }
            if cl.grid_row_span > 0 {
                f.push(("gridRowSpan", int(cl.grid_row_span.into())));
            }
        }
    }

    /// Text: its style, box settings, and characters with their styled runs. `fills`: the layer's
    /// (what runs without fills of their own show when the text's own style sets other fills).
    fn text(&mut self, td: &TextData, fills: &[Paint], f: &mut Fields) {
        style_fields(&td.style, f);
        let (ha, va) = (
            match td.align_h {
                TextAlignH::Left => "LEFT",
                TextAlignH::Center => "CENTER",
                TextAlignH::Right => "RIGHT",
                TextAlignH::Justified => "JUSTIFIED",
            },
            match td.align_v {
                TextAlignV::Top => "TOP",
                TextAlignV::Middle => "CENTER",
                TextAlignV::Bottom => "BOTTOM",
            },
        );
        let resize = match td.auto_resize {
            TextAutoResize::WidthAndHeight => "WIDTH_AND_HEIGHT",
            TextAutoResize::Height => "HEIGHT",
            TextAutoResize::None | TextAutoResize::Truncate => "NONE",
        };
        f.extend([
            ("textAlignHorizontal", e(ha)),
            ("textAlignVertical", e(va)),
            ("textAutoResize", e(resize)),
            ("paragraphSpacing", fl(td.paragraph_spacing)),
            ("paragraphIndent", fl(td.paragraph_indent)),
            ("autoRename", b(false)),
            ("fontVariantCommonLigatures", b(true)),
            ("fontVariantContextualLigatures", b(true)),
            ("fontVersion", s("")),
            ("textUserLayoutVersion", u(5)),
            ("textExplicitLayoutVersion", u(1)),
            ("textBidiVersion", u(1)),
            ("textTracking", fl(0.0)),
            ("textDecorationSkipInk", b(true)),
            ("emojiImageSet", e("APPLE")),
        ]);
        if td.auto_resize == TextAutoResize::Truncate {
            f.push(("textTruncation", e("ENDING")));
        }
        if td.max_lines > 0 {
            f.push(("maxLines", int(td.max_lines.into())));
        }
        // Styles per UTF-16 unit: 0 for the base style, else an entry of the override table.
        if td.char_count() > MAX_CHARS {
            self.warn("text longer than 1,048,576 characters was cut");
        }
        let spans = td.spans();
        let mut table: Vec<&TextStyle> = Vec::new();
        let mut span_ids = Vec::with_capacity(spans.len());
        for (_, _, st) in &spans {
            span_ids.push(if **st == td.style {
                0
            } else {
                let i = table.iter().position(|t| *t == *st).unwrap_or_else(|| {
                    table.push(st);
                    table.len() - 1
                });
                i as u32 + 1
            });
        }
        let mut chars = String::new();
        let mut ids: Vec<Kv> = Vec::new();
        let mut span = 0;
        for (i, ch) in td.characters.chars().take(MAX_CHARS).enumerate() {
            while spans.get(span).is_some_and(|sp| i >= sp.1) {
                span += 1;
            }
            // NULs can't be stored in a string.
            if ch == '\0' {
                continue;
            }
            chars.push(ch);
            let id = span_ids.get(span).copied().unwrap_or(0);
            ids.extend((0..ch.len_utf16()).map(|_| u(id)));
        }
        let mut data: Fields = vec![("characters", Kv::Str(chars))];
        if !table.is_empty() {
            let entries = table
                .iter()
                .zip(1u32..)
                .map(|(st, id)| {
                    let mut ef: Fields = vec![("styleID", u(id))];
                    style_fields(st, &mut ef);
                    // An empty link clears the text's own (a missing one would inherit it).
                    if st.link.is_none() && td.style.link.is_some() {
                        ef.push(("hyperlink", o(vec![("url", s(""))])));
                    }
                    if let Some(p) = st.fills.as_deref().or(td.style.fills.as_ref().map(|_| fills)) {
                        ef.push(("fillPaints", self.paints(p, true, &Bound::default())));
                    }
                    o(ef)
                })
                .collect();
            data.extend([("characterStyleIDs", arr(ids)), ("styleOverrideTable", arr(entries))]);
        }
        let lists: Vec<ListStyle> = (0..td.paragraph_count()).map(|p| td.para_list(p).list).collect();
        // One entry per paragraph, each with every field a reader expects.
        let line = |(i, l): (usize, &ListStyle)| {
            let ty = match l {
                ListStyle::None => "PLAIN",
                ListStyle::Numbered => "ORDERED_LIST",
                ListStyle::Bulleted => "UNORDERED_LIST",
            };
            let listed = *l != ListStyle::None;
            let first = listed && (i == 0 || lists.get(i - 1) != Some(l));
            o(vec![
                ("lineType", e(ty)),
                ("styleId", int(0)),
                ("indentationLevel", int(i64::from(listed))),
                ("sourceDirectionality", e("AUTO")),
                ("listStartOffset", int(0)),
                ("isFirstLineOfList", b(first)),
            ])
        };
        data.push(("lines", arr(lists.iter().enumerate().map(line).collect())));
        f.push(("textData", o(data)));
        if (0..td.paragraph_count()).any(|p| td.para_list(p).indent > 0) {
            self.warn("nested list levels were written as the first level");
        }
        let styles = std::iter::once(&td.style).chain(td.runs.iter().map(|r| &r.style));
        if styles.clone().any(|st| st.decoration_look.is_some() || !st.variations.is_empty()) {
            self.warn("text decoration looks and variable font settings were left out");
        }
        if td.path.is_some() {
            self.warn("text on a path was written as plain text");
        }
        if td.list_spacing != 0.0 || td.hanging_punctuation || td.hanging_list || td.leading_trim != Default::default() || !td.features.is_empty() {
            self.warn("list spacing, hanging punctuation, leading trim and OpenType features were left out");
        }
    }

    /// The editable network (with per-point corner radii, handle mirroring and end caps) and,
    /// when it has filled areas, their outline.
    fn vector(&mut self, n: &Node, net: &VectorNetwork, f: &mut Fields) {
        let entries: usize = net.regions.iter().flat_map(|r| &r.loops).map(Vec::len).sum();
        if net.vertices.len() + net.segments.len() + entries > MAX_NETWORK {
            self.warn("vector networks too large for the format were written as outlines");
        } else {
            // The stroke starts at the first end point and stops at the last: the layer's end caps go
            // there (where the point has none of its own).
            let mut degree = vec![0usize; net.vertices.len()];
            for sg in &net.segments {
                for i in [sg.a, sg.b] {
                    if let Some(d) = degree.get_mut(i) {
                        *d += 1;
                    }
                }
            }
            let ends: Vec<usize> = (0..degree.len()).filter(|i| degree.get(*i) == Some(&1)).collect();
            let (first, last) = (ends.first().copied(), ends.last().copied());
            let caps_differ = n.stroke.cap_start != n.stroke.cap_end || net.vertices.iter().any(|v| v.cap.is_some());
            let mut styles: Vec<Fields> = Vec::new();
            let mut style_of = |fields: Fields| -> u32 {
                if fields.is_empty() {
                    return 0;
                }
                let i = styles.iter().position(|x| *x == fields).unwrap_or_else(|| {
                    styles.push(fields);
                    styles.len() - 1
                });
                i as u32 + 1
            };
            let vertices = net
                .vertices
                .iter()
                .enumerate()
                .map(|(i, v)| {
                    let mut st: Fields = Vec::new();
                    if v.radius > 0.0 {
                        st.push(("cornerRadius", fl(v.radius)));
                    }
                    if let Some(m) = v.mirror {
                        st.push((
                            "handleMirroring",
                            e(match m {
                                figcraft_doc::HandleMirroring::None => "NONE",
                                figcraft_doc::HandleMirroring::Angle => "ANGLE",
                                figcraft_doc::HandleMirroring::AngleAndLength => "ANGLE_AND_LENGTH",
                            }),
                        ));
                    }
                    let end_cap = if Some(i) == first {
                        Some(n.stroke.cap_start)
                    } else if Some(i) == last {
                        Some(n.stroke.cap_end)
                    } else {
                        None
                    };
                    if let Some(c) = v.cap.or(end_cap.filter(|_| caps_differ)) {
                        st.push(("strokeCap", e(cap_name(c))));
                    }
                    if let Some(j) = v.join {
                        st.push(("strokeJoin", e(join_name(j))));
                    }
                    network::Vertex { style: style_of(st), x: finite(v.x), y: finite(v.y) }
                })
                .collect();
            let segments = net
                .segments
                .iter()
                .map(|sg| network::Segment { a: sg.a, ta: (finite(sg.ta.0), finite(sg.ta.1)), b: sg.b, tb: (finite(sg.tb.0), finite(sg.tb.1)) })
                .collect();
            let regions = net
                .regions
                .iter()
                .map(|r| network::Region { style: 0, non_zero: r.winding == WindingRule::NonZero, loops: r.loops.clone() })
                .collect();
            let blob = network::encode(&network::Network { vertices, segments, regions });
            let table = styles.into_iter().zip(1u32..).map(|(mut st, id)| {
                st.insert(0, ("styleID", u(id)));
                o(st)
            });
            let table: Vec<Kv> = table.collect();
            if let Some(i) = self.blob(blob) {
                f.push((
                    "vectorData",
                    o(vec![("vectorNetworkBlob", u(i)), ("normalizedSize", xy(n.width, n.height)), ("styleOverrideTable", arr(table))]),
                ));
            }
        }
        if !net.regions.is_empty() {
            let winding = net.regions.first().map(|r| r.winding).unwrap_or_default();
            if net.regions.iter().any(|r| r.winding != winding) {
                self.warn("vectors whose filled areas use different winding rules use the first one's in their outline");
            }
            self.geometry("fillGeometry", &net.fill_path(), winding, f);
        }
    }

    /// `fillGeometry` or `strokeGeometry` (`key`) from a local path.
    fn geometry(&mut self, key: &'static str, p: &BezPath, winding: WindingRule, f: &mut Fields) {
        if p.elements().is_empty() {
            return;
        }
        if let Some(i) = self.blob(path_blob(p)) {
            let rule = if winding == WindingRule::EvenOdd { "ODD" } else { "NONZERO" };
            f.push((key, arr(vec![o(vec![("windingRule", e(rule)), ("commandsBlob", u(i)), ("styleID", u(0))])])));
        }
    }

    /// `strokeGeometry`, the outline of a plain stroke: a ring around boxes and whole ellipses, the
    /// widened path of other centred strokes. Dashed, per-side and other strokes get none (a reader
    /// builds theirs from the stroke settings).
    fn stroke_geometry(&mut self, n: &Node, boxy: bool, f: &mut Fields) {
        let sp = &n.stroke;
        let (w, h, weight) = (n.width, n.height, sp.weight);
        let plain = n.strokes.iter().any(|p| p.visible) && sp.dashes.is_empty() && sp.sides.is_none() && sp.profile().is_none() && sp.brush.is_none();
        if !plain || !(weight.is_finite() && weight > 0.0 && w.is_finite() && h.is_finite()) {
            return;
        }
        let whole = matches!(n.kind, NodeKind::Ellipse { sweep, inner, .. } if inner == 0.0 && sweep.abs() >= std::f64::consts::TAU - 1e-9);
        if boxy || whole {
            let (out, inset) = match sp.align {
                StrokeAlign::Inside => (0.0, weight),
                StrokeAlign::Center => (weight / 2.0, weight / 2.0),
                StrokeAlign::Outside => (weight, 0.0),
            };
            // The shape grown by `d` (shrunk when negative), or nothing when it shrinks away.
            let grown = |d: f64| -> Option<BezPath> {
                let (gw, gh) = (w + 2.0 * d, h + 2.0 * d);
                if gw <= 0.0 || gh <= 0.0 {
                    return None;
                }
                let mut p = if whole {
                    figcraft_doc::geom::ellipse(gw, gh, 0.0, std::f64::consts::TAU, 0.0)
                } else {
                    let radii = n.corners.radii.map(|r| if r > 0.0 { (r + d).max(0.0) } else { 0.0 });
                    figcraft_doc::geom::rounded_rect(gw, gh, radii, n.corners.smoothing)
                };
                p.apply_affine(Affine::translate((-d, -d)));
                Some(p)
            };
            let Some(mut ring) = grown(out) else { return };
            ring.extend(grown(-inset).iter().flat_map(|p| p.elements().iter().copied()));
            self.geometry("strokeGeometry", &ring, WindingRule::EvenOdd, f);
        } else if sp.align == StrokeAlign::Center {
            let path = match &n.kind {
                NodeKind::Vector { network } => Some(network.stroke_path()),
                NodeKind::Text(_) => None,
                _ => figcraft_doc::geometry::shape_path(n),
            };
            let Some(path) = path.filter(|p| !p.elements().is_empty()) else { return };
            use figcraft_doc::geom::kurbo::{Cap, Join, Stroke, StrokeOpts, stroke};
            let cap = match sp.cap_start {
                StrokeCap::Round => Cap::Round,
                StrokeCap::Square => Cap::Square,
                _ => Cap::Butt,
            };
            let join = match sp.join {
                StrokeJoin::Miter => Join::Miter,
                StrokeJoin::Bevel => Join::Bevel,
                StrokeJoin::Round => Join::Round,
            };
            let limit = if sp.miter_limit.is_finite() { sp.miter_limit.max(1.0) } else { 4.0 };
            let style = Stroke::new(weight).with_caps(cap).with_join(join).with_miter_limit(limit);
            self.geometry("strokeGeometry", &stroke(path, &style, &StrokeOpts::default(), 0.05), WindingRule::NonZero, f);
        }
    }

    /// Add a blob; its index (`None` once the blobs would make the file too large).
    fn blob(&mut self, bytes: Vec<u8>) -> Option<u32> {
        if let Some(i) = self.blobs.get(&bytes) {
            return Some(*i);
        }
        self.blob_bytes += bytes.len() as u64;
        if self.blob_bytes > MAX_CANVAS {
            self.warn("vector data too large for the format was left out");
            return None;
        }
        let i = u32::try_from(self.blobs.len()).ok()?;
        self.blobs.insert(bytes, i);
        Some(i)
    }

    /// A component property definition (variant properties are implied by the variants' names).
    fn prop_def(&mut self, name: &str, d: &PropDef) -> Option<Kv<'static>> {
        let ty = prop_type(d)?;
        let id = *self.defs.get(&(name.to_string(), ty))?;
        let value = match d {
            PropDef::Boolean { default } => o(vec![("boolValue", b(*default))]),
            PropDef::Text { default } => o(vec![("textValue", o(vec![("characters", s(default))]))]),
            PropDef::InstanceSwap { default, preferred } => {
                if !preferred.is_empty() {
                    self.warn("preferred values of instance swap properties were left out");
                }
                o(vec![("guidValue", self.guid_of(*default)?)])
            }
            PropDef::Variant { .. } | PropDef::Slot { .. } => return None,
        };
        Some(o(vec![("id", guid(AUX, id)), ("name", s(name)), ("initialValue", value), ("type", e(ty))]))
    }

    /// Which property controls a layer's `field`.
    fn prop_ref(&mut self, field: &str, prop: &str) -> Option<Kv<'static>> {
        let (var_field, ty, resolved) = match field {
            "visible" => ("VISIBLE", "BOOL", "BOOLEAN"),
            "characters" => ("TEXT_DATA", "TEXT", "TEXT_DATA"),
            "mainComponent" => ("OVERRIDDEN_SYMBOL_ID", "INSTANCE_SWAP", "SYMBOL_ID"),
            _ => {
                self.warn("slot layers were written as plain layers");
                return None;
            }
        };
        let id = *self.defs.get(&(prop.to_string(), ty))?;
        let data = o(vec![
            ("value", o(vec![("propRefValue", o(vec![("defId", guid(AUX, id))]))])),
            ("dataType", e("PROP_REF")),
            ("resolvedDataType", e(resolved)),
        ]);
        Some(o(vec![("variableData", data), ("variableField", e(var_field))]))
    }

    /// An instance: its main, the fields it and its layers override, the size, place and outline
    /// its layers get from that (derived data), its property values. `f`: its own fields so far.
    fn instance(&mut self, n: &Node, main: NodeId, props: &BTreeMap<String, Value>, f: &mut Fields) {
        const OWN: [&str; 7] = ["guid", "phase", "parentIndex", "type", "transform", "fillGeometry", "strokeGeometry"];
        let doc = self.doc;
        let (Some(m), Some(symbol)) = (doc.node(main), self.guid_of(main)) else { return };
        // What the instance itself changes from its main (its size, its paints, …) is an override
        // addressed by the main's id: a reader takes everything else from the main. Where it sits
        // is its own.
        let mut root_theirs = Vec::new();
        self.layer(m, m.parent.and_then(|p| doc.node(p)), &mut root_theirs, true);
        root_theirs.retain(|(k, _)| !OWN.contains(k));
        // An instance is named after its component (the set, for a variant) until renamed.
        let set = m.parent.and_then(|p| doc.node(p)).filter(|p| matches!(p.kind, NodeKind::ComponentSet { .. }));
        let named = set.is_none_or(|s| s.name != n.name);
        let root_mine: Fields = f.iter().filter(|(k, _)| !OWN.contains(k) && (named || *k != "name")).cloned().collect();
        // Each layer below: its id path, the fields that differ from the main's layer, that layer's
        // fields, and the component a nested instance was swapped for.
        struct Row {
            path: Kv<'static>,
            changed: Fields,
            theirs: Fields,
            nested: bool,
            swap: Option<Kv<'static>>,
        }
        let mut rows: Vec<Row> = Vec::new();
        let mut stack: Vec<(NodeId, NodeId)> = n.children.iter().rev().map(|c| (*c, n.id)).collect();
        let mut seen = 0usize;
        while let Some((id, parent)) = stack.pop() {
            let Some(d) = doc.node(id) else { continue };
            seen += 1;
            if seen > MAX_NODES {
                break;
            }
            stack.extend(d.children.iter().rev().map(|c| (*c, id)));
            let path = self.layer_path(d, n.id, main, 0);
            let guids: Option<Vec<Kv>> = path.and_then(|p| p.iter().map(|x| self.guid_of(*x)).collect());
            let (Some(guids), Some(src)) = (guids, d.source.and_then(|src| doc.node(src))) else {
                self.warn("instance layers that don't come from their main component were left out");
                continue;
            };
            let (mut mine, mut theirs) = (Vec::new(), Vec::new());
            self.layer(d, doc.node(parent), &mut mine, true);
            self.layer(src, src.parent.and_then(|p| doc.node(p)), &mut theirs, true);
            // A nested instance swapped for another component.
            let swap = match (&d.kind, &src.kind) {
                (NodeKind::Instance { component, .. }, NodeKind::Instance { component: was, .. }) if component == was => None,
                (NodeKind::Instance { component, .. }, _) => self.guid_of(*component),
                _ => None,
            };
            let nested = matches!(d.kind, NodeKind::Instance { .. });
            rows.push(Row { path: o(vec![("guids", arr(guids))]), changed: changed(mine, &theirs), theirs, nested, swap });
        }
        // An instance scaled as a whole (the Scale tool) is `factor` times its main in every length:
        // sizes, places and stroke weights, its own and its layers'. A resized one keeps its weights.
        let field = |fields: &Fields, key: &str| fields.iter().find(|(k, _)| *k == key).map(|(_, v)| v.clone());
        let factor = Some(n.width / m.width).filter(|k| k.is_finite() && *k > 0.0 && (k - 1.0).abs() > 1e-6).filter(|k| {
            let grown = |mine: &Fields, theirs: &Fields| {
                let weight = field(theirs, "strokeWeight").and_then(|w| w.f64()).unwrap_or(0.0);
                (weight == 0.0 || field(mine, "strokeWeight").is_some_and(|w| scaled(&w, &fl(weight), *k, 0.0)))
                    && field(mine, "size").zip(field(theirs, "size")).is_some_and(|(a, b)| scaled(&a, &b, *k, 1.0))
                    && field(mine, "transform").zip(field(theirs, "transform")).is_none_or(|(a, b)| scaled(&a, &b, *k, 1.0))
            };
            (n.height / m.height - k).abs() <= 1e-6 * k.max(1.0)
                && grown(&changed(root_mine.clone(), &root_theirs), &root_theirs)
                && rows.iter().all(|r| grown(&r.changed, &r.theirs))
        });
        // What follows from the overrides goes with the derived data: a layer's size, place and
        // outline (a vector's network is the main's, drawn at the layer's size), the colours its
        // variables give here, and what the scale factor makes of the main's values.
        let follows = |k: &str, v: &Kv<'static>, theirs: &Fields| {
            ["size", "transform", "fillGeometry", "strokeGeometry", "vectorData"].contains(&k)
                || resolved_alike(k, v, theirs)
                || factor.is_some_and(|x| field(theirs, k).is_some_and(|t| scaled(v, &t, x, 0.0)))
        };
        let mut overrides = Vec::new();
        let mut derived = Vec::new();
        let mut of: Fields = vec![("guidPath", o(vec![("guids", arr(vec![symbol.clone()]))]))];
        of.extend(changed(root_mine, &root_theirs).into_iter().filter(|(k, v)| *k == "size" || !follows(k, v, &root_theirs)));
        if of.len() > 1 {
            overrides.push(o(of));
        }
        for r in rows {
            let (mut of, mut df): (Fields, Fields) = (vec![("guidPath", r.path.clone())], vec![("guidPath", r.path)]);
            for (k, v) in r.changed {
                let follows = follows(k, &v, &r.theirs);
                // A nested instance's size is its own to set.
                if follows && r.nested && k == "size" {
                    of.push((k, v.clone()));
                }
                if follows { &mut df } else { &mut of }.push((k, v));
            }
            if df.len() > 1 {
                derived.push(o(df));
            }
            of.extend(r.swap.map(|g| ("overriddenSymbolID", g)));
            if of.len() > 1 {
                overrides.push(o(of));
            }
        }
        f.push(("symbolData", o(vec![("symbolID", symbol), ("symbolOverrides", arr(overrides)), ("uniformScaleFactor", fl(factor.unwrap_or(1.0)))])));
        if !derived.is_empty() {
            f.push(("derivedSymbolData", arr(derived)));
        }
        let mut assignments = Vec::new();
        for (name, v) in props {
            let (ty, value) = match v {
                Value::Bool(x) => ("BOOL", Some(o(vec![("boolValue", b(*x))]))),
                Value::String(t) => ("TEXT", Some(o(vec![("textValue", o(vec![("characters", s(t))]))]))),
                Value::Number(c) => ("INSTANCE_SWAP", c.as_u64().and_then(|c| self.guid_of(NodeId(c))).map(|g| o(vec![("guidValue", g)]))),
                _ => continue,
            };
            // Variant values have no definition of their own: the main they show says them.
            if let (Some(&id), Some(value)) = (self.defs.get(&(name.clone(), ty)), value) {
                assignments.push(o(vec![("defID", guid(AUX, id)), ("value", value)]));
            }
        }
        if !assignments.is_empty() {
            f.push(("componentPropAssignments", arr(assignments)));
        }
        if n.children.iter().filter_map(|c| doc.node(*c)).any(|c| c.source.is_none()) {
            self.warn("instance layers that don't come from their main component were left out");
        }
    }

    /// The main component layer an instance or instance layer mirrors (through nested instances),
    /// or `id` itself.
    fn main_layer(&self, id: NodeId) -> NodeId {
        let mut cur = id;
        for _ in 0..32 {
            let next = self.doc.node(cur).and_then(|n| match &n.kind {
                _ if n.source.is_some() => n.source,
                NodeKind::Instance { component, .. } => Some(*component),
                _ => None,
            });
            match next.filter(|s| self.doc.contains(*s)) {
                Some(s) => cur = s,
                None => break,
            }
        }
        cur
    }

    /// The id path of layer `d` of instance `inst` (of `main`): that of the main's layer it mirrors,
    /// or, inside a nested instance swapped for another component, the path of that instance and
    /// then the one inside its new main.
    fn layer_path(&self, d: &Node, inst: NodeId, main: NodeId, depth: usize) -> Option<Vec<NodeId>> {
        let src = d.source?;
        if let Some(p) = self.path_in(src, main, 0) {
            return Some(p);
        }
        if depth > 32 {
            return None;
        }
        let doc = self.doc;
        let nested = doc.ancestors(d.id).into_iter().take_while(|a| *a != inst).filter_map(|a| doc.node(a)).find_map(|a| match &a.kind {
            NodeKind::Instance { component, .. } => Some((a, *component)),
            _ => None,
        });
        let (outer, component) = nested?;
        let mut p = self.layer_path(outer, inst, main, depth + 1)?;
        p.extend(self.path_in(src, component, 0)?);
        Some(p)
    }

    /// The id path of layer `s` inside component `comp`: `s` itself, or through the nested
    /// instance it is expanded in, then on inside that instance's main.
    fn path_in(&self, s: NodeId, comp: NodeId, depth: usize) -> Option<Vec<NodeId>> {
        if depth > 32 {
            return None;
        }
        let doc = self.doc;
        let up = doc.ancestors(s);
        let below: Vec<NodeId> = up.iter().take_while(|a| **a != comp).copied().collect();
        if below.len() == up.len() {
            return None;
        }
        // The outermost nested instance between the component and the layer.
        match below.iter().rev().find_map(|a| match doc.node(*a).map(|n| &n.kind) {
            Some(NodeKind::Instance { component, .. }) => Some((*a, *component)),
            _ => None,
        }) {
            None => Some(vec![s]),
            Some((inst, main)) => {
                let mut p = vec![inst];
                p.extend(self.path_in(doc.node(s)?.source?, main, depth + 1)?);
                Some(p)
            }
        }
    }

    /// Interactions, scrolling, flow starts and the overlay settings this layer is opened with.
    fn prototype(&mut self, n: &Node, f: &mut Fields) {
        let list: Vec<Kv> = n.interactions.iter().filter_map(|it| self.interaction(it)).collect();
        if !list.is_empty() {
            f.push(("prototypeInteractions", arr(list)));
        }
        let dir = match n.overflow {
            Overflow::None => None,
            Overflow::Horizontal => Some("HORIZONTAL"),
            Overflow::Vertical => Some("VERTICAL"),
            Overflow::Both => Some("BOTH"),
        };
        f.extend(dir.map(|d| ("scrollDirection", e(d))));
        let behavior = match n.scroll_position {
            ScrollPosition::Scrolls => None,
            ScrollPosition::Fixed => Some("FIXED_WHEN_CHILD_OF_SCROLLING_FRAME"),
            ScrollPosition::Sticky => Some("STICKY_SCROLLS"),
        };
        f.extend(behavior.map(|x| ("scrollBehavior", e(x))));
        if let Some((i, name)) = self.starts.get(&n.id) {
            f.push(("prototypeStartingPoint", o(vec![("name", s(name)), ("position", s(&position(*i)))])));
        }
        if let Some(ov) = self.overlays.get(&n.id) {
            const POSITIONS: [&str; 8] = ["CENTER", "TOP_LEFT", "TOP_CENTER", "TOP_RIGHT", "BOTTOM_LEFT", "BOTTOM_CENTER", "BOTTOM_RIGHT", "MANUAL"];
            let pos = POSITIONS.into_iter().find(|p| crate::rest::proto::overlay_position(p) == Some(ov.position)).unwrap_or("CENTER");
            let bg = match ov.background {
                Some(c) => o(vec![("backgroundType", e("SOLID_COLOR")), ("backgroundColor", color(c))]),
                None => o(vec![("backgroundType", e("NONE"))]),
            };
            f.extend([
                ("overlayPositionType", e(pos)),
                ("overlayBackgroundInteraction", e(if ov.close_on_outside { "CLOSE_ON_CLICK_OUTSIDE" } else { "NONE" })),
                ("overlayBackgroundAppearance", bg),
            ]);
        }
    }

    fn interaction(&mut self, it: &Interaction) -> Option<Kv<'static>> {
        let mut event: Fields = Vec::new();
        let ty = match &it.trigger {
            Trigger::OnClick => "ON_CLICK",
            Trigger::OnHover => "ON_HOVER",
            Trigger::OnPress => "ON_PRESS",
            Trigger::OnDrag => "DRAG",
            Trigger::MouseEnter => "MOUSE_IN",
            Trigger::MouseLeave => "MOUSE_OUT",
            Trigger::MouseDown => "MOUSE_DOWN",
            Trigger::MouseUp => "MOUSE_UP",
            Trigger::AfterDelay { ms } => {
                event.push(("transitionTimeout", fl(f64::from(*ms) / 1000.0)));
                "AFTER_TIMEOUT"
            }
            Trigger::KeyPress { key } => {
                let Some((codes, pad)) = key_codes(key) else {
                    self.warn("key triggers on keys the format has no code for were left out");
                    return None;
                };
                let device = e(if pad { "UNKNOWN_CONTROLLER" } else { "KEYBOARD" });
                event.push(("keyTrigger", o(vec![("keyCodes", arr(codes.into_iter().map(int).collect())), ("triggerDevice", device)])));
                "ON_KEY_DOWN"
            }
        };
        // A mouse trigger's delay is the event's timeout.
        if it.delay_secs() > 0.0 {
            event.push(("transitionTimeout", fl(it.delay_secs())));
        }
        event.insert(0, ("interactionType", e(ty)));
        let actions: Vec<Kv> = it.actions.iter().filter_map(|a| self.action(a, it)).collect();
        (!actions.is_empty()).then(|| o(vec![("event", o(event)), ("actions", arr(actions))]))
    }

    fn action(&mut self, a: &Action, it: &Interaction) -> Option<Kv<'static>> {
        let node = |x: &mut Self, dest: &NodeId, nav: &'static str| -> Option<Kv<'static>> {
            let Some(g) = x.guid_of(*dest) else {
                x.warn("prototype actions whose destination isn't written were left out");
                return None;
            };
            let mut f: Fields = vec![("transitionNodeID", g), ("connectionType", e("INTERNAL_NODE")), ("navigationType", e(nav))];
            x.transition(it, &mut f);
            Some(o(f))
        };
        let plain = |ty: &'static str| Some(o(vec![("connectionType", e(ty))]));
        match a {
            Action::Navigate { dest, preserve_scroll } => {
                let mut act = node(self, dest, "NAVIGATE")?;
                if let Kv::Object(f) = &mut act {
                    f.push(("transitionPreserveScroll", b(*preserve_scroll)));
                }
                Some(act)
            }
            Action::OpenOverlay { dest, position, offset, .. } => {
                let mut act = node(self, dest, "OVERLAY")?;
                if let (Kv::Object(f), OverlayPosition::Manual, Some([x, y])) = (&mut act, position, offset) {
                    f.push(("overlayRelativePosition", o(vec![("x", fl(*x)), ("y", fl(*y))])));
                }
                Some(act)
            }
            Action::SwapOverlay { dest } => node(self, dest, "SWAP"),
            Action::ChangeTo { dest } => node(self, dest, "SWAP_STATE"),
            Action::ScrollTo { dest, offset } => {
                if *offset != [0.0, 0.0] {
                    self.warn("scroll-to offsets were left out");
                }
                node(self, dest, "SCROLL_TO")
            }
            Action::Back => plain("BACK"),
            Action::CloseOverlay => plain("CLOSE"),
            Action::OpenUrl { url } => Some(o(vec![("connectionType", e("URL")), ("connectionURL", s(url))])),
            Action::SetVariable { .. } | Action::SetVariableMode { .. } | Action::Conditional { .. } => {
                self.warn("variable and conditional prototype actions were left out");
                None
            }
        }
    }

    /// An interaction's transition on one of its actions.
    fn transition(&mut self, it: &Interaction, f: &mut Fields) {
        let side_from = |d: Direction, l: &'static str, r: &'static str, t: &'static str, bo: &'static str| match d {
            // The direction names where the incoming screen moves: it comes from the other side.
            Direction::Right => l,
            Direction::Left => r,
            Direction::Bottom => t,
            Direction::Top => bo,
        };
        let side_to = |d: Direction, l: &'static str, r: &'static str, t: &'static str, bo: &'static str| match d {
            Direction::Left => l,
            Direction::Right => r,
            Direction::Top => t,
            Direction::Bottom => bo,
        };
        let ty = match it.transition {
            Transition::Instant => "INSTANT_TRANSITION",
            Transition::Dissolve => "DISSOLVE",
            Transition::SmartAnimate => "SMART_ANIMATE",
            Transition::SlideIn { direction } => side_from(direction, "SLIDE_FROM_LEFT", "SLIDE_FROM_RIGHT", "SLIDE_FROM_TOP", "SLIDE_FROM_BOTTOM"),
            Transition::Push { direction } => side_from(direction, "PUSH_FROM_LEFT", "PUSH_FROM_RIGHT", "PUSH_FROM_TOP", "PUSH_FROM_BOTTOM"),
            Transition::MoveIn { direction } => side_from(direction, "MOVE_FROM_LEFT", "MOVE_FROM_RIGHT", "MOVE_FROM_TOP", "MOVE_FROM_BOTTOM"),
            Transition::SlideOut { direction } => {
                side_to(direction, "SLIDE_OUT_TO_LEFT", "SLIDE_OUT_TO_RIGHT", "SLIDE_OUT_TO_TOP", "SLIDE_OUT_TO_BOTTOM")
            }
            Transition::MoveOut { direction } => side_to(direction, "MOVE_OUT_TO_LEFT", "MOVE_OUT_TO_RIGHT", "MOVE_OUT_TO_TOP", "MOVE_OUT_TO_BOTTOM"),
        };
        let easing = match it.easing {
            Easing::Linear => "LINEAR",
            Easing::EaseIn => "IN_CUBIC",
            Easing::EaseOut => "OUT_CUBIC",
            Easing::EaseInOut => "INOUT_CUBIC",
            Easing::EaseInBack => "IN_BACK_CUBIC",
            Easing::EaseOutBack => "OUT_BACK_CUBIC",
            Easing::EaseInOutBack => "INOUT_BACK_CUBIC",
            Easing::Gentle => "GENTLE_SPRING",
            Easing::CustomBezier { .. } => "CUSTOM_CUBIC",
            Easing::Quick | Easing::Bouncy | Easing::Slow | Easing::CustomSpring { .. } => {
                self.warn("spring animations other than Gentle were written as ease out");
                "OUT_CUBIC"
            }
        };
        f.extend([("transitionType", e(ty)), ("transitionDuration", fl(f64::from(it.duration_ms) / 1000.0)), ("easingType", e(easing))]);
        if let Easing::CustomBezier { x1, y1, x2, y2 } = it.easing {
            f.push(("easingFunction", arr(vec![fl(x1), fl(y1), fl(x2), fl(y2)])));
        }
    }
}

/// The plugin id and key under which a layer written as an outline keeps what it was.
pub(super) const STASH: (&str, &str) = ("figcraft", "stroke");
/// Longest kept description of such a layer (bytes of JSON).
const MAX_STASH: usize = 1 << 20;

/// Whether a width profile reaches further on one side of the path than on the other.
fn one_sided(p: &figcraft_doc::WidthProfile) -> bool {
    p.points.iter().any(|q| q.bias.abs() > 1e-6)
}

/// A shape whose stroke is wider on one side of its path, as the area that stroke paints (a vector
/// filled with the stroke's paints), with what it was as JSON: its kind, paints and stroke. Only
/// for shapes that show nothing but that stroke; `None` for every other layer.
fn outlined(n: &Node) -> Option<(Node, String)> {
    let sp = &n.stroke;
    let shape = matches!(
        n.kind,
        NodeKind::Line | NodeKind::Vector { .. } | NodeKind::Ellipse { .. } | NodeKind::Polygon { .. } | NodeKind::Star { .. } | NodeKind::Rectangle
    );
    let shown = |paints: &[Paint]| paints.iter().any(|p| p.visible);
    if !shape
        || sp.brush.is_some()
        || !sp.profile().is_some_and(one_sided)
        || !(sp.weight.is_finite() && sp.weight > 0.0)
        || !shown(&n.strokes)
        || shown(&n.fills)
    {
        return None;
    }
    let path = figcraft_doc::geometry::stroke_geometry(n)?;
    let net = match &n.kind {
        NodeKind::Vector { network } => Some(network),
        _ => None,
    };
    let area = figcraft_pathops::stroke_outline_of(&path, sp, figcraft_doc::geometry::is_closed(n), net);
    if area.elements().is_empty() || area.elements().len() > MAX_NETWORK / 4 {
        return None;
    }
    let original = serde_json::json!({"kind": n.kind, "fills": n.fills, "strokes": n.strokes, "stroke": n.stroke}).to_string();
    if original.len() > MAX_STASH {
        return None;
    }
    let mut network = VectorNetwork::from_path(&area);
    for r in &mut network.regions {
        r.winding = WindingRule::NonZero;
    }
    let mut v = n.clone();
    v.kind = NodeKind::Vector { network };
    v.fills = std::mem::take(&mut v.strokes);
    v.stroke = Default::default();
    v.styles.fill = v.styles.stroke.take();
    // Bindings name the stroke's paints, which are the fills now: the values stay.
    v.bound.retain(|k, _| !(k == "stroke" || k == "fill" || k.starts_with("strokes/") || k.starts_with("fills/") || k.starts_with("stroke")));
    Some((v, original))
}

/// The number of the layer field a bound property (`VariableField`) is held in.
fn node_field(field: &str) -> Option<u32> {
    let name = match field {
        "WIDTH" | "HEIGHT" => "size",
        "MIN_WIDTH" | "MIN_HEIGHT" => "minSize",
        "MAX_WIDTH" | "MAX_HEIGHT" => "maxSize",
        "STACK_SPACING" => "stackSpacing",
        "STACK_COUNTER_SPACING" => "stackCounterSpacing",
        "STACK_PADDING_LEFT" => "stackHorizontalPadding",
        "STACK_PADDING_TOP" => "stackVerticalPadding",
        "STACK_PADDING_RIGHT" => "stackPaddingRight",
        "STACK_PADDING_BOTTOM" => "stackPaddingBottom",
        "CORNER_RADIUS" => "cornerRadius",
        "RECTANGLE_TOP_LEFT_CORNER_RADIUS" => "rectangleTopLeftCornerRadius",
        "RECTANGLE_TOP_RIGHT_CORNER_RADIUS" => "rectangleTopRightCornerRadius",
        "RECTANGLE_BOTTOM_LEFT_CORNER_RADIUS" => "rectangleBottomLeftCornerRadius",
        "RECTANGLE_BOTTOM_RIGHT_CORNER_RADIUS" => "rectangleBottomRightCornerRadius",
        "OPACITY" => "opacity",
        "VISIBLE" => "visible",
        "TEXT_DATA" => "textData",
        "STROKE_WEIGHT" => "strokeWeight",
        "BORDER_TOP_WEIGHT" => "borderTopWeight",
        "BORDER_RIGHT_WEIGHT" => "borderRightWeight",
        "BORDER_BOTTOM_WEIGHT" => "borderBottomWeight",
        "BORDER_LEFT_WEIGHT" => "borderLeftWeight",
        "FONT_SIZE" => "fontSize",
        "FONT_FAMILY" | "FONT_STYLE" => "fontName",
        "LETTER_SPACING" => "letterSpacing",
        "LINE_HEIGHT" => "lineHeight",
        "PARAGRAPH_SPACING" => "paragraphSpacing",
        "PARAGRAPH_INDENT" => "paragraphIndent",
        _ => return None,
    };
    // The numbers are the schema's.
    let layer = SCHEMA.lines().find(|l| l.starts_with("message NodeChange "))?;
    layer.split(", ").find_map(|f| f.rsplit_once(' ')?.1.strip_prefix(name)?.strip_prefix('=')?.parse().ok())
}

/// Whether `a` is `b` with its lengths scaled by `k`: every number is `k` times the other's (within
/// `slack`, for sizes that snap to whole pixels) or the same, and the rest is equal.
fn scaled(a: &Kv<'static>, b: &Kv<'static>, k: f64, slack: f64) -> bool {
    match (a, b) {
        (Kv::Float(x), Kv::Float(y)) => {
            let (x, y) = (f64::from(*x), f64::from(*y));
            x == y || (x - y * k).abs() <= slack + 1e-3 * x.abs().max(1.0)
        }
        (Kv::Array(x), Kv::Array(y)) => x.len() == y.len() && x.iter().zip(y).all(|(p, q)| scaled(p, q, k, slack)),
        (Kv::Object(x), Kv::Object(y)) => x.len() == y.len() && x.iter().zip(y).all(|((kp, p), (kq, q))| kp == kq && scaled(p, q, k, slack)),
        _ => a == b,
    }
}

/// The fields of `mine` that differ from `theirs` (a layer and the main's layer it mirrors), and
/// the ones only `theirs` has at their empty values.
fn changed(mine: Fields, theirs: &Fields) -> Fields {
    let cleared: Fields = theirs.iter().filter(|(k, _)| !mine.iter().any(|(mk, _)| mk == k)).filter_map(|(k, _)| Some((*k, unset(k)?))).collect();
    let mut out: Fields = mine.into_iter().filter(|(k, v)| !theirs.iter().any(|(tk, tv)| tk == k && tv == v)).collect();
    out.extend(cleared);
    out
}

/// Whether paint list `v` (field `key`) is `theirs` but for the colours variables give: two layers
/// bound alike are the same, whatever mode each one shows.
fn resolved_alike(key: &str, v: &Kv<'static>, theirs: &Fields) -> bool {
    fn unresolved(v: &Kv<'static>) -> Vec<Kv<'static>> {
        let bare = |p: &Kv<'static>| match p {
            Kv::Object(f) if f.iter().any(|(k, _)| *k == "colorVar") => o(f.iter().filter(|(k, _)| *k != "color").cloned().collect()),
            other => other.clone(),
        };
        v.list().iter().map(bare).collect()
    }
    matches!(key, "fillPaints" | "strokePaints") && theirs.iter().any(|(k, t)| *k == key && unresolved(t) == unresolved(v))
}

/// The format's name of a variable type.
fn resolved_type(kind: VariableType) -> &'static str {
    match kind {
        VariableType::Color => "COLOR",
        VariableType::Number => "FLOAT",
        VariableType::String => "STRING",
        VariableType::Boolean => "BOOLEAN",
    }
}

/// The format's name of a variable scope (`None`: it has none).
fn scope_name(scope: &str) -> Option<&'static str> {
    const NAMES: [&str; 20] = [
        "ALL_SCOPES",
        "TEXT_CONTENT",
        "CORNER_RADIUS",
        "WIDTH_HEIGHT",
        "GAP",
        "ALL_FILLS",
        "FRAME_FILL",
        "SHAPE_FILL",
        "TEXT_FILL",
        "STROKE_FLOAT",
        "EFFECT_FLOAT",
        "EFFECT_COLOR",
        "OPACITY",
        "FONT_STYLE",
        "FONT_FAMILY",
        "FONT_SIZE",
        "LINE_HEIGHT",
        "LETTER_SPACING",
        "PARAGRAPH_SPACING",
        "PARAGRAPH_INDENT",
    ];
    if scope == "STROKE_COLOR" {
        return Some("STROKE");
    }
    NAMES.into_iter().find(|n| *n == scope)
}

/// The empty value of a field only written when set (an override clears it with this).
fn unset(key: &str) -> Option<Kv<'static>> {
    Some(match key {
        "styleIdForFill" | "styleIdForStrokeFill" | "styleIdForEffect" | "styleIdForGrid" | "styleIdForText" => {
            o(vec![("guid", guid(u32::MAX, u32::MAX))])
        }
        "variableConsumptionMap" | "variableModeBySetMap" => o(vec![("entries", arr(Vec::new()))]),
        "mask" | "rectangleCornerRadiiIndependent" | "borderStrokeWeightsIndependent" => b(false),
        "effects" | "dashPattern" | "layoutGrids" | "exportSettings" | "prototypeInteractions" | "fillGeometry" | "variableWidthPoints" => {
            arr(Vec::new())
        }
        "cornerSmoothing" | "stackChildPrimaryGrow" => fl(0.0),
        "stackMode" => e("NONE"),
        "stackChildAlignSelf" | "stackPositioning" => e("AUTO"),
        "minSize" | "maxSize" => o(vec![("value", xy(0.0, 0.0))]),
        "gridColumnSpan" | "gridRowSpan" | "maxLines" => int(0),
        "scrollDirection" => e("NONE"),
        "scrollBehavior" => e("SCROLLS"),
        "parameterConsumptionMap" => o(vec![("entries", arr(Vec::new()))]),
        "textTruncation" => e("DISABLED"),
        "hyperlink" => o(vec![("url", s(""))]),
        _ => return None,
    })
}

/// The format's type of a component property (`None`: not written).
fn prop_type(d: &PropDef) -> Option<&'static str> {
    match d {
        PropDef::Boolean { .. } => Some("BOOL"),
        PropDef::Text { .. } => Some("TEXT"),
        PropDef::InstanceSwap { .. } => Some("INSTANCE_SWAP"),
        PropDef::Variant { .. } | PropDef::Slot { .. } => None,
    }
}

/// The key codes of a key trigger (modifiers first), and whether it's a controller button.
fn key_codes(key: &str) -> Option<(Vec<i64>, bool)> {
    if let Some(i) = GAMEPAD_BUTTONS.iter().position(|g| g.eq_ignore_ascii_case(key.trim())) {
        return Some((vec![i as i64], true));
    }
    let (mods, k): (KeyMods, &str) = KeyMods::split(key);
    let code = (0..=255).find(|c| crate::rest::proto::key_name(f64::from(*c)).is_some_and(|n| n.eq_ignore_ascii_case(k)))?;
    let mut codes: Vec<i64> = [(mods.shift, 16), (mods.ctrl, 17), (mods.alt, 18), (mods.cmd, 91)].into_iter().filter(|m| m.0).map(|m| m.1).collect();
    codes.push(i64::from(code));
    Some((codes, false))
}

/// The text style fields of a layer or of an override table entry.
fn style_fields(st: &TextStyle, f: &mut Fields) {
    let line_height = match st.line_height {
        // Percent units count from the font's own line height (100 % is "auto"); a share of the
        // font size is a raw multiplier.
        LineHeight::Auto => o(vec![("value", fl(100.0)), ("units", e("PERCENT"))]),
        LineHeight::Percent(p) => o(vec![("value", fl(p / 100.0)), ("units", e("RAW"))]),
        LineHeight::Pixels(v) => o(vec![("value", fl(v)), ("units", e("PIXELS"))]),
    };
    let letter_spacing = match st.letter_spacing {
        LetterSpacing::Percent(p) => o(vec![("value", fl(p)), ("units", e("PERCENT"))]),
        LetterSpacing::Pixels(v) => o(vec![("value", fl(v)), ("units", e("PIXELS"))]),
    };
    let case = match st.case {
        TextCase::Original => "ORIGINAL",
        TextCase::Upper => "UPPER",
        TextCase::Lower => "LOWER",
        TextCase::Title => "TITLE",
        TextCase::SmallCaps => "SMALL_CAPS",
    };
    let decoration = match st.decoration {
        TextDecoration::None => "NONE",
        TextDecoration::Underline => "UNDERLINE",
        TextDecoration::Strikethrough => "STRIKETHROUGH",
    };
    f.extend([
        ("fontName", o(vec![("family", s(&st.font_family)), ("style", s(&super::style_name(&st.font_style))), ("postscript", s(""))])),
        ("fontSize", fl(st.font_size)),
        ("lineHeight", line_height),
        ("letterSpacing", letter_spacing),
        ("textCase", e(case)),
        ("textDecoration", e(decoration)),
    ]);
    if let Some(url) = &st.link {
        f.push(("hyperlink", o(vec![("url", s(url))])));
    }
}

/// Layout grid `index` of a layer, with the variables `bound` to its fields.
fn layout_grid(g: &figcraft_doc::LayoutGrid, index: usize, bound: &Bound) -> Kv<'static> {
    let (pattern, axis) = match g.kind {
        GridKind::Grid => ("GRID", "X"),
        GridKind::Columns => ("STRIPES", "X"),
        GridKind::Rows => ("STRIPES", "Y"),
    };
    let align = match g.align {
        GridAlign::Stretch => "STRETCH",
        GridAlign::Min => "MIN",
        GridAlign::Center => "CENTER",
        GridAlign::Max => "MAX",
    };
    let mut f: Fields = vec![
        ("type", e(align)),
        ("axis", e(axis)),
        ("visible", b(g.visible)),
        ("numSections", int(g.count.into())),
        ("offset", fl(g.offset)),
        ("sectionSize", fl(g.size)),
        ("gutterSize", fl(g.gutter)),
        ("color", color(g.color)),
        ("pattern", e(pattern)),
    ];
    let vars = [("count", "numSectionsVar"), ("offset", "offsetVar"), ("size", "sectionSizeVar"), ("gutter", "gutterSizeVar")];
    f.extend(vars.into_iter().filter_map(|(ours, key)| Some((key, bound.grids.get(&(index, ours))?.clone()))));
    o(f)
}

fn export_setting(x: &figcraft_doc::ExportSetting) -> Kv<'static> {
    let format = match x.format {
        // The format has no WebP export setting.
        figcraft_doc::ExportFormat::Png | figcraft_doc::ExportFormat::Webp => "PNG",
        figcraft_doc::ExportFormat::Jpg => "JPEG",
        figcraft_doc::ExportFormat::Svg => "SVG",
        figcraft_doc::ExportFormat::Pdf => "PDF",
    };
    let (ty, value) = match x.size {
        ExportSize::Scale { value } => ("CONTENT_SCALE", value),
        ExportSize::Width { value } => ("CONTENT_WIDTH", value),
        ExportSize::Height { value } => ("CONTENT_HEIGHT", value),
    };
    o(vec![("suffix", s(&x.suffix)), ("imageType", e(format)), ("constraint", o(vec![("type", e(ty)), ("value", fl(value))]))])
}