@pixerate/editor 0.40.0 → 0.42.0

package/dist/vector/index.d.cts

@@ -1,7 +1,8 @@
-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-DKRcXiLS.cjs';
+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-BSW2ZTO6.cjs';
 import { P as Point } from '../types-BFkYA4eF.cjs';
 import { H as HistoryManager } from '../HistoryManager-DeQQMBCj.cjs';
 import { C as CommandSpec } from '../registry-D0GADKc7.cjs';
+import { A as AnimationEasing } from '../easing-DTmX99QG.cjs';
 import '../types-DsiXGmjo.cjs';
 import '../schema-DYDGdYL9.cjs';
 
@@ -132,16 +133,73 @@ interface VectorNodeBase {
      * them into the geometry, so stroke widths and the rotated selection box stay exact.
      */
     transform?: VectorMatrix;
+    /**
+     * An in-between a blend group generated from its keys. Steps are rebuilt whenever a key or
+     * 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 {
     type: 'path';
     subpaths: VectorSubpath[];
 }
+/**
+ * How a blend spaces its in-betweens: a number of `steps` between each pair of keys, a fixed
+ * `distance` between steps along the spine, or `smoothColor` (as many steps as the colours
+ * need for a smooth ramp; by distance when the colours match).
+ */
+type VectorBlendSpacing = 'steps' | 'distance' | 'smoothColor';
+declare const VECTOR_BLEND_SPACINGS: readonly VectorBlendSpacing[];
+/** Settings of a blend. */
+interface VectorBlendOptions {
+    /** Default `steps`. */
+    spacing?: VectorBlendSpacing;
+    /** Steps between each pair of keys with `steps` spacing (default 5). */
+    steps?: number;
+    /** Distance between steps along the spine with `distance` spacing (default 20). */
+    distance?: number;
+    /** Turn the steps with the spine's direction (default `false`: they keep the keys' orientation). */
+    orientToSpine?: boolean;
+    /** Move anchors in straight lines instead of the rotation-aware morph (default `false`). */
+    linear?: boolean;
+}
+/** A live blend: the group's keys plus how the in-betweens are made and laid out. */
+interface VectorBlend extends VectorBlendOptions {
+    /**
+     * A replaced spine in the group's space: the steps follow it instead of the straight lines
+     * between the keys' centres (the keys sit along it, spread evenly by arc length).
+     */
+    spine?: VectorSubpath | null;
+    /** The anchor of each key's first subpath its blend starts from, by key id (the Blend tool's clicks). */
+    starts?: Record<string, number>;
+}
 /** A group of nodes that select and transform together. */
 interface VectorGroupNode extends VectorNodeBase {
     type: 'group';
     children: VectorNode[];
+    /**
+     * Makes the group a live blend: its children that are not `blendStep`s are the keys, in
+     * 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. */
@@ -174,9 +232,11 @@ interface VectorHandleRef extends VectorAnchorRef {
  * shape; `scissors` cuts a path at a point, `knife` cuts filled shapes along a freehand stroke,
  * `eraser` rubs out the area under one and `width` drags a stroke's width at a point.
  * `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.
+ * 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).
  */
-type VectorTool = 'select' | 'direct' | 'pen' | 'pencil' | 'rect' | 'ellipse' | 'polygon' | 'star' | 'line' | 'scissors' | 'knife' | 'eraser' | 'width' | 'shapeBuilder' | 'paintBucket';
+type VectorTool = 'select' | 'direct' | 'pen' | 'pencil' | 'rect' | 'ellipse' | 'polygon' | 'star' | 'line' | 'scissors' | 'knife' | 'eraser' | 'width' | 'shapeBuilder' | 'paintBucket' | 'blend';
 declare const VECTOR_TOOLS: readonly VectorTool[];
 /** Keyboard modifiers held during a pointer event. */
 interface VectorModifiers {
@@ -222,6 +282,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;
@@ -252,7 +415,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;
@@ -278,8 +441,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
@@ -292,19 +460,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;
@@ -1089,6 +1265,10 @@ interface VectorEditorState {
     pointer: Vec2 | null;
     /** Shape Builder and paint bucket highlight: faces, line pieces and the gesture's trail. */
     builder: VectorBuilderPreview | null;
+    /** The Blend tool's first click: the shape (and anchor of its first subpath) the next click blends from. */
+    blendStart: VectorBlendStart | null;
+    /** Options new blends get. */
+    blendDefaults: VectorBlendOptions;
     canUndo: boolean;
     canRedo: boolean;
     undoLabel: string;
@@ -1102,6 +1282,22 @@ type VectorActionResult = {
     ok: false;
     message: string;
 };
+/** The shape the Blend tool blends from (its first click). */
+interface VectorBlendStart {
+    nodeId: string;
+    /** The clicked anchor of its first subpath, or null for the shape as a whole. */
+    anchor: number | null;
+}
+/** Blend settings and options of `VectorEditorController.blend`. */
+interface VectorBlendInput extends VectorBlendOptions {
+    /** Nodes to blend (default: the selection), in stacking order unless `keepOrder`. */
+    ids?: readonly string[];
+    /** Blend in the order given instead of stacking order. */
+    keepOrder?: boolean;
+    /** Start anchor of each key's first subpath, by key id. */
+    starts?: Record<string, number>;
+    name?: string;
+}
 /**
  * What the Shape Builder or paint bucket highlights, in document units: the faces (filled paths
  * as SVG path data) under the pointer or touched by the drag, the line pieces an erase would
@@ -1325,6 +1521,9 @@ declare class VectorEditorController {
     /** Paint bucket map of the visible outlines. */
     private fillCache;
     private builderPreview;
+    private blendStart;
+    /** Options new blends get (the toolbars edit them along with the selected blend's). */
+    private blendDefaults;
     /** What the highlight shows, to skip notifying when the pointer stays over the same face. */
     private builderHoverKey;
     private readonly createId;
@@ -1346,6 +1545,8 @@ declare class VectorEditorController {
     getDocument(): VectorDocument;
     getNode(id: string): VectorNode | undefined;
     private computeState;
+    /** `doc` with its blends' steps brought up to date (the same object when they already are). */
+    private refreshed;
     private notify;
     private boundsOf;
     private frameOf;
@@ -1356,10 +1557,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 +1726,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;
@@ -1607,11 +1850,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[];
@@ -1634,6 +1886,44 @@ declare class VectorEditorController {
         ids?: readonly string[];
     }): string[];
     /** The Shape Builder map of the selected (or given) paths, cached per document and selection. */
+    /** Selected (or given) blend groups; a selected key or step counts as its blend. */
+    private blendTargets;
+    /**
+     * Blends two or more selected (or given) paths or groups: they become the keys of a live
+     * blend group (bottom to top, or in the order given with `keepOrder`) whose in-betweens are
+     * regenerated whenever a key or the options change. The keys must share a parent. Returns
+     * the blend group's id, or null.
+     */
+    blend(input?: VectorBlendInput): string | null;
+    /** Sets the options new blends get (spacing, steps, distance, orientation, morph). */
+    setBlendDefaults(patch: Partial<VectorBlendOptions>): void;
+    /**
+     * Adds a node as the last key of a blend (it must share the blend's parent); `start` is the
+     * anchor of its first subpath the blend starts from. One undo step.
+     */
+    addBlendKey(blendId: string, nodeId: string, options?: {
+        start?: number | null;
+    }): VectorActionResult;
+    /** Changes the spacing, steps, distance, orientation or morph of the selected (or given) blends. */
+    setBlendOptions(patch: Partial<VectorBlendOptions>, options?: {
+        ids?: readonly string[];
+    }): VectorActionResult;
+    /** Expand: turns the selected (or given) blends into plain groups of their keys and steps. Returns their ids. */
+    expandBlend(options?: {
+        ids?: readonly string[];
+    }): string[];
+    /** Release: replaces the selected (or given) blends with their keys (and a replaced spine as a path). */
+    releaseBlend(options?: {
+        ids?: readonly string[];
+    }): string[];
+    /**
+     * Replace Spine: the selected blend's steps follow the selected path instead of the straight
+     * lines between its keys. The path's first subpath becomes the spine (the path is removed)
+     * and the keys move onto it, spread evenly by arc length.
+     */
+    replaceBlendSpine(options?: {
+        ids?: readonly string[];
+    }): VectorActionResult;
     private shapeBuilderMap;
     /** The faces the Shape Builder offers for the selected (or given) paths (document units). */
     getShapeBuilderFaces(options?: {
@@ -1816,6 +2106,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;
@@ -1838,6 +2130,10 @@ declare class VectorEditorController {
     private sameHover;
     /** Primary button down on the canvas at `screen` (pixels relative to the canvas). */
     pointerDown(screen: Vec2, input?: VectorPointerInput): void;
+    /** The shape under the pointer for the Blend tool, and the anchor of its first subpath under it. */
+    private blendHit;
+    /** Blend tool: the first click picks the shape to blend from, the next one blends it into the shape clicked. */
+    private downBlend;
     private downSelect;
     private downDirect;
     private downPen;
@@ -1876,6 +2172,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;
@@ -2062,6 +2505,29 @@ interface VectorOverlayRenderData {
         lines: string[];
         trail: string | null;
     } | null;
+    /**
+     * Blends (screen space): the spine of each selected blend (`d`, draw it dashed; `keys` are
+     * where its keys sit on it; `replaced` when it is a replaced spine) and, with the Blend tool,
+     * the outline of the shape it blends from (`start`, with the clicked anchor) and the anchors
+     * of the first subpath under the pointer (click one to start the blend there).
+     */
+    blend: {
+        spines: {
+            id: string;
+            d: string;
+            keys: Vec2[];
+            replaced: boolean;
+        }[];
+        start: {
+            d: string;
+            anchor: Vec2 | null;
+        } | null;
+        anchors: {
+            x: number;
+            y: number;
+            hovered: boolean;
+        }[];
+    };
     /** A short status, e.g. "W 120 × H 80" or "45°". */
     status: string | null;
 }
@@ -2074,8 +2540,32 @@ 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. */
+interface VectorBlendControls {
+    /** Ids of the selected blends (a selected key counts as its blend). */
+    ids: string[];
+    /** The first selected blend's options, or the options new blends get. */
+    options: Required<VectorBlendOptions>;
+    /** Two or more shapes that share a parent are selected: Blend can run. */
+    canBlend: boolean;
+    /** One blend and one path are selected: Replace Spine can run. */
+    canReplaceSpine: boolean;
+    /** The first selected blend follows a replaced spine. */
+    hasSpine: boolean;
+}
+/** State of the Blend controls for the current selection. */
+declare function getVectorBlendControls(state: Pick<VectorEditorState, 'document' | 'selection' | 'blendDefaults'>): VectorBlendControls;
+/**
+ * Applies blend options from a toolbar: to the selected blends (one undo step) and to the
+ * options new blends get, so the controls keep showing what was picked.
+ */
+declare function applyVectorBlendOptions(controller: VectorEditorController, patch: Partial<VectorBlendOptions>): void;
+/** Labels of the blend spacing modes, for toolbars. */
+declare const VECTOR_BLEND_SPACING_LABELS: Readonly<Record<VectorBlendSpacing, string>>;
 /** Colours and sizes (screen pixels) the bundled canvases draw the overlay with. */
 declare const VECTOR_OVERLAY_THEME: {
     readonly accent: "#0ea5e9";
@@ -2219,6 +2709,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. */
@@ -2252,6 +2769,24 @@ interface VectorNodeListing {
     /** SVG path data (paths only). */
     d?: string;
     children?: number;
+    /** A blend group's options (its steps are listed as children with `blendStep`). */
+    blend?: {
+        spacing: string;
+        steps: number;
+        distance: number;
+        orientToSpine: boolean;
+        linear: boolean;
+        spine: boolean;
+        keys: string[];
+    };
+    /** 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,
@@ -2589,10 +3124,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;
@@ -2712,4 +3250,315 @@ declare function planShapeBuilder(m: VectorShapeBuilderMap, touched: VectorBuild
  */
 declare function vectorFillMap(doc: VectorDocument, gap?: number): PlanarMap | null;
 
-export { type AddVectorNodeOptions, AffineMatrix, DEFAULT_VECTOR_PATH_EDIT, DEFAULT_VECTOR_SNAP, IDENTITY_MATRIX, KAPPA, LazyMouse, type NearestSegment, type RecognizeInkOptions, SvgGradientDef, VECTOR_ARROWHEADS, VECTOR_ARROWHEAD_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 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 VectorNode, type VectorNodeListing, type VectorOverlayRenderData, type VectorPaint, type VectorPathAction, type VectorPathEditOptions, type VectorPathEntry, 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, applyVectorCornersAttribute, arrowheadInset, arrowheadPath, arrowheadWeight, bendSegment, bezierToSubpaths, boundsFromPoints, boundsIntersect, cloneAnchor, cloneSubpath, cloneVectorDocument, cloneVectorNode, collectPathNodes, constrainToLeave, convertAnchor, cornerBisectorPoint, cornerRadiusChange, cornerSetback, createVectorCommands, curvatureMoveAnchor, cutSubpathAt, dashIntervals, decomposeRigid, effectiveStrokeAlign, ellipseSubpath, eraseFromFill, eraseFromOutline, eraserRegion, expandVectorCorners, expandVectorCornersOf, findVectorNode, fitCornerRadius, generateWidthProfile, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorCornerWidgets, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVectorWidthHandles, getVisibleAnchors, getVisibleHandles, hasPaint, hasStrokeExtras, hasVectorCorners, hitTestVectorNode, hitTestVectorNodes, hitTestVectorStroke, inferAnchorType, insertAnchor, insertWidthPoint, invertMatrix, isClosedBezierShape, isIdentityMatrix, isUniformWidthProfile, isVectorTextTarget, joinSubpaths, knifePath, lineSubpath, locateVectorNode, matrixRotation, mirrorWidthProfile, moveAnchorHandle, multiplyMatrices, nearestSegment, nearestStrokePosition, nextVectorCornerKind, nodeMatrix, parseSvgTransform, parseVectorSvg, planShapeBuilder, polygonSubpath, polylineBounds, pressureWidthProfile, recognizeInkShape, rectSubpath, removeAnchorKeepingShape, removeAnchors, removeAnchorsKeepingShape, removeRedundantPoints, removeWidthPoints, reverseSubpath, reverseWidthProfile, rotateMatrix, roundSubpaths, samplePolyline, sanitizeWidthProfile, scaleFor, scaleMatrix, setAnchorCorner, setSubpathCorners, setWidthPoint, simplifyPolyline, smoothSubpath, splitIntoFaces, splitSubpathAt, starSubpath, strokePositionPoint, strokeWidthProfileOf, subpathEnclosesArea, subpathPointAt, subpathSegment, subpathSegmentCount, subpathsToBezier, taperWaveFactor, toVectorKeyInput, toVectorModifiers, toVectorPointerInput, transformVectorNode, translateAnchor, translateMatrix, unionBounds, variableStrokeOutline, variableStrokeRings, 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 };
+/**
+ * Morphing between vector paths: bring two shapes to matching anchors, then compute in-betweens.
+ *
+ * - **Contours** pair up in order. A contour without a partner grows out of (or shrinks into) a
+ *   point at the same place relative to the other shape's box. Straight segments become cubics
+ *   with handles at a third of the way, so a line bends smoothly into a curve.
+ * - **Anchors** are inserted by arc length with de Casteljau splits, so both contours of a pair
+ *   keep their exact outline and get the same number of segments, spread over the segments in
+ *   proportion to their length.
+ * - **Correspondence**: the closed side of each pair is turned to the cyclic start that costs
+ *   least — the position differences left after the best-fit rotation (both shapes centred and
+ *   scaled to unit size), a little for the turn, plus the χ² distance of log-polar
+ *   shape-context histograms (Belongie, Malik & Puzicha, PAMI 2002; angles taken from the
+ *   contour's direction) — and the winding is chosen once for all contours (the first closed
+ *   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
+ *   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
+ *   `transform` interpolates as a rotation (the short way round) plus a translation.
+ *
+ * Live corners are cut into the geometry first, so rounded corners morph as curves.
+ */
+
+interface VectorMorphOptions {
+    /**
+     * Move anchors in straight lines instead of following the shapes' best-fit rotation and
+     * scale. Default `false`.
+     */
+    linear?: boolean;
+    /** 0–1: how much the rotation-aware path outweighs the straight one (default 1). */
+    rigidity?: number;
+    /** Fewest segments each contour pair gets (default 16). */
+    minSegments?: number;
+    /** At most this far apart (document units) along the longer contour, when set. */
+    spacing?: number | null;
+    /** Most segments a contour pair gets (default 400). */
+    maxSegments?: number;
+    /** Search the start anchor of closed contours (default `true`); off keeps the stored starts. */
+    matchStart?: boolean;
+    /** Compare shape-context histograms when choosing starts (default `true`). */
+    shapeContext?: boolean;
+    /**
+     * The anchor each shape's first subpath starts from (the Blend tool's clicks). A closed
+     * subpath turns round to it; an open one clicked at its last anchor runs backwards.
+     */
+    starts?: readonly [number | null | undefined, number | null | undefined];
+    /** Id of the in-between (default: the first shape's id). */
+    id?: string;
+}
+/** Two shapes prepared once; `at(t)` interpolates (0 = `a`, 1 = `b`). */
+interface VectorMorph {
+    at(t: number): VectorNode;
+}
+/** A subpath as cubics. A closed contour's last point repeats its first. */
+interface VectorMorphContour {
+    closed: boolean;
+    pts: Point[];
+}
+/** A subpath mapped by `m` as cubics (lines with handles at thirds), or null when empty. */
+declare function subpathToMorphContour(sp: VectorSubpath, m?: AffineMatrix): VectorMorphContour | null;
+/** A contour back to a subpath (`m` maps it out of the morph's space). Straight cubics become lines. */
+declare function morphContourToSubpath(c: VectorMorphContour, m?: AffineMatrix, closed?: boolean): VectorSubpath;
+/**
+ * Exactly the same outline with `segments` cubics (at least as many as it has), the new
+ * anchors spread over its segments in proportion to their arc length (largest remainder)
+ * and each segment split into pieces of equal arc length. Also returns where each original
+ * anchor went.
+ */
+declare function refineMorphContour(c: VectorMorphContour, segments: number): {
+    contour: VectorMorphContour;
+    anchors: number[];
+};
+/** The same contour run backwards (a closed one keeps its start anchor). */
+declare function reverseMorphContour(c: VectorMorphContour): VectorMorphContour;
+/** A closed contour starting at anchor `s` (deckcraft's `turn`). */
+declare function turnMorphContour(c: VectorMorphContour, s: number): VectorMorphContour;
+/** Two shapes' contours with matching structure: same count, and per pair the same segments. */
+interface VectorMorphCorrespondence {
+    a: VectorMorphContour[];
+    b: VectorMorphContour[];
+    /** Whether `b` runs backwards relative to its stored direction. */
+    reversed: boolean;
+}
+/**
+ * Gives two lists of contours the same structure with matching anchors (see the module notes).
+ * Contours pair in order; one without a partner meets a point.
+ */
+declare function correspondMorphContours(a: readonly VectorMorphContour[], b: readonly VectorMorphContour[], options?: VectorMorphOptions): VectorMorphCorrespondence;
+/**
+ * How many pairs of straight anchor paths (from `a`'s anchor i to `b`'s anchor i) cross: a
+ * sanity measure of a correspondence — good matches don't make anchors pass through each other.
+ */
+declare function morphPathsCross(a: readonly VectorMorphContour[], b: readonly VectorMorphContour[]): number;
+/** The similarity (rotation θ, scale s, centroids) that best maps `a`'s anchors onto `b`'s. */
+interface Similarity {
+    ca: Point;
+    cb: Point;
+    theta: number;
+    s: number;
+}
+/**
+ * Corresponded contours at `u`: each point carried by the similarity interpolated to `u`
+ * (rotation θu, scale sᵘ, centroid moving straight), plus `u` of what the full similarity
+ * leaves over, blended with the straight path by `rigidity`.
+ */
+declare function interpolateMorphContours(a: readonly VectorMorphContour[], b: readonly VectorMorphContour[], u: number, options?: Pick<VectorMorphOptions, 'linear' | 'rigidity'> & {
+    similarity?: Similarity;
+}): VectorMorphContour[];
+/**
+ * Interpolates two rigid matrices as a rotation (the shorter way round) plus a translation.
+ * Any scale or skew is interpolated linearly in the rotated frame.
+ */
+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[];
+/**
+ * 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
+ * fading from transparent. Gradients of different kinds switch halfway.
+ */
+declare function interpolateVectorPaint(a: VectorPaint | undefined, b: VectorPaint | undefined, t: number): VectorPaint | undefined;
+/** Width profiles at every position either has a point (no profile is uniform). */
+declare function interpolateWidthProfiles(a: readonly VectorWidthPoint[] | null | undefined, b: readonly VectorWidthPoint[] | null | undefined, t: number): VectorWidthPoint[] | null;
+/**
+ * Interpolated style of two paths: paints, stroke width, dashes, arrowhead scales and width
+ * profiles mix; caps, joins, the fill rule, alignment and arrowheads switch halfway.
+ */
+declare function interpolateVectorStyle(a: VectorStyle, b: VectorStyle, t: number): VectorStyle;
+/**
+ * Prepares two shapes for interpolation. Two paths morph directly; with a group on either side
+ * the paths inside pair up in stacking order and those without a partner grow out of a point.
+ * Shapes are blended in their parent's space.
+ */
+declare function createVectorMorph(a: VectorNode, b: VectorNode, options?: VectorMorphOptions): VectorMorph;
+/**
+ * The in-between of two shapes at `t` (0 = `a`, 1 = `b`). Prepare once with
+ * `createVectorMorph` when interpolating the same pair at many `t`.
+ */
+declare function interpolateVectorPaths(a: VectorNode, b: VectorNode, t: number, options?: VectorMorphOptions): VectorNode;
+/** A keyframe of a path track: a shape at a time (ms), with the easing of the segment leaving it. */
+interface VectorPathKeyframe {
+    time: number;
+    value: VectorNode;
+    easing?: AnimationEasing;
+}
+/**
+ * A path track's shape at `time`: before the first keyframe its shape, after the last the
+ * last; in between the two keyframes morph (prepared once per pair and cached) at the eased
+ * fraction. Easings that overshoot are clamped to the keys. `null` without keyframes.
+ */
+declare function evaluateVectorPathKeyframes(keyframes: readonly VectorPathKeyframe[], time: number, options?: VectorMorphOptions): VectorNode | null;
+
+/**
+ * Live blend groups: a group whose `blend` is set keeps its key shapes as children and
+ * regenerates the in-betweens (`blendStep` children, locked) whenever a key or the options
+ * change. Steps follow the straight lines between the keys' centres, or a replaced spine.
+ *
+ * - **Spacing** (`vectorBlendStepCount`): a number of steps per pair of keys, a fixed distance
+ *   along the spine, or smooth colour — one step per two levels of the largest colour channel
+ *   difference, by distance when the colours match.
+ * - **Spine**: with a replaced spine the keys sit along it, spread evenly by arc length; each
+ *   step is moved by how far the spine bends away from the chord between its keys, so a step
+ *   lands on the spine and the keys stay where they are. Orient to spine also turns the steps
+ *   by how much the spine's direction differs from the keys' (keys keep their orientation);
+ *   without a replaced spine the steps run straight and keep their orientation.
+ */
+
+declare const DEFAULT_VECTOR_BLEND_STEPS = 5;
+declare const DEFAULT_VECTOR_BLEND_DISTANCE = 20;
+/** Most steps between two keys. */
+declare const VECTOR_BLEND_MAX_STEPS = 1000;
+/** Most steps smooth colour makes between two keys. */
+declare const VECTOR_BLEND_MAX_SMOOTH_STEPS = 256;
+/** Whether a node is a live blend group. */
+declare function isVectorBlendGroup(node: VectorNode | null | undefined): node is VectorGroupNode & {
+    blend: VectorBlend;
+};
+/** The keys of a blend group (its children that are not generated steps), in stacking order. */
+declare function vectorBlendKeys(group: VectorGroupNode): VectorNode[];
+/** The full options of a blend, defaults filled in. */
+declare function resolveVectorBlendOptions(options: VectorBlendOptions | null | undefined): Required<VectorBlendOptions>;
+/** Largest channel difference (0–1) between the colours of two shapes' fills and strokes. */
+declare function vectorBlendColorDistance(a: VectorNode, b: VectorNode): number;
+/** Number of in-betweens between two keys `length` apart along the spine. */
+declare function vectorBlendStepCount(a: VectorNode, b: VectorNode, options: VectorBlendOptions | null | undefined, length: number): number;
+/** A subpath flattened to a polyline with cumulative arc lengths and tangent angles. */
+interface VectorBlendRail {
+    pts: Point[];
+    cum: number[];
+    angles: number[];
+    total: number;
+    closed: boolean;
+}
+/** Flattens a spine subpath (32 samples per curve). Null with fewer than two distinct points. */
+declare function vectorBlendRail(sp: VectorSubpath): VectorBlendRail | null;
+/** Point and direction (radians) at arc length `s` (clamped; a closed rail wraps). */
+declare function vectorBlendRailAt(rail: VectorBlendRail, s: number): {
+    point: Point;
+    angle: number;
+};
+/**
+ * The spine of a blend in the group's space and where along it each key sits: the replaced
+ * spine (keys spread evenly by arc length) or the straight lines between the keys' centres.
+ */
+declare function vectorBlendSpine(group: VectorGroupNode): {
+    spine: VectorSubpath;
+    rail: VectorBlendRail;
+    stops: number[];
+    replaced: boolean;
+} | null;
+/** Where key `i` of a blend with spine `spine` should sit: its stop on the spine. */
+declare function vectorBlendKeyTargets(group: VectorGroupNode): Point[];
+/**
+ * A blend group's children with fresh steps: each key followed by the in-betweens to the next,
+ * bottom to top. Groups with fewer than two keys keep just their keys.
+ */
+declare function generateVectorBlendChildren(group: VectorGroupNode): VectorNode[];
+/**
+ * Nodes with every blend group's steps brought up to date (nested blends first). Returns the
+ * same array when nothing changed; steps are cached per set of keys, so calling this after
+ * every edit is cheap.
+ */
+declare function refreshVectorBlends(nodes: readonly VectorNode[]): VectorNode[];
+/** Expand: the blend as a plain group of its keys and steps (steps get fresh ids). */
+declare function expandVectorBlend(group: VectorGroupNode, newId: () => string): VectorGroupNode;
+/**
+ * Release: the blend's keys in the group's parent space (the group's transform and opacity
+ * applied), followed by the replaced spine as an unpainted path when there is one.
+ */
+declare function releaseVectorBlend(group: VectorGroupNode, newId: () => string): VectorNode[];
+
+/** 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;
+
+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 };