curvy 2.0.0-alpha.13 → 2.0.0-alpha.15

package/dist/characteristic/index.mjs

@@ -1,2 +1,2 @@
-import { n as characteristic_exports } from "../shared/characteristic-BkEr-rr8.mjs";
+import { n as characteristic_exports } from "../shared/characteristic--7nC4Q_a.mjs";
 export { characteristic_exports as Characteristic };

package/dist/curve/cubic2d.d.ts

@@ -5,6 +5,7 @@ import type { Pipeable } from '../utils.ts';
 import type { CubicPolynomial } from '../polynomial/cubic.ts';
 import type { Decreasing, Increasing, Monotonic } from '../polynomial/traits.ts';
 import type * as Solution from '../solution/solution.ts';
+import type { Affine2d } from '../transform/affine2d.ts';
 import type { Vector2 } from '../vector/vector2.ts';
 import type { CubicCurve2dTypeId } from './cubic2d.internal.ts';
 export type { Monotonic, Increasing, Decreasing } from '../polynomial/traits.ts';
@@ -193,13 +194,79 @@ export declare const curvature: {
  * @since 2.0.0
  */
 export declare const boundingBox: (c: CubicCurve2d) => Interval2d<Closed, Closed>;
+/**
+ * Evaluates the curve at `t = 0` in closed form — `(c.x.c0, c.y.c0)`.
+ *
+ * @param c - The cubic curve.
+ * @returns The point at the start of the curve's parameter domain.
+ * @since 2.0.0
+ */
+export declare const startPoint: (c: CubicCurve2d) => Vector2;
+/**
+ * Evaluates the curve at `t = 1` in closed form — the sum of the per-axis
+ * monomial coefficients.
+ *
+ * @param c - The cubic curve.
+ * @returns The point at the end of the curve's parameter domain.
+ * @since 2.0.0
+ */
+export declare const endPoint: (c: CubicCurve2d) => Vector2;
+/**
+ * The tight `[min, max]` range of x over the curve's parameter domain `[0, 1]`,
+ * accounting for up to two interior extrema.
+ *
+ * @param c - The cubic curve.
+ * @returns The closed range of x over `[0, 1]`.
+ * @since 2.0.0
+ */
+export declare const xRange: (c: CubicCurve2d) => Closed;
+/**
+ * The tight `[min, max]` range of y over the curve's parameter domain `[0, 1]`,
+ * accounting for up to two interior extrema.
+ *
+ * @param c - The cubic curve.
+ * @returns The closed range of y over `[0, 1]`.
+ * @since 2.0.0
+ */
+export declare const yRange: (c: CubicCurve2d) => Closed;
+/**
+ * Renders the curve as a single SVG path-data drawing command — for a cubic
+ * curve, `C ctrl1X,ctrl1Y ctrl2X,ctrl2Y endX,endY`. Bernstein control points
+ * are recovered from the monomial coefficients in closed form. Does not
+ * include a leading `M`.
+ *
+ * @param c - The cubic curve.
+ * @returns The SVG drawing command for this segment, without a leading `M`.
+ * @since 2.0.0
+ */
+export declare const toPathDataSegment: (c: CubicCurve2d) => string;
+/**
+ * Type-narrowing predicate: refines the curve's x-axis trait to include
+ * `Monotonic` when the x polynomial is strictly monotonic on the unit
+ * interval `[0, 1]`. The y-axis trait is unchanged.
+ *
+ * @since 2.0.0
+ */
+export declare const isMonotonicX: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Monotonic, YT>;
+/** @since 2.0.0 */
+export declare const isIncreasingX: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Increasing, YT>;
+/** @since 2.0.0 */
+export declare const isDecreasingX: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Decreasing, YT>;
+/**
+ * Type-narrowing predicate: refines the curve's y-axis trait to include
+ * `Monotonic`. The x-axis trait is unchanged.
+ *
+ * @since 2.0.0
+ */
+export declare const isMonotonicY: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT, YT & Monotonic>;
+/** @since 2.0.0 */
+export declare const isIncreasingY: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT, YT & Increasing>;
+/** @since 2.0.0 */
+export declare const isDecreasingY: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT, YT & Decreasing>;
 /**
  * Type-narrowing predicate: refines both axes' traits to include `Monotonic`
  * when both x and y polynomials are monotonic over the unit interval `[0, 1]`.
  *
- * For checking only one axis, call the polynomial-level refiner directly:
- * `CubicPolynomial.isMonotonic(curve.x, Interval.unit)`.
- *
  * @since 2.0.0
  */
 export declare const isMonotonic: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Monotonic, YT & Monotonic>;
@@ -213,3 +280,25 @@ export declare const asMonotonic: <XT, YT>(c: CubicCurve2d<XT, YT>) => CubicCurv
 export declare const asIncreasing: <XT, YT>(c: CubicCurve2d<XT, YT>) => CubicCurve2d<XT & Increasing, YT & Increasing>;
 /** @since 2.0.0 */
 export declare const asDecreasing: <XT, YT>(c: CubicCurve2d<XT, YT>) => CubicCurve2d<XT & Decreasing, YT & Decreasing>;
+export declare const transform: {
+    /**
+     * Applies an `Affine2d` transform to a `CubicCurve2d`, returning a new
+     * curve whose image is the affine image of the original. Internally the
+     * transformation works directly on monomial coefficients — `c0` receives
+     * the full affine, `c1`/`c2`/`c3` receive only the linear part.
+     *
+     * @param c - The cubic curve.
+     * @param a - The affine transform.
+     * @returns The transformed cubic curve.
+     * @since 2.0.0
+     */
+    (c: CubicCurve2d, a: Affine2d): CubicCurve2d;
+    /**
+     * Applies an `Affine2d` transform to a `CubicCurve2d`.
+     *
+     * @param a - The affine transform.
+     * @returns A function that takes a `CubicCurve2d` and returns the transformed curve.
+     * @since 2.0.0
+     */
+    (a: Affine2d): (c: CubicCurve2d) => CubicCurve2d;
+};

package/dist/curve/curve2d.d.ts

@@ -0,0 +1,81 @@
+import type { Closed, Interval } from '../interval/interval.ts';
+import type { Interval2d } from '../interval/interval2d.ts';
+import type * as Solution from '../solution/solution.ts';
+import type { Affine2d } from '../transform/affine2d.ts';
+import type { Vector2 } from '../vector/vector2.ts';
+/**
+ * The minimal operation bundle a curve module must provide for the generic
+ * `Path2d` to be built over it. Each polynomial curve module
+ * (`LinearCurve2d`, `QuadraticCurve2d`, `CubicCurve2d`) exports an `Ops`
+ * instance which the corresponding path module passes to
+ * `Path2d.make(ops)` to derive its operation surface.
+ *
+ * The interface is intentionally small — anything that isn't shared
+ * structurally across curve degrees stays on the per-degree module.
+ *
+ * @since 2.0.0
+ */
+export interface Curve2dOps<C> {
+    /**
+     * Evaluate the curve at parameter `t ∈ [0, 1]`.
+     */
+    solve(c: C, t: number): Vector2;
+    /**
+     * Closed-form value at `t = 0`.
+     */
+    startPoint(c: C): Vector2;
+    /**
+     * Closed-form value at `t = 1`.
+     */
+    endPoint(c: C): Vector2;
+    /**
+     * Arc length over an interval of the curve's domain.
+     */
+    length(c: C, interval: Interval): number;
+    /**
+     * Axis-aligned bounding box over the unit interval `[0, 1]`.
+     */
+    boundingBox(c: C): Interval2d<Closed, Closed>;
+    /**
+     * Inverse solve for x. Path-level callers enforce single-valuedness via
+     * the path's `MonotonicX` brand, so the result is narrowed to `AtMostOne`.
+     */
+    solveAtX(c: C, x: number): Solution.AtMostOne<number>;
+    /**
+     * y-axis analog of {@link solveAtX}.
+     */
+    solveAtY(c: C, y: number): Solution.AtMostOne<number>;
+    /**
+     * SVG path-data drawing command for one segment (`L …`, `Q …`, `C …`),
+     * without a leading `M`. Move-insertion is decided by the path-level
+     * `toPathData` based on continuity with the previous segment.
+     */
+    toPathDataSegment(c: C): string;
+    /**
+     * Whether the curve's x is strictly increasing on `[0, 1]`.
+     */
+    isIncreasingX(c: C): boolean;
+    /**
+     * Whether the curve's x is strictly decreasing on `[0, 1]`.
+     */
+    isDecreasingX(c: C): boolean;
+    /**
+     * Whether the curve's y is strictly increasing on `[0, 1]`.
+     */
+    isIncreasingY(c: C): boolean;
+    /**
+     * Whether the curve's y is strictly decreasing on `[0, 1]`.
+     */
+    isDecreasingY(c: C): boolean;
+    /**
+     * Apply an affine transform to the curve, returning a new curve whose
+     * geometric image is the affine image of the original.
+     *
+     * For non-rational coefficient-form curves this is per-coefficient: the
+     * constant coefficient receives the full affine, and all higher-degree
+     * coefficients receive only the linear part. For rational curves the
+     * translation is folded into the numerator polynomials weighted by the
+     * denominator. Path-level callers route through this op per curve.
+     */
+    transform(c: C, a: Affine2d): C;
+}

package/dist/curve/index.mjs

@@ -1,2 +1,2 @@
-import { _ as quadratic2d_exports, i as rationalCubic2d_exports, s as cubic2d_exports, w as linear2d_exports } from "../shared/rationalCubic2d-CeHgpNht.mjs";
+import { i as rationalCubic2d_exports, m as quadratic2d_exports, s as cubic2d_exports, v as linear2d_exports } from "../shared/rationalCubic2d-gM7VeiiT.mjs";
 export { cubic2d_exports as CubicCurve2d, linear2d_exports as LinearCurve2d, quadratic2d_exports as QuadraticCurve2d, rationalCubic2d_exports as RationalCubicCurve2d };

package/dist/curve/linear2d.d.ts

@@ -5,6 +5,7 @@ import type { Pipeable } from '../utils.ts';
 import type { LinearPolynomial } from '../polynomial/linear.ts';
 import type { Decreasing, Increasing, Monotonic } from '../polynomial/traits.ts';
 import type * as Solution from '../solution/solution.ts';
+import type { Affine2d } from '../transform/affine2d.ts';
 import type { Vector2 } from '../vector/vector2.ts';
 import type { LinearCurve2dTypeId } from './linear2d.internal.ts';
 export type { Monotonic, Increasing, Decreasing } from '../polynomial/traits.ts';
@@ -121,6 +122,53 @@ export declare const length: {
  * @since 2.0.0
  */
 export declare const boundingBox: (c: LinearCurve2d) => Interval2d<Closed, Closed>;
+/**
+ * Evaluates the curve at `t = 0` in closed form — `(c.x.c0, c.y.c0)`.
+ *
+ * @param c - The linear curve.
+ * @returns The point at the start of the curve's parameter domain.
+ * @since 2.0.0
+ */
+export declare const startPoint: (c: LinearCurve2d) => Vector2;
+/**
+ * Evaluates the curve at `t = 1` in closed form — `(c.x.c0 + c.x.c1, c.y.c0 + c.y.c1)`.
+ *
+ * @param c - The linear curve.
+ * @returns The point at the end of the curve's parameter domain.
+ * @since 2.0.0
+ */
+export declare const endPoint: (c: LinearCurve2d) => Vector2;
+/**
+ * The tight `[min, max]` range of x over the curve's parameter domain `[0, 1]`.
+ * For a linear curve this is the closed interval bounded by the two endpoints'
+ * x coordinates.
+ *
+ * @param c - The linear curve.
+ * @returns The closed range of x over `[0, 1]`.
+ * @since 2.0.0
+ */
+export declare const xRange: (c: LinearCurve2d) => Closed;
+/**
+ * The tight `[min, max]` range of y over the curve's parameter domain `[0, 1]`.
+ * For a linear curve this is the closed interval bounded by the two endpoints'
+ * y coordinates.
+ *
+ * @param c - The linear curve.
+ * @returns The closed range of y over `[0, 1]`.
+ * @since 2.0.0
+ */
+export declare const yRange: (c: LinearCurve2d) => Closed;
+/**
+ * Renders the curve as a single SVG path-data drawing command — for a linear
+ * curve, `L endX,endY`. Does not include a leading `M`; callers (typically a
+ * path-level `toPathData`) decide whether to emit a move based on continuity
+ * with the previous segment.
+ *
+ * @param c - The linear curve.
+ * @returns The SVG drawing command for this segment, without a leading `M`.
+ * @since 2.0.0
+ */
+export declare const toPathDataSegment: (c: LinearCurve2d) => string;
 export declare const solveAtX: {
     /**
      * Evaluates the curve's y value at a given x. A linear curve crosses any
@@ -152,14 +200,54 @@ export declare const solveAtY: {
     /** @since 2.0.0 */
     (y: number): <XT, YT>(c: LinearCurve2d<XT, YT>) => Solution.AtMostOne<number>;
 };
+/**
+ * Type-narrowing predicate: refines the curve's x-axis trait to include
+ * `Monotonic` when the x polynomial is strictly monotonic. The y-axis trait
+ * is unchanged.
+ *
+ * @since 2.0.0
+ */
+export declare const isMonotonicX: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT & Monotonic, YT>;
+/**
+ * Type-narrowing predicate: refines the curve's x-axis trait to include
+ * `Increasing`.
+ *
+ * @since 2.0.0
+ */
+export declare const isIncreasingX: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT & Increasing, YT>;
+/**
+ * Type-narrowing predicate: refines the curve's x-axis trait to include
+ * `Decreasing`.
+ *
+ * @since 2.0.0
+ */
+export declare const isDecreasingX: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT & Decreasing, YT>;
+/**
+ * Type-narrowing predicate: refines the curve's y-axis trait to include
+ * `Monotonic`. The x-axis trait is unchanged.
+ *
+ * @since 2.0.0
+ */
+export declare const isMonotonicY: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT, YT & Monotonic>;
+/**
+ * Type-narrowing predicate: refines the curve's y-axis trait to include
+ * `Increasing`.
+ *
+ * @since 2.0.0
+ */
+export declare const isIncreasingY: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT, YT & Increasing>;
+/**
+ * Type-narrowing predicate: refines the curve's y-axis trait to include
+ * `Decreasing`.
+ *
+ * @since 2.0.0
+ */
+export declare const isDecreasingY: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT, YT & Decreasing>;
 /**
  * Type-narrowing predicate: refines both axes' traits to include `Monotonic`
  * when both the x and y polynomials are strictly monotonic. When both axes
  * are monotonic, the curve is invertible in either direction.
  *
- * For checking only one axis, call the polynomial-level refiner directly:
- * `LinearPolynomial.isMonotonic(curve.x)`.
- *
  * @since 2.0.0
  */
 export declare const isMonotonic: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT & Monotonic, YT & Monotonic>;
@@ -193,3 +281,25 @@ export declare const asIncreasing: <XT, YT>(c: LinearCurve2d<XT, YT>) => LinearC
  * @since 2.0.0
  */
 export declare const asDecreasing: <XT, YT>(c: LinearCurve2d<XT, YT>) => LinearCurve2d<XT & Decreasing, YT & Decreasing>;
+export declare const transform: {
+    /**
+     * Applies an `Affine2d` transform to a `LinearCurve2d`, returning a new
+     * curve whose image is the affine image of the original. The transformation
+     * is exact: linear curves are degree-1 in every basis, and affine maps
+     * commute with the basis.
+     *
+     * @param c - The linear curve.
+     * @param a - The affine transform.
+     * @returns The transformed linear curve.
+     * @since 2.0.0
+     */
+    (c: LinearCurve2d, a: Affine2d): LinearCurve2d;
+    /**
+     * Applies an `Affine2d` transform to a `LinearCurve2d`.
+     *
+     * @param a - The affine transform.
+     * @returns A function that takes a `LinearCurve2d` and returns the transformed curve.
+     * @since 2.0.0
+     */
+    (a: Affine2d): (c: LinearCurve2d) => LinearCurve2d;
+};

package/dist/curve/quadratic2d.d.ts

@@ -5,6 +5,7 @@ import type { Pipeable } from '../utils.ts';
 import type { QuadraticPolynomial } from '../polynomial/quadratic.ts';
 import type { Decreasing, Increasing, Monotonic } from '../polynomial/traits.ts';
 import type * as Solution from '../solution/solution.ts';
+import type { Affine2d } from '../transform/affine2d.ts';
 import type { Vector2 } from '../vector/vector2.ts';
 import type { LinearCurve2d } from './linear2d.ts';
 import type { QuadraticCurve2dTypeId } from './quadratic2d.internal.ts';
@@ -201,13 +202,79 @@ export declare const curvature: {
  * @since 2.0.0
  */
 export declare const boundingBox: (c: QuadraticCurve2d) => Interval2d<Closed, Closed>;
+/**
+ * Evaluates the curve at `t = 0` in closed form — `(c.x.c0, c.y.c0)`.
+ *
+ * @param c - The quadratic curve.
+ * @returns The point at the start of the curve's parameter domain.
+ * @since 2.0.0
+ */
+export declare const startPoint: (c: QuadraticCurve2d) => Vector2;
+/**
+ * Evaluates the curve at `t = 1` in closed form — the sum of the per-axis
+ * monomial coefficients.
+ *
+ * @param c - The quadratic curve.
+ * @returns The point at the end of the curve's parameter domain.
+ * @since 2.0.0
+ */
+export declare const endPoint: (c: QuadraticCurve2d) => Vector2;
+/**
+ * The tight `[min, max]` range of x over the curve's parameter domain `[0, 1]`,
+ * accounting for an interior extremum if one exists.
+ *
+ * @param c - The quadratic curve.
+ * @returns The closed range of x over `[0, 1]`.
+ * @since 2.0.0
+ */
+export declare const xRange: (c: QuadraticCurve2d) => Closed;
+/**
+ * The tight `[min, max]` range of y over the curve's parameter domain `[0, 1]`,
+ * accounting for an interior extremum if one exists.
+ *
+ * @param c - The quadratic curve.
+ * @returns The closed range of y over `[0, 1]`.
+ * @since 2.0.0
+ */
+export declare const yRange: (c: QuadraticCurve2d) => Closed;
+/**
+ * Renders the curve as a single SVG path-data drawing command — for a
+ * quadratic curve, `Q ctrlX,ctrlY endX,endY`, where the control point is
+ * recovered from the monomial coefficients via the inverse Bernstein
+ * expansion. Does not include a leading `M`.
+ *
+ * @param c - The quadratic curve.
+ * @returns The SVG drawing command for this segment, without a leading `M`.
+ * @since 2.0.0
+ */
+export declare const toPathDataSegment: (c: QuadraticCurve2d) => string;
+/**
+ * Type-narrowing predicate: refines the curve's x-axis trait to include
+ * `Monotonic` when the x polynomial is strictly monotonic on the unit
+ * interval `[0, 1]`. The y-axis trait is unchanged.
+ *
+ * @since 2.0.0
+ */
+export declare const isMonotonicX: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => c is QuadraticCurve2d<XT & Monotonic, YT>;
+/** @since 2.0.0 */
+export declare const isIncreasingX: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => c is QuadraticCurve2d<XT & Increasing, YT>;
+/** @since 2.0.0 */
+export declare const isDecreasingX: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => c is QuadraticCurve2d<XT & Decreasing, YT>;
+/**
+ * Type-narrowing predicate: refines the curve's y-axis trait to include
+ * `Monotonic`. The x-axis trait is unchanged.
+ *
+ * @since 2.0.0
+ */
+export declare const isMonotonicY: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => c is QuadraticCurve2d<XT, YT & Monotonic>;
+/** @since 2.0.0 */
+export declare const isIncreasingY: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => c is QuadraticCurve2d<XT, YT & Increasing>;
+/** @since 2.0.0 */
+export declare const isDecreasingY: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => c is QuadraticCurve2d<XT, YT & Decreasing>;
 /**
  * Type-narrowing predicate: refines both axes' traits to include `Monotonic`
  * when both x and y polynomials are monotonic over the unit interval `[0, 1]`.
  *
- * For checking only one axis, call the polynomial-level refiner directly:
- * `QuadraticPolynomial.isMonotonic(curve.x, Interval.unit)`.
- *
  * @since 2.0.0
  */
 export declare const isMonotonic: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => c is QuadraticCurve2d<XT & Monotonic, YT & Monotonic>;
@@ -221,3 +288,25 @@ export declare const asMonotonic: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => Quadr
 export declare const asIncreasing: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => QuadraticCurve2d<XT & Increasing, YT & Increasing>;
 /** @since 2.0.0 */
 export declare const asDecreasing: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => QuadraticCurve2d<XT & Decreasing, YT & Decreasing>;
+export declare const transform: {
+    /**
+     * Applies an `Affine2d` transform to a `QuadraticCurve2d`, returning a new
+     * curve whose image is the affine image of the original. Internally the
+     * transformation works directly on the curve's monomial coefficients —
+     * `c0` receives the full affine, `c1` and `c2` receive only the linear part.
+     *
+     * @param c - The quadratic curve.
+     * @param a - The affine transform.
+     * @returns The transformed quadratic curve.
+     * @since 2.0.0
+     */
+    (c: QuadraticCurve2d, a: Affine2d): QuadraticCurve2d;
+    /**
+     * Applies an `Affine2d` transform to a `QuadraticCurve2d`.
+     *
+     * @param a - The affine transform.
+     * @returns A function that takes a `QuadraticCurve2d` and returns the transformed curve.
+     * @since 2.0.0
+     */
+    (a: Affine2d): (c: QuadraticCurve2d) => QuadraticCurve2d;
+};

package/dist/curve/rationalCubic2d.d.ts

@@ -5,6 +5,7 @@ import type { Pipeable } from '../utils.ts';
 import type { CubicPolynomial } from '../polynomial/cubic.ts';
 import type { Decreasing, Increasing, Monotonic } from '../polynomial/traits.ts';
 import type * as Solution from '../solution/solution.ts';
+import type { Affine2d } from '../transform/affine2d.ts';
 import type { Vector2, Weighted } from '../vector/vector2.ts';
 import type { CubicCurve2d } from './cubic2d.ts';
 import type { RationalCubicCurve2dTypeId, RationalCurveTraits } from './rationalCubic2d.internal.ts';
@@ -24,10 +25,10 @@ export { RationalCurveTraits } from './rationalCubic2d.internal.ts';
  * to the rational functions `x(t)/w(t)` and `y(t)/w(t)`. Unlike
  * `CubicCurve2d`, traits do not flow through to the underlying polynomials —
  * monotonicity of a ratio of cubics is not the same property as monotonicity
- * of either cubic alone, so the brand lives on the curve itself. Constructors
- * with construction-time monotonicity guarantees (e.g. {@link makeMonotonicEasing})
- * return curves with `Increasing` brands attached, narrowing downstream
- * operations like {@link solveAtX} to single-solution returns.
+ * of either cubic alone, so the brand lives on the curve itself. Brands are
+ * attached after construction via the {@link asMonotonic}, {@link asIncreasing},
+ * and {@link asDecreasing} families, which verify the property rigorously
+ * (Bernstein sign convexity on the derivative-numerator quartic).
  *
  * All fields are readonly and immutable, and all operations create new instances.
  *
@@ -59,43 +60,63 @@ export declare const isRationalCubicCurve2d: (c: unknown) => c is RationalCubicC
  * @since 2.0.0
  */
 export declare const fromPolynomials: (x: CubicPolynomial, y: CubicPolynomial, w: CubicPolynomial) => RationalCubicCurve2d;
+export declare const fromBezierPoints: {
+    /**
+     * Creates a new `RationalCubicCurve2d` from four weighted cubic Bézier
+     * control points. The four control points are lifted to homogeneous form
+     * `(w·x, w·y, w)` and the cubic Bernstein basis is expanded into per-channel
+     * monomial coefficients, yielding the curve's `x`, `y`, and `w` polynomials.
+     *
+     * @param p0 - The first weighted control point (curve start).
+     * @param p1 - The second weighted control point (start handle).
+     * @param p2 - The third weighted control point (end handle).
+     * @param p3 - The fourth weighted control point (curve end).
+     * @returns A new `RationalCubicCurve2d` instance.
+     * @since 2.0.0
+     */
+    (p0: Weighted, p1: Weighted, p2: Weighted, p3: Weighted): RationalCubicCurve2d;
+    /**
+     * Creates a new `RationalCubicCurve2d` from two interior weighted Bézier
+     * handles, with endpoints pinned at `(0, 0, w=1)` and `(1, 1, w=1)`.
+     *
+     * Rational analog of CSS's `cubic-bezier(x1, y1, x2, y2)`: same fixed
+     * endpoints, same two interior handles, plus per-handle weights for true
+     * rational shapes (the polynomial case is recovered with unit weights).
+     * The curve interpolates `(0, 0)` at `t = 0` and `(1, 1)` at `t = 1`.
+     *
+     * @param p1 - The second weighted control point (start handle).
+     * @param p2 - The third weighted control point (end handle).
+     * @returns A new `RationalCubicCurve2d` instance with pinned endpoints.
+     * @since 2.0.0
+     */
+    (p1: Weighted, p2: Weighted): RationalCubicCurve2d;
+};
 /**
- * Creates a new `RationalCubicCurve2d` from four weighted cubic Bézier
- * control points. The four control points are lifted to homogeneous form
- * `(w·x, w·y, w)` and the cubic Bernstein basis is expanded into per-channel
- * monomial coefficients, yielding the curve's `x`, `y`, and `w` polynomials.
- *
- * @param p0 - The first weighted control point (curve start).
- * @param p1 - The second weighted control point (start handle).
- * @param p2 - The third weighted control point (end handle).
- * @param p3 - The fourth weighted control point (curve end).
- * @returns A new `RationalCubicCurve2d` instance.
- * @since 2.0.0
- */
-export declare const fromBezierPoints: (p0: Weighted, p1: Weighted, p2: Weighted, p3: Weighted) => RationalCubicCurve2d;
-/**
- * Creates a guaranteed-monotonic rational cubic easing curve via Gregory-
- * Delbourgo style construction. The result interpolates `(0, 0)` and
- * `(1, 1)` with the given endpoint slopes, with `x(t) = t` pinned linearly
- * and a rational cubic numerator for `y(t)`. Monotonicity of `y(t)` is
- * verified rigorously at construction (degree-3 polynomial sign analysis);
- * the returned curve is branded `<Increasing, Increasing>` so that
- * {@link solveAtX} returns `Solution.AtMostOne<number>` without further
- * trait refinement.
- *
- * For input slope combinations that the default Gregory-Delbourgo
- * construction cannot accommodate (typically when one slope is large while
- * the other is small), construction throws. Useful operating range is
- * roughly `m₀, m₁ ∈ [0, 2]` with `m₀ + m₁ ≲ 3`; smoothstep (`0, 0`) and
- * linear (`1, 1`) fall out as special cases.
- *
- * @param startSlope - The easing function's slope at the start (`dy/dx` at `x = 0`); must be finite and non-negative.
- * @param endSlope - The easing function's slope at the end (`dy/dx` at `x = 1`); must be finite and non-negative.
- * @returns A monotone-by-construction rational cubic easing curve.
- * @throws When slopes are negative, non-finite, or produce a non-monotonic curve under the default construction.
+ * Creates a rational cubic easing curve from endpoint slopes and signed
+ * curvatures. The result interpolates `(0, 0)` and `(1, 1)` with `x(t) = t`
+ * pinned linearly; the y-axis projection `y(t) = Y(t)/W(t)` uses a cubic
+ * numerator over a quadratic denominator, giving six free parameters that
+ * exactly match the six endpoint constraints (two values, two slopes, two
+ * curvatures).
+ *
+ * Curvatures are the signed differential-geometric curvatures `κ = y''(x) /
+ * (1 + y'(x)²)^(3/2)` — the parameterization-invariant "bend" of the easing
+ * graph. Positive κ is concave-up. Smoothstep is `(0, 0, 6, -6)`; linear is
+ * `(1, 1, 0, 0)` (taken as a redundant-system special case).
+ *
+ * Monotonicity is not enforced. Callers needing the `Increasing` brand for
+ * narrowed inverse-solve returns should follow construction with
+ * {@link asIncreasing}, which verifies monotonicity rigorously.
+ *
+ * @param startSlope - The easing function's slope at the start (`dy/dx` at `x = 0`).
+ * @param endSlope - The easing function's slope at the end (`dy/dx` at `x = 1`).
+ * @param startCurvature - The signed differential curvature at the start.
+ * @param endCurvature - The signed differential curvature at the end.
+ * @returns A rational cubic easing curve.
+ * @throws When inputs are non-finite, the constraint system is singular, or the resulting denominator vanishes on `[0, 1]`.
  * @since 2.0.0
  */
-export declare const makeMonotonicEasing: (startSlope: number, endSlope: number) => RationalCubicCurve2d<Increasing, Increasing>;
+export declare const fromSlopesAndCurvatures: (startSlope: number, endSlope: number, startCurvature: number, endCurvature: number) => RationalCubicCurve2d;
 export declare const solve: {
     /**
      * Evaluates the rational cubic curve at parameter `t`. Returns
@@ -116,6 +137,24 @@ export declare const solve: {
      */
     (t: number): (c: RationalCubicCurve2d) => Vector2;
 };
+/**
+ * Evaluates the curve at `t = 0` in closed form — `(c.x.c0 / c.w.c0, c.y.c0 / c.w.c0)`.
+ *
+ * @param c - The rational cubic curve.
+ * @returns The point at the start of the curve's parameter domain.
+ * @since 2.0.0
+ */
+export declare const startPoint: (c: RationalCubicCurve2d) => Vector2;
+/**
+ * Evaluates the curve at `t = 1` in closed form. Both numerator and denominator
+ * Horner evaluations at `t = 1` collapse to the sum of their monomial
+ * coefficients, so the projection is `(Σxᵢ / Σwᵢ, Σyᵢ / Σwᵢ)`.
+ *
+ * @param c - The rational cubic curve.
+ * @returns The point at the end of the curve's parameter domain.
+ * @since 2.0.0
+ */
+export declare const endPoint: (c: RationalCubicCurve2d) => Vector2;
 export declare const solveAtX: {
     /**
      * Evaluates the curve's y values at a given x. Because the curve's x axis
@@ -391,6 +430,29 @@ export declare const asIncreasing: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) =>
  * @since 2.0.0
  */
 export declare const asDecreasing: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => RationalCubicCurve2d<XT & Decreasing, YT & Decreasing>;
+export declare const transform: {
+    /**
+     * Applies an `Affine2d` transform to a `RationalCubicCurve2d`, returning a
+     * new curve whose image is the affine image of the original. The denominator
+     * polynomial is preserved; each numerator pulls in a translation term
+     * weighted by the denominator so the projected curve matches `A · R(s) + t`
+     * pointwise.
+     *
+     * @param c - The rational cubic curve.
+     * @param a - The affine transform.
+     * @returns The transformed rational cubic curve.
+     * @since 2.0.0
+     */
+    (c: RationalCubicCurve2d, a: Affine2d): RationalCubicCurve2d;
+    /**
+     * Applies an `Affine2d` transform to a `RationalCubicCurve2d`.
+     *
+     * @param a - The affine transform.
+     * @returns A function that takes a `RationalCubicCurve2d` and returns the transformed curve.
+     * @since 2.0.0
+     */
+    (a: Affine2d): (c: RationalCubicCurve2d) => RationalCubicCurve2d;
+};
 export declare const approximateAsCubicCurves: {
     /**
      * Approximates the rational cubic as a sequence of polynomial cubic curves

package/dist/interval/index.mjs

@@ -1,3 +1,3 @@
-import { s as interval_exports } from "../shared/interval-Dm35Xhy4.mjs";
-import { n as interval2d_exports } from "../shared/interval2d-AtneyI45.mjs";
+import { c as interval_exports } from "../shared/interval-Dcqpo73t.mjs";
+import { n as interval2d_exports } from "../shared/interval2d-C2Pk66-2.mjs";
 export { interval_exports as Interval, interval2d_exports as Interval2d };