@orbat-mapper/control-measures 0.2.0-alpha.1 → 0.2.0-alpha.3

package/dist/index-BJYbQlzo.d.mts

@@ -0,0 +1,1713 @@
+import { Feature, FeatureCollection, Geometry, LineString, MultiLineString, MultiPolygon, Point, Polygon, Position } from "geojson";
+
+//#region src/internal/api-utils.d.ts
+type ValidationMode = "silent" | "warn" | "throw";
+//#endregion
+//#region src/draw-rules/types.d.ts
+interface AnchorTransformEvent {
+  previous: readonly Position[];
+  next: readonly Position[];
+  activePointIndex?: number;
+}
+interface ControlMeasureDrawRule {
+  readonly id: string;
+  readonly minimumUserPoints: number;
+  readonly canonicalPointCount?: number;
+  /**
+   * Number of raw (clicked + rubber-band) points at which `derive` can already
+   * produce a renderable canonical shape, so the draw controller renders a live
+   * symbol preview instead of the bare vertex-marker outline. Lets a measure
+   * show feedback before the full `minimumUserPoints` commit threshold is
+   * reached — e.g. Area21 pads two points (first click + cursor) up to its
+   * three-point search-area shape. Must be <= `minimumUserPoints`. Defaults to
+   * `minimumUserPoints` (no early preview).
+   */
+  readonly minimumPreviewPoints?: number;
+  /**
+   * Number of trailing slots in the canonical control-point array that are
+   * NOT user-clicked spine vertices. For Axis1, this is 1 (the width handle
+   * at index N-1). Drives four behaviors in TacticalDraw:
+   *   1. New clicks insert at `length - trailingFixedSlots` (not appended).
+   *   2. Midpoint handles render only between segments inside
+   *      [0 .. length - 1 - trailingFixedSlots].
+   *   3. The "click the last added point to commit" hit test uses
+   *      `committed[length - 1 - trailingFixedSlots]`.
+   *   4. `canCommit` evaluates `length - trailingFixedSlots >= minimumUserPoints`.
+   * Defaults to 0 (the entire array is user-clicked spine). See ADR-0008.
+   */
+  readonly trailingFixedSlots?: number;
+  derive(points: readonly Position[]): Position[];
+  transform(event: AnchorTransformEvent): Position[];
+}
+//#endregion
+//#region src/metadata.d.ts
+type ControlMeasureGeometryType = Geometry["type"];
+type ControlMeasureGeometry = "point" | "line" | "area";
+declare const DRAW_RULE_IDS: readonly ["Area1", "Area7", "Area8", "Area11", "Area12", "Area15", "Area21", "Axis1", "Line1", "Line3", "Line9", "Line10", "Line23", "Line24", "Line29", "Point12"];
+type DrawRuleId = (typeof DRAW_RULE_IDS)[number];
+interface BaseParamDescriptor {
+  key: string;
+  label: string;
+  description?: string;
+  visibleWhen?: (opts: Record<string, unknown>) => boolean;
+}
+interface NumberParamDescriptor extends BaseParamDescriptor {
+  type: "number";
+  min?: number;
+  max?: number;
+  step?: number;
+  unit?: string;
+}
+interface BooleanParamDescriptor extends BaseParamDescriptor {
+  type: "boolean";
+}
+interface ColorParamDescriptor extends BaseParamDescriptor {
+  type: "color";
+}
+interface EnumParamDescriptor extends BaseParamDescriptor {
+  type: "enum";
+  options: readonly {
+    label: string;
+    value: string | number | boolean;
+  }[];
+}
+interface TextParamDescriptor extends BaseParamDescriptor {
+  type: "text";
+  placeholder?: string;
+  maxLength?: number;
+}
+type ParamDescriptor = NumberParamDescriptor | BooleanParamDescriptor | ColorParamDescriptor | TextParamDescriptor | EnumParamDescriptor;
+interface ControlMeasureMetadata {
+  id: string;
+  name: string;
+  description: string;
+  entity: string;
+  entityType: string;
+  entitySubtype?: string;
+  value: string;
+  geometry: ControlMeasureGeometry;
+  minCoordinates?: number;
+  maxCoordinates?: number;
+  geometryTypes?: readonly ControlMeasureGeometryType[];
+  drawRule?: DrawRuleId;
+  /**
+   * Resolved draw rule object (anchor contract) attached by the registry when
+   * the kind's `drawRule` id has an implementation. Consumed by the
+   * `TacticalDraw` façade to drive click accumulation during draw and
+   * vertex-snap during edit — see ADR-0005.
+   */
+  rule?: ControlMeasureDrawRule;
+  params?: readonly ParamDescriptor[];
+  /**
+   * Marks a measure that emits a text label whose pixel size should be captured
+   * once at draw-commit time (rather than re-resolved on every zoom). Hosts use
+   * this to stamp default label sizing onto the committed measure — see
+   * `withCommittedAdapterMeasureOptions` in `tactical-draw`. Keeping it on the
+   * definition means adding such a measure stays a one-file change (ADR-0013).
+   */
+  capturesLabelSize?: boolean;
+}
+//#endregion
+//#region src/define.d.ts
+/**
+ * The loosest `FeatureCollection` a control-measure generator may emit: any
+ * geometry, with per-feature properties that the renderer normalizes.
+ */
+type AnyFeatureCollection = FeatureCollection<Geometry, Record<string, unknown> | null>;
+/**
+ * A generator's call signature, constrained only by its inputs and output. The
+ * options parameter is typed `never` so that a generator with *any* concrete
+ * options type satisfies the bound — function parameters are contravariant, so
+ * `(o: BlockOptions) => …` is assignable to `(o: never) => …`. The actual
+ * options type is recovered covariantly via {@link OptsOf}, never through this
+ * bound. See ADR-0013.
+ */
+type ControlMeasureGenerator = (controlPoints: Position[], options: never) => AnyFeatureCollection;
+/**
+ * Everything that defines one control measure, co-located with its generator.
+ * `registry.ts` collects these into the single `DEFINITIONS` map, from which
+ * the `ControlMeasureId` union, `OptionsByKind`, the generator dispatch, the
+ * default options, and rule resolution are all derived rather than maintained
+ * as parallel tables. See ADR-0013.
+ */
+interface ControlMeasureDefinition<Id extends string, G extends ControlMeasureGenerator> {
+  /** Catalog metadata; `id` is pinned to the record's literal key. */
+  metadata: ControlMeasureMetadata & {
+    id: Id;
+  };
+  /** Pure generator: control points (+ options) → GeoJSON features. */
+  generator: G;
+  /** Default options, tied to the generator's own options parameter. */
+  defaultOptions: NonNullable<Parameters<G>[1]>;
+  /**
+   * Resolved draw-rule object, merged back onto metadata by the registry. The
+   * doctrinal `drawRule` spec id stays on `metadata` (ADR-0005); the registry
+   * guards that `rule` agrees with it. See ADR-0013.
+   */
+  rule?: ControlMeasureDrawRule;
+  /**
+   * Representative sample used only by the static catalog/thumbnail previews
+   * (the `/preview` subpath). Most measures omit it and fall back to a generic
+   * layout keyed off `geometry`/`minCoordinates`/`entityType`; a measure whose
+   * symbol needs special framing co-locates the override here rather than in a
+   * central per-id switch. Points are **unitless** (~`[-1, 1]`); the resolver
+   * scales them to the small degree offsets the projected-meter generators
+   * expect. `options` is type-checked against this measure's own options. See
+   * ADR-0025.
+   */
+  previewSample?: PreviewSample<NonNullable<Parameters<G>[1]>>;
+}
+/**
+ * A measure's representative preview input. Shared between the typed
+ * {@link ControlMeasureDefinition} field and the erased
+ * {@link AnyControlMeasureDefinition}; `Options` is the measure's own options
+ * type (or `unknown` once erased). See ADR-0025.
+ */
+interface PreviewSample<Options> {
+  controlPoints: readonly (readonly [number, number])[];
+  options?: Partial<Options>;
+}
+/**
+ * Extracts a definition's options type covariantly from its generator's
+ * (optional) second parameter — robust where inferring through the
+ * contravariant parameter position is not. See ADR-0013.
+ */
+type OptsOf<D> = D extends {
+  generator: (points: Position[], options?: infer O) => unknown;
+} ? O : never;
+//#endregion
+//#region src/generators/cm11-command-control-lines/boundary.d.ts
+/** Configuration options for the Boundary control measure. */
+interface BoundaryOptions {
+  /**
+   * Field B echelon. One of the keys in {@link ECHELONS} (e.g. `"battalion"`,
+   * `"division"`) or an equivalent symbol form (`"II"`, `"XX"`). `"none"`,
+   * empty, or unknown renders no glyph and leaves the line continuous.
+   * @default "battalion"
+   */
+  echelon?: string;
+  /**
+   * Echelon glyph height in meters (ground-anchored). Ignored when
+   * `echelonSizePixels` is supplied together with `metersPerPixel`.
+   * @default 750
+   */
+  echelonSize?: number;
+  /**
+   * Echelon glyph height in screen pixels (screen-anchored). Resolved to meters
+   * against `metersPerPixel`; bakes to a meter size on draw/edit commit
+   * (ADR-0020).
+   * @default 16
+   */
+  echelonSizePixels?: number;
+  /**
+   * Gap left on each side of the echelon glyph, as a ratio of the glyph height.
+   * `0` butts the line against the glyph; larger values widen the break.
+   * @default 0.3
+   */
+  echelonPadding?: number;
+  /**
+   * Meters-per-pixel at the current zoom/latitude. Stamped by the host when the
+   * measure is screen-anchored; required to resolve `echelonSizePixels` and to
+   * lock the T/AS text size to the glyph height.
+   */
+  metersPerPixel?: number;
+  /**
+   * Map zoom captured at draw-commit (`capturesLabelSize`). Forwarded onto the
+   * T/AS labels as `textSizeZoom` so a ground-anchored boundary's text scales
+   * with zoom like its meter-baked echelon glyph (maplibre).
+   */
+  labelSizeZoom?: number;
+  /**
+   * Map resolution (meters-per-pixel) captured at draw-commit
+   * (`capturesLabelSize`). Forwarded onto the T/AS labels as `textSizeResolution`
+   * so a ground-anchored boundary's text scales with zoom (OpenLayers), and used
+   * as the reference resolution that sizes the text to the glyph height.
+   */
+  labelSizeResolution?: number;
+  /**
+   * Number of label groups (echelon + designators), spaced evenly by cumulative
+   * arc length along the whole boundary. `1` places a single group at the
+   * midpoint of the total length (which may fall on any segment).
+   * @default 1
+   */
+  labelRepetitions?: number;
+  /**
+   * Spacing between label groups when `labelRepetitions > 1`, relative to an even
+   * spread across the whole boundary. `1` spreads them evenly end-to-end; `<1`
+   * clusters them toward the midpoint; `>1` pushes them toward the ends
+   * (clamped to the boundary). No effect for a single group.
+   * @default 1
+   */
+  labelSpacing?: number;
+  /** Field T (unique designator) for unit 1 — the left-of-travel side. */
+  unit1Designator?: string;
+  /** Field AS (country code) for unit 1 — the left-of-travel side. */
+  unit1Country?: string;
+  /** Field T (unique designator) for unit 2 — the right-of-travel side. */
+  unit2Designator?: string;
+  /** Field AS (country code) for unit 2 — the right-of-travel side. */
+  unit2Country?: string;
+  /**
+   * Round the boundary's corners by curving it through the control points
+   * (centripetal Catmull-Rom spline). The spline preserves the endpoints, so
+   * the line still meets its drawn anchors.
+   * @default false
+   */
+  smooth?: boolean;
+  /**
+   * Number of samples per segment when `smooth` is enabled. Higher values yield
+   * a denser, smoother curve.
+   * @default 12
+   */
+  smoothResolution?: number;
+}
+/**
+ * Creates a Boundary control measure: a polyline through `positions` carrying
+ * repeated echelon + unit-designator labels.
+ *
+ * @param positions - Boundary anchor points (≥2); the input contract is
+ *   enforced at the render seam (ADR-0014).
+ * @param options - {@link BoundaryOptions}.
+ */
+declare function createBoundary(positions: Position[], options?: BoundaryOptions): FeatureCollection<MultiLineString | MultiPolygon | Point>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/battlePosition.d.ts
+/** Configuration options for the Battle Position control measure. */
+interface BattlePositionOptions {
+  /**
+   * Field B echelon. One of the keys in the echelon vocabulary (e.g.
+   * `"battalion"`, `"division"`) or an equivalent symbol form (`"II"`, `"XX"`).
+   * `"none"`, empty, or unknown renders no glyph and leaves the boundary
+   * continuous.
+   * @default "battalion"
+   */
+  echelon?: string;
+  /**
+   * Echelon glyph height in meters (ground-anchored). Ignored when
+   * `echelonSizePixels` is supplied together with `metersPerPixel`.
+   * @default 750
+   */
+  echelonSize?: number;
+  /**
+   * Echelon glyph height in screen pixels (screen-anchored). Resolved to meters
+   * against `metersPerPixel`; bakes to a meter size on draw/edit commit
+   * (ADR-0020).
+   * @default 16
+   */
+  echelonSizePixels?: number;
+  /**
+   * Gap left on each side of the echelon glyph, as a ratio of the glyph height.
+   * `0` butts the boundary against the glyph; larger values widen the break.
+   * @default 0.3
+   */
+  echelonPadding?: number;
+  /**
+   * Slides the echelon along the boundary, as a signed fraction of the total
+   * perimeter measured from its default anchor on the bottom edge. `0` keeps it
+   * centered on the bottom; positive/negative values move it around the ring in
+   * either direction (wrapping at the seam).
+   * @default 0
+   */
+  echelonPosition?: number;
+  /**
+   * Meters-per-pixel at the current zoom/latitude. Stamped by the host when the
+   * measure is screen-anchored; required to resolve `echelonSizePixels`.
+   */
+  metersPerPixel?: number;
+  /**
+   * Round the area's corners by curving the boundary through the control points
+   * (closed centripetal Catmull-Rom spline), matching the rounded shape in the
+   * APP-6 template.
+   * @default false
+   */
+  smooth?: boolean;
+  /**
+   * Number of samples per segment when `smooth` is enabled. Higher values yield
+   * a denser, smoother curve.
+   * @default 16
+   */
+  smoothResolution?: number;
+}
+/**
+ * Creates a Battle Position control measure: a closed area through `positions`
+ * carrying a single echelon (Field B) glyph straddling its boundary — anchored
+ * to the bottom edge by default, slidable via `echelonPosition`.
+ *
+ * @param positions - Area anchor points (≥3); the input contract is enforced at
+ *   the render seam (ADR-0014).
+ * @param options - {@link BattlePositionOptions}.
+ */
+declare function createBattlePosition(positions: Position[], options?: BattlePositionOptions): FeatureCollection<MultiLineString | MultiPolygon>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/strongPoint.d.ts
+/** Configuration options for the Strong Point control measure. */
+type StrongPointOptions = BattlePositionOptions;
+/** Default options for the Strong Point control measure. */
+declare const DEFAULT_STRONG_POINT_OPTIONS: StrongPointOptions;
+/**
+ * Creates a Strong Point control measure: a Battle Position boundary/echelon
+ * with outward tics whose length and spacing are the Field B echelon height.
+ * Shares the perimeter and echelon placement with Battle Position via the
+ * `area-echelon` primitive (single source of truth for ring and gap).
+ *
+ * @param positions - Area anchor points (>=3); the input contract is enforced
+ *   at the render seam (ADR-0014).
+ * @param options - {@link StrongPointOptions}.
+ */
+declare function createStrongPoint(positions: Position[], options?: StrongPointOptions): FeatureCollection<MultiLineString | MultiPolygon>;
+//#endregion
+//#region src/generators/cm14-maneuver-lines/principalDirectionOfFire.d.ts
+/**
+ * Configuration options for the Principal Direction of Fire tactical symbol.
+ */
+interface PrincipalDirectionOfFireOptions {
+  /** Arrowhead length relative to each arm's own length (default: 0.07) */
+  arrowheadLengthRatio?: number;
+  /** Arrowhead wing spread relative to the arrowhead length (default: 0.67) */
+  arrowheadWidthRatio?: number;
+}
+declare const DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS: Required<PrincipalDirectionOfFireOptions>;
+/**
+ * Generates a GeoJSON FeatureCollection for a PRINCIPAL DIRECTION OF FIRE
+ * tactical symbol: a "V" of arms from the vertex out to the (independent) tips,
+ * each ending in an open arrowhead.
+ *
+ * Renders one arm per tip, so two points (vertex + one tip) draws the single
+ * arm being placed — the live feedback after PT 1 — and three points draws the
+ * full V. Points beyond the third are ignored (input contract, ADR-0014).
+ *
+ * @param coordinates - [PT 1 (vertex), PT 2 (tip), PT 3 (tip)]
+ * @param options - Arrowhead sizing parameters
+ */
+declare function createPrincipalDirectionOfFire(coordinates: Position[], options?: PrincipalDirectionOfFireOptions): FeatureCollection<MultiLineString, Record<string, never>>;
+//#endregion
+//#region src/generators/cm14-maneuver-lines/finalProtectiveFire.d.ts
+/**
+ * Configuration options for the Final Protective Fire tactical symbols.
+ *
+ * Identical to Principal Direction of Fire (arrowhead sizing), plus a filled
+ * "blade" running along the inside of one arm.
+ */
+interface FinalProtectiveFireOptions {
+  /** Arrowhead length relative to each arm's own length (default: 0.07) */
+  arrowheadLengthRatio?: number;
+  /** Arrowhead wing spread relative to the arrowhead length (default: 0.67) */
+  arrowheadWidthRatio?: number;
+  /**
+   * Blade height (its perpendicular reach into the inside of the V) relative
+   * to the bladed arm's own length (default: 0.03).
+   */
+  bladeHeight?: number;
+}
+declare const DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS: Required<FinalProtectiveFireOptions>;
+type FpfProps = {
+  part?: string;
+  fill?: true;
+};
+declare function createFinalProtectiveFireLeft(coordinates: Position[], options?: FinalProtectiveFireOptions): FeatureCollection<MultiLineString | Polygon, FpfProps>;
+declare function createFinalProtectiveFireRight(coordinates: Position[], options?: FinalProtectiveFireOptions): FeatureCollection<MultiLineString | Polygon, FpfProps>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/encirclement.d.ts
+/** Configuration options for the Encirclement control measure. */
+interface EncirclementOptions {
+  /**
+   * Spacing between adjacent barbs as a ratio of the symbol's mean radius;
+   * smaller values pack the barbs more densely. The barbs are then distributed
+   * evenly so they close the ring exactly.
+   * @default 0.4
+   */
+  barbSpacingRatio?: number;
+  /**
+   * Barb length (height/amplitude) as a ratio of the symbol's mean radius.
+   * @default 0.16
+   */
+  barbLengthRatio?: number;
+  /**
+   * Round the boundary by curving it through the control points (closed
+   * centripetal Catmull-Rom) before tracing the barbs.
+   * @default true
+   */
+  smooth?: boolean;
+  /**
+   * Number of samples per segment when `smooth` is enabled.
+   * @default 16
+   */
+  smoothResolution?: number;
+}
+/** Default options for the Encirclement control measure. */
+declare const DEFAULT_ENCIRCLEMENT_OPTIONS: Required<EncirclementOptions>;
+/**
+ * Creates an Encirclement tactical graphic: a complete smooth boundary ring
+ * with outward arrowhead barbs resting on it. The boundary is an unfilled
+ * Polygon; the barbs are open "V" strokes (a MultiLineString) whose base is the
+ * boundary arc itself.
+ *
+ * @param positions - Area anchor points (>=3); the input contract is enforced
+ *   at the render seam (ADR-0014).
+ * @param options - {@link EncirclementOptions}.
+ */
+declare function createEncirclement(positions: Position[], options?: EncirclementOptions): FeatureCollection<Polygon | MultiLineString>;
+//#endregion
+//#region src/projection.d.ts
+type Point2D = [number, number];
+/**
+ * Project WGS84 (Lon/Lat) to Web Mercator (Meters).
+ */
+declare const project: (lon: number, lat: number) => Point2D;
+/**
+ * Unproject Web Mercator (Meters) back to WGS84 (Lon/Lat).
+ */
+declare const unproject: (x: number, y: number) => Position;
+//#endregion
+//#region src/attack-utils.d.ts
+interface AttackOptions {
+  shaftWidthRatio?: number;
+  roundedBends?: boolean;
+  bendSegments?: number;
+}
+/**
+ * Calculates the relative metrics (longitudinal and lateral) of the width point
+ * relative to the Tip-Neck axis.
+ *
+ * @param pts - Array of positions [Tip, Neck, ..., WidthPoint]
+ * @returns { longitudinal: number, lateral: number } | null
+ */
+declare function calculateMetrics(pts: Position[]): {
+  longitudinal: number;
+  lateral: number;
+} | null;
+/**
+ * Computes an initial Width Point based on the Tip and Neck positions.
+ * It places the point perpendicular to the neck at a default distance relative to the length.
+ *
+ * @param tip - Tip position (Lon/Lat)
+ * @param neck - Neck position (Lon/Lat)
+ * @returns Width Point position (Lon/Lat)
+ */
+declare function computeInitialWidthPoint(tip: Position, neck: Position): Position;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/mainAttack.d.ts
+declare const DEFAULT_MAIN_ATTACK_OPTIONS: Required<AttackOptions>;
+type MainAttackOptions = AttackOptions;
+/**
+ * Generates a GeoJSON FeatureCollection for a Main Attack tactical symbol.
+ *
+ * The symbol consists of a single MultiLineString feature containing:
+ * 1. **Arrowhead**: A line forming a "chevron" or "roof" shape.
+ * 2. **Shaft**: Two parallel lines behind the arrow.
+ *
+ * The shaft is calculated to terminate exactly where it touches the inner walls
+ * of the arrowhead, creating a seamless connection.
+ *
+ * @param coordinates - An array of GeoJSON Positions (Lon/Lat).
+ * Minimum 3 points required.
+ * **Order matters:** * - Index 0: **Tip** (The sharp point of the arrow)
+ * - Index 1 to N-2: **Spine** (The path the shaft follows)
+ * - Index N-1: **Width Control** (Determines the width of the arrowhead)
+ * @param options - Configuration for ratios and properties.
+ * @returns A GeoJSON FeatureCollection containing a single MultiLineString.
+ */
+declare function createMainAttack(coordinates: Position[], options?: MainAttackOptions): FeatureCollection<MultiLineString>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/supportingAttack.d.ts
+type SupportingAttackOptions = AttackOptions;
+declare const DEFAULT_SUPPORTING_ATTACK_OPTIONS: Required<SupportingAttackOptions>;
+/**
+ * Generates a GeoJSON FeatureCollection for a Supporting Attack tactical symbol.
+ *
+ * The symbol differs from Main Attack in that it is a single LineString
+ * outlining the arrow shape, rather than a filled Polygon header + Shaft lines.
+ *
+ * @param coordinates - An array of GeoJSON Positions.
+ * @param options - Configuration options.
+ * @returns A GeoJSON FeatureCollection<LineString>.
+ */
+declare function createSupportingAttack(coordinates: Position[], options?: SupportingAttackOptions): FeatureCollection<LineString>;
+//#endregion
+//#region src/generators/cm99-generic-arrows/classicArrow.d.ts
+/**
+ * A plain, clean arrow for illustrations — not a doctrinal symbol. The shaft is
+ * a straight polyline through the drawn control points (Line1 contract) and the
+ * tip carries a solid triangular arrowhead. No wobble, no curve: the canonical
+ * "draw an arrow" graphic.
+ */
+/**
+ * Arrowhead silhouette:
+ * - `triangle` — solid triangle with a flat back (the default).
+ * - `barbed` — swept-back barbs with a forward notch (classic arrowhead).
+ * - `concave` — a sharper barbed head with a deep forward notch.
+ * - `diamond` — a rhombus, widest at its middle.
+ * - `harpoon` — an asymmetric single-sided barb.
+ * - `swallowtail` — barbs that sweep back into two trailing tails.
+ * - `chevron` — a thick hollow "V".
+ * - `circle` — a round dot terminator.
+ * - `tee` — a flat crossbar terminator (no point).
+ * - `open` — an unfilled "V", drawn as two strokes meeting at the tip.
+ */
+type ClassicArrowHeadStyle = "triangle" | "barbed" | "concave" | "diamond" | "harpoon" | "swallowtail" | "chevron" | "circle" | "tee" | "open";
+interface ClassicArrowOptions {
+  /** Arrowhead silhouette. */
+  arrowheadStyle?: ClassicArrowHeadStyle;
+  /** Round the shaft's corners by curving it through the control points. */
+  smooth?: boolean;
+  /** Number of samples per segment when smooth mode is enabled. */
+  smoothResolution?: number;
+  /** Arrowhead length as a fraction of the total path length. */
+  arrowheadLengthRatio?: number;
+  /** Arrowhead base width as a fraction of the total path length. */
+  arrowheadWidthRatio?: number;
+}
+/**
+ * Generates a GeoJSON FeatureCollection for the Classic Arrow: a shaft
+ * LineString (trimmed so it doesn't poke through the head) plus a head feature
+ * whose silhouette follows `arrowheadStyle` — a filled Polygon for the solid heads,
+ * or an open "V" LineString for `open`.
+ */
+declare function createClassicArrow(coordinates: Position[], options?: ClassicArrowOptions): FeatureCollection<LineString | Polygon, {
+  part: "shaft" | "head";
+  fill?: boolean;
+}>;
+//#endregion
+//#region src/generators/cm99-generic-arrows/blockArrow.d.ts
+/**
+ * A solid "block" arrow for illustrations — not a doctrinal symbol. The whole
+ * arrow is one filled polygon: a shaft band of controllable width that runs
+ * through the drawn Axis1 spine and flares into a wider triangular head at the
+ * tip. Axis1 control points are ordered `[tip, neck, ...spine, width]`.
+ */
+/**
+ * Arrowhead silhouette (all carved from the one filled body):
+ * - `triangle` — a flat-backed triangular head (the default).
+ * - `barbed` — swept-back barbs with the shaft entering at a forward notch.
+ * - `concave` — a sharper barbed head with a deeper notch.
+ * - `diamond` — a kite that flares to its widest mid-head.
+ * - `harpoon` — an asymmetric single-sided barb.
+ * - `swallowtail` — barbs that sweep back into two trailing tails.
+ * - `tee` — a flat crossbar terminator (no point).
+ */
+type BlockArrowHeadStyle = "triangle" | "barbed" | "concave" | "diamond" | "harpoon" | "swallowtail" | "tee";
+interface BlockArrowOptions {
+  /** Shaft band width as a fraction of the total path length. */
+  shaftWidth?: number;
+  /** Arrowhead silhouette. */
+  arrowheadStyle?: BlockArrowHeadStyle;
+  /** Arrowhead base width as a fraction of the total path length. */
+  arrowheadWidthRatio?: number;
+  /** Arrowhead length as a fraction of the total path length. */
+  arrowheadLengthRatio?: number;
+  /** Round the shaft's corners by curving it through the control points. */
+  smooth?: boolean;
+  /** Number of samples per segment when smooth mode is enabled. */
+  smoothResolution?: number;
+  /** Fill the body solid; when false the arrow is drawn as an outline only. */
+  filled?: boolean;
+}
+/**
+ * Generates a GeoJSON FeatureCollection for the Block Arrow: a single filled
+ * Polygon whose outline runs up the left side of the shaft, around the head
+ * (whose silhouette follows `arrowheadStyle`) to the tip and back, then down the
+ * right side of the shaft.
+ */
+declare function createBlockArrow(coordinates: Position[], options?: BlockArrowOptions): FeatureCollection<Polygon, {
+  part: "body";
+  fill: boolean;
+}>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/airborneAttack.d.ts
+type AirborneAttackOptions = AttackOptions;
+declare const DEFAULT_AIRBORNE_ATTACK_OPTIONS: Required<AirborneAttackOptions>;
+/**
+ * Generates a GeoJSON FeatureCollection for an Airborne Attack tactical symbol.
+ *
+ * The symbol is similar to Supporting Attack but features a crossover point
+ * between the shaft and the head (Points 1 and 2/Neck).
+ *
+ * @param coordinates - An array of GeoJSON Positions.
+ * @param options - Configuration options.
+ * @returns A GeoJSON FeatureCollection<LineString>.
+ */
+declare function createAirborneAttack(coordinates: Position[], options?: AirborneAttackOptions): FeatureCollection<LineString>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/attackHelicopter.d.ts
+interface AttackHelicopterOptions extends AttackOptions {
+  symbolHeightRatio?: number;
+  triangleSizeRatio?: number;
+  bottomBarWidthRatio?: number;
+  bowtieWidthRatio?: number;
+}
+declare const DEFAULT_ATTACK_HELICOPTER_OPTIONS: Required<AttackHelicopterOptions>;
+/**
+ * Generates a GeoJSON FeatureCollection for an Attack Helicopter tactical symbol.
+ *
+ * The symbol is based on the Airborne Attack (bow tie) geometry but features
+ * an additional symbol (vertical line + triangle) at the crossover point.
+ *
+ * @param coordinates - An array of GeoJSON Positions.
+ * @param options - Configuration options.
+ * @returns A GeoJSON FeatureCollection containing the main graphic and the symbol.
+ */
+declare function createAttackHelicopter(coordinates: Position[], options?: AttackHelicopterOptions): FeatureCollection<LineString | Polygon>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/supportByFire.d.ts
+interface SupportByFireOptions {
+  arrowheadWidthRatio?: number;
+  backLineLengthRatio?: number;
+  backLineAngle?: number;
+}
+declare const DEFAULT_SUPPORT_BY_FIRE_OPTIONS: Required<SupportByFireOptions>;
+/**
+ * Generates a GeoJSON FeatureCollection for a Support By Fire tactical graphic.
+ *
+ * Input:
+ * - PT1: Left Base
+ * - PT2: Right Base
+ * - PT3: Left Tip
+ * - PT4: Right Tip
+ */
+declare function createSupportByFire(coordinates: Position[], options?: SupportByFireOptions): FeatureCollection<LineString>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/attackByFire.d.ts
+interface AttackByFireOptions {
+  arrowheadWidthRatio?: number;
+  backLineLengthRatio?: number;
+  backLineAngle?: number;
+}
+declare const DEFAULT_ATTACK_BY_FIRE_OPTIONS: Required<AttackByFireOptions>;
+/**
+ * Generates a GeoJSON FeatureCollection for an Attack By Fire tactical graphic.
+ *
+ * Input:
+ * - PT1: Arrow Tip (Target)
+ * - PT2: Left Base
+ * - PT3: Right Base
+ *
+ * Logic:
+ * - Shaft: Midpoint(PT2, PT3) -> PT1
+ * - Base Line: PT2 -> PT3
+ * - Wings: Splayed out from PT2 and PT3
+ */
+declare function createAttackByFire(coordinates: Position[], options?: AttackByFireOptions): FeatureCollection<LineString>;
+//#endregion
+//#region src/generators/cm14-maneuver-lines/flot.d.ts
+/**
+ * Configuration options for the FLOT (Forward Line of Own Troops) geometry.
+ */
+interface FLOTOptions {
+  /**
+   * The radius of the semicircular arcs in meters.
+   * Semicircles are placed tangent to each other (diameter = 2 * radius).
+   * This is ignored if radiusPixels is provided along with metersPerPixel.
+   * @default 50
+   */
+  radius?: number;
+  /**
+   * The radius of the semi-circular arcs in pixels.
+   * When provided along with metersPerPixel, the actual meter radius is calculated
+   * dynamically to maintain consistent visual size on screen.
+   * Takes precedence over radius when metersPerPixel is also provided.
+   * @default 10
+   */
+  radiusPixels?: number;
+  /**
+   * The meters-per-pixel ratio at the current zoom level and latitude.
+   * Required when using radiusPixels for zoom-aware sizing.
+   * Can be obtained from the map view's resolution or calculated using getMetersPerPixel().
+   */
+  metersPerPixel?: number;
+  /**
+   * The number of points used to render each individual semi-circle.
+   * Higher values create smoother arcs.
+   * @default 16
+   */
+  resolution?: number;
+}
+/**
+ * Default options for the FLOT graphic.
+ */
+declare const DEFAULT_FLOT_OPTIONS: Required<Omit<FLOTOptions, "metersPerPixel">>;
+/**
+ * Creates a FLOT (Forward Line of Own Troops) tactical graphic.
+ *
+ * Generates a scalloped/arc line representing the forward edge of friendly forces.
+ * The line consists of semi-circular arcs that bulge perpendicular to the base path,
+ * creating a distinctive visual pattern used in military tactical graphics.
+ *
+ * @param positions - Array of GeoJSON positions defining the base path
+ * @param options - Configuration options for the graphic
+ * @returns A GeoJSON FeatureCollection containing the scalloped LineString
+ *
+ * @example
+ * ```typescript
+ * const flot = createFLOT(
+ *   [[-122.4194, 37.7749], [-122.4100, 37.7800], [-122.4000, 37.7750]],
+ *   { radius: 100, resolution: 20 }
+ * );
+ * ```
+ */
+declare function createFLOT(positions: Position[], options?: FLOTOptions): FeatureCollection<LineString>;
+//#endregion
+//#region src/generators/cm34-mission-tasks/block.d.ts
+interface BlockMissionTaskOptions {
+  /** Gap for the 'B' label as a ratio of the front length (default: 0.2) */
+  labelGapRatio?: number;
+  /** Label height in CSS pixels at the draw/reference zoom. */
+  labelSizePixels?: number;
+  /** Map zoom at which labelSizePixels was captured. */
+  labelSizeZoom?: number;
+  /** Map resolution at which labelSizePixels was captured. */
+  labelSizeResolution?: number;
+}
+declare const DEFAULT_BLOCK_MISSION_TASK_OPTIONS: Required<Omit<BlockMissionTaskOptions, "labelSizePixels" | "labelSizeZoom" | "labelSizeResolution">>;
+/**
+ * Generates a GeoJSON FeatureCollection for a BLOCK mission task symbol (340100).
+ *
+ * Uses the same T-shape geometry as the protection-area Block symbol, with a
+ * "B" label centered on the shaft.
+ *
+ * @param coordinates - [PT. 1, PT. 2, optional PT. 3] as Position arrays
+ * @param options - Configuration options
+ * @returns GeoJSON FeatureCollection containing MultiLineString and Point features
+ */
+declare function createBlockMissionTaskSymbol(coordinates: Position[], options?: BlockMissionTaskOptions): FeatureCollection<MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm34-mission-tasks/breach.d.ts
+/**
+ * Configuration options for the BREACH tactical symbol.
+ */
+interface BreachOptions {
+  /** Tick mark length ratio relative to front opening (default: 0.15) */
+  tickLengthRatio?: number;
+  /** Tick mark angle in degrees from perpendicular (default: 45) */
+  tickAngle?: number;
+  /** Gap for the 'B' label as a ratio of the front length (default: 0.2) */
+  labelGapRatio?: number;
+  /** Label height in CSS pixels at the draw/reference zoom. */
+  labelSizePixels?: number;
+  /** Map zoom at which labelSizePixels was captured. */
+  labelSizeZoom?: number;
+  /** Map resolution at which labelSizePixels was captured. */
+  labelSizeResolution?: number;
+}
+/**
+ * Default options for the BREACH symbol.
+ */
+declare const DEFAULT_BREACH_OPTIONS: Required<Omit<BreachOptions, "labelSizePixels" | "labelSizeZoom" | "labelSizeResolution">>;
+/**
+ * Generates a GeoJSON FeatureCollection for a BREACH mission task symbol (340200).
+ *
+ * A three-sided bracket (see {@link createBracketSymbol}) whose front opening
+ * endpoints terminate in tick marks pointing **outward** (away from the rear
+ * "B" line).
+ *
+ * @param coordinates - [PT. 1, PT. 2, PT. 3] as Position arrays
+ * @param options - Configuration options
+ * @returns GeoJSON FeatureCollection containing MultiLineString and Point features
+ */
+declare function createBreachSymbol(coordinates: Position[], options?: BreachOptions): FeatureCollection<MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm34-mission-tasks/bypass.d.ts
+/**
+ * Configuration options for the BYPASS tactical symbol.
+ */
+interface BypassOptions {
+  /** Arrowhead length ratio relative to front opening (default: 0.2) */
+  arrowheadLengthRatio?: number;
+  /** Gap for the 'B' label as a ratio of the front length (default: 0.2) */
+  labelGapRatio?: number;
+  /** Label height in CSS pixels at the draw/reference zoom. */
+  labelSizePixels?: number;
+  /** Map zoom at which labelSizePixels was captured. */
+  labelSizeZoom?: number;
+  /** Map resolution at which labelSizePixels was captured. */
+  labelSizeResolution?: number;
+}
+/**
+ * Default options for the BYPASS symbol.
+ */
+declare const DEFAULT_BYPASS_OPTIONS: Required<Omit<BypassOptions, "labelSizePixels" | "labelSizeZoom" | "labelSizeResolution">>;
+/**
+ * Generates a GeoJSON FeatureCollection for a BYPASS mission task symbol (340300).
+ *
+ * A three-sided bracket (see {@link createBracketSymbol}) with a "B" label on
+ * the rear line, whose front opening endpoints terminate in outward-flaring
+ * chevron arrowheads instead of tick marks.
+ *
+ * @param coordinates - [PT. 1, PT. 2, PT. 3] as Position arrays
+ * @param options - Configuration options
+ * @returns GeoJSON FeatureCollection containing MultiLineString and Point features
+ */
+declare function createBypassSymbol(coordinates: Position[], options?: BypassOptions): FeatureCollection<MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm34-mission-tasks/canalize.d.ts
+/**
+ * Configuration options for the CANALIZE tactical symbol.
+ */
+interface CanalizeOptions {
+  /** Tick mark length ratio relative to front opening (default: 0.15) */
+  tickLengthRatio?: number;
+  /** Tick mark angle in degrees from perpendicular (default: 45) */
+  tickAngle?: number;
+  /** Gap for the 'C' label as a ratio of the front length (default: 0.2) */
+  labelGapRatio?: number;
+  /** Label height in CSS pixels at the draw/reference zoom. */
+  labelSizePixels?: number;
+  /** Map zoom at which labelSizePixels was captured. */
+  labelSizeZoom?: number;
+  /** Map resolution at which labelSizePixels was captured. */
+  labelSizeResolution?: number;
+}
+/**
+ * Default options for the CANALIZE symbol.
+ */
+declare const DEFAULT_CANALIZE_OPTIONS: Required<Omit<CanalizeOptions, "labelSizePixels" | "labelSizeZoom" | "labelSizeResolution">>;
+/**
+ * Generates a GeoJSON FeatureCollection for a CANALIZE mission task symbol (340400).
+ *
+ * A three-sided bracket (see {@link createBracketSymbol}) whose front opening
+ * endpoints terminate in tick marks pointing **inward** (toward the rear "C"
+ * line), opposite BREACH's outward-facing ticks.
+ *
+ * @param coordinates - [PT. 1, PT. 2, PT. 3] as Position arrays
+ * @param options - Configuration options
+ * @returns GeoJSON FeatureCollection containing MultiLineString and Point features
+ */
+declare function createCanalizeSymbol(coordinates: Position[], options?: CanalizeOptions): FeatureCollection<MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm34-mission-tasks/clear.d.ts
+/**
+ * Configuration options for the CLEAR tactical mission task symbol.
+ */
+interface ClearOptions {
+  /**
+   * Padding between the vertical line's endpoints and the outer arrows, as a
+   * ratio of the symbol height. Insets the top and bottom arrows so they sit
+   * clear of PT. 1 / PT. 2 (default: 0.15).
+   */
+  arrowInsetRatio?: number;
+  /** Arrowhead depth (toward the rear) as a ratio of the symbol height (default: 0.15). */
+  arrowheadLengthRatio?: number;
+  /** Arrowhead width (along the vertical line) as a ratio of the symbol height (default: 0.2). */
+  arrowheadWidthRatio?: number;
+  /** Gap for the 'C' label as a ratio of the shaft length (default: 0.2). */
+  labelGapRatio?: number;
+  /** Label height in CSS pixels at the draw/reference zoom. */
+  labelSizePixels?: number;
+  /** Map zoom at which labelSizePixels was captured. */
+  labelSizeZoom?: number;
+  /** Map resolution at which labelSizePixels was captured. */
+  labelSizeResolution?: number;
+}
+/**
+ * Default options for the CLEAR symbol.
+ */
+declare const DEFAULT_CLEAR_OPTIONS: Required<Omit<ClearOptions, "labelSizePixels" | "labelSizeZoom" | "labelSizeResolution">>;
+/**
+ * Generates a GeoJSON FeatureCollection for a CLEAR mission task symbol (340500).
+ *
+ * A vertical line (PT. 1 → PT. 2) with three arrows pointing at it,
+ * perpendicular to the line. The arrows come from the rear — the side PT. 3
+ * sits on — and their tips touch the vertical line; each carries a shaft
+ * reaching back to the rear. The arrows are evenly spaced along the line, so
+ * the middle arrow's tip sits at the midpoint of the vertical line and its
+ * shaft carries the 'C' glyph. The arrows stay perpendicular to the vertical
+ * line at any rotation.
+ *
+ * Input Points:
+ * - PT. 1: Top endpoint of the vertical line
+ * - PT. 2: Bottom endpoint of the vertical line — defines height with PT. 1
+ * - PT. 3: Rear point — defines the shaft length (and which side the arrows
+ *   come from)
+ *
+ * @param coordinates - [PT. 1, PT. 2, PT. 3] as Position arrays
+ * @param options - Configuration options
+ * @returns GeoJSON FeatureCollection containing MultiLineString and Point features
+ */
+declare function createClearSymbol(coordinates: Position[], options?: ClearOptions): FeatureCollection<MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm34-mission-tasks/delay.d.ts
+interface DelayOptions {
+  /** Arrowhead depth as a ratio of the straight-line length (default: 0.12). */
+  arrowheadLengthRatio?: number;
+  /** Arrowhead width as a ratio of the straight-line length (default: 0.12). */
+  arrowheadWidthRatio?: number;
+  /** Gap for the 'D' label as a ratio of the straight-line length (default: 0.18). */
+  labelGapRatio?: number;
+  /** Number of segments used to approximate the 180-degree arc (default: 32). */
+  arcSegments?: number;
+  /** Label height in CSS pixels at the draw/reference zoom. */
+  labelSizePixels?: number;
+  /** Map zoom at which labelSizePixels was captured. */
+  labelSizeZoom?: number;
+  /** Map resolution at which labelSizePixels was captured. */
+  labelSizeResolution?: number;
+}
+declare const DEFAULT_DELAY_OPTIONS: Required<Omit<DelayOptions, "labelSizePixels" | "labelSizeZoom" | "labelSizeResolution">>;
+declare function createDelaySymbol(coordinates: Position[], options?: DelayOptions): FeatureCollection<MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm34-mission-tasks/isolate.d.ts
+/**
+ * Configuration options for the ISOLATE tactical mission task symbol.
+ */
+interface IsolateOptions {
+  /** Angular size of the opening on the friendly side, in degrees (default: 30). */
+  openingAngle?: number;
+  /** Number of inward-pointing arrowhead barbs spaced around the closed arc (default: 9). */
+  barbCount?: number;
+  /** Barb length as a ratio of the symbol radius (default: 0.18). */
+  barbLengthRatio?: number;
+}
+/**
+ * Generates a GeoJSON FeatureCollection for an ISOLATE mission task symbol (341500).
+ *
+ * A near-complete circle centered on PT. 1 whose radius reaches PT. 2. The arc
+ * starts (bare) at PT. 2's bearing and sweeps clockwise around the closed
+ * portion to a single arrow tip at the far end; the wedge-shaped gap (default
+ * 30°) between that arrow tip and PT. 2 is the opening — the "friendly side".
+ * Inward-pointing arrowhead barbs are spaced along the closed arc, set in from
+ * both ends so they never touch PT. 2 or the arrow tip, conveying the
+ * sealing-off of the enclosed force. Unlike the bracket mission tasks, isolate
+ * carries no glyph label.
+ *
+ * Input Points:
+ * - PT. 1: Center point
+ * - PT. 2: Start point — fixes the radius and the bearing of the opening
+ *
+ * @param coordinates - [PT. 1, PT. 2] as Position arrays
+ * @param options - Configuration options
+ * @returns GeoJSON FeatureCollection containing a single MultiLineString feature
+ */
+declare function createIsolateSymbol(coordinates: Position[], options?: IsolateOptions): FeatureCollection<MultiLineString>;
+//#endregion
+//#region src/generators/cm29-protection-lines/antitankDitch.d.ts
+interface AntitankDitchOptions {
+  /**
+   * The tooth depth in meters. Target tooth spacing is roughly 1.15x this depth.
+   * Ignored when toothHeightPixels is provided with metersPerPixel.
+   * @default 50
+   */
+  toothHeight?: number;
+  /**
+   * The tooth depth in pixels. When provided with metersPerPixel, the meter
+   * size is calculated dynamically to maintain a consistent visual size.
+   * @default 10
+   */
+  toothHeightPixels?: number;
+  /**
+   * The target base span of each triangular tooth as a multiple of tooth depth.
+   * Lower values make sharper, denser teeth; higher values make flatter teeth.
+   * @default 1.15
+   */
+  toothWidthRatio?: number;
+  /**
+   * The meters-per-pixel ratio at the current zoom level and latitude. Required
+   * when using toothHeightPixels for zoom-aware sizing.
+   */
+  metersPerPixel?: number;
+}
+declare const DEFAULT_ANTITANK_DITCH_OPTIONS: Required<Omit<AntitankDitchOptions, "metersPerPixel">>;
+declare function createAntitankDitchUnderConstruction(positions: Position[], options?: AntitankDitchOptions): FeatureCollection<MultiLineString, {
+  part: "ditch";
+}>;
+declare function createAntitankDitchCompleted(positions: Position[], options?: AntitankDitchOptions): FeatureCollection<MultiPolygon, {
+  part: "teeth";
+  fill: boolean;
+}>;
+//#endregion
+//#region src/generators/cm29-protection-lines/antitankWall.d.ts
+interface AntitankWallOptions extends AntitankDitchOptions {
+  /**
+   * The total gap between consecutive tooth bases as a multiple of tooth base
+   * width. Use 0 for touching teeth; higher values create wider gaps.
+   * @default 1.35
+   */
+  toothSpacingRatio?: number;
+}
+declare const DEFAULT_ANTITANK_WALL_OPTIONS: Required<Omit<AntitankWallOptions, "metersPerPixel">>;
+declare function createAntitankWall(positions: Position[], options?: AntitankWallOptions): FeatureCollection<MultiLineString, {
+  part: "wall";
+}>;
+//#endregion
+//#region src/generators/cm29-protection-lines/fortifiedLine.d.ts
+/**
+ * Configuration options for the Fortified Line geometry.
+ */
+interface FortifiedLineOptions {
+  /**
+   * The size of the square teeth in meters.
+   * This controls both the width and height of the castellated pattern.
+   * This is ignored if sizePixels is provided along with metersPerPixel.
+   * @default 50
+   */
+  size?: number;
+  /**
+   * The size of the square teeth in pixels.
+   * When provided along with metersPerPixel, the actual meter size is calculated
+   * dynamically to maintain consistent visual size on screen.
+   * Takes precedence over size when metersPerPixel is also provided.
+   * @default 10
+   */
+  sizePixels?: number;
+  /**
+   * The meters-per-pixel ratio at the current zoom level and latitude.
+   * Required when using sizePixels for zoom-aware sizing.
+   */
+  metersPerPixel?: number;
+  /**
+   * Round the line's corners by curving the base path through the control
+   * points (centripetal Catmull-Rom spline) before generating the castellated
+   * teeth, matching the rounded shape option on the Fortified Area and Battle
+   * Position measures. With fewer than three control points the path is left
+   * unchanged (a single segment cannot be smoothed).
+   * @default false
+   */
+  smooth?: boolean;
+  /**
+   * Number of samples per segment when `smooth` is enabled. Higher values yield
+   * a denser, smoother curve.
+   * @default 16
+   */
+  smoothResolution?: number;
+}
+/**
+ * Default options for the Fortified Line graphic.
+ */
+declare const DEFAULT_FORTIFIED_LINE_OPTIONS: Required<Omit<FortifiedLineOptions, "metersPerPixel">>;
+/**
+ * Creates a Fortified Line tactical graphic.
+ *
+ * Generates a castellated/square-wave line representing a fortified line.
+ * The line consists of square "teeth" that project perpendicular to the base path.
+ *
+ * @param positions - Array of GeoJSON positions defining the base path
+ * @param options - Configuration options for the graphic
+ * @returns A GeoJSON FeatureCollection containing the castellated LineString
+ */
+declare function createFortifiedLine(positions: Position[], options?: FortifiedLineOptions): FeatureCollection<LineString>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/fortifiedArea.d.ts
+/**
+ * Configuration options for the Fortified Area. Inherits the Fortified Line
+ * options (including `smooth`/`smoothResolution`) unchanged; the area applies
+ * the smoothing as a closed Catmull-Rom ring rather than an open spline.
+ */
+type FortifiedAreaOptions = FortifiedLineOptions;
+declare const DEFAULT_FORTIFIED_AREA_OPTIONS: Required<Omit<FortifiedLineOptions, "metersPerPixel">>;
+/**
+ * Creates a Fortified Area tactical graphic.
+ *
+ * Generates a polygon with a castellated/square-wave boundary representing a fortified area.
+ * The boundary consists of square "teeth" that project perpendicular to the path.
+ *
+ * @param positions - Array of GeoJSON positions defining the area boundary.
+ *                    The first and last positions should match to close the polygon,
+ *                    or it will be closed automatically.
+ * @param options - Configuration options for the graphic
+ * @returns A GeoJSON FeatureCollection containing the castellated Polygon
+ */
+declare function createFortifiedArea(positions: Position[], options?: FortifiedAreaOptions): FeatureCollection<Polygon>;
+//#endregion
+//#region src/generators/cm27-protection-areas/block.d.ts
+type BlockOptions = Record<never, never>;
+declare const DEFAULT_BLOCK_OPTIONS: BlockOptions;
+/**
+ * Generates a GeoJSON FeatureCollection for a "Block" tactical symbol (T-shape).
+ *
+ * @param coordinates - An array of GeoJSON Positions (Lon/Lat).
+ * Expects exactly 3 points:
+ * - PT1 & PT2: Endpoints of the vertical line.
+ * - PT3: Defines the endpoint of the horizontal line (stem).
+ * @param options - Configuration options.
+ * @returns A GeoJSON FeatureCollection containing a LineString.
+ */
+declare function createBlock(coordinates: Position[], _options?: BlockOptions): FeatureCollection<LineString>;
+//#endregion
+//#region src/generators/cm27-protection-areas/disrupt.d.ts
+interface DisruptOptions {
+  middleArrowLengthRatio?: number;
+  bottomArrowLengthRatio?: number;
+  shaftLengthRatio?: number;
+  arrowheadLengthRatio?: number;
+  arrowheadWidthRatio?: number;
+}
+declare const DEFAULT_DISRUPT_OPTIONS: Required<DisruptOptions>;
+/**
+ * Generates a GeoJSON FeatureCollection for a DISRUPT tactical symbol.
+ *
+ * Input:
+ * - PT1: Top endpoint of the vertical spine
+ * - PT2: Bottom endpoint of the vertical spine
+ * - PT3: Reference point used to determine the longest-arrow offset
+ *
+ * Geometry:
+ * - Spine: PT1 -> PT2
+ * - PT2 -> PT1 defines the baseline orientation; arrow direction is constrained to its perpendicular axis
+ * - PT3 is decomposed and projected onto the perpendicular axis through PT1 to derive a valid longest-arrow tip
+ * - Three arrows placed at PT1, midpoint(PT1, PT2), and PT2
+ * - Center shaft extends opposite arrow direction from midpoint with the same length as the middle arrow
+ * - Top arrow is longest
+ * - Middle and bottom arrows are proportional to the longest arrow
+ * - Arrow heads are returned as filled triangle polygons
+ */
+declare function createDisrupt(coordinates: Position[], options?: DisruptOptions): FeatureCollection<MultiLineString | MultiPolygon>;
+//#endregion
+//#region src/generators/cm27-protection-areas/fix.d.ts
+interface FixOptions {
+  arrowheadAngle?: number;
+  arrowheadLengthRatio?: number;
+  endSegmentRatio?: number;
+}
+declare const DEFAULT_FIX_OPTIONS: Required<FixOptions>;
+/**
+ * Generates a GeoJSON FeatureCollection for a FIX tactical symbol.
+ *
+ * Input:
+ * - PT1: Arrow tip end
+ * - PT2: Opposite end
+ *
+ * Notes:
+ * - Requires exactly two points.
+ * - Produces one MultiLineString feature containing the zigzag body and open arrowhead wings.
+ */
+declare function createFix(coordinates: Position[], options?: FixOptions): FeatureCollection<MultiLineString>;
+//#endregion
+//#region src/generators/cm27-protection-areas/turn.d.ts
+interface TurnOptions {
+  arrowheadLengthRatio?: number;
+  arrowheadWidthRatio?: number;
+  arcSegments?: number;
+}
+declare const DEFAULT_TURN_OPTIONS: Required<TurnOptions>;
+/**
+ * Generates a quarter-circle shaft from PT2 (rear) to the arrowhead base.
+ * The arrowhead continues tangent to the arc and places its tip at PT1.
+ * PT3 selects which side of the PT2 -> PT1 chord contains the arc.
+ */
+declare function createTurn(coordinates: Position[], options?: TurnOptions): FeatureCollection<MultiLineString | MultiPolygon>;
+//#endregion
+//#region src/generators/cm27-protection-areas/obstacleBypassEasy.d.ts
+interface ObstacleBypassEasyOptions {
+  arrowheadLengthRatio?: number;
+  arrowheadWidthRatio?: number;
+  defaultLengthRatio?: number;
+}
+declare const DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS: Required<ObstacleBypassEasyOptions>;
+/**
+ * Generates a GeoJSON FeatureCollection for an "Obstacle Bypass Easy" symbol.
+ *
+ * Input:
+ * - PT1 and PT2 define the tips of the two arrowheads (opening and symbol height)
+ * - PT3 defines signed symbol length along the perpendicular axis through midpoint(PT1, PT2)
+ *
+ * Geometry:
+ * - Rear line is parallel to opening(PT1-PT2) and has equal length
+ * - Two side rails run from rear endpoints to the arrowheads and are parallel to each other
+ * - Rear line is perpendicular to both side rails
+ * - Arrow heads are filled triangle polygons at PT1 and PT2
+ */
+declare function createObstacleBypassEasy(coordinates: Position[], options?: ObstacleBypassEasyOptions): FeatureCollection<MultiLineString | MultiPolygon>;
+//#endregion
+//#region src/generators/cm27-protection-areas/obstacleBypassDifficult.d.ts
+interface ObstacleBypassDifficultOptions {
+  arrowheadLengthRatio?: number;
+  arrowheadWidthRatio?: number;
+  defaultLengthRatio?: number;
+  zigzagAmplitudeRatio?: number;
+  zigzagSpacingRatio?: number;
+}
+declare const DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS: Required<ObstacleBypassDifficultOptions>;
+declare function createObstacleBypassDifficult(coordinates: Position[], options?: ObstacleBypassDifficultOptions): FeatureCollection<MultiLineString | MultiPolygon>;
+//#endregion
+//#region src/generators/cm27-protection-areas/obstacleBypassImpossible.d.ts
+interface ObstacleBypassImpossibleOptions {
+  arrowheadLengthRatio?: number;
+  arrowheadWidthRatio?: number;
+  defaultLengthRatio?: number;
+  rearBarLengthRatio?: number;
+  rearGapRatio?: number;
+}
+declare const DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS: Required<ObstacleBypassImpossibleOptions>;
+/**
+ * Generates a GeoJSON FeatureCollection for an "Obstacle Bypass Impossible" symbol.
+ *
+ * Input:
+ * - PT1 and PT2 define the tips of the two arrowheads (opening and symbol height)
+ * - PT3 defines signed symbol length along the perpendicular axis through midpoint(PT1, PT2)
+ *
+ * Geometry:
+ * - Same base as obstacle bypass easy
+ * - Rear line has two short perpendicular bars on the rear side
+ */
+declare function createObstacleBypassImpossible(coordinates: Position[], options?: ObstacleBypassImpossibleOptions): FeatureCollection<MultiLineString | MultiPolygon>;
+//#endregion
+//#region src/registry.d.ts
+/**
+ * The single source of truth for the catalog: one **control measure
+ * definition** record per measure, co-located with its generator and collected
+ * here. The `ControlMeasureId` union, `OptionsByKind`, the generator dispatch,
+ * the default options, and rule resolution are all *derived* from this map
+ * rather than maintained as parallel tables. Adding a measure is a one-file
+ * change plus one line here. See ADR-0013.
+ */
+declare const DEFINITIONS: {
+  boundary: ControlMeasureDefinition<"boundary", typeof createBoundary>;
+  "battle-position": ControlMeasureDefinition<"battle-position", typeof createBattlePosition>;
+  "strong-point": ControlMeasureDefinition<"strong-point", typeof createStrongPoint>;
+  ambush: ControlMeasureDefinition<"ambush", (controlPoints: import("geojson").Position[], options?: AmbushOptions) => import("geojson").FeatureCollection<import("geojson").MultiLineString, Record<string, never>>>;
+  "principal-direction-of-fire": ControlMeasureDefinition<"principal-direction-of-fire", typeof createPrincipalDirectionOfFire>;
+  "final-protective-fire-left": ControlMeasureDefinition<"final-protective-fire-left", typeof createFinalProtectiveFireLeft>;
+  "final-protective-fire-right": ControlMeasureDefinition<"final-protective-fire-right", typeof createFinalProtectiveFireRight>;
+  "search-area": ControlMeasureDefinition<"search-area", (controlPoints: import("geojson").Position[], options?: TacticalArrowOptions) => import("geojson").FeatureCollection<import("geojson").MultiLineString | import("geojson").MultiPolygon, {
+    part: "shaft" | "head";
+    fill?: boolean;
+  }>>;
+  encirclement: ControlMeasureDefinition<"encirclement", typeof createEncirclement>;
+  "main-attack": ControlMeasureDefinition<"main-attack", typeof createMainAttack>;
+  "supporting-attack": ControlMeasureDefinition<"supporting-attack", typeof createSupportingAttack>;
+  "classic-arrow": ControlMeasureDefinition<"classic-arrow", typeof createClassicArrow>;
+  "block-arrow": ControlMeasureDefinition<"block-arrow", typeof createBlockArrow>;
+  "airborne-attack": ControlMeasureDefinition<"airborne-attack", typeof createAirborneAttack>;
+  "attack-helicopter": ControlMeasureDefinition<"attack-helicopter", typeof createAttackHelicopter>;
+  "support-by-fire": ControlMeasureDefinition<"support-by-fire", typeof createSupportByFire>;
+  "attack-by-fire": ControlMeasureDefinition<"attack-by-fire", typeof createAttackByFire>;
+  flot: ControlMeasureDefinition<"flot", typeof createFLOT>;
+  "block-mission-task": ControlMeasureDefinition<"block-mission-task", typeof createBlockMissionTaskSymbol>;
+  breach: ControlMeasureDefinition<"breach", typeof createBreachSymbol>;
+  bypass: ControlMeasureDefinition<"bypass", typeof createBypassSymbol>;
+  canalize: ControlMeasureDefinition<"canalize", typeof createCanalizeSymbol>;
+  clear: ControlMeasureDefinition<"clear", typeof createClearSymbol>;
+  delay: ControlMeasureDefinition<"delay", typeof createDelaySymbol>;
+  isolate: ControlMeasureDefinition<"isolate", typeof createIsolateSymbol>;
+  "antitank-ditch-under-construction": ControlMeasureDefinition<"antitank-ditch-under-construction", typeof createAntitankDitchUnderConstruction>;
+  "antitank-ditch-completed": ControlMeasureDefinition<"antitank-ditch-completed", typeof createAntitankDitchCompleted>;
+  "antitank-wall": ControlMeasureDefinition<"antitank-wall", typeof createAntitankWall>;
+  "fortified-line": ControlMeasureDefinition<"fortified-line", typeof createFortifiedLine>;
+  "fortified-area": ControlMeasureDefinition<"fortified-area", typeof createFortifiedArea>;
+  block: ControlMeasureDefinition<"block", typeof createBlock>;
+  disrupt: ControlMeasureDefinition<"disrupt", typeof createDisrupt>;
+  fix: ControlMeasureDefinition<"fix", typeof createFix>;
+  turn: ControlMeasureDefinition<"turn", typeof createTurn>;
+  "obstacle-bypass-easy": ControlMeasureDefinition<"obstacle-bypass-easy", typeof createObstacleBypassEasy>;
+  "obstacle-bypass-difficult": ControlMeasureDefinition<"obstacle-bypass-difficult", typeof createObstacleBypassDifficult>;
+  "obstacle-bypass-impossible": ControlMeasureDefinition<"obstacle-bypass-impossible", typeof createObstacleBypassImpossible>;
+};
+type Definitions = typeof DEFINITIONS;
+/** Stable string id of a control measure — the keys of {@link DEFINITIONS}. */
+type ControlMeasureId = keyof Definitions;
+/**
+ * The discriminant for {@link ControlMeasure}. Identical to
+ * {@link ControlMeasureId}; kept as a distinct name for the `<K extends
+ * ControlMeasureKind>` generics threaded through rendering and edit sessions.
+ */
+type ControlMeasureKind = ControlMeasureId;
+/** Strips the internal `validationMode` knob from a public options surface. */
+type PublicOptions<T> = Omit<T, "validationMode">;
+/**
+ * The per-kind public options map, derived covariantly from each definition's
+ * generator (see {@link OptsOf}). Empty-options kinds resolve to `{}` — exactly
+ * as loose as the former hand-written table. See ADR-0013.
+ */
+type OptionsByKind = { [K in keyof Definitions]: PublicOptions<OptsOf<Definitions[K]>> };
+/** Insertion-ordered list of every control-measure id. */
+declare const CONTROL_MEASURE_IDS: readonly ControlMeasureId[];
+declare const CONTROL_MEASURE_METADATA: Readonly<Record<ControlMeasureId, ControlMeasureMetadata>>;
+declare function listControlMeasureMetadata(): readonly ControlMeasureMetadata[];
+declare function getControlMeasureMetadata(id: ControlMeasureId): ControlMeasureMetadata;
+declare function getControlMeasureMetadataByValue(value: string): ControlMeasureMetadata | undefined;
+declare function getDefaultOptions<K extends ControlMeasureKind>(kind: K): OptionsByKind[K];
+//#endregion
+//#region src/style.d.ts
+/**
+ * Framework-agnostic style hints attached to a `ControlMeasure`.
+ *
+ * Mirrors the per-feature subset of what map adapters render. The renderer
+ * fans these into each emitted feature's `properties.style` ([[StyleHints]]).
+ * Adapters merge them over their layer-level style; generator-emitted hints
+ * on individual features win over both.
+ */
+interface ControlMeasureStyle {
+  /**
+   * The single symbol color. Control measures are monocolor: one color paints
+   * every part, stroked or filled. Input-only — resolved into concrete
+   * `strokeColor` / `fillColor` per feature by the renderer and never emitted
+   * on output. `strokeColor` / `fillColor` act as optional per-channel
+   * overrides. See ADR-0011.
+   */
+  color?: string;
+  strokeColor?: string;
+  strokeWidth?: number;
+  strokeDash?: number[];
+  fillColor?: string;
+}
+//#endregion
+//#region src/instance.d.ts
+interface ControlMeasure<K extends ControlMeasureKind = ControlMeasureKind> {
+  id: string;
+  kind: K;
+  controlPoints: Position[];
+  options?: OptionsByKind[K];
+  style?: ControlMeasureStyle;
+  properties?: Record<string, unknown>;
+  schemaVersion?: 1;
+}
+declare function isKind<K extends ControlMeasureKind>(cm: ControlMeasure, kind: K): cm is ControlMeasure<K>;
+/**
+ * Deep-clone a `ControlMeasure` so held references survive mutations to the
+ * original (and vice versa). Used by the session façade to build the
+ * `measure` half of `ControlMeasureSnapshot`. Nested values inside
+ * `options`, `style`, and `properties` are cloned too — `properties` is
+ * `Record<string, unknown>` and may carry arbitrary host metadata, so a
+ * shallow copy would leak shared references.
+ *
+ * Backed by `structuredClone`: only structured-cloneable values are
+ * supported (no functions, DOM nodes, class instances). Absent optional
+ * fields stay absent on the clone.
+ */
+declare function cloneControlMeasure<K extends ControlMeasureKind>(cm: ControlMeasure<K>): ControlMeasure<K>;
+//#endregion
+//#region src/rendered.d.ts
+/**
+ * Per-feature style hints carried on `properties.style`.
+ *
+ * These are *resolved*: `renderControlMeasure` cascades `graphicsStyle` →
+ * `cm.style` → any generator pattern hint, then expands the monocolor `color`
+ * into concrete `strokeColor` / `fillColor` per feature (see ADR-0011 and
+ * `resolveSymbolColor`). Output therefore carries concrete colors, never the
+ * input-only `color` key, and a `fillColor` only on parts the generator
+ * marked filled.
+ *
+ * Generators contribute paint *role* and *pattern* (a part is filled; a
+ * sub-line is dashed regardless of the user's stroke), never a hue. Adapters
+ * merge the resulting `StyleHints` over their layer-level style at draw time.
+ */
+interface StyleHints extends ControlMeasureStyle {}
+/**
+ * Per-feature properties emitted by `renderControlMeasure`.
+ *
+ * Stable-id contract — every feature produced by the renderer has:
+ *  - `feature.id` of the form `${cmId}:${part}:${index}`
+ *  - `properties.part` matching the `part` segment of the id
+ *  - `properties.index` matching the `index` segment of the id
+ *
+ * Adapters rely on this contract to diff renders in place without keeping
+ * their own bookkeeping. Use `controlMeasureIdFromFeature` to recover the
+ * `cmId` from a picked feature.
+ */
+interface FeaturePartProps {
+  part: string;
+  index: number;
+  style?: StyleHints;
+  /** Label text emitted by generators (e.g. breach "B"). */
+  text?: string;
+  /** Label rotation in radians, emitted by generators. */
+  rotation?: number;
+  /** Label size in CSS pixels at the draw/reference zoom. */
+  textSizePixels?: number;
+  /** Map zoom at which textSizePixels was captured. */
+  textSizeZoom?: number;
+  /** Map resolution at which textSizePixels was captured. */
+  textSizeResolution?: number;
+}
+/**
+ * Output of `renderControlMeasure`. A GeoJSON `FeatureCollection` whose
+ * features satisfy the `FeaturePartProps` stable-id contract. See ADR-0010.
+ */
+type ControlMeasureRender = FeatureCollection<Geometry, FeaturePartProps>;
+/**
+ * A `ControlMeasure` paired with its `Render` at a single point in time.
+ *
+ * The unit delivered to `EditChangeEvent` listeners (as `measure` and
+ * `previous`) and resolved from `TacticalDraw.draw()` / `.edit()`. The
+ * `measure` half is a defensive clone (see `cloneControlMeasure`) so held
+ * references remain valid after the originating session has closed.
+ *
+ * See ADR-0010.
+ */
+interface ControlMeasureSnapshot<K extends ControlMeasureKind = ControlMeasureKind> {
+  measure: ControlMeasure<K>;
+  render: ControlMeasureRender;
+}
+/**
+ * Recover the originating control measure id (`cmId`) from a feature emitted
+ * by `renderControlMeasure`. The feature id must match the stable-id contract
+ * `${cmId}:${part}:${index}`; otherwise this throws.
+ */
+declare function controlMeasureIdFromFeature(feature: Feature<Geometry, FeaturePartProps> | {
+  id?: string | number;
+}): string;
+//#endregion
+//#region src/renderControlMeasure.d.ts
+interface RenderOptions {
+  validationMode?: ValidationMode;
+  /**
+   * Façade-level default style (third / lowest-priority layer). Merged
+   * shallowly under `cm.style` and any per-feature generator hint. When
+   * omitted, style resolution matches the prior two-layer behavior.
+   */
+  graphicsStyle?: ControlMeasureStyle;
+}
+/**
+ * Pure render: `ControlMeasure` → `ControlMeasureRender` (a
+ * `FeatureCollection` of `FeaturePartProps`-typed features). Per-feature
+ * stable ids follow `${cm.id}:${part}:${index}`. Style is resolved from the
+ * three layers (graphicsStyle, cm.style, generator hint) and stamped on
+ * `properties.style` when non-empty.
+ */
+declare function renderControlMeasure<K extends ControlMeasureKind>(cm: ControlMeasure<K>, opts?: RenderOptions): ControlMeasureRender;
+//#endregion
+//#region src/styleResolver.d.ts
+/**
+ * Three-layer style precedence for `renderControlMeasure`.
+ *
+ * Lower-priority → higher-priority: `graphicsStyle` (façade default) →
+ * `measureStyle` (`cm.style`) → `generatorStyle` (per-feature hint emitted
+ * by a generator). Merge is shallow and per-property; higher-priority layers
+ * win key by key. Explicit `null` / `undefined` in a higher-priority layer
+ * is treated as "no opinion" and does not clear a lower-priority key.
+ *
+ * Returns `undefined` when all three layers are absent so the renderer can
+ * omit `properties.style` entirely — keeps the no-style case byte-identical
+ * to a property-less feature.
+ *
+ * Pure function: inputs are never mutated; the returned object is always a
+ * fresh allocation when defined.
+ */
+declare function resolveStyleHints(graphicsStyle: ControlMeasureStyle | undefined, measureStyle: ControlMeasureStyle | undefined, generatorStyle: StyleHints | undefined): StyleHints | undefined;
+//#endregion
+//#region src/toSimpleStyle.d.ts
+/**
+ * simplestyle-spec properties (the subset this library can express), flat on
+ * `properties`. All keys are optional.
+ *
+ * @see https://github.com/mapbox/simplestyle-spec
+ */
+interface SimpleStyleProps extends FeaturePartProps {
+  stroke?: string;
+  "stroke-width"?: number;
+  "stroke-opacity"?: number;
+  fill?: string;
+  "fill-opacity"?: number;
+}
+/**
+ * A `FeatureCollection` whose features carry simplestyle-spec keys instead of
+ * the nested `properties.style` slot. The `FeaturePartProps` stable-id
+ * contract (`part`, `index`, `feature.id`) is preserved.
+ */
+type SimpleStyleRender = FeatureCollection<Geometry, SimpleStyleProps>;
+/**
+ * Lossy interop transform: `ControlMeasureRender` → a `FeatureCollection`
+ * whose features carry simplestyle-spec keys. Operates on the already-resolved
+ * per-feature `style`, so it composes after `renderControlMeasure`'s
+ * three-layer merge and stays a pure post-processing step.
+ *
+ * Lossy mapping, by design:
+ *  - `strokeDash` has no simplestyle equivalent and is dropped — dashed
+ *    doctrinal sub-lines render solid in simplestyle consumers.
+ *  - colors must be hex or `rgb()/rgba()`; alpha becomes `*-opacity`. Other
+ *    color forms (named, `hsl()`) are omitted rather than guessed.
+ */
+declare function toSimpleStyle(render: ControlMeasureRender): SimpleStyleRender;
+//#endregion
+//#region src/internal/graphics-utils.d.ts
+/**
+ * Small value used to avoid division by zero and floating-point precision issues.
+ */
+declare const EPSILON = 0.000001;
+/**
+ * Rounds a number to a specified number of decimal places.
+ */
+declare const roundToFixed: (v: number, precision?: number) => number;
+/**
+ * Calculates the meters-per-pixel ratio at a given latitude and zoom level.
+ *
+ * This is essential for maintaining consistent visual sizes on the map
+ * regardless of zoom level. The formula accounts for:
+ * - The Web Mercator projection's tile-based structure
+ * - The latitude-dependent scale distortion in Mercator projection
+ *
+ * @param latitude - The latitude in degrees (affects scale due to projection)
+ * @param zoomLevel - The current map zoom level
+ * @returns The number of meters represented by one pixel at the given location and zoom
+ *
+ * @example
+ * ```typescript
+ * // At zoom 10, latitude 45°
+ * const mpp = getMetersPerPixel(45, 10);
+ * // To get a 20-pixel radius in meters:
+ * const radiusMeters = 20 * mpp;
+ * ```
+ */
+declare const getMetersPerPixel: (latitude: number, zoomLevel: number) => number;
+//#endregion
+//#region src/draw-rules/baseline-frame.d.ts
+type BaselineFrameOrigin = "p1" | "p2" | "midpoint";
+type BaselineFrameNormal = "right" | "left";
+interface BaselineFrameOptions {
+  origin?: BaselineFrameOrigin;
+  normal?: BaselineFrameNormal;
+}
+interface BaselineFrame {
+  readonly p1: Point2D;
+  readonly p2: Point2D;
+  readonly origin: Point2D;
+  readonly direction: Point2D;
+  readonly normal: Point2D;
+  readonly length: number;
+  signedNormalDistance(point: Position): number;
+  pointAtNormalDistance(distance: number): Position | null;
+}
+declare function createBaselineFrame(p1: Position, p2: Position, options?: BaselineFrameOptions): BaselineFrame | null;
+//#endregion
+//#region src/draw-rules/midpoint-perpendicular.d.ts
+interface MidpointPerpendicularDrawRuleOptions {
+  id: string;
+  defaultDistanceRatio?: number;
+  /** User clicks required to commit. Defaults to `2` (the third point is auto-derived). */
+  minimumUserPoints?: number;
+  /** Raw points at which a live preview can be derived. See {@link ControlMeasureDrawRule}. */
+  minimumPreviewPoints?: number;
+  /**
+   * Index of the slot whose point is constrained to the perpendicular axis
+   * through the configured origin of the other two ("baseline") slots. Must be
+   * `0` or `2`. Defaults to `2`.
+   *
+   * Area11 (Block) and Point12 (obstacle-bypass) use `2`: P1/P2 are the free
+   * baseline endpoints and P3 is constrained. Area7 (Attack-By-Fire) uses `0`:
+   * P1 is the constrained arrowhead tip and P2/P3 are the free back-line
+   * endpoints.
+   */
+  constrainedIndex?: 0 | 2;
+  /** Frame origin for the perpendicular axis. Defaults to `"midpoint"`. */
+  origin?: BaselineFrameOrigin;
+  /** Side the positive normal points to. Defaults to `"right"`. */
+  normal?: BaselineFrameNormal;
+}
+declare function createMidpointPerpendicularDrawRule(options: MidpointPerpendicularDrawRuleOptions): ControlMeasureDrawRule;
+declare function computeDefaultMidpointPerpendicularPoint(p1: Position, p2: Position, distanceRatio?: number): Position | null;
+declare function getMidpointPerpendicularSignedDistance(p1: Position, p2: Position, controlPoint: Position): number | null;
+declare function pointOnMidpointPerpendicularAxis(p1: Position, p2: Position, distance: number | null): Position | null;
+declare function snapToMidpointPerpendicular(p1: Position, p2: Position, controlPoint: Position): Position | null;
+//#endregion
+//#region src/draw-rules/area11.d.ts
+declare const blockDrawRule: ControlMeasureDrawRule;
+//#endregion
+//#region src/draw-rules/area12.d.ts
+/**
+ * Area12 anchor draw rule for Disrupt.
+ *
+ * P1/P2 are the free spine endpoints. P3 is the longest-arrow tip, constrained
+ * to the perpendicular axis through P1 (not the baseline midpoint).
+ */
+declare const disruptDrawRule: ControlMeasureDrawRule;
+//#endregion
+//#region src/draw-rules/point12.d.ts
+/**
+ * Point12 anchor draw rule for the obstacle-bypass family.
+ *
+ * Shared by `obstacle-bypass-easy`, `obstacle-bypass-difficult`, and
+ * `obstacle-bypass-impossible`: P1/P2 are the arrowhead tips and define the
+ * opening; P3 is constrained to the perpendicular axis through
+ * `midpoint(P1, P2)` and defines the rear of the symbol. Rear-line decoration
+ * (plain, zigzag, barrier marks) is a generator concern, not a draw-rule one.
+ */
+declare const point12DrawRule: ControlMeasureDrawRule;
+//#endregion
+//#region src/draw-rules/area7.d.ts
+/**
+ * Area7 anchor draw rule for Attack By Fire.
+ *
+ * P2/P3 are the free back-line endpoints; P1 (slot index 0) is the arrowhead
+ * tip, constrained to the perpendicular axis through `midpoint(P2, P3)`.
+ */
+declare const attackByFireDrawRule: ControlMeasureDrawRule;
+//#endregion
+//#region src/draw-rules/line29.d.ts
+/**
+ * Line29 anchor draw rule for Ambush.
+ *
+ * P2/P3 are the free back-line endpoints; P1 (slot index 0) is the arrowhead
+ * tip, constrained to the perpendicular axis through `midpoint(P2, P3)`.
+ */
+declare const ambushDrawRule: ControlMeasureDrawRule;
+//#endregion
+//#region src/draw-rules/line1.d.ts
+declare const line1DrawRule: ControlMeasureDrawRule;
+//#endregion
+//#region src/draw-rules/line10.d.ts
+/**
+ * Line10 — PT1 is the arrow tip, PT2 is the rear, and derived PT3 selects
+ * which side of the PT2 -> PT1 chord contains the 90-degree arc.
+ */
+declare const turnDrawRule: ControlMeasureDrawRule;
+//#endregion
+//#region src/draw-rules/line23.d.ts
+/**
+ * Line23 anchor draw rule for the Clear mission task.
+ *
+ * P1/P2 are the endpoints of the symbol's vertical line (its height); P3 is
+ * constrained to the perpendicular axis through `midpoint(P1, P2)` and defines
+ * the rear of the symbol (the shaft length). Geometrically identical to the
+ * obstacle-bypass `Point12` rule, but kept as its own spec id to match the
+ * doctrinal draw rule for Clear.
+ */
+declare const line23DrawRule: ControlMeasureDrawRule;
+//#endregion
+//#region src/draw-rules/line24.d.ts
+/**
+ * Line24 anchor draw rule for the Delay mission task.
+ *
+ * PT. 1 and PT. 2 are the free straight-line endpoints. PT. 3 is constrained to
+ * the perpendicular axis through PT. 2, where its signed distance from PT. 2
+ * defines the semicircular arc diameter and side. Unlike the sibling Line23
+ * (Clear) rule, the third point must be placed explicitly (three user clicks),
+ * with a two-point live preview before commit.
+ */
+declare const line24DrawRule: ControlMeasureDrawRule;
+//#endregion
+//#region src/draw-rules/area8.d.ts
+declare const supportByFireDrawRule: ControlMeasureDrawRule;
+//#endregion
+//#region src/draw-rules/axis1.d.ts
+declare const axis1DrawRule: ControlMeasureDrawRule;
+//#endregion
+//#region src/generators/cm14-maneuver-lines/ambush.d.ts
+/**
+ * Configuration options for the Ambush tactical symbol.
+ */
+interface AmbushOptions {
+  /** Number of segments used to draw the quadratic curve (default: 30) */
+  resolution?: number;
+  /** Size of arrowhead relative to chord span (default: 0.15) */
+  arrowheadLengthRatio?: number;
+  /** Width of arrowhead wings relative to its length (default: 0.5) */
+  arrowheadWidthRatio?: number;
+  /** Length of parallel hatches relative to chord span (default: 0.15) */
+  hatchLengthRatio?: number;
+  /** Number of parallel hatches along the curve (default: 5) */
+  hatchCount?: number;
+  /** Depth of the curve toward PT 1 relative to chord span (default: 0.25) */
+  curveDepthRatio?: number;
+}
+declare const DEFAULT_AMBUSH_OPTIONS: Required<AmbushOptions>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/searchArea.d.ts
+/**
+ * Configuration options to tweak the tactical arrow's geometry.
+ */
+interface TacticalArrowOptions {
+  /** Ratio of arrowhead length to total leg length (default: 0.12) */
+  arrowheadLengthRatio?: number;
+  /** Width multiplier for the arrowhead wings (default: 0.5) */
+  arrowheadWidthRatio?: number;
+  /** Percentage along the leg where the zigzag begins, 0.0-1.0 (default: 0.55) */
+  zigzagStart?: number;
+  /** Percentage along the leg where the zigzag returns, 0.0-1.0 (default: 0.45) */
+  zigzagEnd?: number;
+  /** Perpendicular offset for the lightning "kink", relative to leg length (default: 0.07) */
+  zigzagAmplitudeRatio?: number;
+}
+/**
+ * Default options for the tactical arrow.
+ */
+declare const DEFAULT_TACTICAL_ARROW_OPTIONS: Required<TacticalArrowOptions>;
+//#endregion
+export { listControlMeasureMetadata as $, DEFAULT_ENCIRCLEMENT_OPTIONS as $t, SimpleStyleProps as A, BreachOptions as At, controlMeasureIdFromFeature as B, AttackHelicopterOptions as Bt, BaselineFrameNormal as C, DelayOptions as Ct, EPSILON as D, DEFAULT_CANALIZE_OPTIONS as Dt, createBaselineFrame as E, CanalizeOptions as Et, renderControlMeasure as F, FLOTOptions as Ft, CONTROL_MEASURE_IDS as G, SupportingAttackOptions as Gt, cloneControlMeasure as H, AirborneAttackOptions as Ht, ControlMeasureRender as I, AttackByFireOptions as It, ControlMeasureKind as J, calculateMetrics as Jt, CONTROL_MEASURE_METADATA as K, DEFAULT_MAIN_ATTACK_OPTIONS as Kt, ControlMeasureSnapshot as L, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Lt, toSimpleStyle as M, BlockMissionTaskOptions as Mt, resolveStyleHints as N, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as Nt, getMetersPerPixel as O, BypassOptions as Ot, RenderOptions as P, DEFAULT_FLOT_OPTIONS as Pt, getDefaultOptions as Q, unproject as Qt, FeaturePartProps as R, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as Rt, BaselineFrame as S, DEFAULT_DELAY_OPTIONS as St, BaselineFrameOrigin as T, DEFAULT_CLEAR_OPTIONS as Tt, isKind as U, DEFAULT_AIRBORNE_ATTACK_OPTIONS as Ut, ControlMeasure as V, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Vt, ControlMeasureStyle as W, DEFAULT_SUPPORTING_ATTACK_OPTIONS as Wt, getControlMeasureMetadata as X, Point2D as Xt, OptionsByKind as Y, computeInitialWidthPoint as Yt, getControlMeasureMetadataByValue as Z, project as Zt, computeDefaultMidpointPerpendicularPoint as _, FortifiedLineOptions as _t, axis1DrawRule as a, DEFAULT_STRONG_POINT_OPTIONS as an, ObstacleBypassEasyOptions as at, pointOnMidpointPerpendicularAxis as b, AntitankDitchOptions as bt, line23DrawRule as c, ControlMeasureGeometryType as cn, DEFAULT_FIX_OPTIONS as ct, ambushDrawRule as d, AnchorTransformEvent as dn, DisruptOptions as dt, EncirclementOptions as en, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as et, attackByFireDrawRule as f, ControlMeasureDrawRule as fn, BlockOptions as ft, MidpointPerpendicularDrawRuleOptions as g, DEFAULT_FORTIFIED_LINE_OPTIONS as gt, blockDrawRule as h, FortifiedAreaOptions as ht, DEFAULT_AMBUSH_OPTIONS as i, PrincipalDirectionOfFireOptions as in, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as it, SimpleStyleRender as j, DEFAULT_BREACH_OPTIONS as jt, roundToFixed as k, DEFAULT_BYPASS_OPTIONS as kt, turnDrawRule as l, ControlMeasureMetadata as ln, FixOptions as lt, disruptDrawRule as m, DEFAULT_FORTIFIED_AREA_OPTIONS as mt, TacticalArrowOptions as n, FinalProtectiveFireOptions as nn, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as nt, supportByFireDrawRule as o, StrongPointOptions as on, DEFAULT_TURN_OPTIONS as ot, point12DrawRule as p, DEFAULT_BLOCK_OPTIONS as pt, ControlMeasureId as q, MainAttackOptions as qt, AmbushOptions as r, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as rn, ObstacleBypassDifficultOptions as rt, line24DrawRule as s, ControlMeasureGeometry as sn, TurnOptions as st, DEFAULT_TACTICAL_ARROW_OPTIONS as t, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as tn, ObstacleBypassImpossibleOptions as tt, line1DrawRule as u, ParamDescriptor as un, DEFAULT_DISRUPT_OPTIONS as ut, createMidpointPerpendicularDrawRule as v, AntitankWallOptions as vt, BaselineFrameOptions as w, ClearOptions as wt, snapToMidpointPerpendicular as x, DEFAULT_ANTITANK_DITCH_OPTIONS as xt, getMidpointPerpendicularSignedDistance as y, DEFAULT_ANTITANK_WALL_OPTIONS as yt, StyleHints as z, SupportByFireOptions as zt };