@weasel-js/geom 1.10.1 → 1.11.1

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-import { b as PathOpenFill, a as PolygonPath, c as PathFillRule, R as RectPath, P as Path } from './path-ljHxobyu.js';
-import { P as Point$1 } from './cubicMath-BW-HJrCE.js';
-export { c as cubicPointAt, s as splitCubicAtT } from './cubicMath-BW-HJrCE.js';
-export { PORT_REACH } from './nd/index.js';
+import { c as PathOpenFill, P as PolygonPath, d as PathFillRule, a as Path, R as RectPath, b as Point, C as CornerSpec, e as CornerPiece } from './path-BW8d_2RY.js';
+export { f as CORNER_FIT_TOLERANCE, g as CORNER_KEYWORDS, h as CornerKeyword, i as CornerShape, j as CornerShapeFrame, k as compactCorners, l as cornerAt, m as cornerCenter, n as cornerKeywordOf, o as cornerShapeK, p as cornerShapePieces, q as cornerShapePoint, r as cornerSpecAt, s as cubicPointAt, t as hasCorners, u as isCornerShape, v as lerpCorners, w as nextCornerShape, x as scaleCorners, y as splitCubicAtT, z as withCorner, A as withoutCorners } from './path-BW8d_2RY.js';
+import { A as AnchorSet, P as PenAnchor, a as SpiroPoint, S as SpiroKind, b as Scale2 } from './curvature-PkoLduGc.js';
+export { c as AnchorRect, d as CombTooth, e as CurvatureCombOptions, C as CurvatureSource, E as EulerFit, f as EulerSegment, g as SPIRO_KINDS, h as SegmentComb, i as SegmentHit, j as SpiroSegment, k as anchorAt, l as anchorCount, m as anchorsInRect, n as anchorsToPath, o as combTeeth, p as countPathAnchors, q as cubicCurvatureAt, r as cubicCurvatureSource, s as cubicDerivativeAt, t as curvatureComb, u as deleteAnchorsAt, v as editAnchorSet, w as eulerAngleAt, x as eulerCurvatureAt, y as eulerCurvatureDerivativesAt, z as eulerPointAt, B as fitEulerSegment, D as flatAnchorIndex, F as insertAnchorOnSegment, G as isAnchorSmooth, H as isSpiroKind, I as isStraightSegment, J as locateAnchor, K as moveHandleTo, L as nearestSegmentT, M as openSubpathAt, N as pathToAnchors, O as placeEulerSegment, Q as pxExtent, R as scaleDelta, T as screenAngleOf, U as segmentAt, V as segmentEnds, W as solveSpiro, X as standoff, Y as translateAnchorBy, Z as withinPxBox, _ as withinPxRadius } from './curvature-PkoLduGc.js';
+export { P as PORT_REACH } from './portCurve-C5HDWuuV.js';
 
 /**
  * Scalar / 2-vector primitives and the kernel-wide epsilon policy.
@@ -203,6 +204,9 @@ declare function cubicEvalAt(x0: number, y0: number, x1: number, y1: number, x2:
  * quadratic endpoints. c1 = q0 + 2/3(ctrl-q0), c2 = q1 + 2/3(ctrl-q1).
  */
 declare function elevateQuadraticToCubic(q0x: number, q0y: number, cx: number, cy: number, q1x: number, q1y: number): [number, number, number, number];
+/** The parameters in (0, 1) where one coordinate of a cubic, with control
+ *  values `p0..p3`, turns: the roots of its derivative. */
+declare function cubicAxisExtremaTs(p0: number, p1: number, p2: number, p3: number): number[];
 /** Tight AABB of a cubic, evaluating only extrema that lie on the curve. */
 declare function cubicBounds(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): Box;
 /** Quadratic Bezier point at parameter t (Bernstein form). */
@@ -375,6 +379,9 @@ declare class PathBuilder {
 }
 /** Construct a `RectPath` (the fast-path subtype). */
 declare function rectPath(x: number, y: number, width: number, height: number): RectPath;
+/** `path` as a command stream drawing the same outline. A rect becomes its four
+ *  corners clockwise from `(x, y)`, the order `countPathAnchors` numbers them in. */
+declare function asPolygonPath(path: Path): PolygonPath;
 /** Build an open polyline from a flat list of points — the same geometry as
  *  {@link polygonFromPoints} without the closing edge. A freehand stroke and a
  *  measurement line want this; a region wants the closed one. */
@@ -421,10 +428,133 @@ declare function linePath(a: {
 /**
  * AABB of a `Path`, returned as a `RectPath` for direct reuse with rect-fast-path machinery.
  * Control points are NOT included directly; they're used only to compute extrema that actually
- * lie on the curve. Empty paths (no commands) return a zero-size rect anchored at the origin.
+ * lie on the curve. Corner shapes are bounded as they are drawn, expanded. Empty paths (no commands) return a zero-size rect anchored at the origin.
  */
 declare function boundsOfPath(path: Path): RectPath;
 
+/**
+ * Corner expansion: a path's corner specs turned into the plain geometry
+ * that every reader draws, hits, bounds, and exports.
+ */
+
+/** Where and how a corner anchor can be cut. */
+interface CornerFrame {
+    /** Flat anchor index. */
+    index: number;
+    /** The anchor. */
+    x: number;
+    y: number;
+    /** Unit direction from the anchor into the wedge the cut is taken from. */
+    bisector: Point;
+    /** Half the angle between the two edges at the anchor. */
+    halfAngle: number;
+    /** How far along each edge the stored spec cuts, its setback, after clamping. */
+    trim: number;
+    /** The longest cut the edges allow while the neighbors keep theirs. */
+    maxTrim: number;
+}
+/** Every anchor of `path` that can take a corner, with the cut its spec
+ *  makes now. */
+declare function cornerFrames(path: PolygonPath): CornerFrame[];
+/** The frame of the corner at flat anchor `index`, or null when that anchor
+ *  cannot take one. */
+declare function cornerFrameAt(path: PolygonPath, index: number): CornerFrame | null;
+/** A path with its corners expanded, and where its anchors came from. */
+interface ResolvedCorners {
+    path: PolygonPath;
+    /**
+     * For each anchor of `path` (each M, L, C, or Q, as `countPathAnchors`
+     * counts them), the anchor of the source path it belongs to, in the same
+     * numbering. Every point a corner's cut adds belongs to that corner's
+     * anchor. Null when the expansion added none.
+     */
+    anchorSources: Uint32Array | null;
+}
+/** {@link resolveCorners}, also answering which source anchor each anchor of
+ *  the result came from, so an array kept per anchor (`vertexColors`) can be
+ *  carried onto it with {@link remapPerAnchor}. */
+declare function resolveCornersWithSources(path: PolygonPath): ResolvedCorners;
+/**
+ * `path` with its corner specs expanded into plain geometry and dropped: each
+ * corner is cut `radius` along both edges and spans the cut with its shape's
+ * superellipse (`cornerShapePieces`). Each cut is clamped so the cuts on
+ * either end of a segment never overlap. A path with no corners comes back
+ * as itself, and so does a rect.
+ */
+declare function resolveCorners<P extends Path>(path: P): P;
+/** `values`, `stride` numbers per source anchor, as `stride` per anchor of
+ *  the expanded path that `sources` describes. */
+declare function remapPerAnchor<T>(values: readonly T[], sources: Uint32Array, stride: number): T[];
+/** One corner of a path as its expansion draws it. */
+interface CornerCut {
+    /** Flat anchor index. */
+    index: number;
+    anchor: Point;
+    spec: CornerSpec;
+    /** Where the cut leaves the edge into the anchor, and where it rejoins the edge out of it. */
+    start: Point;
+    end: Point;
+    /** The outline from `start` to `end`. */
+    pieces: CornerPiece[];
+}
+/** Every corner `path` cuts, in path order. */
+declare function cornerCuts(path: PolygonPath): CornerCut[];
+
+/**
+ * Putting corner specs back on a path an operation rebuilt from expanded
+ * geometry. Booleans, trims and cuts work on what a path draws, its corners
+ * cut and spanned (`resolveCorners`); wherever a corner's cut comes through
+ * whole, it folds back into its anchor and spec, and only a corner the
+ * operation cut into or moved stays expanded.
+ */
+
+/** A corner a rebuilt path may hold expanded: the anchor and spec it folds
+ *  back into, and the cut it is drawn as, from `start` to `end`. */
+interface CornerTrace {
+    anchor: Point;
+    spec: CornerSpec;
+    start: Point;
+    end: Point;
+    pieces: readonly CornerPiece[];
+}
+/** How far a point may sit from where a corner draws it and still count as on it. */
+declare const CORNER_RESTORE_TOLERANCE = 0.001;
+/** The corners `path` cuts, as {@link restoreCorners} looks for them. */
+declare function cornerTraces(path: Path): CornerTrace[];
+/**
+ * `result` with the corners of `sources` folded back in wherever it still
+ * draws them whole: an operation's output, rebuilt from what the sources
+ * draw. A corner the operation cut into, or whose edges it moved, stays as
+ * the plain geometry it already is.
+ */
+declare function keepCorners(sources: readonly Path[], result: PolygonPath, tolerance?: number): PolygonPath;
+/**
+ * `result` with each of `traces` it draws whole folded back into its anchor
+ * and spec. A trace counts as drawn when a run of anchors goes from one end
+ * of its cut to the other along it, the edges either side carry on to its
+ * anchor, and the folded corner cuts the same again. Specs `result` already
+ * holds are kept.
+ */
+declare function restoreCorners(result: PolygonPath, traces: readonly CornerTrace[], tolerance?: number): PolygonPath;
+
+/**
+ * The corners an offset outline would hold as corners: each of the source's,
+ * moved to where its offset edges meet and resized so its cut keeps the
+ * same center.
+ */
+
+/**
+ * Where the corners of `path` would sit on its outline grown by `distance`
+ * (shrunk by a negative one), for `restoreCorners` to look for. A corner
+ * moves with its edges and keeps its center, so its setback changes by
+ * `distance / tan(half the corner's angle)`: a round corner at a right angle
+ * grows its radius by exactly `distance`, and is then exactly what the offset
+ * draws. A shape whose offset is no longer that shape, or a corner between
+ * curved edges, draws differently from its trace, so `restoreCorners` leaves
+ * it expanded. A corner shrunk to nothing has no trace.
+ */
+declare function offsetCornerTraces(path: Path, distance: number): CornerTrace[];
+
 /**
  * AABB union over a heterogeneous set of `Path` poses. Returns the
  * envelope as a `RectPath`, or `null` for empty input — analog of
@@ -486,7 +616,8 @@ declare function decomposePath(parent: Path, world: Path): Path;
 /** Split a path into one path per subpath, cutting at each `M`. A path with a
  *  single subpath comes back as a one-element array. `fillRule` is propagated
  *  unchanged, so even-odd compound paths with interior "holes" lose the hole
- *  semantics — each subpath becomes its own filled region. */
+ *  semantics — each subpath becomes its own filled region. Each subpath keeps
+ *  the corner specs of its own anchors. */
 declare function splitSubpaths(path: PolygonPath): PolygonPath[];
 
 /** Whether any subpath of `path` lacks the `Z` that closes it. */
@@ -521,7 +652,7 @@ declare function pathSignedArea(path: Path): number;
 /**
  * `path` with every contour traversed backwards: same region, same curves,
  * opposite winding. A closed contour keeps its starting point; an open one
- * starts from where it used to end.
+ * starts from where it used to end. Corner specs stay on their anchors.
  */
 declare function reversePath(path: PolygonPath): PolygonPath;
 
@@ -546,26 +677,84 @@ declare function reversePath(path: PolygonPath): PolygonPath;
 declare function pathFromD(d: string, onWarn?: (message: string) => void): ReturnType<PathBuilder['build']>;
 
 /**
- * A station along a path: where it is at a fraction of its length, and which
- * way it is heading there.
+ * `pathToD` — a weasel `Path` as an SVG `d=` string, the inverse of
+ * `pathFromD`. `RectPath` lowers to `M h v h Z`; `PolygonPath` walks the
+ * (commands, coords) arrays, one SVG command per kit command, with corner
+ * shapes expanded into the geometry they draw.
  *
- * For anything positioned *along* geometry rather than beside it — a label on a
- * routed edge, a tick on a curve, a badge near an arrowhead. Curves are
- * flattened first, so the fraction is arc length along the drawn shape rather
- * than a curve parameter, which is what makes 0.5 look like the middle.
+ * Absolute commands only; numbers are rounded to 6 decimals.
  */
 
-/** The answer `pointAlongPath` gives: a point on the path and its heading there. */
+/** `path` as SVG path data. */
+declare function pathToD(given: Path): string;
+
+/**
+ * A path measured once by arc length, so many stations along it cost a binary
+ * search each rather than a fresh flatten: what `pointAlongPath` answers one
+ * fraction at a time, and what anything placing or bending geometry along a
+ * path reads many times over.
+ */
+
+/** A point on a path and its heading there. */
 interface PathStation {
-    point: Point$1;
+    point: Point;
     /** Unit vector along the path at `point`, pointing toward the end. */
-    tangent: Point$1;
+    tangent: Point;
 }
-/** Options for `pointAlongPath`. */
-interface PointAlongPathOptions {
+/** Options for {@link measurePath}. */
+interface MeasurePathOptions {
     /** Curve flattening tolerance, in world units. Default 0.5. */
     flattenTolerance?: number;
 }
+/** The station on a path nearest a point. */
+interface PathNearestStation extends PathStation {
+    /** Arc length at `point`, on the scale {@link PathMeasure.at} reads. */
+    s: number;
+    /** Distance from the queried point to `point`. */
+    dist: number;
+}
+/** A measured path: its length, and the station at any distance along it. */
+interface PathMeasure {
+    /** Total arc length, every subpath counted in order. */
+    readonly length: number;
+    /** True when the path is a single closed contour, so a distance past the
+     *  end can wrap round to the start. */
+    readonly closed: boolean;
+    /**
+     * The station `s` along the path, `s` clamped to `0..length`.
+     *
+     * The tangent is the heading of the flattened segment under `s`. With
+     * `smooth`, it is instead blended across each segment from the heading at
+     * one vertex to the next, so geometry bent along it turns without facets.
+     */
+    at(s: number, smooth?: boolean): PathStation;
+    /**
+     * The inverse of `at`: the station nearest `p`. On a tie the earliest
+     * segment wins. The tangent is the heading of the segment holding it.
+     */
+    nearest(p: Point): PathNearestStation;
+}
+/**
+ * Measure `path` by arc length. Subpaths are measured in order and treated as
+ * one run, the way a browser measures a whole `<path>`. Returns `null` for a
+ * path with no points; a path of zero length answers at its single point,
+ * heading along +X.
+ */
+declare function measurePath(path: Path, opts?: MeasurePathOptions): PathMeasure | null;
+
+/**
+ * A station along a path: where it is at a fraction of its length, and which
+ * way it is heading there.
+ *
+ * For anything positioned *along* geometry rather than beside it — a label on a
+ * routed edge, a tick on a curve, a badge near an arrowhead. Curves are
+ * flattened first, so the fraction is arc length along the drawn shape rather
+ * than a curve parameter, which is what makes 0.5 look like the middle. For
+ * many stations along one path, measure it once with `measurePath`.
+ */
+
+/** Options for `pointAlongPath`. */
+type PointAlongPathOptions = MeasurePathOptions;
 /**
  * Where `path` is at `t` of its total length, and its heading there.
  *
@@ -576,6 +765,144 @@ interface PointAlongPathOptions {
  */
 declare function pointAlongPath(path: Path, t: number, opts?: PointAlongPathOptions): PathStation | null;
 
+/** One cubic segment, `[x0, y0, x1, y1, x2, y2, x3, y3]`, and whether it was
+ *  drawn straight. A straight one keeps its controls at its thirds, so it
+ *  interpolates and warps as a line would. */
+interface CubicSegment {
+    c: [number, number, number, number, number, number, number, number];
+    line: boolean;
+}
+/** One contour of segments, each starting where the one before it ends. */
+interface CubicContour {
+    segs: CubicSegment[];
+    closed: boolean;
+}
+/**
+ * `path`'s contours as cubic segments. A closed contour whose last point
+ * stops short of its first gains the straight closing edge it is drawn with;
+ * zero-length straight segments are dropped. A contour with no segments is a
+ * lone point and is left out. Corner specs are expanded first.
+ */
+declare function pathToCubicContours(path: Path): CubicContour[];
+/** The path drawing `contours`: a straight segment as `L`, the rest as `C`. */
+declare function cubicContoursToPath(contours: readonly CubicContour[], fillRule?: PathFillRule): PolygonPath;
+
+/**
+ * Shape interpolation between two paths: the steps of a blend, or the frames
+ * of a morph.
+ *
+ * The two shapes are matched once — contour to contour, then segment to
+ * segment — and every step is a straight lerp of the matched control points.
+ * Where one contour has fewer segments, its longest ones are split in half
+ * until the counts agree, which adds anchors without moving the outline.
+ */
+
+/** How a blend matches the second shape's anchors to the first's. */
+interface BlendPathsOptions {
+    /**
+     * Choose, for each pair of contours, the start point (and, when `reverse`
+     * is unset, the direction) of the second that keeps matched anchors
+     * closest, with both contours centered on their own middles first so that
+     * where the shapes sit does not decide it. Default `true`.
+     */
+    autoAlign?: boolean;
+    /**
+     * Turn the second shape's start point this many anchors further round each
+     * closed contour, after any `autoAlign` choice. Negative turns it back.
+     * Default 0.
+     */
+    startOffset?: number;
+    /** Run the second shape's contours backwards. Unset, `autoAlign` decides;
+     *  without it, they run as drawn. */
+    reverse?: boolean;
+}
+/** Two shapes matched for interpolation. */
+interface PathBlend {
+    /** The shape `t` of the way from the first to the second: exactly the
+     *  first at 0 and the second at 1, up to the anchors matching added. */
+    at(t: number): PolygonPath;
+    /** Segments per matched pair of contours. */
+    readonly segmentCounts: readonly number[];
+}
+/** The shape `t` of the way from `a` to `b`. Matching once with
+ *  {@link prepareBlend} is cheaper when several steps are wanted. */
+declare function blendPaths(a: Path, b: Path, t: number, opts?: BlendPathsOptions): PolygonPath;
+/** Match `a` to `b` for interpolation. */
+declare function prepareBlend(a: Path, b: Path, opts?: BlendPathsOptions): PathBlend;
+
+/**
+ * Bend a shape along a spine: the shape's x becomes distance along the spine
+ * and its y distance off it, along the spine's normal. A straight edge of the
+ * shape comes out curved wherever the spine bends, so each segment is
+ * sampled through the warp and refit to cubics within a tolerance; anchors
+ * stay where they were, so a corner of the shape stays a corner.
+ */
+
+/** How a shape is laid along its spine. */
+interface BendAlongPathOptions {
+    /**
+     * `'stretch'`, the default, spreads the shape's width over the spine's
+     * whole length. `'natural'` keeps its width: one unit across the shape is
+     * one unit along the spine, starting at the spine's start, and a shape
+     * longer than the spine runs on straight past its end.
+     */
+    fit?: 'stretch' | 'natural';
+    /** Where across the shape's height the spine runs, 0 at its top and 1 at
+     *  its bottom. Default 0.5, the middle. */
+    baseline?: number;
+    /** Lay the shape on the other side of the spine, mirrored across it. */
+    flip?: boolean;
+    /** How far the refit curves may stray from the exact bend, in world
+     *  units. Default 0.5. */
+    tolerance?: number;
+}
+/**
+ * `shape` bent along `spine`. A spine heading left to right keeps the shape
+ * upright; one heading the other way turns it over, as a road sign painted
+ * along a lane does. Returns `null` when the spine has no length or the shape
+ * nothing to bend.
+ */
+declare function bendAlongPath(shape: Path, spine: Path, opts?: BendAlongPathOptions): PolygonPath | null;
+
+/** How copies are spaced along a path. */
+interface RepeatAlongPathOptions {
+    /**
+     * How many copies. With no `spacing`, they spread evenly over the whole
+     * path — end to end on an open one, evenly round a closed one — and the
+     * default is 5. With a `spacing`, it caps the run; unset, as many as fit.
+     */
+    count?: number;
+    /** Distance along the path from one copy's center to the next. */
+    spacing?: number;
+    /** Where a spaced run that is shorter than the path sits on it. Default
+     *  `'start'`. */
+    align?: 'start' | 'center' | 'end';
+    /** Slide every copy this far along the path. On an open path a copy slid
+     *  off either end is dropped; round a closed one it wraps. Default 0. */
+    offset?: number;
+    /** Turn each copy to the path's heading where it sits. Default `true`. */
+    orient?: boolean;
+    /** Curve flattening tolerance for measuring the path. Default 0.5. */
+    flattenTolerance?: number;
+}
+/** Where one copy sits. */
+interface RepeatStation {
+    point: Point;
+    /** The path's heading there, radians clockwise from +X in a y-down frame. */
+    angle: number;
+    /** Arc length from the path's start. */
+    distance: number;
+}
+/** The stations copies sit at along `path`, in order. Empty for a path with
+ *  no points. */
+declare function stationsAlongPath(path: Path, opts?: RepeatAlongPathOptions): RepeatStation[];
+/**
+ * Copies of `shape`, each centered on a station along `path` — its bounding
+ * box's middle on the path — and, with `orient`, turned to the heading
+ * there. The shape's own +X runs along the path.
+ */
+declare function repeatAlongPath(shape: Path, path: Path, opts?: RepeatAlongPathOptions): Path[];
+
 /**
  * Pure-geometry distance from a point to a path's boundary (stroke), with
  * no fill-side logic. Used by pickers that want to know "how close is this
@@ -593,89 +920,313 @@ declare function pointAlongPath(path: Path, t: number, opts?: PointAlongPathOpti
  *  combine with `pathContainsPoint` at the call site. */
 declare function pathDistanceToPoint(path: Path, px: number, py: number): number;
 
+/** Where two Bézier segments cross, by subdivision then Newton refinement. */
+
+/** One crossing of segments `a` and `b`: the parameter on each, and the point. */
+interface SegmentCrossing {
+    ta: number;
+    tb: number;
+    x: number;
+    y: number;
+}
 /**
- * Counts the path anchors used by the per-anchor coloring surface. An
- * "anchor" is the destination point of a path command: M, L, C, Q each
- * contribute one (the (x, y) where the pen ends up); Z contributes none
- * (it closes back to the subpath's first M). RectPath has four implicit
- * anchors — the corners — matching its M/L/L/L/Z stroke tessellation.
- *
- * Consumers use this to size their per-anchor color array; the renderer
- * uses it to validate the array length in dev builds.
+ * Every point where segment `a` crosses or touches segment `b` — each a line,
+ * quadratic or cubic given by its control points — with the parameter on
+ * each. Two lines are solved exactly; a curve is subdivided until its pieces
+ * are flat, their chords crossed, and the answer refined against the curves.
+ * Segments that overlap along a stretch report at most a few points of it.
+ * Sorted by `ta`.
+ */
+declare function intersectSegments(a: Point[], b: Point[]): SegmentCrossing[];
+
+/** A path's stroke as a flat list of segments, each knowing where it sits. */
+
+/** One segment of a path's stroke, in the order the path draws them. */
+interface PathSegment {
+    /** Control points: 2 for a line, 3 for a quadratic, 4 for a cubic. */
+    pts: Point[];
+    /** Index of its subpath among the path's subpaths. */
+    sub: number;
+    /** Index within its subpath. */
+    index: number;
+    /** Segments in its subpath. */
+    count: number;
+    /** Whether its subpath is closed, so its last segment meets its first. */
+    closed: boolean;
+    /** Axis-aligned box of the control points, which holds the segment. */
+    box: {
+        x0: number;
+        y0: number;
+        x1: number;
+        y1: number;
+    };
+}
+/** `path`'s stroke as segments: a closed subpath includes its closing edge,
+ *  an open one does not, and a zero-length line is left out. */
+declare function pathSegments(path: Path): PathSegment[];
+
+/** Where paths cross one another and themselves. */
+
+/** A place on a path's stroke: which segment, and how far along it. */
+interface PathStop {
+    /** Index of the path in the list it came from. */
+    path: number;
+    sub: number;
+    /** Segment index within the subpath. */
+    index: number;
+    /** Parameter on that segment, in [0, 1]. */
+    t: number;
+}
+/** A point where two strokes cross or touch, and where it falls on each. */
+interface PathCrossing {
+    x: number;
+    y: number;
+    a: PathStop;
+    b: PathStop;
+}
+/**
+ * Every crossing among `paths`: between each pair, and — unless `self` is
+ * false — of a path with itself, leaving out the joint where one segment
+ * meets the next. Points where strokes merely touch count too. With `of`,
+ * only the crossings involving that one path.
  */
+declare function pathCrossings(paths: readonly Path[], opts?: {
+    self?: boolean;
+    of?: number;
+}): PathCrossing[];
 
-/** One anchor of an editable path: its on-curve point plus the two control
- *  handles that shape the segments either side of it. Handles are in the same
- *  space as the point, and absent when the adjoining segment is straight. */
-interface PenAnchor {
+/**
+ * Geometric snapping onto paths: the points on a set of strokes a drawn or
+ * dragged point can lock to, and which of them a probe lands on.
+ */
+
+/**
+ * What a snap target is.
+ *
+ * - `anchor` — an end of a segment: a path's anchors, a box's corners.
+ * - `center` — a point a caller names as the middle of something: a text or
+ *   image box's center, given to {@link createPathSnapIndex} as a target.
+ * - `intersection` — where two strokes cross, or one crosses itself.
+ * - `tangent` — where a line from the query's origin touches a curve.
+ * - `perpendicular` — where a line from the origin meets a stroke square on.
+ * - `midpoint` — the middle of a segment by length.
+ * - `extremum` — on a curve, where its tangent turns horizontal or vertical.
+ * - `quadrant` — where a closed subpath crosses the horizontal and vertical
+ *   lines through the center of its box: a circle's four compass points.
+ * - `nearest` — the closest point on any stroke, when nothing else is in range.
+ */
+type PathSnapKind = 'anchor' | 'center' | 'intersection' | 'tangent' | 'perpendicular' | 'midpoint' | 'extremum' | 'quadrant' | 'nearest';
+/** Every snap kind, in the order a picker lists them. */
+declare const PATH_SNAP_KINDS: readonly PathSnapKind[];
+/** The kinds whose targets stand whatever the probe. */
+type StaticPathSnapKind = 'anchor' | 'center' | 'intersection' | 'midpoint' | 'extremum' | 'quadrant';
+/** A target the probe landed on. */
+interface PathSnapHit {
+    kind: PathSnapKind;
     x: number;
     y: number;
-    inHandle?: {
-        x: number;
-        y: number;
-    };
-    outHandle?: {
+    /** Distance from the probe, in the query's `radius` units. */
+    distance: number;
+    /** Indices of the paths that make the target: two for a crossing between
+     *  paths, one otherwise. */
+    paths: readonly number[];
+}
+/** A query for {@link findPathSnap}. */
+interface PathSnapQuery {
+    /** How far from the probe a target may be, in the paths' units times
+     *  `scale`. */
+    radius: number;
+    /** Per-axis scale from the paths' units to the units `radius` is in — a
+     *  view's, to measure the radius in screen pixels under any zoom. Default
+     *  `{ x: 1, y: 1 }`. */
+    scale?: {
         x: number;
         y: number;
     };
+    /** Kinds to consider. Absent, all of them. */
+    kinds?: Iterable<PathSnapKind>;
+    /** Where the line being drawn starts. Tangent and perpendicular targets are
+     *  measured from it, and there are none without it. */
+    origin?: Point;
+    /** Paths by index that offer no targets — the ones a drag is moving. */
+    skip?: (path: number) => boolean;
 }
+/** A target that stands whatever the probe: an anchor, a center, a crossing,
+ *  a midpoint, an extremum or a quadrant point. */
+interface PathSnapTarget {
+    kind: StaticPathSnapKind;
+    x: number;
+    y: number;
+    paths: readonly number[];
+}
+/** A set of paths, prepared for repeated snapping. Static targets are
+ *  computed on first use and kept. */
+interface PathSnapIndex {
+    readonly paths: readonly Path[];
+    /** Each path's segments. */
+    readonly segments: readonly (readonly PathSegment[])[];
+    /** The targets that do not depend on the probe, of one kind. */
+    targets(kind: StaticPathSnapKind): readonly PathSnapTarget[];
+}
+/** Prepare `paths` for {@link findPathSnap}. Build one per set of paths and
+ *  reuse it while they stand: a crossing search is quadratic in segments.
+ *  `extra` adds targets of the caller's own — the center of a box, a point
+ *  with no segment at it — each naming the path it belongs to. */
+declare function createPathSnapIndex(paths: readonly Path[], extra?: readonly PathSnapTarget[]): PathSnapIndex;
 /**
- * Derive a per-subpath anchor model from a PolygonPath. Subpaths split on
- * every `M` command; a subpath is closed iff it ends with `Z`.
- *
- * Cubic-segment control points become the outHandle of the previous anchor
- * and the inHandle of the next anchor. A closed subpath whose last curve ends
- * exactly on its first point holds that point twice; the two are one anchor,
- * and the curve's second control is that anchor's inHandle. Quadratic segments are upgraded to
- * cubics (each control reused for both adjacent handles) — this loses no
- * geometry. Linear segments produce anchors with no handles.
- */
-declare function pathToAnchors(path: PolygonPath): {
-    anchors: PenAnchor[][];
-    closed: boolean[];
-};
+ * The snap target nearest `probe` within `query.radius`, or null when none
+ * is in range. Every enabled kind competes on distance, except `nearest`,
+ * which answers only when no other target is in range.
+ */
+declare function findPathSnap(index: PathSnapIndex, probe: Point, query: PathSnapQuery): PathSnapHit | null;
 /**
- * Serialize the per-subpath anchor model back to a PolygonPath. Inverse of
- * `pathToAnchors`. Curve-vs-line decision per segment:
- *   - Both adjacent handles absent → straight L segment.
- *   - Either handle present → C segment, with missing handles defaulting to
- *     the anchor point itself (degenerate but valid; renders as a near-line).
- * Given `like`, the path being reshaped, the result keeps its fill rules.
+ * Every snap target within `query.radius` of `probe`, unsorted. `nearest`
+ * hits appear only when no other target is in range. Tangent and perpendicular targets
+ * closer to the origin than the radius are dropped, so a line cannot snap
+ * back onto its own start.
  */
-declare function anchorsToPath(anchors: PenAnchor[][], closed: boolean[], like?: PolygonPath): PolygonPath;
+declare function findPathSnaps(index: PathSnapIndex, probe: Point, query: PathSnapQuery): PathSnapHit[];
+
 /**
- * Returns true if the anchor's in-handle and out-handle are collinear with
- * the anchor point, indicating "smooth" (mirror-drag) behavior. Detected via
- * the magnitude of the normalized cross product of the two handle vectors.
+ * Trim: remove the piece of a stroke between the crossings on either side of
+ * a point, as a drafting trim does.
+ */
+
+/** Options for {@link trimPathAt}. */
+interface TrimPathOptions {
+    /** How far from the stroke `probe` may be. Default: any distance. */
+    radius?: number;
+}
+/** What {@link trimPathAt} did. */
+interface TrimResult {
+    /** The path with the piece gone; it has no commands when nothing is left. */
+    path: PolygonPath;
+    /** The piece removed, as an open path. */
+    removed: PolygonPath;
+}
+/**
+ * Remove the piece of `path`'s stroke that `probe` is nearest, bounded by the
+ * nearest crossings on either side — with any of `cutters`, or with the path
+ * itself. On an open subpath an end with no crossing before it bounds the
+ * piece too, so a subpath touched only at its ends goes whole; a closed
+ * subpath is opened, and one crossed at a single point is removed whole.
  *
- * Edge cases:
- *   - Missing in or out handle → false (corner by definition).
- *   - Either handle at zero distance from anchor → false.
- */
-declare function isAnchorSmooth(a: PenAnchor): boolean;
-/** How many anchors a path has. Matches the per-anchor arrays the renderer
- *  expects for `vertexColors`. */
-declare function countPathAnchors(path: Path): number;
-/** The segment `(sub, segIdx)` as its two end anchors, or null when it
- *  doesn't exist. `segIdx === sub.length - 1` names a closed subpath's
- *  closing segment, which runs from the last anchor back to the first. */
-declare function segmentEnds(anchors: readonly PenAnchor[][], closed: readonly boolean[] | undefined, sub: number, segIdx: number): {
-    a: PenAnchor;
-    b: PenAnchor;
-} | null;
-/** Whether the segment from `a` to `b` is a straight line (no handles). */
-declare function isStraightSegment(a: PenAnchor, b: PenAnchor): boolean;
-/** The segment of a decoded path nearest `(wx, wy)`, and the parameter `t`
- *  on it closest to that point. Pass `closed` (from `pathToAnchors`) to
- *  include each closed subpath's closing segment, reported as
- *  `segIdx === sub.length - 1`. `t` spans `[0, 1]`, endpoints included.
- *  Returns `null` only when there are no segments. */
-declare function nearestSegmentT(anchors: PenAnchor[][], wx: number, wy: number, closed?: readonly boolean[]): {
+ * Returns null when the probe is further than `radius` from the stroke, or
+ * when nothing crosses or touches the subpath it is on. Curves are split where they are
+ * cut and keep their type; other subpaths are left as they were.
+ */
+declare function trimPathAt(path: Path, cutters: readonly Path[], probe: Point, opts?: TrimPathOptions): TrimResult | null;
+
+/** What stays put of a path while some of its anchors move. */
+interface PathAwayFromAnchors {
+    /** The segments touching none of the moving anchors, as open runs; a
+     *  subpath none of them is on stays as it was. */
+    path: PolygonPath;
+    /** Every anchor that is not moving, a lone one with no segment left at it
+     *  included. */
+    anchors: Point[];
+}
+/**
+ * The part of `path` that holds still while the anchors at `moving` (flat
+ * indices, as anchor editing numbers them) are dragged: every segment with a
+ * moving anchor at either end is dropped, and so are the moving anchors.
+ */
+declare function pathAwayFromAnchors(path: PolygonPath, moving: Iterable<number>): PathAwayFromAnchors;
+
+/**
+ * Growing an open end of a path along its tangent: by a distance, or until it
+ * meets another stroke.
+ */
+
+/** One end of an open subpath. `sub` counts subpaths as the path's anchor set
+ *  (`pathToAnchors`) does, a bare `M` included. */
+interface OpenPathEnd {
     sub: number;
-    segIdx: number;
-    t: number;
+    end: 'first' | 'last';
+}
+/** Every end of every open subpath of `path` that has a direction to grow in. */
+declare function openPathEnds(path: Path): OpenPathEnd[];
+/** Where `end` sits and the unit direction it points out along, or null when
+ *  it is no open end or has no direction there. */
+declare function openEndRay(path: Path, end: OpenPathEnd): {
+    at: Point;
+    dir: Point;
+} | null;
+/**
+ * `path` with `end` carried `distance` further along its tangent, by
+ * `lengthenPathEnd` in `'tangent'` mode: a straight end segment grows longer,
+ * and a curved one gains a straight segment, which keeps the tangent
+ * continuous. Null when the end is not open or has no direction, or
+ * `distance` is not positive.
+ */
+declare function lengthenOpenEnd(path: Path, end: OpenPathEnd, distance: number): PolygonPath | null;
+/** Options for {@link extendToMeet}. */
+interface ExtendToMeetOptions {
+    /** The furthest the end may travel. Default: as far as any stroke reaches. */
+    maxDistance?: number;
+}
+/**
+ * Extend `end` of `path` along its tangent to the first stroke it meets —
+ * one of `boundaries`, or `path`'s own other segments. Returns the extended
+ * path, the point it now ends at and how far it went, or null when the
+ * tangent meets nothing.
+ */
+declare function extendToMeet(path: Path, boundaries: readonly Path[], end: OpenPathEnd, opts?: ExtendToMeetOptions): {
+    path: PolygonPath;
+    at: Point;
+    distance: number;
 } | null;
 
+/**
+ * Grow or trim an open subpath at one of its ends. Lengthen drags this, and
+ * Extend to next path reaches it through `lengthenOpenEnd`.
+ *
+ * A positive distance extends the end outward: straight along the end tangent,
+ * or along a circular arc with the curvature the end has, which meets the path
+ * with matching direction and curvature. A straight end segment is lengthened
+ * in place; a curved one is continued with a new segment. A negative distance
+ * trims the path back along itself by arc length, whichever way it would have
+ * grown.
+ *
+ * The arc rather than extrapolating the end cubic past t = 1: a cubic's
+ * leading term takes over beyond its range, so a continued curve swings off
+ * and curls on itself within a segment's length, while the arc keeps the
+ * curvature the end shows for as long as it is drawn.
+ */
+
+/** How `lengthenPathEnd` grows an end: straight on, or bending as the end bends. */
+type LengthenMode = 'tangent' | 'curvature';
+/** Where an end is, which way it heads out of the path, and how it bends there. */
+interface PathEndFrame {
+    point: Point;
+    /** Unit vector pointing out of the path. */
+    tangent: Point;
+    /** Signed curvature along `tangent`: positive turns toward `(-tangent.y, tangent.x)`. */
+    curvature: number;
+}
+/** The end of an open subpath that the anchor at `flatIndex` is, or null when it is
+ *  an inner anchor, on a closed subpath, or alone in its subpath. */
+declare function openEndAt(set: AnchorSet, flatIndex: number): OpenPathEnd | null;
+/** Flat index of the anchor at `end`, or -1 when there is none. */
+declare function pathEndAnchorIndex(set: AnchorSet, end: OpenPathEnd): number;
+/** The frame at `end`, or null when it is not the end of an open subpath of two or
+ *  more anchors, or the path has no direction there. */
+declare function pathEndFrame(set: AnchorSet, end: OpenPathEnd): PathEndFrame | null;
+/**
+ * Lengthen `end` by `distance` (see the module comment), in place. A curvature arc
+ * stops at one full turn. Returns false when `end` is not the end of an open
+ * subpath or nothing changed.
+ */
+declare function lengthenPathEnd(set: AnchorSet, end: OpenPathEnd, distance: number, mode: LengthenMode): boolean;
+/**
+ * The distance `lengthenPathEnd` takes for its new end to land nearest `point`: the
+ * point projected onto the end tangent, or for a curvature lengthening, measured
+ * around the circle of curvature. A measurement around the circle can name the
+ * same spot a turn apart; it answers the one nearest `near`, so a drag passing
+ * half a turn keeps going instead of jumping back.
+ */
+declare function lengthToward(set: AnchorSet, end: OpenPathEnd, mode: LengthenMode, point: Point, near?: number): number;
+
 /**
  * Controls for the one cubic that replaces `prev → removed → next` when
  * `removed` is deleted. The new controls keep the directions the curve leaves
@@ -685,8 +1236,8 @@ declare function nearestSegmentT(anchors: PenAnchor[][], wx: number, wy: number,
  * cubic, the original cubic comes back.
  */
 declare function fitCubicThroughDeletion(prev: PenAnchor, removed: PenAnchor, next: PenAnchor): {
-    c1: Point$1;
-    c2: Point$1;
+    c1: Point;
+    c2: Point;
 };
 
 /**
@@ -698,7 +1249,7 @@ declare function fitCubicThroughDeletion(prev: PenAnchor, removed: PenAnchor, ne
  * `C` cubic segments. For colinear / two-point inputs, returns a single
  * degenerate cubic. For empty input, returns an empty polygon path.
  */
-declare function schneiderFit(samples: ReadonlyArray<Point$1>, errorTolerance: number): PolygonPath;
+declare function schneiderFit(samples: ReadonlyArray<Point>, errorTolerance: number): PolygonPath;
 /**
  * The single cubic from the first sample to the last that best fits the
  * samples between, with its control points held to the given unit tangents:
@@ -709,12 +1260,12 @@ declare function schneiderFit(samples: ReadonlyArray<Point$1>, errorTolerance: n
  * omitted; `passes` is how many times those are refined and the lengths
  * solved again.
  */
-declare function fitCubicWithTangents(samples: ReadonlyArray<Point$1>, tStart: Point$1, tEnd: Point$1, opts?: {
+declare function fitCubicWithTangents(samples: ReadonlyArray<Point>, tStart: Point, tEnd: Point, opts?: {
     params?: ReadonlyArray<number>;
     passes?: number;
 }): {
-    cp1: Point$1;
-    cp2: Point$1;
+    cp1: Point;
+    cp2: Point;
 };
 
 /** Options for {@link simplifyPath}. */
@@ -734,195 +1285,156 @@ interface SimplifyPathOptions {
  * becomes one straight segment. Fill rules carry over.
  */
 declare function simplifyPath(path: PolygonPath, tolerance: number, opts?: SimplifyPathOptions): PolygonPath;
-
+/** One subpath of {@link simplifyPath}: its anchors refitted, corners and
+ *  open ends kept. */
+declare function simplifySubpath(sub: PenAnchor[], closed: boolean, tolerance: number, opts?: SimplifyPathOptions): PenAnchor[];
+/**
+ * The anchors of `sub` from index `from` to `to`, refitted the way
+ * {@link simplifyPath} refits a subpath: as few as hold the span within
+ * `tolerance`, corners inside it kept. Indices run modulo the subpath's
+ * length, so on a closed subpath `to` may pass its end and wrap; the span is
+ * shorter than one full turn. The two end anchors stay where they are and
+ * keep their handles facing out of the span. Answers the anchors from `from`
+ * to `to`, both included, to splice in place of the originals.
+ */
+declare function simplifySpan(sub: PenAnchor[], closed: boolean, from: number, to: number, tolerance: number, opts?: SimplifyPathOptions): PenAnchor[];
+
+/** Options for {@link growRegion}. */
+interface GrowRegionOptions {
+    /** How a convex corner turns. `'miter'` keeps it sharp, as a pseudo-distance
+     *  field draws it; `'round'` follows the true distance. Default `'miter'`. */
+    join?: 'miter' | 'round';
+    /** Past this ratio of miter length to distance a miter corner is beveled.
+     *  Default 4. */
+    miterLimit?: number;
+    /** How far a grown curve may stray from the true offset, in the path's
+     *  units. Default 0.1. */
+    tolerance?: number;
+}
 /**
- * Screen-pixel lengths in world units, per axis.
+ * The region `path` fills under `'nonzero'`, grown by `distance` (> 0), as a
+ * path that fills it under `'nonzero'`. Every subpath counts as closed. Each
+ * contour is replaced by its offset, so where grown parts meet the contours
+ * overlap rather than merge, and a hole grown shut winds back on itself and
+ * fills. At an inside corner the two offset edges are cut back to where they
+ * cross; where they do not, the gap is passed through the corner's original
+ * point, which closes it with a loop inside the fill. `mergeRegion`
+ * redraws the result as its outline alone, for a stroke.
  *
- * Chrome declares its hit zones in screen pixels — an 8px handle stays 8px at
- * every zoom, because it paints in screen space. Converting one such length to
- * world units with a single scalar (see `meanScale`) is exact only under
- * uniform zoom; per-axis it is too generous on one axis and too mean on the
- * other, so the pickable region stops matching the painted one.
- *
- * Prefer {@link withinPxBox} / {@link withinPxRadius}, which compare in screen
- * space and so can't drift from the paint at all. {@link pxExtent} is for the
- * cases that must stay in world units — a tolerance handed to geometry that
- * doesn't know about the view.
- */
-interface Scale2 {
-    x: number;
-    y: number;
+ * What it costs: one segment per curve, more where `tolerance` needs the curve
+ * split; a miter corner between two straight edges costs nothing, one beside
+ * a curve gains an anchor or two, a round corner an arc, and an inside corner
+ * whose edges do not cross two.
+ */
+declare function growRegion(path: Path, distance: number, opts?: GrowRegionOptions): PolygonPath;
+
+/** Options for {@link mergeRegion}. */
+interface MergeRegionOptions {
+    /** How far from an edge a point is taken to tell which side is filled, in
+     *  the path's units; a sliver of region thinner than this may be lost.
+     *  Default 0.01. */
+    tolerance?: number;
 }
-/** One screen-pixel length as world-space extents, per axis. `scale` is a
- *  view's, so neither axis is zero (see `View`).
- *
- *  With `rotation`, the axes are a frame turned that far from world, and each
- *  extent is how far along it an edge across it must move to move `px` on
- *  screen — which, under non-uniform zoom, is not the extent along the screen
- *  axis nearest to it. */
-declare function pxExtent(px: number, scale: Scale2, rotation?: number): {
-    x: number;
-    y: number;
-};
-/** World delta → screen delta. Only the scale participates: translation
- *  cancels in a difference, and the kit's views carry no skew. */
-declare function scaleDelta(dx: number, dy: number, scale: Scale2): {
-    x: number;
-    y: number;
-};
 /**
- * Is a world-space delta inside a screen-space square of half-extent `px`?
- *
- * The square is axis-aligned **on screen**, which is what a handle painted in
- * screen space actually is — so this stays true under non-uniform zoom and
- * under a rotated target, where an axis-aligned world-space test is a rotated
- * rectangle on screen.
- */
-declare function withinPxBox(dx: number, dy: number, px: number, scale: Scale2): boolean;
-/** Is a world-space delta inside a screen-space circle of radius `px`? */
-declare function withinPxRadius(dx: number, dy: number, px: number, scale: Scale2): boolean;
+ * The region `path` fills under `'nonzero'`, as contours that neither cross
+ * nor overlap, wound so the fill lies on the same side of each as it does on
+ * most of `path`. Stroking it traces only the region's edge. Every subpath
+ * counts as closed. Answers `path`'s own contours, unchanged, where nothing
+ * needs cutting or dropping.
+ */
+declare function mergeRegion(path: Path, opts?: MergeRegionOptions): PolygonPath;
+
+/**
+ * Simplify only where `flatIndexes` say: each unbroken run of those anchors
+ * along a subpath is refitted as one span by the fitter {@link simplifyPath}
+ * uses (`simplifySpan`), so only anchors the shape does not need, within
+ * `tolerance`, go. A run's first and last anchors stay, and every anchor
+ * outside a run is left as it was. A closed subpath named whole is simplified
+ * whole. Answers whether any anchor went; a run the fit cannot thin is left
+ * untouched.
+ */
+declare function simplifyAnchorsAt(set: AnchorSet, flatIndexes: Iterable<number>, tolerance: number, opts?: SimplifyPathOptions): boolean;
+
+/**
+ * Resample: a path's anchors spread evenly along it by arc length, and its
+ * curves refitted through them.
+ */
+
+/** Options for {@link resamplePath}. */
+interface ResamplePathOptions {
+    /** How many anchors the result holds across all its subpaths. Default: as
+     *  many as `path` has. Ignored when `spacing` is given. */
+    count?: number;
+    /** The distance along the path between neighboring anchors, in path units.
+     *  Each run between fixed anchors is cut into the whole number of equal
+     *  pieces nearest this. */
+    spacing?: number;
+    /** Keep every corner anchor (`isAnchorSmooth` false) where it is, with its
+     *  corner, and resample the runs between. Default `true`. Open ends are
+     *  kept either way. */
+    keepCorners?: boolean;
+    /** How far the result may stray from the original, in path units. A piece
+     *  that cannot follow the original this closely is halved, so the result can
+     *  hold more anchors than `count` asks for. Default 0.5. */
+    tolerance?: number;
+}
 /**
- * A world point pushed `px` screen pixels off an edge, along the edge's normal
- * as it lands on screen. `normal` is the edge's outward normal in world space.
- *
- * Scaling the world normal by the view is not the same thing: under
- * non-uniform zoom the image of a normal is no longer perpendicular to the
- * image of its edge, so chrome placed that way drifts sideways and sits closer
- * than `px`. Returns the point in world coords and the on-screen unit normal.
+ * `path` with its anchors spread evenly along each run between fixed anchors
+ * ({@link ResamplePathOptions}), each new anchor heading the way the original
+ * does there. Anchors that were smooth stay smooth, and the curves between
+ * are fitted to the original. A closed subpath with no fixed anchor keeps
+ * its first one as the place the even spacing starts from. Fill rules carry
+ * over.
  */
-declare function standoff(anchor: {
-    x: number;
-    y: number;
-}, normal: {
-    x: number;
-    y: number;
-}, px: number, scale: Scale2): {
-    x: number;
-    y: number;
-    nx: number;
-    ny: number;
-};
-/** The screen angle a frame turned `rotation` from world lands its x axis at.
- *  Equals `rotation` under uniform zoom; non-uniform zoom bends it. */
-declare function screenAngleOf(rotation: number, scale: Scale2): number;
+declare function resamplePath(path: PolygonPath, opts?: ResamplePathOptions): PolygonPath;
 
+/** The parameters in (0, 1) where the segment from `a` to `b` turns in x or
+ *  y, ascending, or none for a straight segment. */
+declare function segmentExtremaTs(a: PenAnchor, b: PenAnchor): number[];
 /**
- * Pure anchor-set edits on the model `pathToAnchors` produces: subpath-major
- * `PenAnchor[][]` plus a parallel `closed: boolean[]`. Every function here
- * mutates that structure in place; callers decode with `pathToAnchors`,
- * apply, and re-encode with `anchorsToPath` (see {@link editAnchorSet}).
- *
- * Callers address anchors by flat index — the sequential position in walk
- * order across all subpaths, which is what `enumerateAnchors` reports.
- * {@link locateAnchor} and {@link flatAnchorIndex} convert to and from the
- * `(sub, idx)` pair.
- *
- * The two orders agree because `pathToAnchors` and `enumerateAnchors`
- * walk the same command stream and emit one anchor per M/L/C/Q, less the
- * end of a closing curve that lands on its subpath's first point.
- * `countPathAnchors`, which sizes the renderer's per-anchor arrays, counts
- * that end too and so can be one higher per closed subpath.
+ * Split every curved segment of `set` at its extremes
+ * ({@link segmentExtremaTs}), in place. `include(sub, segIdx)` limits it to
+ * some segments, named as `segmentEnds` names them; absent, every one.
+ * Returns the new anchors' flat indices in the edited set. Each new anchor is
+ * smooth, and every anchor after one moves up an index.
  */
+declare function addExtremaAnchors(set: AnchorSet, include?: (sub: number, segIdx: number) => boolean): number[];
 
-/** Subpath-major anchor model — the decoded form of a `PolygonPath`. */
-interface AnchorSet {
-    anchors: PenAnchor[][];
-    closed: boolean[];
-}
-/** A world-space rectangle, as produced by a drag-rect gesture. */
-interface AnchorRect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-/** Total anchors across every subpath. */
-declare function anchorCount(set: AnchorSet): number;
-/** Flat index → `(sub, idx)`. Returns null when out of range. */
-declare function locateAnchor(set: AnchorSet, flatIndex: number): {
-    sub: number;
-    idx: number;
-} | null;
-/** `(sub, idx)` → flat index. Returns -1 when out of range. */
-declare function flatAnchorIndex(set: AnchorSet, sub: number, idx: number): number;
-/** Resolve a flat index to the anchor itself. Null when out of range. */
-declare function anchorAt(set: AnchorSet, flatIndex: number): PenAnchor | null;
-/**
- * Decode `path`, hand the mutable anchor set to `edit`, and re-encode.
- * Returns null when `edit` returns `false` (it changed nothing), so callers
- * can skip a no-op commit.
- */
-declare function editAnchorSet(path: PolygonPath, edit: (set: AnchorSet) => boolean | void): PolygonPath | null;
-/** Translate an anchor and both of its handles by `(dx, dy)`. */
-declare function translateAnchorBy(set: AnchorSet, flatIndex: number, dx: number, dy: number): boolean;
 /**
- * Move one control handle to an absolute world position. When the anchor was
- * smooth (handles collinear through the anchor) and `breakSmoothness` is
- * false, the opposite handle is mirrored so the curve stays smooth.
- */
-declare function moveHandleTo(set: AnchorSet, flatIndex: number, side: 'in' | 'out', toX: number, toY: number, breakSmoothness: boolean): boolean;
-/**
- * Split the segment `(sub, segIdx) → (sub, segIdx + 1)` at parameter `t`,
- * inserting a new anchor there. On a closed subpath `segIdx` may also name
- * the closing segment (`sub.length - 1`); its new anchor is appended.
+ * Anchor selections walked along the path: grown or shrunk by one anchor,
+ * every Nth anchor, anchors by kind, and the complement. Each takes the
+ * decoded set and a selection as flat indices, and returns a new selection
+ * as sorted flat indices; none of them edits the set.
  *
- * A straight segment stays straight — the new anchor has no handles. A curved
- * one splits by de Casteljau, so the two halves trace the original path.
- *
- * Returns the new anchor's flat index, or -1 when the segment doesn't
- * exist.
+ * "Along the path" means within a subpath: an anchor's neighbors are the
+ * anchors before and after it there, and a closed subpath's first and last
+ * anchors are neighbors.
  */
-declare function insertAnchorOnSegment(set: AnchorSet, args: {
-    sub: number;
-    segIdx: number;
-    t: number;
-}): number;
-/** A point on a segment, as {@link segmentAt} reports it. */
-interface SegmentHit {
-    sub: number;
-    segIdx: number;
-    /** Parameter on the segment — what {@link insertAnchorOnSegment} takes. */
-    t: number;
-    /** The point on the path at `t`, in the set's own space. */
-    x: number;
-    y: number;
-}
-/**
- * The segment point under `(x, y)`, when it lies within `tolerancePx` of
- * the path on screen and no nearer than that to either of the segment's
- * own anchors — a press on an anchor is about the anchor, not the segment
- * beside it.
- *
- * `scale` is the view's, so the tolerance holds per axis under
- * non-uniform zoom. The search runs in screen-scaled space: scaling is
- * affine, so the curve's parameterization, and therefore `t`, carries
- * straight back to world space.
- */
-declare function segmentAt(set: AnchorSet, x: number, y: number, opts: {
-    tolerancePx: number;
-    scale?: Scale2;
-}): SegmentHit | null;
+
+/** `selected` with each selected anchor's neighbors along the path added. */
+declare function growAnchorSelection(set: AnchorSet, selected: Iterable<number>): number[];
 /**
- * Delete the anchors at `flatIndexes`. Where a deleted anchor had
- * neighbors on both sides — across the seam too, on a closed subpath — the
- * surviving segment is refitted to the two it replaces (`fitCubicThroughDeletion`)
- * so the path keeps its shape; a gap between two straight segments closes straight.
- *
- * Subpaths left with fewer than two anchors are dropped entirely. If that
- * would leave the path with no subpaths at all, the whole deletion is refused
- * (returns false, `set` untouched): an empty path leaves the node selected
- * and in the scene with nothing on screen and no anchors to grab it by.
+ * `selected` less every anchor at the edge of a selected run: one with a
+ * neighbor that is unselected, or none on one side, as an open subpath's ends
+ * have. A closed subpath selected all the way round has no edge and stays.
  */
-declare function deleteAnchorsAt(set: AnchorSet, flatIndexes: Iterable<number>): boolean;
+declare function shrinkAnchorSelection(set: AnchorSet, selected: Iterable<number>): number[];
 /**
- * Scissors: open a closed subpath at the given anchor. The anchor list is
- * rotated to start there and a second anchor at the same point ends it, so
- * every segment survives and the two ends can be pulled apart. No-ops on an
- * already-open subpath — there's nothing to cut.
+ * Every `n`th anchor along each subpath, counting from its first selected
+ * anchor. With nothing selected, every subpath counts from its first anchor;
+ * otherwise only subpaths holding a selected anchor take part. A closed
+ * subpath is walked once round, so the count does not wrap onto itself.
  */
-declare function openSubpathAt(set: AnchorSet, flatIndex: number): boolean;
-/** Flat indices of every anchor whose on-curve point falls inside `rect`. */
-declare function anchorsInRect(set: AnchorSet, rect: AnchorRect): number[];
+declare function everyNthAnchor(set: AnchorSet, n: number, selected?: Iterable<number>): number[];
+/** Every anchor `keep` says yes to. */
+declare function anchorsWhere(set: AnchorSet, keep: (anchor: PenAnchor) => boolean): number[];
+/** Every corner anchor: one whose handles are not collinear through it, or
+ *  that lacks one (`isAnchorSmooth` false). */
+declare function cornerAnchors(set: AnchorSet): number[];
+/** Every smooth anchor (`isAnchorSmooth`). */
+declare function smoothAnchors(set: AnchorSet): number[];
+/** Every anchor `selected` leaves out. */
+declare function invertAnchorSelection(set: AnchorSet, selected: Iterable<number>): number[];
 
 /**
  * Average and Join: anchor-set edits that bring anchors together. Both mutate
@@ -939,6 +1451,13 @@ interface SubpathEnd {
     sub: number;
     end: 'first' | 'last';
 }
+/** How {@link joinSubpathEnds} spans the gap between two ends apart. */
+interface JoinOptions {
+    /** Absent, a straight segment. Given, a curve leaving each end along the
+     *  direction its path was heading there, each handle `tension` times the
+     *  gap long; `0` is a straight segment. */
+    tension?: number;
+}
 /**
  * Move each anchor in `flatIndexes` to their mean position, along `axis`.
  * Each anchor carries its handles with it. Returns false, changing nothing,
@@ -953,19 +1472,71 @@ declare function subpathEndAt(set: AnchorSet, flatIndex: number): SubpathEnd | n
  * close it; ends of two subpaths make one subpath, `a`'s run followed by
  * `b`'s, in the slot of whichever came first. Ends that coincide merge into
  * one anchor, keeping the handle on either side; ends apart are bridged by a
- * straight segment. Returns false, changing nothing, when the ends are not
- * two distinct ends of open subpaths.
+ * straight segment, or with `options.tension` by a curve meeting each end
+ * tangentially. Returns false, changing nothing, when the ends are not two
+ * distinct ends of open subpaths.
  */
-declare function joinSubpathEnds(set: AnchorSet, a: SubpathEnd, b: SubpathEnd): boolean;
+declare function joinSubpathEnds(set: AnchorSet, a: SubpathEnd, b: SubpathEnd, options?: JoinOptions): boolean;
 /** {@link joinSubpathEnds} for two anchors named by flat index, each the end
  *  of an open subpath. */
-declare function joinAnchorsAt(set: AnchorSet, flatA: number, flatB: number): boolean;
+declare function joinAnchorsAt(set: AnchorSet, flatA: number, flatB: number, options?: JoinOptions): boolean;
 /**
  * The two open-subpath ends nearest each other that `accept` allows, on two
  * different subpaths. Null when there are no two such subpaths.
  */
 declare function closestOpenEnds(set: AnchorSet, accept?: (a: SubpathEnd, b: SubpathEnd) => boolean): [SubpathEnd, SubpathEnd] | null;
 
+/**
+ * Spiro curves as cubic paths, and back. A solved curve is written as cubics,
+ * each spiral segment split into as many as it takes to stay within tolerance,
+ * so most anchors of the path are not spiro points. `at` records which are:
+ * `at[i]` is the flat anchor index of point `i`, counted across subpaths. The
+ * points are then read back out of the path itself, so whatever moves the path
+ * — a move, a resize, a rotation — moves them with it.
+ */
+
+/** One subpath of a spiro curve: its points, and whether it closes. */
+interface SpiroContour {
+    points: SpiroPoint[];
+    closed: boolean;
+}
+/** A spiro curve written as a cubic path, with the anchor each point became. */
+interface SpiroPath {
+    path: PolygonPath;
+    /** The flat anchor index of each point, in contour order. */
+    at: number[];
+}
+/** Options for {@link spiroToPath}. */
+interface SpiroToPathOptions {
+    /** The furthest a cubic may stray from its spiral, as a fraction of that
+     *  segment's arc length. Default `1e-4`. */
+    tolerance?: number;
+    /** The path being reshaped, whose fill rules the result keeps. */
+    like?: PolygonPath;
+}
+/**
+ * Solve each contour and write it as a cubic path. Straight segments carry no
+ * handles.
+ */
+declare function spiroToPath(contours: readonly SpiroContour[], options?: SpiroToPathOptions): SpiroPath;
+/**
+ * The spiro points `path` holds, given the kind of each and the anchor each
+ * became. Null when `kinds` and `at` do not describe `path`: the counts
+ * differ, an index is out of order or out of range, or a subpath does not
+ * start on a point.
+ */
+declare function spiroContoursOf(path: PolygonPath, kinds: readonly SpiroKind[], at: readonly number[]): SpiroContour[] | null;
+/** The straight-sided path through each contour's points: what an editor
+ *  shows and moves in place of the curve. */
+declare function spiroControlPath(contours: readonly SpiroContour[]): PolygonPath;
+/**
+ * Read an edited control path back as contours: every anchor is a point.
+ * Kinds follow from `before`, the contours the edit started from: point for
+ * point when the count is unchanged, else by position, with an anchor that
+ * lands nowhere a point was taking `fallback`. Handles are ignored.
+ */
+declare function spiroContoursFromControl(control: PolygonPath, before: readonly SpiroContour[], fallback?: SpiroKind): SpiroContour[];
+
 /**
  * Path hit-testing: path-vs-point (filled region and stroke distance),
  * path-vs-rect, and path-vs-polygon in both directions.
@@ -1020,15 +1591,15 @@ declare function pathContainsRect(path: Path, rect: Rect, opts?: PointInPathOpti
 /** Returns true if `rect` overlaps (intersects or contains) `path`. */
 declare function pathIntersectsRect(path: Path, rect: Rect, opts?: PointInPathOptions): boolean;
 /** Returns true if every vertex of `polygon` lies inside `path`. */
-declare function pathContainsPolygon(path: Path, polygon: readonly Point$1[], opts?: PointInPathOptions): boolean;
+declare function pathContainsPolygon(path: Path, polygon: readonly Point[], opts?: PointInPathOptions): boolean;
 /** Returns true if `polygon` overlaps (intersects or is contained by) `path`. */
-declare function pathIntersectsPolygon(path: Path, polygon: readonly Point$1[], opts?: PointInPathOptions): boolean;
+declare function pathIntersectsPolygon(path: Path, polygon: readonly Point[], opts?: PointInPathOptions): boolean;
 /**
  * Returns true if all of `path` — every subpath, open ones included, beziers
  * flattened — lies inside the closed `polygon`: the inverse of
  * {@link pathContainsPolygon}. A lasso enclosing a shape asks this.
  */
-declare function polygonContainsPath(polygon: readonly Point$1[], path: Path, opts?: PointInPathOptions): boolean;
+declare function polygonContainsPath(polygon: readonly Point[], path: Path, opts?: PointInPathOptions): boolean;
 /**
  * Returns true if any of `path` meets the closed `polygon`: its filled region,
  * or the line of an open subpath, which encloses nothing. With `filled: false`
@@ -1036,7 +1607,16 @@ declare function polygonContainsPath(polygon: readonly Point$1[], path: Path, op
  * flattened, so a control point off the curve never counts. The companion of
  * {@link polygonContainsPath}; a lasso touching a shape asks this.
  */
-declare function polygonIntersectsPath(polygon: readonly Point$1[], path: Path, opts?: PolygonIntersectsPathOptions): boolean;
+declare function polygonIntersectsPath(polygon: readonly Point[], path: Path, opts?: PolygonIntersectsPathOptions): boolean;
+
+/**
+ * The affine map carrying the points of `from` closest to those of `to`, by
+ * least squares; both are interleaved `x, y` streams of the same length. When
+ * the points lie on one line an affine map is not determined, and the
+ * similarity (turn, even scale and move) is returned instead. Null for fewer
+ * than two distinct points.
+ */
+declare function fitAffine(from: ArrayLike<number>, to: ArrayLike<number>): Affine | null;
 
 /**
  * Ergonomic builders for tiny shape paths used by chrome / overlays / markers.
@@ -1394,6 +1974,20 @@ declare function rotatePathAround(path: Path, cx: number, cy: number, rotation:
  * rotation. Absent is the identity.
  */
 type PoseLinear = readonly [a: number, b: number, c: number, d: number];
+/**
+ * Axis-aligned rectangle in world space. The optional `rotation` (radians,
+ * around the AABB center) and `transform` (inside it, about the same center)
+ * let chrome carry the frame a box is drawn in without a parallel type;
+ * `poseFrameOf` composes the two. routing and core call it `Bounds`.
+ */
+interface FramedBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation?: number;
+    transform?: PoseLinear;
+}
 /** `transform` when it changes anything, `null` for absent or the identity. */
 declare function poseLinearOf(pose: unknown): PoseLinear | null;
 /**
@@ -1412,7 +2006,17 @@ declare function poseFrameInverseOf(pose: unknown): Affine | null;
 /** `path`, given in the pose's unrotated box frame, as the node draws it. */
 declare function pathThroughPoseFrame(path: Path, pose: unknown): Path;
 
-type Side = 'in' | 'out';
+/**
+ * Flat indices of every anchor a round brush covers as it moves from `from` to
+ * `to`: those within `radiusPx` of that segment, measured on screen. A dab is a
+ * segment of zero length. `scale` is the view's, so the brush stays round on
+ * screen under non-uniform zoom; omitted, one unit is one pixel.
+ */
+declare function anchorsUnderBrush(set: AnchorSet, from: Point, to: Point, opts: {
+    radiusPx: number;
+    scale?: Scale2;
+}): number[];
+
 /**
  * How a path maps onto itself under one transform `m`: `partners[i]` is the
  * flat index of the anchor that anchor `i` lands on, and `flips[i]` whether
@@ -1454,7 +2058,7 @@ declare function translateAnchorsSymmetric(set: AnchorSet, flats: readonly numbe
  * follow it. Every handle is written once, from its target, so no anchor
  * re-aims a handle another image already placed.
  */
-declare function moveHandleSymmetric(set: AnchorSet, flat: number, side: Side, toX: number, toY: number, breakSmoothness: boolean, syms: readonly AnchorSymmetry[]): boolean;
+declare function moveHandleSymmetric(set: AnchorSet, flat: number, side: 'in' | 'out', toX: number, toY: number, breakSmoothness: boolean, syms: readonly AnchorSymmetry[]): boolean;
 
 /** Where on a segment a bend is held, as `segmentAt` reports it. */
 interface BendGrip {
@@ -1475,10 +2079,38 @@ interface BendGrip {
  */
 declare function bendSegment(set: AnchorSet, grip: BendGrip, dx: number, dy: number): boolean;
 
-type Point = {
-    x: number;
-    y: number;
-};
+/**
+ * `smudgePath` — one dab of a smudge brush: the outline under a round brush
+ * moved along the brush's motion, most at its center and not at all at its rim.
+ */
+
+/** Options for {@link smudgePath}. */
+interface SmudgePathOptions {
+    /** The brush's center before this dab's motion. */
+    center: Point;
+    /** How far the brush moved. */
+    delta: Point;
+    /** The brush's radius, in the path's units. */
+    radius: number;
+    /** How much of `delta` a point under the brush's center moves: `1` all of it. Default 1. */
+    strength?: number;
+    /**
+     * The longest a segment under the brush may be before an anchor is added at its
+     * middle, in the path's units, so the brush has points to move where it needs
+     * them. Default a third of `radius`; `Infinity` adds none.
+     */
+    detail?: number;
+}
+/**
+ * `path` with the outline under the brush pushed along `delta`. A point at distance
+ * `d` from `center` moves by `delta × strength × (1 − (d/radius)²)²`, and an anchor's
+ * handles move with it, so a smooth anchor stays smooth. First, every segment that
+ * passes under the brush and is longer than `detail` is split at its middle until it
+ * is not, so a long straight edge bends where the brush meets it. Returns `path`
+ * itself when nothing is under the brush.
+ */
+declare function smudgePath(path: PolygonPath, opts: SmudgePathOptions): PolygonPath;
+
 /**
  * Collapse the handles of the anchors at `flatIndexes` onto their anchors,
  * leaving sharp corners. A segment whose ends both lose their handles turns
@@ -1507,17 +2139,165 @@ declare function makeHandlesSymmetric(set: AnchorSet, flatIndexes: Iterable<numb
  * keep and follows `to` freely.
  */
 declare function handleAlongItsAngle(anchor: Point, handle: Point, to: Point): Point;
+/**
+ * Where a handle lands when dragged toward `to` but held to its current
+ * length from `anchor`: on the circle of that length, aimed at `to`. A `to`
+ * on the anchor itself gives no direction, and leaves the handle where it is.
+ */
+declare function handleAtItsLength(anchor: Point, handle: Point, to: Point): Point;
+
+/**
+ * Soft selection over an anchor set: how strongly an edit to some anchors
+ * carries to the anchors near them, by distance measured along the path.
+ *
+ * Distance is arc length along the drawn curve, not a straight line, so two
+ * anchors that sit close across a gap in a shape are as far apart as the
+ * path between them. A `scale` measures it in screen pixels under a view's
+ * zoom, per axis.
+ */
+
+/** How influence fades from 1 at a selected anchor to 0 at the radius:
+ *  `smooth` eases out and in, `linear` falls evenly, `sharp` drops fast and
+ *  tails off. */
+type SoftFalloff = 'smooth' | 'linear' | 'sharp';
+/**
+ * The weight `falloff` gives a point `distance` from the selection, for a
+ * radius of `radius`: 1 at distance 0, 0 at the radius and beyond.
+ */
+declare function softFalloff(falloff: SoftFalloff, distance: number, radius: number): number;
+/** Arc length along one segment, sampled at evenly spaced curve parameters. */
+interface SegmentMeasure {
+    /** Arc length from the subpath's start to each sample; sample `i` is at
+     *  parameter `i / (lengths.length - 1)`. */
+    lengths: Float64Array;
+}
+/** Arc lengths along one subpath, as {@link measureAnchorPath} takes them. */
+interface AnchorSubpathMeasure {
+    closed: boolean;
+    /** Flat index of the subpath's first anchor. */
+    first: number;
+    /** Arc length from the subpath's start to each anchor. */
+    at: Float64Array;
+    /** Total length, the closing segment included on a closed subpath. */
+    length: number;
+    /** Segment `i` runs from anchor `i` to anchor `i + 1`, wrapping on a closed subpath. */
+    segments: SegmentMeasure[];
+}
+/** Arc lengths along every subpath of an anchor set, as
+ *  {@link measureAnchorPath} takes them. Read it with
+ *  {@link softSelectionWeights} and {@link softSelectionBand}. */
+interface AnchorPathMeasure {
+    readonly subpaths: readonly AnchorSubpathMeasure[];
+}
+/** Options for {@link measureAnchorPath}. */
+interface MeasureAnchorPathOptions {
+    /** Per-axis factor applied before measuring — a view's scale, to measure in
+     *  screen pixels. Default 1 on both axes. */
+    scale?: {
+        x: number;
+        y: number;
+    };
+    /** Samples taken along each curved segment. Default 24. */
+    samples?: number;
+}
+/** Measure the arc length along every subpath of `set`. */
+declare function measureAnchorPath(set: AnchorSet, opts?: MeasureAnchorPathOptions): AnchorPathMeasure;
+/**
+ * How much of an edit to the `selected` anchors each anchor receives: 1 for
+ * a selected anchor, the falloff of its distance along the path for one
+ * within `radius` of the nearest selected anchor on its subpath. Anchors
+ * that receive nothing are absent, as are anchors on a subpath with no
+ * selected anchor.
+ */
+declare function softSelectionWeights(measure: AnchorPathMeasure, selected: Iterable<number>, radius: number, falloff: SoftFalloff): Map<number, number>;
+/**
+ * The stretches of path within `radius` of the `selected` anchors, as world
+ * polylines drawn on `set`. `measure` is of the set the distances are taken
+ * on — the path as it was when the edit began — and `set` the geometry to
+ * draw on, which must have the same anchors. A stretch crossing the seam of a
+ * closed subpath comes back as one run.
+ */
+declare function softSelectionBand(measure: AnchorPathMeasure, set: AnchorSet, selected: Iterable<number>, radius: number): Point[][];
+
+/** A curved segment's balance line: from its first handle's tip to its
+ *  second's, with a grip at the middle. */
+interface HandleBalance {
+    sub: number;
+    segIdx: number;
+    /** Flat index of the anchor the segment starts at, which names the segment
+     *  the way an anchor's flat index names the anchor. */
+    flat: number;
+    /** Tip of the segment's first handle, the start anchor's out-handle. */
+    from: Point;
+    /** Tip of the segment's second handle, the end anchor's in-handle. */
+    to: Point;
+    /** Midway between the two tips. */
+    grip: Point;
+}
+/**
+ * The balance line of every curved segment in `set` that has both handles
+ * pulled off their anchors. Dragging a line's grip scales both handles
+ * together ({@link scaleSegmentHandles}), which fills the curve out toward
+ * its corner or flattens it toward its chord without turning either end.
+ */
+declare function handleBalances(set: AnchorSet): HandleBalance[];
+/**
+ * Scale both handles of segment `(sub, segIdx)` by `factor`, each along its
+ * own direction, so the segment keeps its end tangents. A smooth anchor at
+ * either end stays smooth: its other handle points the same way as before.
+ * `factor` below zero counts as zero, which retracts both handles.
+ *
+ * Under `syms`, as `anchorSymmetries` gives them, every image of either handle
+ * moves to the image of where that handle goes, the way `moveHandleSymmetric`
+ * moves a dragged handle's.
+ *
+ * Returns false when the segment has no balance line or nothing moved.
+ */
+declare function scaleSegmentHandles(set: AnchorSet, sub: number, segIdx: number, factor: number, syms?: readonly AnchorSymmetry[]): boolean;
+/**
+ * The factor {@link scaleSegmentHandles} takes to bring segment
+ * `(sub, segIdx)`'s grip as near `to` as scaling can: `to` projected onto the
+ * line the grip slides along as both handles grow. 1 when the segment has no
+ * balance line.
+ */
+declare function balanceFactorToward(set: AnchorSet, sub: number, segIdx: number, to: Point): number;
+/**
+ * Give both handles of segment `(sub, segIdx)` the same proportion: each
+ * reaches the same fraction of the way from its anchor to the corner where
+ * the two handle lines cross, that fraction being the mean of the two they
+ * had. Where the lines don't cross ahead of both handles, both take the mean
+ * length instead. Directions are kept either way.
+ *
+ * Returns false when the segment has no balance line or the handles already
+ * match.
+ */
+declare function equalizeSegmentHandles(set: AnchorSet, sub: number, segIdx: number): boolean;
+
+/**
+ * Make each smooth anchor at `flatIndexes` curvature-continuous: the curve
+ * bends as tightly just after the anchor as just before it, so it shows no
+ * kink in its curvature there. Only handle lengths change — each handle keeps
+ * its direction, so the anchor stays smooth and the tangent stays put — and
+ * the product of the two lengths is kept, so the anchor's pull on the curve
+ * stays about as strong.
+ *
+ * Absent `flatIndexes`, every anchor in the set. Moving one anchor's handles
+ * changes the curvature at its neighbors, so the fixes are repeated until
+ * they settle.
+ *
+ * Skipped, because lengths alone cannot do it: a corner, an anchor missing a
+ * handle, an end of an open subpath, and an anchor the curve bends opposite
+ * ways either side of, or straight through on one side.
+ *
+ * Returns false when nothing changed.
+ */
+declare function harmonizeAnchors(set: AnchorSet, flatIndexes?: Iterable<number>): boolean;
 
 /**
  * Where each point of an edited path came from, so an array kept per point (a skin's
  * weights) can follow an edit that inserts, deletes, or reorders points.
  */
 
-/** The anchor model `pathToAnchors` produces; `AnchorSet` in `anchorEdits`. */
-interface Anchors {
-    anchors: PenAnchor[][];
-    closed: boolean[];
-}
 /**
  * Where a point of an edited path came from: point `a` of the path before the edit, or for a
  * point the edit made, a blend `t` of the way from point `a` to point `b`.
@@ -1526,6 +2306,8 @@ interface PointOrigin {
     a: number;
     b: number;
     t: number;
+    /** On an anchor's own point: its subpath now runs the other way through it. */
+    reversed?: true;
 }
 /**
  * `editAnchorSet`, answering also where each point of the new path came from.
@@ -1536,7 +2318,7 @@ interface PointOrigin {
  * of it in its subpath, by its distance to each, or a copy of the one it has; its origin is
  * `null` when its subpath has none.
  */
-declare function editAnchorSetTracked(path: PolygonPath, edit: (set: Anchors) => boolean | void): {
+declare function editAnchorSetTracked(path: PolygonPath, edit: (set: AnchorSet) => boolean | void): {
     path: PolygonPath;
     origins: (PointOrigin | null)[];
 } | null;
@@ -1547,6 +2329,452 @@ declare function editAnchorSetTracked(path: PolygonPath, edit: (set: Anchors) =>
  */
 declare function remapPointValues(values: ArrayLike<number>, origins: readonly (PointOrigin | null)[]): number[];
 
+/**
+ * Arrays kept per anchor of a path — vertex colors, stroke widths — carried through an edit
+ * that `editAnchorSetTracked` reported.
+ */
+
+/**
+ * Where each anchor of `after` came from, in anchors of `before` as `countPathAnchors` counts
+ * them, given the point `origins` `editAnchorSetTracked` answered for the edit: anchor `a`, or
+ * for an anchor the edit made, a blend `t` of the way from `a` to `b`. `reversed` marks an
+ * anchor whose subpath now runs the other way through it. Null for an anchor with no origin.
+ */
+declare function anchorOriginsOf(before: PolygonPath, after: PolygonPath, origins: readonly (PointOrigin | null)[]): (PointOrigin | null)[];
+/**
+ * An array kept per anchor of a path, `stride` numbers each — four color channels, say —
+ * carried through an edit from `before` to `after`, with `origins` as
+ * `editAnchorSetTracked` answered. An anchor the edit kept keeps its numbers; one it
+ * made blends those of the anchors it came between. An anchor with no origin reads 0. Anchors
+ * are counted as `countPathAnchors` counts them.
+ */
+declare function remapAnchorValues(values: ArrayLike<number>, stride: number, before: PolygonPath, after: PolygonPath, origins: readonly (PointOrigin | null)[]): number[];
+
+/**
+ * Geometric constraints on a path's anchors. Each names anchors by flat index,
+ * the walk-order numbering `enumerateAnchors` and `anchorAt` use, and is plain
+ * JSON, so a list of them can be kept in scene data and saved with it.
+ */
+/** Two anchors by flat index: the straight line from the first to the second. */
+type AnchorPair = readonly [number, number];
+/**
+ * One constraint. `fixed` holds an anchor where it was before an edit, so it
+ * moves with its node but not with any edit of the path. `horizontal` and
+ * `vertical` read the axes of the frame the solve is given; `length` is in
+ * the path's own units. `tangent` keeps an anchor's two handles on one line
+ * through it, pointing apart (G1 continuity), their lengths free; it needs
+ * both handles. `onPath` holds an anchor on the path's segment from
+ * `segment[0]` to `segment[1]`, anywhere along it.
+ */
+type PathConstraint = {
+    readonly kind: 'fixed' | 'tangent';
+    readonly anchor: number;
+} | {
+    readonly kind: 'horizontal' | 'vertical';
+    readonly segment: AnchorPair;
+} | {
+    readonly kind: 'parallel' | 'perpendicular' | 'equalLength';
+    readonly segments: readonly [AnchorPair, AnchorPair];
+} | {
+    readonly kind: 'length';
+    readonly segment: AnchorPair;
+    readonly length: number;
+} | {
+    readonly kind: 'coincident';
+    readonly anchors: AnchorPair;
+} | {
+    readonly kind: 'onPath';
+    readonly anchor: number;
+    readonly segment: AnchorPair;
+};
+/** Every kind of {@link PathConstraint}. */
+type PathConstraintKind = PathConstraint['kind'];
+/** The anchors `c` reads, in the order it names them; an anchor named twice is listed twice. */
+declare function constraintAnchors(c: PathConstraint): number[];
+/**
+ * `c` with every anchor index passed through `to`, or null when `to` answers
+ * `undefined` for any of them — the anchor is gone, and so is the constraint.
+ */
+declare function mapConstraintAnchors(c: PathConstraint, to: (anchor: number) => number | undefined): PathConstraint | null;
+/** Whether every anchor `c` names is an index below `count`. */
+declare function constraintFits(c: PathConstraint, count: number): boolean;
+
+/**
+ * The points a constraint solve reads, and the coordinate vector it works in:
+ * anchors, then each anchor's handles as offsets from it (see `ResidualSpace`).
+ */
+
+/** An anchor the solver reads and writes, with its handles where it has them. */
+interface ConstraintPoint {
+    x: number;
+    y: number;
+    inHandle?: {
+        x: number;
+        y: number;
+    };
+    outHandle?: {
+        x: number;
+        y: number;
+    };
+}
+/** One handle of an anchor. */
+interface HandleRef {
+    anchor: number;
+    side: 'in' | 'out';
+}
+/**
+ * Whether `c` can be solved over `points`: every anchor it names exists, and
+ * a `tangent` anchor has both handles.
+ */
+declare function constraintApplies(c: PathConstraint, points: readonly ConstraintPoint[]): boolean;
+
+/**
+ * A damped Gauss-Newton solve for anchor constraints: from the state an edit
+ * left, the smallest weighted move of the anchors and handles that makes
+ * every residual zero. Each step is the minimum-norm solution of the
+ * linearized system, `Δ = -M Jᵀ (J M Jᵀ + λI)⁻¹ r`, where `M` weighs how
+ * freely each coordinate may move; λ grows when a step makes things worse and
+ * shrinks when it helps, which is the Levenberg-Marquardt schedule run on the
+ * constraint side.
+ *
+ * A handle is a coordinate of its own only where a `tangent` reads it; any
+ * other rides with its anchor, as an offset nothing changes.
+ */
+
+/** Options for {@link solveConstraints}. */
+interface SolveConstraintsOptions {
+    /** Anchors the edit put where they are — the dragged ones. They move only when no other anchor can satisfy the constraints. */
+    held?: Iterable<number>;
+    /** Handles the edit put where they are, held the way `held` holds anchors. */
+    heldHandles?: Iterable<HandleRef>;
+    /** Where each anchor was before the edit, which is where a `fixed` constraint keeps it. Default: where it is now. */
+    reference?: readonly (ConstraintPoint | undefined)[];
+    /** Radians the frame `horizontal` and `vertical` read is turned from the world's axes. Default 0. */
+    axisAngle?: number;
+    /** A frame per constraint, by index, over `axisAngle` — for constraints gathered from paths drawn in different frames. */
+    axisAngles?: readonly (number | undefined)[];
+    /** Indices of constraints to leave out of the solve — ones already known not to hold. */
+    skip?: Iterable<number>;
+    /** Default 100. */
+    maxIterations?: number;
+    /** The largest residual the solve stops at. Default 1e-7. */
+    tolerance?: number;
+}
+/** What {@link solveConstraints} answers. */
+interface SolveConstraintsResult {
+    /** Every anchor, moved, with its handles. */
+    points: ConstraintPoint[];
+    /** Whether every constraint the solve took holds within its tolerance. */
+    converged: boolean;
+    iterations: number;
+    /** Indices of the constraints that do not hold in `points`, skipped ones included. */
+    unsatisfied: number[];
+}
+/**
+ * Move `points` the least that makes `constraints` hold. Anchors named by a
+ * `fixed` constraint go back to `reference` and stay there; `held` anchors
+ * and `heldHandles` stay where they are when the rest can satisfy the
+ * constraints, and give way as little as they must when not. When the
+ * constraints cannot all hold, `converged` is false and `unsatisfied` names
+ * the ones that do not.
+ */
+declare function solveConstraints(points: readonly ConstraintPoint[], constraints: readonly PathConstraint[], opts?: SolveConstraintsOptions): SolveConstraintsResult;
+
+/**
+ * Whether constraints hold for a set of points, and whether a solve made them
+ * hold only by collapsing what they measure.
+ */
+
+/** The residual, in the path's units, under which a constraint counts as holding. */
+declare const CONSTRAINT_TOLERANCE = 0.001;
+/** Options for {@link unsatisfiedConstraints}. */
+interface UnsatisfiedConstraintsOptions {
+    axisAngle?: number;
+    /** A frame per constraint, by index, over `axisAngle`. */
+    axisAngles?: readonly (number | undefined)[];
+    /** Where a `fixed` anchor belongs. Absent, a `fixed` constraint always holds. */
+    reference?: readonly (ConstraintPoint | undefined)[];
+    /** Default {@link CONSTRAINT_TOLERANCE}. */
+    tolerance?: number;
+}
+/**
+ * Indices of the constraints that do not hold for `points`: a residual past
+ * the tolerance, an anchor index the points do not have, or a tangent on an
+ * anchor missing a handle.
+ */
+declare function unsatisfiedConstraints(points: readonly ConstraintPoint[], constraints: readonly PathConstraint[], opts?: UnsatisfiedConstraintsOptions): number[];
+
+/**
+ * Constraints on a `PolygonPath`: solving them over its anchors, and carrying
+ * them through an edit that renumbers the anchors.
+ */
+
+/** Every anchor of `path`, by flat index, with the handles it has. */
+declare function pathAnchorPoints(path: PolygonPath): ConstraintPoint[];
+/** {@link solveConstraints} over `path`'s anchors, and `path` with them moved. */
+interface SolvePathConstraintsResult extends SolveConstraintsResult {
+    /** `path` with each anchor moved where the solve put it, its handles moved with it; `path` itself when none moved. */
+    path: PolygonPath;
+}
+/**
+ * Solve `constraints` over the anchors of `path` and write the result back,
+ * carrying each moved anchor's handles with it so its curves keep their
+ * shape, except where a `tangent` turned them.
+ */
+declare function solvePathConstraints(path: PolygonPath, constraints: readonly PathConstraint[], opts?: SolveConstraintsOptions): SolvePathConstraintsResult;
+/**
+ * `path` with its anchors and handles where `to` puts them, given `from`,
+ * where they are now; `path` itself when nothing moved.
+ */
+declare function withAnchorPoints(path: PolygonPath, from: readonly ConstraintPoint[], to: readonly ConstraintPoint[]): PolygonPath;
+/**
+ * For each anchor of `after`, the anchor of `before` it is: the one whose
+ * point `origins` says it was copied from. An anchor the edit made has none.
+ * `origins` is what `editAnchorSetTracked` answered for the edit.
+ */
+declare function anchorsBefore(before: PolygonPath, after: PolygonPath, origins: readonly (PointOrigin | null)[]): (number | undefined)[];
+/**
+ * `constraints` renumbered for the anchors of a path after an edit, given
+ * `wasAnchor` — for each new anchor, the old one it is, as
+ * {@link anchorsBefore} answers. A constraint naming an anchor the edit
+ * removed is dropped; `from` holds each kept one's index in `constraints`.
+ */
+declare function remapConstraints(constraints: readonly PathConstraint[], wasAnchor: readonly (number | undefined)[]): {
+    constraints: PathConstraint[];
+    from: number[];
+};
+/**
+ * The segment of `path` joining anchors `a` and `b`, as the pair in the order
+ * the path runs it, or null when no segment joins them.
+ */
+declare function segmentBetween(path: PolygonPath, a: number, b: number): AnchorPair | null;
+
+/**
+ * Finishing an edit of constrained paths so their constraints hold: one path
+ * on its own, or several solved together when links — constraints naming
+ * anchors of more than one — tie them.
+ */
+
+/** Options for {@link constrainPathEdit}. */
+interface ConstrainPathEditOptions {
+    /**
+     * Where each point of the edited path came from, as `editAnchorSetTracked`
+     * answers. Absent, the edit is taken to keep every anchor's number, and one
+     * that changes the anchor count drops every constraint.
+     */
+    origins?: readonly (PointOrigin | null)[];
+    /** See {@link SolveConstraintsOptions.axisAngle}. */
+    axisAngle?: number;
+}
+/** What {@link constrainPathEdit} answers. */
+interface ConstrainedPathEdit {
+    /** The edited path with the constraints holding again. */
+    path: PolygonPath;
+    /** The constraints renumbered for `path`'s anchors. */
+    constraints: PathConstraint[];
+    /** Whether every constraint that held before the edit holds after it. */
+    converged: boolean;
+    /** Indices into `constraints` of the ones that do not hold, including any that already did not before the edit. */
+    unsatisfied: number[];
+}
+/** One path of a {@link constrainPathsEdit}: its edit, and its own constraints. */
+interface PathsEditItem extends ConstrainPathEditOptions {
+    before: PolygonPath;
+    /** `before` as the edit left it; `before` itself for a path the edit did not touch. */
+    after: PolygonPath;
+    constraints: readonly PathConstraint[];
+    /** For a path the edit left alone: its anchors give way as freely as any the edit did not move, rather than only when the edited paths cannot. */
+    yields?: boolean;
+}
+/**
+ * A constraint across paths. Its anchors are numbered over the anchors of
+ * `paths` — indices into the items — one after another in that order: with
+ * `paths: [2, 0]` and a 5-anchor item 2, anchor 6 is item 0's anchor 1. Its
+ * `horizontal` and `vertical` read the world's axes.
+ */
+interface PathLink {
+    constraint: PathConstraint;
+    paths: readonly number[];
+}
+/** What {@link constrainPathsEdit} answers. */
+interface ConstrainedPathsEdit {
+    /** Each item, in order: its path with the constraints holding, and its own constraints renumbered for it. */
+    items: {
+        path: PolygonPath;
+        constraints: PathConstraint[];
+        unsatisfied: number[];
+    }[];
+    /** Each link renumbered over its paths' anchors after the edit; null when the edit removed an anchor it names. */
+    links: {
+        constraint: PathConstraint | null;
+        satisfied: boolean;
+    }[];
+    /** Whether every constraint that held before the edit holds after it. */
+    converged: boolean;
+}
+/**
+ * An edit of constrained paths, finished so their constraints and the links
+ * between them hold, as one solve over every anchor: the anchors and handles
+ * the edit moved are held, and so are the anchors of a path it left alone
+ * (`after === before`), except one held on a segment or on a path that
+ * `yields`; `fixed` anchors go
+ * back to where they were, and the rest move the least they must. A constraint
+ * that did not hold before the edit is left out of the solve, and reported.
+ * Each item's own `horizontal` and `vertical` read its own `axisAngle`.
+ */
+declare function constrainPathsEdit(items: readonly PathsEditItem[], links?: readonly PathLink[]): ConstrainedPathsEdit;
+/**
+ * An edit of a constrained path, `before` → `after`, finished so its
+ * constraints hold: the anchors and handles the edit moved are held, `fixed`
+ * anchors go back to where they were, and the rest move the least they must.
+ * A constraint that did not hold before the edit conflicts with the others
+ * and is left out of the solve rather than allowed to pull them out of true;
+ * `unsatisfied` reports it.
+ */
+declare function constrainPathEdit(before: PolygonPath, after: PolygonPath, constraints: readonly PathConstraint[], opts?: ConstrainPathEditOptions): ConstrainedPathEdit;
+
+/**
+ * Which constraints conflict: not merely the ones a failed solve leaves
+ * unsatisfied, but a smallest set that cannot all hold together, found by a
+ * deletion filter — drop each member in turn, and keep it out when what is
+ * left still fails. Every member of the answer is needed for the conflict.
+ */
+
+/** Options for {@link conflictingConstraints}. */
+interface ConflictingConstraintsOptions {
+    /** Radians the frame `horizontal` and `vertical` read is turned from the world's axes. Default 0. */
+    axisAngle?: number;
+    /** A frame per constraint, by index, over `axisAngle`. */
+    axisAngles?: readonly (number | undefined)[];
+    /** Where each anchor belongs for a `fixed` constraint. Default: where it is now. */
+    reference?: readonly (ConstraintPoint | undefined)[];
+}
+/**
+ * The constraints of `constraints` that conflict over `points`: for every
+ * group of them sharing anchors that cannot all hold, a smallest subset that
+ * still cannot — each member needed, the later ones in the list kept in
+ * preference to the earlier — and every constraint that cannot apply at all.
+ * Sorted; empty when every constraint can hold at once.
+ */
+declare function conflictingConstraints(points: readonly ConstraintPoint[], constraints: readonly PathConstraint[], opts?: ConflictingConstraintsOptions): number[];
+
+/**
+ * Edits to a path's order rather than its shape: where a subpath starts, and
+ * which way it runs. Each mutates an `AnchorSet` in place, like the edits in
+ * `anchorEdits`, and moves anchors whole, so anything an anchor carries beside
+ * its point and handles travels with it.
+ */
+
+/**
+ * Make the anchor at `flatIndex` its subpath's first. A closed subpath turns
+ * so it starts there, keeping its direction. An open subpath can only start
+ * at one of its ends: its last anchor makes it run the other way, and an
+ * interior anchor changes nothing. Returns whether the set changed.
+ */
+declare function setSubpathStart(set: AnchorSet, flatIndex: number): boolean;
+/**
+ * Run each subpath in `subs` the other way, every one when `subs` is absent.
+ * The shape is unchanged: each anchor's handles trade places. A closed
+ * subpath keeps its start anchor, as `reversePath` does; an open one starts
+ * where it used to end. Returns whether any subpath had a segment to turn.
+ */
+declare function reverseSubpaths(set: AnchorSet, subs?: Iterable<number>): boolean;
+/**
+ * Where each anchor at `flatIndexes` sits once `reverseSubpaths(set, subs)`
+ * has run: an anchor keeps its point, so a selection can follow it. Indexes
+ * outside the set are dropped.
+ */
+declare function flatIndexesAfterReverse(set: AnchorSet, flatIndexes: Iterable<number>, subs?: Iterable<number>): number[];
+/** The subpaths holding the anchors at `flatIndexes`, each once, in order. */
+declare function subpathsOfAnchors(set: AnchorSet, flatIndexes: Iterable<number>): number[];
+/** A mark showing which way a path runs: a point on it and the unit vector of its heading there. */
+interface DirectionMark {
+    x: number;
+    y: number;
+    dx: number;
+    dy: number;
+    /** The subpath the mark is on. */
+    sub: number;
+}
+/**
+ * One {@link DirectionMark} at the middle of every segment of `set`, closing
+ * segments included, in walk order. A segment with no length gets none.
+ */
+declare function directionMarks(set: AnchorSet): DirectionMark[];
+
+/**
+ * Straight and curved segments, converted in place. A segment runs from one
+ * anchor to the next, the closing segment of a closed subpath included, and is
+ * named `(sub, segIdx)` as `segmentAt` reports it.
+ */
+
+/** A segment of an `AnchorSet`: `segIdx === sub.length - 1` is a closed
+ *  subpath's closing segment. */
+interface SegmentRef {
+    sub: number;
+    segIdx: number;
+}
+/** What a segment is made: a line, a curve, or the other of what it is. */
+type SegmentType = 'line' | 'curve';
+/**
+ * The segments both of whose ends are among `flatIndexes`, in walk order.
+ * Two adjacent selected anchors select the segment between them; a closed
+ * subpath with every anchor selected has all its segments.
+ */
+declare function segmentsBetweenAnchors(set: AnchorSet, flatIndexes: Iterable<number>): SegmentRef[];
+/** Whether segment `seg` is straight, or null when it does not exist. */
+declare function isSegmentStraight(set: AnchorSet, seg: SegmentRef): boolean | null;
+/**
+ * Make each segment in `segs` straight or curved without moving its anchors.
+ * A line becomes a curve with its handles a third of the way in from each
+ * end, which draws the same line; a curve becomes a line by dropping the two
+ * handles that shape it, leaving the handles of the segments beside it alone.
+ * With no `to`, every segment turns curved when any of them is straight, and
+ * straight when all are curved: one press flips the lot.
+ *
+ * Returns whether any segment changed.
+ */
+declare function convertSegments(set: AnchorSet, segs: readonly SegmentRef[], to?: SegmentType): boolean;
+
+/**
+ * Anchors as numbers a person types: the position of the selected anchors,
+ * and for a lone anchor its handles' positions, angles and lengths. Reading
+ * answers what a field shows; writing sets a value on every selected anchor,
+ * or offsets each by an amount.
+ */
+
+/** One number of an anchor. Handle angles are degrees counterclockwise from
+ *  +x as drawn, where y grows downward; lengths and positions are in the
+ *  set's own units. */
+type AnchorField = 'x' | 'y' | 'inX' | 'inY' | 'inAngle' | 'inLength' | 'outX' | 'outY' | 'outAngle' | 'outLength';
+/** Every {@link AnchorField}, in the order a panel lists them. */
+declare const ANCHOR_FIELDS: readonly AnchorField[];
+/** What a typed field asks for: a value for every anchor, or an amount added to each one's own. */
+type NumberEntry = {
+    to: number;
+} | {
+    by: number;
+};
+/**
+ * What each field shows for the anchors at `flatIndexes`: a number where
+ * they agree, `null` where they differ, and no key for a field that does not
+ * apply. Position applies to any selection; handle fields only to a single
+ * anchor, and only for a handle it has.
+ */
+type AnchorFieldValues = Partial<Record<AnchorField, number | null>>;
+/** The fields for the anchors at `flatIndexes`; `{}` when none of them exists. */
+declare function readAnchorFields(set: AnchorSet, flatIndexes: Iterable<number>): AnchorFieldValues;
+/**
+ * Write `entry` into `field` of every anchor at `flatIndexes`. Moving an
+ * anchor carries its handles. A handle field moves the handle as a drag to
+ * the typed spot would (`moveHandleTo`): on a smooth anchor the opposite
+ * handle mirrors it, taking its turn and its length, and on a corner it stays
+ * where it is. An anchor without that handle is skipped. An angle keeps the
+ * handle's length, and a length keeps its angle. Returns whether anything
+ * moved.
+ */
+declare function writeAnchorField(set: AnchorSet, flatIndexes: Iterable<number>, field: AnchorField, entry: NumberEntry): boolean;
+
 /**
  * Anchor lookup across several paths, measured on screen: which existing
  * anchor is nearest a point, and whether it ends an open subpath. Feeds the
@@ -1671,4 +2899,4 @@ declare function reviveTypedArrays(value: unknown): unknown;
 /** `tagTypedArrays` as a `JSON.stringify` replacer. */
 declare function typedArrayReplacer(_key: string, value: unknown): unknown;
 
-export { type Affine, type AnchorRect, type AnchorSet, type AnchorSymmetry, type AverageAxis, type BendGrip, type BezierEasing, type Box, type CubicCoords, type CurveNearest, DEFAULT_FLATTEN_TOLERANCE, EASINGS, EPS, type EasingFn, type EasingName, type EasingSpec, type GlMat3, type LineCoords, type NumberTypedArray, PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, Path, type PathAnchorHit, PathBuilder, type PathCommandCode, type PathCommandName, PathFillRule, type PathInWorldPose, type PathNearest, PathOpenFill, type PathStation, type PenAnchor, type PlaceRectOptions, type PlacedRect, type Placement, type PlacementAlign, type PlacementSide, Point$1 as Point, type PointAlongPathOptions, type PointInPathOptions, type PointOrigin, type PolygonIntersectsPathOptions, PolygonPath, type PoseLinear, type PoseRotation, type QuadraticCoords, type Rect, RectPath, SPRING_PRESETS, type Scale2, type SegmentHit, type SimplifyPathOptions, type SpringPreset, type SpringPresetName, type StrokeHitTestOptions, type SubpathEnd, TYPED_ARRAY_CONSTRUCTORS, type TaggedTypedArray, type TypedArrayTag, type View, ZOOM_FLOOR, anchorAt, anchorCount, anchorSymmetries, anchorSymmetry, anchorsInRect, anchorsToPath, applyToPoint, approxEq, averageAnchorsAt, bendSegment, boundsOfCoords, boundsOfPath, boxContainsBox, boxContainsPoint, boxToBox, circlePath, clamp, clampRectWithin, closestOpenEnds, composePath, countPathAnchors, cross, cubicBezierEasing, cubicBounds, cubicEvalAt, decomposePath, defaultOpenFill, deleteAnchorsAt, dot, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorSet, editAnchorSetTracked, elevateQuadraticToCubic, ellipsePath, fillsOpenSubpaths, fitCubicThroughDeletion, fitCubicWithTangents, flatAnchorIndex, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, forEachSegment, handleAlongItsAngle, hasOpenSubpath, identity$1 as identity, insertAnchorOnSegment, invert$1 as invert, isAnchorSmooth, isStraightSegment, joinAnchorsAt, joinSubpathEnds, len2, linePath, linear, locateAnchor, makeHandlesSymmetric, mat3, meanScale, moveHandleSymmetric, moveHandleTo, multiply$1 as multiply, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, nearestPathAnchor, nearestSegmentT, normalizeZoom, openSubpathAt, pathCommandCoordCount, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSignedArea, pathThroughPoseFrame, pathToAnchors, placeRect, pointAlongPath, pointInPath, pointInPolygon, pointSegmentDist2, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls, portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, pxExtent, quadraticEvalAt, rectMarkerPath, rectPath, rectToContour, regularPolygonPath, remapPointValues, resolveEasing, retractHandles, reverseAnchors, reversePath, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roundRectPath, scale, scaleDelta, scalePathToBounds, schneiderFit, screenAngleOf, segmentAt, segmentEnds, segmentsCross, setDefaultOpenFill, sign, simplifyPath, splitByClosure, splitCubicAt, splitLineAt, splitQuadraticAt, splitSubpaths, squarePath, standoff, starPath, strokeHitTest, sub, subpathEndAt, tagTypedArray, tagTypedArrays, transformCoords, transformPath, translate, translateAnchorBy, translateAnchorsSymmetric, translatePath, typedArrayReplacer, unionBoundsPath, unionBox, untagTypedArray, viewToMat3, withinPxBox, withinPxRadius, worldEditToStorage };
+export { ANCHOR_FIELDS, type Affine, type AnchorField, type AnchorFieldValues, type AnchorPair, type AnchorPathMeasure, AnchorSet, type AnchorSubpathMeasure, type AnchorSymmetry, type AverageAxis, type BendAlongPathOptions, type BendGrip, type BezierEasing, type BlendPathsOptions, type Box, CONSTRAINT_TOLERANCE, CORNER_RESTORE_TOLERANCE, type ConflictingConstraintsOptions, type ConstrainPathEditOptions, type ConstrainedPathEdit, type ConstrainedPathsEdit, type ConstraintPoint, type CornerCut, type CornerFrame, CornerPiece, CornerSpec, type CornerTrace, type CubicContour, type CubicCoords, type CubicSegment, type CurveNearest, DEFAULT_FLATTEN_TOLERANCE, type DirectionMark, EASINGS, EPS, type EasingFn, type EasingName, type EasingSpec, type ExtendToMeetOptions, type FramedBox, type GlMat3, type GrowRegionOptions, type HandleBalance, type HandleRef, type JoinOptions, type LengthenMode, type LineCoords, type MeasureAnchorPathOptions, type MeasurePathOptions, type MergeRegionOptions, type NumberEntry, type NumberTypedArray, type OpenPathEnd, PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_SNAP_KINDS, PATH_Z, Path, type PathAnchorHit, type PathAwayFromAnchors, type PathBlend, PathBuilder, type PathCommandCode, type PathCommandName, type PathConstraint, type PathConstraintKind, type PathCrossing, type PathEndFrame, PathFillRule, type PathInWorldPose, type PathLink, type PathMeasure, type PathNearest, type PathNearestStation, PathOpenFill, type PathSegment, type PathSnapHit, type PathSnapIndex, type PathSnapKind, type PathSnapQuery, type PathSnapTarget, type PathStation, type PathStop, type PathsEditItem, PenAnchor, type PlaceRectOptions, type PlacedRect, type Placement, type PlacementAlign, type PlacementSide, Point, type PointAlongPathOptions, type PointInPathOptions, type PointOrigin, type PolygonIntersectsPathOptions, PolygonPath, type PoseLinear, type PoseRotation, type QuadraticCoords, type Rect, RectPath, type RepeatAlongPathOptions, type RepeatStation, type ResamplePathOptions, type ResolvedCorners, SPRING_PRESETS, Scale2, type SegmentCrossing, type SegmentMeasure, type SegmentRef, type SegmentType, type SimplifyPathOptions, type SmudgePathOptions, type SoftFalloff, type SolveConstraintsOptions, type SolveConstraintsResult, type SolvePathConstraintsResult, type SpiroContour, SpiroKind, type SpiroPath, SpiroPoint, type SpiroToPathOptions, type SpringPreset, type SpringPresetName, type StaticPathSnapKind, type StrokeHitTestOptions, type SubpathEnd, TYPED_ARRAY_CONSTRUCTORS, type TaggedTypedArray, type TrimPathOptions, type TrimResult, type TypedArrayTag, type UnsatisfiedConstraintsOptions, type View, ZOOM_FLOOR, addExtremaAnchors, anchorOriginsOf, anchorSymmetries, anchorSymmetry, anchorsBefore, anchorsUnderBrush, anchorsWhere, applyToPoint, approxEq, asPolygonPath, averageAnchorsAt, balanceFactorToward, bendAlongPath, bendSegment, blendPaths, boundsOfCoords, boundsOfPath, boxContainsBox, boxContainsPoint, boxToBox, circlePath, clamp, clampRectWithin, closestOpenEnds, composePath, conflictingConstraints, constrainPathEdit, constrainPathsEdit, constraintAnchors, constraintApplies, constraintFits, convertSegments, cornerAnchors, cornerCuts, cornerFrameAt, cornerFrames, cornerTraces, createPathSnapIndex, cross, cubicAxisExtremaTs, cubicBezierEasing, cubicBounds, cubicContoursToPath, cubicEvalAt, decomposePath, defaultOpenFill, directionMarks, dot, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorSetTracked, elevateQuadraticToCubic, ellipsePath, equalizeSegmentHandles, everyNthAnchor, extendToMeet, fillsOpenSubpaths, findPathSnap, findPathSnaps, fitAffine, fitCubicThroughDeletion, fitCubicWithTangents, flatIndexesAfterReverse, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, forEachSegment, growAnchorSelection, growRegion, handleAlongItsAngle, handleAtItsLength, handleBalances, harmonizeAnchors, hasOpenSubpath, identity$1 as identity, intersectSegments, invert$1 as invert, invertAnchorSelection, isSegmentStraight, joinAnchorsAt, joinSubpathEnds, keepCorners, len2, lengthToward, lengthenOpenEnd, lengthenPathEnd, linePath, linear, makeHandlesSymmetric, mapConstraintAnchors, mat3, meanScale, measureAnchorPath, measurePath, mergeRegion, moveHandleSymmetric, multiply$1 as multiply, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, nearestPathAnchor, normalizeZoom, offsetCornerTraces, openEndAt, openEndRay, openPathEnds, pathAnchorPoints, pathAwayFromAnchors, pathCommandCoordCount, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathCrossings, pathDistanceToPoint, pathEndAnchorIndex, pathEndFrame, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSegments, pathSignedArea, pathThroughPoseFrame, pathToCubicContours, pathToD, placeRect, pointAlongPath, pointInPath, pointInPolygon, pointSegmentDist2, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls, portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, prepareBlend, quadraticEvalAt, readAnchorFields, rectMarkerPath, rectPath, rectToContour, regularPolygonPath, remapAnchorValues, remapConstraints, remapPerAnchor, remapPointValues, repeatAlongPath, resamplePath, resolveCorners, resolveCornersWithSources, resolveEasing, restoreCorners, retractHandles, reverseAnchors, reversePath, reverseSubpaths, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roundRectPath, scale, scalePathToBounds, scaleSegmentHandles, schneiderFit, segmentBetween, segmentExtremaTs, segmentsBetweenAnchors, segmentsCross, setDefaultOpenFill, setSubpathStart, shrinkAnchorSelection, sign, simplifyAnchorsAt, simplifyPath, simplifySpan, simplifySubpath, smoothAnchors, smudgePath, softFalloff, softSelectionBand, softSelectionWeights, solveConstraints, solvePathConstraints, spiroContoursFromControl, spiroContoursOf, spiroControlPath, spiroToPath, splitByClosure, splitCubicAt, splitLineAt, splitQuadraticAt, splitSubpaths, squarePath, starPath, stationsAlongPath, strokeHitTest, sub, subpathEndAt, subpathsOfAnchors, tagTypedArray, tagTypedArrays, transformCoords, transformPath, translate, translateAnchorsSymmetric, translatePath, trimPathAt, typedArrayReplacer, unionBoundsPath, unionBox, unsatisfiedConstraints, untagTypedArray, viewToMat3, withAnchorPoints, worldEditToStorage, writeAnchorField };