@pixerate/editor 0.43.0 → 0.44.0

package/dist/vector/index.d.ts

@@ -319,9 +319,10 @@ interface VectorHandleRef extends VectorAnchorRef {
  * `shapeBuilder` merges (Alt: deletes) the faces the selected shapes make, and `paintBucket`
  * fills the region the visible outlines enclose around a click with a new shape. `blend`
  * blends the shape clicked first into the one clicked next (clicking an anchor of a closed path
- * starts the blend there).
+ * starts the blend there). `envelope` edits the mesh of the selection's envelope: drag its
+ * anchors and handles, or inside a patch to pull the surface.
  */
-type VectorTool = 'select' | 'direct' | 'pen' | 'pencil' | 'rect' | 'ellipse' | 'polygon' | 'star' | 'line' | 'scissors' | 'knife' | 'eraser' | 'width' | 'shapeBuilder' | 'paintBucket' | 'blend' | 'gradient';
+type VectorTool = 'select' | 'direct' | 'pen' | 'pencil' | 'rect' | 'ellipse' | 'polygon' | 'star' | 'line' | 'scissors' | 'knife' | 'eraser' | 'width' | 'shapeBuilder' | 'paintBucket' | 'blend' | 'gradient' | 'envelope';
 declare const VECTOR_TOOLS: readonly VectorTool[];
 /** Keyboard modifiers held during a pointer event. */
 interface VectorModifiers {
@@ -370,10 +371,24 @@ type VectorAverageAxis = 'horizontal' | 'vertical' | 'both';
 /**
  * Live path effects (After Effects' path operators): `trim` (Trim Paths), `roundCorners`,
  * `puckerBloat`, `twist`, `zigzag`, `wiggle` (Wiggle Paths), `offset` (Offset Paths), `merge`
- * (Merge Paths) and `repeater`.
+ * (Merge Paths), `repeater` and `envelope` (an envelope distortion: a warp preset or a mesh).
  */
-type VectorEffectType = 'trim' | 'roundCorners' | 'puckerBloat' | 'twist' | 'zigzag' | 'wiggle' | 'offset' | 'merge' | 'repeater';
+type VectorEffectType = 'trim' | 'roundCorners' | 'puckerBloat' | 'twist' | 'zigzag' | 'wiggle' | 'offset' | 'merge' | 'repeater' | 'envelope';
 declare const VECTOR_EFFECT_TYPES: readonly VectorEffectType[];
+/** Warp presets (Photoshop's fifteen, in menu order). */
+type VectorWarpStyle = 'arc' | 'arcLower' | 'arcUpper' | 'arch' | 'bulge' | 'shellLower' | 'shellUpper' | 'flag' | 'wave' | 'fish' | 'rise' | 'fisheye' | 'inflate' | 'squeeze' | 'twist';
+/**
+ * A grid of bicubic Bézier patches mapping a source box onto the plane. `us` / `vs` are the patch
+ * boundaries as fractions of the box (increasing, first 0, last 1); `points` is the
+ * `(3·(us.length − 1) + 1) × (3·(vs.length − 1) + 1)` control grid, row by row, in the node's own
+ * space. Neighbouring patches share their edge row: anchors sit where both indices are multiples
+ * of 3, handles where one is.
+ */
+interface VectorWarpMesh {
+    us: number[];
+    vs: number[];
+    points: Vec2[];
+}
 /** Merge Paths modes: a compound path (no boolean), union, the first minus the others, intersection or exclusion. */
 type VectorMergeMode = 'merge' | 'add' | 'subtract' | 'intersect' | 'exclude';
 declare const VECTOR_MERGE_MODES: readonly VectorMergeMode[];
@@ -458,6 +473,23 @@ interface VectorEffectParamsMap {
         /** `below`: each copy draws under the one before it; `above`: over it. */
         composite: 'below' | 'above';
     };
+    /**
+     * Envelope distortion: the paths above it are mapped from their combined bounds through a warp
+     * preset (bend and horizontal / vertical distortion in percent) or, with style `mesh`, through
+     * `mesh` (null: the flat mesh of `columns × rows` patches over the bounds). The bounds are
+     * taken afresh each time, so editing the contents keeps the envelope.
+     */
+    envelope: {
+        style: VectorWarpStyle | 'mesh';
+        bend: number;
+        horizontal: number;
+        vertical: number;
+        orientation: 'horizontal' | 'vertical';
+        /** Patches of the mesh (a preset turns into a mesh of this size when it is edited). */
+        rows: number;
+        columns: number;
+        mesh: VectorWarpMesh | null;
+    };
 }
 /** One entry of an effect stack. */
 type VectorEffect = {
@@ -784,6 +816,15 @@ declare function pinVectorGradient(g: VectorGradient, bounds: VectorBounds | nul
  * three points span); a box gradient follows the box and is unchanged.
  */
 declare function transformVectorGradient(g: VectorGradient, m: VectorMatrix): VectorGradient;
+/**
+ * A gradient after its node's geometry goes through a non-affine map `f` (Free Distort, an
+ * envelope): handles in the node's own space (`userSpaceOnUse`) are mapped point by point, which
+ * keeps the gradient's frame where the shape went; bounding-box gradients are left alone, as they
+ * already follow the shape's new bounds.
+ */
+declare function mapVectorGradient(g: VectorGradient, f: (p: Vec2) => Vec2): VectorGradient;
+/** A paint after its node's geometry goes through a non-affine map `f` (see `mapVectorGradient`). */
+declare function mapVectorPaint<T extends VectorPaint | undefined>(paint: T, f: (p: Vec2) => Vec2): T;
 /** A paint after its node's geometry is mapped by `m` (colours unchanged). */
 declare function transformVectorPaint<T extends VectorPaint | undefined>(paint: T, m: VectorMatrix): T;
 /**
@@ -1256,6 +1297,246 @@ declare function vectorGradientBarPosition(a: Pick<VectorGradientAnnotator, 'sta
 /** The annotator part under screen point `p`: stops, then midpoints, the handles and the bar. */
 declare function hitVectorGradientAnnotator(a: VectorGradientAnnotator, p: Vec2): VectorGradientPart | null;
 
+/**
+ * Live appearance: path effect stacks and live boolean groups, evaluated on demand while the
+ * stored anchors and children stay editable.
+ *
+ * `expandVectorAppearance` is the one place the effected geometry is made (cached per node
+ * object, so an edit recomputes only the nodes it replaced). Rendering, hit-testing, bounds,
+ * snapping, booleans, the Pathfinder, the Shape Builder and SVG export all read it, the way they
+ * read live corners through `subpathsToBezier`; Expand Appearance stores it.
+ *
+ * Stacking follows After Effects' shape layers (effectcraft `crates/render/src/shapes.rs`): an
+ * effect acts on every path above it — the node's own outline, or for a group every path of its
+ * children (nested groups included, as drawn by their own effects) — in the order of the stack,
+ * and effects placed after a repeater act on its copies. The result paints with the style of the
+ * path each shape came from; Merge Paths and live booleans paint with the bottom one's.
+ *
+ * Live booleans fold their operands bottom to top, each combined with the result below it by its
+ * own operation or the group's, and every prefix of the fold is cached under a rolling hash of the
+ * operands it covers, so editing one operand recombines only the operands from it up; the cache
+ * drops its least recently used half when full. Live groups are hit by their result except while
+ * they are being edited (`vectorEnteredGroups`).
+ *
+ * Ported from ArtCraft (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
+ * THIRD_PARTY_NOTICES.md): the stacking rule of effectcraft `crates/render/src/shapes.rs`
+ * (`collect()`); figcraft `crates/render/src/boolean.rs` (`fold_cached`, `PathCache`) and
+ * `crates/engine/src/booleans.rs` (`operand_op`, `result_outline`); and the live-object model of
+ * vectorcraft `crates/doc/src/live.rs` (`expand_live`, `expanded_group`, `subtree_has_live`).
+ */
+
+/** One shape of a node's appearance: a path in the node's own space, painted in `source`'s style. */
+interface VectorAppearanceShape {
+    /** The path whose style paints it. */
+    source: VectorPathNode;
+    path: BezierPath;
+    /** Opacity factor relative to the node (its own opacity not included). */
+    opacity: number;
+    /** Draw-order key (compared element by element). */
+    order: number[];
+}
+/** Default parameters of each effect type. */
+declare const VECTOR_EFFECT_DEFAULTS: {
+    readonly [K in VectorEffectType]: VectorEffectParamsMap[K];
+};
+declare const VECTOR_EFFECT_LABELS: Record<VectorEffectType, string>;
+/** How a panel edits one effect parameter. */
+type VectorEffectParamSpec = {
+    key: string;
+    label: string;
+    kind: 'number';
+    min?: number;
+    max?: number;
+    step: number;
+    slider?: boolean;
+} | {
+    key: string;
+    label: string;
+    kind: 'vec2';
+    step: number;
+} | {
+    key: string;
+    label: string;
+    kind: 'boolean';
+} | {
+    key: string;
+    label: string;
+    kind: 'select';
+    options: {
+        value: string;
+        label: string;
+    }[];
+};
+/** The editable parameters of each effect type, in panel order. */
+declare const VECTOR_EFFECT_PARAM_SPECS: Record<VectorEffectType, VectorEffectParamSpec[]>;
+/** Envelope parameters. */
+type VectorEnvelopeParams = VectorEffectParamsMap['envelope'];
+/**
+ * The envelope's mesh over `bounds` (the paths' combined bounds), in the node's space: its own
+ * mesh, the flat mesh of `columns × rows` patches, or a preset split exactly into that many patches.
+ */
+declare function vectorEnvelopeMesh(params: VectorEnvelopeParams, bounds: VectorBounds): VectorWarpMesh;
+/** The envelope as a map of the node's space over `bounds`, or null when it changes nothing (or the box is empty). */
+declare function vectorEnvelopeMap(params: VectorEnvelopeParams, bounds: VectorBounds | null): ((p: {
+    x: number;
+    y: number;
+}) => {
+    x: number;
+    y: number;
+}) | null;
+/**
+ * Effect parameters with defaults filled in and invalid values dropped (unknown keys go too).
+ * Returns null for an unknown type.
+ */
+declare function normalizeVectorEffectParams<K extends VectorEffectType>(type: K, params: Record<string, unknown> | null | undefined, base?: VectorEffectParamsMap[K]): VectorEffectParamsMap[K] | null;
+/** A new effect of `type` (defaults merged with `params`), or null for an unknown type. */
+declare function createVectorEffect<K extends VectorEffectType>(type: K, id: string, params?: Partial<VectorEffectParamsMap[K]> | Record<string, unknown>): Extract<VectorEffect, {
+    type: K;
+}> | null;
+/** The node's effects that take part (enabled, of a known type). */
+declare function activeVectorEffects(node: VectorNode): VectorEffect[];
+/** Whether the node itself draws differently from its stored geometry (effects or a live boolean). */
+declare function hasOwnVectorAppearance(node: VectorNode): boolean;
+/** Whether the node or anything inside it has a live appearance. */
+declare function hasVectorAppearance(node: VectorNode): boolean;
+/** A live boolean group (its children are operands). */
+declare function isVectorLiveBoolean(node: VectorNode | null | undefined): node is VectorGroupNode & {
+    liveBoolean: VectorBooleanOperation;
+};
+/** How operand `child` of a live boolean group combines with the operands below it. */
+declare function vectorOperandOperation(group: VectorGroupNode, child: VectorNode): VectorBooleanOperation;
+/** How many boolean steps (one operand combined with the result below it) live booleans have computed: what a cache miss costs. */
+declare function vectorLiveBooleanSteps(): number;
+/** Empties the live boolean prefix cache. */
+declare function clearVectorLiveBooleanCache(): void;
+/** One operand of a live boolean: its outline (group space), fill rule and operation (unused for the bottom one). */
+interface VectorBooleanOperand {
+    path: BezierPath;
+    fillRule: VectorFillRule;
+    operation: VectorBooleanOperation;
+}
+/**
+ * The result of folding `operands` bottom to top, reusing the longest cached prefix: only the
+ * operands above it are combined. Invalid geometry gives an empty path.
+ */
+declare function foldVectorBooleanOperands(operands: readonly VectorBooleanOperand[]): BezierPath;
+/** Applies an effect stack to shapes, top to bottom (disabled effects skipped). */
+declare function applyVectorEffects(shapes: readonly VectorAppearanceShape[], effects: readonly VectorEffect[] | null | undefined): VectorAppearanceShape[];
+/** The paths entering effect `effectId` of the node's stack (those above it applied), in the node's own space. */
+declare function vectorEffectInputPaths(node: VectorNode, effectId: string): BezierPath[] | null;
+/** The box effect `effectId` (an envelope) bends: the combined bounds of the paths entering it, in the node's own space. */
+declare function vectorEffectInputBounds(node: VectorNode, effectId: string): VectorBounds | null;
+/** The node's first enabled envelope effect, or null. */
+declare function vectorNodeEnvelope(node: VectorNode | null | undefined): Extract<VectorEffect, {
+    type: 'envelope';
+}> | null;
+/**
+ * The editable mesh of a node's envelope (its own mesh, or the preset or flat mesh it stands for)
+ * with the box it bends, in the node's own space; null without an envelope or contents.
+ */
+declare function vectorEnvelopeFrame(node: VectorNode, effectId?: string): {
+    effectId: string;
+    bounds: VectorBounds;
+    mesh: VectorWarpMesh;
+} | null;
+/**
+ * What a node draws as: shapes in its own space (its `transform` and opacity not applied),
+ * bottom to top, with its effects and those of everything inside it applied. Cached per node
+ * object.
+ */
+declare function vectorAppearanceShapes(node: VectorNode): VectorAppearanceShape[];
+/** Everything a node draws as one path in its own space (live corners cut, effects applied). */
+declare function vectorAppearanceOutline(node: VectorNode): BezierPath;
+/** What a node draws as, one plain path per shape (ids `<id>~fx<n>`, opacity relative to the node). */
+declare function vectorAppearanceNodes(node: VectorNode): VectorPathNode[];
+/**
+ * The node as plain geometry: path effects and live booleans evaluated into paths (the node
+ * itself when nothing inside it is live). A path keeps its id when it draws as one shape;
+ * otherwise, like any live group, it becomes a group with that id holding one path per shape
+ * (ids `<id>~fx<n>`). Groups without effects of their own keep their structure. Cached per node.
+ */
+declare function expandVectorAppearance(node: VectorNode): VectorNode;
+/** Every node of a list expanded (the same array when nothing in it is live). */
+declare function expandVectorAppearances(nodes: readonly VectorNode[]): VectorNode[];
+/**
+ * Reads effects from untrusted data (JSON, agent input): unknown types and malformed entries are
+ * dropped, parameters normalized, ids made unique.
+ */
+declare function sanitizeVectorEffects(value: unknown): VectorEffect[];
+/**
+ * Effect parameters carried through a linear map baked into a node's geometry (scaling or
+ * flipping it): offsets and positions move with it, angles turn the other way when it mirrors.
+ * Lengths such as sizes and radii are kept, like stroke widths.
+ */
+declare function transformVectorEffects(effects: readonly VectorEffect[], m: AffineMatrix, node?: VectorNode): VectorEffect[];
+/**
+ * The live groups (live booleans and groups with effects) being edited: those in `ids` and those
+ * holding a node in `ids`. Their children are hit and outlined as stored instead of as drawn, so
+ * each operand can be picked (figcraft `crates/engine/src/booleans.rs`, `result_outline`).
+ */
+declare function vectorEnteredGroups(nodes: readonly VectorNode[], ids: readonly string[]): Set<string>;
+
+/** A map of the plane (document or node space). */
+type VectorPointMap = (p: Vec2) => Vec2;
+/** Every anchor and handle of `subpaths` through `f` (no subdivision). */
+declare function mapVectorPoints(subpaths: readonly VectorSubpath[], f: VectorPointMap): VectorSubpath[];
+interface MapVectorSubpathsOptions {
+    /** Refit runs of split pieces with fewer cubics where they stay within the tolerance (default true). */
+    refit?: boolean;
+}
+/**
+ * `subpaths` through a smooth, possibly non-linear map `f`: each segment is split in halves until
+ * its mapped control points follow the mapped curve within `tolerance` (at most 64 pieces a
+ * segment, fewer for huge paths), then refitted with fewer cubics where possible. A straight
+ * segment whose image is straight stays a straight segment; anchors keep their types and live
+ * corners, and the anchors added are smooth.
+ */
+declare function mapVectorSubpaths(subpaths: readonly VectorSubpath[], f: VectorPointMap, tolerance?: number, options?: MapVectorSubpathsOptions): VectorSubpath[];
+/** `mapVectorSubpaths` for Bézier commands (live corners are not involved). */
+declare function mapBezierPath(path: BezierPathInput, f: VectorPointMap, tolerance?: number, options?: MapVectorSubpathsOptions): BezierPath;
+
+/**
+ * Free Distort, perspective and skew: the selection box's corners or sides dragged, and nodes sent
+ * through a map of document space while each keeps its own (rigid) transform.
+ *
+ * Ported from ArtCraft (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
+ * THIRD_PARTY_NOTICES.md): vectorcraft `crates/tools/src/xform/free.rs` (`distort_quad`: a corner
+ * moved freely, or with its partner mirrored along the dominant axis for perspective, and a side's
+ * two corners moved together; `shear_for_side`: a side handle shears about the opposite side, or
+ * the centre with Alt).
+ */
+
+/** Default tolerance (document units) of Free Distort's adaptive path mapping. */
+declare const VECTOR_DISTORT_TOLERANCE = 0.05;
+/** How dragging a selection box handle distorts it: each corner freely, or in symmetric perspective. */
+type VectorDistortMode = 'distort' | 'perspective';
+/** A box's corners clockwise from the top left. */
+declare const vectorBoxCorners: (b: VectorBounds) => Vec2[];
+/**
+ * The quad (clockwise from the top left) box `b` becomes when handle `handle` is dragged by `d`: a
+ * corner moves by `d` (`distort`), or along the drag's dominant axis with the corner beside it on
+ * that side moving the opposite way (`perspective`); a side moves both its corners.
+ */
+declare function vectorDistortQuad(b: VectorBounds, handle: VectorTransformHandle, d: Vec2, mode?: VectorDistortMode): Vec2[];
+/**
+ * The skew for dragging side `handle` of box `b` by `d`: along that side, about the opposite side
+ * (or the centre, `fromCenter`). Corners give the identity.
+ */
+declare function vectorShearForSide(b: VectorBounds, handle: VectorTransformHandle, d: Vec2, fromCenter?: boolean): AffineMatrix;
+/**
+ * A skew by `ax` degrees horizontally (vertical lines lean right for positive angles: x' = x + tan(ax)·y)
+ * and `ay` degrees vertically (y' = y + tan(ay)·x), about `origin`.
+ */
+declare function vectorSkewMatrix(ax: number, ay: number, origin?: Vec2): AffineMatrix;
+/**
+ * A node sent through `f`, a map of the space `parentToDoc` maps its parent to (the document):
+ * every anchor and handle is mapped in the node's own space, adaptively so curves stay within
+ * `tolerance`, and the node keeps its rigid `transform`. Gradients in the node's space have their
+ * handles mapped (bounding-box ones follow the new bounds), envelope meshes and a blend's spine
+ * are mapped too; stroke widths, live corner radii and effect parameters are kept.
+ */
+declare function distortVectorNode<T extends VectorNode>(node: T, parentToDoc: AffineMatrix, f: VectorPointMap, tolerance?: number): T;
+
 /**
  * What a guide line shows: `align` lines run from a target through the snapped point or box,
  * `construction` lines from where a drawn point leaves, `spacing` marks equal gaps and `size`
@@ -1524,6 +1805,8 @@ interface VectorEditorOptions {
     createId?: () => string;
     /** Called after the document changes (edits, undo, redo, load). */
     onChange?: (document: VectorDocument) => void;
+    /** Start in Free Distort mode (see `setFreeDistort`). */
+    freeDistort?: boolean;
 }
 /** A pointer event as the controller needs it. Positions are in screen pixels relative to the canvas. */
 interface VectorPointerInput extends VectorModifiers {
@@ -1595,6 +1878,11 @@ interface VectorHover {
     strokeSpot?: VectorStrokeSpot;
     /** A part of the gradient annotator (gradient tool). */
     gradient?: VectorGradientPart;
+    /** A control point of the selected envelope's mesh (`index`), or a spot inside it (`index` null): Envelope tool. */
+    envelope?: {
+        nodeId: string;
+        index: number | null;
+    };
 }
 /** The drag in progress, for overlays and status text. */
 type VectorInteraction = {
@@ -1656,6 +1944,18 @@ type VectorInteraction = {
     part: 'create' | VectorGradientPart['kind'];
     handle?: VectorGradientHandle;
     removing?: boolean;
+}
+/** Free Distort: the selection box's corners as dragged so far (document space, clockwise from the top left). */
+ | {
+    type: 'distort';
+    mode: VectorDistortMode | 'skew';
+    corners: Vec2[];
+}
+/** Envelope tool: a mesh point (`index`) or the surface (`index` null) being dragged. */
+ | {
+    type: 'envelope';
+    nodeId: string;
+    index: number | null;
 } | {
     type: 'pan';
 };
@@ -1706,6 +2006,12 @@ interface VectorEditorState {
         target: VectorGradientTarget;
         stop: number | null;
     };
+    /**
+     * Free Distort mode of the selection box: dragging a corner distorts in perspective (each corner
+     * on its own; Shift+Alt+Mod: symmetric perspective), a side moves its two corners, and Mod-dragging
+     * a side skews along it (Alt: about the centre).
+     */
+    freeDistort: boolean;
     canUndo: boolean;
     canRedo: boolean;
     undoLabel: string;
@@ -1911,6 +2217,19 @@ interface VectorSelectionBoxGeometry {
     corners: Vec2[];
 }
 declare function getVectorSelectionBoxGeometry(frame: VectorSelectionFrame, viewport: VectorViewport): VectorSelectionBoxGeometry;
+/**
+ * The node the Envelope tool edits: the one selected node with an enabled envelope, with the
+ * envelope's mesh and box (node space) and the node → document matrix. Null otherwise.
+ */
+declare function getVectorEnvelopeTarget(doc: VectorDocument, selection: readonly string[]): {
+    node: VectorNode;
+    frame: {
+        effectId: string;
+        bounds: VectorBounds;
+        mesh: VectorWarpMesh;
+    };
+    world: AffineMatrix;
+} | null;
 /** The resize cursor for a handle of a box rotated by `angle` degrees. */
 declare function vectorResizeCursor(handle: VectorTransformHandle, angle?: number): string;
 declare function vectorToolLabel(tool: VectorTool): string;
@@ -1962,6 +2281,7 @@ declare class VectorEditorController {
     /** Options new blends get (the toolbars edit them along with the selected blend's). */
     private blendDefaults;
     private gradientEdit;
+    private freeDistort;
     /** What the highlight shows, to skip notifying when the pointer stays over the same face. */
     private builderHoverKey;
     private readonly createId;
@@ -2268,6 +2588,83 @@ declare class VectorEditorController {
     private selectedRoots;
     /** `m`, given in a frame rotated by `angle`, as a document-space matrix. */
     private inFrame;
+    /** The selection frame's corners in document space, clockwise from the top left. */
+    private frameCorners;
+    /** `doc` with nodes `ids` sent through `f` (a map of document space), each in its own space (see `distortVectorNode`). */
+    private distorted;
+    /**
+     * Free Distort mode of the selection box (`state.freeDistort`): dragging a corner distorts the
+     * selection in perspective, each corner on its own (Shift+Alt+Mod: symmetric perspective, the
+     * corner beside it moving the other way); dragging a side moves its two corners; Mod-dragging a
+     * side skews along it (Alt: about the centre). Each drag is one undo step.
+     */
+    setFreeDistort(on: boolean): void;
+    /**
+     * Distorts the selected (or given) nodes so the corners of their selection box (clockwise from
+     * the top left, in the box's own rotation) land on `corners` (document space): a projective map,
+     * so straight lines stay straight. Curves are followed within `tolerance` (document units).
+     * One undo step.
+     */
+    distort(corners: readonly Vec2[], options?: {
+        ids?: readonly string[];
+        tolerance?: number;
+    }): VectorActionResult;
+    /**
+     * Skews the selected (or given) nodes along the selection box's own axes by `ax` degrees
+     * horizontally (x' = x + tan(ax)·y: vertical lines lean right for positive angles) and `ay`
+     * vertically, about `origin` (default: the box centre, document space). One undo step.
+     */
+    skew(ax: number, ay?: number, options?: {
+        ids?: readonly string[];
+        origin?: Vec2;
+    }): VectorActionResult;
+    /** A selection box handle dragged in Free Distort mode. */
+    private moveDistort;
+    /** Selected (or given) roots that can carry an envelope. */
+    private envelopeTargets;
+    /** Envelope parameters for `node` after `patch`: a preset switched to a mesh becomes the mesh it stood for. */
+    private envelopeParams;
+    /**
+     * Gives the selected (or given) nodes an envelope distortion, or changes the one they have: a
+     * warp preset (`style` with `bend`, `horizontal` and `vertical` in percent and `orientation`) or
+     * a mesh (`style: 'mesh'` with `rows` and `columns`, and optionally its `mesh` points). The
+     * envelope stays live (an `envelope` effect: edit it with the Envelope tool, Expand Appearance
+     * bakes it). One undo step (with `merge`, consecutive changes fold into one, as a slider drag
+     * should). Returns the envelope of each node.
+     */
+    envelope(params?: Partial<VectorEnvelopeParams>, options?: {
+        ids?: readonly string[];
+        merge?: boolean;
+    }): {
+        nodeId: string;
+        effectId: string;
+    }[];
+    /**
+     * Make with Top Object: the topmost selected object's outline (a closed path) becomes the envelope
+     * of the other selected objects (grouped when there are several; they must share a parent), as a
+     * mesh of `columns × rows` patches whose border follows the outline. The top object is used up.
+     * One undo step; returns the id of the enveloped node.
+     */
+    makeEnvelopeWithTopObject(options?: {
+        ids?: readonly string[];
+        rows?: number;
+        columns?: number;
+    }): VectorActionResult & {
+        nodeId?: string;
+    };
+    /**
+     * Release: the selected (or given) nodes lose their envelope, and its shape (the mesh's border)
+     * comes back as a path above each of them. One undo step; returns the new paths' ids.
+     */
+    releaseEnvelope(options?: {
+        ids?: readonly string[];
+    }): string[];
+    /** The selected node the Envelope tool edits, with its mesh (node space) and node → document matrix. */
+    private envelopeTarget;
+    /** The envelope mesh point under `screen` (handles first), or a spot inside the mesh. */
+    private hitEnvelope;
+    private downEnvelope;
+    private moveEnvelope;
     /** Applies a matrix to the selected (or given) nodes as one undo step. */
     transform(matrix: AffineMatrix, options?: {
         ids?: readonly string[];
@@ -2657,153 +3054,6 @@ declare function scaleFor(handle: VectorTransformHandle, b: VectorBounds, p: Vec
     origin: Vec2;
 };
 
-/**
- * Live appearance: path effect stacks and live boolean groups, evaluated on demand while the
- * stored anchors and children stay editable.
- *
- * `expandVectorAppearance` is the one place the effected geometry is made (cached per node
- * object, so an edit recomputes only the nodes it replaced). Rendering, hit-testing, bounds,
- * snapping, booleans, the Pathfinder, the Shape Builder and SVG export all read it, the way they
- * read live corners through `subpathsToBezier`; Expand Appearance stores it.
- *
- * Stacking follows After Effects' shape layers (effectcraft `crates/render/src/shapes.rs`): an
- * effect acts on every path above it — the node's own outline, or for a group every path of its
- * children (nested groups included, as drawn by their own effects) — in the order of the stack,
- * and effects placed after a repeater act on its copies. The result paints with the style of the
- * path each shape came from; Merge Paths and live booleans paint with the bottom one's.
- *
- * Live booleans fold their operands bottom to top, each combined with the result below it by its
- * own operation or the group's, and every prefix of the fold is cached under a rolling hash of the
- * operands it covers, so editing one operand recombines only the operands from it up; the cache
- * drops its least recently used half when full. Live groups are hit by their result except while
- * they are being edited (`vectorEnteredGroups`).
- *
- * Ported from ArtCraft (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
- * THIRD_PARTY_NOTICES.md): the stacking rule of effectcraft `crates/render/src/shapes.rs`
- * (`collect()`); figcraft `crates/render/src/boolean.rs` (`fold_cached`, `PathCache`) and
- * `crates/engine/src/booleans.rs` (`operand_op`, `result_outline`); and the live-object model of
- * vectorcraft `crates/doc/src/live.rs` (`expand_live`, `expanded_group`, `subtree_has_live`).
- */
-
-/** One shape of a node's appearance: a path in the node's own space, painted in `source`'s style. */
-interface VectorAppearanceShape {
-    /** The path whose style paints it. */
-    source: VectorPathNode;
-    path: BezierPath;
-    /** Opacity factor relative to the node (its own opacity not included). */
-    opacity: number;
-    /** Draw-order key (compared element by element). */
-    order: number[];
-}
-/** Default parameters of each effect type. */
-declare const VECTOR_EFFECT_DEFAULTS: {
-    readonly [K in VectorEffectType]: VectorEffectParamsMap[K];
-};
-declare const VECTOR_EFFECT_LABELS: Record<VectorEffectType, string>;
-/** How a panel edits one effect parameter. */
-type VectorEffectParamSpec = {
-    key: string;
-    label: string;
-    kind: 'number';
-    min?: number;
-    max?: number;
-    step: number;
-    slider?: boolean;
-} | {
-    key: string;
-    label: string;
-    kind: 'vec2';
-    step: number;
-} | {
-    key: string;
-    label: string;
-    kind: 'boolean';
-} | {
-    key: string;
-    label: string;
-    kind: 'select';
-    options: {
-        value: string;
-        label: string;
-    }[];
-};
-/** The editable parameters of each effect type, in panel order. */
-declare const VECTOR_EFFECT_PARAM_SPECS: Record<VectorEffectType, VectorEffectParamSpec[]>;
-/**
- * Effect parameters with defaults filled in and invalid values dropped (unknown keys go too).
- * Returns null for an unknown type.
- */
-declare function normalizeVectorEffectParams<K extends VectorEffectType>(type: K, params: Record<string, unknown> | null | undefined, base?: VectorEffectParamsMap[K]): VectorEffectParamsMap[K] | null;
-/** A new effect of `type` (defaults merged with `params`), or null for an unknown type. */
-declare function createVectorEffect<K extends VectorEffectType>(type: K, id: string, params?: Partial<VectorEffectParamsMap[K]> | Record<string, unknown>): Extract<VectorEffect, {
-    type: K;
-}> | null;
-/** The node's effects that take part (enabled, of a known type). */
-declare function activeVectorEffects(node: VectorNode): VectorEffect[];
-/** Whether the node itself draws differently from its stored geometry (effects or a live boolean). */
-declare function hasOwnVectorAppearance(node: VectorNode): boolean;
-/** Whether the node or anything inside it has a live appearance. */
-declare function hasVectorAppearance(node: VectorNode): boolean;
-/** A live boolean group (its children are operands). */
-declare function isVectorLiveBoolean(node: VectorNode | null | undefined): node is VectorGroupNode & {
-    liveBoolean: VectorBooleanOperation;
-};
-/** How operand `child` of a live boolean group combines with the operands below it. */
-declare function vectorOperandOperation(group: VectorGroupNode, child: VectorNode): VectorBooleanOperation;
-/** How many boolean steps (one operand combined with the result below it) live booleans have computed: what a cache miss costs. */
-declare function vectorLiveBooleanSteps(): number;
-/** Empties the live boolean prefix cache. */
-declare function clearVectorLiveBooleanCache(): void;
-/** One operand of a live boolean: its outline (group space), fill rule and operation (unused for the bottom one). */
-interface VectorBooleanOperand {
-    path: BezierPath;
-    fillRule: VectorFillRule;
-    operation: VectorBooleanOperation;
-}
-/**
- * The result of folding `operands` bottom to top, reusing the longest cached prefix: only the
- * operands above it are combined. Invalid geometry gives an empty path.
- */
-declare function foldVectorBooleanOperands(operands: readonly VectorBooleanOperand[]): BezierPath;
-/** Applies an effect stack to shapes, top to bottom (disabled effects skipped). */
-declare function applyVectorEffects(shapes: readonly VectorAppearanceShape[], effects: readonly VectorEffect[] | null | undefined): VectorAppearanceShape[];
-/**
- * What a node draws as: shapes in its own space (its `transform` and opacity not applied),
- * bottom to top, with its effects and those of everything inside it applied. Cached per node
- * object.
- */
-declare function vectorAppearanceShapes(node: VectorNode): VectorAppearanceShape[];
-/** Everything a node draws as one path in its own space (live corners cut, effects applied). */
-declare function vectorAppearanceOutline(node: VectorNode): BezierPath;
-/** What a node draws as, one plain path per shape (ids `<id>~fx<n>`, opacity relative to the node). */
-declare function vectorAppearanceNodes(node: VectorNode): VectorPathNode[];
-/**
- * The node as plain geometry: path effects and live booleans evaluated into paths (the node
- * itself when nothing inside it is live). A path keeps its id when it draws as one shape;
- * otherwise, like any live group, it becomes a group with that id holding one path per shape
- * (ids `<id>~fx<n>`). Groups without effects of their own keep their structure. Cached per node.
- */
-declare function expandVectorAppearance(node: VectorNode): VectorNode;
-/** Every node of a list expanded (the same array when nothing in it is live). */
-declare function expandVectorAppearances(nodes: readonly VectorNode[]): VectorNode[];
-/**
- * Reads effects from untrusted data (JSON, agent input): unknown types and malformed entries are
- * dropped, parameters normalized, ids made unique.
- */
-declare function sanitizeVectorEffects(value: unknown): VectorEffect[];
-/**
- * Effect parameters carried through a linear map baked into a node's geometry (scaling or
- * flipping it): offsets and positions move with it, angles turn the other way when it mirrors.
- * Lengths such as sizes and radii are kept, like stroke widths.
- */
-declare function transformVectorEffects(effects: readonly VectorEffect[], m: AffineMatrix): VectorEffect[];
-/**
- * The live groups (live booleans and groups with effects) being edited: those in `ids` and those
- * holding a node in `ids`. Their children are hit and outlined as stored instead of as drawn, so
- * each operand can be picked (figcraft `crates/engine/src/booleans.rs`, `result_outline`).
- */
-declare function vectorEnteredGroups(nodes: readonly VectorNode[], ids: readonly string[]): Set<string>;
-
 interface VectorRenderPath {
     kind: 'path';
     id: string;
@@ -2930,7 +3180,43 @@ interface VectorOverlayRenderData {
         transform: string;
         corners: Vec2[];
         handles: VectorSelectionBoxGeometry['handles'];
+        freeDistort: boolean;
     }) | null;
+    /**
+     * A Free Distort drag (screen space): the quad the selection box's corners make so far (`d`,
+     * closed path data) and its corners clockwise from the top left. The box is hidden meanwhile.
+     */
+    distort: {
+        mode: 'distort' | 'perspective' | 'skew';
+        d: string;
+        corners: Vec2[];
+    } | null;
+    /**
+     * The Envelope tool's mesh of the selected envelope (screen space): `grid` is the grid lines as
+     * path data, `anchors` the points where they cross and `handles` the handles along them, each
+     * with the anchor it belongs to (`index` is the point's index in the mesh). Draw anchors as
+     * squares and handles as dots joined to their anchors.
+     */
+    envelope: {
+        nodeId: string;
+        grid: string;
+        anchors: {
+            index: number;
+            x: number;
+            y: number;
+            hovered: boolean;
+            active: boolean;
+        }[];
+        handles: {
+            index: number;
+            x: number;
+            y: number;
+            anchorX: number;
+            anchorY: number;
+            hovered: boolean;
+            active: boolean;
+        }[];
+    } | null;
     anchors: VectorRenderAnchor[];
     handles: VectorRenderHandle[];
     /** Marquee rectangle, screen space. */
@@ -3086,6 +3372,31 @@ declare function getVectorSceneRenderData(state: Pick<VectorEditorState, 'docume
 declare function getVectorEnteredGroups(state: Pick<VectorEditorState, 'document' | 'selection' | 'editingId'>): Set<string>;
 /** The editing overlay in screen pixels. Render it on top of the scene, untransformed. */
 declare function getVectorOverlayRenderData(state: VectorEditorState): VectorOverlayRenderData;
+/** Warp choices of an envelope: the fifteen presets, then Mesh. */
+declare const VECTOR_ENVELOPE_STYLE_OPTIONS: readonly {
+    value: VectorEnvelopeParams['style'];
+    label: string;
+}[];
+/** What a Distort / Envelope panel shows for the selection. */
+interface VectorEnvelopePanelData {
+    /** The one selected node, or null when several are selected. */
+    nodeId: string | null;
+    count: number;
+    /** The selected node's envelope (the first one in its stack), if any. */
+    envelope: {
+        effectId: string;
+        enabled: boolean;
+        params: VectorEnvelopeParams;
+    } | null;
+    /** Some selected node can take an envelope (Make with Warp / Mesh). */
+    canMake: boolean;
+    /** Make with Top Object: several objects selected and the topmost is a closed path. */
+    canMakeWithTopObject: boolean;
+    /** Some selected node has an envelope (Release, Expand). */
+    canRelease: boolean;
+}
+/** The Distort / Envelope panel of the selection, or null when nothing is selected. */
+declare function getVectorEnvelopePanel(state: Pick<VectorEditorState, 'document' | 'selection'>): VectorEnvelopePanelData | null;
 /** What the Blend controls of a toolbar or style panel show. */
 interface VectorBlendControls {
     /** Ids of the selected blends (a selected key counts as its blend). */
@@ -3290,6 +3601,7 @@ interface VectorEffectsPanelItem {
     label: string;
     enabled: boolean;
     params: Record<string, unknown>;
+    /** The parameters to edit (none for an envelope: `getVectorEnvelopePanel` and the Envelope panels edit it). */
     specs: readonly VectorEffectParamSpec[];
 }
 /** What an Effects panel shows for the selection. */
@@ -4149,4 +4461,162 @@ declare function vectorStrokeGradientDefs(g: VectorGradient, id: string, node: V
     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 };
+/**
+ * Perspective (projective) maps between quadrilaterals: what Free Distort needs. Pure maths;
+ * degenerate or non-finite quads give `null` instead of NaNs.
+ *
+ * Ported from ArtCraft (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
+ * THIRD_PARTY_NOTICES.md): pdfcraft `crates/geom/src/perspective.rs` (`Homography::from_points`,
+ * `Homography::apply`, `solve8`, `order_quad`).
+ */
+
+/** A 3×3 projective map, row-major, normalised so that the last entry is 1. */
+type VectorHomography = readonly [number, number, number, number, number, number, number, number, number];
+/**
+ * Gaussian elimination with partial pivoting on an 8×8 system (the 9th column of each row is the
+ * right-hand side). Null when the system is singular.
+ */
+declare function solve8(rows: readonly (readonly number[])[]): number[] | null;
+/** The image of `p`, or null where the map sends it to infinity. */
+declare function applyVectorHomography(h: VectorHomography, p: Vec2): Vec2 | null;
+/**
+ * The projective map that takes each of `from` to the point at the same index of `to`. Null when
+ * three of either set are collinear or a coordinate is not finite.
+ */
+declare function vectorHomography(from: readonly Vec2[], to: readonly Vec2[]): VectorHomography | null;
+/**
+ * Whether `h` maps the whole convex quad `quad` without sending any of it through infinity (the
+ * denominator keeps one sign over it): what a usable distortion needs.
+ */
+declare function vectorHomographyKeepsQuad(h: VectorHomography, quad: readonly Vec2[]): boolean;
+/**
+ * The four corners in reading order for a y-down space: top-left, top-right, bottom-right,
+ * bottom-left, whatever order they come in. Null unless they form a convex quadrilateral with a
+ * non-negligible area.
+ */
+declare function orderVectorQuad(points: readonly Vec2[]): Vec2[] | null;
+
+/**
+ * Warp geometry for envelope distortion: preset warp styles and editable Bézier meshes, both
+ * forward maps from a source box (the bounds of the paths an envelope bends) to the node's space.
+ *
+ * - **Presets** (`VectorWarpStyle`, Photoshop's fifteen with bend and horizontal / vertical
+ *   distortion in percent): each is one bicubic Bézier patch whose 4 × 4 control grid follows the
+ *   bend (`vectorWarpPresetGrid`). Every preset is the identity at bend 0 and continuous in it.
+ * - **Meshes** (`VectorWarpMesh`): a grid of bicubic patches. Splitting a mesh (`splitVectorMeshU`
+ *   / `V`) is an exact de Casteljau subdivision, so it never changes the shape, and a preset turns
+ *   into an editable mesh of any size exactly.
+ *
+ * Ported from ArtCraft (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
+ * THIRD_PARTY_NOTICES.md): photocraft `crates/geom/src/warp.rs` (`WarpStyle`, `StyleWarp`,
+ * `rest_grid`, `edge_arc`, `arc_grid`, `blend_rows`, `preset_grid`, `bernstein`, `split_cubic`,
+ * `BERN_INV`, and `BezierMesh`: `identity`, `fit`, `eval`, `split_u`, `split_v`, `remove_split_u`,
+ * `transpose`, `map_points`, `param_at`, `pull`, `smooth_lines`, `drag_point`, `control_bounds`;
+ * `Warp::map` and `Warp::to_mesh`). The Coons patch of `vectorMeshFromOutline` is our own.
+ */
+
+/** The fifteen presets in Photoshop's menu order. */
+declare const VECTOR_WARP_STYLES: readonly VectorWarpStyle[];
+declare const VECTOR_WARP_STYLE_LABELS: Readonly<Record<VectorWarpStyle, string>>;
+/**
+ * A preset as a Bézier control grid (rows of `[x, y]` in box units, y down). `b`, `hd`, `vd` are
+ * the bend and the horizontal / vertical distortion as fractions (−1…1); `aspect` is the box's
+ * height over its width. The arc family stays circular in pixels, the other offsets scale with the
+ * box, and a vertical warp is the horizontal one with the axes (and distortions) swapped.
+ */
+declare function vectorWarpPresetGrid(style: VectorWarpStyle, b: number, hd: number, vd: number, vertical: boolean, aspect: number): [number, number][][];
+/** A preset warp's settings (bend and distortions in percent, −100…100). */
+interface VectorWarpPreset {
+    style: VectorWarpStyle;
+    bend: number;
+    horizontal?: number;
+    vertical?: number;
+    /** Bend along the vertical axis. */
+    orientation?: 'horizontal' | 'vertical';
+}
+/**
+ * A preset as one Bézier patch over `bounds` (points in the bounds' space), or null when it
+ * changes nothing (an unknown style, all-zero amounts, or an empty box).
+ */
+declare function vectorWarpPresetMesh(preset: VectorWarpPreset, bounds: VectorBounds): VectorWarpMesh | null;
+/** Control points per row. */
+declare const vectorMeshColumns: (m: VectorWarpMesh) => number;
+/** Control point rows. */
+declare const vectorMeshRows: (m: VectorWarpMesh) => number;
+/** Whether a mesh is well formed: knots from 0 to 1 increasing, the right number of finite points. */
+declare function isValidVectorMesh(m: unknown): m is VectorWarpMesh;
+/** Fits a mesh with patch boundaries `us` / `vs` to the map `f` (box fractions → output) by interpolating it at each patch's thirds. Exact for bicubic maps (affine maps included). */
+declare function fitVectorMesh(f: (s: number, t: number) => Vec2, us: readonly number[], vs: readonly number[]): VectorWarpMesh;
+/** The identity mesh over `bounds` with `columns × rows` patches. */
+declare function vectorIdentityMesh(bounds: VectorBounds, columns?: number, rows?: number): VectorWarpMesh;
+/** The surface at box fractions `(s, t)`. */
+declare function evalVectorMesh(m: VectorWarpMesh, s: number, t: number): Vec2;
+/** The mesh with the patch column holding `s` split at `s` (exact). Null when `s` is on or too close to a boundary. */
+declare function splitVectorMeshU(m: VectorWarpMesh, s: number): VectorWarpMesh | null;
+/** The mesh with the patch row holding `t` split at `t` (exact). */
+declare function splitVectorMeshV(m: VectorWarpMesh, t: number): VectorWarpMesh | null;
+/**
+ * The mesh without interior vertical boundary `k` (1 … us.length − 2), its two patch columns
+ * merged: exact when they came from an unedited split; otherwise the outer control points stay and
+ * the inner handles are extrapolated.
+ */
+declare function removeVectorMeshSplitU(m: VectorWarpMesh, k: number): VectorWarpMesh | null;
+/** Removes interior horizontal boundary `k`. */
+declare function removeVectorMeshSplitV(m: VectorWarpMesh, k: number): VectorWarpMesh | null;
+/** Every control point through `f` (exact for affine maps). */
+declare function mapVectorMeshPoints(m: VectorWarpMesh, f: (p: Vec2) => Vec2): VectorWarpMesh;
+/**
+ * The mesh with `columns × rows` patches over the same surface: split exactly when its knots are
+ * a subset of the new even ones (a one-patch mesh always is), otherwise refitted.
+ */
+declare function resizeVectorMesh(m: VectorWarpMesh, columns: number, rows: number): VectorWarpMesh;
+/** Bounding box of the control points (the surface lies inside it). */
+declare function vectorMeshControlBounds(m: VectorWarpMesh): VectorBounds;
+/** Box fractions `(s, t)` whose surface point is nearest `p` (a coarse search, then Newton steps). */
+declare function vectorMeshParamAt(m: VectorWarpMesh, p: Vec2): {
+    s: number;
+    t: number;
+    distance: number;
+};
+/**
+ * `base` with control point `index` dragged by `d`, keeping the surface smooth across the grid
+ * lines: an anchor moves with the eight points around it as one block; a handle moves with the two
+ * points beside it across its line, and the handle opposite it on the same anchor turns the other
+ * way (with its two neighbours), so the line keeps passing straight through the anchor. An inner
+ * point of a patch moves alone.
+ */
+declare function dragVectorMeshPoint(base: VectorWarpMesh, index: number, d: Vec2): VectorWarpMesh;
+/**
+ * `base` with its surface point at box fractions `(s, t)` pulled by `d`, the way dragging inside a
+ * patch works: interior anchors within about two cells follow by a share of `d` that fades with
+ * distance (each with its block of handles, so grid lines stay smooth); the outer border stays
+ * pinned unless the grab is near it, and then it bows; the four corners never move. The grabbed
+ * patch's inner points (and, near the border, the border's handles) make up the rest, so the
+ * grabbed point lands exactly at its start + `d`.
+ */
+declare function pullVectorMesh(base: VectorWarpMesh, s: number, t: number, d: Vec2): VectorWarpMesh;
+/**
+ * A mesh whose border follows a closed outline (Illustrator's Make with Top Object): the outline is
+ * cut into four sides at the points nearest its bounding box's corners, and the interior is the
+ * Coons patch of those sides, fitted with `columns × rows` patches. Null for an open or degenerate
+ * outline.
+ */
+declare function vectorMeshFromOutline(sp: VectorSubpath, columns?: number, rows?: number): VectorWarpMesh | null;
+/** The mesh's border as one closed subpath (clockwise from the top-left corner): what Release gives back as the envelope's shape. */
+declare function vectorMeshOutline(m: VectorWarpMesh): VectorSubpath;
+/**
+ * The control points an editor shows: the anchors (where grid lines cross) and the handles along
+ * the grid lines, each with the anchor it belongs to. Points inside a patch are left out (drag
+ * inside a patch to pull the surface instead).
+ */
+declare function vectorMeshEditPoints(m: VectorWarpMesh): {
+    anchors: number[];
+    handles: {
+        index: number;
+        anchor: number;
+    }[];
+};
+/** The mesh's grid lines (patch borders) as cubics `[p0, p1, p2, p3]`. */
+declare function vectorMeshGridCurves(m: VectorWarpMesh): Vec2[][];
+
+export { type AddVectorNodeOptions, AffineMatrix, DEFAULT_VECTOR_BLEND_DISTANCE, DEFAULT_VECTOR_BLEND_STEPS, DEFAULT_VECTOR_PATH_EDIT, DEFAULT_VECTOR_SNAP, IDENTITY_MATRIX, KAPPA, LazyMouse, type MapVectorSubpathsOptions, type NearestSegment, type RecognizeInkOptions, SvgGradientDef, VECTOR_ARROWHEADS, VECTOR_ARROWHEAD_LABELS, VECTOR_BLEND_MAX_SMOOTH_STEPS, VECTOR_BLEND_MAX_STEPS, VECTOR_BLEND_SPACINGS, VECTOR_BLEND_SPACING_LABELS, VECTOR_BUILDER_HATCH_GAP, VECTOR_CLIPBOARD_TYPE, VECTOR_CONSTRUCTION_ANGLES, VECTOR_CORNER_KINDS, VECTOR_CORNER_KIND_LABELS, VECTOR_CORNER_WIDGET_INSET, VECTOR_DISTORT_TOLERANCE, VECTOR_EDIT_TOGGLES, VECTOR_EFFECT_DEFAULTS, VECTOR_EFFECT_LABELS, VECTOR_EFFECT_MENU, VECTOR_EFFECT_PARAM_SPECS, VECTOR_EFFECT_TYPES, VECTOR_ENVELOPE_STYLE_OPTIONS, VECTOR_FILL_GAP, VECTOR_GRADIENT_INTERPOLATIONS, VECTOR_GRADIENT_INTERPOLATION_LABELS, VECTOR_GRADIENT_MAX_PERIODS, VECTOR_GRADIENT_MIDPOINT_GAP, VECTOR_GRADIENT_MIN_STOPS, VECTOR_GRADIENT_OFF_BAR, VECTOR_GRADIENT_SPREADS, VECTOR_GRADIENT_SPREAD_LABELS, VECTOR_GRADIENT_STOP_GAP, VECTOR_GRADIENT_TYPES, VECTOR_GRADIENT_TYPE_LABELS, VECTOR_INK_MAX_CORNERS, VECTOR_MERGE_MODES, VECTOR_OVERLAY_THEME, VECTOR_PATHFINDER_ACTIONS, VECTOR_PATHFINDER_LABELS, VECTOR_PATHFINDER_OPERATIONS, VECTOR_PATH_ACTIONS, VECTOR_PENCIL_STRING_PX, VECTOR_PRESSURE_NOMINAL, VECTOR_ROTATE_HANDLE_OFFSET, VECTOR_STROKE_ALIGN_LABELS, VECTOR_STROKE_GRADIENT_MODES, VECTOR_STROKE_GRADIENT_MODE_LABELS, VECTOR_STYLE_KEYS, VECTOR_TOOLS, VECTOR_TOOL_GLYPHS, VECTOR_TOOL_SHORTCUTS, VECTOR_TRANSFORM_HANDLES, VECTOR_WARP_STYLES, VECTOR_WARP_STYLE_LABELS, VECTOR_WIDTH_PRESETS, VECTOR_WIDTH_PRESET_IDS, VECTOR_WIDTH_PROFILE_MAX_POINTS, VECTOR_WIDTH_PROFILE_MAX_SCALE, VECTOR_WIDTH_SAME_T, type VariableStrokeOptions, type Vec2, type VectorActionResult, type VectorAlign, type VectorAnchor, type VectorAnchorRef, type VectorAnchorType, type VectorAppearanceShape, type VectorArrange, type VectorArrowAlign, type VectorArrowhead, type VectorArrowheadShape, type VectorAverageAxis, type VectorBlend, type VectorBlendControls, type VectorBlendInput, type VectorBlendOptions, type VectorBlendRail, type VectorBlendSpacing, type VectorBlendStart, type VectorBooleanOperand, type VectorBooleanOperation, type VectorBounds, type VectorBuilderHit, type VectorBuilderLinePiece, type VectorBuilderPreview, type VectorBuilderReplacement, type VectorBuilderTouched, type VectorCommandOptions, type VectorCorner, type VectorCornerInfo, type VectorCornerKind, type VectorCornerWidget, type VectorDefaults, type VectorDistortMode, type VectorDistribute, type VectorDocument, VectorEditorController, type VectorEditorOptions, type VectorEditorState, type VectorEffect, type VectorEffectParamSpec, type VectorEffectParamsMap, type VectorEffectType, type VectorEffectsPanelData, type VectorEffectsPanelItem, type VectorEnvelopePanelData, type VectorEnvelopeParams, type VectorFillRule, type VectorGradient, type VectorGradientAnnotator, type VectorGradientEditorData, type VectorGradientHandle, type VectorGradientInterpolation, type VectorGradientPart, type VectorGradientPatch, type VectorGradientPoints, type VectorGradientRamp, type VectorGradientSpread, type VectorGradientStop, type VectorGradientSvgOptions, type VectorGradientTarget, type VectorGradientType, type VectorGradientUnits, type VectorGroupNode, type VectorGuideKind, type VectorGuideLabel, type VectorGuideLine, type VectorHandleRef, type VectorHitTestOptions, type VectorHomography, type VectorHover, type VectorInkShape, type VectorInteraction, type VectorKeyInput, type VectorLineCap, type VectorLineJoin, type VectorMatrix, type VectorMergeMode, type VectorModifiers, type VectorMorph, type VectorMorphContour, type VectorMorphCorrespondence, type VectorMorphOptions, type VectorNode, type VectorNodeListing, type VectorOverlayRenderData, type VectorPaint, type VectorPaintDef, type VectorPaintSvgOptions, type VectorPathAction, type VectorPathEditOptions, type VectorPathEntry, type VectorPathKeyframe, type VectorPathNode, type VectorPathfinderAction, type VectorPathfinderOperation, type VectorPathfinderPaint, type VectorPointMap, type VectorPointSnap, type VectorPointerInput, type VectorRectSnap, type VectorRenderAnchor, type VectorRenderCornerWidget, type VectorRenderGradientAnnotator, type VectorRenderGroup, type VectorRenderGuideLabel, type VectorRenderGuideLine, type VectorRenderHandle, type VectorRenderNode, type VectorRenderPath, type VectorRenderStrokeParts, type VectorRenderWidthPoint, type VectorRepeaterCopy, type VectorRgba, type VectorScaleSnap, type VectorSceneRenderData, type VectorSegmentRef, type VectorSelectionBoxGeometry, type VectorSelectionFrame, type VectorSelectionStyle, type VectorShapeBuilderFace, type VectorShapeBuilderMap, type VectorShapeBuilderPlan, type VectorShapeBuilderResult, type VectorShapeInput, type VectorSnapGuides, type VectorSnapKind, type VectorSnapLeave, type VectorSnapOptions, VectorSnapTargets, type VectorStrokeAlign, type VectorStrokeGradientMode, type VectorStrokeParts, type VectorStrokeSpot, type VectorStyle, type VectorSubpath, type VectorSvgExportOptions, type VectorSvgImportOptions, type VectorSvgPatternDef, type VectorTaperOptions, type VectorTool, type VectorTransformHandle, type VectorViewport, type VectorWarpMesh, type VectorWarpPreset, type VectorWarpStyle, type VectorWaveOptions, type VectorWidthHandle, type VectorWidthPoint, type VectorWidthPointEdit, type VectorWidthPointRef, type VectorWidthPreset, type VectorWidthPresetInfo, activeVectorEffects, addBuilderHit, applyMatrix, applyMatrixLinear, applyVectorBlendOptions, applyVectorCornersAttribute, applyVectorEffects, applyVectorGradientPatch, applyVectorGradientSpread, applyVectorHomography, arrowheadInset, arrowheadPath, arrowheadWeight, bendSegment, bezierToSubpaths, boundsFromPoints, boundsIntersect, clearVectorLiveBooleanCache, cloneAnchor, cloneSubpath, cloneVectorDocument, cloneVectorNode, collectPathNodes, constrainToLeave, convertAnchor, convertVectorGradient, cornerBisectorPoint, cornerRadiusChange, cornerSetback, correspondMorphContours, createVectorCommands, createVectorEffect, createVectorMorph, curvatureMoveAnchor, cutSubpathAt, dashIntervals, decomposeRigid, defaultVectorGradient, distortVectorNode, dragVectorMeshPoint, effectPathLength, effectPathVertexCount, effectiveStrokeAlign, ellipseSubpath, eraseFromFill, eraseFromOutline, eraserRegion, evalVectorMesh, evaluateVectorPathKeyframes, expandVectorAppearance, expandVectorAppearances, expandVectorBlend, expandVectorCorners, expandVectorCornersOf, expandVectorGradientSpread, expandVectorGradientStops, explicitVectorGradient, findVectorNode, fitCornerRadius, fitVectorMesh, foldVectorBooleanOperands, generateVectorBlendChildren, generateWidthProfile, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorBlendControls, getVectorCornerWidgets, getVectorEffectsPanel, getVectorEnteredGroups, getVectorEnvelopePanel, getVectorEnvelopeTarget, getVectorGradientAnnotator, getVectorGradientEditor, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVectorWidthHandles, getVisibleAnchors, getVisibleHandles, gradientMidpointRemap, hasExplicitGradientGeometry, hasOwnVectorAppearance, hasPaint, hasStrokeExtras, hasVectorAppearance, hasVectorCorners, hitTestVectorNode, hitTestVectorNodes, hitTestVectorStroke, hitVectorGradientAnnotator, inferAnchorType, insertAnchor, insertVectorGradientStop, insertWidthPoint, interpolateMorphContours, interpolateRigidMatrix, interpolateVectorColor, interpolateVectorPaint, interpolateVectorPaths, interpolateVectorStyle, interpolateWidthProfiles, invertMatrix, isCentredVectorGradient, isClosedBezierShape, isIdentityMatrix, isUniformWidthProfile, isValidVectorMesh, isVectorBlendGroup, isVectorGradient, isVectorLiveBoolean, isVectorTextTarget, joinSubpaths, knifePath, lineSubpath, locateVectorNode, mapBezierPath, mapVectorGradient, mapVectorMeshPoints, mapVectorPaint, mapVectorPoints, mapVectorSubpaths, matrixRotation, mergePaths, mirrorWidthProfile, morphContourToSubpath, morphPathsCross, moveAnchorHandle, moveVectorGradientHandle, moveVectorGradientStop, multiplyMatrices, nearestSegment, nearestStrokePosition, nextVectorCornerKind, nodeMatrix, normalizeVectorEffectParams, offsetPaths, orderVectorQuad, parseSvgTransform, parseVectorColor, parseVectorSvg, pathsCenter, patternAttrs, periodicVectorGradientStops, pinVectorGradient, planShapeBuilder, polygonSubpath, polylineBounds, pressureWidthProfile, puckerBloatPaths, pullVectorMesh, recognizeInkShape, rectSubpath, refineMorphContour, refreshVectorBlends, releaseVectorBlend, removeAnchorKeepingShape, removeAnchors, removeAnchorsKeepingShape, removeRedundantPoints, removeVectorGradientStop, removeVectorMeshSplitU, removeVectorMeshSplitV, removeWidthPoints, repeatPaths, resampleGradientStops, resizeVectorMesh, resolveVectorBlendOptions, reverseMorphContour, reverseSubpath, reverseVectorGradient, reverseWidthProfile, rotateMatrix, roundCornerPaths, roundSubpaths, samplePlainStops, samplePolyline, sampleVectorGradient, sampleVectorGradientAt, sampleVectorPaintDefAt, sanitizeVectorEffects, sanitizeVectorGradient, sanitizeWidthProfile, scaleFor, scaleMatrix, setAnchorCorner, setSubpathCorners, setVectorGradientVector, setWidthPoint, simplifyPolyline, smoothSubpath, solve8, sortedVectorGradientStops, spanVectorGradientStops, splitIntoFaces, splitSubpathAt, splitVectorMeshU, splitVectorMeshV, starSubpath, strokePositionPoint, strokeWidthProfileOf, subpathEnclosesArea, subpathPointAt, subpathSegment, subpathSegmentCount, subpathToMorphContour, subpathsToBezier, taperWaveFactor, toVectorKeyInput, toVectorModifiers, toVectorPointerInput, transformVectorEffects, transformVectorGradient, transformVectorNode, transformVectorPaint, translateAnchor, translateMatrix, trimIntervals, trimPaths, trimPathsIndividually, turnMorphContour, twistPaths, unionBounds, variableStrokeOutline, variableStrokeRings, vectorAppearanceNodes, vectorAppearanceOutline, vectorAppearanceShapes, vectorBlendColorDistance, vectorBlendKeyTargets, vectorBlendKeys, vectorBlendRail, vectorBlendRailAt, vectorBlendSpine, vectorBlendStepCount, vectorBoxCorners, vectorBoxMatrix, vectorBuilderErasedEdges, vectorCornerAt, vectorCorners, vectorCornersAttribute, vectorDiamondPath, vectorDistortQuad, vectorDocumentToSvg, vectorEffectInputBounds, vectorEffectInputPaths, vectorEnteredGroups, vectorEnvelopeFrame, vectorEnvelopeMap, vectorEnvelopeMesh, vectorFillMap, vectorGradientArea, vectorGradientAspect, vectorGradientBarPosition, vectorGradientFocalParam, vectorGradientHandles, vectorGradientMatrix, vectorGradientMidpointFromPosition, vectorGradientMidpointPosition, vectorGradientNeedsExpansion, vectorGradientParam, vectorGradientPoints, vectorGradientRamp, vectorGradientSvgDefs, vectorGradientTAt, vectorGradientTargetPath, vectorGradientUnitsMatrix, vectorHomography, vectorHomographyKeepsQuad, vectorIdentityMesh, vectorInkShapeName, vectorLiveBooleanSteps, vectorMeshColumns, vectorMeshControlBounds, vectorMeshEditPoints, vectorMeshFromOutline, vectorMeshGridCurves, vectorMeshOutline, vectorMeshParamAt, vectorMeshRows, vectorNodeBounds, vectorNodeEnvelope, vectorNodeRotation, vectorNodeToBezier, vectorOperandOperation, vectorPaintToHex, vectorPaintToSvg, vectorParentMatrix, vectorPathData, vectorPathEntries, vectorPathLocalBounds, vectorPathWorldBezier, vectorPathfinderShape, vectorRepeaterCopies, vectorResizeCursor, vectorResultStyle, vectorShapeBuilderHit, vectorShapeBuilderMap, vectorShearForSide, vectorSkewMatrix, vectorStrokeGradientDefs, vectorStrokeLineArea, vectorStrokeOutline, vectorStrokeOutlinePath, vectorStrokeParts, vectorStrokeReach, vectorStrokeSvgParts, vectorStrokeWidthGeometry, vectorToolLabel, vectorWarpPresetGrid, vectorWarpPresetMesh, vectorWorldMatrix, walkVectorNodes, widthProfileAt, widthProfileFromAttribute, widthProfileMaxScale, widthProfilePreset, widthProfilePresetId, widthProfileToAttribute, wigglePaths, zigzagPaths };