@pixerate/editor 0.41.0 → 0.43.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';
@@ -138,6 +223,17 @@ interface VectorNodeBase {
      * the blend options change, and are locked (clicks select the blend group).
      */
     blendStep?: boolean;
+    /**
+     * Live path effects, applied top to bottom: each acts on every path above it (the node's own
+     * outline, or a group's children, then the result of the effects before it), and effects after a
+     * repeater act on its copies. The stored anchors and children never change.
+     */
+    effects?: VectorEffect[] | null;
+    /**
+     * As an operand of a live boolean group: how it combines with the result of the operands below
+     * it. Absent: the group's `liveBoolean` operation.
+     */
+    booleanOperation?: VectorBooleanOperation | null;
 }
 /** A shape made of one or more subpaths (holes and compound shapes included). */
 interface VectorPathNode extends VectorNodeBase, VectorStyle {
@@ -183,6 +279,12 @@ interface VectorGroupNode extends VectorNodeBase {
      * stacking order, and the steps between them are regenerated whenever a key changes.
      */
     blend?: VectorBlend | null;
+    /**
+     * Makes the group a live boolean: its children stay editable operands, folded bottom to top
+     * (each by its own `booleanOperation` or this one), and the group draws as the result in the
+     * bottom operand's style.
+     */
+    liveBoolean?: VectorBooleanOperation | null;
 }
 type VectorNode = VectorPathNode | VectorGroupNode;
 /** A vector drawing: an artboard and its nodes, bottom to top. */
@@ -219,7 +321,7 @@ interface VectorHandleRef extends VectorAnchorRef {
  * blends the shape clicked first into the one clicked next (clicking an anchor of a closed path
  * starts the blend there).
  */
-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';
 declare const VECTOR_TOOLS: readonly VectorTool[];
 /** Keyboard modifiers held during a pointer event. */
 interface VectorModifiers {
@@ -265,6 +367,109 @@ declare const VECTOR_PATHFINDER_OPERATIONS: readonly VectorPathfinderOperation[]
 type VectorArrange = 'front' | 'forward' | 'backward' | 'back';
 /** Average: line anchors up on a horizontal line (same y), a vertical one (same x), or both. */
 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`.
+ */
+type VectorEffectType = 'trim' | 'roundCorners' | 'puckerBloat' | 'twist' | 'zigzag' | 'wiggle' | 'offset' | 'merge' | 'repeater';
+declare const VECTOR_EFFECT_TYPES: readonly VectorEffectType[];
+/** 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[];
+/** Parameters of each effect type. Lengths are in the node's own units, angles in degrees, percentages 0–100. */
+interface VectorEffectParamsMap {
+    trim: {
+        /** Start and end of the kept part, percent of the length (swapped when start > end). */
+        start: number;
+        end: number;
+        /** Shifts both, in degrees (360° = once round). */
+        offset: number;
+        /**
+         * `simultaneous`: every path trimmed by the same fractions of its own length;
+         * `individual`: the paths laid end to end in stacking order and trimmed as one length.
+         */
+        mode: 'simultaneous' | 'individual';
+    };
+    roundCorners: {
+        radius: number;
+    };
+    /** Percent, −100 (pucker: spiky) to 100 (bloat: bulging). */
+    puckerBloat: {
+        amount: number;
+    };
+    twist: {
+        /** Turn at the farthest point from the centre (none at the centre). */
+        angle: number;
+        /** The centre as an offset from the middle of the paths' bounds. */
+        center: Vec2;
+    };
+    zigzag: {
+        /** How far the points move to either side. */
+        size: number;
+        /** Ridges per segment. */
+        ridges: number;
+        /** Rounded waves instead of sharp zig zags. */
+        smooth: boolean;
+    };
+    wiggle: {
+        /** Largest displacement. */
+        size: number;
+        /** Points added per segment. */
+        detail: number;
+        smooth: boolean;
+        /** Wiggles per second. */
+        speed: number;
+        /** Percent: how much neighbouring points move together. */
+        correlation: number;
+        /** Degrees (360° = one wiggle). */
+        phase: number;
+        /** The same seed (and time) always gives the same wiggle. */
+        seed: number;
+        /** Seconds: where along the wiggle's motion it is drawn. */
+        time: number;
+    };
+    offset: {
+        /** Grows (positive) or shrinks (negative) the shapes. */
+        amount: number;
+        join: VectorLineJoin;
+        miterLimit: number;
+        /** Copies, copy i offset by `amount · (i + 1 + copyOffset)`. */
+        copies: number;
+        copyOffset: number;
+    };
+    merge: {
+        mode: VectorMergeMode;
+    };
+    repeater: {
+        /** Copies, the original included; a fraction fades the last copy. */
+        copies: number;
+        /** Shifts the copies along: copy i is transformed `i + offset` times. */
+        offset: number;
+        /** Each step: move, about `anchor` turn by `rotation` and scale by `scale` percent. */
+        position: Vec2;
+        /** Offset from the middle of the paths' bounds. */
+        anchor: Vec2;
+        rotation: number;
+        scale: Vec2;
+        /** Percent opacity of the first and last copies (in between interpolated). */
+        startOpacity: number;
+        endOpacity: number;
+        /** `below`: each copy draws under the one before it; `above`: over it. */
+        composite: 'below' | 'above';
+    };
+}
+/** One entry of an effect stack. */
+type VectorEffect = {
+    [K in VectorEffectType]: {
+        /** Unique within the node. */
+        id: string;
+        type: K;
+        /** Disabled effects are skipped. Default true. */
+        enabled?: boolean;
+        params: VectorEffectParamsMap[K];
+    };
+}[VectorEffectType];
 /** Identifies one segment of a path node: from anchor `segment` to the next. */
 interface VectorSegmentRef {
     nodeId: string;
@@ -272,11 +477,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). */
@@ -295,7 +495,7 @@ declare function subpathSegment(sp: VectorSubpath, i: number): Point[];
 declare function subpathsToBezier(subpaths: readonly VectorSubpath[], options?: {
     corners?: boolean;
 }): BezierPath;
-/** The node's outline as Bézier commands. Groups have none. */
+/** The node's outline as Bézier commands, as drawn (path effects applied). Groups have none. */
 declare function vectorNodeToBezier(node: VectorNode): BezierPath;
 /** SVG path data (`d`) of a path node or subpaths. */
 declare function vectorPathData(input: VectorPathNode | readonly VectorSubpath[], precision?: number): string;
@@ -321,8 +521,13 @@ declare function locateVectorNode(nodes: VectorNode[], id: string): {
 declare function collectPathNodes(node: VectorNode): VectorPathNode[];
 /** The node's local → parent matrix (identity when it has no `transform`). */
 declare function nodeMatrix(node: VectorNode): AffineMatrix;
-/** A path node's outline in the space `parent` maps to (default: its parent's space). */
-declare function vectorPathWorldBezier(node: VectorPathNode, parent?: AffineMatrix): BezierPath;
+/**
+ * A path node's outline in the space `parent` maps to (default: its parent's space), as drawn:
+ * live corners cut and path effects applied (`{ effects: false }`: the stored path only).
+ */
+declare function vectorPathWorldBezier(node: VectorPathNode, parent?: AffineMatrix, options?: {
+    effects?: boolean;
+}): BezierPath;
 /**
  * Geometric bounds of a node (stroke width not included) in the space `parent` maps to —
  * by default the node's parent space, which for top-level nodes is the document. Null when
@@ -335,19 +540,27 @@ declare function unionBounds(list: readonly (VectorBounds | null | undefined)[])
 declare function boundsIntersect(a: VectorBounds, b: VectorBounds): boolean;
 /** A box from two corners in any order. */
 declare function boundsFromPoints(a: Vec2, b: Vec2): VectorBounds;
+/** Options of `hitTestVectorNode`. */
+interface VectorHitTestOptions {
+    /**
+     * Live groups (live booleans or groups with effects) hit by their children as stored rather
+     * than by what they draw: the groups being edited.
+     */
+    entered?: ReadonlySet<string>;
+}
 /**
- * Whether `p` hits a node: inside its fill (when it has one), on its stroke as drawn (its
- * alignment and arrowheads respected) or within `tolerance` of either. A group is hit when
- * any visible child is.
+ * Whether `p` hits a node as drawn (path effects and live booleans applied): inside its fill
+ * (when it has one), on its stroke (its alignment and arrowheads respected) or within
+ * `tolerance` of either. A group is hit when any visible child is.
  */
-declare function hitTestVectorNode(node: VectorNode, p: Vec2, tolerance?: number, parent?: AffineMatrix): boolean;
+declare function hitTestVectorNode(node: VectorNode, p: Vec2, tolerance?: number, parent?: AffineMatrix, options?: VectorHitTestOptions): boolean;
 /**
  * The area a path node's stroke paints (alignment, caps, joins, dashes and arrowheads
  * included), as a filled path in the space `parent` maps to. Empty without a stroke.
  */
 declare function vectorStrokeOutline(node: VectorPathNode, parent?: AffineMatrix): BezierPath;
 /** The topmost node hit by `p` (skipping hidden and locked ones), or null. */
-declare function hitTestVectorNodes(nodes: readonly VectorNode[], p: Vec2, tolerance?: number): VectorNode | null;
+declare function hitTestVectorNodes(nodes: readonly VectorNode[], p: Vec2, tolerance?: number, options?: VectorHitTestOptions): VectorNode | null;
 interface NearestSegment {
     subpath: number;
     segment: number;
@@ -444,6 +657,257 @@ 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 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;
@@ -466,10 +930,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 {
@@ -700,6 +1177,85 @@ 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;
+
 /**
  * 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`
@@ -1037,6 +1593,8 @@ 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;
 }
 /** The drag in progress, for overlays and status text. */
 type VectorInteraction = {
@@ -1091,6 +1649,13 @@ 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;
 } | {
     type: 'pan';
 };
@@ -1136,6 +1701,11 @@ 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;
+    };
     canUndo: boolean;
     canRedo: boolean;
     undoLabel: string;
@@ -1391,6 +1961,7 @@ declare class VectorEditorController {
     private blendStart;
     /** Options new blends get (the toolbars edit them along with the selected blend's). */
     private blendDefaults;
+    private gradientEdit;
     /** What the highlight shows, to skip notifying when the pointer stays over the same face. */
     private builderHoverKey;
     private readonly createId;
@@ -1403,7 +1974,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;
@@ -1424,10 +2001,15 @@ declare class VectorEditorController {
     private cursorFor;
     private snapshot;
     private restore;
-    /** Records the change from `before` to the current state as one undo step. */
+    /**
+     * Records the change from `before` to the current state as one undo step. Consecutive
+     * changes with the same `merge` key (a slider drag) fold into one step.
+     */
     private commit;
-    /** Runs `fn` (which updates fields) and records it as one undo step. */
+    /** Runs `fn` (which updates fields) and records it as one undo step (merged by `merge` key). */
     private change;
+    /** Ends a merged edit (a slider released): the next change starts a new undo step. */
+    endMergedEdit(): void;
     private setDoc;
     private replaceNode;
     private freshIds;
@@ -1520,6 +2102,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. */
@@ -1588,6 +2211,43 @@ declare class VectorEditorController {
     outlineStroke(options?: {
         ids?: readonly string[];
     }): string[];
+    /** Selected (or given) nodes that can carry effects: the roots of the selection. */
+    private effectTargets;
+    /**
+     * Adds an effect of `type` to the selected (or given) nodes, at the bottom of each stack (or
+     * at `index`), with default parameters merged with `params`. A repeater's copies start one
+     * shape width apart. One undo step; returns the new effect ids (one per node, in order).
+     */
+    addEffect(type: VectorEffectType, options?: {
+        ids?: readonly string[];
+        params?: Record<string, unknown>;
+        index?: number;
+    }): string[];
+    private editEffects;
+    /**
+     * Turns an effect on or off and changes its parameters (unknown or invalid values are
+     * ignored). With `merge` (true, or a key of your own), consecutive updates of the same effect
+     * fold into one undo step, as a slider drag should; call `endMergedEdit` when it ends.
+     */
+    updateEffect(nodeId: string, effectId: string, patch: {
+        enabled?: boolean;
+        params?: Record<string, unknown>;
+    }, options?: {
+        merge?: boolean | string;
+    }): VectorActionResult;
+    /** Removes an effect from a node's stack. */
+    removeEffect(nodeId: string, effectId: string): VectorActionResult;
+    /** Moves an effect to position `index` of its stack (0 is applied first). */
+    moveEffect(nodeId: string, effectId: string, index: number): VectorActionResult;
+    /**
+     * Expand Appearance: bakes the path effects and live booleans of the selected (or given)
+     * nodes, and of everything inside them, into plain paths. A node keeps its id (a group when
+     * it draws as several shapes); the shapes it made get new ids. Returns the ids of the expanded
+     * nodes (empty when none was live).
+     */
+    expandAppearance(options?: {
+        ids?: readonly string[];
+    }): string[];
     rename(id: string, name: string): VectorActionResult;
     setVisible(id: string, visible: boolean): VectorActionResult;
     setLocked(id: string, locked: boolean): VectorActionResult;
@@ -1675,11 +2335,20 @@ declare class VectorEditorController {
     /**
      * Combines the selected paths (two or more) into one with a boolean operation. `subtract`
      * removes the upper shapes from the lowest one. The result takes the lowest shape's style
-     * and place.
+     * and place. Shapes take part as drawn (path effects and live booleans applied).
+     *
+     * With `live`, the operands stay editable instead: a lone live boolean group gets the
+     * operation (its operands follow it again), operands of live boolean groups get it as their
+     * own, and anything else (two or more nodes with one parent) is wrapped in a new live boolean
+     * group. Returns the result's (or the live group's) id, or null.
      */
     booleanOp(op: VectorBooleanOperation, options?: {
         ids?: readonly string[];
+        live?: boolean;
     }): string | null;
+    /** Whether stored node `rootId` holds `id` as drawn (`id` may be an expanded path inside it). */
+    private holds;
+    private liveBooleanOp;
     /** Joins the selected paths into one compound path (subpaths kept, lowest style). */
     combine(options?: {
         ids?: readonly string[];
@@ -1922,6 +2591,8 @@ declare class VectorEditorController {
     private hitCornerWidget;
     private hitAnchor;
     /** Deepest unlocked visible path under `p`. */
+    /** Live groups being edited (selected, or holding the selection or the edited path): their children are hit as stored. */
+    private enteredGroups;
     private hitPath;
     /** Endpoints of open subpaths of unlocked visible paths (pen tool resumes from them). */
     private openEndpoints;
@@ -1986,6 +2657,153 @@ 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;
@@ -2024,8 +2842,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[];
 }
@@ -2195,9 +3017,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;
 /**
@@ -2207,6 +3082,8 @@ declare const VECTOR_BUILDER_HATCH_GAP = 6;
 declare function getVectorSceneRenderData(state: Pick<VectorEditorState, 'document' | 'viewport'>, options?: {
     idPrefix?: string;
 }): VectorSceneRenderData;
+/** Live groups being edited in `state` (see `vectorEnteredGroups`). */
+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;
 /** What the Blend controls of a toolbar or style panel show. */
@@ -2345,6 +3222,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';
@@ -2374,6 +3283,33 @@ declare const VECTOR_EDIT_TOGGLES: readonly {
     label: string;
     title: string;
 }[];
+/** One effect of the listed stack, with what a panel needs to edit it. */
+interface VectorEffectsPanelItem {
+    id: string;
+    type: VectorEffectType;
+    label: string;
+    enabled: boolean;
+    params: Record<string, unknown>;
+    specs: readonly VectorEffectParamSpec[];
+}
+/** What an Effects panel shows for the selection. */
+interface VectorEffectsPanelData {
+    /** The node whose stack is listed (when one node is selected), else null. */
+    nodeId: string | null;
+    /** Selected nodes an added effect goes to. */
+    count: number;
+    /** The listed stack, applied top to bottom. */
+    effects: VectorEffectsPanelItem[];
+    /** Something selected is live (Expand Appearance applies). */
+    expandable: boolean;
+}
+/** Effect types in menu order, with their names. */
+declare const VECTOR_EFFECT_MENU: readonly {
+    type: VectorEffectType;
+    label: string;
+}[];
+/** The Effects panel of the selection, or null when nothing that takes effects is selected. */
+declare function getVectorEffectsPanel(state: Pick<VectorEditorState, 'document' | 'selection'>): VectorEffectsPanelData | null;
 
 interface VectorCommandOptions {
     /** Id prefix (default `vector.`); use one per editor when several are registered. */
@@ -2419,6 +3355,12 @@ interface VectorNodeListing {
     };
     /** An in-between generated by a blend (locked; changes come from its keys). */
     blendStep?: boolean;
+    /** The node's live path effects, applied in order. */
+    effects?: VectorEffect[];
+    /** A live boolean group's operation (its children are the operands). */
+    liveBoolean?: VectorBooleanOperation;
+    /** An operand's own operation in a live boolean group. */
+    booleanOperation?: VectorBooleanOperation;
 }
 /**
  * Palette and agent commands for a vector editor: list, select, add shapes and paths, style,
@@ -2756,10 +3698,13 @@ interface VectorPathEntry {
 }
 /**
  * The path nodes inside `roots` (or every node when `roots` is null), bottom to top, with their
- * parent matrices. Hidden nodes are skipped, and locked ones unless `locked` is true.
+ * parent matrices. Hidden nodes are skipped, and locked ones unless `locked` is true. Live nodes
+ * (path effects, live booleans) take part as drawn (`expandVectorAppearance`: their entries are
+ * the expanded paths, whose ids may not be in the document) unless `expand` is false.
  */
 declare function vectorPathEntries(doc: VectorDocument, roots: readonly string[] | null, options?: {
     locked?: boolean;
+    expand?: boolean;
 }): VectorPathEntry[];
 /** Whether a subpath, closed, encloses an area (rather than retracing itself). */
 declare function subpathEnclosesArea(sp: VectorSubpath): boolean;
@@ -2896,7 +3841,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
@@ -2997,8 +3942,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
@@ -3115,4 +4063,90 @@ declare function expandVectorBlend(group: VectorGroupNode, newId: () => string):
  */
 declare function releaseVectorBlend(group: VectorGroupNode, newId: () => string): VectorNode[];
 
-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_FILL_GAP, VECTOR_INK_MAX_CORNERS, 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 VectorArrange, type VectorArrowAlign, type VectorArrowhead, type VectorArrowheadShape, type VectorAverageAxis, type VectorBlend, type VectorBlendControls, type VectorBlendInput, type VectorBlendOptions, type VectorBlendRail, type VectorBlendSpacing, type VectorBlendStart, 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 VectorFillRule, type VectorGroupNode, type VectorGuideKind, type VectorGuideLabel, type VectorGuideLine, type VectorHandleRef, type VectorHover, type VectorInkShape, type VectorInteraction, type VectorKeyInput, type VectorLineCap, type VectorLineJoin, type VectorMatrix, 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 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, addBuilderHit, applyMatrix, applyMatrixLinear, applyVectorBlendOptions, applyVectorCornersAttribute, arrowheadInset, arrowheadPath, arrowheadWeight, bendSegment, bezierToSubpaths, boundsFromPoints, boundsIntersect, cloneAnchor, cloneSubpath, cloneVectorDocument, cloneVectorNode, collectPathNodes, constrainToLeave, convertAnchor, cornerBisectorPoint, cornerRadiusChange, cornerSetback, correspondMorphContours, createVectorCommands, createVectorMorph, curvatureMoveAnchor, cutSubpathAt, dashIntervals, decomposeRigid, effectiveStrokeAlign, ellipseSubpath, eraseFromFill, eraseFromOutline, eraserRegion, evaluateVectorPathKeyframes, expandVectorBlend, expandVectorCorners, expandVectorCornersOf, findVectorNode, fitCornerRadius, generateVectorBlendChildren, generateWidthProfile, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorBlendControls, getVectorCornerWidgets, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVectorWidthHandles, getVisibleAnchors, getVisibleHandles, hasPaint, hasStrokeExtras, hasVectorCorners, hitTestVectorNode, hitTestVectorNodes, hitTestVectorStroke, inferAnchorType, insertAnchor, insertWidthPoint, interpolateMorphContours, interpolateRigidMatrix, interpolateVectorColor, interpolateVectorPaint, interpolateVectorPaths, interpolateVectorStyle, interpolateWidthProfiles, invertMatrix, isClosedBezierShape, isIdentityMatrix, isUniformWidthProfile, isVectorBlendGroup, isVectorTextTarget, joinSubpaths, knifePath, lineSubpath, locateVectorNode, matrixRotation, mirrorWidthProfile, morphContourToSubpath, morphPathsCross, moveAnchorHandle, multiplyMatrices, nearestSegment, nearestStrokePosition, nextVectorCornerKind, nodeMatrix, parseSvgTransform, parseVectorSvg, planShapeBuilder, polygonSubpath, polylineBounds, pressureWidthProfile, recognizeInkShape, rectSubpath, refineMorphContour, refreshVectorBlends, releaseVectorBlend, removeAnchorKeepingShape, removeAnchors, removeAnchorsKeepingShape, removeRedundantPoints, removeWidthPoints, resampleGradientStops, resolveVectorBlendOptions, reverseMorphContour, reverseSubpath, reverseWidthProfile, rotateMatrix, roundSubpaths, samplePolyline, sanitizeWidthProfile, scaleFor, scaleMatrix, setAnchorCorner, setSubpathCorners, setWidthPoint, simplifyPolyline, smoothSubpath, splitIntoFaces, splitSubpathAt, starSubpath, strokePositionPoint, strokeWidthProfileOf, subpathEnclosesArea, subpathPointAt, subpathSegment, subpathSegmentCount, subpathToMorphContour, subpathsToBezier, taperWaveFactor, toVectorKeyInput, toVectorModifiers, toVectorPointerInput, transformVectorNode, translateAnchor, translateMatrix, turnMorphContour, unionBounds, variableStrokeOutline, variableStrokeRings, vectorBlendColorDistance, vectorBlendKeyTargets, vectorBlendKeys, vectorBlendRail, vectorBlendRailAt, vectorBlendSpine, vectorBlendStepCount, vectorBuilderErasedEdges, vectorCornerAt, vectorCorners, vectorCornersAttribute, vectorDiamondPath, vectorDocumentToSvg, vectorFillMap, vectorInkShapeName, vectorNodeBounds, vectorNodeRotation, vectorNodeToBezier, vectorPaintToHex, vectorPaintToSvg, vectorParentMatrix, vectorPathData, vectorPathEntries, vectorPathWorldBezier, vectorPathfinderShape, vectorResizeCursor, vectorResultStyle, vectorShapeBuilderHit, vectorShapeBuilderMap, vectorStrokeLineArea, vectorStrokeOutline, vectorStrokeOutlinePath, vectorStrokeParts, vectorStrokeReach, vectorStrokeSvgParts, vectorStrokeWidthGeometry, vectorToolLabel, vectorWorldMatrix, walkVectorNodes, widthProfileAt, widthProfileFromAttribute, widthProfileMaxScale, widthProfilePreset, widthProfilePresetId, widthProfileToAttribute };
+/** Total arc length of a path (closing lines included). */
+declare function effectPathLength(path: BezierPath): number;
+/** Number of on-curve points of a path (a closed subpath's start counted once). */
+declare function effectPathVertexCount(path: BezierPath): number;
+/** The fractions of the length a trim keeps, or null when it keeps everything. */
+declare function trimIntervals(start: number, end: number, offsetDegrees: number): [number, number][] | null;
+/**
+ * Trim Paths, simultaneously: every path is trimmed by the same fractions of its own length.
+ * `start` / `end` in percent, `offset` in degrees. Paths trimmed away entirely come back empty.
+ */
+declare function trimPaths(paths: readonly BezierPath[], start: number, end: number, offsetDegrees?: number): BezierPath[];
+/**
+ * Trim Paths, individually: the paths are laid end to end in stacking order and trimmed as one
+ * length, so they draw on one after another.
+ */
+declare function trimPathsIndividually(paths: readonly BezierPath[], start: number, end: number, offsetDegrees?: number): BezierPath[];
+/**
+ * Pucker & Bloat (`amount` in percent, −100 to 100). Positive (bloat) moves the points towards
+ * the mean of a path's points and pushes the handles away from it, so the segments bulge
+ * outwards; negative (pucker) does the opposite, giving spiky shapes.
+ */
+declare function puckerBloatPaths(paths: readonly BezierPath[], amount: number): BezierPath[];
+/**
+ * Round Corners: every corner (where the direction jumps) gets a circular arc of `radius`,
+ * shrunk to fit where the sides are short. Smooth points and the ends of open paths are kept.
+ */
+declare function roundCornerPaths(paths: readonly BezierPath[], radius: number): BezierPath[];
+/**
+ * Offset Paths: grows (positive `amount`) or shrinks (negative) every path with the given join.
+ * `copies` copies are made, copy i offset by `amount · (i + 1 + copyOffset)`, all in one path.
+ */
+declare function offsetPaths(paths: readonly BezierPath[], amount: number, join?: VectorLineJoin, miterLimit?: number, copies?: number, copyOffset?: number): BezierPath[];
+/**
+ * Twist: turns the paths about `center` by an angle growing with the distance from it, from 0
+ * at the centre to `angle` degrees at the farthest point. Segments are subdivided and their
+ * handles mapped through the warp's derivative, which keeps the result smooth.
+ */
+declare function twistPaths(paths: readonly BezierPath[], angle: number, center: Vec2): BezierPath[];
+/**
+ * Zig Zag: every segment gets `ridges` ridges: it is split into `ridges + 1` equal pieces and the
+ * points (original ones included) are pushed alternately `size` to either side of the path.
+ * `smooth` makes rounded waves. A closed path of n segments ends up with `n · (ridges + 1)` points
+ * (an open one, one more).
+ */
+declare function zigzagPaths(paths: readonly BezierPath[], size: number, ridges: number, smooth?: boolean): BezierPath[];
+/**
+ * Wiggle Paths: subdivides the paths (`detail` points per segment) and moves every point by
+ * smooth noise of up to `size` that evolves over `time` seconds at `speed` wiggles per second.
+ * The same parameters always give the same result.
+ */
+declare function wigglePaths(paths: readonly BezierPath[], w: VectorEffectParamsMap['wiggle']): BezierPath[];
+/** Merge Paths: the paths (in stacking order, each filled non-zero) combined into one path. */
+declare function mergePaths(paths: readonly BezierPath[], mode?: VectorMergeMode): BezierPath;
+/** One copy a repeater makes: its transform (node space) and opacity factor. */
+interface VectorRepeaterCopy {
+    /** Copy number (0 is the original). */
+    index: number;
+    matrix: AffineMatrix;
+    opacity: number;
+}
+/**
+ * The copies of a repeater around `pivot` (the anchor point in node space), in copy order.
+ * Copy i is moved by `translate(position·k) · rotate(rotation·k) · scale^k` about the pivot with
+ * `k = i + offset`; opacity runs from the start to the end opacity across the copies, and a
+ * fractional copy count fades the last copy by its fraction.
+ */
+declare function vectorRepeaterCopies(r: VectorEffectParamsMap['repeater'], pivot: Vec2): VectorRepeaterCopy[];
+/** Each path repeated by `vectorRepeaterCopies` (copy order, the original first). */
+declare function repeatPaths(paths: readonly BezierPath[], r: VectorEffectParamsMap['repeater'], pivot: Vec2): {
+    copy: VectorRepeaterCopy;
+    paths: BezierPath[];
+}[];
+/** The middle of the paths' bounds (the origin when they are empty). */
+declare function pathsCenter(paths: readonly BezierPath[]): Vec2;
+
+/**
+ * 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[];
+
+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_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_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 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 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 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 VectorWaveOptions, type VectorWidthHandle, type VectorWidthPoint, type VectorWidthPointEdit, type VectorWidthPointRef, type VectorWidthPreset, type VectorWidthPresetInfo, activeVectorEffects, addBuilderHit, applyMatrix, applyMatrixLinear, applyVectorBlendOptions, applyVectorCornersAttribute, applyVectorEffects, applyVectorGradientPatch, applyVectorGradientSpread, 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, effectPathLength, effectPathVertexCount, effectiveStrokeAlign, ellipseSubpath, eraseFromFill, eraseFromOutline, eraserRegion, evaluateVectorPathKeyframes, expandVectorAppearance, expandVectorAppearances, expandVectorBlend, expandVectorCorners, expandVectorCornersOf, expandVectorGradientSpread, expandVectorGradientStops, explicitVectorGradient, findVectorNode, fitCornerRadius, foldVectorBooleanOperands, generateVectorBlendChildren, generateWidthProfile, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorBlendControls, getVectorCornerWidgets, getVectorEffectsPanel, getVectorEnteredGroups, 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, isVectorBlendGroup, isVectorGradient, isVectorLiveBoolean, isVectorTextTarget, joinSubpaths, knifePath, lineSubpath, locateVectorNode, matrixRotation, mergePaths, mirrorWidthProfile, morphContourToSubpath, morphPathsCross, moveAnchorHandle, moveVectorGradientHandle, moveVectorGradientStop, multiplyMatrices, nearestSegment, nearestStrokePosition, nextVectorCornerKind, nodeMatrix, normalizeVectorEffectParams, offsetPaths, parseSvgTransform, parseVectorColor, parseVectorSvg, pathsCenter, patternAttrs, periodicVectorGradientStops, pinVectorGradient, planShapeBuilder, polygonSubpath, polylineBounds, pressureWidthProfile, puckerBloatPaths, recognizeInkShape, rectSubpath, refineMorphContour, refreshVectorBlends, releaseVectorBlend, removeAnchorKeepingShape, removeAnchors, removeAnchorsKeepingShape, removeRedundantPoints, removeVectorGradientStop, removeWidthPoints, repeatPaths, resampleGradientStops, resolveVectorBlendOptions, reverseMorphContour, reverseSubpath, reverseVectorGradient, reverseWidthProfile, rotateMatrix, roundCornerPaths, roundSubpaths, samplePlainStops, samplePolyline, sampleVectorGradient, sampleVectorGradientAt, sampleVectorPaintDefAt, sanitizeVectorEffects, sanitizeVectorGradient, sanitizeWidthProfile, scaleFor, scaleMatrix, setAnchorCorner, setSubpathCorners, setVectorGradientVector, setWidthPoint, simplifyPolyline, smoothSubpath, sortedVectorGradientStops, spanVectorGradientStops, splitIntoFaces, splitSubpathAt, 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, vectorBoxMatrix, vectorBuilderErasedEdges, vectorCornerAt, vectorCorners, vectorCornersAttribute, vectorDiamondPath, vectorDocumentToSvg, vectorEnteredGroups, vectorFillMap, vectorGradientArea, vectorGradientAspect, vectorGradientBarPosition, vectorGradientFocalParam, vectorGradientHandles, vectorGradientMatrix, vectorGradientMidpointFromPosition, vectorGradientMidpointPosition, vectorGradientNeedsExpansion, vectorGradientParam, vectorGradientPoints, vectorGradientRamp, vectorGradientSvgDefs, vectorGradientTAt, vectorGradientTargetPath, vectorGradientUnitsMatrix, vectorInkShapeName, vectorLiveBooleanSteps, vectorNodeBounds, vectorNodeRotation, vectorNodeToBezier, vectorOperandOperation, vectorPaintToHex, vectorPaintToSvg, vectorParentMatrix, vectorPathData, vectorPathEntries, vectorPathLocalBounds, vectorPathWorldBezier, vectorPathfinderShape, vectorRepeaterCopies, vectorResizeCursor, vectorResultStyle, vectorShapeBuilderHit, vectorShapeBuilderMap, vectorStrokeGradientDefs, vectorStrokeLineArea, vectorStrokeOutline, vectorStrokeOutlinePath, vectorStrokeParts, vectorStrokeReach, vectorStrokeSvgParts, vectorStrokeWidthGeometry, vectorToolLabel, vectorWorldMatrix, walkVectorNodes, widthProfileAt, widthProfileFromAttribute, widthProfileMaxScale, widthProfilePreset, widthProfilePresetId, widthProfileToAttribute, wigglePaths, zigzagPaths };