@pixerate/editor 0.42.0 → 0.44.0

package/dist/vector/index.d.ts

@@ -1,4 +1,4 @@
-import { C as CanvasGradientDef, A as AffineMatrix, B as BezierPathInput, a as BezierPath, S as SvgGradientDef, b as StrokeJoin, c as StrokeCap, d as BezierSegment, P as PlanarMap, e as PathfinderOperation, f as PathfinderShape, G as GradientStop } from '../pathfinder-D7hXenzu.js';
+import { C as CanvasGradientDef, A as AffineMatrix, B as BezierPathInput, a as BezierPath, S as SvgGradientDef, b as StrokeJoin, c as StrokeCap, d as BezierSegment, P as PlanarMap, e as PathfinderOperation, f as PathfinderShape } from '../pathfinder-D98S2lV5.js';
 import { P as Point } from '../types-BFkYA4eF.js';
 import { H as HistoryManager } from '../HistoryManager-DWSLd6Tf.js';
 import { C as CommandSpec } from '../registry-DhVUZioj.js';
@@ -58,8 +58,93 @@ interface VectorSubpath {
     /** Joins the last anchor back to the first. */
     closed: boolean;
 }
+/**
+ * Gradient styles: `linear` (start → end), `radial` (centred on the start, reaching the end;
+ * focal point and aspect), `conic` (an angle sweep around the start, from the end's direction
+ * towards the aspect handle's: clockwise on screen), `reflected` (linear mirrored about the
+ * start) and `diamond` (`|u| + |v|` in the gradient's frame: a rhombus through the end and the
+ * aspect handle).
+ */
+type VectorGradientType = 'linear' | 'radial' | 'conic' | 'reflected' | 'diamond';
+declare const VECTOR_GRADIENT_TYPES: readonly VectorGradientType[];
+/** What a gradient paints past its ends: the end colours, mirrored periods or repeated periods. */
+type VectorGradientSpread = 'pad' | 'reflect' | 'repeat';
+declare const VECTOR_GRADIENT_SPREADS: readonly VectorGradientSpread[];
+/** Where colours mix between stops: sRGB (SVG's own), linear light or Oklab. */
+type VectorGradientInterpolation = 'srgb' | 'linear' | 'oklab';
+declare const VECTOR_GRADIENT_INTERPOLATIONS: readonly VectorGradientInterpolation[];
+/**
+ * The space a gradient's points are in: fractions of the shape's bounding box (SVG's
+ * `objectBoundingBox`, the default) or the node's own coordinates (`userSpaceOnUse`).
+ */
+type VectorGradientUnits = 'objectBoundingBox' | 'userSpaceOnUse';
+/**
+ * How a gradient lies on a stroke: `within` (laid over the stroke's area like a fill), `along`
+ * (t runs from 0 at the start of each subpath to 1 at its end) or `across` (from the stroke's
+ * left edge to its right edge, looking along the path).
+ */
+type VectorStrokeGradientMode = 'within' | 'along' | 'across';
+declare const VECTOR_STROKE_GRADIENT_MODES: readonly VectorStrokeGradientMode[];
+/** A colour stop. `opacity` multiplies the colour's own alpha. */
+interface VectorGradientStop {
+    /** 0–1. */
+    offset: number;
+    color: string;
+    /** 0–1, default 1. */
+    opacity?: number;
+    /**
+     * Where, between this stop and the next (0–1 of the way), the colour is half-way between
+     * them. Default 0.5 (an even mix).
+     */
+    midpoint?: number;
+}
+/**
+ * A gradient paint. `CanvasGradientDef` (the canvas package's linear `angle` / radial
+ * `cx, cy, r` gradients) is a valid value: those fields are the shorthand form. Explicit
+ * geometry (`start` / `end`, in `units`) wins over the shorthand.
+ */
+interface VectorGradient {
+    type: VectorGradientType;
+    stops: VectorGradientStop[];
+    /**
+     * Shorthand direction in degrees, CSS style (0 points up, clockwise): a linear or reflected
+     * gradient's direction across the box (default 180), a conic gradient's start angle or a
+     * diamond's turn (default 90).
+     */
+    angle?: number;
+    /** Shorthand centre and radius of radial, conic and diamond gradients (fractions of the box, default 0.5). */
+    cx?: number;
+    cy?: number;
+    r?: number;
+    /** Where t = 0: a linear gradient's start, the centre of the other styles. */
+    start?: Vec2;
+    /** Where t = 1 along the gradient's main axis (a radial gradient's radius). */
+    end?: Vec2;
+    /**
+     * The end of the secondary axis (radial, conic and diamond): its distance from `start` over
+     * the main axis' length is the aspect ratio. Absent: square to the main axis, as long.
+     */
+    width?: Vec2 | null;
+    /** A radial gradient's focal point (where t = 0); absent: the centre. */
+    focal?: Vec2 | null;
+    /** Radius of the focal circle as a fraction of the radius (SVG `fr`, default 0). */
+    focalRadius?: number;
+    /** Space of `start`, `end`, `width` and `focal` (default `objectBoundingBox`). */
+    units?: VectorGradientUnits;
+    /** Default `pad`. */
+    spread?: VectorGradientSpread;
+    /** Default `srgb`. */
+    interpolation?: VectorGradientInterpolation;
+    /**
+     * 0–1: how far the colours follow a smooth spline through the stops instead of straight
+     * lines (Photoshop's Smoothness). Default 0.
+     */
+    smoothness?: number;
+    /** On a stroke: how the gradient lies on it (default `within`). Ignored on fills. */
+    strokeMode?: VectorStrokeGradientMode;
+}
 /** A fill or stroke: any CSS colour, a gradient, or `null` / `'none'` for no paint. */
-type VectorPaint = string | CanvasGradientDef | null;
+type VectorPaint = string | VectorGradient | CanvasGradientDef | null;
 type VectorFillRule = 'nonzero' | 'evenodd';
 type VectorLineCap = 'butt' | 'round' | 'square';
 type VectorLineJoin = 'miter' | 'round' | 'bevel';
@@ -234,9 +319,10 @@ interface VectorHandleRef extends VectorAnchorRef {
  * `shapeBuilder` merges (Alt: deletes) the faces the selected shapes make, and `paintBucket`
  * fills the region the visible outlines enclose around a click with a new shape. `blend`
  * blends the shape clicked first into the one clicked next (clicking an anchor of a closed path
- * starts the blend there).
+ * starts the blend there). `envelope` edits the mesh of the selection's envelope: drag its
+ * anchors and handles, or inside a patch to pull the surface.
  */
-type VectorTool = 'select' | 'direct' | 'pen' | 'pencil' | 'rect' | 'ellipse' | 'polygon' | 'star' | 'line' | 'scissors' | 'knife' | 'eraser' | 'width' | 'shapeBuilder' | 'paintBucket' | 'blend';
+type VectorTool = 'select' | 'direct' | 'pen' | 'pencil' | 'rect' | 'ellipse' | 'polygon' | 'star' | 'line' | 'scissors' | 'knife' | 'eraser' | 'width' | 'shapeBuilder' | 'paintBucket' | 'blend' | 'gradient' | 'envelope';
 declare const VECTOR_TOOLS: readonly VectorTool[];
 /** Keyboard modifiers held during a pointer event. */
 interface VectorModifiers {
@@ -285,10 +371,24 @@ type VectorAverageAxis = 'horizontal' | 'vertical' | 'both';
 /**
  * Live path effects (After Effects' path operators): `trim` (Trim Paths), `roundCorners`,
  * `puckerBloat`, `twist`, `zigzag`, `wiggle` (Wiggle Paths), `offset` (Offset Paths), `merge`
- * (Merge Paths) and `repeater`.
+ * (Merge Paths), `repeater` and `envelope` (an envelope distortion: a warp preset or a mesh).
  */
-type VectorEffectType = 'trim' | 'roundCorners' | 'puckerBloat' | 'twist' | 'zigzag' | 'wiggle' | 'offset' | 'merge' | 'repeater';
+type VectorEffectType = 'trim' | 'roundCorners' | 'puckerBloat' | 'twist' | 'zigzag' | 'wiggle' | 'offset' | 'merge' | 'repeater' | 'envelope';
 declare const VECTOR_EFFECT_TYPES: readonly VectorEffectType[];
+/** Warp presets (Photoshop's fifteen, in menu order). */
+type VectorWarpStyle = 'arc' | 'arcLower' | 'arcUpper' | 'arch' | 'bulge' | 'shellLower' | 'shellUpper' | 'flag' | 'wave' | 'fish' | 'rise' | 'fisheye' | 'inflate' | 'squeeze' | 'twist';
+/**
+ * A grid of bicubic Bézier patches mapping a source box onto the plane. `us` / `vs` are the patch
+ * boundaries as fractions of the box (increasing, first 0, last 1); `points` is the
+ * `(3·(us.length − 1) + 1) × (3·(vs.length − 1) + 1)` control grid, row by row, in the node's own
+ * space. Neighbouring patches share their edge row: anchors sit where both indices are multiples
+ * of 3, handles where one is.
+ */
+interface VectorWarpMesh {
+    us: number[];
+    vs: number[];
+    points: Vec2[];
+}
 /** Merge Paths modes: a compound path (no boolean), union, the first minus the others, intersection or exclusion. */
 type VectorMergeMode = 'merge' | 'add' | 'subtract' | 'intersect' | 'exclude';
 declare const VECTOR_MERGE_MODES: readonly VectorMergeMode[];
@@ -373,6 +473,23 @@ interface VectorEffectParamsMap {
         /** `below`: each copy draws under the one before it; `above`: over it. */
         composite: 'below' | 'above';
     };
+    /**
+     * Envelope distortion: the paths above it are mapped from their combined bounds through a warp
+     * preset (bend and horizontal / vertical distortion in percent) or, with style `mesh`, through
+     * `mesh` (null: the flat mesh of `columns × rows` patches over the bounds). The bounds are
+     * taken afresh each time, so editing the contents keeps the envelope.
+     */
+    envelope: {
+        style: VectorWarpStyle | 'mesh';
+        bend: number;
+        horizontal: number;
+        vertical: number;
+        orientation: 'horizontal' | 'vertical';
+        /** Patches of the mesh (a preset turns into a mesh of this size when it is edited). */
+        rows: number;
+        columns: number;
+        mesh: VectorWarpMesh | null;
+    };
 }
 /** One entry of an effect stack. */
 type VectorEffect = {
@@ -392,11 +509,6 @@ interface VectorSegmentRef {
     segment: number;
 }
 
-/**
- * Vector path geometry: anchors and handles to Bézier paths and back, bounds, hit-testing,
- * affine transforms, segment splitting, anchor-type conversion and shape factories.
- */
-
 declare const cloneAnchor: (a: VectorAnchor) => VectorAnchor;
 declare const cloneSubpath: (s: VectorSubpath) => VectorSubpath;
 /** A deep copy of a node (ids kept). */
@@ -577,6 +689,266 @@ declare function lineSubpath(a: Vec2, b: Vec2): VectorSubpath;
 /** Rounds every coordinate to `precision` decimals (stable JSON and SVG output). */
 declare function roundSubpaths(subpaths: readonly VectorSubpath[], precision?: number): VectorSubpath[];
 
+/** True when `paint` is a gradient (any style). */
+declare function isVectorGradient(paint: VectorPaint | undefined): paint is VectorGradient;
+/** Straight-alpha sRGB channels, 0–1. */
+type VectorRgba = [number, number, number, number];
+/** A CSS colour as 0–1 channels (hex, `rgb()`, `transparent`, `black`, `white`), or null. */
+declare function parseVectorColor(color: string): VectorRgba | null;
+/** Fewest stops a gradient keeps when one is removed. */
+declare const VECTOR_GRADIENT_MIN_STOPS = 2;
+/**
+ * Where relative position `u` of a segment lands once its midpoint is `m` (0.5 = unchanged): the
+ * colour is half-way at `m`, linear on either side (photocraft `midpoint_remap`).
+ */
+declare function gradientMidpointRemap(u: number, m: number): number;
+/** The stops sorted by offset (stable), offsets clamped to 0–1, unreadable offsets dropped. */
+declare function sortedVectorGradientStops(g: Pick<VectorGradient, 'stops'>): VectorGradientStop[];
+/** Does the gradient need extra stops to look the same in SVG (midpoints, smoothness or a non-sRGB space)? */
+declare function vectorGradientNeedsExpansion(g: VectorGradient): boolean;
+/** A gradient's colour ramp, prepared for sampling. */
+interface VectorGradientRamp {
+    /** Straight-alpha sRGB at `t` (clamped to 0–1). */
+    sample(t: number): VectorRgba;
+}
+/**
+ * The colour ramp of a gradient (midpoints, smoothness and interpolation space applied), or null
+ * when a stop colour is not one `parseVectorColor` reads.
+ */
+declare function vectorGradientRamp(g: Pick<VectorGradient, 'stops' | 'interpolation' | 'smoothness'>): VectorGradientRamp | null;
+/** What the gradient paints at `t` (0–1 along its stops): `#rrggbb` and opacity. */
+declare function sampleVectorGradient(g: VectorGradient, t: number): {
+    color: string;
+    opacity: number;
+};
+/**
+ * Plain stops (no midpoints) that SVG's sRGB interpolation turns into the gradient's colours:
+ * the stops as they are when nothing needs expanding; one extra stop per off-centre midpoint for
+ * sRGB without smoothness (exact: the midpoint makes each half linear); otherwise stops placed
+ * adaptively until linear interpolation between them is within `tolerance` (0–1 per channel,
+ * default half a level) of the true curve everywhere they were checked.
+ */
+declare function expandVectorGradientStops(g: VectorGradient, options?: {
+    tolerance?: number;
+}): VectorGradientStop[];
+/** Linear interpolation between plain stops (what SVG draws from them), straight alpha. */
+declare function samplePlainStops(stops: readonly VectorGradientStop[], t: number): VectorRgba;
+/** The gradient with its stops reversed, each midpoint measured from the other side (vectorcraft `reverse`). */
+declare function reverseVectorGradient<T extends Pick<VectorGradient, 'stops'>>(g: T): T;
+/** A stop added at `offset` painting what the gradient paints there; returns the stops and its index. */
+declare function insertVectorGradientStop(g: VectorGradient, offset: number): {
+    stops: VectorGradientStop[];
+    index: number;
+};
+/** Stop `index` moved to `offset` (re-sorted); returns the stops and its new index. */
+declare function moveVectorGradientStop(stops: readonly VectorGradientStop[], index: number, offset: number): {
+    stops: VectorGradientStop[];
+    index: number;
+};
+/** The stops without stop `index`, or null when that would leave fewer than two. */
+declare function removeVectorGradientStop(stops: readonly VectorGradientStop[], index: number): VectorGradientStop[] | null;
+/** Where (0–1 along the gradient) the midpoint after stop `index` sits, or null for the last stop. */
+declare function vectorGradientMidpointPosition(stops: readonly VectorGradientStop[], index: number): number | null;
+/** The midpoint of stop `index` that puts it at position `pos` (clamped to 0.05–0.95), or null. */
+declare function vectorGradientMidpointFromPosition(stops: readonly VectorGradientStop[], index: number, pos: number): number | null;
+/**
+ * The part of the gradient from `from` to `to` (0–1, either order) as plain stops over 0–1
+ * (vectorcraft `span`): the colours at both ends plus the expanded stops between them.
+ */
+declare function spanVectorGradientStops(g: VectorGradient, from: number, to: number, expanded?: VectorGradientStop[]): VectorGradientStop[];
+/** A gradient's frame points, in its units (see `VectorGradient`). */
+interface VectorGradientPoints {
+    start: Vec2;
+    end: Vec2;
+    width: Vec2;
+    focal: Vec2 | null;
+    focalRadius: number;
+    units: VectorGradientUnits;
+}
+/** Whether the gradient carries its own points (rather than the angle / centre shorthand). */
+declare const hasExplicitGradientGeometry: (g: VectorGradient) => boolean;
+/** The gradient's frame points in its units, the shorthand resolved (it is always in the box). */
+declare function vectorGradientPoints(g: VectorGradient): VectorGradientPoints;
+/**
+ * The unit box → `bounds` matrix of `objectBoundingBox` gradients. A side with no extent (a
+ * horizontal or vertical line) takes the other side's, centred, so the gradient still paints
+ * (SVG paints nothing there).
+ */
+declare function vectorBoxMatrix(bounds: VectorBounds | null | undefined): VectorMatrix;
+/** The gradient's units → node space (the box matrix for `objectBoundingBox`, else the identity). */
+declare function vectorGradientUnitsMatrix(g: VectorGradient, bounds: VectorBounds | null | undefined): VectorMatrix;
+/** The gradient's unit frame → node space: u = 1 at the end, v = 1 at the width point. */
+declare function vectorGradientMatrix(g: VectorGradient, bounds: VectorBounds | null | undefined): VectorMatrix;
+/**
+ * t of a radial gradient at unit-frame point `q` with the focal circle centred on `f` with radius
+ * `fr` and the end circle the unit circle (SVG's two-point conical gradient). With `fr = 0` this
+ * is the focal ray: t is the distance from the focal point to `q` over the distance from it to
+ * the circle along the same ray (effectcraft `GradientRamp::t`, vectorcraft `param_at`).
+ */
+declare function vectorGradientFocalParam(q: Vec2, f?: Vec2, fr?: number): number;
+/**
+ * The raw gradient parameter (before the spread) of a style at unit-frame point `q`: linear `u`,
+ * reflected `|u|`, diamond `|u| + |v|`, conic the turn from the u axis towards the v axis (0–1),
+ * radial the distance through the focal circle (photocraft `gradient_t`).
+ */
+declare function vectorGradientParam(type: VectorGradientType, q: Vec2, focal?: {
+    f: Vec2;
+    fr: number;
+} | null): number;
+/** `t` folded into 0–1 by a spread mode. */
+declare function applyVectorGradientSpread(t: number, spread?: VectorGradientSpread): number;
+/** The gradient's t (spread applied) at node-space point `p` of a shape with box `bounds`. */
+declare function vectorGradientTAt(g: VectorGradient, bounds: VectorBounds | null | undefined, p: Vec2): number;
+/** What the gradient paints at node-space point `p` (straight-alpha sRGB, 0–1). */
+declare function sampleVectorGradientAt(g: VectorGradient, bounds: VectorBounds | null | undefined, p: Vec2): VectorRgba;
+/** The main axis length over the secondary's: |width − start| / |end − start| (signed by side). */
+declare function vectorGradientAspect(g: VectorGradient): number;
+/** The gradient with explicit points (in its units) replacing the shorthand. */
+declare function explicitVectorGradient(g: VectorGradient): VectorGradient;
+/**
+ * The gradient in the node's own space (`userSpaceOnUse`), painting what it paints on a shape
+ * with box `bounds` (vectorcraft `GradientPaint::pin`): its points mapped through the box.
+ */
+declare function pinVectorGradient(g: VectorGradient, bounds: VectorBounds | null | undefined): VectorGradient;
+/**
+ * The gradient after the node's geometry is mapped by `m`: a `userSpaceOnUse` gradient's points
+ * are mapped too (any affine map keeps every style's t, since t is measured in the frame the
+ * three points span); a box gradient follows the box and is unchanged.
+ */
+declare function transformVectorGradient(g: VectorGradient, m: VectorMatrix): VectorGradient;
+/**
+ * A gradient after its node's geometry goes through a non-affine map `f` (Free Distort, an
+ * envelope): handles in the node's own space (`userSpaceOnUse`) are mapped point by point, which
+ * keeps the gradient's frame where the shape went; bounding-box gradients are left alone, as they
+ * already follow the shape's new bounds.
+ */
+declare function mapVectorGradient(g: VectorGradient, f: (p: Vec2) => Vec2): VectorGradient;
+/** A paint after its node's geometry goes through a non-affine map `f` (see `mapVectorGradient`). */
+declare function mapVectorPaint<T extends VectorPaint | undefined>(paint: T, f: (p: Vec2) => Vec2): T;
+/** A paint after its node's geometry is mapped by `m` (colours unchanged). */
+declare function transformVectorPaint<T extends VectorPaint | undefined>(paint: T, m: VectorMatrix): T;
+/**
+ * An on-canvas handle of a gradient: `start` (a radial, conic or diamond gradient's centre),
+ * `end` (a linear or reflected gradient's end), `radius` (the end of the others), `aspect` (the
+ * secondary axis' end) and `focal` (radial).
+ */
+type VectorGradientHandle = 'start' | 'end' | 'radius' | 'aspect' | 'focal';
+/** Whether the style has a centre with a radius (rather than a start and an end). */
+declare const isCentredVectorGradient: (type: VectorGradientType) => type is "radial" | "conic" | "diamond";
+/** The handles of a gradient in the space `toWorld` maps the node's space to (the document, the screen). */
+declare function vectorGradientHandles(g: VectorGradient, bounds: VectorBounds | null | undefined, toWorld?: VectorMatrix): {
+    start: Vec2;
+    end: Vec2;
+    aspect: Vec2 | null;
+    focal: Vec2 | null;
+};
+/**
+ * The gradient (pinned to the node's space) with a handle dragged to node-space point `to`.
+ * `start` moves the whole gradient by `to − from`; `end` / `radius` move the end, the secondary
+ * axis and focal point following; `aspect` sets the secondary axis' length square to the main
+ * one; `focal` sets the focal point (pulled inside the circle; null centres it).
+ */
+declare function moveVectorGradientHandle(g: VectorGradient, bounds: VectorBounds | null | undefined, handle: VectorGradientHandle, to: Vec2, from?: Vec2): VectorGradient;
+/** The gradient set to run from `start` to `end` (node space), its secondary axis square to it with its aspect kept. */
+declare function setVectorGradientVector(g: VectorGradient, bounds: VectorBounds | null | undefined, start: Vec2, end: Vec2): VectorGradient;
+/** Most periods a spread is expanded to (vectorcraft `MAX_PERIODS`). */
+declare const VECTOR_GRADIENT_MAX_PERIODS = 64;
+/**
+ * Stops repeating the gradient's plain stops over periods `lo` … `hi` (integers, at most
+ * `VECTOR_GRADIENT_MAX_PERIODS`), period `k` mirrored when `mirrored(k)`; offsets over 0–1 span
+ * the whole range (vectorcraft `spread::expand`, which emulates `reflect` and `repeat` this way).
+ */
+declare function periodicVectorGradientStops(stops: readonly VectorGradientStop[], lo: number, hi: number, mirrored: (k: number) => boolean): VectorGradientStop[];
+/**
+ * A linear or reflected gradient's spread as stop periods over `area` (node space), for
+ * renderers (and combinations) without the spread mode: vectorcraft's SVG import emulates
+ * `reflect` and `repeat` this way. Returns where the periods start and end and their stops, or
+ * null when a linear gradient pads (nothing to repeat). Reflected gradients always get at least
+ * the period either side of the start (the one before it mirrored). `from` / `to` are the
+ * periods' ends along the frame's u axis (`matrix` maps the frame to node space).
+ */
+declare function expandVectorGradientSpread(g: VectorGradient, bounds: VectorBounds | null | undefined, area: VectorBounds): {
+    start: Vec2;
+    end: Vec2;
+    from: number;
+    to: number;
+    matrix: VectorMatrix;
+    stops: VectorGradientStop[];
+    capped: boolean;
+} | null;
+/**
+ * A `<pattern>` paint server in user space: draw `gradients` (inside it or in `<defs>`) and then
+ * each tile (`d` filled with `fill`) in order, all in the painted element's user space (the
+ * `viewBox` in `attrs` matches the tile, so keep it). Conic and diamond gradients, and gradients along
+ * or across a stroke, take this form.
+ */
+interface VectorSvgPatternDef {
+    id: string;
+    type: 'pattern';
+    /** `x`, `y`, `width`, `height`, `patternUnits="userSpaceOnUse"` and the matching `viewBox`. */
+    attrs: Record<string, string | number>;
+    gradients: SvgGradientDef[];
+    tiles: {
+        d: string;
+        fill: string;
+    }[];
+}
+/** A paint server for `fill` / `stroke`: a gradient element or a pattern of gradient tiles. */
+type VectorPaintDef = SvgGradientDef | VectorSvgPatternDef;
+interface VectorGradientSvgOptions {
+    /** The shape's box in its own space (for `objectBoundingBox` gradients). */
+    bounds?: VectorBounds | null;
+    /** The area the paint must cover (pattern tiles, spread periods); default `bounds` padded by 1. */
+    area?: VectorBounds | null;
+    /** Wedges of a conic gradient (default 72: 5° each). */
+    wedges?: number;
+    precision?: number;
+}
+/** The area a gradient on a shape with box `bounds` paints (the box padded by 1). */
+declare const vectorGradientArea: (bounds: VectorBounds | null | undefined) => VectorBounds;
+/**
+ * A user-space pattern tile over `area`. Without a `viewBox` SVG puts the content's origin at the
+ * tile's corner; the matching `viewBox` keeps the content in the painted element's user space.
+ */
+declare function patternAttrs(area: VectorBounds): Record<string, string>;
+/**
+ * The SVG paint servers of a gradient on a shape: the first def's id is `id` (reference it as
+ * `url(#id)`), any others are what it uses. All are in the user space of the element painted
+ * (the node's own space).
+ */
+declare function vectorGradientSvgDefs(g: VectorGradient, id: string, options?: VectorGradientSvgOptions): VectorPaintDef[];
+/**
+ * What a `userSpaceOnUse` paint server from `vectorGradientSvgDefs` paints at point `p` (straight
+ * alpha, 0–1) the way an SVG renderer would: a gradient's stops interpolated in sRGB, a pattern's
+ * topmost tile containing `p`. Null for a point no tile covers.
+ */
+declare function sampleVectorPaintDefAt(defs: readonly VectorPaintDef[], id: string, p: Vec2): VectorRgba | null;
+/**
+ * A gradient from untrusted input (agent commands, SVG data attributes), or null when it is not
+ * one: unknown fields dropped, numbers clamped, at least one stop.
+ */
+declare function sanitizeVectorGradient(input: unknown): VectorGradient | null;
+/**
+ * A gradient changed to style `type`, keeping its stops, colour settings and placement: explicit
+ * points stay where they are (a linear end becomes a radius), shorthand is redone for the style.
+ */
+declare function convertVectorGradient(g: VectorGradient, type: VectorGradientType): VectorGradient;
+/** A default gradient for a paint that was a colour (or nothing): the colour fading to white. */
+declare function defaultVectorGradient(type?: VectorGradientType, from?: VectorPaint): VectorGradient;
+/**
+ * Changes to a gradient (`vector.setGradient`, the gradient editor): any gradient field, plus
+ * `aspect` (the secondary axis' length over the main one, square to it) and `reverse`. `focal` or
+ * `width` set to null removes them.
+ */
+interface VectorGradientPatch extends Partial<Omit<VectorGradient, 'focal' | 'width'>> {
+    focal?: Vec2 | null;
+    width?: Vec2 | null;
+    aspect?: number;
+    reverse?: boolean;
+}
+/** `g` with `patch` applied (a style change converts it first), or null when the result is not a gradient. */
+declare function applyVectorGradientPatch(g: VectorGradient, patch: VectorGradientPatch): VectorGradient | null;
+
 interface VectorSvgExportOptions {
     /** Decimal places for coordinates (default 3). */
     precision?: number;
@@ -599,10 +971,23 @@ interface VectorSvgExportOptions {
 declare function vectorCornersAttribute(subpaths: readonly VectorSubpath[], precision?: number): string;
 /** Puts `data-vector-corners` back on subpaths (malformed entries are ignored). */
 declare function applyVectorCornersAttribute(subpaths: VectorSubpath[], value: string): VectorSubpath[];
-/** A paint as an SVG attribute value plus the gradient def it needs (if any). */
-declare function vectorPaintToSvg(paint: VectorPaint | undefined, gradientId: string): {
+/** Where a paint goes: what `vectorPaintToSvg` needs to place a gradient on a shape. */
+interface VectorPaintSvgOptions {
+    /** The path painted (its box places `objectBoundingBox` gradients; strokes need its geometry). */
+    node?: VectorPathNode;
+    /** `stroke` lays `along` / `across` gradients on the stroke and covers its reach (default `fill`). */
+    role?: 'fill' | 'stroke';
+    precision?: number;
+}
+/** The box of a path's drawn outline in its own space (null when it has no points). */
+declare function vectorPathLocalBounds(node: VectorPathNode): VectorBounds | null;
+/**
+ * A paint as an SVG attribute value plus the paint servers it needs (`url(#id)` refers to the
+ * first). Gradients sit in the painted element's user space (the node's own space).
+ */
+declare function vectorPaintToSvg(paint: VectorPaint | undefined, gradientId: string, options?: VectorPaintSvgOptions): {
     value: string;
-    gradient: SvgGradientDef | null;
+    defs: VectorPaintDef[];
 };
 /** The parts of an aligned or arrowed stroke (see `VectorRenderPath.strokeParts`). */
 interface VectorRenderStrokeParts {
@@ -833,6 +1218,325 @@ declare function pressureWidthProfile(samples: readonly {
     tolerance?: number;
 }): VectorWidthPoint[];
 
+/**
+ * The Gradient tool's on-canvas annotator: a bar from the start (or centre) handle to the end (or
+ * radius) handle with the colour stops under it and midpoint diamonds above it, plus a radial,
+ * conic or diamond gradient's extent outline, aspect handle and (radial) focal point. All in
+ * screen pixels, for hit-testing and the overlay.
+ *
+ * After vectorcraft `crates/tools/src/xform/gradient.rs` (`Annotator`: stop chips below the bar,
+ * midpoints above it, a stop dragged off the bar is removed, a click on the bar adds one), ArtCraft,
+ * MIT OR Apache-2.0 — see THIRD_PARTY_NOTICES.md.
+ */
+
+/** Which paint of the selection the Gradient tool and the gradient editor work on. */
+type VectorGradientTarget = 'fill' | 'stroke';
+/** A part of the annotator under the pointer. */
+type VectorGradientPart = {
+    kind: 'handle';
+    handle: VectorGradientHandle;
+} | {
+    kind: 'stop';
+    index: number;
+} | {
+    kind: 'midpoint';
+    index: number;
+}
+/** The bar at `offset` (0–1): a click adds a stop there, a drag moves the gradient. */
+ | {
+    kind: 'bar';
+    offset: number;
+};
+/** Distance of the stop chips below the bar, the midpoint diamonds above it (screen pixels). */
+declare const VECTOR_GRADIENT_STOP_GAP = 12;
+declare const VECTOR_GRADIENT_MIDPOINT_GAP = 9;
+/** How far off the bar a dragged stop goes before it is removed (screen pixels). */
+declare const VECTOR_GRADIENT_OFF_BAR = 24;
+interface VectorGradientAnnotator {
+    nodeId: string;
+    target: VectorGradientTarget;
+    gradient: VectorGradient;
+    /** The path's box in its own space. */
+    bounds: VectorBounds | null;
+    /** The path's own space → document. */
+    world: AffineMatrix;
+    /** Screen positions of the handles. */
+    start: Vec2;
+    end: Vec2;
+    /** Radial, conic and diamond gradients. */
+    aspect: Vec2 | null;
+    /** Radial gradients. */
+    focal: Vec2 | null;
+    /** Unit normal to the bar towards the stop chips (screen). */
+    normal: Vec2;
+    /** Stops (sorted, as the gradient stores them) with their chips' screen positions. */
+    stops: (VectorGradientStop & {
+        index: number;
+        x: number;
+        y: number;
+    })[];
+    /** The midpoint diamond after each stop but the last (screen). */
+    midpoints: {
+        index: number;
+        x: number;
+        y: number;
+        midpoint: number;
+    }[];
+    /** Screen path of the extent: an ellipse (radial, conic) or a rhombus (diamond). */
+    extent: string | null;
+}
+/** The path whose `target` paint the annotator shows: the first path of the selection with a gradient there. */
+declare function vectorGradientTargetPath(doc: VectorDocument, selection: readonly string[], target: VectorGradientTarget): VectorPathNode | null;
+/** The annotator of the selection's gradient (`target` paint), in screen pixels, or null when it has none. */
+declare function getVectorGradientAnnotator(doc: VectorDocument, selection: readonly string[], viewport: VectorViewport, target: VectorGradientTarget): VectorGradientAnnotator | null;
+/** Where `p` lies relative to the bar: offset along it (0 at the start, 1 at the end) and distance towards the stop chips. */
+declare function vectorGradientBarPosition(a: Pick<VectorGradientAnnotator, 'start' | 'end' | 'normal'>, p: Vec2): {
+    offset: number;
+    across: number;
+};
+/** The annotator part under screen point `p`: stops, then midpoints, the handles and the bar. */
+declare function hitVectorGradientAnnotator(a: VectorGradientAnnotator, p: Vec2): VectorGradientPart | null;
+
+/**
+ * Live appearance: path effect stacks and live boolean groups, evaluated on demand while the
+ * stored anchors and children stay editable.
+ *
+ * `expandVectorAppearance` is the one place the effected geometry is made (cached per node
+ * object, so an edit recomputes only the nodes it replaced). Rendering, hit-testing, bounds,
+ * snapping, booleans, the Pathfinder, the Shape Builder and SVG export all read it, the way they
+ * read live corners through `subpathsToBezier`; Expand Appearance stores it.
+ *
+ * Stacking follows After Effects' shape layers (effectcraft `crates/render/src/shapes.rs`): an
+ * effect acts on every path above it — the node's own outline, or for a group every path of its
+ * children (nested groups included, as drawn by their own effects) — in the order of the stack,
+ * and effects placed after a repeater act on its copies. The result paints with the style of the
+ * path each shape came from; Merge Paths and live booleans paint with the bottom one's.
+ *
+ * Live booleans fold their operands bottom to top, each combined with the result below it by its
+ * own operation or the group's, and every prefix of the fold is cached under a rolling hash of the
+ * operands it covers, so editing one operand recombines only the operands from it up; the cache
+ * drops its least recently used half when full. Live groups are hit by their result except while
+ * they are being edited (`vectorEnteredGroups`).
+ *
+ * Ported from ArtCraft (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
+ * THIRD_PARTY_NOTICES.md): the stacking rule of effectcraft `crates/render/src/shapes.rs`
+ * (`collect()`); figcraft `crates/render/src/boolean.rs` (`fold_cached`, `PathCache`) and
+ * `crates/engine/src/booleans.rs` (`operand_op`, `result_outline`); and the live-object model of
+ * vectorcraft `crates/doc/src/live.rs` (`expand_live`, `expanded_group`, `subtree_has_live`).
+ */
+
+/** One shape of a node's appearance: a path in the node's own space, painted in `source`'s style. */
+interface VectorAppearanceShape {
+    /** The path whose style paints it. */
+    source: VectorPathNode;
+    path: BezierPath;
+    /** Opacity factor relative to the node (its own opacity not included). */
+    opacity: number;
+    /** Draw-order key (compared element by element). */
+    order: number[];
+}
+/** Default parameters of each effect type. */
+declare const VECTOR_EFFECT_DEFAULTS: {
+    readonly [K in VectorEffectType]: VectorEffectParamsMap[K];
+};
+declare const VECTOR_EFFECT_LABELS: Record<VectorEffectType, string>;
+/** How a panel edits one effect parameter. */
+type VectorEffectParamSpec = {
+    key: string;
+    label: string;
+    kind: 'number';
+    min?: number;
+    max?: number;
+    step: number;
+    slider?: boolean;
+} | {
+    key: string;
+    label: string;
+    kind: 'vec2';
+    step: number;
+} | {
+    key: string;
+    label: string;
+    kind: 'boolean';
+} | {
+    key: string;
+    label: string;
+    kind: 'select';
+    options: {
+        value: string;
+        label: string;
+    }[];
+};
+/** The editable parameters of each effect type, in panel order. */
+declare const VECTOR_EFFECT_PARAM_SPECS: Record<VectorEffectType, VectorEffectParamSpec[]>;
+/** Envelope parameters. */
+type VectorEnvelopeParams = VectorEffectParamsMap['envelope'];
+/**
+ * The envelope's mesh over `bounds` (the paths' combined bounds), in the node's space: its own
+ * mesh, the flat mesh of `columns × rows` patches, or a preset split exactly into that many patches.
+ */
+declare function vectorEnvelopeMesh(params: VectorEnvelopeParams, bounds: VectorBounds): VectorWarpMesh;
+/** The envelope as a map of the node's space over `bounds`, or null when it changes nothing (or the box is empty). */
+declare function vectorEnvelopeMap(params: VectorEnvelopeParams, bounds: VectorBounds | null): ((p: {
+    x: number;
+    y: number;
+}) => {
+    x: number;
+    y: number;
+}) | null;
+/**
+ * Effect parameters with defaults filled in and invalid values dropped (unknown keys go too).
+ * Returns null for an unknown type.
+ */
+declare function normalizeVectorEffectParams<K extends VectorEffectType>(type: K, params: Record<string, unknown> | null | undefined, base?: VectorEffectParamsMap[K]): VectorEffectParamsMap[K] | null;
+/** A new effect of `type` (defaults merged with `params`), or null for an unknown type. */
+declare function createVectorEffect<K extends VectorEffectType>(type: K, id: string, params?: Partial<VectorEffectParamsMap[K]> | Record<string, unknown>): Extract<VectorEffect, {
+    type: K;
+}> | null;
+/** The node's effects that take part (enabled, of a known type). */
+declare function activeVectorEffects(node: VectorNode): VectorEffect[];
+/** Whether the node itself draws differently from its stored geometry (effects or a live boolean). */
+declare function hasOwnVectorAppearance(node: VectorNode): boolean;
+/** Whether the node or anything inside it has a live appearance. */
+declare function hasVectorAppearance(node: VectorNode): boolean;
+/** A live boolean group (its children are operands). */
+declare function isVectorLiveBoolean(node: VectorNode | null | undefined): node is VectorGroupNode & {
+    liveBoolean: VectorBooleanOperation;
+};
+/** How operand `child` of a live boolean group combines with the operands below it. */
+declare function vectorOperandOperation(group: VectorGroupNode, child: VectorNode): VectorBooleanOperation;
+/** How many boolean steps (one operand combined with the result below it) live booleans have computed: what a cache miss costs. */
+declare function vectorLiveBooleanSteps(): number;
+/** Empties the live boolean prefix cache. */
+declare function clearVectorLiveBooleanCache(): void;
+/** One operand of a live boolean: its outline (group space), fill rule and operation (unused for the bottom one). */
+interface VectorBooleanOperand {
+    path: BezierPath;
+    fillRule: VectorFillRule;
+    operation: VectorBooleanOperation;
+}
+/**
+ * The result of folding `operands` bottom to top, reusing the longest cached prefix: only the
+ * operands above it are combined. Invalid geometry gives an empty path.
+ */
+declare function foldVectorBooleanOperands(operands: readonly VectorBooleanOperand[]): BezierPath;
+/** Applies an effect stack to shapes, top to bottom (disabled effects skipped). */
+declare function applyVectorEffects(shapes: readonly VectorAppearanceShape[], effects: readonly VectorEffect[] | null | undefined): VectorAppearanceShape[];
+/** The paths entering effect `effectId` of the node's stack (those above it applied), in the node's own space. */
+declare function vectorEffectInputPaths(node: VectorNode, effectId: string): BezierPath[] | null;
+/** The box effect `effectId` (an envelope) bends: the combined bounds of the paths entering it, in the node's own space. */
+declare function vectorEffectInputBounds(node: VectorNode, effectId: string): VectorBounds | null;
+/** The node's first enabled envelope effect, or null. */
+declare function vectorNodeEnvelope(node: VectorNode | null | undefined): Extract<VectorEffect, {
+    type: 'envelope';
+}> | null;
+/**
+ * The editable mesh of a node's envelope (its own mesh, or the preset or flat mesh it stands for)
+ * with the box it bends, in the node's own space; null without an envelope or contents.
+ */
+declare function vectorEnvelopeFrame(node: VectorNode, effectId?: string): {
+    effectId: string;
+    bounds: VectorBounds;
+    mesh: VectorWarpMesh;
+} | null;
+/**
+ * What a node draws as: shapes in its own space (its `transform` and opacity not applied),
+ * bottom to top, with its effects and those of everything inside it applied. Cached per node
+ * object.
+ */
+declare function vectorAppearanceShapes(node: VectorNode): VectorAppearanceShape[];
+/** Everything a node draws as one path in its own space (live corners cut, effects applied). */
+declare function vectorAppearanceOutline(node: VectorNode): BezierPath;
+/** What a node draws as, one plain path per shape (ids `<id>~fx<n>`, opacity relative to the node). */
+declare function vectorAppearanceNodes(node: VectorNode): VectorPathNode[];
+/**
+ * The node as plain geometry: path effects and live booleans evaluated into paths (the node
+ * itself when nothing inside it is live). A path keeps its id when it draws as one shape;
+ * otherwise, like any live group, it becomes a group with that id holding one path per shape
+ * (ids `<id>~fx<n>`). Groups without effects of their own keep their structure. Cached per node.
+ */
+declare function expandVectorAppearance(node: VectorNode): VectorNode;
+/** Every node of a list expanded (the same array when nothing in it is live). */
+declare function expandVectorAppearances(nodes: readonly VectorNode[]): VectorNode[];
+/**
+ * Reads effects from untrusted data (JSON, agent input): unknown types and malformed entries are
+ * dropped, parameters normalized, ids made unique.
+ */
+declare function sanitizeVectorEffects(value: unknown): VectorEffect[];
+/**
+ * Effect parameters carried through a linear map baked into a node's geometry (scaling or
+ * flipping it): offsets and positions move with it, angles turn the other way when it mirrors.
+ * Lengths such as sizes and radii are kept, like stroke widths.
+ */
+declare function transformVectorEffects(effects: readonly VectorEffect[], m: AffineMatrix, node?: VectorNode): VectorEffect[];
+/**
+ * The live groups (live booleans and groups with effects) being edited: those in `ids` and those
+ * holding a node in `ids`. Their children are hit and outlined as stored instead of as drawn, so
+ * each operand can be picked (figcraft `crates/engine/src/booleans.rs`, `result_outline`).
+ */
+declare function vectorEnteredGroups(nodes: readonly VectorNode[], ids: readonly string[]): Set<string>;
+
+/** A map of the plane (document or node space). */
+type VectorPointMap = (p: Vec2) => Vec2;
+/** Every anchor and handle of `subpaths` through `f` (no subdivision). */
+declare function mapVectorPoints(subpaths: readonly VectorSubpath[], f: VectorPointMap): VectorSubpath[];
+interface MapVectorSubpathsOptions {
+    /** Refit runs of split pieces with fewer cubics where they stay within the tolerance (default true). */
+    refit?: boolean;
+}
+/**
+ * `subpaths` through a smooth, possibly non-linear map `f`: each segment is split in halves until
+ * its mapped control points follow the mapped curve within `tolerance` (at most 64 pieces a
+ * segment, fewer for huge paths), then refitted with fewer cubics where possible. A straight
+ * segment whose image is straight stays a straight segment; anchors keep their types and live
+ * corners, and the anchors added are smooth.
+ */
+declare function mapVectorSubpaths(subpaths: readonly VectorSubpath[], f: VectorPointMap, tolerance?: number, options?: MapVectorSubpathsOptions): VectorSubpath[];
+/** `mapVectorSubpaths` for Bézier commands (live corners are not involved). */
+declare function mapBezierPath(path: BezierPathInput, f: VectorPointMap, tolerance?: number, options?: MapVectorSubpathsOptions): BezierPath;
+
+/**
+ * Free Distort, perspective and skew: the selection box's corners or sides dragged, and nodes sent
+ * through a map of document space while each keeps its own (rigid) transform.
+ *
+ * Ported from ArtCraft (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
+ * THIRD_PARTY_NOTICES.md): vectorcraft `crates/tools/src/xform/free.rs` (`distort_quad`: a corner
+ * moved freely, or with its partner mirrored along the dominant axis for perspective, and a side's
+ * two corners moved together; `shear_for_side`: a side handle shears about the opposite side, or
+ * the centre with Alt).
+ */
+
+/** Default tolerance (document units) of Free Distort's adaptive path mapping. */
+declare const VECTOR_DISTORT_TOLERANCE = 0.05;
+/** How dragging a selection box handle distorts it: each corner freely, or in symmetric perspective. */
+type VectorDistortMode = 'distort' | 'perspective';
+/** A box's corners clockwise from the top left. */
+declare const vectorBoxCorners: (b: VectorBounds) => Vec2[];
+/**
+ * The quad (clockwise from the top left) box `b` becomes when handle `handle` is dragged by `d`: a
+ * corner moves by `d` (`distort`), or along the drag's dominant axis with the corner beside it on
+ * that side moving the opposite way (`perspective`); a side moves both its corners.
+ */
+declare function vectorDistortQuad(b: VectorBounds, handle: VectorTransformHandle, d: Vec2, mode?: VectorDistortMode): Vec2[];
+/**
+ * The skew for dragging side `handle` of box `b` by `d`: along that side, about the opposite side
+ * (or the centre, `fromCenter`). Corners give the identity.
+ */
+declare function vectorShearForSide(b: VectorBounds, handle: VectorTransformHandle, d: Vec2, fromCenter?: boolean): AffineMatrix;
+/**
+ * A skew by `ax` degrees horizontally (vertical lines lean right for positive angles: x' = x + tan(ax)·y)
+ * and `ay` degrees vertically (y' = y + tan(ay)·x), about `origin`.
+ */
+declare function vectorSkewMatrix(ax: number, ay: number, origin?: Vec2): AffineMatrix;
+/**
+ * A node sent through `f`, a map of the space `parentToDoc` maps its parent to (the document):
+ * every anchor and handle is mapped in the node's own space, adaptively so curves stay within
+ * `tolerance`, and the node keeps its rigid `transform`. Gradients in the node's space have their
+ * handles mapped (bounding-box ones follow the new bounds), envelope meshes and a blend's spine
+ * are mapped too; stroke widths, live corner radii and effect parameters are kept.
+ */
+declare function distortVectorNode<T extends VectorNode>(node: T, parentToDoc: AffineMatrix, f: VectorPointMap, tolerance?: number): T;
+
 /**
  * What a guide line shows: `align` lines run from a target through the snapped point or box,
  * `construction` lines from where a drawn point leaves, `spacing` marks equal gaps and `size`
@@ -1101,6 +1805,8 @@ interface VectorEditorOptions {
     createId?: () => string;
     /** Called after the document changes (edits, undo, redo, load). */
     onChange?: (document: VectorDocument) => void;
+    /** Start in Free Distort mode (see `setFreeDistort`). */
+    freeDistort?: boolean;
 }
 /** A pointer event as the controller needs it. Positions are in screen pixels relative to the canvas. */
 interface VectorPointerInput extends VectorModifiers {
@@ -1170,6 +1876,13 @@ interface VectorHover {
     };
     /** A spot on a stroke away from its width points (width tool). */
     strokeSpot?: VectorStrokeSpot;
+    /** A part of the gradient annotator (gradient tool). */
+    gradient?: VectorGradientPart;
+    /** A control point of the selected envelope's mesh (`index`), or a spot inside it (`index` null): Envelope tool. */
+    envelope?: {
+        nodeId: string;
+        index: number | null;
+    };
 }
 /** The drag in progress, for overlays and status text. */
 type VectorInteraction = {
@@ -1224,6 +1937,25 @@ type VectorInteraction = {
 } | {
     type: 'pen';
     nodeId: string;
+}
+/** A gradient tool drag: drawing a new vector, or a handle, stop, midpoint or the bar (`removing`: a stop dragged off the bar). */
+ | {
+    type: 'gradient';
+    part: 'create' | VectorGradientPart['kind'];
+    handle?: VectorGradientHandle;
+    removing?: boolean;
+}
+/** Free Distort: the selection box's corners as dragged so far (document space, clockwise from the top left). */
+ | {
+    type: 'distort';
+    mode: VectorDistortMode | 'skew';
+    corners: Vec2[];
+}
+/** Envelope tool: a mesh point (`index`) or the surface (`index` null) being dragged. */
+ | {
+    type: 'envelope';
+    nodeId: string;
+    index: number | null;
 } | {
     type: 'pan';
 };
@@ -1269,6 +2001,17 @@ interface VectorEditorState {
     blendStart: VectorBlendStart | null;
     /** Options new blends get. */
     blendDefaults: VectorBlendOptions;
+    /** The paint the gradient tool and gradient editor work on, and the selected stop (index into the sorted stops). */
+    gradientEdit: {
+        target: VectorGradientTarget;
+        stop: number | null;
+    };
+    /**
+     * Free Distort mode of the selection box: dragging a corner distorts in perspective (each corner
+     * on its own; Shift+Alt+Mod: symmetric perspective), a side moves its two corners, and Mod-dragging
+     * a side skews along it (Alt: about the centre).
+     */
+    freeDistort: boolean;
     canUndo: boolean;
     canRedo: boolean;
     undoLabel: string;
@@ -1474,6 +2217,19 @@ interface VectorSelectionBoxGeometry {
     corners: Vec2[];
 }
 declare function getVectorSelectionBoxGeometry(frame: VectorSelectionFrame, viewport: VectorViewport): VectorSelectionBoxGeometry;
+/**
+ * The node the Envelope tool edits: the one selected node with an enabled envelope, with the
+ * envelope's mesh and box (node space) and the node → document matrix. Null otherwise.
+ */
+declare function getVectorEnvelopeTarget(doc: VectorDocument, selection: readonly string[]): {
+    node: VectorNode;
+    frame: {
+        effectId: string;
+        bounds: VectorBounds;
+        mesh: VectorWarpMesh;
+    };
+    world: AffineMatrix;
+} | null;
 /** The resize cursor for a handle of a box rotated by `angle` degrees. */
 declare function vectorResizeCursor(handle: VectorTransformHandle, angle?: number): string;
 declare function vectorToolLabel(tool: VectorTool): string;
@@ -1524,6 +2280,8 @@ declare class VectorEditorController {
     private blendStart;
     /** Options new blends get (the toolbars edit them along with the selected blend's). */
     private blendDefaults;
+    private gradientEdit;
+    private freeDistort;
     /** What the highlight shows, to skip notifying when the pointer stays over the same face. */
     private builderHoverKey;
     private readonly createId;
@@ -1536,7 +2294,13 @@ declare class VectorEditorController {
     private revision;
     private state;
     constructor(options?: VectorEditorOptions);
-    /** Stops listening to the history. */
+    /** Listens to the history (once; again after `destroy`). */
+    private connect;
+    private historyDiffers;
+    /**
+     * Stops listening to the history and drops all listeners. A later `subscribe` reconnects, so a
+     * controller torn down by React StrictMode's double effect keeps working when it is reused.
+     */
     destroy(): void;
     /** The current snapshot (stable until the next change). */
     getState: () => VectorEditorState;
@@ -1658,6 +2422,47 @@ declare class VectorEditorController {
     } | null, options?: {
         ids?: readonly string[];
     }): VectorActionResult;
+    /** Which paint (fill or stroke) the gradient tool and editor work on. */
+    setGradientTarget(target: VectorGradientTarget): void;
+    /** Selects a stop of the gradient being edited (index into its sorted stops), or none. */
+    selectGradientStop(index: number | null): void;
+    /** The gradient tool's annotator for the selection (screen pixels), or null when its paint is not a gradient. */
+    getGradientAnnotator(): VectorGradientAnnotator | null;
+    /** Unlocked paths of `ids` (default: the selection). */
+    private gradientPaths;
+    /**
+     * Edits the gradient of the `target` paint (default: the editor's) of the selected (or given)
+     * paths with `patch`: a colour or no paint becomes a gradient (`patch.type`, default linear,
+     * from the colour to white). Consecutive edits with the same `merge` key are one undo step.
+     */
+    setGradient(patch: VectorGradientPatch, options?: {
+        ids?: readonly string[];
+        target?: VectorGradientTarget;
+        label?: string;
+        merge?: string;
+    }): VectorActionResult;
+    /** Applies `fn` to every target gradient of the selection (paths whose paint is not a gradient are skipped). */
+    private editGradients;
+    /** Changes stop `index` (colour, opacity, offset or midpoint) of the selection's gradients; selects it. */
+    setGradientStop(index: number, patch: {
+        color?: string;
+        opacity?: number;
+        offset?: number;
+        midpoint?: number;
+    }, options?: {
+        merge?: string;
+    }): VectorActionResult;
+    /** Adds a stop at `offset` (painting what the gradient paints there) to the selection's gradients and selects it. */
+    addGradientStop(offset: number): VectorActionResult;
+    /** Removes stop `index` of the selection's gradients (never below two stops). */
+    removeGradientStop(index: number): VectorActionResult;
+    /** Reverses the selection's gradients (stops and midpoints). */
+    reverseGradient(): VectorActionResult;
+    /** `doc` with path `id`'s `target` paint replaced. */
+    private withGradient;
+    private downGradient;
+    private moveGradient;
+    private upGradient;
     /** Removes one width point of a path's profile. */
     removeWidthPoint(ref: Pick<VectorWidthPointRef, 'nodeId' | 'index'>): VectorActionResult;
     /** Removes width points (default: the selected ones — the width tool's Delete), as one undo step. */
@@ -1783,6 +2588,83 @@ declare class VectorEditorController {
     private selectedRoots;
     /** `m`, given in a frame rotated by `angle`, as a document-space matrix. */
     private inFrame;
+    /** The selection frame's corners in document space, clockwise from the top left. */
+    private frameCorners;
+    /** `doc` with nodes `ids` sent through `f` (a map of document space), each in its own space (see `distortVectorNode`). */
+    private distorted;
+    /**
+     * Free Distort mode of the selection box (`state.freeDistort`): dragging a corner distorts the
+     * selection in perspective, each corner on its own (Shift+Alt+Mod: symmetric perspective, the
+     * corner beside it moving the other way); dragging a side moves its two corners; Mod-dragging a
+     * side skews along it (Alt: about the centre). Each drag is one undo step.
+     */
+    setFreeDistort(on: boolean): void;
+    /**
+     * Distorts the selected (or given) nodes so the corners of their selection box (clockwise from
+     * the top left, in the box's own rotation) land on `corners` (document space): a projective map,
+     * so straight lines stay straight. Curves are followed within `tolerance` (document units).
+     * One undo step.
+     */
+    distort(corners: readonly Vec2[], options?: {
+        ids?: readonly string[];
+        tolerance?: number;
+    }): VectorActionResult;
+    /**
+     * Skews the selected (or given) nodes along the selection box's own axes by `ax` degrees
+     * horizontally (x' = x + tan(ax)·y: vertical lines lean right for positive angles) and `ay`
+     * vertically, about `origin` (default: the box centre, document space). One undo step.
+     */
+    skew(ax: number, ay?: number, options?: {
+        ids?: readonly string[];
+        origin?: Vec2;
+    }): VectorActionResult;
+    /** A selection box handle dragged in Free Distort mode. */
+    private moveDistort;
+    /** Selected (or given) roots that can carry an envelope. */
+    private envelopeTargets;
+    /** Envelope parameters for `node` after `patch`: a preset switched to a mesh becomes the mesh it stood for. */
+    private envelopeParams;
+    /**
+     * Gives the selected (or given) nodes an envelope distortion, or changes the one they have: a
+     * warp preset (`style` with `bend`, `horizontal` and `vertical` in percent and `orientation`) or
+     * a mesh (`style: 'mesh'` with `rows` and `columns`, and optionally its `mesh` points). The
+     * envelope stays live (an `envelope` effect: edit it with the Envelope tool, Expand Appearance
+     * bakes it). One undo step (with `merge`, consecutive changes fold into one, as a slider drag
+     * should). Returns the envelope of each node.
+     */
+    envelope(params?: Partial<VectorEnvelopeParams>, options?: {
+        ids?: readonly string[];
+        merge?: boolean;
+    }): {
+        nodeId: string;
+        effectId: string;
+    }[];
+    /**
+     * Make with Top Object: the topmost selected object's outline (a closed path) becomes the envelope
+     * of the other selected objects (grouped when there are several; they must share a parent), as a
+     * mesh of `columns × rows` patches whose border follows the outline. The top object is used up.
+     * One undo step; returns the id of the enveloped node.
+     */
+    makeEnvelopeWithTopObject(options?: {
+        ids?: readonly string[];
+        rows?: number;
+        columns?: number;
+    }): VectorActionResult & {
+        nodeId?: string;
+    };
+    /**
+     * Release: the selected (or given) nodes lose their envelope, and its shape (the mesh's border)
+     * comes back as a path above each of them. One undo step; returns the new paths' ids.
+     */
+    releaseEnvelope(options?: {
+        ids?: readonly string[];
+    }): string[];
+    /** The selected node the Envelope tool edits, with its mesh (node space) and node → document matrix. */
+    private envelopeTarget;
+    /** The envelope mesh point under `screen` (handles first), or a spot inside the mesh. */
+    private hitEnvelope;
+    private downEnvelope;
+    private moveEnvelope;
     /** Applies a matrix to the selected (or given) nodes as one undo step. */
     transform(matrix: AffineMatrix, options?: {
         ids?: readonly string[];
@@ -2172,153 +3054,6 @@ declare function scaleFor(handle: VectorTransformHandle, b: VectorBounds, p: Vec
     origin: Vec2;
 };
 
-/**
- * Live appearance: path effect stacks and live boolean groups, evaluated on demand while the
- * stored anchors and children stay editable.
- *
- * `expandVectorAppearance` is the one place the effected geometry is made (cached per node
- * object, so an edit recomputes only the nodes it replaced). Rendering, hit-testing, bounds,
- * snapping, booleans, the Pathfinder, the Shape Builder and SVG export all read it, the way they
- * read live corners through `subpathsToBezier`; Expand Appearance stores it.
- *
- * Stacking follows After Effects' shape layers (effectcraft `crates/render/src/shapes.rs`): an
- * effect acts on every path above it — the node's own outline, or for a group every path of its
- * children (nested groups included, as drawn by their own effects) — in the order of the stack,
- * and effects placed after a repeater act on its copies. The result paints with the style of the
- * path each shape came from; Merge Paths and live booleans paint with the bottom one's.
- *
- * Live booleans fold their operands bottom to top, each combined with the result below it by its
- * own operation or the group's, and every prefix of the fold is cached under a rolling hash of the
- * operands it covers, so editing one operand recombines only the operands from it up; the cache
- * drops its least recently used half when full. Live groups are hit by their result except while
- * they are being edited (`vectorEnteredGroups`).
- *
- * Ported from ArtCraft (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
- * THIRD_PARTY_NOTICES.md): the stacking rule of effectcraft `crates/render/src/shapes.rs`
- * (`collect()`); figcraft `crates/render/src/boolean.rs` (`fold_cached`, `PathCache`) and
- * `crates/engine/src/booleans.rs` (`operand_op`, `result_outline`); and the live-object model of
- * vectorcraft `crates/doc/src/live.rs` (`expand_live`, `expanded_group`, `subtree_has_live`).
- */
-
-/** One shape of a node's appearance: a path in the node's own space, painted in `source`'s style. */
-interface VectorAppearanceShape {
-    /** The path whose style paints it. */
-    source: VectorPathNode;
-    path: BezierPath;
-    /** Opacity factor relative to the node (its own opacity not included). */
-    opacity: number;
-    /** Draw-order key (compared element by element). */
-    order: number[];
-}
-/** Default parameters of each effect type. */
-declare const VECTOR_EFFECT_DEFAULTS: {
-    readonly [K in VectorEffectType]: VectorEffectParamsMap[K];
-};
-declare const VECTOR_EFFECT_LABELS: Record<VectorEffectType, string>;
-/** How a panel edits one effect parameter. */
-type VectorEffectParamSpec = {
-    key: string;
-    label: string;
-    kind: 'number';
-    min?: number;
-    max?: number;
-    step: number;
-    slider?: boolean;
-} | {
-    key: string;
-    label: string;
-    kind: 'vec2';
-    step: number;
-} | {
-    key: string;
-    label: string;
-    kind: 'boolean';
-} | {
-    key: string;
-    label: string;
-    kind: 'select';
-    options: {
-        value: string;
-        label: string;
-    }[];
-};
-/** The editable parameters of each effect type, in panel order. */
-declare const VECTOR_EFFECT_PARAM_SPECS: Record<VectorEffectType, VectorEffectParamSpec[]>;
-/**
- * Effect parameters with defaults filled in and invalid values dropped (unknown keys go too).
- * Returns null for an unknown type.
- */
-declare function normalizeVectorEffectParams<K extends VectorEffectType>(type: K, params: Record<string, unknown> | null | undefined, base?: VectorEffectParamsMap[K]): VectorEffectParamsMap[K] | null;
-/** A new effect of `type` (defaults merged with `params`), or null for an unknown type. */
-declare function createVectorEffect<K extends VectorEffectType>(type: K, id: string, params?: Partial<VectorEffectParamsMap[K]> | Record<string, unknown>): Extract<VectorEffect, {
-    type: K;
-}> | null;
-/** The node's effects that take part (enabled, of a known type). */
-declare function activeVectorEffects(node: VectorNode): VectorEffect[];
-/** Whether the node itself draws differently from its stored geometry (effects or a live boolean). */
-declare function hasOwnVectorAppearance(node: VectorNode): boolean;
-/** Whether the node or anything inside it has a live appearance. */
-declare function hasVectorAppearance(node: VectorNode): boolean;
-/** A live boolean group (its children are operands). */
-declare function isVectorLiveBoolean(node: VectorNode | null | undefined): node is VectorGroupNode & {
-    liveBoolean: VectorBooleanOperation;
-};
-/** How operand `child` of a live boolean group combines with the operands below it. */
-declare function vectorOperandOperation(group: VectorGroupNode, child: VectorNode): VectorBooleanOperation;
-/** How many boolean steps (one operand combined with the result below it) live booleans have computed: what a cache miss costs. */
-declare function vectorLiveBooleanSteps(): number;
-/** Empties the live boolean prefix cache. */
-declare function clearVectorLiveBooleanCache(): void;
-/** One operand of a live boolean: its outline (group space), fill rule and operation (unused for the bottom one). */
-interface VectorBooleanOperand {
-    path: BezierPath;
-    fillRule: VectorFillRule;
-    operation: VectorBooleanOperation;
-}
-/**
- * The result of folding `operands` bottom to top, reusing the longest cached prefix: only the
- * operands above it are combined. Invalid geometry gives an empty path.
- */
-declare function foldVectorBooleanOperands(operands: readonly VectorBooleanOperand[]): BezierPath;
-/** Applies an effect stack to shapes, top to bottom (disabled effects skipped). */
-declare function applyVectorEffects(shapes: readonly VectorAppearanceShape[], effects: readonly VectorEffect[] | null | undefined): VectorAppearanceShape[];
-/**
- * What a node draws as: shapes in its own space (its `transform` and opacity not applied),
- * bottom to top, with its effects and those of everything inside it applied. Cached per node
- * object.
- */
-declare function vectorAppearanceShapes(node: VectorNode): VectorAppearanceShape[];
-/** Everything a node draws as one path in its own space (live corners cut, effects applied). */
-declare function vectorAppearanceOutline(node: VectorNode): BezierPath;
-/** What a node draws as, one plain path per shape (ids `<id>~fx<n>`, opacity relative to the node). */
-declare function vectorAppearanceNodes(node: VectorNode): VectorPathNode[];
-/**
- * The node as plain geometry: path effects and live booleans evaluated into paths (the node
- * itself when nothing inside it is live). A path keeps its id when it draws as one shape;
- * otherwise, like any live group, it becomes a group with that id holding one path per shape
- * (ids `<id>~fx<n>`). Groups without effects of their own keep their structure. Cached per node.
- */
-declare function expandVectorAppearance(node: VectorNode): VectorNode;
-/** Every node of a list expanded (the same array when nothing in it is live). */
-declare function expandVectorAppearances(nodes: readonly VectorNode[]): VectorNode[];
-/**
- * Reads effects from untrusted data (JSON, agent input): unknown types and malformed entries are
- * dropped, parameters normalized, ids made unique.
- */
-declare function sanitizeVectorEffects(value: unknown): VectorEffect[];
-/**
- * Effect parameters carried through a linear map baked into a node's geometry (scaling or
- * flipping it): offsets and positions move with it, angles turn the other way when it mirrors.
- * Lengths such as sizes and radii are kept, like stroke widths.
- */
-declare function transformVectorEffects(effects: readonly VectorEffect[], m: AffineMatrix): VectorEffect[];
-/**
- * The live groups (live booleans and groups with effects) being edited: those in `ids` and those
- * holding a node in `ids`. Their children are hit and outlined as stored instead of as drawn, so
- * each operand can be picked (figcraft `crates/engine/src/booleans.rs`, `result_outline`).
- */
-declare function vectorEnteredGroups(nodes: readonly VectorNode[], ids: readonly string[]): Set<string>;
-
 interface VectorRenderPath {
     kind: 'path';
     id: string;
@@ -2357,8 +3092,12 @@ interface VectorSceneRenderData {
     width: number;
     height: number;
     background?: string;
-    /** Gradients referenced by `fill` / `stroke` values. */
-    defs: SvgGradientDef[];
+    /**
+     * Paint servers referenced by `fill` / `stroke` values: `<linearGradient>` /
+     * `<radialGradient>` descriptors and `pattern`s (conic, diamond and stroke-mode gradients:
+     * draw each of `gradients`, then each tile filled, inside a `<pattern>`).
+     */
+    defs: VectorPaintDef[];
     /** Visible nodes, bottom to top. */
     nodes: VectorRenderNode[];
 }
@@ -2441,7 +3180,43 @@ interface VectorOverlayRenderData {
         transform: string;
         corners: Vec2[];
         handles: VectorSelectionBoxGeometry['handles'];
+        freeDistort: boolean;
     }) | null;
+    /**
+     * A Free Distort drag (screen space): the quad the selection box's corners make so far (`d`,
+     * closed path data) and its corners clockwise from the top left. The box is hidden meanwhile.
+     */
+    distort: {
+        mode: 'distort' | 'perspective' | 'skew';
+        d: string;
+        corners: Vec2[];
+    } | null;
+    /**
+     * The Envelope tool's mesh of the selected envelope (screen space): `grid` is the grid lines as
+     * path data, `anchors` the points where they cross and `handles` the handles along them, each
+     * with the anchor it belongs to (`index` is the point's index in the mesh). Draw anchors as
+     * squares and handles as dots joined to their anchors.
+     */
+    envelope: {
+        nodeId: string;
+        grid: string;
+        anchors: {
+            index: number;
+            x: number;
+            y: number;
+            hovered: boolean;
+            active: boolean;
+        }[];
+        handles: {
+            index: number;
+            x: number;
+            y: number;
+            anchorX: number;
+            anchorY: number;
+            hovered: boolean;
+            active: boolean;
+        }[];
+    } | null;
     anchors: VectorRenderAnchor[];
     handles: VectorRenderHandle[];
     /** Marquee rectangle, screen space. */
@@ -2528,9 +3303,62 @@ interface VectorOverlayRenderData {
             hovered: boolean;
         }[];
     };
+    /** The gradient tool's annotator over the selection's gradient (screen space), or null. */
+    gradient: VectorRenderGradientAnnotator | null;
     /** A short status, e.g. "W 120 × H 80" or "45°". */
     status: string | null;
 }
+/**
+ * The gradient annotator in screen pixels: draw the `extent` outline (dashed), the bar from
+ * `start` to `end`, the handles, each stop's chip (a swatch at `x, y` with a tick to `barX, barY`;
+ * `removing`: the dragged stop is off the bar and will be deleted, draw it faded) and the
+ * midpoint diamonds.
+ */
+interface VectorRenderGradientAnnotator {
+    nodeId: string;
+    type: VectorGradientType;
+    start: {
+        x: number;
+        y: number;
+        hovered: boolean;
+    };
+    /** `radius` for radial, conic and diamond gradients. */
+    end: {
+        x: number;
+        y: number;
+        hovered: boolean;
+        handle: 'end' | 'radius';
+    };
+    aspect: {
+        x: number;
+        y: number;
+        hovered: boolean;
+    } | null;
+    focal: {
+        x: number;
+        y: number;
+        hovered: boolean;
+    } | null;
+    stops: {
+        index: number;
+        x: number;
+        y: number;
+        barX: number;
+        barY: number;
+        color: string;
+        opacity: number;
+        selected: boolean;
+        hovered: boolean;
+    }[];
+    midpoints: {
+        index: number;
+        x: number;
+        y: number;
+        hovered: boolean;
+    }[];
+    extent: string | null;
+    removing: boolean;
+}
 /** Distance between the Shape Builder's hatch lines over a face (screen pixels). */
 declare const VECTOR_BUILDER_HATCH_GAP = 6;
 /**
@@ -2544,6 +3372,31 @@ declare function getVectorSceneRenderData(state: Pick<VectorEditorState, 'docume
 declare function getVectorEnteredGroups(state: Pick<VectorEditorState, 'document' | 'selection' | 'editingId'>): Set<string>;
 /** The editing overlay in screen pixels. Render it on top of the scene, untransformed. */
 declare function getVectorOverlayRenderData(state: VectorEditorState): VectorOverlayRenderData;
+/** Warp choices of an envelope: the fifteen presets, then Mesh. */
+declare const VECTOR_ENVELOPE_STYLE_OPTIONS: readonly {
+    value: VectorEnvelopeParams['style'];
+    label: string;
+}[];
+/** What a Distort / Envelope panel shows for the selection. */
+interface VectorEnvelopePanelData {
+    /** The one selected node, or null when several are selected. */
+    nodeId: string | null;
+    count: number;
+    /** The selected node's envelope (the first one in its stack), if any. */
+    envelope: {
+        effectId: string;
+        enabled: boolean;
+        params: VectorEnvelopeParams;
+    } | null;
+    /** Some selected node can take an envelope (Make with Warp / Mesh). */
+    canMake: boolean;
+    /** Make with Top Object: several objects selected and the topmost is a closed path. */
+    canMakeWithTopObject: boolean;
+    /** Some selected node has an envelope (Release, Expand). */
+    canRelease: boolean;
+}
+/** The Distort / Envelope panel of the selection, or null when nothing is selected. */
+declare function getVectorEnvelopePanel(state: Pick<VectorEditorState, 'document' | 'selection'>): VectorEnvelopePanelData | null;
 /** What the Blend controls of a toolbar or style panel show. */
 interface VectorBlendControls {
     /** Ids of the selected blends (a selected key counts as its blend). */
@@ -2680,6 +3533,38 @@ declare const VECTOR_CORNER_KIND_LABELS: Readonly<Record<VectorCornerKind, strin
 declare const VECTOR_ARROWHEAD_LABELS: Readonly<Record<VectorArrowhead, string>>;
 /** A paint as `#rrggbb` for `<input type="color">`, or null for none, gradients and other CSS colours. */
 declare function vectorPaintToHex(paint: VectorPaint | undefined): string | null;
+declare const VECTOR_GRADIENT_TYPE_LABELS: Readonly<Record<VectorGradientType, string>>;
+declare const VECTOR_GRADIENT_SPREAD_LABELS: Readonly<Record<VectorGradientSpread, string>>;
+declare const VECTOR_GRADIENT_INTERPOLATION_LABELS: Readonly<Record<VectorGradientInterpolation, string>>;
+declare const VECTOR_STROKE_GRADIENT_MODE_LABELS: Readonly<Record<VectorStrokeGradientMode, string>>;
+/** What a gradient editor shows for the selection's `target` paint (see `getVectorGradientEditor`). */
+interface VectorGradientEditorData {
+    target: 'fill' | 'stroke';
+    /** The first selected path's paint is a gradient. */
+    gradient: VectorGradient | null;
+    /** The paint as a `#rrggbb` colour when it is one (what a new gradient starts from). */
+    color: string | null;
+    /** Sorted stops; `index` is what `setGradientStop` takes. */
+    stops: (VectorGradientStop & {
+        index: number;
+        selected: boolean;
+    })[];
+    selected: (VectorGradientStop & {
+        index: number;
+        last: boolean;
+    }) | null;
+    /** A CSS `linear-gradient(to right, …)` of the ramp (midpoints and colour space expanded). */
+    preview: string | null;
+    type: VectorGradientType | null;
+    spread: VectorGradientSpread;
+    interpolation: VectorGradientInterpolation;
+    smoothness: number;
+    strokeMode: VectorStrokeGradientMode;
+    /** The selected paths' gradients differ. */
+    mixed: boolean;
+}
+/** The gradient editor of the selection's fill or stroke (`state.gradientEdit.target`), or null with nothing selected. */
+declare function getVectorGradientEditor(state: Pick<VectorEditorState, 'document' | 'selection' | 'gradientEdit'>): VectorGradientEditorData | null;
 /** A path-editing button of the bundled toolbars. */
 interface VectorPathAction {
     id: 'join' | 'average' | 'cut' | 'clean' | 'smooth' | 'outline';
@@ -2716,6 +3601,7 @@ interface VectorEffectsPanelItem {
     label: string;
     enabled: boolean;
     params: Record<string, unknown>;
+    /** The parameters to edit (none for an envelope: `getVectorEnvelopePanel` and the Envelope panels edit it). */
     specs: readonly VectorEffectParamSpec[];
 }
 /** What an Effects panel shows for the selection. */
@@ -3267,7 +4153,7 @@ declare function vectorFillMap(doc: VectorDocument, gap?: number): PlanarMap | n
  *   pair turns the same way), so a nonzero fill keeps its holes.
  * - **In-betweens** follow the shapes' best-fit rotation and scale (Procrustes), with the
  *   leftover difference blended in linearly, so a turning shape turns instead of collapsing.
- * - **Paint**: colours mix in OKLab, gradients of one kind resample their stops to a common
+ * - **Paint**: colours mix in OKLab, gradients of one style resample their stops to a common
  *   set, a missing paint fades from transparent; stroke width, opacity, dashes, arrowhead
  *   scales and width profiles interpolate, and the rest switches halfway.
  * - **Transforms**: both shapes are blended in their parent's space; the in-between's rigid
@@ -3368,8 +4254,11 @@ declare function interpolateMorphContours(a: readonly VectorMorphContour[], b: r
 declare function interpolateRigidMatrix(a: AffineMatrix, b: AffineMatrix, t: number): AffineMatrix;
 /** Two colours mixed in OKLab (premultiplied alpha); unreadable colours switch halfway. */
 declare function interpolateVectorColor(a: string, b: string, t: number): string;
-/** A gradient's stops resampled at `offsets`, each painting what the gradient paints there. */
-declare function resampleGradientStops(g: CanvasGradientDef, offsets: readonly number[]): GradientStop[];
+/**
+ * A gradient's stops resampled at `offsets`, each painting what the gradient paints there (its
+ * midpoints, smoothness and interpolation space included).
+ */
+declare function resampleGradientStops(g: VectorGradient, offsets: readonly number[]): VectorGradientStop[];
 /**
  * Interpolates paints: colours in OKLab, gradients of one kind with their stops resampled to a
  * common set, a colour and a gradient through a gradient of that colour, and a missing paint
@@ -3561,4 +4450,173 @@ declare function repeatPaths(paths: readonly BezierPath[], r: VectorEffectParams
 /** The middle of the paths' bounds (the origin when they are empty). */
 declare function pathsCenter(paths: readonly BezierPath[]): Vec2;
 
-export { type AddVectorNodeOptions, AffineMatrix, DEFAULT_VECTOR_BLEND_DISTANCE, DEFAULT_VECTOR_BLEND_STEPS, DEFAULT_VECTOR_PATH_EDIT, DEFAULT_VECTOR_SNAP, IDENTITY_MATRIX, KAPPA, LazyMouse, type NearestSegment, type RecognizeInkOptions, SvgGradientDef, VECTOR_ARROWHEADS, VECTOR_ARROWHEAD_LABELS, VECTOR_BLEND_MAX_SMOOTH_STEPS, VECTOR_BLEND_MAX_STEPS, VECTOR_BLEND_SPACINGS, VECTOR_BLEND_SPACING_LABELS, VECTOR_BUILDER_HATCH_GAP, VECTOR_CLIPBOARD_TYPE, VECTOR_CONSTRUCTION_ANGLES, VECTOR_CORNER_KINDS, VECTOR_CORNER_KIND_LABELS, VECTOR_CORNER_WIDGET_INSET, VECTOR_EDIT_TOGGLES, VECTOR_EFFECT_DEFAULTS, VECTOR_EFFECT_LABELS, VECTOR_EFFECT_MENU, VECTOR_EFFECT_PARAM_SPECS, VECTOR_EFFECT_TYPES, VECTOR_FILL_GAP, VECTOR_INK_MAX_CORNERS, VECTOR_MERGE_MODES, VECTOR_OVERLAY_THEME, VECTOR_PATHFINDER_ACTIONS, VECTOR_PATHFINDER_LABELS, VECTOR_PATHFINDER_OPERATIONS, VECTOR_PATH_ACTIONS, VECTOR_PENCIL_STRING_PX, VECTOR_PRESSURE_NOMINAL, VECTOR_ROTATE_HANDLE_OFFSET, VECTOR_STROKE_ALIGN_LABELS, VECTOR_STYLE_KEYS, VECTOR_TOOLS, VECTOR_TOOL_GLYPHS, VECTOR_TOOL_SHORTCUTS, VECTOR_TRANSFORM_HANDLES, VECTOR_WIDTH_PRESETS, VECTOR_WIDTH_PRESET_IDS, VECTOR_WIDTH_PROFILE_MAX_POINTS, VECTOR_WIDTH_PROFILE_MAX_SCALE, VECTOR_WIDTH_SAME_T, type VariableStrokeOptions, type Vec2, type VectorActionResult, type VectorAlign, type VectorAnchor, type VectorAnchorRef, type VectorAnchorType, type VectorAppearanceShape, type VectorArrange, type VectorArrowAlign, type VectorArrowhead, type VectorArrowheadShape, type VectorAverageAxis, type VectorBlend, type VectorBlendControls, type VectorBlendInput, type VectorBlendOptions, type VectorBlendRail, type VectorBlendSpacing, type VectorBlendStart, type VectorBooleanOperand, type VectorBooleanOperation, type VectorBounds, type VectorBuilderHit, type VectorBuilderLinePiece, type VectorBuilderPreview, type VectorBuilderReplacement, type VectorBuilderTouched, type VectorCommandOptions, type VectorCorner, type VectorCornerInfo, type VectorCornerKind, type VectorCornerWidget, type VectorDefaults, type VectorDistribute, type VectorDocument, VectorEditorController, type VectorEditorOptions, type VectorEditorState, type VectorEffect, type VectorEffectParamSpec, type VectorEffectParamsMap, type VectorEffectType, type VectorEffectsPanelData, type VectorEffectsPanelItem, type VectorFillRule, type VectorGroupNode, type VectorGuideKind, type VectorGuideLabel, type VectorGuideLine, type VectorHandleRef, type VectorHitTestOptions, type VectorHover, type VectorInkShape, type VectorInteraction, type VectorKeyInput, type VectorLineCap, type VectorLineJoin, type VectorMatrix, type VectorMergeMode, type VectorModifiers, type VectorMorph, type VectorMorphContour, type VectorMorphCorrespondence, type VectorMorphOptions, type VectorNode, type VectorNodeListing, type VectorOverlayRenderData, type VectorPaint, type VectorPathAction, type VectorPathEditOptions, type VectorPathEntry, type VectorPathKeyframe, type VectorPathNode, type VectorPathfinderAction, type VectorPathfinderOperation, type VectorPathfinderPaint, type VectorPointSnap, type VectorPointerInput, type VectorRectSnap, type VectorRenderAnchor, type VectorRenderCornerWidget, type VectorRenderGroup, type VectorRenderGuideLabel, type VectorRenderGuideLine, type VectorRenderHandle, type VectorRenderNode, type VectorRenderPath, type VectorRenderStrokeParts, type VectorRenderWidthPoint, type VectorRepeaterCopy, type VectorScaleSnap, type VectorSceneRenderData, type VectorSegmentRef, type VectorSelectionBoxGeometry, type VectorSelectionFrame, type VectorSelectionStyle, type VectorShapeBuilderFace, type VectorShapeBuilderMap, type VectorShapeBuilderPlan, type VectorShapeBuilderResult, type VectorShapeInput, type VectorSnapGuides, type VectorSnapKind, type VectorSnapLeave, type VectorSnapOptions, VectorSnapTargets, type VectorStrokeAlign, type VectorStrokeParts, type VectorStrokeSpot, type VectorStyle, type VectorSubpath, type VectorSvgExportOptions, type VectorSvgImportOptions, type VectorTaperOptions, type VectorTool, type VectorTransformHandle, type VectorViewport, type VectorWaveOptions, type VectorWidthHandle, type VectorWidthPoint, type VectorWidthPointEdit, type VectorWidthPointRef, type VectorWidthPreset, type VectorWidthPresetInfo, activeVectorEffects, addBuilderHit, applyMatrix, applyMatrixLinear, applyVectorBlendOptions, applyVectorCornersAttribute, applyVectorEffects, arrowheadInset, arrowheadPath, arrowheadWeight, bendSegment, bezierToSubpaths, boundsFromPoints, boundsIntersect, clearVectorLiveBooleanCache, cloneAnchor, cloneSubpath, cloneVectorDocument, cloneVectorNode, collectPathNodes, constrainToLeave, convertAnchor, cornerBisectorPoint, cornerRadiusChange, cornerSetback, correspondMorphContours, createVectorCommands, createVectorEffect, createVectorMorph, curvatureMoveAnchor, cutSubpathAt, dashIntervals, decomposeRigid, effectPathLength, effectPathVertexCount, effectiveStrokeAlign, ellipseSubpath, eraseFromFill, eraseFromOutline, eraserRegion, evaluateVectorPathKeyframes, expandVectorAppearance, expandVectorAppearances, expandVectorBlend, expandVectorCorners, expandVectorCornersOf, findVectorNode, fitCornerRadius, foldVectorBooleanOperands, generateVectorBlendChildren, generateWidthProfile, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorBlendControls, getVectorCornerWidgets, getVectorEffectsPanel, getVectorEnteredGroups, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVectorWidthHandles, getVisibleAnchors, getVisibleHandles, hasOwnVectorAppearance, hasPaint, hasStrokeExtras, hasVectorAppearance, hasVectorCorners, hitTestVectorNode, hitTestVectorNodes, hitTestVectorStroke, inferAnchorType, insertAnchor, insertWidthPoint, interpolateMorphContours, interpolateRigidMatrix, interpolateVectorColor, interpolateVectorPaint, interpolateVectorPaths, interpolateVectorStyle, interpolateWidthProfiles, invertMatrix, isClosedBezierShape, isIdentityMatrix, isUniformWidthProfile, isVectorBlendGroup, isVectorLiveBoolean, isVectorTextTarget, joinSubpaths, knifePath, lineSubpath, locateVectorNode, matrixRotation, mergePaths, mirrorWidthProfile, morphContourToSubpath, morphPathsCross, moveAnchorHandle, multiplyMatrices, nearestSegment, nearestStrokePosition, nextVectorCornerKind, nodeMatrix, normalizeVectorEffectParams, offsetPaths, parseSvgTransform, parseVectorSvg, pathsCenter, planShapeBuilder, polygonSubpath, polylineBounds, pressureWidthProfile, puckerBloatPaths, recognizeInkShape, rectSubpath, refineMorphContour, refreshVectorBlends, releaseVectorBlend, removeAnchorKeepingShape, removeAnchors, removeAnchorsKeepingShape, removeRedundantPoints, removeWidthPoints, repeatPaths, resampleGradientStops, resolveVectorBlendOptions, reverseMorphContour, reverseSubpath, reverseWidthProfile, rotateMatrix, roundCornerPaths, roundSubpaths, samplePolyline, sanitizeVectorEffects, sanitizeWidthProfile, scaleFor, scaleMatrix, setAnchorCorner, setSubpathCorners, setWidthPoint, simplifyPolyline, smoothSubpath, splitIntoFaces, splitSubpathAt, starSubpath, strokePositionPoint, strokeWidthProfileOf, subpathEnclosesArea, subpathPointAt, subpathSegment, subpathSegmentCount, subpathToMorphContour, subpathsToBezier, taperWaveFactor, toVectorKeyInput, toVectorModifiers, toVectorPointerInput, transformVectorEffects, transformVectorNode, translateAnchor, translateMatrix, trimIntervals, trimPaths, trimPathsIndividually, turnMorphContour, twistPaths, unionBounds, variableStrokeOutline, variableStrokeRings, vectorAppearanceNodes, vectorAppearanceOutline, vectorAppearanceShapes, vectorBlendColorDistance, vectorBlendKeyTargets, vectorBlendKeys, vectorBlendRail, vectorBlendRailAt, vectorBlendSpine, vectorBlendStepCount, vectorBuilderErasedEdges, vectorCornerAt, vectorCorners, vectorCornersAttribute, vectorDiamondPath, vectorDocumentToSvg, vectorEnteredGroups, vectorFillMap, vectorInkShapeName, vectorLiveBooleanSteps, vectorNodeBounds, vectorNodeRotation, vectorNodeToBezier, vectorOperandOperation, vectorPaintToHex, vectorPaintToSvg, vectorParentMatrix, vectorPathData, vectorPathEntries, vectorPathWorldBezier, vectorPathfinderShape, vectorRepeaterCopies, vectorResizeCursor, vectorResultStyle, vectorShapeBuilderHit, vectorShapeBuilderMap, vectorStrokeLineArea, vectorStrokeOutline, vectorStrokeOutlinePath, vectorStrokeParts, vectorStrokeReach, vectorStrokeSvgParts, vectorStrokeWidthGeometry, vectorToolLabel, vectorWorldMatrix, walkVectorNodes, widthProfileAt, widthProfileFromAttribute, widthProfileMaxScale, widthProfilePreset, widthProfilePresetId, widthProfileToAttribute, wigglePaths, zigzagPaths };
+/**
+ * The paint server of a gradient along or across the stroke of `node` (in its own space): a
+ * pattern whose first def id is `id`. `area` defaults to the path's box padded by the stroke's
+ * reach.
+ */
+declare function vectorStrokeGradientDefs(g: VectorGradient, id: string, node: VectorPathNode, options?: {
+    bounds?: VectorBounds | null;
+    area?: VectorBounds | null;
+    precision?: number;
+}): VectorPaintDef[];
+
+/**
+ * Perspective (projective) maps between quadrilaterals: what Free Distort needs. Pure maths;
+ * degenerate or non-finite quads give `null` instead of NaNs.
+ *
+ * Ported from ArtCraft (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
+ * THIRD_PARTY_NOTICES.md): pdfcraft `crates/geom/src/perspective.rs` (`Homography::from_points`,
+ * `Homography::apply`, `solve8`, `order_quad`).
+ */
+
+/** A 3×3 projective map, row-major, normalised so that the last entry is 1. */
+type VectorHomography = readonly [number, number, number, number, number, number, number, number, number];
+/**
+ * Gaussian elimination with partial pivoting on an 8×8 system (the 9th column of each row is the
+ * right-hand side). Null when the system is singular.
+ */
+declare function solve8(rows: readonly (readonly number[])[]): number[] | null;
+/** The image of `p`, or null where the map sends it to infinity. */
+declare function applyVectorHomography(h: VectorHomography, p: Vec2): Vec2 | null;
+/**
+ * The projective map that takes each of `from` to the point at the same index of `to`. Null when
+ * three of either set are collinear or a coordinate is not finite.
+ */
+declare function vectorHomography(from: readonly Vec2[], to: readonly Vec2[]): VectorHomography | null;
+/**
+ * Whether `h` maps the whole convex quad `quad` without sending any of it through infinity (the
+ * denominator keeps one sign over it): what a usable distortion needs.
+ */
+declare function vectorHomographyKeepsQuad(h: VectorHomography, quad: readonly Vec2[]): boolean;
+/**
+ * The four corners in reading order for a y-down space: top-left, top-right, bottom-right,
+ * bottom-left, whatever order they come in. Null unless they form a convex quadrilateral with a
+ * non-negligible area.
+ */
+declare function orderVectorQuad(points: readonly Vec2[]): Vec2[] | null;
+
+/**
+ * Warp geometry for envelope distortion: preset warp styles and editable Bézier meshes, both
+ * forward maps from a source box (the bounds of the paths an envelope bends) to the node's space.
+ *
+ * - **Presets** (`VectorWarpStyle`, Photoshop's fifteen with bend and horizontal / vertical
+ *   distortion in percent): each is one bicubic Bézier patch whose 4 × 4 control grid follows the
+ *   bend (`vectorWarpPresetGrid`). Every preset is the identity at bend 0 and continuous in it.
+ * - **Meshes** (`VectorWarpMesh`): a grid of bicubic patches. Splitting a mesh (`splitVectorMeshU`
+ *   / `V`) is an exact de Casteljau subdivision, so it never changes the shape, and a preset turns
+ *   into an editable mesh of any size exactly.
+ *
+ * Ported from ArtCraft (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
+ * THIRD_PARTY_NOTICES.md): photocraft `crates/geom/src/warp.rs` (`WarpStyle`, `StyleWarp`,
+ * `rest_grid`, `edge_arc`, `arc_grid`, `blend_rows`, `preset_grid`, `bernstein`, `split_cubic`,
+ * `BERN_INV`, and `BezierMesh`: `identity`, `fit`, `eval`, `split_u`, `split_v`, `remove_split_u`,
+ * `transpose`, `map_points`, `param_at`, `pull`, `smooth_lines`, `drag_point`, `control_bounds`;
+ * `Warp::map` and `Warp::to_mesh`). The Coons patch of `vectorMeshFromOutline` is our own.
+ */
+
+/** The fifteen presets in Photoshop's menu order. */
+declare const VECTOR_WARP_STYLES: readonly VectorWarpStyle[];
+declare const VECTOR_WARP_STYLE_LABELS: Readonly<Record<VectorWarpStyle, string>>;
+/**
+ * A preset as a Bézier control grid (rows of `[x, y]` in box units, y down). `b`, `hd`, `vd` are
+ * the bend and the horizontal / vertical distortion as fractions (−1…1); `aspect` is the box's
+ * height over its width. The arc family stays circular in pixels, the other offsets scale with the
+ * box, and a vertical warp is the horizontal one with the axes (and distortions) swapped.
+ */
+declare function vectorWarpPresetGrid(style: VectorWarpStyle, b: number, hd: number, vd: number, vertical: boolean, aspect: number): [number, number][][];
+/** A preset warp's settings (bend and distortions in percent, −100…100). */
+interface VectorWarpPreset {
+    style: VectorWarpStyle;
+    bend: number;
+    horizontal?: number;
+    vertical?: number;
+    /** Bend along the vertical axis. */
+    orientation?: 'horizontal' | 'vertical';
+}
+/**
+ * A preset as one Bézier patch over `bounds` (points in the bounds' space), or null when it
+ * changes nothing (an unknown style, all-zero amounts, or an empty box).
+ */
+declare function vectorWarpPresetMesh(preset: VectorWarpPreset, bounds: VectorBounds): VectorWarpMesh | null;
+/** Control points per row. */
+declare const vectorMeshColumns: (m: VectorWarpMesh) => number;
+/** Control point rows. */
+declare const vectorMeshRows: (m: VectorWarpMesh) => number;
+/** Whether a mesh is well formed: knots from 0 to 1 increasing, the right number of finite points. */
+declare function isValidVectorMesh(m: unknown): m is VectorWarpMesh;
+/** Fits a mesh with patch boundaries `us` / `vs` to the map `f` (box fractions → output) by interpolating it at each patch's thirds. Exact for bicubic maps (affine maps included). */
+declare function fitVectorMesh(f: (s: number, t: number) => Vec2, us: readonly number[], vs: readonly number[]): VectorWarpMesh;
+/** The identity mesh over `bounds` with `columns × rows` patches. */
+declare function vectorIdentityMesh(bounds: VectorBounds, columns?: number, rows?: number): VectorWarpMesh;
+/** The surface at box fractions `(s, t)`. */
+declare function evalVectorMesh(m: VectorWarpMesh, s: number, t: number): Vec2;
+/** The mesh with the patch column holding `s` split at `s` (exact). Null when `s` is on or too close to a boundary. */
+declare function splitVectorMeshU(m: VectorWarpMesh, s: number): VectorWarpMesh | null;
+/** The mesh with the patch row holding `t` split at `t` (exact). */
+declare function splitVectorMeshV(m: VectorWarpMesh, t: number): VectorWarpMesh | null;
+/**
+ * The mesh without interior vertical boundary `k` (1 … us.length − 2), its two patch columns
+ * merged: exact when they came from an unedited split; otherwise the outer control points stay and
+ * the inner handles are extrapolated.
+ */
+declare function removeVectorMeshSplitU(m: VectorWarpMesh, k: number): VectorWarpMesh | null;
+/** Removes interior horizontal boundary `k`. */
+declare function removeVectorMeshSplitV(m: VectorWarpMesh, k: number): VectorWarpMesh | null;
+/** Every control point through `f` (exact for affine maps). */
+declare function mapVectorMeshPoints(m: VectorWarpMesh, f: (p: Vec2) => Vec2): VectorWarpMesh;
+/**
+ * The mesh with `columns × rows` patches over the same surface: split exactly when its knots are
+ * a subset of the new even ones (a one-patch mesh always is), otherwise refitted.
+ */
+declare function resizeVectorMesh(m: VectorWarpMesh, columns: number, rows: number): VectorWarpMesh;
+/** Bounding box of the control points (the surface lies inside it). */
+declare function vectorMeshControlBounds(m: VectorWarpMesh): VectorBounds;
+/** Box fractions `(s, t)` whose surface point is nearest `p` (a coarse search, then Newton steps). */
+declare function vectorMeshParamAt(m: VectorWarpMesh, p: Vec2): {
+    s: number;
+    t: number;
+    distance: number;
+};
+/**
+ * `base` with control point `index` dragged by `d`, keeping the surface smooth across the grid
+ * lines: an anchor moves with the eight points around it as one block; a handle moves with the two
+ * points beside it across its line, and the handle opposite it on the same anchor turns the other
+ * way (with its two neighbours), so the line keeps passing straight through the anchor. An inner
+ * point of a patch moves alone.
+ */
+declare function dragVectorMeshPoint(base: VectorWarpMesh, index: number, d: Vec2): VectorWarpMesh;
+/**
+ * `base` with its surface point at box fractions `(s, t)` pulled by `d`, the way dragging inside a
+ * patch works: interior anchors within about two cells follow by a share of `d` that fades with
+ * distance (each with its block of handles, so grid lines stay smooth); the outer border stays
+ * pinned unless the grab is near it, and then it bows; the four corners never move. The grabbed
+ * patch's inner points (and, near the border, the border's handles) make up the rest, so the
+ * grabbed point lands exactly at its start + `d`.
+ */
+declare function pullVectorMesh(base: VectorWarpMesh, s: number, t: number, d: Vec2): VectorWarpMesh;
+/**
+ * A mesh whose border follows a closed outline (Illustrator's Make with Top Object): the outline is
+ * cut into four sides at the points nearest its bounding box's corners, and the interior is the
+ * Coons patch of those sides, fitted with `columns × rows` patches. Null for an open or degenerate
+ * outline.
+ */
+declare function vectorMeshFromOutline(sp: VectorSubpath, columns?: number, rows?: number): VectorWarpMesh | null;
+/** The mesh's border as one closed subpath (clockwise from the top-left corner): what Release gives back as the envelope's shape. */
+declare function vectorMeshOutline(m: VectorWarpMesh): VectorSubpath;
+/**
+ * The control points an editor shows: the anchors (where grid lines cross) and the handles along
+ * the grid lines, each with the anchor it belongs to. Points inside a patch are left out (drag
+ * inside a patch to pull the surface instead).
+ */
+declare function vectorMeshEditPoints(m: VectorWarpMesh): {
+    anchors: number[];
+    handles: {
+        index: number;
+        anchor: number;
+    }[];
+};
+/** The mesh's grid lines (patch borders) as cubics `[p0, p1, p2, p3]`. */
+declare function vectorMeshGridCurves(m: VectorWarpMesh): Vec2[][];
+
+export { type AddVectorNodeOptions, AffineMatrix, DEFAULT_VECTOR_BLEND_DISTANCE, DEFAULT_VECTOR_BLEND_STEPS, DEFAULT_VECTOR_PATH_EDIT, DEFAULT_VECTOR_SNAP, IDENTITY_MATRIX, KAPPA, LazyMouse, type MapVectorSubpathsOptions, type NearestSegment, type RecognizeInkOptions, SvgGradientDef, VECTOR_ARROWHEADS, VECTOR_ARROWHEAD_LABELS, VECTOR_BLEND_MAX_SMOOTH_STEPS, VECTOR_BLEND_MAX_STEPS, VECTOR_BLEND_SPACINGS, VECTOR_BLEND_SPACING_LABELS, VECTOR_BUILDER_HATCH_GAP, VECTOR_CLIPBOARD_TYPE, VECTOR_CONSTRUCTION_ANGLES, VECTOR_CORNER_KINDS, VECTOR_CORNER_KIND_LABELS, VECTOR_CORNER_WIDGET_INSET, VECTOR_DISTORT_TOLERANCE, VECTOR_EDIT_TOGGLES, VECTOR_EFFECT_DEFAULTS, VECTOR_EFFECT_LABELS, VECTOR_EFFECT_MENU, VECTOR_EFFECT_PARAM_SPECS, VECTOR_EFFECT_TYPES, VECTOR_ENVELOPE_STYLE_OPTIONS, VECTOR_FILL_GAP, VECTOR_GRADIENT_INTERPOLATIONS, VECTOR_GRADIENT_INTERPOLATION_LABELS, VECTOR_GRADIENT_MAX_PERIODS, VECTOR_GRADIENT_MIDPOINT_GAP, VECTOR_GRADIENT_MIN_STOPS, VECTOR_GRADIENT_OFF_BAR, VECTOR_GRADIENT_SPREADS, VECTOR_GRADIENT_SPREAD_LABELS, VECTOR_GRADIENT_STOP_GAP, VECTOR_GRADIENT_TYPES, VECTOR_GRADIENT_TYPE_LABELS, VECTOR_INK_MAX_CORNERS, VECTOR_MERGE_MODES, VECTOR_OVERLAY_THEME, VECTOR_PATHFINDER_ACTIONS, VECTOR_PATHFINDER_LABELS, VECTOR_PATHFINDER_OPERATIONS, VECTOR_PATH_ACTIONS, VECTOR_PENCIL_STRING_PX, VECTOR_PRESSURE_NOMINAL, VECTOR_ROTATE_HANDLE_OFFSET, VECTOR_STROKE_ALIGN_LABELS, VECTOR_STROKE_GRADIENT_MODES, VECTOR_STROKE_GRADIENT_MODE_LABELS, VECTOR_STYLE_KEYS, VECTOR_TOOLS, VECTOR_TOOL_GLYPHS, VECTOR_TOOL_SHORTCUTS, VECTOR_TRANSFORM_HANDLES, VECTOR_WARP_STYLES, VECTOR_WARP_STYLE_LABELS, VECTOR_WIDTH_PRESETS, VECTOR_WIDTH_PRESET_IDS, VECTOR_WIDTH_PROFILE_MAX_POINTS, VECTOR_WIDTH_PROFILE_MAX_SCALE, VECTOR_WIDTH_SAME_T, type VariableStrokeOptions, type Vec2, type VectorActionResult, type VectorAlign, type VectorAnchor, type VectorAnchorRef, type VectorAnchorType, type VectorAppearanceShape, type VectorArrange, type VectorArrowAlign, type VectorArrowhead, type VectorArrowheadShape, type VectorAverageAxis, type VectorBlend, type VectorBlendControls, type VectorBlendInput, type VectorBlendOptions, type VectorBlendRail, type VectorBlendSpacing, type VectorBlendStart, type VectorBooleanOperand, type VectorBooleanOperation, type VectorBounds, type VectorBuilderHit, type VectorBuilderLinePiece, type VectorBuilderPreview, type VectorBuilderReplacement, type VectorBuilderTouched, type VectorCommandOptions, type VectorCorner, type VectorCornerInfo, type VectorCornerKind, type VectorCornerWidget, type VectorDefaults, type VectorDistortMode, type VectorDistribute, type VectorDocument, VectorEditorController, type VectorEditorOptions, type VectorEditorState, type VectorEffect, type VectorEffectParamSpec, type VectorEffectParamsMap, type VectorEffectType, type VectorEffectsPanelData, type VectorEffectsPanelItem, type VectorEnvelopePanelData, type VectorEnvelopeParams, type VectorFillRule, type VectorGradient, type VectorGradientAnnotator, type VectorGradientEditorData, type VectorGradientHandle, type VectorGradientInterpolation, type VectorGradientPart, type VectorGradientPatch, type VectorGradientPoints, type VectorGradientRamp, type VectorGradientSpread, type VectorGradientStop, type VectorGradientSvgOptions, type VectorGradientTarget, type VectorGradientType, type VectorGradientUnits, type VectorGroupNode, type VectorGuideKind, type VectorGuideLabel, type VectorGuideLine, type VectorHandleRef, type VectorHitTestOptions, type VectorHomography, type VectorHover, type VectorInkShape, type VectorInteraction, type VectorKeyInput, type VectorLineCap, type VectorLineJoin, type VectorMatrix, type VectorMergeMode, type VectorModifiers, type VectorMorph, type VectorMorphContour, type VectorMorphCorrespondence, type VectorMorphOptions, type VectorNode, type VectorNodeListing, type VectorOverlayRenderData, type VectorPaint, type VectorPaintDef, type VectorPaintSvgOptions, type VectorPathAction, type VectorPathEditOptions, type VectorPathEntry, type VectorPathKeyframe, type VectorPathNode, type VectorPathfinderAction, type VectorPathfinderOperation, type VectorPathfinderPaint, type VectorPointMap, type VectorPointSnap, type VectorPointerInput, type VectorRectSnap, type VectorRenderAnchor, type VectorRenderCornerWidget, type VectorRenderGradientAnnotator, type VectorRenderGroup, type VectorRenderGuideLabel, type VectorRenderGuideLine, type VectorRenderHandle, type VectorRenderNode, type VectorRenderPath, type VectorRenderStrokeParts, type VectorRenderWidthPoint, type VectorRepeaterCopy, type VectorRgba, type VectorScaleSnap, type VectorSceneRenderData, type VectorSegmentRef, type VectorSelectionBoxGeometry, type VectorSelectionFrame, type VectorSelectionStyle, type VectorShapeBuilderFace, type VectorShapeBuilderMap, type VectorShapeBuilderPlan, type VectorShapeBuilderResult, type VectorShapeInput, type VectorSnapGuides, type VectorSnapKind, type VectorSnapLeave, type VectorSnapOptions, VectorSnapTargets, type VectorStrokeAlign, type VectorStrokeGradientMode, type VectorStrokeParts, type VectorStrokeSpot, type VectorStyle, type VectorSubpath, type VectorSvgExportOptions, type VectorSvgImportOptions, type VectorSvgPatternDef, type VectorTaperOptions, type VectorTool, type VectorTransformHandle, type VectorViewport, type VectorWarpMesh, type VectorWarpPreset, type VectorWarpStyle, type VectorWaveOptions, type VectorWidthHandle, type VectorWidthPoint, type VectorWidthPointEdit, type VectorWidthPointRef, type VectorWidthPreset, type VectorWidthPresetInfo, activeVectorEffects, addBuilderHit, applyMatrix, applyMatrixLinear, applyVectorBlendOptions, applyVectorCornersAttribute, applyVectorEffects, applyVectorGradientPatch, applyVectorGradientSpread, applyVectorHomography, arrowheadInset, arrowheadPath, arrowheadWeight, bendSegment, bezierToSubpaths, boundsFromPoints, boundsIntersect, clearVectorLiveBooleanCache, cloneAnchor, cloneSubpath, cloneVectorDocument, cloneVectorNode, collectPathNodes, constrainToLeave, convertAnchor, convertVectorGradient, cornerBisectorPoint, cornerRadiusChange, cornerSetback, correspondMorphContours, createVectorCommands, createVectorEffect, createVectorMorph, curvatureMoveAnchor, cutSubpathAt, dashIntervals, decomposeRigid, defaultVectorGradient, distortVectorNode, dragVectorMeshPoint, effectPathLength, effectPathVertexCount, effectiveStrokeAlign, ellipseSubpath, eraseFromFill, eraseFromOutline, eraserRegion, evalVectorMesh, evaluateVectorPathKeyframes, expandVectorAppearance, expandVectorAppearances, expandVectorBlend, expandVectorCorners, expandVectorCornersOf, expandVectorGradientSpread, expandVectorGradientStops, explicitVectorGradient, findVectorNode, fitCornerRadius, fitVectorMesh, foldVectorBooleanOperands, generateVectorBlendChildren, generateWidthProfile, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorBlendControls, getVectorCornerWidgets, getVectorEffectsPanel, getVectorEnteredGroups, getVectorEnvelopePanel, getVectorEnvelopeTarget, getVectorGradientAnnotator, getVectorGradientEditor, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVectorWidthHandles, getVisibleAnchors, getVisibleHandles, gradientMidpointRemap, hasExplicitGradientGeometry, hasOwnVectorAppearance, hasPaint, hasStrokeExtras, hasVectorAppearance, hasVectorCorners, hitTestVectorNode, hitTestVectorNodes, hitTestVectorStroke, hitVectorGradientAnnotator, inferAnchorType, insertAnchor, insertVectorGradientStop, insertWidthPoint, interpolateMorphContours, interpolateRigidMatrix, interpolateVectorColor, interpolateVectorPaint, interpolateVectorPaths, interpolateVectorStyle, interpolateWidthProfiles, invertMatrix, isCentredVectorGradient, isClosedBezierShape, isIdentityMatrix, isUniformWidthProfile, isValidVectorMesh, isVectorBlendGroup, isVectorGradient, isVectorLiveBoolean, isVectorTextTarget, joinSubpaths, knifePath, lineSubpath, locateVectorNode, mapBezierPath, mapVectorGradient, mapVectorMeshPoints, mapVectorPaint, mapVectorPoints, mapVectorSubpaths, matrixRotation, mergePaths, mirrorWidthProfile, morphContourToSubpath, morphPathsCross, moveAnchorHandle, moveVectorGradientHandle, moveVectorGradientStop, multiplyMatrices, nearestSegment, nearestStrokePosition, nextVectorCornerKind, nodeMatrix, normalizeVectorEffectParams, offsetPaths, orderVectorQuad, parseSvgTransform, parseVectorColor, parseVectorSvg, pathsCenter, patternAttrs, periodicVectorGradientStops, pinVectorGradient, planShapeBuilder, polygonSubpath, polylineBounds, pressureWidthProfile, puckerBloatPaths, pullVectorMesh, recognizeInkShape, rectSubpath, refineMorphContour, refreshVectorBlends, releaseVectorBlend, removeAnchorKeepingShape, removeAnchors, removeAnchorsKeepingShape, removeRedundantPoints, removeVectorGradientStop, removeVectorMeshSplitU, removeVectorMeshSplitV, removeWidthPoints, repeatPaths, resampleGradientStops, resizeVectorMesh, resolveVectorBlendOptions, reverseMorphContour, reverseSubpath, reverseVectorGradient, reverseWidthProfile, rotateMatrix, roundCornerPaths, roundSubpaths, samplePlainStops, samplePolyline, sampleVectorGradient, sampleVectorGradientAt, sampleVectorPaintDefAt, sanitizeVectorEffects, sanitizeVectorGradient, sanitizeWidthProfile, scaleFor, scaleMatrix, setAnchorCorner, setSubpathCorners, setVectorGradientVector, setWidthPoint, simplifyPolyline, smoothSubpath, solve8, sortedVectorGradientStops, spanVectorGradientStops, splitIntoFaces, splitSubpathAt, splitVectorMeshU, splitVectorMeshV, starSubpath, strokePositionPoint, strokeWidthProfileOf, subpathEnclosesArea, subpathPointAt, subpathSegment, subpathSegmentCount, subpathToMorphContour, subpathsToBezier, taperWaveFactor, toVectorKeyInput, toVectorModifiers, toVectorPointerInput, transformVectorEffects, transformVectorGradient, transformVectorNode, transformVectorPaint, translateAnchor, translateMatrix, trimIntervals, trimPaths, trimPathsIndividually, turnMorphContour, twistPaths, unionBounds, variableStrokeOutline, variableStrokeRings, vectorAppearanceNodes, vectorAppearanceOutline, vectorAppearanceShapes, vectorBlendColorDistance, vectorBlendKeyTargets, vectorBlendKeys, vectorBlendRail, vectorBlendRailAt, vectorBlendSpine, vectorBlendStepCount, vectorBoxCorners, vectorBoxMatrix, vectorBuilderErasedEdges, vectorCornerAt, vectorCorners, vectorCornersAttribute, vectorDiamondPath, vectorDistortQuad, vectorDocumentToSvg, vectorEffectInputBounds, vectorEffectInputPaths, vectorEnteredGroups, vectorEnvelopeFrame, vectorEnvelopeMap, vectorEnvelopeMesh, vectorFillMap, vectorGradientArea, vectorGradientAspect, vectorGradientBarPosition, vectorGradientFocalParam, vectorGradientHandles, vectorGradientMatrix, vectorGradientMidpointFromPosition, vectorGradientMidpointPosition, vectorGradientNeedsExpansion, vectorGradientParam, vectorGradientPoints, vectorGradientRamp, vectorGradientSvgDefs, vectorGradientTAt, vectorGradientTargetPath, vectorGradientUnitsMatrix, vectorHomography, vectorHomographyKeepsQuad, vectorIdentityMesh, vectorInkShapeName, vectorLiveBooleanSteps, vectorMeshColumns, vectorMeshControlBounds, vectorMeshEditPoints, vectorMeshFromOutline, vectorMeshGridCurves, vectorMeshOutline, vectorMeshParamAt, vectorMeshRows, vectorNodeBounds, vectorNodeEnvelope, vectorNodeRotation, vectorNodeToBezier, vectorOperandOperation, vectorPaintToHex, vectorPaintToSvg, vectorParentMatrix, vectorPathData, vectorPathEntries, vectorPathLocalBounds, vectorPathWorldBezier, vectorPathfinderShape, vectorRepeaterCopies, vectorResizeCursor, vectorResultStyle, vectorShapeBuilderHit, vectorShapeBuilderMap, vectorShearForSide, vectorSkewMatrix, vectorStrokeGradientDefs, vectorStrokeLineArea, vectorStrokeOutline, vectorStrokeOutlinePath, vectorStrokeParts, vectorStrokeReach, vectorStrokeSvgParts, vectorStrokeWidthGeometry, vectorToolLabel, vectorWarpPresetGrid, vectorWarpPresetMesh, vectorWorldMatrix, walkVectorNodes, widthProfileAt, widthProfileFromAttribute, widthProfileMaxScale, widthProfilePreset, widthProfilePresetId, widthProfileToAttribute, wigglePaths, zigzagPaths };