ofs-object 0.1.0-beta.1 → 0.1.0-beta.3

package/dist/index.d.ts

@@ -80,6 +80,97 @@ declare type AnyFeature = Feature<Geometry, any>;
 /** Apply a class color / size / override on top of the base symbol */
 export declare function applyClassSymbol(base: SymbolStyle, classColor: string | undefined, classSize: number | undefined, override?: ClassSymbolOverride): SymbolStyle;
 
+/**
+ * Rebuild a feature from vertices and bends: the curve goes into the properties and the polyline
+ * that samples it into the geometry. A run with no bend left drops the property, so straightening
+ * the last arc leaves an ordinary feature behind.
+ */
+export declare function applyCurveState(feature: Feature<Geometry, any>, state: CurveState): Feature<Geometry, any> | null;
+
+/** True when the point lies to the left of the chord, the side the arc bulges towards */
+export declare function arcBulgesLeft(arc: PlanarArc): boolean;
+
+/** Straight-line distance between the two ends, in meters */
+export declare function arcChordLength(arc: PlanarArc): number;
+
+/** The point an arc ends at */
+export declare function arcEndPoint(arc: PlanarArc): PlanarPoint;
+
+/** Rebuild an arc from two ends and a DXF bulge factor. Returns null for a bulge of zero (a straight segment). */
+export declare function arcFromBulge(start: PlanarPoint, end: PlanarPoint, bulge: number): PlanarArc | null;
+
+/**
+ * AutoCAD's Start, Center, Length - the length of the *chord*, not of the arc. Returns null when the
+ * chord is longer than the diameter, which no arc on this circle can span.
+ */
+export declare function arcFromStartCenterChord(start: PlanarPoint, center: PlanarPoint, chordLength: number, ccw?: boolean): PlanarArc | null;
+
+/**
+ * AutoCAD's Start, Center, End. The radius comes from the start point; the end point only supplies
+ * a direction, so an end that is not exactly on the circle is pulled onto it rather than refused.
+ */
+export declare function arcFromStartCenterEnd(start: PlanarPoint, center: PlanarPoint, end: PlanarPoint, ccw?: boolean): PlanarArc | null;
+
+/** AutoCAD's Start, Center, Angle. A positive sweep turns counter-clockwise. */
+export declare function arcFromStartCenterSweep(start: PlanarPoint, center: PlanarPoint, sweep: number): PlanarArc | null;
+
+/**
+ * AutoCAD's Start, End, Direction: the arc leaves `start` heading along `direction` and still reaches
+ * `end`. This is the one a polyline uses when a straight run turns into a curve, because passing the
+ * previous segment's direction makes the arc tangent to it and the join comes out smooth.
+ *
+ * Returns null when `direction` points straight at (or straight away from) `end`: the answer there is
+ * a line, not an arc of infinite radius.
+ */
+export declare function arcFromStartEndDirection(start: PlanarPoint, end: PlanarPoint, direction: PlanarPoint): PlanarArc | null;
+
+/**
+ * AutoCAD's Start, End, Radius. Two ends and a radius describe four different arcs, so the caller
+ * says which: `ccw` picks the direction of travel and `major` picks the long way round.
+ * Returns null when the radius is too small to reach both ends.
+ */
+export declare function arcFromStartEndRadius(start: PlanarPoint, end: PlanarPoint, radius: number, options?: {
+    ccw?: boolean;
+    major?: boolean;
+}): PlanarArc | null;
+
+/**
+ * AutoCAD's Start, End, Angle. The sweep and the two ends fix the radius, so this is the form to use
+ * when the turn matters more than the size - a pipe bend specified as "45 degrees", say.
+ */
+export declare function arcFromStartEndSweep(start: PlanarPoint, end: PlanarPoint, sweep: number): PlanarArc | null;
+
+/** Length along the arc, in meters */
+export declare function arcLength(arc: PlanarArc): number;
+
+/** The point halfway along the arc - the grip a user drags to change the bulge */
+export declare function arcMidPoint(arc: PlanarArc): PlanarPoint;
+
+/** The point at parameter t along the arc, t = 0 at the start and t = 1 at the end */
+export declare function arcPointAt(arc: PlanarArc, t: number): PlanarPoint;
+
+/** The point an arc starts at */
+export declare function arcStartPoint(arc: PlanarArc): PlanarPoint;
+
+/** Unit direction of travel at parameter t, pointing the way the arc is drawn */
+export declare function arcTangentAt(arc: PlanarArc, t: number): PlanarPoint;
+
+/**
+ * The arc through three points, in the order given. Returns null when the points are collinear or
+ * two of them coincide - there is no circle through them, and the caller should draw a line.
+ *
+ * This is AutoCAD's 3-Point arc, and also what a "drag the midpoint" grip produces: the two ends
+ * stay put and the dragged point rides the arc.
+ */
+export declare function arcThroughPoints(start: PlanarPoint, through: PlanarPoint, end: PlanarPoint): PlanarArc | null;
+
+/**
+ * DXF bulge factor: the tangent of a quarter of the sweep. DXF and several CAD formats store an arc
+ * inside a polyline this way, so keeping the conversion here means the export path needs no arc
+ * maths of its own.
+ */
+export declare function arcToBulge(arc: PlanarArc): number;
+
 /** 1 rai = 4 ngan = 400 square wa = 1600 m² */
 export declare const AREA_UNITS: Record<string, number>;
 
@@ -114,6 +205,9 @@ export declare function askRequiredPoint(consoleService: IOFSConsole, prompt: st
 
 export declare function assertValidPolygon(geometry: Polygon | MultiPolygon, what: string): void;
 
+/** Write a curve definition onto a properties object, or clear it when there is no curve left */
+export declare function attachCurve(properties: Record<string, any>, meta: OfsCurveMeta | null): Record<string, any>;
+
 export declare interface AttributeRow {
     featureId: string | number;
     selected: boolean;
@@ -258,6 +352,13 @@ export declare abstract class BaseGLAdapter implements IMapAdapter {
     destroy(): void;
 }
 
+/**
+ * Bend one segment of a feature into an arc turning through `sweepDegrees`, or straighten it when
+ * the sweep is zero. The turn is asked for rather than guessed: there is no one bend that is
+ * obviously right for a straight line. Returns null when the segment or the feature cannot take one.
+ */
+export declare function bendSegment(feature: Feature<Geometry, any>, segmentIndex: number, sweepDegrees: number): Feature<Geometry, any> | null;
+
 export declare type BoundingBox = [number, number, number, number];
 
 /** Build contiguous breaks from ascending upper bounds, with colors, labels and counts */
@@ -275,6 +376,13 @@ export declare const BUILTIN_MARKER_SHAPES: MarkerShape[];
 /** Points along a bulge segment (excluding the start point, including the end point) */
 export declare function bulgePoints(p1: Position, p2: Position, bulge: number, maxStepDeg: number): Position[];
 
+/**
+ * The bulge that makes the segment from `start` to `end` pass through `through`. This is what a
+ * midpoint grip reports while it is being dragged: the two ends stay put and the arc follows the
+ * pointer. Returns 0 when the three points line up, which straightens the segment again.
+ */
+export declare function bulgeThroughPoint(start: Coordinate, through: Coordinate, end: Coordinate, projection?: PlanarProjection): number;
+
 export declare class CADOperations {
     /**
      * Split a Polygon using a LineString.
@@ -601,6 +709,28 @@ export declare interface ClassSymbolOverride {
     rotationDeg?: number;
 }
 
+/**
+ * Closest point on the arc to an arbitrary point, and how far away it is. Used for snapping onto a
+ * curve: the stored polyline's vertices are sampling artefacts, so snapping to them would put a
+ * point where the user never drew one.
+ */
+export declare function closestPointOnArc(arc: PlanarArc, point: PlanarPoint): {
+    point: PlanarPoint;
+    t: number;
+    distance: number;
+};
+
+/**
+ * Closest point on the curve to a coordinate, measured against the real arcs rather than the sampled
+ * polyline. Snapping has to ask this: the sampled vertices are an artefact of the tolerance, so
+ * snapping to one of them would drop a point where the user never drew anything.
+ */
+export declare function closestPointOnCurve(meta: OfsCurveMeta, coordinate: Coordinate, projection?: PlanarProjection): {
+    coordinate: Coordinate;
+    segmentIndex: number;
+    distanceMeters: number;
+} | null;
+
 /**
  * Check and convert one value for a field. Text is converted to the field type only when the meaning is
  * unambiguous ("12" for a number field, "true"/"1" for a boolean); anything else is refused.
@@ -861,6 +991,50 @@ export declare function crsToOgcWkt(crs: ResolvedCrs): string;
 /** WKT for .prj export (ESRI flavour for common CRSs) */
 export declare function crsToPrj(crs: ResolvedCrs): string;
 
+/** Property name the curve definition lives under */
+export declare const CURVE_PROPERTY = "ofsCurve";
+
+export declare interface CurveGripPoint {
+    /** Index of the segment this grip bends */
+    segmentIndex: number;
+    coordinate: Coordinate;
+    /** True once the segment is already curved; a straight segment's grip is its plain midpoint */
+    curved: boolean;
+}
+
+/**
+ * One grip per segment, sitting at the middle of the arc, or at the middle of the straight line for
+ * a segment that has not been bent yet. Dragging one is how a drawn feature gains a curve.
+ */
+export declare function curveGripPoints(vertices: Coordinate[], bulges: number[], sagToleranceMeters?: number, projection?: PlanarProjection): CurveGripPoint[];
+
+/** One segment of a feature that can be straight or bent, as a UI would list it for a menu */
+export declare interface CurveSegmentInfo {
+    index: number;
+    curved: boolean;
+    /** Where the bend handle sits: the middle of the arc, or the middle of the straight segment */
+    coordinate: Coordinate;
+    /** How far the arc stands off its chord, in meters; zero while the segment is straight */
+    sagMeters: number;
+}
+
+export declare interface CurveState {
+    vertices: Coordinate[];
+    bulges: number[];
+    sagToleranceMeters: number;
+}
+
+/**
+ * The vertices and bends behind a feature, whether or not it has been curved yet.
+ *
+ * A feature that carries a curve keeps its real vertices in the properties, because its geometry is
+ * a sampled polyline whose points are an artefact of the drawing tolerance. A feature with no curve
+ * has no such distinction: its coordinates are its vertices and every segment is straight.
+ *
+ * Only single-ring lines and polygons can hold a curve; anything else returns null.
+ */
+export declare function curveStateOf(feature: Feature<Geometry, any> | null | undefined): CurveState | null;
+
 export declare interface DbfTable {
     fields: (FieldDefinition & {
         dbfType: string;
@@ -897,6 +1071,16 @@ export declare const DEFAULT_MAX_NETWORK_POINTS = 5000;
 
 export declare const DEFAULT_POLAR_TRACKING: PolarTrackingSettings;
 
+export declare const DEFAULT_PREVIEW_STYLE: DrawPreviewStyle;
+
+/**
+ * How far the stored polyline may sag away from the true arc, in meters. Five centimeters is below
+ * the positional accuracy of the survey data these plans are drawn over, and is deliberately a
+ * distance on the ground rather than a step count: a fixed number of steps makes a 2 m arc far more
+ * detailed than it needs to be and a 2 km arc visibly faceted.
+ */
+export declare const DEFAULT_SAG_TOLERANCE_METERS = 0.05;
+
 export declare const DEFAULT_SYMBOL_COLOR = "#3b82f6";
 
 export declare const DEFAULT_TOPOLOGY_OPTIONS: ResolvedTopologyOptions;
@@ -980,6 +1164,14 @@ export declare interface DrawEvents {
         mode: DrawMode;
         coordinates: Coordinate[];
     };
+    'draw:arc-segment': {
+        /** Whether the next segment will be drawn as an arc */
+        enabled: boolean;
+        /** Fixed turn in degrees, or null when the arc follows on smoothly from the last segment */
+        sweepDegrees: number | null;
+        /** False when an arc was asked for but there is nothing yet for it to continue from */
+        ready: boolean;
+    };
     'draw:tracking-points': {
         points: Coordinate[];
     };
@@ -1063,6 +1255,21 @@ export declare type DrawMode = 'point' | 'line' | 'polygon' | 'circle' | 'rectan
  */
 export declare function drawNorthArrow(ctx: DrawingContext, x: number, y: number, size?: number, bearingDeg?: number): void;
 
+export declare interface DrawPreviewStyle {
+    pointColor: string;
+    pointRadius: number;
+    pointStrokeColor: string;
+    pointStrokeWidth: number;
+    lineColor: string;
+    lineWidth: number;
+    /** Dash pattern in multiples of the line width; an empty list draws a solid line */
+    lineDash: number[];
+    fillColor: string;
+    fillOpacity: number;
+    /** Applied to points and lines together, so the whole preview can be dimmed at once */
+    opacity: number;
+}
+
 /** Draw a scale bar with its left end at (x, y) (y is the bottom of the bar) */
 export declare function drawScaleBar(ctx: DrawingContext, plan: ScaleBarPlan, x: number, y: number, style?: ScaleBarStyle): void;
 
@@ -1417,7 +1624,11 @@ export declare class GridTooLargeError extends OFSError {
 export declare interface GripHandle {
     id: string;
     coordinate: Coordinate;
-    type: 'vertex' | 'midpoint' | 'center';
+    /**
+     * `curve` is the bend handle of an arc segment: dragging it reshapes the arc rather than moving a
+     * point, which is why it is not a `midpoint` - dragging one of those inserts a vertex.
+     */
+    type: 'vertex' | 'midpoint' | 'center' | 'curve';
     index: number;
     ringIndex: number;
     partIndex?: number;
@@ -1442,6 +1653,9 @@ export declare interface GripsEditorEvents {
     'grip:clear': void;
 }
 
+/** A curve with no bend worth drawing is just a polyline and needs no metadata */
+export declare function hasCurvedSegments(meta: OfsCurveMeta, projection?: PlanarProjection): boolean;
+
 /** Stable short hash for image ids */
 export declare function hashString(text: string): string;
 
@@ -1681,6 +1895,20 @@ export declare function isInlineSvg(source: string): boolean;
 
 export declare function isInternalProperty(name: string): boolean;
 
+/**
+ * Whether one segment is bent enough to be worth treating as an arc.
+ *
+ * The test is the sag the bend actually produces on the ground, not the size of the bulge number: a
+ * bulge is a shape, so the same value is a sharp bend across a 5 m segment and an invisible one
+ * across 5 km. Judging it by the same tolerance the geometry is sampled at means a segment counts as
+ * curved exactly when drawing it as an arc would put the line somewhere a straight one would not.
+ *
+ * Two points at the same latitude are the case that makes this matter: a parallel is not a straight
+ * line on a Transverse Mercator plane, so dragging a grip back onto the apparent line leaves a
+ * millimetre of real bend behind. Without this the segment would never straighten again.
+ */
+export declare function isSegmentCurved(meta: OfsCurveMeta, index: number, projection?: PlanarProjection): boolean;
+
 export declare function isTruthy(value: ExpressionValue): boolean;
 
 /**
@@ -1935,6 +2163,12 @@ export declare type LocationPredicate = 'intersects' | 'within' | 'contains' | '
 /** True when every coordinate is a plausible lng/lat */
 export declare function looksGeographic(bounds: [number, number, number, number]): boolean;
 
+/**
+ * Build a curve definition from the vertices a user placed and the bend of each segment.
+ * Returns null when the run is straight throughout, so a plain polyline carries no extra properties.
+ */
+export declare function makeCurve(vertices: Coordinate[], bulges: number[], sagToleranceMeters?: number): OfsCurveMeta | null;
+
 export declare class MapboxAdapter extends BaseGLAdapter {
     readonly engineName: "mapbox";
     init(container: HTMLElement | string, options?: Record<string, any>): Promise<void>;
@@ -2046,6 +2280,9 @@ export declare interface MarkerSymbol {
     allowOverlap?: boolean;
 }
 
+/** Never emit more than this many points for one arc, whatever the tolerance asks for */
+export declare const MAX_ARC_POINTS = 2048;
+
 /** Distance (m) and user angle from `from` to `to` */
 export declare function measure(from: Coordinate, to: Coordinate, frame?: InputFrame): {
     distance: number;
@@ -2352,6 +2589,23 @@ export declare class OFSCommandRegistry {
     suggest(prefix: string): string[];
 }
 
+export declare interface OfsCurveMeta {
+    version: 1;
+    /** The points the user actually placed, in order. The geometry samples the curve between them. */
+    vertices: Coordinate[];
+    /**
+     * One entry per segment, so always one shorter than `vertices`. Zero is a straight segment;
+     * otherwise the tangent of a quarter of the arc's sweep, positive counter-clockwise.
+     */
+    bulges: number[];
+    /**
+     * How far the sampled geometry may stand away from the true curve, in meters on the ground. Kept
+     * with the feature so that re-sampling after an edit reproduces the fidelity it was drawn at,
+     * rather than silently changing it.
+     */
+    sagToleranceMeters: number;
+}
+
 export declare class OFSDataSource extends TypedEventEmitter<OFSDataSourceEvents> {
     private layers;
     private groups;
@@ -2610,12 +2864,64 @@ export declare interface OFSDataSourceEvents {
  */
 export declare type OFSDiagnosticHandler = (scope: string, error: unknown) => void;
 
+export declare class OFSDrawPreview {
+    private mapAdapter;
+    private sourceId;
+    private style;
+    private current;
+    /** Layer ids in draw order, bottom first */
+    get layerIds(): string[];
+    constructor(mapAdapter: IMapAdapter);
+    private raw;
+    /**
+     * Create the source and layers. Called for you the first time anything is drawn, so a caller that
+     * only ever uses `set` never has to think about it.
+     */
+    setupLayers(): void;
+    /**
+     * Replace what the preview shows. Safe to call on every mouse move: it writes one GeoJSON payload
+     * and touches nothing else.
+     *
+     * Points, lines and polygons can be mixed freely. A feature may carry `color`, `opacity`, `width`,
+     * `radius`, `fillOpacity`, `strokeColor` or `strokeWidth` in its properties to depart from the
+     * style for itself.
+     */
+    set(features: Feature<Geometry, any>[] | FeatureCollection | null): void;
+    /**
+     * Take the preview off the map.
+     *
+     * This is never called for you when a drawing finishes or is cancelled. The preview belongs to the
+     * caller and only the caller knows whether it has gone stale, so scaffolding tied to a drawing
+     * session is cleared from a `draw:complete` and `draw:cancel` handler.
+     */
+    clear(): void;
+    /** What the preview is currently showing */
+    getFeatures(): Feature<Geometry, any>[];
+    isEmpty(): boolean;
+    /** Change the look of the preview. Anything left out keeps its current value. */
+    setStyle(style: Partial<DrawPreviewStyle>): void;
+    getStyle(): DrawPreviewStyle;
+    /**
+     * Lift the preview above the data layers. The drawing guides are raised after this, so the rubber
+     * band and the measurements stay readable over whatever the preview is showing.
+     */
+    bringToFront(): void;
+    /** Remove the layers and the source, for when the draw tools are torn down */
+    destroy(): void;
+}
+
 export declare class OFSDrawTools extends TypedEventEmitter<DrawEvents> {
     private dataSource;
     private mapAdapter;
     readonly snapping: SnappingEngine;
     readonly grips: OFSGripsEditor;
     readonly selectionOverlay: OFSSelectionOverlay;
+    /**
+     * A scratch layer for the host application to draw on while a tool is in use - a planting grid
+     * following the line being drawn, the parcels a cutting line is about to divide. Nothing put here
+     * reaches the data source, the undo history or an export. See `preview/draw-preview.ts`.
+     */
+    readonly preview: OFSDrawPreview;
     orthoEnabled: boolean;
     polarTracking: PolarTrackingSettings;
     /** Angle convention and UCS used for typed angles, relative coordinates, ortho and polar tracking */
@@ -2631,6 +2937,17 @@ export declare class OFSDrawTools extends TypedEventEmitter<DrawEvents> {
     private pointPick;
     private currentMode;
     private activeCoordinates;
+    /**
+     * Bend of each segment already placed, one shorter than `activeCoordinates`. Zero is straight.
+     * See `curves/curve-feature.ts` for why a curve is one number per segment rather than a centre.
+     */
+    private activeBulges;
+    /** Whether the segment about to be drawn is an arc (AutoCAD PLINE's Arc option) */
+    private arcSegment;
+    /** Fixed turn for arc segments, in radians; null means each arc leaves the last one smoothly */
+    private arcSweepRadians;
+    /** How far stored geometry may sag from the curves it samples */
+    private sagToleranceMeters;
     private targetLayerId;
     private tempSourceId;
     private unsubClick;
@@ -2662,6 +2979,47 @@ export declare class OFSDrawTools extends TypedEventEmitter<DrawEvents> {
      * Choose how typed angles are interpreted: 'bearing' (0° = North, clockwise) or 'cad' (0° = East, counter-clockwise)
      */
     setAngleConvention(convention: AngleConvention): void;
+    /**
+     * Draw the next segment as an arc instead of a straight line, the way AutoCAD's PLINE takes its
+     * Arc and Line options. Only `line` and `polygon` carry curved segments.
+     *
+     * With no `sweepDegrees` the arc leaves the previous segment along the direction it arrived in, so
+     * the join comes out smooth and no further input is needed - one click still places one vertex.
+     * That needs something to continue from, so an arc asked for as the very first segment reports
+     * `ready: false` and is drawn straight until there is a segment behind it. Passing `sweepDegrees`
+     * fixes the turn instead, which works from the first segment and is what a command or an agent
+     * uses when the bend is a specification rather than something drawn by eye.
+     */
+    setArcSegment(enabled: boolean, options?: {
+        sweepDegrees?: number | null;
+    }): void;
+    /** Swap between straight and curved segments, returning the state that is now in force */
+    toggleArcSegment(): boolean;
+    /** Whether the segment about to be drawn is an arc */
+    isArcSegment(): boolean;
+    /** Bend of each segment placed so far, one shorter than the vertex list */
+    getActiveBulges(): number[];
+    /**
+     * How far stored geometry may stand away from the curve it samples, in meters on the ground.
+     * It is recorded on each feature as it is drawn, so tightening it later does not silently change
+     * the fidelity of anything already on the map.
+     */
+    setSagTolerance(meters: number): void;
+    getSagTolerance(): number;
+    /**
+     * Which way the drawing is heading as it leaves the last vertex placed: along the last straight
+     * segment, or along the tangent at the end of the last arc. Null before there is a segment at all.
+     */
+    private headingAtLastVertex;
+    /** Bend of a segment running from the last vertex to `end`, under the arc settings in force */
+    private bulgeForSegmentTo;
+    /**
+     * Length of a drawn line, measuring each arc along the arc rather than along the polyline that
+     * samples it. The sampled version is always a little short, by design - it is a chord chain.
+     */
+    private curveLengthMeters;
+    /** The line as it is being drawn, sampled through any arcs, with the live segment on the end */
+    private previewCoordinates;
     /** Map adapter used by these tools */
     getMapAdapter(): IMapAdapter;
     /** Last known cursor position after snapping / tracking */
@@ -2812,6 +3170,20 @@ export declare class OFSDrawTools extends TypedEventEmitter<DrawEvents> {
     scaleFeature(layerId: string, featureId: string | number, factor: number, origin?: Coordinate): Feature<Geometry> | null;
     explodeFeature(layerId: string, featureId: string | number): Feature<LineString>[] | null;
     filletFeature(layerId: string, featureId: string | number, vertexIndex: number, radiusMeters?: number): Feature<Polygon | LineString> | null;
+    /**
+     * Bend one segment of an existing line or polygon into an arc turning through `sweepDegrees`, or
+     * straighten it again with a sweep of zero. The segment is numbered from the vertices the user
+     * placed, which for a feature that already holds a curve are not the same as the coordinates in
+     * its geometry - see `getFeatureCurveSegments` to list them.
+     */
+    curveFeatureSegment(layerId: string, featureId: string | number, segmentIndex: number, sweepDegrees: number): Feature<Geometry, any> | null;
+    /** Segments of a feature that can be bent, with where each one's handle sits and how deep it runs */
+    getFeatureCurveSegments(layerId: string, featureId: string | number): {
+        index: number;
+        curved: boolean;
+        coordinate: Coordinate;
+        sagMeters: number;
+    }[];
     /**
      * Start interactive Grips editing on a feature
      */
@@ -3146,6 +3518,28 @@ export declare class OFSGripsEditor extends TypedEventEmitter<GripsEditorEvents>
     /**
      * Generate grip handles for the active feature
      */
+    /**
+     * Grips come from the curve's own vertices, never from the geometry. A curved feature's geometry
+     * is a sampled polyline whose points are an artefact of the drawing tolerance, so a handle on each
+     * of those would bury the feature and let a drag pull one sample point off the arc it belongs to.
+     */
+    private curveStateOf;
+    /** Write vertices and bends back to the active feature */
+    private writeCurveState;
+    /** Every segment of the feature being edited, for a UI offering to bend or straighten one */
+    getCurveSegments(): CurveSegmentInfo[];
+    /**
+     * Bend one segment of the feature being edited into an arc - the action behind a "convert to arc"
+     * menu entry. `sweepDegrees` says how far the arc turns; it is required rather than guessed,
+     * because there is no one bend that is obviously the right one for a straight line.
+     */
+    convertSegmentToArc(segmentIndex: number, sweepDegrees: number): boolean;
+    /** Set one segment's bend directly, as a DXF bulge factor */
+    setSegmentBulge(segmentIndex: number, bulge: number): boolean;
+    /** Take the bend out of one segment, leaving a straight line between its two vertices */
+    straightenSegment(segmentIndex: number): boolean;
+    /** Handles for a feature whose vertices live in its properties rather than in its geometry */
+    private curveHandles;
     getHandles(): GripHandle[];
     private setupLayers;
     private renderGrips;
@@ -3158,7 +3552,14 @@ export declare class OFSGripsEditor extends TypedEventEmitter<GripsEditorEvents>
     private handleContextMenu;
     private handleMove;
     private applyCoordinateChange;
+    /**
+     * Drag handling for a feature that carries a curve. A bend handle reshapes its arc so the curve
+     * follows the pointer; a vertex handle moves the point itself and the arcs on either side bend to
+     * keep up, because a bulge is defined against its own two ends rather than against a fixed centre.
+     */
+    private applyCurveChange;
     private insertVertexAtMidpoint;
+    private insertVertexIntoGeometry;
     /**
      * Delete selected vertex
      */
@@ -3876,6 +4277,15 @@ export declare function parseXml(source: string): XmlElement;
 /** Boundary paths: polygon rings or line parts */
 export declare function pathsOf(geometry: Geometry): Position[][];
 
+export declare interface PlanarArc {
+    center: PlanarPoint;
+    radius: number;
+    /** Direction of the start point from the centre, in radians (atan2 convention) */
+    startAngle: number;
+    /** Signed turn from start to end, in radians. Positive turns counter-clockwise; never zero, never beyond a full turn. */
+    sweep: number;
+}
+
 export declare type PlanarPoint = [number, number];
 
 export declare class PlanarProjection {
@@ -3936,6 +4346,9 @@ export declare function printImportResult(consoleService: IOFSConsole, result: I
 /** Print an import / export report: summary lines, then issues grouped by code */
 export declare function printIssues(consoleService: IOFSConsole, issues: ImportIssue[], limit?: number): void;
 
+/** Plane to do the arc maths on, centred on the curve so distances come out in ground meters */
+export declare function projectionForVertices(vertices: Coordinate[]): PlanarProjection;
+
 export declare class PromptBuilder {
     /**
      * Summarize current map state for LLM prompt context.
@@ -3969,6 +4382,9 @@ export declare function rasterizeMarker(request: Extract<SymbolImageRequest, {
  */
 export declare function readCoordinate(value: unknown): Coordinate;
 
+/** Read and validate a curve definition off a feature. Returns null when there is none, or it is malformed. */
+export declare function readCurve(feature: Feature<Geometry, any> | null | undefined): OfsCurveMeta | null;
+
 export declare function readDbf(buffer: Uint8Array, options?: {
     encoding?: string;
     cpg?: string;
@@ -4106,6 +4522,9 @@ export declare function restoreCollinearVertices<G extends Polygon | MultiPolygo
     restored: number;
 };
 
+/** The same arc travelled the other way: ends swap and the sweep changes sign */
+export declare function reverseArc(arc: PlanarArc): PlanarArc;
+
 /** Planar area of one ring in m² (absolute) */
 export declare function ringArea(ring: Position[], projection: PlanarProjection): number;
 
@@ -4150,6 +4569,12 @@ declare type Schema = NonNullable<OFSCommandProcess['schema']>;
 /** Property names of a schema, including none when the command has no schema */
 export declare function schemaProperties(schema: Schema | undefined): string[];
 
+/**
+ * The arc of one segment, or null when that segment is straight.
+ * `index` counts segments, so segment 0 runs from vertex 0 to vertex 1.
+ */
+export declare function segmentArc(meta: OfsCurveMeta, index: number, projection?: PlanarProjection): PlanarArc | null;
+
 export declare interface SegmentHit {
     distance: number;
     /** Parameter along the segment, 0..1 */
@@ -4166,6 +4591,12 @@ export declare interface SegmentMeasure {
     angleDeg: number;
 }
 
+/**
+ * How far a bulged segment stands off its own chord at the deepest point, in meters. Exactly half
+ * the chord times the bulge, which falls out of the definitions of the two.
+ */
+export declare function segmentSagitta(chordLengthMeters: number, bulge: number): number;
+
 export declare interface SelectedFeatureRef {
     layerId: string;
     feature: Feature<Geometry>;
@@ -4238,11 +4669,30 @@ export declare class SnappingEngine {
      * @param additionalCoords Optional extra coordinates to snap to (e.g. start vertex of in-progress polygon)
      * @param options.excludeFeatureId Feature to ignore (e.g. the feature being edited)
      * @param options.fromPoint Previous point, enables perpendicular snapping
+     * @param options.connectAdditional Treat `additionalCoords` as a connected run, so the segments
+     *   between them can be snapped to as well. True while drawing, where those segments are really
+     *   there. False when the points are just a list, such as the vertices of a curve, where the
+     *   straight lines between them are not part of any shape on the map.
      */
     getSnap(cursorCoord: Coordinate, additionalCoords?: Coordinate[], options?: {
         excludeFeatureId?: string | number | null;
         fromPoint?: Coordinate | null;
+        connectAdditional?: boolean;
     }): SnapResult | null;
+    /**
+     * Snap targets of a feature that carries a curve.
+     *
+     * Its geometry is a polyline sampled off the curve, so every point in it except the placed
+     * vertices is an artefact of the drawing tolerance. Snapping to one of those drops a point where
+     * the user never drew anything, and it is worse than useless while dragging an arc's own bend
+     * handle: the handle lands on a sample point of the arc it is supposed to be shaping, and the
+     * curve collapses onto its chord.
+     *
+     * So the arcs are snapped to as arcs. A vertex is one the user placed; the nearest point on an
+     * arc is found on the arc itself; and an arc offers its centre, which is the one point a circular
+     * feature is most often measured from.
+     */
+    private considerCurve;
     /**
      * Proper crossing point of two segments (shared endpoints are vertices, not intersections)
      */
@@ -4504,6 +4954,21 @@ export declare interface TableResult {
     filtered: number;
 }
 
+/**
+ * Sample an arc into the polyline that actually gets stored, including both end points.
+ *
+ * The step count comes from the sag tolerance: for a chord spanning angle `d` on radius `r` the
+ * middle of the arc stands `r * (1 - cos(d / 2))` away from it, so the angle that keeps that under
+ * the tolerance is `2 * acos(1 - tolerance / r)`.
+ */
+export declare function tessellateArc(arc: PlanarArc, sagToleranceMeters?: number, maxPoints?: number): PlanarPoint[];
+
+/**
+ * Sample a curve into the coordinate list that gets stored in the geometry. Straight segments
+ * contribute their end vertex alone; curved ones contribute the points of the arc between.
+ */
+export declare function tessellateCurve(meta: OfsCurveMeta, projection?: PlanarProjection): Coordinate[];
+
 /** Text content including descendants */
 export declare function textContent(el: XmlElement | undefined): string;