@pixerate/editor 0.112.0 → 0.114.0

package/dist/vector/index.d.cts

@@ -1,18 +1,19 @@
-import { n as Vec2$1, v as VectorSubpath, h as VectorBounds, y as VectorAnchor, w as VectorDocument, e as VectorNode, b as VectorPathNode, z as VectorAnchorType, r as VectorPaint, g as VectorGroupNode, A as VectorCornerKind, x as VectorWidthPoint, m as VectorGradient, t as VectorGradientStop, B as VectorViewport, C as VectorTransformHandle, D as VectorAnchorRef, E as VectorPathfinderOperation, F as VectorTool, G as VectorDefaults, H as VectorStyle, I as VectorHandleRef, J as VectorSegmentRef, K as VectorBlendOptions, L as VectorModifiers, M as VectorBlendMode, j as VectorFilterType, V as VectorEffectType, N as VectorAlign, O as VectorDistribute, P as VectorArrange, d as VectorBooleanOperation, Q as VectorMaskType, R as VectorMask, S as VectorAverageAxis, i as VectorWarpMesh, c as VectorFillRule, T as VectorArrowhead, U as VectorBlendSpacing, W as VectorGradientInterpolation, p as VectorGradientSpread, q as VectorGradientType, u as VectorStrokeAlign, X as VectorStrokeGradientMode, Y as VectorArrowAlign, f as VectorEffect, Z as VectorPaintLayer, _ as VectorStrokeLayer, l as VectorFilter, $ as VectorBlend, a0 as VectorMergeMode, a1 as VectorLineJoin, a as VectorEffectParamsMap, a2 as VectorStrokeSettings } from '../types-DyQq-WPY.cjs';
-export { a3 as VECTOR_ARROWHEADS, a4 as VECTOR_BLEND_MODES, a5 as VECTOR_BLEND_SPACINGS, a6 as VECTOR_CORNER_KINDS, a7 as VECTOR_EFFECT_TYPES, a8 as VECTOR_FILTER_TYPES, a9 as VECTOR_GRADIENT_INTERPOLATIONS, aa as VECTOR_GRADIENT_SPREADS, ab as VECTOR_GRADIENT_TYPES, ac as VECTOR_MASK_TYPES, ad as VECTOR_MERGE_MODES, ae as VECTOR_PATHFINDER_OPERATIONS, af as VECTOR_STROKE_GRADIENT_MODES, ag as VECTOR_TOOLS, ah as VECTOR_TRANSFORM_HANDLES, ai as VectorCorner, k as VectorFilterParamsMap, o as VectorGradientUnits, aj as VectorLineCap, s as VectorMatrix, ak as VectorStrokeLayerKind, al as VectorWarpStyle } from '../types-DyQq-WPY.cjs';
+import { o as Vec2$1, w as VectorSubpath, h as VectorBounds, z as VectorAnchor, x as VectorDocument, e as VectorNode, b as VectorPathNode, A as VectorTextNode, B as VectorAnchorType, s as VectorPaint, g as VectorGroupNode, C as VectorCornerKind, y as VectorWidthPoint, n as VectorGradient, u as VectorGradientStop, D as VectorViewport, E as VectorConnectorRoute, F as VectorConnectorSide, G as VectorConnectorEnd, H as VectorConnector, I as VectorConstraintKind, J as VectorConstraint, K as VectorCharacterStyle, L as VectorTextRun, M as VectorParagraphStyle, N as VectorTextFrame, O as VectorTransformHandle, P as VectorAnchorRef, Q as VectorPathfinderOperation, R as VectorTool, S as VectorDefaults, T as VectorTextAlign, U as VectorStyle, W as VectorHandleRef, X as VectorSegmentRef, Y as VectorBlendOptions, t as VectorMatrix, Z as VectorModifiers, _ as VectorBlendMode, k as VectorFilterType, V as VectorEffectType, $ as VectorAlign, a0 as VectorDistribute, a1 as VectorArrange, d as VectorBooleanOperation, a2 as VectorMaskType, a3 as VectorArrowhead, a4 as VectorResizing, a5 as VectorFrame, a6 as VectorHorizontalResizing, a7 as VectorVerticalResizing, a8 as VectorMask, a9 as VectorAverageAxis, aa as VectorSymbol, ab as VectorParameter, i as VectorWarpMesh, c as VectorFillRule, ac as VectorBlendSpacing, ad as VectorGradientInterpolation, q as VectorGradientSpread, r as VectorGradientType, v as VectorStrokeAlign, ae as VectorStrokeGradientMode, af as VectorArrowAlign, f as VectorEffect, ag as VectorPaintLayer, ah as VectorStrokeLayer, m as VectorFilter, ai as VectorBlend, aj as VectorMergeMode, ak as VectorLineJoin, a as VectorEffectParamsMap, al as VectorStrokeSettings, am as VectorInstanceOverrides, j as VectorInstanceNode } from '../types-yINF17Ta.cjs';
+export { an as VECTOR_ARROWHEADS, ao as VECTOR_BLEND_MODES, ap as VECTOR_BLEND_SPACINGS, aq as VECTOR_CONNECTOR_ROUTES, ar as VECTOR_CONNECTOR_SIDES, as as VECTOR_CONSTRAINT_KINDS, at as VECTOR_CORNER_KINDS, au as VECTOR_EFFECT_TYPES, av as VECTOR_FILTER_TYPES, aw as VECTOR_GRADIENT_INTERPOLATIONS, ax as VECTOR_GRADIENT_SPREADS, ay as VECTOR_GRADIENT_TYPES, az as VECTOR_HORIZONTAL_RESIZING, aA as VECTOR_MASK_TYPES, aB as VECTOR_MERGE_MODES, aC as VECTOR_PATHFINDER_OPERATIONS, aD as VECTOR_PATH_TEXT_BASELINES, aE as VECTOR_STROKE_GRADIENT_MODES, aF as VECTOR_TEXT_ALIGNS, aG as VECTOR_TOOLS, aH as VECTOR_TRANSFORM_HANDLES, aI as VECTOR_VERTICAL_RESIZING, aJ as VectorCorner, l as VectorFilterParamsMap, aK as VectorGeomRef, p as VectorGradientUnits, aL as VectorLineCap, aM as VectorPathTextBaseline, aN as VectorStrokeLayerKind, aO as VectorTextRunStyle, aP as VectorWarpStyle } from '../types-yINF17Ta.cjs';
 import { P as Point } from '../types-BFkYA4eF.cjs';
 import { a as BezierPathInput, A as AffineMatrix$1, B as BezierPath, c as BezierSegment } from '../bezier-BfwIbVTl.cjs';
 export { S as SvgGradientDef } from '../bezier-BfwIbVTl.cjs';
-import { a as VectorGradientHandle, V as VectorSvgExportOptions, b as VectorGradientPatch, c as VectorEnvelopeParams, d as VectorRenderFilter, e as VectorAppearanceShape, f as VectorFilterParamSpec, g as VectorEffectParamSpec, h as VectorRenderStrokeParts, i as VectorPaintDef } from '../svg-D_cfkhlB.cjs';
-export { j as VECTOR_EFFECT_DEFAULTS, k as VECTOR_EFFECT_LABELS, l as VECTOR_EFFECT_PARAM_SPECS, m as VECTOR_FILTER_DEFAULTS, n as VECTOR_FILTER_LABELS, o as VECTOR_FILTER_MENU, p as VECTOR_FILTER_PARAM_SPECS, q as VECTOR_GRADIENT_MAX_PERIODS, r as VECTOR_GRADIENT_MIN_STOPS, s as VectorBooleanOperand, t as VectorFilterPrimitive, u as VectorGradientPoints, v as VectorGradientRamp, w as VectorGradientSvgOptions, x as VectorPaintSvgOptions, y as VectorRgba, z as VectorSvgImportOptions, A as VectorSvgPatternDef, B as VectorSvgWrapper, C as activeVectorEffects, D as activeVectorFilters, E as applyVectorCornersAttribute, F as applyVectorEffects, G as applyVectorGradientPatch, H as applyVectorGradientSpread, I as clearVectorLiveBooleanCache, J as convertVectorGradient, K as createVectorEffect, L as createVectorFilter, M as defaultVectorGradient, N as expandVectorAppearance, O as expandVectorAppearances, P as expandVectorGradientSpread, Q as expandVectorGradientStops, R as explicitVectorGradient, S as foldVectorBooleanOperands, T as gradientMidpointRemap, U as hasExplicitGradientGeometry, W as hasOwnVectorAppearance, X as hasVectorAppearance, Y as insertVectorGradientStop, Z as isCentredVectorGradient, _ as isVectorFilterType, $ as isVectorGradient, a0 as isVectorLiveBoolean, a1 as mapVectorGradient, a2 as mapVectorPaint, a3 as moveVectorGradientHandle, a4 as moveVectorGradientStop, a5 as normalizeVectorEffectParams, a6 as normalizeVectorFilterParams, a7 as parseSvgTransform, a8 as parseVectorColor, a9 as parseVectorSvg, aa as patternAttrs, ab as periodicVectorGradientStops, ac as pinVectorGradient, ad as removeVectorGradientStop, ae as reverseVectorGradient, af as samplePlainStops, ag as sampleVectorGradient, ah as sampleVectorGradientAt, ai as sampleVectorPaintDefAt, aj as sanitizeVectorEffects, ak as sanitizeVectorFilters, al as sanitizeVectorGradient, am as setVectorGradientVector, an as sortedVectorGradientStops, ao as spanVectorGradientStops, ap as transformVectorEffects, aq as transformVectorGradient, ar as transformVectorPaint, as as vectorAppearanceNodes, at as vectorAppearanceOutline, au as vectorAppearanceShapes, av as vectorBoxMatrix, aw as vectorChildAppearanceShapes, ax as vectorCornersAttribute, ay as vectorDocumentToSvg, az as vectorEffectInputBounds, aA as vectorEffectInputPaths, aB as vectorEnteredGroups, aC as vectorEnvelopeFrame, aD as vectorEnvelopeMap, aE as vectorEnvelopeMesh, aF as vectorFilterMarkup, aG as vectorFilterParamKeys, aH as vectorFilterReach, aI as vectorFilterSvg, aJ as vectorGradientArea, aK as vectorGradientAspect, aL as vectorGradientFocalParam, aM as vectorGradientHandles, aN as vectorGradientMatrix, aO as vectorGradientMidpointFromPosition, aP as vectorGradientMidpointPosition, aQ as vectorGradientNeedsExpansion, aR as vectorGradientParam, aS as vectorGradientPoints, aT as vectorGradientRamp, aU as vectorGradientSvgDefs, aV as vectorGradientTAt, aW as vectorGradientUnitsMatrix, aX as vectorLiveBooleanSteps, aY as vectorNodeEnvelope, aZ as vectorNodeFilterSvg, a_ as vectorNodeLocalPaintBounds, a$ as vectorOperandOperation, b0 as vectorPaintToSvg, b1 as vectorPathLocalBounds, b2 as vectorStrokeSvgParts, b3 as widthProfileFromAttribute, b4 as widthProfileToAttribute } from '../svg-D_cfkhlB.cjs';
+import { a as VectorGradientHandle, V as VectorSvgExportOptions, b as VectorGradientPatch, c as VectorEnvelopeParams, d as VectorRenderFilter, e as VectorAppearanceShape, f as VectorFilterParamSpec, g as VectorEffectParamSpec, h as VectorRenderStrokeParts, i as VectorPaintDef } from '../svg-BnRj0q8i.cjs';
+export { j as VECTOR_EFFECT_DEFAULTS, k as VECTOR_EFFECT_LABELS, l as VECTOR_EFFECT_PARAM_SPECS, m as VECTOR_FILTER_DEFAULTS, n as VECTOR_FILTER_LABELS, o as VECTOR_FILTER_MENU, p as VECTOR_FILTER_PARAM_SPECS, q as VECTOR_GRADIENT_MAX_PERIODS, r as VECTOR_GRADIENT_MIN_STOPS, s as VectorBooleanOperand, t as VectorFilterPrimitive, u as VectorGradientPoints, v as VectorGradientRamp, w as VectorGradientSvgOptions, x as VectorPaintSvgOptions, y as VectorRgba, z as VectorSvgImportOptions, A as VectorSvgPatternDef, B as VectorSvgWrapper, C as activeVectorEffects, D as activeVectorFilters, E as applyVectorCornersAttribute, F as applyVectorEffects, G as applyVectorGradientPatch, H as applyVectorGradientSpread, I as clearVectorLiveBooleanCache, J as convertVectorGradient, K as createVectorEffect, L as createVectorFilter, M as defaultVectorGradient, N as expandVectorAppearance, O as expandVectorAppearances, P as expandVectorGradientSpread, Q as expandVectorGradientStops, R as explicitVectorGradient, S as foldVectorBooleanOperands, T as gradientMidpointRemap, U as hasExplicitGradientGeometry, W as hasOwnVectorAppearance, X as hasVectorAppearance, Y as insertVectorGradientStop, Z as isCentredVectorGradient, _ as isVectorFilterType, $ as isVectorGradient, a0 as isVectorLiveBoolean, a1 as mapVectorGradient, a2 as mapVectorPaint, a3 as moveVectorGradientHandle, a4 as moveVectorGradientStop, a5 as normalizeVectorEffectParams, a6 as normalizeVectorFilterParams, a7 as parseSvgTransform, a8 as parseVectorColor, a9 as parseVectorSvg, aa as patternAttrs, ab as periodicVectorGradientStops, ac as pinVectorGradient, ad as removeVectorGradientStop, ae as reverseVectorGradient, af as samplePlainStops, ag as sampleVectorGradient, ah as sampleVectorGradientAt, ai as sampleVectorPaintDefAt, aj as sanitizeVectorEffects, ak as sanitizeVectorFilters, al as sanitizeVectorGradient, am as setVectorGradientVector, an as sortedVectorGradientStops, ao as spanVectorGradientStops, ap as transformVectorEffects, aq as transformVectorGradient, ar as transformVectorPaint, as as vectorAppearanceNodes, at as vectorAppearanceOutline, au as vectorAppearanceShapes, av as vectorBoxMatrix, aw as vectorChildAppearanceShapes, ax as vectorCornersAttribute, ay as vectorDocumentToSvg, az as vectorEffectInputBounds, aA as vectorEffectInputPaths, aB as vectorEnteredGroups, aC as vectorEnvelopeFrame, aD as vectorEnvelopeMap, aE as vectorEnvelopeMesh, aF as vectorFilterMarkup, aG as vectorFilterParamKeys, aH as vectorFilterReach, aI as vectorFilterSvg, aJ as vectorGradientArea, aK as vectorGradientAspect, aL as vectorGradientFocalParam, aM as vectorGradientHandles, aN as vectorGradientMatrix, aO as vectorGradientMidpointFromPosition, aP as vectorGradientMidpointPosition, aQ as vectorGradientNeedsExpansion, aR as vectorGradientParam, aS as vectorGradientPoints, aT as vectorGradientRamp, aU as vectorGradientSvgDefs, aV as vectorGradientTAt, aW as vectorGradientUnitsMatrix, aX as vectorInstanceDrawn, aY as vectorLiveBooleanSteps, aZ as vectorNodeEnvelope, a_ as vectorNodeFilterSvg, a$ as vectorNodeLocalPaintBounds, b0 as vectorOperandOperation, b1 as vectorPaintToSvg, b2 as vectorPathLocalBounds, b3 as vectorStrokeSvgParts, b4 as widthProfileFromAttribute, b5 as widthProfileToAttribute } from '../svg-BnRj0q8i.cjs';
 import { H as HistoryManager } from '../HistoryManager-DeQQMBCj.cjs';
+import { a as TextFont, L as LaidFragment, f as LaidLine, e as TextLayout, T as TextShaper } from '../warp-B39VsOtd.cjs';
+export { g as VECTOR_WARP_STYLES, h as VECTOR_WARP_STYLE_LABELS, W as VectorWarpPreset, i as dragVectorMeshPoint, j as evalVectorMesh, k as fitVectorMesh, l as isValidVectorMesh, m as mapVectorMeshPoints, p as pullVectorMesh, r as removeVectorMeshSplitU, n as removeVectorMeshSplitV, o as resizeVectorMesh, s as splitVectorMeshU, q as splitVectorMeshV, t as vectorIdentityMesh, w as vectorMeshColumns, u as vectorMeshControlBounds, v as vectorMeshEditPoints, x as vectorMeshGridCurves, y as vectorMeshParamAt, z as vectorMeshRows, A as vectorWarpPresetGrid, B as vectorWarpPresetMesh } from '../warp-B39VsOtd.cjs';
+import { A as AffineMatrix, V as Vec2 } from '../types-CwMPoRMU.cjs';
+export { H as VectorHomography } from '../types-CwMPoRMU.cjs';
 import { C as CommandSpec } from '../registry-CaR7LC6W.cjs';
 import { S as StrokeJoin, a as StrokeCap, P as PlanarMap, b as PathfinderOperation, c as PathfinderShape } from '../pathfinder-BZL8aSu0.cjs';
 import { b as AnimationEasing } from '../easing-lM0Xo9Ni.cjs';
-export { a as applyVectorHomography, o as orderVectorQuad, s as solve8, h as vectorHomography, b as vectorHomographyKeepsQuad } from '../homography-CZ-tFjay.cjs';
-import { A as AffineMatrix, V as Vec2 } from '../types-CwMPoRMU.cjs';
-export { H as VectorHomography } from '../types-CwMPoRMU.cjs';
-export { a as VECTOR_WARP_STYLES, b as VECTOR_WARP_STYLE_LABELS, W as VectorWarpPreset, d as dragVectorMeshPoint, e as evalVectorMesh, f as fitVectorMesh, i as isValidVectorMesh, m as mapVectorMeshPoints, p as pullVectorMesh, r as removeVectorMeshSplitU, c as removeVectorMeshSplitV, g as resizeVectorMesh, s as splitVectorMeshU, h as splitVectorMeshV, j as vectorIdentityMesh, w as vectorMeshColumns, k as vectorMeshControlBounds, l as vectorMeshEditPoints, n as vectorMeshGridCurves, o as vectorMeshParamAt, q as vectorMeshRows, t as vectorWarpPresetGrid, u as vectorWarpPresetMesh } from '../warp-D5jz_tN7.cjs';
+export { C as CanvasTextShaperOptions, O as OpenTypeFont, a as OutlineFontEntry, b as OutlineFontFace, c as OutlinePathCommand, d as applyVectorHomography, e as createCanvasTextShaper, f as createMetricTextShaper, g as createOutlineTextShaper, h as cssFontFamily, l as loadOpenTypeFont, o as orderVectorQuad, p as parseOpenTypeFont, s as solve8, i as vectorHomography, j as vectorHomographyKeepsQuad } from '../opentype-Dpe75vL5.cjs';
 import '../types-DsiXGmjo.cjs';
 import '../schema-Di0CS6Pe.cjs';
 
@@ -90,6 +91,8 @@ declare function locateVectorNode(nodes: VectorNode[], id: string): {
     index: number;
     parent: VectorGroupNode | null;
 } | null;
+/** Every node that paints with fills and strokes in the subtree: paths and text. */
+declare function collectPaintedNodes(node: VectorNode): Array<VectorPathNode | VectorTextNode>;
 /** Every path node in the subtree (a path node itself, or a group's descendants). */
 declare function collectPathNodes(node: VectorNode): VectorPathNode[];
 /** The node's local → parent matrix (identity when it has no `transform`). */
@@ -257,11 +260,11 @@ declare function expandVectorCorners(subpaths: readonly VectorSubpath[]): Vector
  * 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;
+declare function setAnchorCorner(a: VectorAnchor, radius: number, kind?: VectorCornerKind, smoothing?: number): 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;
+declare function setSubpathCorners(sp: VectorSubpath, radius: number, kind?: VectorCornerKind, smoothing?: number): VectorSubpath;
 
 /**
  * Variable-width stroke profiles: stroke widths at positions along a path (each subpath on its
@@ -461,6 +464,487 @@ 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$1): VectorGradientPart | null;
 
+/**
+ * Connectors glued to objects: connection sites, routing and rerouting after every edit.
+ *
+ * After wordcraft's `crates/doc/src/connector.rs` (`sites`, `site_point`, `nearest_site`,
+ * `connector_segs`, `reroute_group`) and deckcraft's `crates/engine/src/connect.rs` (`sites`,
+ * `nearest_site`, `reroute`, `set_glue`) (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
+ * THIRD_PARTY_NOTICES.md): an end is glued to a site of another object (here a side's middle or the
+ * centre of its own bounds, through its rotation); the connector is routed again whenever what it
+ * is glued to changes, and glue to an object that no longer exists is dropped, the end staying where
+ * it was. Straight, elbow and curved routes follow `connector_segs`; elbows leave and enter along the
+ * sides' normals (a gap out first) and curves take their handles along them. `auto` sides (the one
+ * facing the other end) are ours.
+ */
+
+type Vec$1 = {
+    x: number;
+    y: number;
+};
+/** A connection site in document space: where an end meets the object, and the side's outward normal. */
+interface VectorConnectionSite {
+    side: Exclude<VectorConnectorSide, 'auto'>;
+    x: number;
+    y: number;
+    /** Unit outward normal (zero for the centre). */
+    nx: number;
+    ny: number;
+}
+/** Whether the node is a connector path. */
+declare function isVectorConnector(node: VectorNode | null | undefined): node is VectorPathNode & {
+    connector: VectorConnector;
+};
+/**
+ * The connection sites of node `id` in document space, in the order top, right, bottom, left,
+ * centre: the middles of its own (unrotated) bounds' sides, through its rotation and its ancestors'.
+ * Empty for a connector, a hidden node or one without extent.
+ */
+declare function vectorConnectionSites(nodes: readonly VectorNode[], id: string): VectorConnectionSite[];
+/** The site of `sites` nearest `p` (document space) within `radius`, or null. */
+declare function nearestVectorConnectionSite(sites: readonly VectorConnectionSite[], p: Vec$1, radius?: number): VectorConnectionSite | null;
+/** A routed end: its point and the direction the line leaves it (zero when it has none). */
+interface RoutedEnd {
+    x: number;
+    y: number;
+    nx: number;
+    ny: number;
+    glued: boolean;
+}
+/** The connector's path in document space, from routed ends. */
+declare function vectorConnectorWorldAnchors(a: RoutedEnd, b: RoutedEnd, route: VectorConnectorRoute, options?: {
+    radius?: number;
+    gap?: number;
+}): VectorAnchor[];
+/** What routing a connector gives: its new subpaths (own space) and which ends lost their object. */
+interface VectorConnectorRouting {
+    subpaths: VectorSubpath[];
+    /** The resolved sides of its glued ends (null when not glued). */
+    startSide: Exclude<VectorConnectorSide, 'auto'> | null;
+    endSide: Exclude<VectorConnectorSide, 'auto'> | null;
+    /** Ends glued to an object that no longer exists (or has no extent). */
+    dropped: {
+        start: boolean;
+        end: boolean;
+    };
+}
+/** Routes connector `id` of `nodes` from where its ends are glued (or stored), or null when it is not a connector. */
+declare function routeVectorConnector(nodes: readonly VectorNode[], id: string): VectorConnectorRouting | null;
+/**
+ * The document with every connector routed again (glue to objects that no longer exist dropped);
+ * the same object when nothing moved.
+ */
+declare function rerouteVectorConnectors<D extends Pick<VectorDocument, 'nodes'>>(doc: D): D;
+/** Reads connector settings from untrusted data (JSON, SVG import), or null. */
+declare function sanitizeVectorConnector(value: unknown): VectorConnector | null;
+/** Labels for the connector pickers. */
+declare const VECTOR_CONNECTOR_ROUTE_LABELS: Readonly<Record<VectorConnectorRoute, string>>;
+declare const VECTOR_CONNECTOR_SIDE_LABELS: Readonly<Record<VectorConnectorSide, string>>;
+/** What the connector panel shows: the first selected connector, or null. */
+interface VectorConnectorPanel {
+    id: string;
+    route: VectorConnectorRoute;
+    radius: number;
+    gap: number;
+    start: VectorConnectorEnd | null;
+    end: VectorConnectorEnd | null;
+}
+/** The connector panel's data for a selection. */
+declare function getVectorConnectorPanel(state: {
+    document: Pick<VectorDocument, 'nodes'>;
+    selection: readonly string[];
+}): VectorConnectorPanel | null;
+/**
+ * What a connector end dragged to `p` (document space) glues to: the nearest connection site
+ * within `radius` of a top-level object (that side), else the object under `p` (`auto`), else
+ * null (a free end). Connectors, hidden and locked objects and `exclude` are skipped.
+ */
+declare function vectorConnectorTargetAt(nodes: readonly VectorNode[], p: Vec$1, radius: number, exclude?: string): (VectorConnectorEnd & {
+    site: VectorConnectionSite | null;
+}) | null;
+
+declare class VectorExprError extends Error {
+}
+/** A valid name: a letter or `_`, then letters, digits or `_` (not `pi`), at most 64 characters. */
+declare function isValidVectorParameterName(s: string): boolean;
+/** Checks an expression's syntax (throws a `VectorExprError` saying what is wrong). */
+declare function checkVectorExpression(text: string): void;
+/** Names an expression refers to. */
+declare function vectorExpressionNames(text: string): string[];
+/** Named expressions (parameters and dimensional constraint names), evaluated lazily with cycle detection. */
+declare class VectorExprEnv {
+    private readonly exprs;
+    private readonly cache;
+    set(name: string, expr: string): void;
+    has(name: string): boolean;
+    /** The value of a name. */
+    value(name: string, stack?: string[]): number;
+    /** Evaluates a free expression against these names. */
+    eval(text: string): number;
+}
+/** Evaluates an expression with no names. */
+declare function evalVectorExpression(text: string): number;
+/** A value as an expression: up to 6 decimals, trailing zeros trimmed. */
+declare function formatVectorValue(v: number): string;
+
+/** Most constraints one document may hold. */
+declare const VECTOR_MAX_CONSTRAINTS = 2000;
+declare const VECTOR_DIMENSIONAL_KINDS: ReadonlySet<VectorConstraintKind>;
+declare class VectorConstraintError extends Error {
+    /** Constraints involved (conflicting or duplicated), when known. */
+    readonly ids: string[];
+    constructor(message: string, 
+    /** Constraints involved (conflicting or duplicated), when known. */
+    ids?: string[]);
+}
+/** Subpath and index of the anchor with `id` in a path, or null. */
+declare function findVectorAnchorById(node: VectorPathNode, id: string): {
+    subpath: number;
+    index: number;
+} | null;
+/** The round closed path's centre and radius (document space), or null when it is not round. */
+declare function vectorPathCircle(node: VectorPathNode, world?: AffineMatrix): {
+    c: Vec2$1;
+    r: number;
+} | null;
+/** The expression environment: the document's parameters and named dimensional constraints. */
+declare function vectorConstraintEnv(doc: VectorDocument): VectorExprEnv;
+/** The value of a dimensional constraint (degrees for angles). */
+declare function vectorConstraintValue(env: VectorExprEnv, c: VectorConstraint): number;
+/** What a solve did. */
+interface VectorSolveResult {
+    /** The document with the solved geometry (the same object when nothing moved). */
+    document: VectorDocument;
+    /** Every component converged (every constraint holds). */
+    converged: boolean;
+    /** Constraints in conflict where a component did not converge. */
+    conflicts: string[];
+    /** Constraints that could not be interpreted (and were ignored), with the reason. */
+    skipped: {
+        id: string;
+        message: string;
+    }[];
+}
+/**
+ * Solves the document's constraints and writes the geometry back. `previous` (the last solved
+ * document) marks what was just edited, which moves least. A component that cannot be solved is
+ * left with its best compromise and reported in `conflicts`.
+ */
+declare function solveVectorConstraints(doc: VectorDocument, previous?: VectorDocument | null): VectorSolveResult;
+/** The largest residual of each constraint at the current geometry (null when it cannot be interpreted). */
+declare function vectorConstraintResiduals(doc: VectorDocument): Map<string, number | null>;
+/** The current value of a dimensional constraint's references (degrees for angles). */
+declare function measureVectorConstraint(doc: VectorDocument, c: Pick<VectorConstraint, 'kind' | 'refs' | 'axis'>): number;
+/** Checks a constraint's references against the document (throws with what is needed). */
+declare function validateVectorConstraint(doc: VectorDocument, c: VectorConstraint): void;
+/** Next free name for a dimensional constraint (`d1`, `ang2`, `rad1`, `dia1`). */
+declare function nextVectorConstraintName(doc: VectorDocument, kind: VectorConstraintKind): string;
+/**
+ * Adds a constraint to the document: names and measures a dimensional one without a value,
+ * refuses one that conflicts with the others or duplicates them (over-constrains), solves and
+ * returns the new document. Throws a `VectorConstraintError` naming the constraints involved.
+ */
+declare function addVectorConstraint(doc: VectorDocument, input: VectorConstraint): VectorDocument;
+/** Constraint state of the drawing or a part of it. */
+type VectorDofStatus = 'unconstrained' | 'under' | 'fully' | 'over' | 'unknown';
+interface VectorDofReport {
+    /** Remaining degrees of freedom (null when too large to analyse). */
+    dof: number | null;
+    status: VectorDofStatus;
+    /** Equations that only repeat others. */
+    redundant: number;
+    constraints: number;
+    /** Per constrained path: its parameters and remaining freedom. */
+    nodes: {
+        nodeId: string;
+        params: number;
+        dof: number | null;
+        status: VectorDofStatus;
+    }[];
+    message: string;
+}
+/** Degrees of freedom the constraints leave (QR rank of the Jacobian per component; per path by null space). */
+declare function vectorConstraintDof(doc: VectorDocument): VectorDofReport;
+/** Constraints whose references are gone (deleted paths or anchors) or no longer fit, removed. */
+declare function purgeVectorConstraints(doc: VectorDocument): {
+    document: VectorDocument;
+    removed: string[];
+};
+
+interface VectorInferOptions {
+    /** Document units (default 0.5). */
+    distanceTolerance?: number;
+    /** Degrees (default 1). */
+    angleTolerance?: number;
+    /** Kinds to infer (default all of them). */
+    kinds?: readonly VectorConstraintKind[];
+}
+/** The path with every anchor given a stable id (`a1`, `a2`, …; existing ids kept). */
+declare function withVectorAnchorIds(node: VectorPathNode): VectorPathNode;
+/** The document with every anchor of the paths `ids` (all paths when absent) given an id. */
+declare function withVectorDocumentAnchorIds(doc: VectorDocument, ids?: ReadonlySet<string>): VectorDocument;
+/**
+ * Candidate constraints the paths `ids` (default all) nearly satisfy, most important first. Their
+ * anchors need ids (`withVectorDocumentAnchorIds`); candidates have ids `auto-<n>`.
+ */
+declare function inferVectorConstraints(doc: VectorDocument, ids?: readonly string[] | null, options?: VectorInferOptions): VectorConstraint[];
+/**
+ * Auto-constrain: anchors of the paths given ids, the inferred constraints added one by one with
+ * `newId` ids (each solved; refused ones, redundant or conflicting, skipped). Returns the document
+ * and the constraints added.
+ */
+declare function autoConstrainVector(doc: VectorDocument, ids: readonly string[] | null, newId: () => string, options?: VectorInferOptions): {
+    document: VectorDocument;
+    added: VectorConstraint[];
+};
+
+/**
+ * Text nodes: layout through the shared text engine (`src/text`, also used by the image editor's
+ * type layers), glyph placement for point, area and path text, glyph outlines, and the pure edits
+ * the controller and agent commands build on.
+ *
+ * Fonts come from one text shaper per page (`setVectorTextShaper`; the controller's `textShaper`
+ * option sets it). In browsers the default is the Canvas 2D shaper (the browser's own fonts, no
+ * outlines: text draws as SVG `<text>`), elsewhere a metric shaper that estimates advances. With an
+ * outline shaper (`createOutlineTextShaper` over fonts read by `parseOpenTypeFont`), text draws as
+ * its glyph outlines, so path effects, envelopes and Create Outlines work on it.
+ */
+
+/**
+ * Sets the text shaper every vector editor on the page lays text out with (`null`: back to the
+ * default). Text nodes already laid out with another shaper lay out again when next drawn.
+ */
+declare function setVectorTextShaper(shaper: TextShaper | null): void;
+/** The text shaper in use: the one set, else the browser's (Canvas 2D), else the metric shaper. */
+declare function getVectorTextShaper(): TextShaper;
+/** Bumped whenever the shaper changes (part of every layout cache key). */
+declare function vectorTextShaperGeneration(): number;
+/** Whether the shaper gives glyph outlines (text then draws as paths, and Create Outlines works). */
+declare function vectorTextHasOutlines(): boolean;
+/** Families the shaper can draw, when it can tell (always includes the generic families). */
+declare function vectorTextFamilies(): string[];
+declare const DEFAULT_VECTOR_FONT: Readonly<VectorCharacterStyle>;
+/** Character style fields, in the order agents see them. */
+declare const VECTOR_CHARACTER_STYLE_KEYS: readonly ["fontFamily", "fontWeight", "italic", "fontSize", "tracking", "leading", "baselineShift", "underline", "strikethrough"];
+/** Paragraph style fields. */
+declare const VECTOR_PARAGRAPH_STYLE_KEYS: readonly ["align", "autoLeading", "firstLineIndent", "startIndent", "endIndent", "spaceBefore", "spaceAfter"];
+declare class VectorTextError extends Error {
+}
+/** A resolved run: the node's style with the run's fields over it. */
+interface VectorResolvedRun {
+    start: number;
+    end: number;
+    style: VectorCharacterStyle;
+    /** The run's own fill, when it has one. */
+    fill?: VectorPaint;
+}
+/**
+ * Runs fitted to a text of `length`: cut at its end, and text past the last run in the node's own
+ * style (an empty override). Neighbours with equal styles merge.
+ */
+declare function fitVectorTextRuns(runs: readonly VectorTextRun[], length: number): VectorTextRun[];
+/** The node's runs fitted to its text, each with the full style it draws in. */
+declare function vectorTextRuns(node: Pick<VectorTextNode, 'text' | 'font' | 'runs'>): VectorResolvedRun[];
+/** The style at code unit `index` (the run holding it; past the end, the last run). */
+declare function vectorTextStyleAt(node: Pick<VectorTextNode, 'text' | 'font' | 'runs'>, index: number): VectorResolvedRun;
+/** A subpath flattened and measured by arc length. */
+interface VectorPathMeasure {
+    points: Vec2$1[];
+    /** Cumulative length at each point. */
+    lengths: number[];
+    closed: boolean;
+    length: number;
+}
+/** Measures a path's first subpath by arc length (reversed when `reverse`). */
+declare function measureVectorPath(path: BezierPath, reverse?: boolean): VectorPathMeasure;
+/**
+ * Point and unit tangent at arc length `s`. Closed paths wrap; open paths continue straight along
+ * their end tangents past either end.
+ */
+declare function vectorPathAt(m: VectorPathMeasure, s: number): {
+    point: Vec2$1;
+    tangent: Vec2$1;
+};
+/**
+ * Arc-length positions for character pivots along a path: `xs` are the pivots along the line,
+ * `[x0, x1]` the line's extent. `left` / `center` / `right` keep the spacing; `justify` spreads the
+ * pivots over the path between the margins.
+ */
+declare function vectorPathTextPositions(xs: readonly number[], line: [number, number], align: 'left' | 'center' | 'right' | 'justify', length: number, start: number, end: number): number[];
+/** One placed character, in the node's own space. */
+interface VectorTextGlyph {
+    /** Index of its first code unit in the text. */
+    index: number;
+    /** The character (two code units for a surrogate pair). */
+    char: string;
+    /** Its origin: the start of the character on the baseline. */
+    x: number;
+    y: number;
+    /** Turn in degrees, clockwise on screen (0 for point and area text). */
+    angle: number;
+    advance: number;
+    /** The line's ascent and descent around the baseline. */
+    ascent: number;
+    descent: number;
+    /** Index into `fragments`. */
+    fragment: number;
+}
+/** A run of glyphs in one style on one line. */
+interface VectorTextFragment {
+    style: VectorCharacterStyle;
+    /** The font as the shaper resolved it (its family may be a fallback). */
+    font: TextFont;
+    fill?: VectorPaint;
+    /** Glyphs of this fragment: `glyphs.slice(from, to)`. */
+    from: number;
+    to: number;
+    line: number;
+    /** The shared engine's fragment and line (point and area text). */
+    laid?: {
+        fragment: LaidFragment;
+        line: LaidLine;
+    };
+}
+/** A laid-out text node. */
+interface VectorTextLayout {
+    /** The shaper it was laid out with. */
+    shaper: string;
+    glyphs: VectorTextGlyph[];
+    fragments: VectorTextFragment[];
+    /** Lines: their text range and baseline (node space for point and area text). */
+    lines: {
+        start: number;
+        end: number;
+        baseline: number;
+        x: number;
+        width: number;
+    }[];
+    /** Where text space (the shared layout's) starts in the node: the frame's origin. */
+    origin: Vec2$1;
+    /** The shared layout in text space (one line for path text). */
+    text: TextLayout;
+    /** Bounds of the glyph boxes (or the frame box of area text), node space; null when empty. */
+    bounds: VectorBounds | null;
+    /** Text that does not fit (lines below an area's box, characters past a path's end). */
+    overflow: boolean;
+    /** Families drawn with a fallback. */
+    missingFonts: string[];
+}
+/** Lays out a text node with the current shaper (memoised per node object and shaper). */
+declare function layoutVectorText(node: VectorTextNode): VectorTextLayout;
+/** The four corners of a glyph's box (origin, advance, ascent to descent), turned by its angle. */
+declare function glyphBox(g: VectorTextGlyph): Vec2$1[];
+/** The text as paths in the node's own space, one per fill (bottom to top in text order). */
+interface VectorTextPaths {
+    /** `fill`: a run's own fill, or undefined for the node's paint. */
+    parts: Array<{
+        fill?: VectorPaint;
+        path: BezierPath;
+    }>;
+    /** Whether these are glyph outlines (false: glyph boxes, for geometry without an outline shaper). */
+    outlines: boolean;
+}
+/**
+ * What a text node draws as geometry: its glyph outlines (plus underline and strike-through bars)
+ * with an outline shaper, else a box per glyph (ascent to descent), which bounds, hit-testing and
+ * snapping use. Memoised per node object and shaper.
+ */
+declare function vectorTextPaths(node: VectorTextNode): VectorTextPaths;
+/**
+ * The style a text node paints with as a path node (for the drawing machinery): its paint stacks,
+ * stroke settings and fill rule, with `fill` replacing the top fill's paint when given.
+ */
+declare function vectorTextPaintSource(node: VectorTextNode, fill?: VectorPaint, subpaths?: VectorSubpath[]): VectorPathNode;
+/** A caret as a segment from the top of its line to the bottom, node space. */
+interface VectorTextCaret {
+    top: Vec2$1;
+    bottom: Vec2$1;
+    /** The line it is on. */
+    line: number;
+}
+/** The caret before code unit `index` (after the last character at the end). */
+declare function vectorTextCaret(node: VectorTextNode, index: number): VectorTextCaret;
+/** The text index nearest a node-space point (for clicks). */
+declare function vectorTextIndexAt(node: VectorTextNode, p: Vec2$1): number;
+/** Quads (node space) covering the glyphs of [start, end), one per line for point and area text. */
+declare function vectorTextSelectionQuads(node: VectorTextNode, start: number, end: number): Vec2$1[][];
+/**
+ * A character style patch validated (`null` clears an optional field). With `full`, the result
+ * must be a complete style (the node's own).
+ */
+declare function patchVectorCharacterStyle<T extends Partial<VectorCharacterStyle>>(base: T, patch: Record<string, unknown>, path?: string): T;
+/** A paragraph style patch validated (`null` clears a field). */
+declare function patchVectorParagraphStyle(base: VectorParagraphStyle, patch: Record<string, unknown>, path?: string): VectorParagraphStyle;
+/** A frame from loose input, validated. */
+declare function sanitizeVectorTextFrame(value: unknown, path?: string): VectorTextFrame;
+/** Normalised runs: fitted to the text, empty overrides dropped, `null` when there is one plain style. */
+declare function normalizeVectorTextRuns(text: string, runs: readonly VectorTextRun[] | null | undefined): VectorTextRun[] | null;
+/** A text node read from untrusted data (JSON, SVG data attributes, agents): fields validated and normalised. */
+declare function sanitizeVectorTextFields(value: Record<string, unknown>): Pick<VectorTextNode, 'text' | 'font' | 'runs' | 'paragraph' | 'frame'>;
+/** A range of the text from loose input: [start, end) in UTF-16 code units (default the whole text). */
+declare function vectorTextRange(text: string, start: unknown, end: unknown): [number, number];
+/** The node with [start, end) of its text replaced by `insert` (styled like the character before it). */
+declare function replaceVectorText(node: VectorTextNode, start: number, end: number, insert: string): VectorTextNode;
+/**
+ * The node with a character style patch (and `fill`) applied over [start, end). The whole text
+ * changes the node's own style (and its `fill`) and drops those fields from its runs.
+ */
+declare function styleVectorText(node: VectorTextNode, start: number, end: number, patch: Record<string, unknown>): VectorTextNode;
+/**
+ * The node with scale and skew of `m` baked in (its rigid part goes to `transform` elsewhere): the
+ * frame's points map through `m`, font sizes scale by √|det| (text keeps its proportions), and an
+ * area's box takes each axis' own scale.
+ */
+declare function bakeVectorTextGeometry(node: VectorTextNode, m: AffineMatrix): VectorTextNode;
+/** The text of a node as a short name ("Hello world…"). */
+declare function vectorTextName(text: string): string;
+/** Parses loose path data for a path text frame (the first subpath). */
+declare function pathTextFrameFromBezier(path: BezierPath): VectorSubpath | null;
+/**
+ * The outline the editor shows for a text node (hover, selection), node space: an area's box, a
+ * path text's path, or a box round each line of point text.
+ */
+declare function vectorTextBoxOutline(node: VectorTextNode): BezierPath;
+/** One `<tspan>` of text drawn as SVG text: a fragment's characters, each placed on its own. */
+interface VectorTextSpan {
+    text: string;
+    /** Per-character origins (node space) and turns (degrees; absent when all are 0). */
+    x: number[];
+    y: number[];
+    rotate?: number[];
+    style: VectorCharacterStyle;
+    /** The family to draw with (the resolved one, a fallback when the family is missing). */
+    family: string;
+    /** The run's own fill, if it has one. */
+    fill?: VectorPaint;
+}
+/** The text as SVG text spans: one per fragment, every character placed by the layout. */
+declare function vectorTextSpans(node: VectorTextNode): VectorTextSpan[];
+/**
+ * The text as one path node in its style: its geometry (glyph outlines, or glyph boxes) and paint
+ * stacks. Paint servers and stroke layers of SVG text are computed on it.
+ */
+declare function vectorTextGeometryNode(node: VectorTextNode): VectorPathNode;
+/** One `<tspan>` as render data: per-character positions (space-separated lists) and its font. */
+interface VectorRenderTextSpan {
+    text: string;
+    x: string;
+    y: string;
+    /** Per-character turns in degrees (text on a path). */
+    rotate?: string;
+    /** A CSS `font-family` value. */
+    fontFamily: string;
+    fontSize: number;
+    fontWeight: number;
+    fontStyle?: 'italic';
+    /** `underline`, `line-through` or both. */
+    textDecoration?: string;
+    /** The run's own fill (a colour or `url(#id)`), for layers with `runFills`. */
+    fill?: string;
+}
+/** A span as render data (positions as SVG number lists), with the run's fill as drawn. */
+declare function vectorTextSpanSvg(sp: VectorTextSpan, fill?: string): VectorRenderTextSpan;
+
 /** A map of the plane (document or node space). */
 type VectorPointMap = (p: Vec2$1) => Vec2$1;
 /** Every anchor and handle of `subpaths` through `f` (no subdivision). */
@@ -537,7 +1021,7 @@ interface VectorGuideLine {
     y2: number;
 }
 /** What a point or box snapped to. */
-type VectorSnapKind = 'anchor' | 'centre' | 'intersect' | 'perpendicular' | 'tangent' | 'path' | 'construction' | 'align' | 'spacing' | 'size';
+type VectorSnapKind = 'anchor' | 'centre' | 'intersect' | 'perpendicular' | 'tangent' | 'path' | 'construction' | 'align' | 'spacing' | 'size' | 'tracking';
 /** A guide label in document units: the snap kind's name, or a distance for gaps and sizes. */
 interface VectorGuideLabel {
     kind: VectorSnapKind;
@@ -585,6 +1069,37 @@ interface VectorSnapLeave {
     /** Snap to the perpendicular foot and tangent points from `at` on paths (default true). */
     curves?: boolean;
 }
+/**
+ * A tracking path (CAD object snap tracking): a ray from `origin` along the unit `dir`. Acquired
+ * points send `alignment` paths, an acquired end of an open path its `extension`, and the point a
+ * drawn point leaves from its `polar` angles. Points snap where two paths cross, where a path
+ * crosses a path of the drawing, or onto the nearest path.
+ */
+interface VectorTrackingPath {
+    origin: Vec2$1;
+    dir: Vec2$1;
+    kind: 'alignment' | 'extension' | 'polar';
+}
+/** A point acquired for tracking, and the direction of its path's extension when it ends an open path. */
+interface VectorTrackingPoint {
+    x: number;
+    y: number;
+    extension?: Vec2$1 | null;
+}
+/** The most points kept acquired (the oldest dropped first), as AutoCAD keeps. */
+declare const VECTOR_MAX_TRACKING_POINTS = 7;
+/** A unit direction for `deg` degrees counter-clockwise on the y-down page (exact on the axes). */
+declare function vectorAngleDirection(deg: number): Vec2$1;
+/**
+ * Polar angles (degrees, counter-clockwise on the page, in [0, 360)): every multiple of
+ * `increment` round the circle plus the `additional` angles, without repeats, at most 360. After
+ * cadcraft's `polar_angles` (POLARANG / POLARADDANG).
+ */
+declare function vectorPolarAngles(increment: number, additional?: readonly number[]): number[];
+/** The increment (degrees) that `angles` are the multiples of, as lines (so 0, 45, 90, 135 is 45), or null when they are not one increment's multiples. */
+declare function vectorPolarIncrementOf(angles: readonly number[]): number | null;
+/** The paths acquired points send: a ray along each of `angles` (degrees) from each, plus its extension. After cadcraft's `Tracker::paths`. */
+declare function vectorTrackingPaths(points: readonly VectorTrackingPoint[], angles?: readonly number[]): VectorTrackingPath[];
 /** The construction guide angles new editors start with. */
 declare const VECTOR_CONSTRUCTION_ANGLES: readonly number[];
 /** Where `constrain` puts `p` (unchanged without one). */
@@ -604,6 +1119,7 @@ declare class VectorSnapTargets {
     private readonly boxes;
     /** Side lengths of the other objects (in their own frames), which a resize may match. */
     private readonly sizes;
+    private segmentTree;
     private constructor();
     /** How many targets of each sort were gathered. */
     get counts(): {
@@ -658,7 +1174,7 @@ declare class VectorSnapTargets {
      * through `leave.at` (where a target's line crosses it if one does nearby), or else lines up
      * with targets on x and y.
      */
-    snapFrom(p: Vec2$1, leave: VectorSnapLeave | null | undefined, tol: number): VectorPointSnap;
+    snapFrom(p: Vec2$1, leave: VectorSnapLeave | null | undefined, tol: number, tracking?: readonly VectorTrackingPath[]): VectorPointSnap;
     private label;
     /** The anchor or centre nearest `p`, within `tol`. */
     private nearestPoint;
@@ -733,8 +1249,18 @@ interface VectorSnapOptions {
     guides: boolean;
     /** How near a target pulls, in screen pixels (default 5). */
     threshold: number;
-    /** Construction guide angles through the point a drawn point leaves from, in degrees (default 0, 45, 90, 135). */
+    /** Construction guide angles through the point a drawn point leaves from, in degrees (default 0, 45, 90, 135). Polar tracking: see `vectorPolarAngles`. */
     angles: readonly number[];
+    /**
+     * Object snap tracking (default true): resting the pointer on an anchor, centre or crossing
+     * while drawing acquires it (again releases it); acquired points send alignment paths, an open
+     * path's end its extension, and points snap where paths cross, cross the drawing or onto them.
+     */
+    tracking?: boolean;
+    /** Acquired points send paths along every polar angle (`angles`) instead of only horizontal and vertical (default false). */
+    trackPolar?: boolean;
+    /** The pen measures polar angles from its last segment's direction instead of the page's x axis (default false). */
+    polarRelative?: boolean;
 }
 /** Snap options new editors start with. Hold Cmd / Ctrl (`mod`) during a drag to bypass snapping. */
 declare const DEFAULT_VECTOR_SNAP: Readonly<VectorSnapOptions>;
@@ -792,6 +1318,60 @@ interface VectorEditorOptions {
     onChange?: (document: VectorDocument) => void;
     /** Start in Free Distort mode (see `setFreeDistort`). */
     freeDistort?: boolean;
+    /**
+     * The text shaper text nodes lay out with (see `setVectorTextShaper`; it is shared by every
+     * editor on the page). Default: the browser's fonts, or estimated metrics outside a browser.
+     */
+    textShaper?: TextShaper | null;
+    /** Font and alignment new text gets (default 24 px sans-serif, left). */
+    textDefaults?: Partial<VectorTextDefaults>;
+}
+/** Font and alignment of new text. */
+interface VectorTextDefaults extends VectorCharacterStyle {
+    align?: VectorTextAlign;
+}
+/** Text to add (`addText`): point text at (`x`, `y`), area text with `width` and `height`, or text on `path`. */
+interface VectorTextInput extends VectorStyle {
+    text: string;
+    /** Point text: the first baseline's start; area text: the box's top left. */
+    x?: number;
+    y?: number;
+    /** Area text: the box (both needed). */
+    width?: number;
+    height?: number;
+    /** Text on a path: SVG path data or a subpath (document units); `x`, `y`, `width` and `height` are then ignored. */
+    path?: string | VectorSubpath;
+    /** Text on a path: margins from the path's start and end, side, orientation and baseline. */
+    pathOptions?: Omit<Extract<VectorTextFrame, {
+        kind: 'path';
+    }>, 'kind' | 'path'>;
+    font?: Partial<VectorCharacterStyle>;
+    paragraph?: VectorParagraphStyle;
+    name?: string;
+}
+/** A constraint reference from loose input: an anchor by `subpath` / `index` (or its `id` as `anchor`), its handle, its segment, or a path as a circle. */
+interface VectorConstraintRefInput {
+    nodeId: string;
+    subpath?: number;
+    index?: number;
+    anchor?: string;
+    handle?: 'in' | 'out';
+    segment?: boolean;
+    circle?: boolean;
+}
+/** A constraint to add (`addConstraint`). */
+interface VectorConstraintInput {
+    kind: VectorConstraintKind;
+    refs: VectorConstraintRefInput[];
+    value?: string | number;
+    name?: string;
+    axis?: 'aligned' | 'horizontal' | 'vertical';
+}
+/** The text being edited on the canvas: the node and the selection in UTF-16 code units (`anchor` where it started, `focus` the caret). */
+interface VectorTextEditState {
+    nodeId: string;
+    anchor: number;
+    focus: number;
 }
 /** A pointer event as the controller needs it. Positions are in screen pixels relative to the canvas. */
 interface VectorPointerInput extends VectorModifiers {
@@ -941,6 +1521,16 @@ type VectorInteraction = {
     type: 'envelope';
     nodeId: string;
     index: number | null;
+}
+/** The Type tool dragging out an area text box (document space). */
+ | {
+    type: 'textBox';
+    bounds: VectorBounds;
+}
+/** Selecting text by dragging over it. */
+ | {
+    type: 'textSelect';
+    nodeId: string;
 } | {
     type: 'pan';
 };
@@ -999,6 +1589,34 @@ interface VectorEditorState {
      * a side skews along it (Alt: about the centre).
      */
     freeDistort: boolean;
+    /** The text being edited on the canvas, or null. Typing goes to `textInput`, keys to `keyDown`. */
+    textEdit: VectorTextEditState | null;
+    /** Font and alignment new text gets. */
+    textDefaults: VectorTextDefaults;
+    /**
+     * Isolation mode: `document` is then the art of symbol `symbolId`, in the symbol's own space.
+     * `host` is the whole document with that art (draw it dimmed behind, through `hostTransform`,
+     * which lines the instance it was entered from up with the art).
+     */
+    symbolEdit: {
+        symbolId: string;
+        name: string;
+        instanceId: string | null;
+        host: VectorDocument;
+        hostTransform: VectorMatrix | null;
+    } | null;
+    /** Constraints the last solve could not satisfy (`conflicts`) or interpret (`skipped`), or null when all hold. */
+    constraintIssues: {
+        conflicts: string[];
+        skipped: {
+            id: string;
+            message: string;
+        }[];
+    } | null;
+    /** Points acquired for object snap tracking (document units), oldest first. */
+    trackingPoints: readonly VectorTrackingPoint[];
+    /** A distance or coordinate being typed while the pen draws (Enter places the point), or null. */
+    typedEntry: string | null;
     canUndo: boolean;
     canRedo: boolean;
     undoLabel: string;
@@ -1020,6 +1638,48 @@ type VectorMaskResult = {
     ok: false;
     message: string;
 };
+/** A connector as `getConnectors` lists it. */
+interface VectorConnectorListing {
+    id: string;
+    name?: string;
+    route: VectorConnectorRoute;
+    radius?: number;
+    /** Each end: the glued object, its side setting and the side in use, and where the end is (document units). */
+    start: {
+        nodeId?: string;
+        side?: VectorConnectorSide;
+        resolvedSide?: string | null;
+        x?: number;
+        y?: number;
+    };
+    end: {
+        nodeId?: string;
+        side?: VectorConnectorSide;
+        resolvedSide?: string | null;
+        x?: number;
+        y?: number;
+    };
+}
+/** A frame as `getFrames` lists it. */
+interface VectorFrameListing {
+    id: string;
+    name: string;
+    /** The group holding it (null for an artboard: a top-level frame). */
+    parentId: string | null;
+    artboard: boolean;
+    /** Its rectangle in its own space, fill and clip. */
+    frame: VectorFrame;
+    /** Its rectangle in document space (axis-aligned). */
+    bounds: VectorBounds | null;
+    /** Its children, bottom to top, with their resizing constraints. */
+    children: {
+        id: string;
+        type: VectorNode['type'];
+        name?: string;
+        horizontal: VectorHorizontalResizing;
+        vertical: VectorVerticalResizing;
+    }[];
+}
 /** The shape the Blend tool blends from (its first click). */
 interface VectorBlendStart {
     nodeId: string;
@@ -1277,6 +1937,14 @@ declare class VectorEditorController {
     private blendDefaults;
     private gradientEdit;
     private freeDistort;
+    /** The text edit session: selection, the snapshot before a text node it created (until the first change), the merge key of its undo step. */
+    private textEdit;
+    private textEditCount;
+    private symbolEdit;
+    /** The document as last solved: what differs from it was just edited, so the solver moves it least. */
+    private lastSolved;
+    private constraintIssues;
+    private textDefaults;
     /** What the highlight shows, to skip notifying when the pointer stays over the same face. */
     private builderHoverKey;
     private readonly createId;
@@ -1306,6 +1974,11 @@ declare class VectorEditorController {
     private computeState;
     /** `doc` with its blends' steps brought up to date (the same object when they already are). */
     private refreshed;
+    /**
+     * `doc` with its constraints solved (geometry edited since the last solve moving least) and
+     * constraints on deleted anchors removed; the same object when nothing changes.
+     */
+    private solved;
     private notify;
     private boundsOf;
     private frameOf;
@@ -1509,8 +2182,15 @@ declare class VectorEditorController {
      */
     setCornerRadius(radius: number, options?: {
         kind?: VectorCornerKind;
+        smoothing?: number;
+        refs?: readonly VectorAnchorRef[];
+        ids?: readonly string[];
+    }): VectorActionResult;
+    /** Sets corner smoothing (squircle, 0–1) of the same anchors as `setCornerRadius`, keeping their radii. */
+    setCornerSmoothing(smoothing: number, options?: {
         refs?: readonly VectorAnchorRef[];
         ids?: readonly string[];
+        merge?: string;
     }): VectorActionResult;
     /** Sets the live corner kind of the same anchors as `setCornerRadius`, keeping their radii. */
     setCornerKind(kind: VectorCornerKind, options?: {
@@ -1854,6 +2534,170 @@ declare class VectorEditorController {
         invert?: boolean;
         name?: string;
     }): VectorMaskResult;
+    private trackingPoints;
+    private lastSnap;
+    private dwellTimer;
+    private dwellAt;
+    private dwellToggled;
+    private typed;
+    /** How long (ms) the pointer rests on a point before it is acquired or released for tracking. */
+    static readonly TRACKING_DWELL_MS = 400;
+    /** The pen's polar angles: measured from its last segment with `polarRelative`, else the page's (`snap.angles`). */
+    private penAngles;
+    /** Pointer rested on the snapped anchor, centre or crossing: starts (or keeps) the dwell that acquires it. */
+    private dwell;
+    /** The direction an open path's end at `p` (document space) would extend in, or null when no open path ends there. */
+    private extensionAt;
+    private toggleTracking;
+    /**
+     * Acquires the point at `x, y` (document units) for object snap tracking, or releases it when
+     * it is acquired already, as resting the pointer on it does. An open path's end also sends its
+     * extension. At most seven are kept, the oldest dropped. Returns the acquired points.
+     */
+    acquireTrackingPoint(p: Vec2$1): readonly VectorTrackingPoint[];
+    /** Releases every acquired tracking point. */
+    clearTracking(notify?: boolean): void;
+    /** A key typed while the pen draws: digits and `. , < @ -` build a typed entry, Enter places it, Backspace and Escape edit or drop it. */
+    private typedKey;
+    /**
+     * Places the pen's next point from typed text, as CAD direct distance entry does: `120` is that
+     * far from the last point toward the pointer (along the path it tracks), `120<30` that far at 30°
+     * (counter-clockwise on the page, from the last segment with `snap.polarRelative`), `@40,-10`
+     * an offset from the last point and `200,150` a position. One undo step. Fails without a path
+     * being drawn with the pen.
+     */
+    placePenPoint(text: string): VectorActionResult;
+    /**
+     * Adds an open (or closed) path drawn by dimensions, the way a CAD user types them: from
+     * `start`, each step goes `length` at `angle` degrees (counter-clockwise on the page), by an
+     * offset `dx, dy`, or to a position `x, y` (document units). Default style. One undo step;
+     * selects it. Returns its id and the anchors placed.
+     */
+    addPathByDimensions(input: {
+        start: Vec2$1;
+        steps: readonly ({
+            length: number;
+            angle: number;
+        } | {
+            dx: number;
+            dy: number;
+        } | {
+            x: number;
+            y: number;
+        })[];
+        closed?: boolean;
+        name?: string;
+    }): VectorMaskResult & {
+        anchors?: Vec2$1[];
+    };
+    /** How near (document units) a connector end snaps to a connection site. */
+    private connectorRadius;
+    private downConnector;
+    /** The route new connectors get (the Connector tool and `addConnector`). Default straight. */
+    private connectorRoute;
+    /** Sets the route the Connector tool draws with. */
+    setConnectorRoute(route: VectorConnectorRoute): VectorActionResult;
+    /** The route the Connector tool draws with. */
+    getConnectorRoute(): VectorConnectorRoute;
+    /** Checks a connector end given by an API caller: the object must exist and not be a connector. */
+    private checkConnectorEnd;
+    /**
+     * Adds a connector from `start` to `end`, each glued to an object (`{ nodeId, side? }`, side
+     * default `auto`) or a free point (`{ x, y }`, document units). It is routed now and after every
+     * later edit, so it follows the objects. Stroked in the default stroke with an arrowhead at the
+     * end unless given. One undo step; selects it.
+     */
+    addConnector(input: {
+        start: VectorConnectorEnd | Vec2$1;
+        end: VectorConnectorEnd | Vec2$1;
+        route?: VectorConnectorRoute;
+        radius?: number;
+        gap?: number;
+        name?: string;
+        stroke?: VectorPaint;
+        strokeWidth?: number;
+        startArrow?: VectorArrowhead | null;
+        endArrow?: VectorArrowhead | null;
+    }): VectorMaskResult;
+    /**
+     * Changes connectors (default: the selected ones): `start` / `end` glue an end to an object
+     * (`{ nodeId, side? }`) or unglue it (`null`, the end staying where it is), and `route`,
+     * `radius`, `gap` set how they run. Plain open paths given by id become connectors. One undo step.
+     */
+    setConnector(patch: {
+        start?: VectorConnectorEnd | null;
+        end?: VectorConnectorEnd | null;
+        route?: VectorConnectorRoute;
+        radius?: number;
+        gap?: number;
+    }, options?: {
+        ids?: readonly string[];
+    }): VectorActionResult;
+    /** Every connector: its ends (glued object and resolved side, or the free point) and route. */
+    getConnectors(): VectorConnectorListing[];
+    /** The connection sites of node `id` in document space (top, right, bottom, left, centre), or null when there is no such node. */
+    getConnectionSites(id: string): VectorConnectionSite[] | null;
+    /** A name for a new frame: "Frame <n>" after the frames there are. */
+    private frameName;
+    /**
+     * Adds an empty frame (an artboard when top-level) with its rectangle at `x, y, width, height`
+     * (document units), filled white by default and clipping its contents. With `adopt`, the
+     * top-level objects it fully encloses move into it. One undo step; selects it.
+     */
+    addFrame(input: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        name?: string;
+        fill?: VectorPaint;
+        clip?: boolean;
+        adopt?: boolean;
+    }): VectorMaskResult;
+    /**
+     * Frame Selection: puts the selected (or given) objects, which must share a parent, into a new
+     * frame fitted to their bounds plus `padding` (document units, default 0), in their place in the
+     * stacking order. No fill unless `fill` is given; clips unless `clip: false`. One undo step;
+     * selects the frame.
+     */
+    frameSelection(options?: {
+        ids?: readonly string[];
+        padding?: number;
+        name?: string;
+        fill?: VectorPaint;
+        clip?: boolean;
+    }): VectorMaskResult;
+    /** Frames among `ids` (default: the selection), or holding one of them directly. */
+    private frameTargets;
+    /**
+     * Changes frames (default: the selected ones, or the frame holding the selection): `x`, `y`,
+     * `width`, `height` move and resize the rectangle (in the frame's own space), and its children
+     * follow their resizing constraints; `fill` (null for none) and `clip` set how it draws.
+     * One undo step (merged while `merge` is the same key).
+     */
+    setFrame(patch: {
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+        fill?: VectorPaint;
+        clip?: boolean;
+    }, options?: {
+        ids?: readonly string[];
+        merge?: string;
+    }): VectorActionResult;
+    /**
+     * Sets the resizing constraints of the selected (or given) objects, which must be children of
+     * frames: how each follows its frame when the frame is resized. A missing axis keeps its value.
+     * One undo step.
+     */
+    setResizing(resizing: VectorResizing, options?: {
+        ids?: readonly string[];
+    }): VectorActionResult;
+    /** Every frame in the document (top-level ones are artboards), with its rectangle, parent and children's constraints. */
+    getFrames(): VectorFrameListing[];
+    /** One frame as an SVG document of its own size (its corner at the origin), or null when `id` is not a frame. */
+    frameToSvg(id: string, options?: VectorSvgExportOptions): string | null;
     /** Mask groups among `ids` (default: the selection), or holding one of them directly. */
     private maskTargets;
     /**
@@ -2150,6 +2994,248 @@ declare class VectorEditorController {
      * width tool opens the width-point editor (`widthPointEdit`).
      */
     doubleClick(screen: Vec2$1): void;
+    /**
+     * Sets the text shaper (shared by every vector editor on the page, see `setVectorTextShaper`) and
+     * lays every text node out again with it. Not an undo step.
+     */
+    setTextShaper(shaper: TextShaper | null): void;
+    /** The text shaper in use. */
+    getTextShaper(): TextShaper;
+    /** Changes the font and alignment new text gets (validated; throws on a bad value). */
+    setTextDefaults(patch: Partial<VectorTextDefaults>): void;
+    /** The paint new text gets: black, no stroke (`addText` and the style panel change it). */
+    private textStyle;
+    /** Builds a text node from `input` with the text defaults (not added). Throws a `VectorTextError` on bad input. */
+    createTextNode(input: VectorTextInput): VectorTextNode;
+    /** Adds text (point, area or on a path, see `VectorTextInput`). Returns its id. */
+    addText(input: VectorTextInput, options?: AddVectorNodeOptions): string;
+    /** The text node `id`, or an error message. */
+    private textNode;
+    /** Replaces text node `id` by `fn(node)` as one undo step (merged with others of `merge`). */
+    private editTextNode;
+    /** Replaces [start, end) of text node `id` (default: all of it) with `text`. One undo step. */
+    setText(id: string, text: string, range?: {
+        start?: number;
+        end?: number;
+    }, options?: {
+        merge?: string;
+    }): VectorActionResult;
+    /**
+     * Applies character style fields (`fontFamily`, `fontWeight`, `italic`, `fontSize`, `tracking`,
+     * `leading`, `baselineShift`, `underline`, `strikethrough`, `null` to clear) and `fill` to
+     * [start, end) of text node `id` (default: all of it, which changes its own style). One undo step.
+     */
+    setTextStyle(id: string, patch: Record<string, unknown>, range?: {
+        start?: number;
+        end?: number;
+    }, options?: {
+        merge?: string;
+    }): VectorActionResult;
+    /**
+     * Applies character style fields (and `fill`) to the whole of every text node in `ids` (default:
+     * the selected text, including text inside selected groups), or a paragraph patch with
+     * `paragraph`. One undo step for all of them.
+     */
+    styleTexts(patch: {
+        style?: Record<string, unknown>;
+        paragraph?: Record<string, unknown>;
+    }, options?: {
+        ids?: readonly string[];
+        merge?: string;
+    }): VectorActionResult;
+    /** Changes paragraph fields (`align`, `autoLeading`, indents, spacing; `null` clears) of text node `id`. One undo step. */
+    setParagraphStyle(id: string, patch: Record<string, unknown>, options?: {
+        merge?: string;
+    }): VectorActionResult;
+    /**
+     * Changes how text node `id` is set: `point` (keeps where its first line starts), `area` (a box:
+     * `width` / `height` default to its current size, `x` / `y` to its top left) or `path` options
+     * (`start`, `end`, `flip`, `orientation`, `baseline`; a new `path` needs path data or a subpath in
+     * the node's own space). One undo step.
+     */
+    setTextFrame(id: string, patch: Record<string, unknown>): VectorActionResult;
+    /**
+     * Turns path `pathId` into text set along it (Type on a Path): a text node in its place, its
+     * anchors the text's path, its paint dropped for the text defaults (or `input`'s). Returns the
+     * text's id, or an error.
+     */
+    typeOnPath(pathId: string, input?: Partial<VectorTextInput>): VectorActionResult & {
+        id?: string;
+    };
+    /**
+     * Create Outlines: turns text into paths of its glyph outlines (one compound path, or a group
+     * with one per run fill), keeping its paint, effects, filters and placement. Needs an outline
+     * text shaper. Returns the new nodes' ids, or an error.
+     */
+    createOutlines(options?: {
+        ids?: readonly string[];
+    }): VectorActionResult & {
+        ids?: string[];
+    };
+    /** The layout of text node `id` (lines, glyphs, bounds, overflow), or null. */
+    getTextLayout(id: string): VectorTextLayout | null;
+    /**
+     * Starts editing text node `id` on the canvas (the caret at `index`, default the end; or a
+     * selection from `anchor` to `focus`). Typing goes to `textInput`, keys to `keyDown`.
+     */
+    editText(id: string, options?: {
+        index?: number;
+        anchor?: number;
+        focus?: number;
+    }): VectorActionResult;
+    /** Moves the caret or selection of the text being edited. */
+    selectText(anchor: number, focus?: number): void;
+    /**
+     * Ends the text edit session. Text it created and left empty is removed (with no undo step when
+     * nothing was typed); other emptied text is deleted as its own step.
+     */
+    endTextEdit(): void;
+    /** Types `text` over the selection of the text being edited (one undo step per session). */
+    textInput(text: string): VectorActionResult;
+    /** Deletes the selection, or one character (a whole surrogate pair) before or after the caret. */
+    private textDelete;
+    /** Keys while text is being edited: caret movement, deleting, Enter, Escape and style shortcuts. */
+    private textKey;
+    /** The selected characters of the text being edited ('' when the selection is collapsed), or null when not editing. */
+    getSelectedText(): string | null;
+    /** Cut while editing text: returns the selected characters and deletes them (null when not editing). */
+    cutText(): string | null;
+    /** The index one line up or down from `index`, at the same x (start or end of the text past the first or last line). */
+    private lineMove;
+    /** The topmost node of `type` under `p` (inside groups too, hit where it draws), or null. */
+    private hitOfType;
+    /** The topmost text node under `p` (inside groups too), or null. */
+    private hitText;
+    /** A text node created for the edit session (no undo step until something is typed). */
+    private startNewText;
+    private downType;
+    private upTypeBox;
+    /** The whole document: in isolation mode, the host with the edited symbol's art. */
+    private storedDocument;
+    private symbolEditState;
+    /** The document's symbols (the stored ones, also while one is being edited). */
+    getSymbols(): readonly VectorSymbol[];
+    /** Ids of the instances of symbol `symbolId` in the whole document (inside other symbols too). */
+    getSymbolInstances(symbolId: string): string[];
+    private newSymbolId;
+    /**
+     * Make Symbol: turns the selected (or given) objects, which must share a parent, into a new
+     * symbol whose registration point is their centre, and puts an instance in their place. One
+     * undo step. Returns the symbol's and the instance's ids.
+     */
+    makeSymbol(options?: {
+        ids?: readonly string[];
+        name?: string;
+    }): VectorActionResult & {
+        symbolId?: string;
+        instanceId?: string;
+    };
+    /**
+     * Places an instance of symbol `symbolId` with its registration point at (`x`, `y`) (default the
+     * artboard's centre), or through `transform`. One undo step. Returns its id.
+     */
+    placeSymbol(symbolId: string, options?: {
+        x?: number;
+        y?: number;
+        transform?: VectorMatrix;
+        name?: string;
+        parentId?: string;
+    }): VectorActionResult & {
+        id?: string;
+    };
+    private instanceTargets;
+    /**
+     * Detach: replaces instances by groups of their symbol's art as drawn (placed, strokes scaled,
+     * overrides applied), unlinked from the symbol. One undo step. Returns the groups' ids (the
+     * instances' own).
+     */
+    detachInstances(options?: {
+        ids?: readonly string[];
+    }): VectorActionResult & {
+        ids?: string[];
+    };
+    /** Replace Symbol: instances draw symbol `symbolId` instead, keeping their placement. One undo step. */
+    replaceSymbol(symbolId: string, options?: {
+        ids?: readonly string[];
+    }): VectorActionResult;
+    /**
+     * Instance options: `scaleStrokes` (strokes of the art scale with the instance), and overrides —
+     * `fill` / `stroke` (every fill or stroke of the art in one paint; `null` clears), `hidden` (art
+     * node ids not drawn). One undo step.
+     */
+    setInstanceOptions(patch: {
+        scaleStrokes?: boolean;
+        fill?: VectorPaint | null;
+        stroke?: VectorPaint | null;
+        hidden?: string[] | null;
+    }, options?: {
+        ids?: readonly string[];
+    }): VectorActionResult;
+    /** Renames symbol `symbolId`. One undo step. */
+    renameSymbol(symbolId: string, name: string): VectorActionResult;
+    /**
+     * Deletes symbol `symbolId`. With instances in use it refuses unless `detach` (they become plain
+     * groups first). One undo step.
+     */
+    deleteSymbol(symbolId: string, options?: {
+        detach?: boolean;
+    }): VectorActionResult;
+    /**
+     * Edit Symbol (isolation mode): the document becomes the art of symbol `id` (or of instance `id`'s
+     * symbol), in its own space; everything else draws dimmed behind it. Edits are ordinary undo
+     * steps; `exitSymbolEdit` returns to the document with every instance updated.
+     */
+    editSymbol(id: string): VectorActionResult;
+    /** The view inside isolation mode for the current (document) view. */
+    private viewInto;
+    /** The document's view for the current view inside isolation mode. */
+    private viewOutOf;
+    /** Leaves isolation mode: back to the whole document, the symbol's instances showing the edits. */
+    exitSymbolEdit(): void;
+    /** The document's constraints. */
+    getConstraints(): readonly VectorConstraint[];
+    /** The document's named parameters. */
+    getParameters(): readonly VectorParameter[];
+    /** Degrees of freedom the constraints leave, and whether any are redundant. */
+    getConstraintDof(): VectorDofReport;
+    /**
+     * References from loose input to stable ones: anchors given by `subpath` / `index` get ids (the
+     * path is updated in `nodes`). Throws on a missing path or anchor.
+     */
+    private resolveRefs;
+    private newConstraintId;
+    /**
+     * Adds a constraint: refs by anchor (`subpath` / `index`, or its id), handle, segment or circle;
+     * dimensional kinds take a `value` expression (default: what the geometry measures now) and a
+     * `name`. Refuses (changing nothing) one that conflicts with the others or repeats them, naming
+     * them. One undo step. Returns the new constraint's id.
+     */
+    addConstraint(input: VectorConstraintInput): VectorActionResult & {
+        id?: string;
+        ids?: string[];
+    };
+    /** Removes constraints by id. One undo step. */
+    removeConstraints(ids: readonly string[]): VectorActionResult;
+    /**
+     * Sets a dimensional constraint's value expression (by id or name), or a named parameter's
+     * (creating it; `null` removes a parameter), then solves. Refuses (changing nothing) a value
+     * that does not evaluate or that the constraints cannot meet. One undo step.
+     */
+    setConstraintValue(key: string, value: string | number | null, options?: {
+        merge?: string;
+    }): VectorActionResult & {
+        ids?: string[];
+    };
+    /**
+     * Auto-constrain: constraints the paths `ids` (default the selection, or every path) nearly
+     * satisfy, added one by one (redundant or conflicting ones skipped). One undo step. Returns the
+     * ids of the constraints added.
+     */
+    autoConstrain(options?: {
+        ids?: readonly string[];
+    } & VectorInferOptions): VectorActionResult & {
+        ids?: string[];
+    };
     /**
      * Handles editor shortcuts. Returns true when the key was used (call `preventDefault`).
      * Do not forward keys typed into text inputs.
@@ -2386,7 +3472,38 @@ interface VectorRenderMask extends Omit<VectorMaskRenderData, 'invertFilter'> {
     /** The mask as drawn, for the `<mask>` of an opacity mask (in the group's own space). */
     nodes?: VectorRenderNode[];
 }
-type VectorRenderNode = VectorRenderPath | VectorRenderGroup;
+/**
+ * Text drawn as SVG text (when the text shaper gives no glyph outlines; with outlines, text renders
+ * as a `VectorRenderPath` or group). Draw a `<g>` with `id`, `transform`, `opacity`, `blendMode` and
+ * `filter`, holding one `<text>` per layer, bottom to top, each holding every span as a `<tspan>`.
+ */
+interface VectorRenderText {
+    kind: 'text';
+    id: string;
+    transform?: string;
+    opacity: number;
+    blendMode?: string;
+    filter?: string;
+    /**
+     * Paint layers, bottom to top: a fill (`fill` set, `stroke` none) or a stroke. Draw each as a
+     * `<text>` with these attributes (and `mix-blend-mode`). `runFills`: spans with their own `fill`
+     * use it on this layer (the top fill).
+     */
+    layers: Array<{
+        kind: 'fill' | 'stroke';
+        fill: string;
+        stroke: string;
+        strokeWidth: number;
+        strokeLinejoin?: string;
+        strokeDasharray?: string;
+        opacity: number;
+        blendMode?: string;
+        runFills?: boolean;
+    }>;
+    spans: VectorRenderTextSpan[];
+}
+
+type VectorRenderNode = VectorRenderPath | VectorRenderGroup | VectorRenderText;
 interface VectorSceneRenderData {
     /** SVG `transform` for the document layer: `translate(x y) scale(zoom)`. */
     transform: string;
@@ -2622,6 +3739,79 @@ interface VectorOverlayRenderData {
         enabled: boolean;
         editing: boolean;
     }[];
+    /**
+     * Text editing (screen space): the edited text's frame outline (`frame`, draw it thin and
+     * dashed), the caret (a line, when the selection is collapsed), the selection's quads (`selection`,
+     * filled translucent) and the overflow marker (a small boxed plus at `overflow` when text does
+     * not fit). Also set, without caret, for the selected text while a Type tool is active.
+     */
+    text: {
+        nodeId: string;
+        frame: string;
+        caret: {
+            x1: number;
+            y1: number;
+            x2: number;
+            y2: number;
+        } | null;
+        selection: string[];
+        overflow: Vec2$1 | null;
+        editing: boolean;
+    } | null;
+    /** The Type tool's area text box being dragged out (screen space). */
+    textBox: VectorBounds | null;
+    /**
+     * Constraint glyphs of the selected or edited paths (screen space): a label at (`x`, `y`) (a
+     * glyph, or `name = value`), a dimension line for distances, `satisfied` false when the solve
+     * could not meet it (draw it in a warning colour).
+     */
+    /**
+     * Name labels of the top-level frames (artboards), screen space: draw `name` just above (x, y),
+     * the frame's top-left corner (bold when `selected`). Clicking a label should select the frame.
+     */
+    frames: {
+        id: string;
+        name: string;
+        x: number;
+        y: number;
+        selected: boolean;
+    }[];
+    /**
+     * Connection sites, screen space, while the Connector tool is on: those of the object under the
+     * pointer (top, right, bottom, left, centre), `active` on the one an end would glue to.
+     */
+    connectorSites: {
+        nodeId: string;
+        side: string;
+        x: number;
+        y: number;
+        active: boolean;
+    }[];
+    /** Points acquired for object snap tracking, screen space: draw a small `+` at each. */
+    trackingPoints: {
+        x: number;
+        y: number;
+    }[];
+    /** The distance or coordinate being typed while the pen draws, and where to show it (screen space, by the pointer), or null. */
+    typedEntry: {
+        text: string;
+        x: number;
+        y: number;
+    } | null;
+    constraints: {
+        id: string;
+        kind: string;
+        label: string;
+        x: number;
+        y: number;
+        dimension: {
+            x1: number;
+            y1: number;
+            x2: number;
+            y2: number;
+        } | null;
+        satisfied: boolean;
+    }[];
     /** A short status, e.g. "W 120 × H 80" or "45°". */
     status: string | null;
 }
@@ -2825,6 +4015,8 @@ interface VectorSelectionStyle {
      */
     cornerRadius: number;
     cornerKind: VectorCornerKind;
+    /** Squircle smoothing (0–1) of the first corner. */
+    cornerSmoothing: number;
     corners: number;
     /** Some selected path is open, so arrowheads apply. */
     hasOpenPath: boolean;
@@ -3040,7 +4232,7 @@ interface VectorCommandOptions {
 /** A node as listed for agents. */
 interface VectorNodeListing {
     id: string;
-    type: 'path' | 'group';
+    type: 'path' | 'group' | 'text' | 'instance';
     name?: string;
     depth: number;
     /** Axis-aligned bounds in document units. */
@@ -3060,6 +4252,13 @@ interface VectorNodeListing {
     strokeWidth?: number;
     /** SVG path data (paths only). */
     d?: string;
+    /** An instance's symbol, transform (it may scale and skew) and overrides. */
+    symbolId?: string;
+    transform?: number[];
+    overrides?: unknown;
+    /** A text node's text and frame kind (`point`, `area` or `path`); `vector.getText` has the rest. */
+    text?: string;
+    frame?: 'point' | 'area' | 'path';
     children?: number;
     /** A blend group's options (its steps are listed as children with `blendStep`). */
     blend?: {
@@ -3087,6 +4286,12 @@ interface VectorNodeListing {
     blendMode?: VectorBlendMode;
     /** The node's visual filters (shadows, glows, blurs, feather). */
     filters?: VectorFilter[];
+    /** A frame's rectangle (in its own space), fill and clip (see vector.listFrames). */
+    frameRect?: VectorFrame;
+    /** A frame child's resizing constraints, when set. */
+    resizing?: VectorResizing;
+    /** A connector's ends and route (see vector.listConnectors). */
+    connector?: VectorConnector;
     /** A mask group's mask: type, inversion, the mask's id (its first child) and the masked contents. */
     mask?: VectorMaskSummary;
 }
@@ -4008,4 +5213,362 @@ declare function vectorTargetPaint(style: VectorStyle, target: 'fill' | 'stroke'
 /** The node with `paint` in the place `vectorTargetPaint` reads (stored canonically). */
 declare function withVectorTargetPaint<T extends VectorStyle>(node: T, target: 'fill' | 'stroke', layer: number | null, paint: VectorPaint): T;
 
-export { type AddVectorNodeOptions, AffineMatrix$1 as 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, VECTOR_ARROWHEAD_LABELS, VECTOR_BLEND_MAX_SMOOTH_STEPS, VECTOR_BLEND_MAX_STEPS, VECTOR_BLEND_MODE_LABELS, VECTOR_BLEND_MODE_MENU, VECTOR_BLEND_SPACING_LABELS, VECTOR_BUILDER_HATCH_GAP, VECTOR_CLIPBOARD_TYPE, VECTOR_CONSTRUCTION_ANGLES, VECTOR_CORNER_KIND_LABELS, VECTOR_CORNER_WIDGET_INSET, VECTOR_DISTORT_TOLERANCE, VECTOR_EDIT_TOGGLES, VECTOR_EFFECT_MENU, VECTOR_ENVELOPE_STYLE_OPTIONS, VECTOR_FILL_GAP, VECTOR_GRADIENT_INTERPOLATION_LABELS, VECTOR_GRADIENT_MIDPOINT_GAP, VECTOR_GRADIENT_OFF_BAR, VECTOR_GRADIENT_SPREAD_LABELS, VECTOR_GRADIENT_STOP_GAP, VECTOR_GRADIENT_TYPE_LABELS, VECTOR_INK_MAX_CORNERS, VECTOR_MASK_TYPE_LABELS, VECTOR_MASK_TYPE_OPTIONS, VECTOR_OVERLAY_THEME, VECTOR_PATHFINDER_ACTIONS, VECTOR_PATHFINDER_LABELS, VECTOR_PATH_ACTIONS, VECTOR_PENCIL_STRING_PX, VECTOR_PRESSURE_NOMINAL, VECTOR_ROTATE_HANDLE_OFFSET, VECTOR_STROKE_ALIGN_LABELS, VECTOR_STROKE_GRADIENT_MODE_LABELS, VECTOR_STROKE_SETTING_KEYS, VECTOR_STYLE_KEYS, VECTOR_TOOL_GLYPHS, VECTOR_TOOL_SHORTCUTS, VECTOR_WIDTH_PRESETS, VECTOR_WIDTH_PRESET_IDS, VECTOR_WIDTH_PROFILE_MAX_POINTS, VECTOR_WIDTH_PROFILE_MAX_SCALE, VECTOR_WIDTH_SAME_T, type VariableStrokeOptions, Vec2$1 as Vec2, type VectorActionResult, VectorAlign, VectorAnchor, VectorAnchorRef, VectorAnchorType, type VectorAppearancePanelData, type VectorAppearancePanelLayer, VectorAppearanceShape, VectorArrange, VectorArrowAlign, VectorArrowhead, type VectorArrowheadShape, VectorAverageAxis, VectorBlend, type VectorBlendControls, type VectorBlendInput, VectorBlendMode, VectorBlendOptions, type VectorBlendRail, VectorBlendSpacing, type VectorBlendStart, VectorBooleanOperation, VectorBounds, type VectorBuilderHit, type VectorBuilderLinePiece, type VectorBuilderPreview, type VectorBuilderReplacement, type VectorBuilderTouched, type VectorCommandOptions, type VectorCornerInfo, VectorCornerKind, type VectorCornerWidget, VectorDefaults, type VectorDistortMode, VectorDistribute, VectorDocument, VectorEditorController, type VectorEditorOptions, type VectorEditorState, VectorEffect, VectorEffectParamSpec, VectorEffectParamsMap, VectorEffectType, type VectorEffectsPanelData, type VectorEffectsPanelItem, type VectorEnvelopePanelData, VectorEnvelopeParams, VectorFillRule, VectorFilter, VectorFilterParamSpec, VectorFilterType, type VectorFiltersPanelItem, VectorGradient, type VectorGradientAnnotator, type VectorGradientEditorData, VectorGradientHandle, VectorGradientInterpolation, type VectorGradientPart, VectorGradientPatch, VectorGradientSpread, VectorGradientStop, type VectorGradientTarget, VectorGradientType, VectorGroupNode, type VectorGuideKind, type VectorGuideLabel, type VectorGuideLine, VectorHandleRef, type VectorHitTestOptions, type VectorHover, type VectorInkShape, type VectorInteraction, type VectorKeyInput, VectorLineJoin, VectorMask, type VectorMaskClipShape, type VectorMaskGroup, type VectorMaskPanelData, type VectorMaskRegionShape, type VectorMaskRenderData, type VectorMaskResult, type VectorMaskSummary, VectorMaskType, VectorMergeMode, VectorModifiers, type VectorMorph, type VectorMorphContour, type VectorMorphCorrespondence, type VectorMorphOptions, VectorNode, type VectorNodeListing, type VectorOverlayRenderData, VectorPaint, VectorPaintDef, VectorPaintLayer, type VectorPaintLayerHit, type VectorPaintLayerNode, type VectorPathAction, type VectorPathEditOptions, type VectorPathEntry, type VectorPathKeyframe, VectorPathNode, type VectorPathfinderAction, VectorPathfinderOperation, type VectorPathfinderPaint, type VectorPointMap, type VectorPointSnap, type VectorPointerInput, type VectorRectSnap, type VectorRenderAnchor, type VectorRenderCornerWidget, VectorRenderFilter, type VectorRenderGradientAnnotator, type VectorRenderGroup, type VectorRenderGuideLabel, type VectorRenderGuideLine, type VectorRenderHandle, type VectorRenderMask, type VectorRenderNode, type VectorRenderPaintLayer, type VectorRenderPath, VectorRenderStrokeParts, type VectorRenderWidthPoint, type VectorRepeaterCopy, type VectorScaleSnap, type VectorSceneRenderData, 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, VectorStrokeAlign, VectorStrokeGradientMode, VectorStrokeLayer, type VectorStrokeParts, VectorStrokeSettings, type VectorStrokeSpot, VectorStyle, VectorSubpath, VectorSvgExportOptions, type VectorTaperOptions, VectorTool, VectorTransformHandle, VectorViewport, VectorWarpMesh, type VectorWaveOptions, type VectorWidthHandle, VectorWidthPoint, type VectorWidthPointEdit, type VectorWidthPointRef, type VectorWidthPreset, type VectorWidthPresetInfo, addBuilderHit, applyMatrix, applyMatrixLinear, applyVectorBlendOptions, arrowheadInset, arrowheadPath, arrowheadWeight, bendSegment, bezierToSubpaths, boundsFromPoints, boundsIntersect, cloneAnchor, cloneSubpath, cloneVectorDocument, cloneVectorNode, collectPathNodes, constrainToLeave, convertAnchor, cornerBisectorPoint, cornerRadiusChange, cornerSetback, correspondMorphContours, createVectorCommands, createVectorMorph, curvatureMoveAnchor, cutSubpathAt, dashIntervals, decomposeRigid, distortVectorNode, effectPathLength, effectPathVertexCount, effectiveStrokeAlign, ellipseSubpath, eraseFromFill, eraseFromOutline, eraserRegion, evaluateVectorPathKeyframes, expandVectorBlend, expandVectorCorners, expandVectorCornersOf, findVectorNode, fitCornerRadius, generateVectorBlendChildren, generateWidthProfile, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorAppearancePanel, getVectorBlendControls, getVectorCornerWidgets, getVectorEffectsPanel, getVectorEnteredGroups, getVectorEnvelopePanel, getVectorEnvelopeTarget, getVectorGradientAnnotator, getVectorGradientEditor, getVectorMaskPanel, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVectorWidthHandles, getVisibleAnchors, getVisibleHandles, hasPaint, hasStrokeExtras, hasVectorCorners, hasVectorPaintStacks, hitTestVectorNode, hitTestVectorNodes, hitTestVectorPaintLayer, hitTestVectorPaintStack, hitTestVectorStroke, hitVectorGradientAnnotator, inferAnchorType, insertAnchor, insertWidthPoint, interpolateMorphContours, interpolateRigidMatrix, interpolateVectorColor, interpolateVectorPaint, interpolateVectorPaths, interpolateVectorStyle, interpolateWidthProfiles, invertMatrix, isClosedBezierShape, isDrawnVectorPaintLayer, isIdentityMatrix, isPlainVectorPaintLayer, isUniformWidthProfile, isVectorBlendGroup, isVectorBlendMode, isVectorMaskActive, isVectorMaskGroup, isVectorMaskType, isVectorTextTarget, joinSubpaths, knifePath, lineSubpath, locateVectorNode, mapBezierPath, mapVectorPoints, mapVectorSubpaths, matrixRotation, mergePaths, mirrorWidthProfile, morphContourToSubpath, morphPathsCross, moveAnchorHandle, multiplyMatrices, nearestSegment, nearestStrokePosition, needsVectorPaintLayers, newVectorStrokeLayer, nextVectorCornerKind, nodeMatrix, normalizeVectorPaintStacks, offsetPaths, pathsCenter, planShapeBuilder, polygonSubpath, polylineBounds, pressureWidthProfile, puckerBloatPaths, recognizeInkShape, rectSubpath, refineMorphContour, refreshVectorBlends, releaseVectorBlend, removeAnchorKeepingShape, removeAnchors, removeAnchorsKeepingShape, removeRedundantPoints, removeWidthPoints, repeatPaths, resampleGradientStops, resolveVectorBlendOptions, reverseMorphContour, reverseSubpath, reverseWidthProfile, rotateMatrix, roundCornerPaths, roundSubpaths, samplePolyline, sanitizeVectorFills, sanitizeVectorMask, sanitizeVectorStrokeSettings, sanitizeVectorStrokes, sanitizeWidthProfile, scaleFor, scaleMatrix, setAnchorCorner, setSubpathCorners, setWidthPoint, simplifyPolyline, smoothSubpath, splitIntoFaces, splitSubpathAt, starSubpath, strokePositionPoint, strokeWidthProfileOf, subpathEnclosesArea, subpathPointAt, subpathSegment, subpathSegmentCount, subpathToMorphContour, subpathsToBezier, taperWaveFactor, toVectorKeyInput, toVectorModifiers, toVectorPointerInput, transformVectorNode, translateAnchor, translateMatrix, trimIntervals, trimPaths, trimPathsIndividually, turnMorphContour, twistPaths, unionBounds, variableStrokeOutline, variableStrokeRings, vectorBlendColorDistance, vectorBlendKeyTargets, vectorBlendKeys, vectorBlendModeCss, vectorBlendModeFromCss, vectorBlendRail, vectorBlendRailAt, vectorBlendSpine, vectorBlendStepCount, vectorBoxCorners, vectorBuilderErasedEdges, vectorCornerAt, vectorCorners, vectorDiamondPath, vectorDistortQuad, vectorFillMap, vectorFills, vectorGradientBarPosition, vectorGradientTargetPath, vectorInkShapeName, vectorMaskContains, vectorMaskContentBounds, vectorMaskContents, vectorMaskOwner, vectorMaskRegion, vectorMaskRegionPath, vectorMaskRegionShapes, vectorMaskRenderData, vectorMaskSource, vectorMaskSummary, vectorMaskedGeometry, vectorMaskedLocalBounds, vectorMaskedShapes, vectorMeshFromOutline, vectorMeshOutline, vectorNodeBounds, vectorNodeRotation, vectorNodeToBezier, vectorPaintLayerNodes, vectorPaintSwatch, vectorPaintToHex, vectorParentMatrix, vectorPathData, vectorPathEntries, vectorPathWorldBezier, vectorPathfinderShape, vectorRepeaterCopies, vectorResizeCursor, vectorResultStyle, vectorShapeBuilderHit, vectorShapeBuilderMap, vectorShearForSide, vectorSkewMatrix, vectorStacksHaveGradient, vectorStrokeGradientDefs, vectorStrokeLineArea, vectorStrokeOutline, vectorStrokeOutlinePath, vectorStrokeParts, vectorStrokeReach, vectorStrokeSettings, vectorStrokeStackReach, vectorStrokeWidthGeometry, vectorStrokes, vectorTargetPaint, vectorToolLabel, vectorWorldMatrix, walkVectorNodes, widthProfileAt, widthProfileMaxScale, widthProfilePreset, widthProfilePresetId, wigglePaths, withVectorFills, withVectorStrokes, withVectorTargetPaint, zigzagPaths };
+/**
+ * Frames (artboards) and their children's resizing constraints.
+ *
+ * A frame is a group with `frame` set: a rectangle in the group's own space, a fill drawn below the
+ * children and (by default) a clip. It draws, hit-tests and bounds through `vectorFrameDrawn`, an
+ * equivalent clip group (or plain group without the clip), so rendering, masks, snapping and SVG
+ * export reuse the mask group machinery. Resizing a frame lays out its children by their
+ * `resizing` constraints (`vectorFrameChildMatrix`) instead of scaling them.
+ *
+ * The constraint rules follow figcraft's `crates/layout/src/lib.rs` `apply_constraints` (MIT OR
+ * Apache-2.0, © ArtCraft Team and contributors; see THIRD_PARTY_NOTICES.md), as already ported for
+ * the canvas package (`canvas/autoLayout.ts`): left / right / left and right / centre / scale
+ * horizontally, top / bottom / top and bottom / centre / scale vertically.
+ */
+
+/** A frame group (its `frame` set, and not a blend, live boolean or mask group). */
+type VectorFrameGroup = VectorGroupNode & {
+    frame: VectorFrame;
+};
+/** Whether the node is a frame. */
+declare function isVectorFrame(node: VectorNode | null | undefined): node is VectorFrameGroup;
+/** The frame's rectangle as a closed four-anchor path (in the frame's own space). */
+declare function vectorFrameRectPath(frame: VectorFrame): VectorPathNode['subpaths'];
+/**
+ * The frame as an equivalent plain group: a clip group (`mask: clip`) whose mask is the frame's
+ * rectangle (`<id>~frame-clip`), then its fill (`<id>~frame-fill`) and its children; without the
+ * clip, a group of the fill and the children. Same id, transform and appearance. Cached per node.
+ */
+declare function vectorFrameDrawn(node: VectorFrameGroup): VectorGroupNode;
+/** Whether `p` (in the frame's own space) lies in its rectangle, within `tolerance`. */
+declare function vectorFrameContains(frame: VectorFrame, p: {
+    x: number;
+    y: number;
+}, tolerance?: number): boolean;
+/**
+ * The matrix (in the frame's own space) that takes a child with bounds `box` from frame rectangle
+ * `from` to `to` by the child's `resizing` constraints: a scale and translation per axis.
+ */
+declare function vectorFrameChildMatrix(resizing: VectorResizing | null | undefined, box: VectorBounds, from: VectorFrame, to: VectorFrame): AffineMatrix;
+/** Reads a frame from untrusted data (JSON, agent input, SVG import), or null. */
+declare function sanitizeVectorFrame(value: unknown): VectorFrame | null;
+/** Reads resizing constraints from untrusted data, or null (unknown values dropped). */
+declare function sanitizeVectorResizing(value: unknown): VectorResizing | null;
+/** Labels for the resizing constraint pickers. */
+declare const VECTOR_HORIZONTAL_RESIZING_LABELS: Readonly<Record<VectorHorizontalResizing, string>>;
+declare const VECTOR_VERTICAL_RESIZING_LABELS: Readonly<Record<VectorVerticalResizing, string>>;
+/** Whether `inner` lies wholly in `outer` (false for a missing box). */
+declare function vectorBoundsInside(inner: VectorBounds | null, outer: VectorBounds): boolean;
+/** Top-level frames of a document (its artboards), bottom to top. */
+declare function vectorArtboards(doc: Pick<VectorDocument, 'nodes'>): VectorFrameGroup[];
+/**
+ * A document of one frame on its own, sized to the frame with the frame's corner at the origin
+ * (the frame's rotation undone), for exporting an artboard. Symbols, constraints' parameters and the
+ * page background are carried over. Null when `id` is not a frame.
+ */
+declare function vectorFrameDocument(doc: VectorDocument, id: string, find: (nodes: readonly VectorNode[], id: string) => VectorNode | null | undefined): VectorDocument | null;
+/** What the frame panel shows for the selection. */
+interface VectorFramePanel {
+    /** The selected frame (the first, when several are), or null. */
+    frame: {
+        id: string;
+        name: string;
+        artboard: boolean;
+        frame: VectorFrame;
+    } | null;
+    /**
+     * The resizing constraints of the selected objects that sit directly in a frame (null when none
+     * does): each axis' value, or `mixed` when they differ.
+     */
+    resizing: {
+        ids: string[];
+        horizontal: VectorHorizontalResizing | 'mixed';
+        vertical: VectorVerticalResizing | 'mixed';
+    } | null;
+}
+/** The frame panel's data for a selection. */
+declare function getVectorFramePanel(state: {
+    document: Pick<VectorDocument, 'nodes'>;
+    selection: readonly string[];
+}): VectorFramePanel;
+
+/**
+ * Framework-neutral data for a text panel (React and Svelte render it the same way): what it edits
+ * (the selected characters of the text being edited, the selected text nodes, or the defaults for
+ * new text), the current values (`null` where they differ), and the apply helpers.
+ */
+
+interface VectorTextPanelData {
+    /** `range`: the selected characters of the text being edited; `nodes`: whole text nodes; `defaults`: new text. */
+    target: 'range' | 'nodes' | 'defaults';
+    /** The text nodes edited (empty for defaults). */
+    ids: string[];
+    /** Character fields; `null` where the target mixes values (or, for leading, auto). */
+    font: {
+        [K in keyof Required<VectorCharacterStyle>]: VectorCharacterStyle[K] | null;
+    };
+    align: VectorTextAlign | null;
+    /** The frame kind of a single text node. */
+    frame: 'point' | 'area' | 'path' | null;
+    /** Families the shaper can draw (always the generic ones too). */
+    families: string[];
+    /** Whether the shaper gives outlines (Create Outlines works). */
+    outlines: boolean;
+    /** One path is selected: Type on a Path can turn it into path text. */
+    pathId: string | null;
+}
+declare const VECTOR_TEXT_ALIGN_LABELS: Readonly<Record<VectorTextAlign, string>>;
+declare const VECTOR_TEXT_ALIGN_OPTIONS: readonly {
+    value: VectorTextAlign;
+    label: string;
+}[];
+/** Weights a font menu offers. */
+declare const VECTOR_FONT_WEIGHTS: readonly {
+    value: number;
+    label: string;
+}[];
+/**
+ * The text panel for `state`: shown while a Type tool is active or text is selected; null
+ * otherwise.
+ */
+declare function getVectorTextPanel(state: Pick<VectorEditorState, 'document' | 'selection' | 'textEdit' | 'textDefaults' | 'tool'>): VectorTextPanelData | null;
+/**
+ * Applies character fields (and `fill`) from the panel: to the selected characters, the selected
+ * text nodes (one undo step) or the defaults for new text. `merge` folds slider drags into one step.
+ */
+declare function applyVectorTextStyle(controller: VectorEditorController, patch: Record<string, unknown>, options?: {
+    merge?: string;
+}): void;
+/** Applies paragraph fields from the panel to the text being edited or selected, or to the defaults. */
+declare function applyVectorParagraphStyle(controller: VectorEditorController, patch: {
+    align?: VectorTextAlign;
+} & Record<string, unknown>, options?: {
+    merge?: string;
+}): void;
+
+/**
+ * Symbols and instances: reusable art (`VectorDocument.symbols`) drawn by `instance` nodes through
+ * an affine transform that may scale and skew.
+ *
+ * The concepts follow vectorcraft's `Symbol { name, art }` and `SymbolInstance { symbol, xf }`
+ * (`crates/doc/src/symbols.rs`, MIT OR Apache-2.0, © ArtCraft Team and contributors; see
+ * THIRD_PARTY_NOTICES.md): instances measure and draw their symbol's art placed by their own
+ * transform, nesting is bounded, and a symbol that would contain itself draws nothing. The
+ * resolution and expansion here are our own.
+ *
+ * Instances carry their symbol's art resolved (`art`, the symbol's own `nodes` array) so that
+ * geometry, rendering and export, which see one node at a time, can draw them. The editor resolves
+ * after every change (`resolveVectorSymbols`); storage leaves it out (`stripVectorSymbolArt`).
+ */
+
+/** Instances inside symbols nest at most this deep; deeper ones draw nothing. */
+declare const VECTOR_SYMBOL_MAX_DEPTH = 16;
+/** Ids of the symbols instances in `nodes` use (nested groups included, not through other symbols). */
+declare function vectorSymbolsUsedIn(nodes: readonly VectorNode[]): Set<string>;
+/** Whether symbol `symbolId`'s art reaches symbol `target` through its instances (a cycle when they are the same). */
+declare function vectorSymbolUses(symbols: readonly VectorSymbol[], symbolId: string, target: string): boolean;
+/**
+ * The document with every instance's `art` set to its symbol's art (instances inside symbols
+ * included), the same object when nothing changed. An instance of a missing symbol, or one that
+ * would draw its own symbol, gets no art.
+ */
+declare function resolveVectorSymbols(doc: VectorDocument): VectorDocument;
+/** The document without resolved art on its instances (for storage). */
+declare function stripVectorSymbolArt(doc: VectorDocument): VectorDocument;
+/** A node's stroke widths (every stroke layer, the shorthand and profiles are relative) times `k`; groups pass it on. */
+declare function scaleVectorStrokeWidths<T extends VectorNode>(node: T, k: number): T;
+/** A node's fills and / or strokes all painted with the overrides' paints (groups pass them on). */
+declare function tintVectorNode<T extends VectorNode>(node: T, overrides: Pick<VectorInstanceOverrides, 'fill' | 'stroke'>): T;
+/** Copies of `nodes` with ids prefixed `<prefix>~` (all the way down). */
+declare function prefixVectorIds(nodes: readonly VectorNode[], prefix: string): VectorNode[];
+/**
+ * What an instance draws, as a plain group in its parent's space: its art placed through its
+ * transform (the rotation on the group, scale and skew baked into the art so transforms stay
+ * rigid), strokes scaled unless `scaleStrokes` is false, overrides applied, ids `<instance>~<art>`.
+ * `bake(node, m)` is `transformVectorNode` (passed in to keep this module below geometry).
+ */
+declare function vectorInstanceGroup(node: VectorInstanceNode, bake: (n: VectorNode, m: AffineMatrix) => VectorNode): VectorGroupNode;
+/** `a` then `b` (re-exported for callers that place art). */
+declare const composeVectorMatrices: (a: AffineMatrix, b: AffineMatrix) => AffineMatrix;
+
+/**
+ * Framework-neutral data for symbol UI: the symbols panel (each symbol with a preview, the selected
+ * instance's options) and the dimmed document behind a symbol edited in isolation.
+ */
+
+interface VectorSymbolsPanelItem {
+    id: string;
+    name: string;
+    instances: number;
+    /** A preview: draw `scene.nodes` (with its defs and filters) in an `<svg viewBox={viewBox}>`. */
+    viewBox: string;
+    scene: VectorSceneRenderData;
+    /** Being edited in isolation. */
+    editing: boolean;
+}
+interface VectorSymbolsPanelData {
+    symbols: VectorSymbolsPanelItem[];
+    /** The selection can become a symbol (objects selected, not one instance alone). */
+    canMake: boolean;
+    /** The one selected instance, with its options. */
+    instance: {
+        id: string;
+        symbolId: string;
+        scaleStrokes: boolean;
+        fill: VectorPaint | null;
+        stroke: VectorPaint | null;
+        hidden: number;
+    } | null;
+    editing: {
+        symbolId: string;
+        name: string;
+    } | null;
+}
+/** The symbols panel for `state`. */
+declare function getVectorSymbolsPanel(state: VectorEditorState, options?: {
+    idPrefix?: string;
+}): VectorSymbolsPanelData;
+/**
+ * The document behind a symbol edited in isolation, to draw dimmed under the art: its scene, placed
+ * so the instance it was entered from lines up with the art (that instance left out). Null outside
+ * isolation mode, or when the symbol was entered without an instance.
+ */
+declare function getVectorSymbolEditBackground(state: VectorEditorState, options?: {
+    idPrefix?: string;
+}): (VectorSceneRenderData & {
+    name: string;
+}) | null;
+
+/**
+ * Where to draw constraint glyphs (document space), the constraints panel's data and the actions the
+ * current selection allows. Framework-neutral, so React and Svelte draw the same thing.
+ */
+
+/** Short glyphs per kind. */
+declare const VECTOR_CONSTRAINT_GLYPHS: Readonly<Record<VectorConstraintKind, string>>;
+declare const VECTOR_CONSTRAINT_LABELS: Readonly<Record<VectorConstraintKind, string>>;
+/** A constraint's glyph in document space. */
+interface VectorConstraintGlyph {
+    id: string;
+    kind: VectorConstraintKind;
+    /** The glyph, or `name = value` for dimensional constraints. */
+    label: string;
+    /** Where to draw it (near the middle of what it refers to). */
+    at: Vec2$1;
+    /** The points it refers to (for a highlight). */
+    points: Vec2$1[];
+    /** A dimension line between two points (distances). */
+    dimension: {
+        a: Vec2$1;
+        b: Vec2$1;
+    } | null;
+    satisfied: boolean;
+}
+/** Glyphs of the constraints that touch `nodeIds` (all when null), document space. */
+declare function vectorConstraintGlyphs(doc: VectorDocument, nodeIds?: ReadonlySet<string> | null): VectorConstraintGlyph[];
+/** A constraint the selection allows, with its references ready for `addConstraint`. */
+interface VectorConstraintAction {
+    kind: VectorConstraintKind;
+    label: string;
+    refs: {
+        nodeId: string;
+        subpath?: number;
+        index?: number;
+        segment?: boolean;
+        circle?: boolean;
+    }[];
+    /** Dimensional: it asks for a value (the current measure is the default). */
+    dimensional: boolean;
+}
+/**
+ * Constraints the selected anchors (direct tool) or paths allow: one anchor (fix, tangent and
+ * smooth at it), two anchors (a segment when they are neighbours: horizontal, vertical, length,
+ * fix; else coincident, horizontal, vertical, distance), three (a point and a segment: on its
+ * line), four as two segments (parallel, perpendicular, equal, collinear, angle); one or two round
+ * paths (radius, diameter, fix; concentric, equal, tangent).
+ */
+declare function vectorConstraintActions(doc: VectorDocument, selection: {
+    anchors: readonly VectorAnchorRef[];
+    nodes: readonly string[];
+}): VectorConstraintAction[];
+/** The constraints panel: degrees of freedom, constraints of the selection (all without one), actions, parameters. */
+interface VectorConstraintPanelData {
+    dof: VectorDofReport;
+    constraints: {
+        id: string;
+        kind: VectorConstraintKind;
+        label: string;
+        name?: string;
+        value?: string;
+        satisfied: boolean;
+        conflict: boolean;
+    }[];
+    actions: VectorConstraintAction[];
+    parameters: {
+        name: string;
+        value: string;
+        result: number | null;
+        error: string | null;
+    }[];
+}
+declare function vectorConstraintPanel(doc: VectorDocument, selection: {
+    anchors: readonly VectorAnchorRef[];
+    nodes: readonly string[];
+}, conflicts?: readonly string[]): VectorConstraintPanelData;
+/** The constraints panel for an editor state (selection: the direct tool's anchors, else the selected paths). */
+declare function getVectorConstraintPanel(state: {
+    document: VectorDocument;
+    selection: readonly string[];
+    selectedAnchors: readonly VectorAnchorRef[];
+    tool: string;
+    constraintIssues: {
+        conflicts: string[];
+    } | null;
+}): VectorConstraintPanelData;
+
+/**
+ * A spatial index for hit-testing, marquee selection and snapping in large documents.
+ *
+ * After cadcraft's `crates/engine/src/spatial.rs` (MIT OR Apache-2.0, © ArtCraft Team and
+ * contributors; see THIRD_PARTY_NOTICES.md): an R-tree over object bounds, built only above a
+ * size where scanning costs more, reused while the content is the same (here: the same node array),
+ * and rebuilt cheaply after an edit because each node's bounds are cached by node object, so only
+ * the nodes an edit replaced are measured again (structural sharing). Queries return candidates in
+ * draw order; callers then run exactly the same tests as a scan, so results are identical. The
+ * tree itself is ours (sort-tile-recursive packing) since cadcraft uses the `rstar` crate.
+ */
+
+/** Node lists shorter than this are scanned directly (building an index costs more). */
+declare const VECTOR_SPATIAL_MIN = 256;
+interface Box {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+/** A static R-tree over boxes, packed sort-tile-recursive (items with no box are always candidates). */
+declare class VectorRTree {
+    private readonly root;
+    private readonly always;
+    private readonly boxes;
+    constructor(boxes: ReadonlyArray<Box | null>);
+    private static pack;
+    /** Indices of the items whose box meets `box` (and the unbounded ones), ascending. */
+    search(box: Box): number[];
+}
+/** A top-level node's paint box in its parent's space (strokes and filters' reach included), cached per node object. */
+declare function vectorNodePaintBox(node: VectorNode): Box | null;
+/**
+ * The index over a node list (cached per array; null below `VECTOR_SPATIAL_MIN` nodes). Nodes
+ * without bounds (empty groups, unresolved instances) are always candidates.
+ */
+declare function vectorSpatialIndex(nodes: readonly VectorNode[]): VectorRTree | null;
+/**
+ * Indices (ascending, draw order) of the nodes of `nodes` that may meet `rect` padded by `pad`
+ * (document units): every index when the list is small enough to scan.
+ */
+declare function vectorNodesNear(nodes: readonly VectorNode[], rect: VectorBounds, pad?: number): number[];
+
+export { type AddVectorNodeOptions, AffineMatrix$1 as AffineMatrix, DEFAULT_VECTOR_BLEND_DISTANCE, DEFAULT_VECTOR_BLEND_STEPS, DEFAULT_VECTOR_FONT, DEFAULT_VECTOR_PATH_EDIT, DEFAULT_VECTOR_SNAP, IDENTITY_MATRIX, KAPPA, LazyMouse, type MapVectorSubpathsOptions, type NearestSegment, type RecognizeInkOptions, TextFont, TextShaper, VECTOR_ARROWHEAD_LABELS, VECTOR_BLEND_MAX_SMOOTH_STEPS, VECTOR_BLEND_MAX_STEPS, VECTOR_BLEND_MODE_LABELS, VECTOR_BLEND_MODE_MENU, VECTOR_BLEND_SPACING_LABELS, VECTOR_BUILDER_HATCH_GAP, VECTOR_CHARACTER_STYLE_KEYS, VECTOR_CLIPBOARD_TYPE, VECTOR_CONNECTOR_ROUTE_LABELS, VECTOR_CONNECTOR_SIDE_LABELS, VECTOR_CONSTRAINT_GLYPHS, VECTOR_CONSTRAINT_LABELS, VECTOR_CONSTRUCTION_ANGLES, VECTOR_CORNER_KIND_LABELS, VECTOR_CORNER_WIDGET_INSET, VECTOR_DIMENSIONAL_KINDS, VECTOR_DISTORT_TOLERANCE, VECTOR_EDIT_TOGGLES, VECTOR_EFFECT_MENU, VECTOR_ENVELOPE_STYLE_OPTIONS, VECTOR_FILL_GAP, VECTOR_FONT_WEIGHTS, VECTOR_GRADIENT_INTERPOLATION_LABELS, VECTOR_GRADIENT_MIDPOINT_GAP, VECTOR_GRADIENT_OFF_BAR, VECTOR_GRADIENT_SPREAD_LABELS, VECTOR_GRADIENT_STOP_GAP, VECTOR_GRADIENT_TYPE_LABELS, VECTOR_HORIZONTAL_RESIZING_LABELS, VECTOR_INK_MAX_CORNERS, VECTOR_MASK_TYPE_LABELS, VECTOR_MASK_TYPE_OPTIONS, VECTOR_MAX_CONSTRAINTS, VECTOR_MAX_TRACKING_POINTS, VECTOR_OVERLAY_THEME, VECTOR_PARAGRAPH_STYLE_KEYS, VECTOR_PATHFINDER_ACTIONS, VECTOR_PATHFINDER_LABELS, VECTOR_PATH_ACTIONS, VECTOR_PENCIL_STRING_PX, VECTOR_PRESSURE_NOMINAL, VECTOR_ROTATE_HANDLE_OFFSET, VECTOR_SPATIAL_MIN, VECTOR_STROKE_ALIGN_LABELS, VECTOR_STROKE_GRADIENT_MODE_LABELS, VECTOR_STROKE_SETTING_KEYS, VECTOR_STYLE_KEYS, VECTOR_SYMBOL_MAX_DEPTH, VECTOR_TEXT_ALIGN_LABELS, VECTOR_TEXT_ALIGN_OPTIONS, VECTOR_TOOL_GLYPHS, VECTOR_TOOL_SHORTCUTS, VECTOR_VERTICAL_RESIZING_LABELS, VECTOR_WIDTH_PRESETS, VECTOR_WIDTH_PRESET_IDS, VECTOR_WIDTH_PROFILE_MAX_POINTS, VECTOR_WIDTH_PROFILE_MAX_SCALE, VECTOR_WIDTH_SAME_T, type VariableStrokeOptions, Vec2$1 as Vec2, type VectorActionResult, VectorAlign, VectorAnchor, VectorAnchorRef, VectorAnchorType, type VectorAppearancePanelData, type VectorAppearancePanelLayer, VectorAppearanceShape, VectorArrange, VectorArrowAlign, VectorArrowhead, type VectorArrowheadShape, VectorAverageAxis, VectorBlend, type VectorBlendControls, type VectorBlendInput, VectorBlendMode, VectorBlendOptions, type VectorBlendRail, VectorBlendSpacing, type VectorBlendStart, VectorBooleanOperation, VectorBounds, type VectorBuilderHit, type VectorBuilderLinePiece, type VectorBuilderPreview, type VectorBuilderReplacement, type VectorBuilderTouched, VectorCharacterStyle, type VectorCommandOptions, type VectorConnectionSite, VectorConnector, VectorConnectorEnd, type VectorConnectorListing, type VectorConnectorPanel, VectorConnectorRoute, type VectorConnectorRouting, VectorConnectorSide, VectorConstraint, type VectorConstraintAction, VectorConstraintError, type VectorConstraintGlyph, type VectorConstraintInput, VectorConstraintKind, type VectorConstraintPanelData, type VectorConstraintRefInput, type VectorCornerInfo, VectorCornerKind, type VectorCornerWidget, VectorDefaults, type VectorDistortMode, VectorDistribute, VectorDocument, type VectorDofReport, type VectorDofStatus, VectorEditorController, type VectorEditorOptions, type VectorEditorState, VectorEffect, VectorEffectParamSpec, VectorEffectParamsMap, VectorEffectType, type VectorEffectsPanelData, type VectorEffectsPanelItem, type VectorEnvelopePanelData, VectorEnvelopeParams, VectorExprEnv, VectorExprError, VectorFillRule, VectorFilter, VectorFilterParamSpec, VectorFilterType, type VectorFiltersPanelItem, VectorFrame, type VectorFrameGroup, type VectorFrameListing, type VectorFramePanel, VectorGradient, type VectorGradientAnnotator, type VectorGradientEditorData, VectorGradientHandle, VectorGradientInterpolation, type VectorGradientPart, VectorGradientPatch, VectorGradientSpread, VectorGradientStop, type VectorGradientTarget, VectorGradientType, VectorGroupNode, type VectorGuideKind, type VectorGuideLabel, type VectorGuideLine, VectorHandleRef, type VectorHitTestOptions, VectorHorizontalResizing, type VectorHover, type VectorInferOptions, type VectorInkShape, VectorInstanceNode, VectorInstanceOverrides, type VectorInteraction, type VectorKeyInput, VectorLineJoin, VectorMask, type VectorMaskClipShape, type VectorMaskGroup, type VectorMaskPanelData, type VectorMaskRegionShape, type VectorMaskRenderData, type VectorMaskResult, type VectorMaskSummary, VectorMaskType, VectorMatrix, VectorMergeMode, VectorModifiers, type VectorMorph, type VectorMorphContour, type VectorMorphCorrespondence, type VectorMorphOptions, VectorNode, type VectorNodeListing, type VectorOverlayRenderData, VectorPaint, VectorPaintDef, VectorPaintLayer, type VectorPaintLayerHit, type VectorPaintLayerNode, VectorParagraphStyle, VectorParameter, type VectorPathAction, type VectorPathEditOptions, type VectorPathEntry, type VectorPathKeyframe, type VectorPathMeasure, VectorPathNode, type VectorPathfinderAction, VectorPathfinderOperation, type VectorPathfinderPaint, type VectorPointMap, type VectorPointSnap, type VectorPointerInput, VectorRTree, type VectorRectSnap, type VectorRenderAnchor, type VectorRenderCornerWidget, VectorRenderFilter, type VectorRenderGradientAnnotator, type VectorRenderGroup, type VectorRenderGuideLabel, type VectorRenderGuideLine, type VectorRenderHandle, type VectorRenderMask, type VectorRenderNode, type VectorRenderPaintLayer, type VectorRenderPath, VectorRenderStrokeParts, type VectorRenderText, type VectorRenderTextSpan, type VectorRenderWidthPoint, type VectorRepeaterCopy, VectorResizing, type VectorResolvedRun, type VectorScaleSnap, type VectorSceneRenderData, 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 VectorSolveResult, VectorStrokeAlign, VectorStrokeGradientMode, VectorStrokeLayer, type VectorStrokeParts, VectorStrokeSettings, type VectorStrokeSpot, VectorStyle, VectorSubpath, VectorSvgExportOptions, VectorSymbol, type VectorSymbolsPanelData, type VectorSymbolsPanelItem, type VectorTaperOptions, VectorTextAlign, type VectorTextCaret, type VectorTextDefaults, type VectorTextEditState, VectorTextError, type VectorTextFragment, VectorTextFrame, type VectorTextGlyph, type VectorTextInput, type VectorTextLayout, VectorTextNode, type VectorTextPanelData, type VectorTextPaths, VectorTextRun, type VectorTextSpan, VectorTool, type VectorTrackingPath, type VectorTrackingPoint, VectorTransformHandle, VectorVerticalResizing, VectorViewport, VectorWarpMesh, type VectorWaveOptions, type VectorWidthHandle, VectorWidthPoint, type VectorWidthPointEdit, type VectorWidthPointRef, type VectorWidthPreset, type VectorWidthPresetInfo, addBuilderHit, addVectorConstraint, applyMatrix, applyMatrixLinear, applyVectorBlendOptions, applyVectorParagraphStyle, applyVectorTextStyle, arrowheadInset, arrowheadPath, arrowheadWeight, autoConstrainVector, bakeVectorTextGeometry, bendSegment, bezierToSubpaths, boundsFromPoints, boundsIntersect, checkVectorExpression, cloneAnchor, cloneSubpath, cloneVectorDocument, cloneVectorNode, collectPaintedNodes, collectPathNodes, composeVectorMatrices, constrainToLeave, convertAnchor, cornerBisectorPoint, cornerRadiusChange, cornerSetback, correspondMorphContours, createVectorCommands, createVectorMorph, curvatureMoveAnchor, cutSubpathAt, dashIntervals, decomposeRigid, distortVectorNode, effectPathLength, effectPathVertexCount, effectiveStrokeAlign, ellipseSubpath, eraseFromFill, eraseFromOutline, eraserRegion, evalVectorExpression, evaluateVectorPathKeyframes, expandVectorBlend, expandVectorCorners, expandVectorCornersOf, findVectorAnchorById, findVectorNode, fitCornerRadius, fitVectorTextRuns, formatVectorValue, generateVectorBlendChildren, generateWidthProfile, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorAppearancePanel, getVectorBlendControls, getVectorConnectorPanel, getVectorConstraintPanel, getVectorCornerWidgets, getVectorEffectsPanel, getVectorEnteredGroups, getVectorEnvelopePanel, getVectorEnvelopeTarget, getVectorFramePanel, getVectorGradientAnnotator, getVectorGradientEditor, getVectorMaskPanel, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVectorSymbolEditBackground, getVectorSymbolsPanel, getVectorTextPanel, getVectorTextShaper, getVectorWidthHandles, getVisibleAnchors, getVisibleHandles, glyphBox, hasPaint, hasStrokeExtras, hasVectorCorners, hasVectorPaintStacks, hitTestVectorNode, hitTestVectorNodes, hitTestVectorPaintLayer, hitTestVectorPaintStack, hitTestVectorStroke, hitVectorGradientAnnotator, inferAnchorType, inferVectorConstraints, insertAnchor, insertWidthPoint, interpolateMorphContours, interpolateRigidMatrix, interpolateVectorColor, interpolateVectorPaint, interpolateVectorPaths, interpolateVectorStyle, interpolateWidthProfiles, invertMatrix, isClosedBezierShape, isDrawnVectorPaintLayer, isIdentityMatrix, isPlainVectorPaintLayer, isUniformWidthProfile, isValidVectorParameterName, isVectorBlendGroup, isVectorBlendMode, isVectorConnector, isVectorFrame, isVectorMaskActive, isVectorMaskGroup, isVectorMaskType, isVectorTextTarget, joinSubpaths, knifePath, layoutVectorText, lineSubpath, locateVectorNode, mapBezierPath, mapVectorPoints, mapVectorSubpaths, matrixRotation, measureVectorConstraint, measureVectorPath, mergePaths, mirrorWidthProfile, morphContourToSubpath, morphPathsCross, moveAnchorHandle, multiplyMatrices, nearestSegment, nearestStrokePosition, nearestVectorConnectionSite, needsVectorPaintLayers, newVectorStrokeLayer, nextVectorConstraintName, nextVectorCornerKind, nodeMatrix, normalizeVectorPaintStacks, normalizeVectorTextRuns, offsetPaths, patchVectorCharacterStyle, patchVectorParagraphStyle, pathTextFrameFromBezier, pathsCenter, planShapeBuilder, polygonSubpath, polylineBounds, prefixVectorIds, pressureWidthProfile, puckerBloatPaths, purgeVectorConstraints, recognizeInkShape, rectSubpath, refineMorphContour, refreshVectorBlends, releaseVectorBlend, removeAnchorKeepingShape, removeAnchors, removeAnchorsKeepingShape, removeRedundantPoints, removeWidthPoints, repeatPaths, replaceVectorText, rerouteVectorConnectors, resampleGradientStops, resolveVectorBlendOptions, resolveVectorSymbols, reverseMorphContour, reverseSubpath, reverseWidthProfile, rotateMatrix, roundCornerPaths, roundSubpaths, routeVectorConnector, samplePolyline, sanitizeVectorConnector, sanitizeVectorFills, sanitizeVectorFrame, sanitizeVectorMask, sanitizeVectorResizing, sanitizeVectorStrokeSettings, sanitizeVectorStrokes, sanitizeVectorTextFields, sanitizeVectorTextFrame, sanitizeWidthProfile, scaleFor, scaleMatrix, scaleVectorStrokeWidths, setAnchorCorner, setSubpathCorners, setVectorTextShaper, setWidthPoint, simplifyPolyline, smoothSubpath, solveVectorConstraints, splitIntoFaces, splitSubpathAt, starSubpath, stripVectorSymbolArt, strokePositionPoint, strokeWidthProfileOf, styleVectorText, subpathEnclosesArea, subpathPointAt, subpathSegment, subpathSegmentCount, subpathToMorphContour, subpathsToBezier, taperWaveFactor, tintVectorNode, toVectorKeyInput, toVectorModifiers, toVectorPointerInput, transformVectorNode, translateAnchor, translateMatrix, trimIntervals, trimPaths, trimPathsIndividually, turnMorphContour, twistPaths, unionBounds, validateVectorConstraint, variableStrokeOutline, variableStrokeRings, vectorAngleDirection, vectorArtboards, vectorBlendColorDistance, vectorBlendKeyTargets, vectorBlendKeys, vectorBlendModeCss, vectorBlendModeFromCss, vectorBlendRail, vectorBlendRailAt, vectorBlendSpine, vectorBlendStepCount, vectorBoundsInside, vectorBoxCorners, vectorBuilderErasedEdges, vectorConnectionSites, vectorConnectorTargetAt, vectorConnectorWorldAnchors, vectorConstraintActions, vectorConstraintDof, vectorConstraintEnv, vectorConstraintGlyphs, vectorConstraintPanel, vectorConstraintResiduals, vectorConstraintValue, vectorCornerAt, vectorCorners, vectorDiamondPath, vectorDistortQuad, vectorExpressionNames, vectorFillMap, vectorFills, vectorFrameChildMatrix, vectorFrameContains, vectorFrameDocument, vectorFrameDrawn, vectorFrameRectPath, vectorGradientBarPosition, vectorGradientTargetPath, vectorInkShapeName, vectorInstanceGroup, vectorMaskContains, vectorMaskContentBounds, vectorMaskContents, vectorMaskOwner, vectorMaskRegion, vectorMaskRegionPath, vectorMaskRegionShapes, vectorMaskRenderData, vectorMaskSource, vectorMaskSummary, vectorMaskedGeometry, vectorMaskedLocalBounds, vectorMaskedShapes, vectorMeshFromOutline, vectorMeshOutline, vectorNodeBounds, vectorNodePaintBox, vectorNodeRotation, vectorNodeToBezier, vectorNodesNear, vectorPaintLayerNodes, vectorPaintSwatch, vectorPaintToHex, vectorParentMatrix, vectorPathAt, vectorPathCircle, vectorPathData, vectorPathEntries, vectorPathTextPositions, vectorPathWorldBezier, vectorPathfinderShape, vectorPolarAngles, vectorPolarIncrementOf, vectorRepeaterCopies, vectorResizeCursor, vectorResultStyle, vectorShapeBuilderHit, vectorShapeBuilderMap, vectorShearForSide, vectorSkewMatrix, vectorSpatialIndex, vectorStacksHaveGradient, vectorStrokeGradientDefs, vectorStrokeLineArea, vectorStrokeOutline, vectorStrokeOutlinePath, vectorStrokeParts, vectorStrokeReach, vectorStrokeSettings, vectorStrokeStackReach, vectorStrokeWidthGeometry, vectorStrokes, vectorSymbolUses, vectorSymbolsUsedIn, vectorTargetPaint, vectorTextBoxOutline, vectorTextCaret, vectorTextFamilies, vectorTextGeometryNode, vectorTextHasOutlines, vectorTextIndexAt, vectorTextName, vectorTextPaintSource, vectorTextPaths, vectorTextRange, vectorTextRuns, vectorTextSelectionQuads, vectorTextShaperGeneration, vectorTextSpanSvg, vectorTextSpans, vectorTextStyleAt, vectorToolLabel, vectorTrackingPaths, vectorWorldMatrix, walkVectorNodes, widthProfileAt, widthProfileMaxScale, widthProfilePreset, widthProfilePresetId, wigglePaths, withVectorAnchorIds, withVectorDocumentAnchorIds, withVectorFills, withVectorStrokes, withVectorTargetPaint, zigzagPaths };