@weasel-js/geom 1.9.4 → 1.10.1

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { a as PolygonPath, b as PathFillRule, R as RectPath, P as Path } from './path-D0CoudGM.js';
-import { P as Point } from './cubicMath-CpCvuEl8.js';
-export { c as cubicPointAt, f as fitCubicThroughDeletion, s as splitCubicAtT } from './cubicMath-CpCvuEl8.js';
+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';
 
 /**
@@ -8,8 +8,7 @@ export { PORT_REACH } from './nd/index.js';
  *
  * Points are scalar pairs (px, py); there is no point struct. All math is
  * f64 (JS-native). Epsilons are f32-SCALE and magnitude-relative, because
- * stored coords are quantized to Float32 (~7 significant digits) — see the
- * geometry-kernel spec.
+ * stored coords are quantized to Float32 (~7 significant digits).
  */
 /** Base relative epsilon, sized for Float32 storage (~1 part in 1e-6). */
 declare const EPS = 0.000001;
@@ -33,9 +32,8 @@ declare function sign(n: number): -1 | 0 | 1;
  *
  * The exception is a guard against an exact algebraic value that a formula
  * produces bit-for-bit: a homogeneous `w === 1`, a ray's `d === 0`. Those are
- * testing a branch, not comparing coordinates, and `geom/3d` has two of them
- * (`mat4.ts`, `ray3.ts`). Widening one to `approxEq` would change which branch
- * runs, not how precisely it runs.
+ * testing a branch, not comparing coordinates. Widening one to `approxEq`
+ * would change which branch runs, not how precisely it runs.
  */
 declare function approxEq(a: number, b: number, eps?: number): boolean;
 
@@ -72,28 +70,35 @@ declare const ZOOM_FLOOR = 1e-9;
 declare function normalizeZoom(zoom: number): number;
 
 /** `[a, b, c, d, e, f]`: `x' = a·x + c·y + e`, `y' = b·x + d·y + f`. */
-type Mat3 = readonly [number, number, number, number, number, number];
+type Affine = readonly [number, number, number, number, number, number];
 /** The transform that leaves a point where it is. */
-declare function identity(): Mat3;
+declare function identity$1(): Affine;
 /** A pure translation by `(tx, ty)`. */
-declare function translate(tx: number, ty: number): Mat3;
+declare function translate(tx: number, ty: number): Affine;
 /** A pure scale about the origin. Scale about another point by composing
  *  translate → scale → inverse translate with `multiply`. */
-declare function scale(sx: number, sy: number): Mat3;
+declare function scale(sx: number, sy: number): Affine;
 /** A pure rotation about the origin, in radians, clockwise in canvas
  *  coordinates (y down). */
-declare function rotate(rad: number): Mat3;
+declare function rotate(rad: number): Affine;
 /** Compose: result applies `n` first, then `m` (m·n). */
-declare function multiply(m: Mat3, n: Mat3): Mat3;
+declare function multiply$1(m: Affine, n: Affine): Affine;
 /** Inverse, or null when the matrix is singular, non-finite, or too
  *  ill-conditioned to invert meaningfully at its own scale. */
-declare function invert(m: Mat3): Mat3 | null;
+declare function invert$1(m: Affine): Affine | null;
 /** Apply to a point, returning a tuple. Cold-path use; hot loops inline. */
-declare function applyToPoint(m: Mat3, x: number, y: number): [number, number];
+declare function applyToPoint(m: Affine, x: number, y: number): [number, number];
 /** Affine that maps source box (sx,sy,sw,sh) onto destination box (dx,dy,dw,dh). */
-declare function boxToBox(sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): Mat3;
+declare function boxToBox(sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): Affine;
 /** Rotation by `rad` about pivot (cx,cy): translate(c)·rotate·translate(-c). */
-declare function rotateAboutPoint(cx: number, cy: number, rad: number): Mat3;
+declare function rotateAboutPoint(cx: number, cy: number, rad: number): Affine;
+/**
+ * Apply an affine to an interleaved coord stream, returning a fresh f64
+ * buffer. Command codes are unaffected — for a Bezier the transformed control
+ * points define the transformed curve exactly (affine invariance), so callers
+ * pass `path.coords` straight through and keep `path.commands` as-is.
+ */
+declare function transformCoords(coords: ArrayLike<number>, m: Affine): Float64Array;
 
 /** Axis-aligned box as [minX, minY, maxX, maxY]. */
 type Box = readonly [number, number, number, number];
@@ -122,12 +127,12 @@ declare function rectToContour(x: number, y: number, w: number, h: number): Floa
 
 /**
  * SVG-style command-stream encoding — the kit's single declaration of the path
- * opcodes. `Path` (`./path`) wraps this with `kind` + `fillRule`.
+ * opcodes.
  *
  * The codes index a `Uint8Array` command stream whose coords live in a
  * parallel float array, so a code declared anywhere but `PATH_COMMANDS` makes
  * every walker that doesn't know it misread the coord stream from that command
- * on — silently, for every path. Derive, never restate.
+ * on — silently, for every path.
  */
 /** Opcode table: command code and the float coords it consumes. */
 declare const PATH_COMMANDS: {
@@ -178,18 +183,15 @@ declare const PATH_CMD_LENGTHS: readonly number[];
 declare function pathCommandCoordCount(cmd: number): number;
 /**
  * Visit each command with its coord offset and the pen position BEFORE the
- * command consumes its coords (the segment start). The callback receives
- * (cmd, coordIndex, penX, penY, commandIndex) and stops the walk by returning
- * `false`. The pen advances to the command's last coord pair afterward; `Z`
- * returns it to the subpath's opening `M`, so a command following a `Z`
- * without an intervening `M` starts where SVG says it does.
+ * command consumes its coords (the segment start). The callback stops the
+ * walk by returning `false`. `Z` returns the pen to the subpath's opening `M`.
  *
- * Such a command opens a new subpath at the pen, as does a drawing command
- * no `M` precedes at all. The visitor is told with `opensSubpath`, and has to
- * start its contour at `(penX, penY)` then: there is no `M` to do it.
+ * A command following a `Z` without an intervening `M` opens a new subpath at
+ * the pen, as does a drawing command no `M` precedes at all. The visitor is
+ * told with `opensSubpath`, and has to start its contour at `(penX, penY)`
+ * then: there is no `M` to do it.
  *
- * A code `PATH_COMMANDS` does not declare throws once the visitor has seen it,
- * since the walker cannot tell how many coords it consumes.
+ * A code `PATH_COMMANDS` does not declare throws once the visitor has seen it.
  */
 declare function forEachSegment(commands: ArrayLike<number>, coords: ArrayLike<number>, visit: (cmd: number, coordIndex: number, penX: number, penY: number, commandIndex: number, opensSubpath: boolean) => void | boolean): void;
 
@@ -274,13 +276,10 @@ declare function portCurvePoints(ax: number, ay: number, bx: number, by: number,
 
 /**
  * Bezier flattening — subdivide cubic and quadratic segments into polyline
- * approximations within a flatness tolerance. Used by hit-testing and
- * (eventually) any kernel that doesn't want to special-case curves.
+ * approximations within a flatness tolerance.
  *
- * The flatness metric is the maximum perpendicular distance from any
- * control point to the chord between endpoints. When that distance falls
- * below `tolerance`, the segment is "flat enough" and emitted as a single
- * line segment.
+ * The flatness metric is the maximum distance from any control point to the
+ * chord between endpoints.
  *
  * Tolerance is in world units. 0.5 is a sensible default for screen-rate
  * rendering at 1× zoom; consumers that zoom in heavily should pass a
@@ -296,23 +295,18 @@ declare function flattenCubic(x0: number, y0: number, x1: number, y1: number, x2
 /** Recursively subdivide a quadratic bezier (P0, P1, P2). */
 declare function flattenQuadratic(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, tolerance: number, out: number[]): void;
 /**
- * Like `flattenCubic` but also appends, for each new flattened point, its
- * arc-length fraction `t` (relative to the polyline distance accumulated so
- * far inside this curve) to `arcOut`. Caller then post-processes the segment's
- * `arcOut` range by dividing each by the segment's total flattened arc length
- * to yield t ∈ (0, 1].
- *
- * The returned values are *cumulative distance from the segment start*, not
- * normalized fractions. Two-pass design (accumulate, then divide) keeps the
- * recursive splitter simple — it doesn't need to know the total length up
- * front.
+ * Like `flattenCubic` but also appends to `arcOut`, for each new flattened
+ * point, its *cumulative distance from the segment start* — not a normalized
+ * fraction. The caller divides each by the segment's total flattened arc
+ * length to yield t ∈ (0, 1]. `maxTurn`, in radians, also bounds how far each
+ * piece's control polygon may turn.
  */
-declare function flattenCubicWithArcLen(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, tolerance: number, out: number[], arcOut: number[]): number;
+declare function flattenCubicWithArcLen(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, tolerance: number, out: number[], arcOut: number[], maxTurn?: number): number;
 /** Flatten a quadratic bezier into line segments within `tolerance`, appending
  *  points to `out` and their cumulative arc lengths to `arcOut`. The arc
  *  lengths are what lets per-anchor color and dash phase be interpolated
  *  evenly along the curve rather than per segment. */
-declare function flattenQuadraticWithArcLen(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, tolerance: number, out: number[], arcOut: number[]): number;
+declare function flattenQuadraticWithArcLen(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, tolerance: number, out: number[], arcOut: number[], maxTurn?: number): number;
 
 /**
  * Even-odd ray-cast point-in-polygon over an interleaved, unclosed contour
@@ -333,6 +327,15 @@ declare function segmentsCross(ax: number, ay: number, bx: number, by: number, c
 /** Squared distance from (px,py) to segment (ax,ay)-(bx,by), endpoint-clamped. */
 declare function pointSegmentDist2(px: number, py: number, ax: number, ay: number, bx: number, by: number): number;
 
+/** Set whether a fill closes an open subpath, for every path that names no
+ *  `openFill` of its own. Starts at `'close'`. */
+declare function setDefaultOpenFill(rule: PathOpenFill): void;
+/** The rule a path with no `openFill` of its own follows. */
+declare function defaultOpenFill(): PathOpenFill;
+/** Whether `path`'s open subpaths fill, each closed by a straight edge back to
+ *  its start. What painting, area, and the filled-region hit tests all ask. */
+declare function fillsOpenSubpaths(path: PolygonPath): boolean;
+
 /**
  * Fluent builder for `PolygonPath`. Hides the `Uint8Array` / `Float32Array`
  * encoding behind move/line/curve/close calls and a final `build()`. Use
@@ -416,29 +419,10 @@ declare function linePath(a: {
 }): PolygonPath;
 
 /**
- * AABB bounds of a `Path`. Returned as `RectPath` for direct reuse with the
- * rect fast path machinery (selection AABB, area-select intersection).
- *
- * `RectPath` is its own bounds — O(1). For `PolygonPath`, walk segment by
- * segment, computing the tight bound per segment:
- *
- *   - `M` / `L`: just the endpoint.
- *   - `Q`: quadratic Bezier — endpoints plus axis-aligned extrema (one
- *     possible inflection per axis).
- *   - `C`: cubic Bezier — endpoints plus axis-aligned extrema (up to two
- *     possible inflections per axis, found via the quadratic formula on
- *     the derivative).
- *
- * Control points are NOT included directly; they're used only to compute
- * extrema that actually lie on the curve. This avoids the classic "AABB
- * extends past where the curve visibly reaches" bug for curved paths whose
- * control points poke outside the visible extent.
- *
- * Empty paths (no commands) return a zero-size rect anchored at the
- * origin — the convention used elsewhere in the kit for missing geometry.
+ * 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.
  */
-
-/** AABB of a `Path`, returned as a `RectPath` for direct reuse with rect-fast-path machinery. */
 declare function boundsOfPath(path: Path): RectPath;
 
 /**
@@ -476,19 +460,12 @@ declare function translatePath(path: Path, dx: number, dy: number): Path;
  */
 declare function scalePathToBounds(path: Path, target: RectPath): Path;
 
-/** Apply an affine `Mat3` to a path's geometry.
+/** Apply an `Affine` to a path's geometry. Never mutates the input.
  *
  * Axis-aligned maps (no rotation/shear: `m[1]` and `m[2]` within 1e-9 of 0) keep a
- * `RectPath` a rect — the four corners stay axis-aligned, so we transform the
- * two diagonal corners and normalize negative extent (mirror). Rotation or
- * shear promotes the rect's four corners to a `PolygonPath`. Polygon paths map
- * every coord via the kernel's `transformCoords`, preserving the command stream
- * and `fillRule`. Never mutates the input.
- *
- * `Mat3` here is the 6-tuple `number[]` from `@weasel-js/geom` (DOMMatrix order:
- * `[a, b, c, d, e, f]` where `x' = a·x + c·y + e`, `y' = b·x + d·y + f`),
- * not the renderer's 9-element `Float32Array`. */
-declare function transformPath(path: Path, m: Mat3): Path;
+ * `RectPath` a rect, normalizing negative extent (mirror). Rotation or
+ * shear promotes the rect's four corners to a `PolygonPath`. */
+declare function transformPath(path: Path, m: Affine): Path;
 
 /**
  * Translation-only compose/decompose for `Path` poses, the analog of
@@ -506,24 +483,24 @@ declare function composePath(parent: Path, child: Path): Path;
 /** Inverse of `composePath` — undo `parent`'s translation from a world pose. */
 declare function decomposePath(parent: Path, world: Path): Path;
 
-/**
- * Split a `PolygonPath` at each `M` command, returning one `PolygonPath` per
- * subpath. Inverse-ish of compound-path construction: a multi-region
- * (compound) path becomes N independent paths.
- *
- * `fillRule` is propagated unchanged to every output. Even-odd compound paths
- * with interior "holes" lose the hole semantics — each subpath becomes its
- * own filled region. (Same behavior as Illustrator's Release Compound Path.)
- *
- * If the input has zero `M` commands (which would already be malformed) the
- * input is returned wrapped in a single-element array. A path with exactly
- * one subpath is also returned as a single-element array — a trivial pass.
- */
-
 /** 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. */
+ *  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. */
 declare function splitSubpaths(path: PolygonPath): PolygonPath[];
 
+/** Whether any subpath of `path` lacks the `Z` that closes it. */
+declare function hasOpenSubpath(path: Path): boolean;
+/**
+ * `path` as two paths: the subpaths a `Z` closes, and those left open, each in
+ * the order `path` holds them and with its fill rules. A side with no subpaths
+ * is `null`. A fill that does not close an open subpath covers `closed` alone.
+ */
+declare function splitByClosure(path: PolygonPath): {
+    closed: PolygonPath | null;
+    open: PolygonPath | null;
+};
+
 /**
  * Contour orientation: which way a path winds, and the same path wound the
  * other way. Under `'nonzero'` two overlapping contours fill their overlap
@@ -535,7 +512,8 @@ declare function splitSubpaths(path: PolygonPath): PolygonPath[];
  * Signed area enclosed by `path`, summed over its contours. Positive for a
  * contour that turns clockwise on a y-down screen (the shoelace sign), so a
  * hole wound against its outer contour subtracts. An open contour counts as
- * closed by a straight edge back to its start, the way a fill closes it.
+ * closed by a straight edge back to its start where a fill closes it, and as
+ * nothing where one does not: see `fillsOpenSubpaths`.
  * Curved segments are integrated exactly, not through their control polygon.
  * A `RectPath` has no direction and counts as positive.
  */
@@ -551,25 +529,11 @@ declare function reversePath(path: PolygonPath): PolygonPath;
  * `pathFromD` — build a weasel `Path` from an **SVG path-data string** (the
  * value of SVG's `d` attribute, e.g. `"M0 0 L100 0 Z"`).
  *
- * This is the terse, declarative composition surface for geometry: a
- * consumer authors a shape as `d` and hands it straight to a scene/op API,
- * instead of chaining imperative builder calls. SVG `d` is deliberately the
- * language — it's a standard every consumer already knows, so the kit gets
- * path-language expressiveness without minting a new one. See
- * `docs/conventions.md` ("Compose scenes in a terse path language").
- *
  * Lowers every supported command (M/m L/l H/h V/v C/c S/s Q/q T/t A/a Z/z)
  * into weasel's `PathBuilder` primitives (move, line, cubic, quadratic,
- * close). Smooth (`S`/`s`/`T`/`t`) commands resolve their implicit reflected
- * control point from the previous cubic / quadratic. Arc commands (`A`/`a`)
- * convert to a series of cubic Bezier curves using the standard
- * endpoint-parameterization formulas (F.6.5 in the SVG spec): we reconstruct
- * the center, sweep angle, and a fixed number of (≤ 90°) cubic segments per
- * arc.
- *
- * No runtime dependency — a small hand-rolled parser. `@weasel-js/svg`'s
- * document parser (`parseSvg`) calls this for `<path d=…>` elements, so the
- * `d` grammar coverage is shared between the two entry points.
+ * close). Arc commands (`A`/`a`) convert to a series of cubic Bezier curves
+ * using the standard endpoint-parameterization formulas (F.6.5 in the SVG
+ * spec).
  */
 
 /**
@@ -593,9 +557,9 @@ declare function pathFromD(d: string, onWarn?: (message: string) => void): Retur
 
 /** The answer `pointAlongPath` gives: a point on the path and its heading there. */
 interface PathStation {
-    point: Point;
+    point: Point$1;
     /** Unit vector along the path at `point`, pointing toward the end. */
-    tangent: Point;
+    tangent: Point$1;
 }
 /** Options for `pointAlongPath`. */
 interface PointAlongPathOptions {
@@ -629,6 +593,102 @@ 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;
 
+/**
+ * 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.
+ */
+
+/** 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 {
+    x: number;
+    y: number;
+    inHandle?: {
+        x: number;
+        y: number;
+    };
+    outHandle?: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * 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[];
+};
+/**
+ * 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.
+ */
+declare function anchorsToPath(anchors: PenAnchor[][], closed: boolean[], like?: PolygonPath): PolygonPath;
+/**
+ * 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.
+ *
+ * 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[]): {
+    sub: number;
+    segIdx: number;
+    t: number;
+} | null;
+
+/**
+ * Controls for the one cubic that replaces `prev → removed → next` when
+ * `removed` is deleted. The new controls keep the directions the curve leaves
+ * `prev` and arrives at `next` with, and their lengths are least-squares fitted
+ * to samples of the two segments being replaced, so the curve keeps its shape
+ * as closely as one cubic can. Where `removed` was inserted by splitting a
+ * cubic, the original cubic comes back.
+ */
+declare function fitCubicThroughDeletion(prev: PenAnchor, removed: PenAnchor, next: PenAnchor): {
+    c1: Point$1;
+    c2: Point$1;
+};
+
 /**
  * Schneider (1990, Graphics Gems I) adaptive cubic-Bezier fitter.
  * Given a sequence of sample points, returns a `PolygonPath` whose `C`
@@ -638,7 +698,273 @@ declare function pathDistanceToPoint(path: Path, px: number, py: number): number
  * `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>, errorTolerance: number): PolygonPath;
+declare function schneiderFit(samples: ReadonlyArray<Point$1>, 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:
+ * `tStart` leaving the first sample, `tEnd` leaving the last one backward.
+ * Only the two handle lengths are solved for.
+ *
+ * `params` is the curve parameter each sample starts at, chord length when
+ * 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?: {
+    params?: ReadonlyArray<number>;
+    passes?: number;
+}): {
+    cp1: Point$1;
+    cp2: Point$1;
+};
+
+/** Options for {@link simplifyPath}. */
+interface SimplifyPathOptions {
+    /**
+     * An anchor whose path turns by more than this many degrees is a corner:
+     * it is kept, and the curve is refitted on either side of it. Default 40.
+     */
+    cornerAngle?: number;
+}
+/**
+ * `path` refitted with as few anchors as hold it within `tolerance`: every
+ * point sampled along the original lies within `tolerance` of the result.
+ * Corners (see {@link SimplifyPathOptions.cornerAngle}) and the ends of open
+ * subpaths stay where they are; the runs between them are refitted as smooth
+ * cubics, Schneider-style, and a run that lies within `tolerance` of a line
+ * becomes one straight segment. Fill rules carry over.
+ */
+declare function simplifyPath(path: PolygonPath, tolerance: number, opts?: SimplifyPathOptions): PolygonPath;
+
+/**
+ * Screen-pixel lengths in world units, per axis.
+ *
+ * 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;
+}
+/** 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;
+/**
+ * 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.
+ */
+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;
+
+/**
+ * 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.
+ */
+
+/** 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.
+ *
+ * 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.
+ */
+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;
+/**
+ * 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.
+ */
+declare function deleteAnchorsAt(set: AnchorSet, flatIndexes: Iterable<number>): boolean;
+/**
+ * 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.
+ */
+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[];
+
+/**
+ * Average and Join: anchor-set edits that bring anchors together. Both mutate
+ * the model `pathToAnchors` produces in place, like the edits in
+ * `anchorEdits`, and address anchors by flat index.
+ */
+
+/** Which coordinates {@link averageAnchorsAt} averages: `'x'` lines the
+ *  anchors up on one vertical, `'y'` on one horizontal, `'both'` stacks them
+ *  on one point. */
+type AverageAxis = 'x' | 'y' | 'both';
+/** One end of an open subpath. */
+interface SubpathEnd {
+    sub: number;
+    end: 'first' | 'last';
+}
+/**
+ * Move each anchor in `flatIndexes` to their mean position, along `axis`.
+ * Each anchor carries its handles with it. Returns false, changing nothing,
+ * when fewer than two of the indexes name anchors.
+ */
+declare function averageAnchorsAt(set: AnchorSet, flatIndexes: Iterable<number>, axis?: AverageAxis): boolean;
+/** The open-subpath end anchor `flatIndex` names, or null for an interior
+ *  anchor or one on a closed subpath. A lone anchor reads as `'last'`. */
+declare function subpathEndAt(set: AnchorSet, flatIndex: number): SubpathEnd | null;
+/**
+ * Join the two open-subpath ends `a` and `b`. The two ends of one subpath
+ * 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.
+ */
+declare function joinSubpathEnds(set: AnchorSet, a: SubpathEnd, b: SubpathEnd): 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;
+/**
+ * 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;
 
 /**
  * Path hit-testing: path-vs-point (filled region and stroke distance),
@@ -647,19 +973,22 @@ declare function schneiderFit(samples: ReadonlyArray<Point>, errorTolerance: num
  * A `rect` path short-circuits to AABB arithmetic. A `polygon` path is its
  * filled region: beziers are flattened, `fillRule` is honored (default
  * `nonzero`), and every closed subpath counts — the hole of a donut is not
- * part of the shape under `evenodd`. Open subpaths enclose no area, so the
- * filled-region tests ignore them.
+ * part of the shape under `evenodd`. An open subpath counts as closed where a
+ * fill closes it and encloses nothing where one does not: see
+ * `fillsOpenSubpaths`.
  */
 
-type XY = {
-    x: number;
-    y: number;
-};
 /** Options for the path hit-tests. */
 interface PointInPathOptions {
     /** Bezier flattening tolerance in world units. Default 0.5. */
     tolerance?: number;
 }
+/** Options for {@link polygonIntersectsPath}. */
+interface PolygonIntersectsPathOptions extends PointInPathOptions {
+    /** False when nothing paints the path's interior: only its outline can meet
+     *  the polygon, and a polygon lying wholly inside meets nothing. Default true. */
+    filled?: boolean;
+}
 /** Options for {@link strokeHitTest}. */
 interface StrokeHitTestOptions {
     /** Bezier flattening tolerance in world units. Default 0.5. */
@@ -671,7 +1000,7 @@ interface StrokeHitTestOptions {
      *  transform no world distance equals it. */
     slop?: {
         px: number;
-        transform: Mat3;
+        transform: Affine;
     };
 }
 /** Filled-region hit-test for a path. Rect short-circuits to AABB; polygons run ray-cast / winding per `fillRule`. */
@@ -691,30 +1020,132 @@ 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 XY[], opts?: PointInPathOptions): boolean;
+declare function pathContainsPolygon(path: Path, polygon: readonly Point$1[], opts?: PointInPathOptions): boolean;
 /** Returns true if `polygon` overlaps (intersects or is contained by) `path`. */
-declare function pathIntersectsPolygon(path: Path, polygon: readonly XY[], opts?: PointInPathOptions): boolean;
+declare function pathIntersectsPolygon(path: Path, polygon: readonly Point$1[], 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 XY[], path: Path, opts?: PointInPathOptions): boolean;
+declare function polygonContainsPath(polygon: readonly Point$1[], 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. Beziers are
+ * or the line of an open subpath, which encloses nothing. With `filled: false`
+ * a closed subpath is a line too. Beziers are
  * 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 XY[], path: Path, opts?: PointInPathOptions): boolean;
+declare function polygonIntersectsPath(polygon: readonly Point$1[], path: Path, opts?: PolygonIntersectsPathOptions): boolean;
 
 /**
- * Apply an affine to an interleaved coord stream, returning a fresh f64
- * buffer. Command codes are unaffected — for a Bezier the transformed control
- * points define the transformed curve exactly (affine invariance), so callers
- * pass `path.coords` straight through and keep `path.commands` as-is.
+ * Ergonomic builders for tiny shape paths used by chrome / overlays / markers.
+ * They all return `PolygonPath`.
+ *
+ * Not appropriate for *user-drawn* shapes (those have a pose and live in the
+ * scene).
+ */
+
+/**
+ * N-segment polygon approximation of a circle. Default 32 segments → max
+ * radial deviation of ≈0.005·r (≈0.05 px at r=10). Bump higher for large
+ * filled circles where the facets become visible.
+ */
+declare function circlePath(cx: number, cy: number, r: number, segments?: number): PolygonPath;
+/** Axis-aligned square centred at (cx, cy) with side length `size`. */
+declare function squarePath(cx: number, cy: number, size: number): PolygonPath;
+/** Axis-aligned rectangle. Top-left at (x, y), width/height as given. */
+declare function rectMarkerPath(x: number, y: number, width: number, height: number): PolygonPath;
+/**
+ * Axis-aligned rounded rectangle. Top-left at (x, y); `r` is clamped to half
+ * the shorter side. Each corner is `cornerSamples` line segments — the
+ * default 8 gives the same angular resolution as `circlePath`'s 32.
+ */
+declare function roundRectPath(x: number, y: number, width: number, height: number, r: number, cornerSamples?: number): PolygonPath;
+
+/**
+ * 2D affine matrix utilities. Column-major 9 elements, matching
+ * `WebGL2RenderingContext.uniformMatrix3fv` element order so an upload needs
+ * no transpose flag.
+ *
+ * Layout (column-major):
+ *   [m00, m10, 0,
+ *    m01, m11, 0,
+ *    tx,  ty,  1]
  */
-declare function transformCoords(coords: ArrayLike<number>, m: Mat3): Float64Array;
+
+/**
+ * A 2D affine transform as a column-major 9-element array, laid out as above.
+ *
+ * Every matrix the kit builds is a `Float64Array`: a view translation far
+ * from the origin at high zoom needs more than a float32's 24 bits to hold a
+ * fraction of a pixel. A `Float32Array` is accepted wherever one is read.
+ * `mat3.toUniform` makes the float32 copy a GL uniform upload wants.
+ */
+type GlMat3 = Float32Array | Float64Array;
+declare function identity(): GlMat3;
+declare function multiply(out: GlMat3, m: GlMat3): GlMat3;
+/** `m · T(tx, ty)`: composes onto `m`, where `@weasel-js/geom`'s `translate`
+ *  constructs a fresh matrix. */
+declare function translated(m: GlMat3, tx: number, ty: number): GlMat3;
+/** `m · S(sx, sy)`: composes onto `m`, where geom's `scale` constructs one. */
+declare function scaled(m: GlMat3, sx: number, sy: number): GlMat3;
+/** This layout read as the kernel's 6-element affine. The two carry the same
+ *  logical order, so the conversion is a repack and nothing else. */
+declare function toAffine(m: GlMat3): Affine;
+/** The kernel's affine in this layout. The inverse of {@link toAffine}. */
+declare function fromAffine(a: Affine): GlMat3;
+/** Inverse of an affine matrix, or `null` when `@weasel-js/geom`'s `invert`
+ *  finds it singular — the same rule, read through this layout. */
+declare function invert(m: GlMat3): GlMat3 | null;
+/** A float32 copy of `m`, for `uniformMatrix3fv` or a shader uniform value. */
+declare function toUniform(m: GlMat3): Float32Array;
+declare function apply(m: GlMat3, x: number, y: number): [number, number];
+/**
+ * Map screen pixel coords (0..width on X, 0..height on Y, top-left origin)
+ * into clip space (-1..1 on X, 1..-1 on Y — note Y flip so screen-down
+ * matches clip-down).
+ */
+declare function screenToClip(width: number, height: number): GlMat3;
+/**
+ * Uniform-equivalent scale factor: the square root of the absolute
+ * determinant of the linear part, i.e. the geometric mean of the two axis
+ * scales. Rotation-invariant. Under non-uniform scale it is between the two
+ * axes and exact on neither — the same compromise `meanScale` documents.
+ */
+declare function meanScaleOf(m: GlMat3): number;
+/** The least any direction is scaled by the linear part — its smaller singular
+ *  value. What a screen length is worth in world units, at most. */
+declare function minScaleOf(m: GlMat3): number;
+/** The renderer's 3x3 matrix operations, as one namespace. These work on the
+ *  9-element form the GL uniform upload wants — distinct from the 6-element
+ *  `Affine`, though the logical element order is the same. */
+declare const mat3: {
+    identity: typeof identity;
+    toAffine: typeof toAffine;
+    fromAffine: typeof fromAffine;
+    multiply: typeof multiply;
+    translated: typeof translated;
+    scaled: typeof scaled;
+    invert: typeof invert;
+    toUniform: typeof toUniform;
+    apply: typeof apply;
+    screenToClip: typeof screenToClip;
+    meanScaleOf: typeof meanScaleOf;
+    minScaleOf: typeof minScaleOf;
+};
+
+/**
+ * Build the world→screen transform matrix for a `View`.
+ * Use as the `transform` field of a `kind: 'group'` DrawCommand to wrap
+ * world-space content emitted from a layer `draw` implementation.
+ *
+ * Mapping: `screen = (world − {view.x, view.y}) × {view.scale.x, view.scale.y}`.
+ *
+ * Column-major layout (matches `mat3.identity()`):
+ * `[scale.x, 0, 0,  0, scale.y, 0,  -view.x*scale.x, -view.y*scale.y, 1]`.
+ */
+declare function viewToMat3(view: View): GlMat3;
 
 /** Which side of the anchor the overlay sits on. */
 type PlacementSide = 'top' | 'bottom' | 'left' | 'right';
@@ -907,4 +1338,337 @@ declare function cubicBezierEasing(x1: number, y1: number, x2: number, y2: numbe
 /** Resolve a spec to the function that shapes progress. `undefined` is linear. */
 declare function resolveEasing(spec?: EasingSpec): EasingFn;
 
-export { type BezierEasing, type Box, type CubicCoords, type CurveNearest, DEFAULT_FLATTEN_TOLERANCE, EASINGS, EPS, type EasingFn, type EasingName, type EasingSpec, type LineCoords, type Mat3, PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, Path, PathBuilder, type PathCommandCode, type PathCommandName, PathFillRule, type PathNearest, type PathStation, type PlaceRectOptions, type PlacedRect, type Placement, type PlacementAlign, type PlacementSide, Point, type PointAlongPathOptions, type PointInPathOptions, PolygonPath, type QuadraticCoords, type Rect, RectPath, SPRING_PRESETS, type SpringPreset, type SpringPresetName, type StrokeHitTestOptions, type View, ZOOM_FLOOR, applyToPoint, approxEq, boundsOfCoords, boundsOfPath, boxContainsBox, boxContainsPoint, boxToBox, clamp, clampRectWithin, composePath, cross, cubicBezierEasing, cubicBounds, cubicEvalAt, decomposePath, 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, elevateQuadraticToCubic, ellipsePath, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, forEachSegment, identity, invert, len2, linePath, linear, multiply, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, normalizeZoom, pathCommandCoordCount, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathFromD, pathIntersectsPolygon, pathIntersectsRect, pathSignedArea, placeRect, pointAlongPath, pointInPath, pointInPolygon, pointSegmentDist2, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls, portCurvePoints, quadraticEvalAt, rectPath, rectToContour, regularPolygonPath, resolveEasing, reversePath, rotate, rotateAboutPoint, scale, scalePathToBounds, schneiderFit, segmentsCross, sign, splitCubicAt, splitLineAt, splitQuadraticAt, splitSubpaths, starPath, strokeHitTest, sub, transformCoords, transformPath, translate, translatePath, unionBoundsPath, unionBox };
+/**
+ * Geometric mean of a per-axis scale's magnitudes, so a flipped (negative)
+ * axis counts by its size.
+ *
+ * **Not for hit-testing.** A screen-pixel length is not one world distance
+ * under non-uniform zoom, and collapsing it to a scalar makes a pickable
+ * region too generous on one axis and too mean on the other. Use `pxExtent`
+ * for a per-axis world length, or `withinPxBox` / `withinPxRadius` to compare
+ * in screen space directly. Nor for placing chrome or measuring a pick slop:
+ * `standoff` and `strokeHitTest`'s `slop` work on screen.
+ *
+ * What legitimately remains is a stroke width for a line that is not
+ * axis-aligned: the renderer resolves a `{ px }` width through this same
+ * mean, so a picker reading ink widths must too.
+ */
+declare function meanScale(s: {
+    x: number;
+    y: number;
+}): number;
+
+/** Pivot (`cx`, `cy`) and angle resolved from a pose's rotation convention. */
+interface PoseRotation {
+    cx: number;
+    cy: number;
+    rotation: number;
+}
+/**
+ * Resolve a pose's rotation transform, or `null` when the pose carries no
+ * effective rotation. Non-null requires a nonzero `rotation` **and** all four
+ * AABB fields (`x`, `y`, `width`, `height`) — the pivot is the unrotated AABB
+ * center.
+ */
+declare function poseRotationOf(pose: unknown): PoseRotation | null;
+/**
+ * Rotate every coordinate of `path` about `(cx, cy)` by `rotation` radians.
+ * A `rect` promotes to a four-corner polygon (axis-aligned rects can't encode
+ * rotation). Returns a fresh `PolygonPath`; never mutates the input.
+ */
+declare function rotatePathAround(path: Path, cx: number, cy: number, rotation: number): PolygonPath;
+
+/**
+ * The one composition of a box pose into the matrix that carries its own
+ * frame to its parent's: the rotation convention of `poseRotationOf`, and the
+ * pose's residual `transform` inside it. Painting, culling, silhouettes, and
+ * picking all read a pose through `poseFrameOf` so they agree on where the
+ * node is.
+ */
+
+/**
+ * The linear part of a box pose that its box, rotation, and flips cannot
+ * hold: a skew, or a scale that differs by axis. `[a, b, c, d]` in
+ * `Affine` order (`x' = a·x + c·y`, `y' = b·x + d·y`), applied about the
+ * box center to what the node draws in its unrotated box, before the
+ * rotation. Absent is the identity.
+ */
+type PoseLinear = readonly [a: number, b: number, c: number, d: number];
+/** `transform` when it changes anything, `null` for absent or the identity. */
+declare function poseLinearOf(pose: unknown): PoseLinear | null;
+/**
+ * The matrix taking a point in the pose's own unrotated box frame to where
+ * the node draws it: `rotate(rotation) · transform`, about the box center.
+ * `null` when the pose has neither, or is not a box, so a caller can skip
+ * the step.
+ */
+declare function poseFrameOf(pose: unknown): Affine | null;
+/**
+ * The inverse of {@link poseFrameOf}: where a parent-frame point falls in the
+ * pose's unrotated box frame. `null` when there is no frame to undo, or when
+ * the `transform` is singular and nothing maps back.
+ */
+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';
+/**
+ * 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
+ * its in-handle lands on that anchor's out-handle — a mirror reverses which
+ * way a path runs, a rotation does not. An anchor `m` fixes is its own
+ * partner.
+ */
+interface AnchorSymmetry {
+    readonly m: Affine;
+    readonly partners: readonly number[];
+    readonly flips: readonly boolean[];
+}
+/**
+ * The pairing that makes `set` its own image under `m`, or `null` when it is
+ * not one: every anchor, handles included, must land on a distinct anchor
+ * within `tolerance` on each axis.
+ */
+declare function anchorSymmetry(set: AnchorSet, m: Affine, tolerance?: number): AnchorSymmetry | null;
+/** Every transform in `group` that `set` is its own image under, paired. */
+declare function anchorSymmetries(set: AnchorSet, group: readonly Affine[], tolerance?: number): AnchorSymmetry[];
+/**
+ * Translate the anchors `flats` by `(dx, dy)` the way `translateAnchorBy`
+ * does, and every image of each under `syms` by the transformed delta, so a
+ * path that was its own image under each of them still is. `syms` should be
+ * the whole symmetry group less its identity, as `anchorSymmetries` gives it
+ * for a group; with a part of one, the anchors it fixes are only partly held.
+ * An anchor that is itself being dragged moves as dragged.
+ */
+declare function translateAnchorsSymmetric(set: AnchorSet, flats: readonly number[], dx: number, dy: number, syms: readonly AnchorSymmetry[]): boolean;
+/**
+ * Move one handle to `(toX, toY)` and every image of it under `syms` to the
+ * image of that point, so a path that was its own image under each of them
+ * still is. A handle a transform maps onto itself keeps to where that
+ * transform allows; one mapped onto its own anchor's opposite handle drives
+ * that handle.
+ *
+ * Otherwise a smooth anchor keeps the opposite handle opposite, as
+ * `moveHandleTo` does, unless `breakSmoothness`, and that handle's images
+ * 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;
+
+/** Where on a segment a bend is held, as `segmentAt` reports it. */
+interface BendGrip {
+    sub: number;
+    segIdx: number;
+    /** Curve parameter of the held point. */
+    t: number;
+}
+/**
+ * Bend one segment so the point held at `grip.t` moves by `(dx, dy)`, by
+ * moving its two control handles: each by an amount weighted toward the end it
+ * belongs to, together exactly enough to carry the held point along. A straight
+ * segment becomes a curve. Where an end anchor was smooth, its other handle
+ * turns to stay in line, keeping its length, so the neighboring segment bends
+ * with it rather than kinking.
+ *
+ * Returns false when the segment doesn't exist.
+ */
+declare function bendSegment(set: AnchorSet, grip: BendGrip, dx: number, dy: number): boolean;
+
+type Point = {
+    x: number;
+    y: number;
+};
+/**
+ * Collapse the handles of the anchors at `flatIndexes` onto their anchors,
+ * leaving sharp corners. A segment whose ends both lose their handles turns
+ * straight.
+ *
+ * Returns false when every handle was already on its anchor. A segment that
+ * stays curved because its far end keeps a handle still encodes a control at
+ * this end, so it decodes as a handle sitting on the anchor: retracted.
+ */
+declare function retractHandles(set: AnchorSet, flatIndexes: Iterable<number>): boolean;
+/**
+ * Give each anchor at `flatIndexes` two handles of equal length pointing in
+ * opposite directions, so the curve passes through it smoothly. The shared
+ * direction splits the difference between the two handles' own directions,
+ * and the shared length is their mean; an anchor with one handle mirrors it.
+ *
+ * Skipped: an anchor with no handles, and the ends of an open subpath, which
+ * have only one segment to shape. Returns false when nothing changed.
+ */
+declare function makeHandlesSymmetric(set: AnchorSet, flatIndexes: Iterable<number>): boolean;
+/**
+ * Where a handle lands when dragged toward `to` but held to its current
+ * direction from `anchor`: `to` projected onto that ray. The length never
+ * goes below zero, so the handle can shrink onto the anchor but not flip
+ * through it. A handle already sitting on its anchor has no direction to
+ * keep and follows `to` freely.
+ */
+declare function handleAlongItsAngle(anchor: Point, handle: Point, to: Point): Point;
+
+/**
+ * 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`.
+ */
+interface PointOrigin {
+    a: number;
+    b: number;
+    t: number;
+}
+/**
+ * `editAnchorSet`, answering also where each point of the new path came from.
+ *
+ * An anchor the edit kept, moved or not, keeps its points. One the edit put exactly where an
+ * anchor was takes that anchor's, each handle by where it is, so a subpath turned around
+ * keeps its weights. A handle an edit gave an anchor that had none takes the anchor's point. An anchor the edit made is a blend of the nearest kept anchors either side
+ * 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): {
+    path: PolygonPath;
+    origins: (PointOrigin | null)[];
+} | null;
+/**
+ * An array kept per point of a path, carried through an edit: `origins` is what
+ * {@link editAnchorSetTracked} answered. A point with no origin, and an origin past the
+ * array's end, read 0.
+ */
+declare function remapPointValues(values: ArrayLike<number>, origins: readonly (PointOrigin | null)[]): number[];
+
+/**
+ * Anchor lookup across several paths, measured on screen: which existing
+ * anchor is nearest a point, and whether it ends an open subpath. Feeds the
+ * pen's anchor snapping and its pick-up of an open path's endpoint.
+ */
+
+/** An existing anchor found near a point. */
+interface PathAnchorHit {
+    /** The id the path was supplied under. */
+    id: string;
+    /** Subpath index, then anchor index within that subpath. */
+    sub: number;
+    idx: number;
+    x: number;
+    y: number;
+    /** Which end of an open subpath this anchor is, or null when it is an
+     *  interior anchor or its subpath is closed. A lone anchor reads `'last'`. */
+    end: 'first' | 'last' | null;
+}
+/**
+ * The anchor nearest `point` within a screen-space circle of radius `px`,
+ * across every subpath of every path in `paths`. Paths and `point` share one
+ * world frame; `scale` is the view's, so the radius stays round under
+ * non-uniform zoom. `accept` narrows the candidates (endpoints only, say).
+ * Ties go to the earlier path, so pass paths front-to-back.
+ */
+declare function nearestPathAnchor(paths: Iterable<{
+    id: string;
+    path: PolygonPath;
+}>, point: {
+    x: number;
+    y: number;
+}, px: number, scale: Scale2, accept?: (hit: PathAnchorHit) => boolean): PathAnchorHit | null;
+/** Reverse a subpath's direction without changing its shape: the anchor
+ *  order flips and each anchor's in and out handles trade places. */
+declare function reverseAnchors<A extends PenAnchor>(anchors: readonly A[]): A[];
+
+/**
+ * Project a leaf path from its source frame into world coordinates given a
+ * `{x, y, width, height, rotation?}` pose.
+ *
+ * RectPaths can't carry rotation as-is (they're axis-aligned by definition);
+ * a non-zero `pose.rotation` on a rect promotes the result to a polygon so
+ * the four corners are baked into world coords.
+ */
+
+/** Subset of pose fields this helper consumes: `x/y/width/height` define an
+ *  AABB whose unrotated center is the rotation pivot. */
+interface PathInWorldPose {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation?: number;
+    transform?: PoseLinear;
+}
+/**
+ * Project a stored path into the pose's **local frame**: rebase its AABB onto
+ * the pose box. It does NOT apply `pose.rotation`; `pathInWorld` composes
+ * this with the rotation wrap.
+ *
+ * Rects rebase onto the pose's `width`/`height` because resize updates the pose,
+ * not the stored `RectPath` — so the live size lives on the pose.
+ */
+declare function pathInPoseFrame(path: Path, pose: PathInWorldPose): Path;
+/**
+ * Bake `pose` into `path`'s coordinates so the returned path is positioned
+ * in world space. Returns a fresh `Path` instance; never mutates inputs.
+ */
+declare function pathInWorld(path: Path, pose: PathInWorldPose): Path;
+/**
+ * Inverse of `pathInWorld` for a path in **world** space: the stored path
+ * in the pose's own frame plus the pose that draws it there. The pose's
+ * `rotation` and `transform` are preserved, and its AABB fields are fit to
+ * the result. The new box's center is placed where the old frame carries it,
+ * since the pivot moves with the box: `pathInWorld(result.path, result.pose)`
+ * reproduces `worldPath` whether or not its bounds changed.
+ */
+declare function worldEditToStorage<P extends PathInWorldPose>(pose: P, worldPath: PolygonPath): {
+    pose: P;
+    path: PolygonPath;
+};
+declare function worldEditToStorage<P extends PathInWorldPose>(pose: P, worldPath: Path): {
+    pose: P;
+    path: Path;
+};
+
+/** The constructor of each typed array of numbers, under the tag its type is written by. */
+declare const TYPED_ARRAY_CONSTRUCTORS: {
+    readonly i8: Int8ArrayConstructor;
+    readonly u8: Uint8ArrayConstructor;
+    readonly u8c: Uint8ClampedArrayConstructor;
+    readonly i16: Int16ArrayConstructor;
+    readonly u16: Uint16ArrayConstructor;
+    readonly i32: Int32ArrayConstructor;
+    readonly u32: Uint32ArrayConstructor;
+    readonly f32: Float32ArrayConstructor;
+    readonly f64: Float64ArrayConstructor;
+};
+/** The name a typed array's type is written under. */
+type TypedArrayTag = keyof typeof TYPED_ARRAY_CONSTRUCTORS;
+/** A typed array of numbers: what a `Path` keeps its commands and coords in. */
+type NumberTypedArray = InstanceType<(typeof TYPED_ARRAY_CONSTRUCTORS)[TypedArrayTag]>;
+/** A typed array as JSON holds it: its type's tag and its numbers. */
+interface TaggedTypedArray {
+    __ta: TypedArrayTag;
+    data: number[];
+}
+/** `value` as a tag and its numbers where it is a typed array of numbers, else `undefined`. */
+declare function tagTypedArray(value: unknown): TaggedTypedArray | undefined;
+/** The typed array a `TaggedTypedArray` describes, or `undefined` for anything else. */
+declare function untagTypedArray(value: unknown): NumberTypedArray | undefined;
+/**
+ * A copy of `value` that `JSON.stringify` writes whole: every typed array in it, at any
+ * depth of arrays and plain objects, becomes a `TaggedTypedArray`. A `Path` goes through it
+ * to be saved, and `reviveTypedArrays` reads it back.
+ */
+declare function tagTypedArrays(value: unknown): unknown;
+/** A copy of `value` with every `TaggedTypedArray` in it a typed array again: what
+ *  `JSON.parse` answered for something `tagTypedArrays` or `typedArrayReplacer` wrote. */
+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 };