@pixerate/editor 0.34.0 → 0.36.0

package/dist/vector/index.d.ts

@@ -19,6 +19,22 @@ interface Vec2 {
  * - `symmetric`: handles stay on one line with equal lengths.
  */
 type VectorAnchorType = 'corner' | 'smooth' | 'symmetric';
+/**
+ * Live corner shapes: `round` (an arc tangent to both sides), `inverted` (an arc centred on
+ * the corner, cut into the shape) and `chamfer` (a straight bevel).
+ */
+type VectorCornerKind = 'round' | 'inverted' | 'chamfer';
+declare const VECTOR_CORNER_KINDS: readonly VectorCornerKind[];
+/**
+ * A live corner: drawn rounded (or cut) at render, hit-test, bounds, boolean, outline and export
+ * time while the stored anchor stays sharp. The radius shrinks to fit when the sides are short:
+ * the cut reaches at most halfway along each side.
+ */
+interface VectorCorner {
+    radius: number;
+    /** Default `round`. */
+    kind?: VectorCornerKind;
+}
 /**
  * One anchor of a subpath. Handles are absolute document positions; a missing (or `null`)
  * handle sits on the anchor, so a segment with no handles at either end is a straight line.
@@ -32,6 +48,8 @@ interface VectorAnchor {
     out?: Vec2 | null;
     /** Default `corner`. */
     type?: VectorAnchorType;
+    /** Live corner radius. Ignored on smooth / symmetric anchors and the ends of open subpaths. */
+    corner?: VectorCorner | null;
 }
 /** A chain of anchors joined by line or cubic Bézier segments. */
 interface VectorSubpath {
@@ -44,6 +62,19 @@ type VectorPaint = string | CanvasGradientDef | null;
 type VectorFillRule = 'nonzero' | 'evenodd';
 type VectorLineCap = 'butt' | 'round' | 'square';
 type VectorLineJoin = 'miter' | 'round' | 'bevel';
+/**
+ * Where the stroke sits on the outline: centred on it, inside the shape or outside it. Only
+ * shapes whose subpaths are all closed have an inside; open paths always stroke centred.
+ */
+type VectorStrokeAlign = 'center' | 'inside' | 'outside';
+/** Arrowheads and end markers for the ends of open paths. */
+type VectorArrowhead = 'triangle' | 'arrow' | 'open' | 'circle' | 'square' | 'bar';
+declare const VECTOR_ARROWHEADS: readonly VectorArrowhead[];
+/**
+ * `extend`: the head's tip sits past the end point and the path keeps its length; `tip`: the
+ * tip sits on the end point and the stroke is shortened under the head.
+ */
+type VectorArrowAlign = 'extend' | 'tip';
 /** Paint and stroke settings of a path. */
 interface VectorStyle {
     fill?: VectorPaint;
@@ -55,6 +86,18 @@ interface VectorStyle {
     strokeDasharray?: number[];
     /** Default `nonzero`. */
     fillRule?: VectorFillRule;
+    /** Default `center`. */
+    strokeAlign?: VectorStrokeAlign;
+    /** Head at the start of the first subpath when it is open, or none. */
+    startArrow?: VectorArrowhead | null;
+    /** Head at the end of the last subpath when it is open, or none. */
+    endArrow?: VectorArrowhead | null;
+    /** Default `extend`. */
+    arrowAlign?: VectorArrowAlign;
+    /** Size of the start head as a multiple of the stroke width (default 1: a head 4 widths long). */
+    startArrowScale?: number;
+    /** Size of the end head (default 1). */
+    endArrowScale?: number;
 }
 interface VectorNodeBase {
     id: string;
@@ -109,8 +152,12 @@ interface VectorAnchorRef {
 interface VectorHandleRef extends VectorAnchorRef {
     handle: 'in' | 'out';
 }
-/** Canvas tools. `direct` edits anchors and handles; the shape tools drag out a new shape. */
-type VectorTool = 'select' | 'direct' | 'pen' | 'pencil' | 'rect' | 'ellipse' | 'polygon' | 'star' | 'line';
+/**
+ * Canvas tools. `direct` edits anchors, handles and segments; the shape tools drag out a new
+ * shape; `scissors` cuts a path at a point, `knife` cuts filled shapes along a freehand stroke
+ * and `eraser` rubs out the area under one.
+ */
+type VectorTool = 'select' | 'direct' | 'pen' | 'pencil' | 'rect' | 'ellipse' | 'polygon' | 'star' | 'line' | 'scissors' | 'knife' | 'eraser';
 declare const VECTOR_TOOLS: readonly VectorTool[];
 /** Keyboard modifiers held during a pointer event. */
 interface VectorModifiers {
@@ -137,13 +184,23 @@ interface VectorDefaults extends VectorStyle {
     starPoints?: number;
     /** Inner radius of the star tool as a fraction of the outer one (default 0.5). */
     starInnerRatio?: number;
-    /** Corner radius of the rectangle tool (default 0). */
+    /** Live corner radius the rectangle, polygon and star tools give their corners (default 0). */
     cornerRadius?: number;
+    /** Corner kind of those tools (default `round`). */
+    cornerKind?: VectorCornerKind;
 }
 type VectorAlign = 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom';
 type VectorDistribute = 'horizontal' | 'vertical';
 type VectorBooleanOperation = 'union' | 'subtract' | 'intersect' | 'exclude';
 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';
+/** Identifies one segment of a path node: from anchor `segment` to the next. */
+interface VectorSegmentRef {
+    nodeId: string;
+    subpath: number;
+    segment: number;
+}
 
 /**
  * Vector path geometry: anchors and handles to Bézier paths and back, bounds, hit-testing,
@@ -161,8 +218,13 @@ declare function hasPaint(paint: VectorPaint | undefined): boolean;
 declare function subpathSegmentCount(sp: VectorSubpath): number;
 /** Control points of segment `i` of a subpath: 2 for a line, 4 for a cubic. */
 declare function subpathSegment(sp: VectorSubpath, i: number): Point[];
-/** Absolute `M` / `L` / `C` / `Z` commands of subpaths. */
-declare function subpathsToBezier(subpaths: readonly VectorSubpath[]): BezierPath;
+/**
+ * Absolute `M` / `L` / `C` / `Z` commands of subpaths, with live corners cut
+ * (`expandVectorCorners`). Pass `{ corners: false }` for the stored anchors as they are.
+ */
+declare function subpathsToBezier(subpaths: readonly VectorSubpath[], options?: {
+    corners?: boolean;
+}): BezierPath;
 /** The node's outline as Bézier commands. Groups have none. */
 declare function vectorNodeToBezier(node: VectorNode): BezierPath;
 /** SVG path data (`d`) of a path node or subpaths. */
@@ -204,10 +266,16 @@ declare function boundsIntersect(a: VectorBounds, b: VectorBounds): boolean;
 /** A box from two corners in any order. */
 declare function boundsFromPoints(a: Vec2, b: Vec2): VectorBounds;
 /**
- * Whether `p` hits a node: inside its fill (when it has one) or within half its stroke
- * width plus `tolerance` of its outline. A group is hit when any visible child is.
+ * 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.
  */
 declare function hitTestVectorNode(node: VectorNode, p: Vec2, tolerance?: number, parent?: AffineMatrix): 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;
 interface NearestSegment {
@@ -290,8 +358,11 @@ declare function removeAnchors(sp: VectorSubpath, indices: readonly number[]): V
 declare function reverseSubpath(sp: VectorSubpath): VectorSubpath;
 /** Handle length that makes a cubic approximate a quarter circle. */
 declare const KAPPA = 0.5522847498307936;
-/** A rectangle, optionally with rounded corners (clamped to half the shorter side). */
-declare function rectSubpath(b: VectorBounds, radius?: number): VectorSubpath;
+/**
+ * A rectangle. A `radius` becomes a live corner on each of its four anchors (drawn round, and
+ * clamped to half the shorter side, when the path is turned into curves).
+ */
+declare function rectSubpath(b: VectorBounds, radius?: number, kind?: VectorCornerKind): VectorSubpath;
 /** An ellipse inscribed in a box (four smooth anchors). */
 declare function ellipseSubpath(b: VectorBounds): VectorSubpath;
 /** A regular polygon inscribed in a box, first vertex at the top. */
@@ -303,14 +374,6 @@ declare function lineSubpath(a: Vec2, b: Vec2): VectorSubpath;
 /** Rounds every coordinate to `precision` decimals (stable JSON and SVG output). */
 declare function roundSubpaths(subpaths: readonly VectorSubpath[], precision?: number): VectorSubpath[];
 
-/**
- * SVG export and import for vector documents. Import is DOM-free (works in Node and
- * workers): it reads `<svg>`, `<g>`, `<path>`, `<rect>`, `<circle>`, `<ellipse>`, `<line>`,
- * `<polyline>`, `<polygon>`, linear / radial gradients, presentation attributes, `style`
- * declarations and `transform`s. Text, images, clip paths, masks, filters and `<use>` are
- * skipped.
- */
-
 interface VectorSvgExportOptions {
     /** Decimal places for coordinates (default 3). */
     precision?: number;
@@ -322,12 +385,43 @@ interface VectorSvgExportOptions {
     idPrefix?: string;
     /** Indent nested elements (default true). */
     pretty?: boolean;
+    /**
+     * How strokes with an inside / outside alignment or arrowheads are written: `clip` (default)
+     * as a double-width stroke clipped or masked by the shape plus filled heads, `outline` as
+     * one filled path of the area the stroke paints.
+     */
+    strokes?: 'clip' | 'outline';
 }
+/** `data-vector-corners`: the live corners of subpaths as `subpath.index:radius[:kind]`, space separated. */
+declare function vectorCornersAttribute(subpaths: readonly VectorSubpath[], precision?: number): string;
+/** Puts `data-vector-corners` back on subpaths (malformed entries are ignored). */
+declare function applyVectorCornersAttribute(subpaths: VectorSubpath[], value: string): VectorSubpath[];
 /** A paint as an SVG attribute value plus the gradient def it needs (if any). */
 declare function vectorPaintToSvg(paint: VectorPaint | undefined, gradientId: string): {
     value: string;
     gradient: SvgGradientDef | null;
 };
+/** The parts of an aligned or arrowed stroke (see `VectorRenderPath.strokeParts`). */
+interface VectorRenderStrokeParts {
+    align: VectorStrokeAlign;
+    /** The line the stroke follows (shortened under `tip`-aligned heads). */
+    d: string;
+    /** Width to draw it with: twice the stroke width when aligned, half of it being clipped away. */
+    width: number;
+    /**
+     * Inside: a `<clipPath id>` holding the shape (`d`, `clip-rule` = `fillRule`). Outside: a
+     * `<mask id>` in user space over `bounds`, white with the shape (`d`) in black.
+     */
+    clip: {
+        kind: 'clip' | 'mask';
+        id: string;
+        bounds: VectorBounds;
+    } | null;
+    /** Arrowhead outlines (fill with `stroke`, nonzero). */
+    heads: string[];
+}
+/** The stroke parts of a path whose stroke needs more than one element, in its own space (undefined otherwise). */
+declare function vectorStrokeSvgParts(node: VectorPathNode, clipId: string, precision?: number): VectorRenderStrokeParts | undefined;
 /** Serializes a vector document as a standalone SVG string. */
 declare function vectorDocumentToSvg(doc: VectorDocument, options?: VectorSvgExportOptions): string;
 interface VectorSvgImportOptions {
@@ -339,6 +433,64 @@ declare function parseSvgTransform(value: string | undefined): AffineMatrix;
 /** Parses SVG markup into a vector document. Throws when there is no `<svg>` element. */
 declare function parseVectorSvg(svg: string, options?: VectorSvgImportOptions): VectorDocument;
 
+/**
+ * A corner a live radius can cut: an anchor that is not smooth, where two sides (straight or
+ * curved) meet at an angle. Positions are in the path node's own space.
+ */
+interface VectorCornerInfo {
+    subpath: number;
+    index: number;
+    /** Where the sides meet. */
+    at: Vec2;
+    /** Unit directions the sides leave the corner in: towards the previous anchor, then the next one. */
+    u: Vec2;
+    v: Vec2;
+    /** The sides' lengths (along curves), in the same order. */
+    lu: number;
+    lv: number;
+    /** Cosine and sine of the angle between the sides. */
+    cos: number;
+    sin: number;
+    /** The angle between the sides in degrees (90 at a rectangle's corners). */
+    angle: number;
+    /** The largest radius that fits: its cut then reaches halfway along the shorter side. */
+    maxRadius: number;
+}
+/** The corner at anchor `index` of a subpath, or null when the anchor makes none (an open end, smooth, or straight on). */
+declare function vectorCornerAt(sp: VectorSubpath, index: number, subpath?: number): VectorCornerInfo | null;
+/** Every corner of the subpaths that a live radius can cut, in anchor order. */
+declare function vectorCorners(subpaths: readonly VectorSubpath[]): VectorCornerInfo[];
+/** How far from the corner a round cut of radius `r` meets each side: r / tan(angle / 2). */
+declare const cornerSetback: (c: Pick<VectorCornerInfo, "cos" | "sin">, r: number) => number;
+/** `radius` clamped to what the corner can draw (0 for negative or non-finite radii). */
+declare const fitCornerRadius: (c: Pick<VectorCornerInfo, "maxRadius">, radius: number) => number;
+/** The point `k` along the corner's bisector, measured in (u + v): a round cut of radius r is centred at k = r / sin. */
+declare const cornerBisectorPoint: (c: VectorCornerInfo, k: number) => Vec2;
+/** How much the radius grows when the round cut's centre moves by `d` (its part along the bisector, in radius units). */
+declare const cornerRadiusChange: (c: VectorCornerInfo, d: Vec2) => number;
+/** True when any anchor of the subpaths has a live corner radius. */
+declare function hasVectorCorners(subpaths: readonly VectorSubpath[]): boolean;
+/** One subpath with its corners cut; `sources[i]` is the stored anchor each output anchor comes from. */
+declare function expandVectorCornersOf(sp: VectorSubpath, subpath?: number): {
+    subpath: VectorSubpath;
+    sources: number[];
+};
+/**
+ * The subpaths with every live corner cut (round, inverted or chamfer), each radius no larger
+ * than fits. A cut corner becomes two anchors and curved sides are trimmed to what the cuts
+ * leave of them. Subpaths without corners come back unchanged.
+ */
+declare function expandVectorCorners(subpaths: readonly VectorSubpath[]): VectorSubpath[];
+/**
+ * Sets (or clears, with radius 0) the live corner of anchors. `kind` keeps each anchor's own
+ * kind when omitted. Anchors that make no corner keep the radius too, so it applies once they do.
+ */
+declare function setAnchorCorner(a: VectorAnchor, radius: number, kind?: VectorCornerKind): VectorAnchor;
+/** The next corner kind (Alt-clicking a corner widget cycles round → inverted → chamfer). */
+declare function nextVectorCornerKind(kind: VectorCornerKind | undefined): VectorCornerKind;
+/** Every anchor of a subpath given the same live corner (radius 0 clears them). */
+declare function setSubpathCorners(sp: VectorSubpath, radius: number, kind?: VectorCornerKind): VectorSubpath;
+
 /**
  * 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`
@@ -555,6 +707,29 @@ interface VectorSnapOptions {
 }
 /** Snap options new editors start with. Hold Cmd / Ctrl (`mod`) during a drag to bypass snapping. */
 declare const DEFAULT_VECTOR_SNAP: Readonly<VectorSnapOptions>;
+/** How path-editing gestures and the pencil, knife and eraser behave. */
+interface VectorPathEditOptions {
+    /**
+     * Deleting anchors refits the neighbouring handles so the shape stays (default true). Off,
+     * the neighbours are joined with their handles as they are.
+     */
+    keepShapeOnDelete: boolean;
+    /**
+     * Dragging one anchor with the direct tool bends its two segments like the Curvature tool,
+     * keeping the segments beyond still (default false). Alt held during the drag flips it.
+     */
+    curvatureMoves: boolean;
+    /** Pencil lazy-mouse smoothing, 0–1: the pulled string is up to 100 screen pixels long (default 0, off). */
+    pencilSmoothing: number;
+    /** Pencil strokes that look like a line, rectangle, ellipse or polygon become that shape (default false). */
+    recognizeShapes: boolean;
+    /** Eraser diameter in document units (default 10). */
+    eraserSize: number;
+}
+/** Path-editing options new editors start with. */
+declare const DEFAULT_VECTOR_PATH_EDIT: Readonly<VectorPathEditOptions>;
+/** Longest pencil lazy-mouse string (at smoothing 1), in screen pixels. */
+declare const VECTOR_PENCIL_STRING_PX = 100;
 interface VectorEditorOptions {
     document?: VectorDocument;
     /** History to record into, e.g. one shared with the rest of the app (default: a new one). */
@@ -565,6 +740,7 @@ interface VectorEditorOptions {
     defaults?: VectorDefaults;
     viewport?: Partial<VectorViewport>;
     snap?: Partial<VectorSnapOptions>;
+    editing?: Partial<VectorPathEditOptions>;
     /** Pick distance for anchors, handles and outlines in screen pixels (default 6). */
     hitRadius?: number;
     /** Id factory for new nodes. */
@@ -587,6 +763,7 @@ interface VectorHover {
     nodeId: string | null;
     anchor?: VectorAnchorRef;
     handle?: VectorHandleRef;
+    /** A segment under the pointer (direct tool and scissors); `point` is in document space. */
     segment?: {
         nodeId: string;
         subpath: number;
@@ -595,6 +772,8 @@ interface VectorHover {
         point: Vec2;
     };
     transformHandle?: VectorTransformHandle;
+    /** A live corner widget (direct tool): the corner's anchor. */
+    corner?: VectorAnchorRef;
 }
 /** The drag in progress, for overlays and status text. */
 type VectorInteraction = {
@@ -619,11 +798,24 @@ type VectorInteraction = {
 } | {
     type: 'handle';
     ref: VectorHandleRef;
+} | {
+    type: 'bend';
+    ref: VectorSegmentRef;
+} | {
+    type: 'corner';
+    ref: VectorAnchorRef;
+    radius: number;
 } | {
     type: 'draw';
     tool: VectorTool;
     nodeId: string;
     bounds: VectorBounds;
+    string?: [Vec2, Vec2];
+} | {
+    type: 'stroke';
+    tool: 'knife' | 'eraser';
+    points: Vec2[];
+    width: number;
 } | {
     type: 'pen';
     nodeId: string;
@@ -645,8 +837,9 @@ interface VectorEditorState {
     /** The selection box, rotated with the selection when its nodes share a rotation. */
     selectionFrame: VectorSelectionFrame | null;
     viewport: VectorViewport;
-    defaults: Readonly<Required<Pick<VectorDefaults, 'polygonSides' | 'starPoints' | 'starInnerRatio' | 'cornerRadius'>> & VectorStyle>;
+    defaults: Readonly<Required<Pick<VectorDefaults, 'polygonSides' | 'starPoints' | 'starInnerRatio' | 'cornerRadius'>> & Pick<VectorDefaults, 'cornerKind'> & VectorStyle>;
     snap: VectorSnapOptions;
+    editing: VectorPathEditOptions;
     /** Smart guides of the snap in progress, in document units (null when there are none). */
     guides: VectorSnapGuides | null;
     hitRadius: number;
@@ -691,12 +884,16 @@ interface VectorShapeInput extends VectorStyle {
     y: number;
     width: number;
     height: number;
+    /** Live corner radius of a rectangle, polygon or star (default: the editor default). */
     cornerRadius?: number;
+    cornerKind?: VectorCornerKind;
     sides?: number;
     points?: number;
     innerRatio?: number;
     name?: string;
 }
+/** Every field of `VectorStyle`, in the order style panels and commands list them. */
+declare const VECTOR_STYLE_KEYS: readonly ["fill", "stroke", "strokeWidth", "strokeLinecap", "strokeLinejoin", "strokeDasharray", "fillRule", "strokeAlign", "startArrow", "endArrow", "arrowAlign", "startArrowScale", "endArrowScale"];
 /** Clipboard payload type written by `copy()`. */
 declare const VECTOR_CLIPBOARD_TYPE = "pixerate/vector";
 /** Screen distance of the rotation handle above the selection box. */
@@ -710,6 +907,29 @@ declare function getVisibleAnchors(state: Pick<VectorEditorState, 'document' | '
  * (direct tool), or of the last anchor of the pen path.
  */
 declare function getVisibleHandles(state: Pick<VectorEditorState, 'document' | 'selection' | 'editingId' | 'tool' | 'pen' | 'selectedAnchors'>): VectorHandleRef[];
+/** Live corner widgets sit at least this far inside their corner (screen px along each side of a right angle). */
+declare const VECTOR_CORNER_WIDGET_INSET = 10;
+/** A live corner widget of the direct tool: drag it to round the corners, Alt-click to change their kind. */
+interface VectorCornerWidget {
+    ref: VectorAnchorRef;
+    /** Document position of the widget. */
+    x: number;
+    y: number;
+    /** The radius stored on the anchor and the radius drawn (no larger than fits). */
+    radius: number;
+    drawnRadius: number;
+    kind: VectorCornerKind;
+    /** The corner in its node's own space. */
+    corner: VectorCornerInfo;
+}
+/**
+ * The live corner widgets the direct tool shows: on each editable path, at its selected corner
+ * anchors (or at every corner when none of its anchors is selected). Corners whose sides are
+ * shorter than three insets on screen hide theirs. Dragging one sets the radius of all of them.
+ * Ported from ArtCraft vectorcraft `crates/tools/src/corners.rs` (MIT OR Apache-2.0, see
+ * THIRD_PARTY_NOTICES.md), as is the `corner` drag below.
+ */
+declare function getVectorCornerWidgets(state: Pick<VectorEditorState, 'document' | 'selection' | 'editingId' | 'tool' | 'pen' | 'selectedAnchors' | 'viewport'>): VectorCornerWidget[];
 /** Looks up an anchor (positions in its node's own space). */
 declare function getAnchor(doc: VectorDocument, ref: VectorAnchorRef): VectorAnchor | undefined;
 /** An anchor with its position and handles in document space (its node's transforms applied). */
@@ -784,6 +1004,7 @@ declare class VectorEditorController {
     private defaults;
     private viewport;
     private snap;
+    private editing;
     private hitRadius;
     private hover;
     private pointer;
@@ -855,6 +1076,8 @@ declare class VectorEditorController {
     setTool(tool: VectorTool): void;
     setDefaults(defaults: Partial<VectorDefaults>): void;
     setSnap(snap: Partial<VectorSnapOptions>): void;
+    /** Changes how deleting, dragging anchors, the pencil and the eraser behave. */
+    setEditing(editing: Partial<VectorPathEditOptions>): void;
     /** Turns object snapping on or off (the toolbar's snapping toggle). */
     toggleSnapping(on?: boolean): void;
     private gridValue;
@@ -908,6 +1131,31 @@ declare class VectorEditorController {
     }, ids?: readonly string[], options?: {
         label?: string;
     }): VectorActionResult;
+    /**
+     * Sets the live corner radius (and optionally the kind) of anchors: `refs`, else the selected
+     * anchors (direct tool), else every anchor of the `ids` / selected paths. Radius 0 makes the
+     * corners sharp again. Corners shrink to fit when drawn, so any radius is accepted.
+     */
+    setCornerRadius(radius: number, options?: {
+        kind?: VectorCornerKind;
+        refs?: readonly VectorAnchorRef[];
+        ids?: readonly string[];
+    }): VectorActionResult;
+    /** Sets the live corner kind of the same anchors as `setCornerRadius`, keeping their radii. */
+    setCornerKind(kind: VectorCornerKind, options?: {
+        refs?: readonly VectorAnchorRef[];
+        ids?: readonly string[];
+    }): VectorActionResult;
+    /** Anchors a corner change applies to (see `setCornerRadius`). */
+    private cornerTargets;
+    /**
+     * Outline Stroke: replaces each selected (or given) path's stroke with a filled path of the
+     * area it paints (alignment, joins, caps, dashes and arrowheads included), placed above a copy
+     * of the path that keeps the fill (left out when there is none). Returns the new paths' ids.
+     */
+    outlineStroke(options?: {
+        ids?: readonly string[];
+    }): string[];
     rename(id: string, name: string): VectorActionResult;
     setVisible(id: string, visible: boolean): VectorActionResult;
     setLocked(id: string, locked: boolean): VectorActionResult;
@@ -1013,8 +1261,22 @@ declare class VectorEditorController {
     private updateAnchors;
     /** Moves anchors by a document-space offset (converted into each node's own space). */
     private movedAnchors;
-    /** Moves one anchor to a document position (handles follow). */
-    moveAnchor(ref: VectorAnchorRef, to: Vec2): VectorActionResult;
+    /**
+     * Moves one anchor to a document position. Its handles follow; with `curvature` (default:
+     * the `curvatureMoves` setting) its two segments bend instead, as the Curvature tool does.
+     */
+    moveAnchor(ref: VectorAnchorRef, to: Vec2, options?: {
+        curvature?: boolean;
+    }): VectorActionResult;
+    /** `doc` with anchor `ref` moved to document point `to` by a Curvature-tool move. */
+    private curvatureMoved;
+    /** `doc` with segment `ref` bent through document point `p` at parameter `t`. */
+    private bent;
+    /**
+     * Bends a segment so the curve passes through document point `to` at parameter `t`
+     * (default 0.5, clamped to 0.05–0.95); see `bendSegment` in `pathEdit`.
+     */
+    bendSegment(ref: VectorSegmentRef, to: Vec2, t?: number): VectorActionResult;
     /** Moves one handle to a document position (see `moveAnchorHandle` for how the opposite handle follows). */
     moveHandle(ref: VectorHandleRef, to: Vec2, options?: {
         breakHandles?: boolean;
@@ -1023,12 +1285,95 @@ declare class VectorEditorController {
     convertAnchors(type: VectorAnchorType, refs?: readonly VectorAnchorRef[]): VectorActionResult;
     /** Adds an anchor on the nearest segment of `nodeId` to document point `point` (shape unchanged). */
     insertAnchorAt(nodeId: string, point: Vec2): VectorAnchorRef | null;
-    /** Deletes the selected anchors; empty subpaths and paths go too. */
-    deleteAnchors(refs?: readonly VectorAnchorRef[]): VectorActionResult;
+    /**
+     * Deletes the selected (or given) anchors; subpaths left with one anchor and empty paths go
+     * too. With `keepShape` (default: the `keepShapeOnDelete` setting, on) the neighbours'
+     * handles are refitted so the path keeps its shape; off, the neighbours are joined as they are.
+     */
+    deleteAnchors(refs?: readonly VectorAnchorRef[], options?: {
+        keepShape?: boolean;
+    }): VectorActionResult;
     /** Opens or closes the subpaths that contain selected anchors (or all subpaths of `nodeId`). */
     setClosed(closed: boolean, nodeId?: string): VectorActionResult;
     /** Reverses the direction of every subpath of the selected paths. */
     reversePaths(ids?: readonly string[]): VectorActionResult;
+    /** Unlocked path nodes in the given roots (default: the paths being edited, else the selection). */
+    private pathTargets;
+    /** Subpaths of node `from` mapped into node `to`'s own space. */
+    private subpathsIn;
+    /**
+     * Replaces a path with pieces: each entry becomes one path (the first keeps the node's id and
+     * place, the others go just above it with the same style). No pieces removes the path.
+     * Returns the ids of the paths now standing in for it.
+     */
+    private replaceWithPieces;
+    /** Clears anchor selections, editing and pen state that no longer point at anything. */
+    private dropStaleRefs;
+    /**
+     * Join: the open subpaths of the selected (or given) paths become one open path, joined
+     * nearest endpoints first (ends within `tolerance` document units merge into one anchor,
+     * others get a straight segment); a single open subpath is closed. The result replaces the
+     * lowest path, in its space and style. Default tolerance: the pick distance.
+     */
+    joinPaths(options?: {
+        ids?: readonly string[];
+        tolerance?: number;
+    }): VectorActionResult;
+    /** Average: moves the selected (or given) anchors onto their average position along `axis`, in document space. */
+    averageAnchors(axis?: VectorAverageAxis, refs?: readonly VectorAnchorRef[]): VectorActionResult;
+    /** Applies `fn` to every subpath of the target paths as one undo step. */
+    private editSubpaths;
+    /**
+     * Remove Redundant Points: drops anchors of the selected (or given) paths that can go
+     * without moving the outline more than `tolerance` document units (default 0.5).
+     */
+    removeRedundantPoints(options?: {
+        ids?: readonly string[];
+        tolerance?: number;
+    }): VectorActionResult;
+    /**
+     * Smooth: pulls handles towards smooth tangents by `amount` (0–1, default 1). With the direct
+     * tool and points selected, only those points change.
+     */
+    smoothPaths(options?: {
+        ids?: readonly string[];
+        amount?: number;
+        refs?: readonly VectorAnchorRef[];
+    }): VectorActionResult;
+    /** Splits a cut subpath into pieces: separate paths for a one-subpath node, subpaths in place for a compound one. */
+    private applyCuts;
+    /**
+     * Scissors: cuts path `nodeId` at the outline point nearest document point `point` (at an
+     * anchor when within the pick distance of one). A closed subpath opens there; an open one
+     * splits in two (a one-subpath path becomes two paths). Returns the ids of the paths.
+     */
+    cutPathAt(nodeId: string, point: Vec2): string[] | null;
+    /** Scissors on the selected (or given) anchors: each cuts its subpath there (see `cutPathAt`). */
+    cutAtAnchors(refs?: readonly VectorAnchorRef[]): VectorActionResult;
+    /** Visible, unlocked paths a stroke over `points` can reach: in `ids`, the selection, or (with neither) any whose bounds it crosses. */
+    private strokeTargets;
+    /** A stroke's points in node `id`'s own space. */
+    private localPoints;
+    /**
+     * Knife: cuts closed paths along the polyline `points` (document space) wherever it crosses
+     * them from edge to edge, with no gap between the pieces. It cuts the given paths, the
+     * selection, or (with neither) every path it crosses. Returns the ids of the pieces (empty
+     * when nothing was cut).
+     */
+    knife(points: readonly Vec2[], options?: {
+        ids?: readonly string[];
+    }): string[];
+    /**
+     * Eraser: rubs out a round stroke of diameter `size` (default: the `eraserSize` setting)
+     * along `points` (document space). Filled closed paths lose that area (pieces that come
+     * apart become separate paths); outlines are cut where they pass under it. It erases from
+     * the given paths, the selection, or (with neither) every path it reaches. Returns the ids
+     * of the paths it changed or created.
+     */
+    erase(points: readonly Vec2[], options?: {
+        ids?: readonly string[];
+        size?: number;
+    }): string[];
     /** Ends the pen path being drawn (a lone anchor is removed). */
     finishPath(): void;
     /** Copies the selection. Returns JSON text for the system clipboard (or null). */
@@ -1050,12 +1395,16 @@ declare class VectorEditorController {
     private tolerance;
     private hitTransformHandle;
     private hitHandle;
+    private cornerView;
+    private hitCornerWidget;
     private hitAnchor;
     /** Deepest unlocked visible path under `p`. */
     private hitPath;
     /** Endpoints of open subpaths of unlocked visible paths (pen tool resumes from them). */
     private openEndpoints;
     private computeHover;
+    /** The nearest outline point of any visible, unlocked path within the pick distance of document point `p`. */
+    private nearestOutline;
     private sameHover;
     /** Primary button down on the canvas at `screen` (pixels relative to the canvas). */
     pointerDown(screen: Vec2, input?: VectorPointerInput): void;
@@ -1109,6 +1458,13 @@ interface VectorRenderPath {
     strokeDasharray?: string;
     fillRule: 'nonzero' | 'evenodd';
     opacity: number;
+    /**
+     * Set when the stroke takes more than one element: an inside / outside alignment or
+     * arrowheads. Draw `d` with the fill only, then `stroke.d` with the stroke (at
+     * `stroke.width`, clipped or masked as `stroke.clip` says), then each head filled with
+     * `stroke`; group them under `id`, `transform` and `opacity`.
+     */
+    strokeParts?: VectorRenderStrokeParts;
 }
 interface VectorRenderGroup {
     kind: 'group';
@@ -1150,6 +1506,17 @@ interface VectorRenderHandle {
     anchorY: number;
     hovered: boolean;
 }
+/** A live corner widget in screen pixels. */
+interface VectorRenderCornerWidget {
+    ref: VectorAnchorRef;
+    x: number;
+    y: number;
+    radius: number;
+    kind: VectorCornerKind;
+    hovered: boolean;
+    /** Its corners are being dragged. */
+    active: boolean;
+}
 /** A smart guide line in screen pixels. */
 interface VectorRenderGuideLine {
     kind: VectorGuideKind;
@@ -1196,6 +1563,29 @@ interface VectorOverlayRenderData {
         lines: VectorRenderGuideLine[];
         labels: VectorRenderGuideLabel[];
     };
+    /**
+     * The knife or eraser stroke being drawn, screen space: `d` is an open polyline; draw the
+     * eraser's with a round-capped stroke `width` pixels wide (0 for the knife: a thin line).
+     */
+    toolStroke: {
+        tool: 'knife' | 'eraser';
+        d: string;
+        width: number;
+    } | null;
+    /** The pencil's lazy-mouse string from the pen to the pointer, screen space. */
+    pencilString: {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    } | null;
+    /** Where the scissors would cut (screen space). */
+    cutPoint: Vec2 | null;
+    /**
+     * Live corner widgets of the direct tool (screen space): drag one to round its corners,
+     * Alt-click to cycle round / inverted / chamfer, click to pick its corner alone.
+     */
+    cornerWidgets: VectorRenderCornerWidget[];
     /** A short status, e.g. "W 120 × H 80" or "45°". */
     status: string | null;
 }
@@ -1215,9 +1605,13 @@ declare const VECTOR_OVERLAY_THEME: {
     readonly guide: "#ff3dfc";
     readonly handleFill: "#ffffff";
     readonly marqueeFill: "rgba(14, 165, 233, 0.08)";
+    /** The eraser's swath while it is dragged. */
+    readonly eraserFill: "rgba(239, 68, 68, 0.25)";
     readonly transformHandleSize: 8;
     readonly anchorSize: 7;
     readonly handleRadius: 3.5;
+    /** Radius of a live corner widget (a ring with a dot). */
+    readonly cornerWidgetRadius: 4;
 };
 interface ModifierEventLike {
     shiftKey?: boolean;
@@ -1257,18 +1651,64 @@ interface VectorSelectionStyle {
     stroke: VectorPaint;
     strokeWidth: number;
     opacity: number;
+    strokeAlign: VectorStrokeAlign;
+    startArrow: VectorArrowhead | null;
+    endArrow: VectorArrowhead | null;
+    arrowAlign: VectorArrowAlign;
+    startArrowScale: number;
+    endArrowScale: number;
+    /**
+     * Live corners of the selected anchors (direct tool) or of every corner of the selected
+     * paths: the first one's radius and kind, and how many corners there are (0: none to round).
+     */
+    cornerRadius: number;
+    cornerKind: VectorCornerKind;
+    corners: number;
+    /** Some selected path is open, so arrowheads apply. */
+    hasOpenPath: boolean;
     mixed: {
         fill: boolean;
         stroke: boolean;
         strokeWidth: boolean;
         opacity: boolean;
+        strokeAlign: boolean;
+        startArrow: boolean;
+        endArrow: boolean;
+        arrowAlign: boolean;
+        startArrowScale: boolean;
+        endArrowScale: boolean;
+        cornerRadius: boolean;
+        cornerKind: boolean;
     };
     /** Ids of the paths the style applies to. */
     pathIds: string[];
 }
-declare function getVectorSelectionStyle(state: Pick<VectorEditorState, 'document' | 'selection'>): VectorSelectionStyle | null;
+declare function getVectorSelectionStyle(state: Pick<VectorEditorState, 'document' | 'selection'> & Partial<Pick<VectorEditorState, 'selectedAnchors' | 'tool'>>): VectorSelectionStyle | null;
+/** Labels of the stroke alignments, corner kinds and arrowheads, for style panels. */
+declare const VECTOR_STROKE_ALIGN_LABELS: Readonly<Record<VectorStrokeAlign, string>>;
+declare const VECTOR_CORNER_KIND_LABELS: Readonly<Record<VectorCornerKind, string>>;
+declare const VECTOR_ARROWHEAD_LABELS: Readonly<Record<VectorArrowhead, string>>;
 /** A paint as `#rrggbb` for `<input type="color">`, or null for none, gradients and other CSS colours. */
 declare function vectorPaintToHex(paint: VectorPaint | undefined): string | null;
+/** A path-editing button of the bundled toolbars. */
+interface VectorPathAction {
+    id: 'join' | 'average' | 'cut' | 'clean' | 'smooth' | 'outline';
+    label: string;
+    title: string;
+    /** Shortcut after Cmd / Ctrl, if any. */
+    shortcut?: string;
+    /** Whether it can run with `selected` nodes and `points` selected anchors (direct tool). */
+    enabled: (selected: number, points: number) => boolean;
+    run: (controller: VectorEditorController) => unknown;
+}
+/** Join, Average, Cut at Points, Remove Redundant Points, Smooth and Outline Stroke, as the toolbars show them. */
+declare const VECTOR_PATH_ACTIONS: readonly VectorPathAction[];
+/** The on / off path-editing settings the toolbars toggle. */
+declare const VECTOR_EDIT_TOGGLES: readonly {
+    key: 'keepShapeOnDelete' | 'curvatureMoves' | 'recognizeShapes';
+    label: string;
+    title: string;
+}[];
 
 interface VectorCommandOptions {
     /** Id prefix (default `vector.`); use one per editor when several are registered. */
@@ -1311,4 +1751,236 @@ interface VectorNodeListing {
  */
 declare function createVectorCommands(controller: VectorEditorController, options?: VectorCommandOptions): CommandSpec[];
 
-export { type AddVectorNodeOptions, AffineMatrix, DEFAULT_VECTOR_SNAP, IDENTITY_MATRIX, KAPPA, type NearestSegment, SvgGradientDef, VECTOR_CLIPBOARD_TYPE, VECTOR_CONSTRUCTION_ANGLES, VECTOR_OVERLAY_THEME, VECTOR_ROTATE_HANDLE_OFFSET, VECTOR_TOOLS, VECTOR_TOOL_GLYPHS, VECTOR_TOOL_SHORTCUTS, VECTOR_TRANSFORM_HANDLES, type Vec2, type VectorActionResult, type VectorAlign, type VectorAnchor, type VectorAnchorRef, type VectorAnchorType, type VectorArrange, type VectorBooleanOperation, type VectorBounds, type VectorCommandOptions, 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 VectorInteraction, type VectorKeyInput, type VectorLineCap, type VectorLineJoin, type VectorMatrix, type VectorModifiers, type VectorNode, type VectorNodeListing, type VectorOverlayRenderData, type VectorPaint, type VectorPathNode, type VectorPointSnap, type VectorPointerInput, type VectorRectSnap, type VectorRenderAnchor, type VectorRenderGroup, type VectorRenderGuideLabel, type VectorRenderGuideLine, type VectorRenderHandle, type VectorRenderNode, type VectorRenderPath, type VectorScaleSnap, type VectorSceneRenderData, type VectorSelectionBoxGeometry, type VectorSelectionFrame, type VectorSelectionStyle, type VectorShapeInput, type VectorSnapGuides, type VectorSnapKind, type VectorSnapLeave, type VectorSnapOptions, VectorSnapTargets, type VectorStyle, type VectorSubpath, type VectorSvgExportOptions, type VectorSvgImportOptions, type VectorTool, type VectorTransformHandle, type VectorViewport, applyMatrix, applyMatrixLinear, bezierToSubpaths, boundsFromPoints, boundsIntersect, cloneAnchor, cloneSubpath, cloneVectorDocument, cloneVectorNode, collectPathNodes, constrainToLeave, convertAnchor, createVectorCommands, decomposeRigid, ellipseSubpath, findVectorNode, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVisibleAnchors, getVisibleHandles, hasPaint, hitTestVectorNode, hitTestVectorNodes, inferAnchorType, insertAnchor, invertMatrix, isIdentityMatrix, isVectorTextTarget, lineSubpath, locateVectorNode, matrixRotation, moveAnchorHandle, multiplyMatrices, nearestSegment, nodeMatrix, parseSvgTransform, parseVectorSvg, polygonSubpath, rectSubpath, removeAnchors, reverseSubpath, rotateMatrix, roundSubpaths, scaleFor, scaleMatrix, starSubpath, subpathSegment, subpathSegmentCount, subpathsToBezier, toVectorKeyInput, toVectorModifiers, toVectorPointerInput, transformVectorNode, translateAnchor, translateMatrix, unionBounds, vectorDocumentToSvg, vectorNodeBounds, vectorNodeRotation, vectorNodeToBezier, vectorPaintToHex, vectorPaintToSvg, vectorParentMatrix, vectorPathData, vectorPathWorldBezier, vectorResizeCursor, vectorToolLabel, vectorWorldMatrix, walkVectorNodes };
+/**
+ * Removes anchor `index` without opening the path: its neighbours keep their handle directions
+ * and their facing handles are refitted so one cubic follows the two segments that met there
+ * as closely as possible (least maximum error over where the new curve passes the removed
+ * point). Two straight segments become one; removing an end of an open subpath drops its
+ * segment. Returns the subpath unchanged (a copy) when `index` is out of range.
+ */
+declare function removeAnchorKeepingShape(sp: VectorSubpath, index: number): VectorSubpath;
+/** Removes several anchors of a subpath, keeping the shape (see `removeAnchorKeepingShape`). */
+declare function removeAnchorsKeepingShape(sp: VectorSubpath, indices: readonly number[]): VectorSubpath;
+/**
+ * Bends segment `segment` so the curve passes through `p` at parameter `t` (clamped to
+ * 0.05–0.95): its handles go to the thirds of the chord plus one shared offset, so
+ * `B(t) = L(t) + 3t(1 − t)·offset` exactly. The end anchors keep their types (a smooth or
+ * symmetric end turns its other handle to stay in line).
+ */
+declare function bendSegment(sp: VectorSubpath, segment: number, t: number, p: Vec2): VectorSubpath;
+/** The point at parameter `t` of segment `segment` (for tests and previews). */
+declare function subpathPointAt(sp: VectorSubpath, segment: number, t: number): Vec2;
+/**
+ * Moves anchor `index` to `q` the way the Curvature tool drags a point: only the two segments
+ * at it change. A smooth or symmetric anchor turns its handles along the line through its
+ * neighbours; the neighbours' handles on those segments, and a corner's own handles, keep
+ * their directions while their lengths scale with their segment's chord, so the segments
+ * beyond don't move and a corner without handles keeps none.
+ */
+declare function curvatureMoveAnchor(sp: VectorSubpath, index: number, q: Vec2): VectorSubpath;
+/**
+ * Cuts a subpath at the anchors `at`: each becomes the end of one open piece and the start of
+ * the next, its handle off each piece dropped (the shape doesn't change). A closed subpath
+ * opens at its first cut, so one cut leaves one piece whose ends coincide. The ends of an open
+ * subpath and indices out of range don't cut; with no cut left the subpath comes back as it is.
+ */
+declare function cutSubpathAt(sp: VectorSubpath, at: readonly number[]): VectorSubpath[];
+/**
+ * Cuts a subpath at parameter `t` of segment `segment` (Scissors on a segment): an anchor is
+ * inserted there without changing the shape, then cut. Within `endTolerance` of the segment's
+ * ends (in parameter) the existing anchor is cut instead.
+ */
+declare function splitSubpathAt(sp: VectorSubpath, segment: number, t: number, endTolerance?: number): VectorSubpath[];
+/**
+ * Join: open subpaths are joined nearest-endpoints-first into one open subpath (endpoints
+ * within `tolerance` merge into one anchor, otherwise a straight segment connects them). A
+ * single open subpath is closed instead (its ends merged when they meet). Closed subpaths and
+ * lone anchors pass through unchanged, before the joined one.
+ */
+declare function joinSubpaths(subpaths: readonly VectorSubpath[], tolerance: number): VectorSubpath[];
+/**
+ * Smooth: pulls handles towards Catmull-Rom-like tangents (a third of the way to each
+ * neighbour along the line through both). `amount` 0–1 (0 = unchanged, 1 = fully smooth).
+ * Only the anchors in `only` change when it is given; endpoints of open subpaths keep their
+ * handles. Subpaths of fewer than three anchors are unchanged.
+ */
+declare function smoothSubpath(sp: VectorSubpath, amount?: number, only?: ReadonlySet<number>): VectorSubpath;
+/**
+ * Remove Redundant Points: drops anchors that can go without changing the shape by more than
+ * `tolerance` (collinear corners, duplicate points, and smooth joints that one cubic can
+ * replace).
+ */
+declare function removeRedundantPoints(sp: VectorSubpath, tolerance: number): VectorSubpath;
+
+/**
+ * Knife and eraser on Bézier paths, built on the curve booleans and `outlineStroke`.
+ *
+ * The knife cuts filled regions along a polyline with no gap: each stretch of the polyline
+ * that crosses a region from boundary to boundary (a chord) splits the boundary loop it starts
+ * and ends on into two loops sharing that chord, or, when it joins two loops (an outline and a
+ * hole), merges them into one. Crossings are exact (line–cubic roots), and the pieces share
+ * the cut edge exactly.
+ *
+ * The eraser removes the area of a round-capped stroke along a polyline: filled shapes lose it
+ * by a boolean difference; outlines are cut where they cross the stroke's outline (exact
+ * curve–curve intersections) and keep the parts outside it.
+ *
+ * Modelled on vectorcraft-main/crates/engine/src/cmd/draw2.rs (`knife`, `erase_region`,
+ * `erase_outline`, `cut_subpath`; MIT OR Apache-2.0, © ArtCraft Team and contributors; see
+ * THIRD_PARTY_NOTICES.md), without its fixed knife slit and its sampled crossing search.
+ */
+
+type FillRule = 'nonzero' | 'evenodd';
+/** One path per face (an outline with its holes) of a filled path, largest first. */
+declare function splitIntoFaces(path: BezierPathInput, fillRule?: FillRule): BezierPath[];
+/**
+ * Cuts the filled path along the open polyline `knife`. Returns one path per resulting face
+ * (an outline with its holes), or null when the knife crossed nothing from edge to edge. A
+ * stretch of the knife that starts or ends inside the shape does not cut.
+ */
+declare function knifePath(path: BezierPathInput, fillRule: FillRule, knife: readonly Point[]): BezierPath[] | null;
+/** The area a round eraser of diameter `width` covers along `points` (a disc for one point). */
+declare function eraserRegion(points: readonly Point[], width: number): BezierPath;
+/**
+ * A filled path with `region` removed: one path per remaining face, or null when the region
+ * does not overlap the fill.
+ */
+declare function eraseFromFill(path: BezierPathInput, fillRule: FillRule, region: BezierPathInput): BezierPath[] | null;
+/**
+ * The parts of a subpath's outline outside `region`, as open subpaths that keep the original
+ * curves exactly; null when the outline does not enter the region. A closed subpath's last
+ * and first parts join at its first anchor.
+ */
+declare function eraseFromOutline(sp: VectorSubpath, region: BezierPathInput): VectorSubpath[] | null;
+/** Bounds of a point list (for picking the paths a knife or eraser stroke can reach). */
+declare function polylineBounds(points: readonly Point[], pad?: number): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null;
+/** Ramer–Douglas–Peucker reduction of a polyline (keeps both ends). */
+declare function simplifyPolyline(points: readonly Point[], tolerance: number): Point[];
+
+/**
+ * Pencil helpers: lazy-mouse smoothing (a pulled string between the pointer and the pen) and
+ * ink-to-shape recognition (a hand-drawn stroke that is a line, rectangle, ellipse or polygon).
+ *
+ * Portions ported from (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
+ * THIRD_PARTY_NOTICES.md):
+ * - photocraft-main/crates/paint/src/dynamics.rs (`Smoother`: pulled-string mode, `string`,
+ *   `finish` with catch-up on stroke end)
+ * - wordcraft-main/crates/engine/src/cmd/ink_shape.rs (`recognise`, `ellipse_rms`,
+ *   `snap_square`, `corners`, `turning`, `rdp`, `upright`)
+ */
+
+/**
+ * Pulled-string smoothing: the pen stays put until the pointer is more than `length` away,
+ * then follows it at that distance, so small wobbles never reach the stroke. Feed pointer
+ * positions to `push`; it returns the pen positions to draw through (possibly none).
+ */
+declare class LazyMouse {
+    readonly length: number;
+    private pos;
+    private last;
+    /** `length` is the string length in the units of the points (0 turns smoothing off). */
+    constructor(length: number);
+    push(p: Point): Point[];
+    /** The string from the pen to the pointer while they are apart, else null. */
+    string(): [Point, Point] | null;
+    /** End of stroke: the pen catches up with the pointer (the point to add, if it lagged). */
+    finish(): Point[];
+}
+/** A shape recognised in a stroke, in the stroke's coordinates. */
+type VectorInkShape = {
+    kind: 'line';
+    a: Point;
+    b: Point;
+} | {
+    kind: 'rect';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | {
+    kind: 'ellipse';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | {
+    kind: 'polygon';
+    points: Point[];
+};
+interface RecognizeInkOptions {
+    /** Strokes whose longer side is smaller than this stay ink (default 6). */
+    minSize?: number;
+}
+/** Most corners a recognised polygon may have. */
+declare const VECTOR_INK_MAX_CORNERS = 8;
+/** "line", "square", "rectangle", "circle", "ellipse", "triangle" or "polygon". */
+declare function vectorInkShapeName(shape: VectorInkShape): string;
+/**
+ * The shape a hand-drawn stroke draws, if it is one: an open stroke is a line when it stays
+ * close to the chord between its ends; a closed one is an ellipse when its points sit on the
+ * ellipse inscribed in their bounds, else a polygon of 3–8 corners when that polygon stays
+ * close to every point (an upright four-cornered one is a rectangle). Nearly square boxes
+ * become squares and circles. Anything else (scribbles, curves, letters) is null.
+ */
+declare function recognizeInkShape(points: readonly Point[], options?: RecognizeInkOptions): VectorInkShape | null;
+
+/** One arrowhead: a filled outline (nonzero) painted with the stroke's paint. */
+interface VectorArrowheadShape {
+    end: 'start' | 'end';
+    kind: VectorArrowhead;
+    tip: Vec2;
+    /** Unit direction the head points in. */
+    dir: Vec2;
+    /** Distance from the tip back to where the stroke ends under the head. */
+    inset: number;
+    path: BezierPath;
+}
+/** What the stroke of a path draws. */
+interface VectorStrokeParts {
+    /** Where the stroke sits (`center` for open shapes, whatever the style says). */
+    align: VectorStrokeAlign;
+    /** The line the stroke follows: the outline, shortened under `tip`-aligned heads. */
+    line: BezierPath;
+    /** The stroke width to draw `line` with: twice the style's width for inside / outside (half is clipped away). */
+    drawWidth: number;
+    heads: VectorArrowheadShape[];
+}
+/** True when the path has subpaths and all of them are closed (only such shapes have an inside). */
+declare function isClosedBezierShape(path: BezierPath): boolean;
+/** The alignment a stroke is drawn with: the style's, or `center` for open shapes. */
+declare function effectiveStrokeAlign(style: Pick<VectorStyle, 'strokeAlign'>, closedShape: boolean): VectorStrokeAlign;
+/** True when the style asks for more than a plain centred stroke (an alignment or arrowheads). */
+declare function hasStrokeExtras(style: VectorStyle): boolean;
+/** The weight of a head: the stroke width times its scale (at least 0.25). A head is 4 weights long and wide. */
+declare function arrowheadWeight(style: VectorStyle, end: 'start' | 'end'): number;
+/** Distance from the tip where the stroke ends, for a stroke whose cap reaches `cap` past its end. */
+declare function arrowheadInset(kind: VectorArrowhead, hw: number, cap: number): number;
+/** The outline of a `kind` head of weight `hw` with its tip at `tip`, pointing along unit `dir`. */
+declare function arrowheadPath(kind: VectorArrowhead, tip: Vec2, dir: Vec2, hw: number): BezierPath;
+/**
+ * The stroke of `path` as `style` draws it: its alignment, the line it follows (shortened under
+ * `tip`-aligned heads) and its arrowheads. Heads go on the start of the first subpath and the
+ * end of the last one, when those are open.
+ */
+declare function vectorStrokeParts(path: BezierPath, style: VectorStyle): VectorStrokeParts;
+/**
+ * The area the stroke paints, as one filled path: the outlined stroke (joins, caps and dashes
+ * as SVG) clipped by the alignment (against the fill, read with the style's `fillRule`), plus
+ * the arrowheads.
+ */
+declare function vectorStrokeOutlinePath(path: BezierPath, style: VectorStyle): BezierPath;
+/**
+ * Whether point `p` hits the stroke of `path` (`tolerance` added on every side): within half
+ * the width of the outline for a centred stroke, within the whole width on the inside or the
+ * outside of the fill for an aligned one, or on an arrowhead.
+ */
+declare function hitTestVectorStroke(path: BezierPath, p: Vec2, style: VectorStyle, tolerance?: number): boolean;
+/** How far the stroke can reach past the outline (for padding bounds and masks). */
+declare function vectorStrokeReach(style: VectorStyle): number;
+
+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_CLIPBOARD_TYPE, VECTOR_CONSTRUCTION_ANGLES, VECTOR_CORNER_KINDS, VECTOR_CORNER_KIND_LABELS, VECTOR_CORNER_WIDGET_INSET, VECTOR_EDIT_TOGGLES, VECTOR_INK_MAX_CORNERS, VECTOR_OVERLAY_THEME, VECTOR_PATH_ACTIONS, VECTOR_PENCIL_STRING_PX, VECTOR_ROTATE_HANDLE_OFFSET, VECTOR_STROKE_ALIGN_LABELS, VECTOR_STYLE_KEYS, VECTOR_TOOLS, VECTOR_TOOL_GLYPHS, VECTOR_TOOL_SHORTCUTS, VECTOR_TRANSFORM_HANDLES, 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 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 VectorPathNode, 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 VectorScaleSnap, type VectorSceneRenderData, type VectorSegmentRef, type VectorSelectionBoxGeometry, type VectorSelectionFrame, type VectorSelectionStyle, type VectorShapeInput, type VectorSnapGuides, type VectorSnapKind, type VectorSnapLeave, type VectorSnapOptions, VectorSnapTargets, type VectorStrokeAlign, type VectorStrokeParts, type VectorStyle, type VectorSubpath, type VectorSvgExportOptions, type VectorSvgImportOptions, type VectorTool, type VectorTransformHandle, type VectorViewport, applyMatrix, applyMatrixLinear, applyVectorCornersAttribute, arrowheadInset, arrowheadPath, arrowheadWeight, bendSegment, bezierToSubpaths, boundsFromPoints, boundsIntersect, cloneAnchor, cloneSubpath, cloneVectorDocument, cloneVectorNode, collectPathNodes, constrainToLeave, convertAnchor, cornerBisectorPoint, cornerRadiusChange, cornerSetback, createVectorCommands, curvatureMoveAnchor, cutSubpathAt, decomposeRigid, effectiveStrokeAlign, ellipseSubpath, eraseFromFill, eraseFromOutline, eraserRegion, expandVectorCorners, expandVectorCornersOf, findVectorNode, fitCornerRadius, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorCornerWidgets, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVisibleAnchors, getVisibleHandles, hasPaint, hasStrokeExtras, hasVectorCorners, hitTestVectorNode, hitTestVectorNodes, hitTestVectorStroke, inferAnchorType, insertAnchor, invertMatrix, isClosedBezierShape, isIdentityMatrix, isVectorTextTarget, joinSubpaths, knifePath, lineSubpath, locateVectorNode, matrixRotation, moveAnchorHandle, multiplyMatrices, nearestSegment, nextVectorCornerKind, nodeMatrix, parseSvgTransform, parseVectorSvg, polygonSubpath, polylineBounds, recognizeInkShape, rectSubpath, removeAnchorKeepingShape, removeAnchors, removeAnchorsKeepingShape, removeRedundantPoints, reverseSubpath, rotateMatrix, roundSubpaths, scaleFor, scaleMatrix, setAnchorCorner, setSubpathCorners, simplifyPolyline, smoothSubpath, splitIntoFaces, splitSubpathAt, starSubpath, subpathPointAt, subpathSegment, subpathSegmentCount, subpathsToBezier, toVectorKeyInput, toVectorModifiers, toVectorPointerInput, transformVectorNode, translateAnchor, translateMatrix, unionBounds, vectorCornerAt, vectorCorners, vectorCornersAttribute, vectorDocumentToSvg, vectorInkShapeName, vectorNodeBounds, vectorNodeRotation, vectorNodeToBezier, vectorPaintToHex, vectorPaintToSvg, vectorParentMatrix, vectorPathData, vectorPathWorldBezier, vectorResizeCursor, vectorStrokeOutline, vectorStrokeOutlinePath, vectorStrokeParts, vectorStrokeReach, vectorStrokeSvgParts, vectorToolLabel, vectorWorldMatrix, walkVectorNodes };