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

package/dist/index-C6nqkw1A.d.mts

@@ -0,0 +1,2552 @@
+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;
+  /**
+   * Opt a fixed-length draw into the standard dashed interaction guide. Fixed
+   * shapes suppress guides by default because their generator preview is
+   * normally sufficient. Use this when the guide communicates an incomplete
+   * construction state, such as Rectangle's P1-P2 baseline.
+   */
+  readonly showGuide?: boolean;
+  /**
+   * Convert raw draw points into the spine rendered by the interaction guide.
+   * Defaults to the raw points. A rule may return the first point again at the
+   * end when it needs to provide its own closed guide geometry.
+   */
+  guidePoints?(points: readonly Position[]): Position[];
+  /**
+   * 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;
+  /**
+   * The user-spine points form a closed ring even though the first point is not
+   * duplicated at the end. TacticalDraw uses this to treat the last→first edge
+   * like every other edge for completion and midpoint insertion.
+   */
+  readonly closedRing?: boolean;
+  derive(points: readonly Position[]): Position[];
+  transform(event: AnchorTransformEvent): Position[];
+}
+//#endregion
+//#region src/text-amplifiers.d.ts
+/**
+ * MIL-STD-2525E Appendix L Table L-II text amplifier fields.
+ *
+ * A control measure instance carries free-text amplifier fields (unique
+ * designation, country, date-time group, …) keyed by their doctrinal field
+ * code. Repeated fields use numbered suffixes per the standard (`T`, `T1`,
+ * `AS1`, `W1`, …). Graphic amplifiers (echelon `B`, direction of movement `Q`,
+ * offset location `BA`) are deliberately excluded — they are geometry
+ * concerns, rendered from generator options rather than free text.
+ *
+ * This module is a leaf: it imports nothing from `./metadata` or
+ * `./registry`, so both can depend on it without a cycle.
+ */
+type Suffix = "" | "1" | "2";
+/** Doctrinal text amplifier field codes (Table L-II); graphic amplifier fields excluded. */
+type TextAmplifierField = "C" | "H" | "N" | "T" | "V" | "W" | "X" | "Y" | "AM" | "AN" | "AP" | "AS";
+/** A doctrinal field code with its optional repetition suffix, e.g. `"T1"`. */
+type TextAmplifierKey = `${TextAmplifierField}${Suffix}`;
+/**
+ * The vocabulary of text amplifier fields: doctrinal code, milsymbol-style
+ * friendly alias, and a human-readable label. The single source of truth for
+ * both the runtime catalog and the derived alias→code lookup used by
+ * {@link normalizeTextAmplifiers}.
+ */
+declare const TEXT_AMPLIFIER_FIELDS: {
+  readonly C: {
+    readonly alias: "quantity";
+    readonly label: "Quantity";
+  };
+  readonly H: {
+    readonly alias: "additionalInformation";
+    readonly label: "Additional information";
+  };
+  readonly N: {
+    readonly alias: "hostile";
+    readonly label: "Hostile (ENY) marker";
+  };
+  readonly T: {
+    readonly alias: "uniqueDesignation";
+    readonly label: "Unique designation";
+  };
+  readonly V: {
+    readonly alias: "type";
+    readonly label: "Equipment/type";
+  };
+  readonly W: {
+    readonly alias: "dtg";
+    readonly label: "Date-time group / O/O";
+  };
+  readonly X: {
+    readonly alias: "altitudeDepth";
+    readonly label: "Altitude/depth";
+  };
+  readonly Y: {
+    readonly alias: "location";
+    readonly label: "Location";
+  };
+  readonly AM: {
+    readonly alias: "distance";
+    readonly label: "Distance/range/radius";
+  };
+  readonly AN: {
+    readonly alias: "azimuth";
+    readonly label: "Azimuth";
+  };
+  readonly AP: {
+    readonly alias: "targetNumber";
+    readonly label: "Target number";
+  };
+  readonly AS: {
+    readonly alias: "country";
+    readonly label: "Country code";
+  };
+};
+/** The milsymbol-style friendly alias for a text amplifier field, e.g. `"uniqueDesignation"`. */
+type FriendlyName = (typeof TEXT_AMPLIFIER_FIELDS)[TextAmplifierField]["alias"];
+/** A friendly alias with its optional repetition suffix, e.g. `"country1"`. */
+type FriendlyKey = `${FriendlyName}${Suffix}`;
+/**
+ * User-facing amplifier input: either canonical doctrinal keys (`T`, `AS1`,
+ * …) or friendly aliases (`uniqueDesignation`, `country1`, …), optionally
+ * mixed. Values are free text; see {@link normalizeTextAmplifiers} for how
+ * this is resolved to canonical form.
+ */
+type TextAmplifiers = Partial<Record<TextAmplifierKey | FriendlyKey, string>>;
+/** Amplifier values resolved to canonical doctrinal keys, as generators receive them. */
+type CanonicalTextAmplifiers = Readonly<Partial<Record<TextAmplifierKey, string>>>;
+/**
+ * Resolves any accepted key (canonical or friendly alias, with an optional
+ * `1`/`2` suffix) to its canonical key, or `undefined` if unknown — e.g.
+ * `"T"` → `"T"`, `"uniqueDesignation1"` → `"T1"`, `"bogus"` → `undefined`.
+ */
+declare function canonicalTextAmplifierKey(key: string): TextAmplifierKey | undefined;
+/**
+ * Resolves a `TextAmplifiers` record (canonical keys, friendly aliases, or a
+ * mix) to `CanonicalTextAmplifiers` keyed purely by doctrinal field code.
+ *
+ * - Friendly aliases (with an optional `1`/`2` suffix) map to their canonical
+ *   code (e.g. `country1` → `AS1`).
+ * - Values are trimmed; entries that are empty/whitespace-only after
+ *   trimming, or not strings, are dropped.
+ * - When both a canonical key and its friendly alias are present for the same
+ *   field + suffix, the **canonical key wins** regardless of insertion order.
+ *   This holds even for an empty/whitespace canonical value: it suppresses
+ *   (clears) the alias entry rather than letting the alias survive.
+ * - Unknown keys are ignored.
+ *
+ * `undefined` or an empty input returns a shared frozen empty object.
+ */
+declare function normalizeTextAmplifiers(input: TextAmplifiers | undefined): CanonicalTextAmplifiers;
+//#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", "Rectangle"];
+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;
+  /**
+   * The doctrinal Table L-II field this free-text option renders (e.g.
+   * `phaseLineName` renders field `T`) — lets metadata-driven UIs (e.g. a
+   * label-placement preview) substitute a `<T>`-style placeholder for the
+   * option, the same way a `TextAmplifierDescriptor` does for a real
+   * amplifier field.
+   */
+  field?: TextAmplifierField;
+}
+type ParamDescriptor = NumberParamDescriptor | BooleanParamDescriptor | ColorParamDescriptor | TextParamDescriptor | EnumParamDescriptor;
+/** Editor-facing description of one text amplifier field a measure accepts. */
+interface TextAmplifierDescriptor {
+  key: TextAmplifierKey;
+  label: string;
+  description?: string;
+  placeholder?: string;
+  /** Editor hint only — the renderer never truncates the value. */
+  maxLength?: number;
+}
+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[];
+  /** Text amplifier fields (MIL-STD-2525E Appendix L Table L-II) this measure accepts. */
+  textAmplifiers?: readonly TextAmplifierDescriptor[];
+  /**
+   * 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.
+ *
+ * The optional third parameter carries the instance's normalized text
+ * amplifiers (ADR-0027); a generator that ignores text amplifiers just omits
+ * the parameter — fewer params is still assignable to this bound.
+ */
+type ControlMeasureGenerator = (controlPoints: Position[], options: never, textAmplifiers?: CanonicalTextAmplifiers) => 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]>>;
+  /**
+   * Pins orientation-derived defaults — options whose default value depends on
+   * the shape's current screen orientation (e.g. Battle Position's echelon
+   * anchor, which defaults to the bottom edge) — to their current concrete
+   * values. Returns an options patch to merge onto the working options, or
+   * `undefined` when there is nothing to freeze (already frozen, or nothing
+   * visible to pin). Called by edit hosts when a rotate gesture starts, so a
+   * subsequent rigid rotation of the control points preserves the rendered
+   * appearance instead of an orientation-relative default silently re-deriving
+   * against the new orientation. See ADR-0023.
+   */
+  freezeOrientation?: (controlPoints: Position[], options: NonNullable<Parameters<G>[1]>) => Partial<NonNullable<Parameters<G>[1]>> | undefined;
+}
+/**
+ * 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>;
+  /**
+   * Sample text amplifiers (ADR-0027) rendered onto the representative
+   * preview, for measures whose doctrinal appearance is carried by amplifier
+   * text (e.g. Boundary-style end/center labels) rather than options alone.
+   */
+  textAmplifiers?: TextAmplifiers;
+}
+/**
+ * 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;
+  /**
+   * 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;
+  /**
+   * Clearance between the line/echelon glyph and the unit labels, as a ratio
+   * of the echelon glyph height (like `echelonPadding`). In `"along"` mode
+   * (and on `"standard"` east–west segments) it grows the labels'
+   * perpendicular offset from the line; in a `"standard"` north–south crossing
+   * row it grows each label's gap to the echelon glyph. Negative values clamp
+   * to 0.
+   * @default 0.4
+   */
+  labelPadding?: number;
+  /**
+   * How the T/AS unit labels and the echelon glyph are oriented:
+   *
+   * - `"along"` — text runs along the line, offset perpendicular to it, and
+   *   the echelon glyph turns with the segment (the default).
+   * - `"standard"` — MIL-STD-2525E Appendix L §L.5.5.2 / Figure L-10
+   *   placement. On mostly east–west segments this reads exactly like
+   *   `"along"`. On mostly north–south segments the whole group rotates to run
+   *   *perpendicular* to the line instead: a single row of
+   *   `<unit 1> <echelon> <unit 2>` crossing it (unit 1 on its left-of-travel
+   *   side), each label aligned away from the glyph so long designations never
+   *   overlap the line.
+   * @default "along"
+   */
+  labelOrientation?: "along" | "standard";
+  /**
+   * 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;
+}
+/** Default options for the Boundary control measure. */
+declare const DEFAULT_BOUNDARY_OPTIONS: BoundaryOptions;
+/**
+ * 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}.
+ * @param textAmplifiers - Normalized text amplifiers (ADR-0027): `T`/`AS` label
+ *   unit 1 (left-of-travel side), `T1`/`AS1` label unit 2 (right-of-travel side).
+ */
+declare function createBoundary(positions: Position[], options?: BoundaryOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<MultiLineString | MultiPolygon | Point>;
+//#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/internal/sketch.d.ts
+/**
+ * Shared `smooth`/`smoothResolution` option pair for free n-point polyline
+ * measures (draw rule Line1): curves the rendered path through the control
+ * points via a centripetal Catmull-Rom spline. The spline preserves the
+ * endpoints, so the line still meets its drawn anchors, and is a no-op for
+ * fewer than three control points (a single segment cannot be smoothed).
+ */
+interface SmoothLineOptions {
+  /**
+   * Round the line's corners by curving the path 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 (varies per measure)
+   */
+  smoothResolution?: number;
+}
+//#endregion
+//#region src/internal/line-labels.d.ts
+/**
+ * Label sizing per the size-anchor model (ADR-0020, ADR-0028): the presence of
+ * `labelSizePixels` marks the labels screen-anchored; `labelSize` alone is
+ * ground-anchored. Carrying both behaves screen-anchored (pixels win),
+ * matching the geometry options' precedence.
+ */
+interface LabelSizeOptions {
+  /** Text height in projected meters — ground-anchored label size (ADR-0028). */
+  labelSize?: number;
+  /** Text height in CSS pixels — screen-anchored label size (ADR-0028). */
+  labelSizePixels?: number;
+  /**
+   * Meters-per-pixel at the current view. Stamped by the host when the labels
+   * are screen-anchored; resolves `labelSizePixels` to the projected-meter
+   * height that meter-denominated placement (offsets, gaps, row pitch) needs.
+   */
+  metersPerPixel?: number;
+}
+/** Shared placement options for the fixed-end-label line measures. */
+interface LineLabelOptions extends LabelSizeOptions {
+  /**
+   * Extra clearance between the line and its labels, as a ratio of the
+   * label's resolved text height (`labelSize`, or `labelSizePixels ×
+   * metersPerPixel`), like Boundary's `labelPadding`. Negative values clamp
+   * to 0. Only effective when a label size resolves — the no-size fallback
+   * offset is a fixed meter value, unaffected by this ratio.
+   * @default 0
+   */
+  labelPadding?: number;
+}
+//#endregion
+//#region src/generators/cm11-command-control-lines/light-line.d.ts
+/** Configuration options for the Light line control measure. */
+interface LightLineOptions extends LineLabelOptions, SmoothLineOptions {
+  /**
+   * Optional phase line naming: renders `PL <name>` just beyond each end of
+   * the line, additive to the fixed "LL" labels. Empty or whitespace-only
+   * renders no label.
+   * @default none
+   */
+  phaseLineName?: string;
+  /**
+   * Prefix the `phaseLineName` label with "PL" (`"PL DAVID"`, or a bare
+   * "DAVID" when `false`). No effect when `phaseLineName` is empty — unlike
+   * Phase Line itself, this measure already carries its own fixed "LL"
+   * label, so there is no bare "PL" fallback.
+   * @default true
+   */
+  includePrefix?: boolean;
+}
+/** Default options for the Light line control measure. */
+declare const DEFAULT_LIGHT_LINE_OPTIONS: LightLineOptions;
+/**
+ * Creates a Light line control measure: a polyline through `positions`
+ * labeled "LL" above the line near each end.
+ */
+declare function createLightLine(positions: Position[], options?: LightLineOptions): FeatureCollection<LineString | Point>;
+//#endregion
+//#region src/generators/cm11-command-control-lines/engineer-work-line.d.ts
+/** Configuration options for the Engineer work line control measure. */
+interface EngineerWorkLineOptions extends LineLabelOptions, SmoothLineOptions {
+  /**
+   * Optional phase line naming: renders `PL <name>` just beyond each end of
+   * the line, additive to the fixed "EWL" labels. Empty or whitespace-only
+   * renders no label.
+   * @default none
+   */
+  phaseLineName?: string;
+  /**
+   * Prefix the `phaseLineName` label with "PL" (`"PL DAVID"`, or a bare
+   * "DAVID" when `false`). No effect when `phaseLineName` is empty — unlike
+   * Phase Line itself, this measure already carries its own fixed "EWL"
+   * label, so there is no bare "PL" fallback.
+   * @default true
+   */
+  includePrefix?: boolean;
+}
+/** Default options for the Engineer work line control measure. */
+declare const DEFAULT_ENGINEER_WORK_LINE_OPTIONS: EngineerWorkLineOptions;
+/**
+ * Creates an Engineer work line control measure: a polyline through
+ * `positions` labeled "EWL" above the line near each end, plus one center
+ * label group at the midpoint of the total arc length carrying the
+ * responsible units' Field T/AS designator+country (left-of-travel side
+ * above the line, T1/AS1 below). No center group is emitted when all four
+ * amplifiers are empty.
+ */
+declare function createEngineerWorkLine(positions: Position[], options?: EngineerWorkLineOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<LineString | Point>;
+//#endregion
+//#region src/generators/cm11-command-control-lines/generic-c2-line.d.ts
+/** Configuration options for the Generic command and control line. */
+interface GenericC2LineOptions extends LineLabelOptions, SmoothLineOptions {
+  /**
+   * Optional phase line naming: renders `PL <name>` just beyond each end of
+   * the line, additive to the H/T/W/W1 amplifier labels. Empty or
+   * whitespace-only renders no label.
+   * @default none
+   */
+  phaseLineName?: string;
+  /**
+   * Prefix the `phaseLineName` label with "PL" (`"PL DAVID"`, or a bare
+   * "DAVID" when `false`). No effect when `phaseLineName` is empty — this
+   * measure already carries its own H/T/W/W1 amplifier labels, so there is
+   * no bare "PL" fallback.
+   * @default true
+   */
+  includePrefix?: boolean;
+}
+/** Default options for the Generic command and control line. */
+declare const DEFAULT_GENERIC_C2_LINE_OPTIONS: GenericC2LineOptions;
+/**
+ * Creates a Generic command and control line: a polyline through `positions`
+ * with optional near-end text — `H`/`T` joined above the line, `W`/`W1`
+ * joined as a "from - to" range below it. Both rows share the per-tip
+ * placement from {@link import("../../internal/line-labels").aboveEndFrames}
+ * (inset from the tip, anchored toward the line's interior), one at
+ * `base + perp·offset` and the other at `base − perp·offset`.
+ */
+declare function createGenericC2Line(positions: Position[], options?: GenericC2LineOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<LineString | Point>;
+//#endregion
+//#region src/internal/area-labels.d.ts
+/** Shared placement options for the centered-label area measures. */
+interface AreaLabelOptions extends LabelSizeOptions {
+  /**
+   * Extra row leading (and ENY inset), as a ratio of the label's resolved
+   * text height, like the labeled line measures' own `labelPadding`.
+   * Negative values clamp to 0.
+   * @default 0
+   */
+  labelPadding?: number;
+}
+/** Options for {@link labeledAreaFeatures}: {@link buildClosedRing}'s
+ *  smoothing knobs plus the shared {@link AreaLabelOptions} label placement. */
+interface LabeledAreaOptions extends AreaLabelOptions {
+  /**
+   * Round the area's corners by curving the boundary through the control
+   * points (closed centripetal Catmull-Rom spline).
+   * @default false
+   */
+  smooth?: boolean;
+  /**
+   * Number of samples per segment when `smooth` is enabled.
+   * @default 16
+   */
+  smoothResolution?: number;
+}
+//#endregion
+//#region src/generators/cm15-maneuver-areas/battlePosition.d.ts
+/**
+ * Configuration options for the Battle Position control measure. Also
+ * carries the shared {@link AreaLabelOptions} placement for its centered
+ * Field T (designator) label.
+ */
+interface BattlePositionOptions extends AreaLabelOptions {
+  /**
+   * 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;
+  /**
+   * Absolute anchor for the echelon glyph, as a fraction of the total
+   * perimeter measured from the ring seam (the ring's first vertex), wrapped
+   * into `[0, 1)`. When omitted, the anchor is "auto": the bottom edge's
+   * midpoint (the side opposite the front), recomputed from the current
+   * geometry on every render — the long-standing default behavior.
+   * `echelonPosition` still applies on top of this anchor as a signed offset,
+   * exactly as it does against the auto anchor.
+   *
+   * Edit controllers freeze this from "auto" to a concrete fraction the
+   * moment a rotate gesture starts (see `freezeEchelonAnchor` /
+   * `freezeOrientationOptions`): the transform box rotates only the control
+   * points and re-renders, so without a pinned anchor the "bottom edge" would
+   * keep re-deriving against the rotated geometry and the glyph would jump to
+   * a different edge each time a new edge becomes lowest. Freezing the anchor
+   * first makes the rotation rigid — the glyph turns with the shape instead.
+   * See ADR-0023.
+   */
+  echelonAnchor?: 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;
+}
+/** Default options for the Battle Position control measure. */
+declare const DEFAULT_BATTLE_POSITION_OPTIONS: BattlePositionOptions;
+/**
+ * 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}.
+ * @param textAmplifiers - Field T only, centered in the area (no H/W rows —
+ *   this measure's template pairs the designation with the Field B glyph,
+ *   not the plain L-15 boundary template).
+ */
+declare function createBattlePosition(positions: Position[], options?: BattlePositionOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<MultiLineString | MultiPolygon | Point>;
+//#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}.
+ * @param textAmplifiers - Field T only, centered in the area, same as Battle
+ *   Position.
+ */
+declare function createStrongPoint(positions: Position[], options?: StrongPointOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<MultiLineString | MultiPolygon | Point>;
+//#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).
+   */
+  bladeHeightRatio?: 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. Also carries
+ * the shared {@link AreaLabelOptions} label placement for its Field N (ENY)
+ * marker — the doctrinal example shows only the hostile marker, no name/H/W
+ * rows.
+ */
+interface EncirclementOptions extends AreaLabelOptions {
+  /**
+   * 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. Not `Required<...>`
+ * — the inherited label-size options ({@link AreaLabelOptions}) have no
+ * static default, so this covers only the barb/smoothing options.
+ */
+declare const DEFAULT_ENCIRCLEMENT_OPTIONS: 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. When a Field N (ENY) marker is set, it sits ON the
+ * boundary and masks it with a knockout gap (mirroring Field B's echelon
+ * glyph, ADR-0023) — the boundary becomes a gapped MultiLineString instead of
+ * a closed Polygon, and any barb whose center falls inside the gap is
+ * suppressed; the no-`N` case is unaffected.
+ *
+ * @param positions - Area anchor points (>=3); the input contract is enforced
+ *   at the render seam (ADR-0014).
+ * @param options - {@link EncirclementOptions}.
+ * @param textAmplifiers - Field N only — rendered as "ENY" markers at the
+ *   ring's west and east edges, per the doctrinal hostile example.
+ */
+declare function createEncirclement(positions: Position[], options?: EncirclementOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/area.d.ts
+/** Configuration options for the Area control measure. */
+type AreaOptions = LabeledAreaOptions;
+/**
+ * Creates an Area control measure: a closed area through `positions` labeled
+ * at its center with an un-prefixed `T` (Field T) plus an `N` (Field N) ENY
+ * marker, per {@link labeledAreaFeatures}.
+ */
+declare function createArea(positions: Position[], options?: AreaOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/assemblyArea.d.ts
+/** Configuration options for the Assembly area control measure. */
+type AssemblyAreaOptions = LabeledAreaOptions;
+/** Default options for the Assembly area control measure. */
+declare const DEFAULT_ASSEMBLY_AREA_OPTIONS: AssemblyAreaOptions;
+/**
+ * Creates an Assembly area control measure: a closed area through
+ * `positions` labeled at its center with "AA "-prefixed `T` (Field T) plus
+ * `H`/`W`/`W1`/`N` amplifier rows, per {@link labeledAreaFeatures}.
+ */
+declare function createAssemblyArea(positions: Position[], options?: AssemblyAreaOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/jointTacticalActionArea.d.ts
+/** Configuration options for the Joint tactical action area control measure. */
+type JointTacticalActionAreaOptions = LabeledAreaOptions;
+/** Default options for the Joint tactical action area control measure. */
+declare const DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS: JointTacticalActionAreaOptions;
+/**
+ * Creates a Joint tactical action area control measure: a closed area
+ * through `positions` labeled at its center with "JTAA -"-prefixed `T`
+ * (Field T) plus `H`/`W`/`W1`/`N` amplifier rows, per
+ * {@link labeledAreaFeatures}.
+ */
+declare function createJointTacticalActionArea(positions: Position[], options?: JointTacticalActionAreaOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/submarineActionArea.d.ts
+/** Configuration options for the Submarine action area control measure. */
+type SubmarineActionAreaOptions = LabeledAreaOptions;
+/**
+ * Creates a Submarine action area control measure: a closed area through
+ * `positions` labeled at its center with "SAA -"-prefixed `T` (Field T) plus
+ * `W`/`W1`/`N` amplifier rows, per {@link labeledAreaFeatures}.
+ */
+declare function createSubmarineActionArea(positions: Position[], options?: SubmarineActionAreaOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/submarineGeneratedActionArea.d.ts
+/** Configuration options for the Submarine-generated action area control measure. */
+type SubmarineGeneratedActionAreaOptions = LabeledAreaOptions;
+/**
+ * Creates a Submarine-generated action area control measure: a closed area
+ * through `positions` labeled at its center with "SGSA -"-prefixed `T`
+ * (Field T) plus `W`/`W1`/`N` amplifier rows, per {@link labeledAreaFeatures}.
+ */
+declare function createSubmarineGeneratedActionArea(positions: Position[], options?: SubmarineGeneratedActionAreaOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/dropZone.d.ts
+/** Configuration options for the Drop zone control measure. */
+type DropZoneOptions = LabeledAreaOptions;
+/**
+ * Creates a Drop zone control measure: a closed area through `positions`
+ * labeled at its center with "DZ "-prefixed `T` (Field T) plus an `N`
+ * (Field N) ENY marker, per {@link labeledAreaFeatures}.
+ */
+declare function createDropZone(positions: Position[], options?: DropZoneOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/extractionZone.d.ts
+/** Configuration options for the Extraction zone control measure. */
+type ExtractionZoneOptions = LabeledAreaOptions;
+/**
+ * Creates an Extraction zone control measure: a closed area through
+ * `positions` labeled at its center with "EZ "-prefixed `T` (Field T) plus
+ * an `N` (Field N) ENY marker, per {@link labeledAreaFeatures}.
+ */
+declare function createExtractionZone(positions: Position[], options?: ExtractionZoneOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/landingZone.d.ts
+/** Configuration options for the Landing zone control measure. */
+type LandingZoneOptions = LabeledAreaOptions;
+/** Default options for the Landing zone control measure. */
+declare const DEFAULT_LANDING_ZONE_OPTIONS: LandingZoneOptions;
+/**
+ * Creates a Landing zone control measure: a closed area through `positions`
+ * labeled at its center with "LZ "-prefixed `T` (Field T) plus `H`/`W`/`W1`/`N`
+ * amplifier rows, per {@link labeledAreaFeatures}.
+ */
+declare function createLandingZone(positions: Position[], options?: LandingZoneOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/pickupZone.d.ts
+/** Configuration options for the Pickup zone control measure. */
+type PickupZoneOptions = LabeledAreaOptions;
+/** Default options for the Pickup zone control measure. */
+declare const DEFAULT_PICKUP_ZONE_OPTIONS: PickupZoneOptions;
+/**
+ * Creates a Pickup zone control measure: a closed area through `positions`
+ * labeled at its center with "PZ "-prefixed `T` (Field T) plus `H`/`W`/`W1`/`N`
+ * amplifier rows, per {@link labeledAreaFeatures}.
+ */
+declare function createPickupZone(positions: Position[], options?: PickupZoneOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/assaultPosition.d.ts
+/** Configuration options for the Assault position control measure. */
+type AssaultPositionOptions = LabeledAreaOptions;
+/**
+ * Creates an Assault position control measure: a closed area through
+ * `positions` labeled at its center with "ASLT "-prefixed `T` (Field T) —
+ * the sole label row, per {@link labeledAreaFeatures}.
+ */
+declare function createAssaultPosition(positions: Position[], options?: AssaultPositionOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/attackPosition.d.ts
+/** Configuration options for the Attack position control measure. */
+type AttackPositionOptions = LabeledAreaOptions;
+/**
+ * Creates an Attack position control measure: a closed area through
+ * `positions` labeled at its center with "ATK "-prefixed `T` (Field T) —
+ * the sole label row, per {@link labeledAreaFeatures}.
+ */
+declare function createAttackPosition(positions: Position[], options?: AttackPositionOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/objectiveArea.d.ts
+/** Configuration options for the Objective area control measure. */
+type ObjectiveAreaOptions = LabeledAreaOptions;
+/**
+ * Creates an Objective area control measure: a closed area through
+ * `positions` labeled at its center with "OBJ "-prefixed `T` (Field T) —
+ * the sole label row, per {@link labeledAreaFeatures}.
+ */
+declare function createObjectiveArea(positions: Position[], options?: ObjectiveAreaOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm12-command-control-areas/area-of-operations.d.ts
+/** Configuration options for the Area of operations control measure. */
+type AreaOfOperationsOptions = LabeledAreaOptions;
+/** Default options for the Area of operations control measure. */
+declare const DEFAULT_AREA_OF_OPERATIONS_OPTIONS: AreaOfOperationsOptions;
+/**
+ * Creates an Area of operations control measure: a closed area through
+ * `positions` labeled at its center with "AO "-prefixed `T` (Field T) plus
+ * `H`/`W`/`W1`/`N` amplifier rows, per {@link labeledAreaFeatures}.
+ */
+declare function createAreaOfOperations(positions: Position[], options?: AreaOfOperationsOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm12-command-control-areas/named-area-of-interest.d.ts
+/** Configuration options for the Named area of interest control measure. */
+type NamedAreaOfInterestOptions = LabeledAreaOptions;
+/**
+ * Creates a Named area of interest control measure: a closed area through
+ * `positions` labeled at its center with "NAI "-prefixed `T` (Field T) —
+ * the sole label row, per {@link labeledAreaFeatures}.
+ */
+declare function createNamedAreaOfInterest(positions: Position[], options?: NamedAreaOfInterestOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm12-command-control-areas/target-area-of-interest.d.ts
+/** Configuration options for the Target area of interest control measure. */
+type TargetAreaOfInterestOptions = LabeledAreaOptions;
+/**
+ * Creates a Target area of interest control measure: a closed area through
+ * `positions` labeled at its center with "TAI "-prefixed `T` (Field T) —
+ * the sole label row, per {@link labeledAreaFeatures}.
+ */
+declare function createTargetAreaOfInterest(positions: Position[], options?: TargetAreaOfInterestOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm12-command-control-areas/airfield-zone.d.ts
+/** Configuration options for the Airfield zone control measure. */
+interface AirfieldZoneOptions extends LabeledAreaOptions {
+  /**
+   * The runway glyph's long line, as a ratio of the ring's projected
+   * bounding-box width (full length, not half).
+   * @default 0.55
+   */
+  glyphSizeRatio?: number;
+}
+/**
+ * Creates an Airfield zone control measure: a closed area through
+ * `positions` with a runway glyph (two crossed lines forming a shallow
+ * asymmetric X) centered on the ring, and Field H placed outside the area to
+ * the east when set.
+ *
+ * @param positions - Area anchor points (≥3); the input contract is enforced
+ *   at the render seam (ADR-0014).
+ * @param options - {@link AirfieldZoneOptions}.
+ * @param textAmplifiers - Field H only.
+ */
+declare function createAirfieldZone(positions: Position[], options?: AirfieldZoneOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm12-command-control-areas/echelon-labeled-area.d.ts
+/**
+ * Configuration options shared by Base Camp and Guerrilla Base: the full L-15
+ * label placement ({@link LabeledAreaOptions}) plus Battle Position's Field B
+ * echelon knobs.
+ */
+interface EchelonLabeledAreaOptions extends LabeledAreaOptions {
+  /**
+   * Field B echelon straddling the boundary. `"none"` (the default — the
+   * standard's examples show no echelon glyph), empty, or unknown renders no
+   * glyph and leaves the boundary unaffected by echelon masking.
+   * @default "none"
+   */
+  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.
+   * @default 0
+   */
+  echelonPosition?: number;
+  /**
+   * Absolute anchor for the echelon glyph, as a fraction of the total
+   * perimeter measured from the ring seam, wrapped into `[0, 1)`. See Battle
+   * Position's `echelonAnchor` (ADR-0023) — edit controllers freeze this via
+   * the `freezeOrientation` hook the moment a rotate gesture starts.
+   */
+  echelonAnchor?: 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;
+}
+//#endregion
+//#region src/generators/cm12-command-control-areas/base-camp.d.ts
+/** Configuration options for the Base camp control measure. */
+type BaseCampOptions = EchelonLabeledAreaOptions;
+/**
+ * Creates a Base camp control measure: a closed area through `positions`
+ * labeled at its center with "BC "-prefixed `T` (Field T) plus `H`/`W`/`W1`/`N`
+ * amplifier rows, and an optional Field B echelon glyph straddling the
+ * boundary, per {@link echelonLabeledAreaFeatures}.
+ */
+declare function createBaseCamp(positions: Position[], options?: BaseCampOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | MultiPolygon | Point>;
+//#endregion
+//#region src/generators/cm12-command-control-areas/guerrilla-base.d.ts
+/** Configuration options for the Guerrilla base control measure. */
+type GuerrillaBaseOptions = EchelonLabeledAreaOptions;
+/**
+ * Creates a Guerrilla base control measure: a closed area through
+ * `positions` labeled at its center with "GB "-prefixed `T` (Field T) plus
+ * `H`/`W`/`W1`/`N` amplifier rows, and an optional Field B echelon glyph
+ * straddling the boundary, per {@link echelonLabeledAreaFeatures}.
+ */
+declare function createGuerrillaBase(positions: Position[], options?: GuerrillaBaseOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | MultiPolygon | Point>;
+//#endregion
+//#region src/generators/cm12-command-control-areas/generic-c2-area.d.ts
+/** Configuration options for the Generic command and control area control measure. */
+type GenericC2AreaOptions = LabeledAreaOptions;
+/**
+ * Creates a Generic command and control area control measure: a closed area
+ * through `positions` labeled at its center with the bare `T` (Field T) plus
+ * `H`/`W`/`W1`/`N` amplifier rows — no prefix, per {@link labeledAreaFeatures}.
+ */
+declare function createGenericC2Area(positions: Position[], options?: GenericC2AreaOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/attack-utils.d.ts
+interface AttackOptions {
+  shaftWidthRatio?: number;
+  smooth?: boolean;
+  smoothResolution?: 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;
+}
+declare const DEFAULT_CLASSIC_ARROW_OPTIONS: Required<ClassicArrowOptions>;
+/**
+ * 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. */
+  shaftWidthRatio?: 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;
+}
+declare const DEFAULT_BLOCK_ARROW_OPTIONS: Required<BlockArrowOptions>;
+/**
+ * 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/cm99-generic-graphics/params.d.ts
+interface SmoothPathOptions {
+  /** Curve the rendered path through the unchanged control points. */
+  smooth?: boolean;
+  /** Number of samples per segment when smoothing is enabled. */
+  smoothResolution?: number;
+}
+interface FilledAreaOptions {
+  /** Fill the polygon interior; false renders only its outline. */
+  filled?: boolean;
+}
+//#endregion
+//#region src/generators/cm99-generic-graphics/line.d.ts
+type GenericLineOptions = SmoothPathOptions;
+declare const DEFAULT_GENERIC_LINE_OPTIONS: Required<GenericLineOptions>;
+declare function createGenericLine(coordinates: Position[], options?: GenericLineOptions): FeatureCollection<LineString>;
+//#endregion
+//#region src/generators/cm99-generic-graphics/polygon.d.ts
+interface GenericPolygonOptions extends SmoothPathOptions, FilledAreaOptions {}
+declare const DEFAULT_GENERIC_POLYGON_OPTIONS: Required<GenericPolygonOptions>;
+declare function createGenericPolygon(coordinates: Position[], options?: GenericPolygonOptions): FeatureCollection<Polygon, {
+  part: string;
+  fill: boolean;
+}>;
+//#endregion
+//#region src/generators/cm99-generic-graphics/rectangle.d.ts
+type GenericRectangleOptions = FilledAreaOptions;
+declare const DEFAULT_GENERIC_RECTANGLE_OPTIONS: Required<GenericRectangleOptions>;
+declare function createGenericRectangle(coordinates: Position[], options?: GenericRectangleOptions): FeatureCollection<Polygon, {
+  part: string;
+  fill: boolean;
+}>;
+//#endregion
+//#region src/generators/cm99-generic-graphics/circle.d.ts
+type GenericCircleOptions = FilledAreaOptions;
+declare const DEFAULT_GENERIC_CIRCLE_OPTIONS: Required<GenericCircleOptions>;
+declare function createGenericCircle(coordinates: Position[], options?: GenericCircleOptions): FeatureCollection<Polygon, {
+  part: string;
+  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;
+  rearLineLengthRatio?: number;
+  rearLineAngle?: 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;
+  rearLineLengthRatio?: number;
+  rearLineAngle?: 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 extends SmoothLineOptions {
+  /**
+   * 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
+   */
+  arcSegments?: 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, arcSegments: 20 }
+ * );
+ * ```
+ */
+declare function createFLOT(positions: Position[], options?: FLOTOptions): FeatureCollection<LineString>;
+//#endregion
+//#region src/generators/cm14-maneuver-lines/phase-line.d.ts
+/** Configuration options for the Phase line control measure. */
+interface PhaseLineOptions extends LineLabelOptions, SmoothLineOptions {
+  /**
+   * Prefix the end labels with "PL" (`"PL ECHO"`, or a bare `"PL"` when no
+   * designation is set). When `false`, the label is the bare designation
+   * (`Field T`) alone, and the line carries no label at all when `T` is empty.
+   * @default true
+   */
+  includePrefix?: boolean;
+}
+/** Default options for the Phase line control measure. */
+declare const DEFAULT_PHASE_LINE_OPTIONS: PhaseLineOptions;
+/**
+ * Creates a Phase line control measure: a polyline through `positions`
+ * labeled at each end with `T` (optionally "PL"-prefixed).
+ */
+declare function createPhaseLine(positions: Position[], options?: PhaseLineOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<LineString | Point>;
+//#endregion
+//#region src/generators/cm14-maneuver-lines/handover-line.d.ts
+/** Configuration options for the Handover line control measure. */
+interface HandoverLineOptions extends LineLabelOptions, SmoothLineOptions {
+  /**
+   * Optional phase line naming: renders `PL <name>` just beyond each end of
+   * the line, additive to the fixed "HOL" labels. Empty or whitespace-only
+   * renders no label.
+   * @default none
+   */
+  phaseLineName?: string;
+  /**
+   * Prefix the `phaseLineName` label with "PL" (`"PL DAVID"`, or a bare
+   * "DAVID" when `false`). No effect when `phaseLineName` is empty — unlike
+   * Phase Line itself, this measure already carries its own fixed "HOL"
+   * label, so there is no bare "PL" fallback.
+   * @default true
+   */
+  includePrefix?: boolean;
+}
+/** Default options for the Handover line control measure. */
+declare const DEFAULT_HANDOVER_LINE_OPTIONS: HandoverLineOptions;
+/**
+ * Creates a Handover line control measure: a polyline through `positions`
+ * labeled "HOL" above the line near each end.
+ */
+declare function createHandoverLine(positions: Position[], options?: HandoverLineOptions): FeatureCollection<LineString | Point>;
+//#endregion
+//#region src/generators/cm14-maneuver-lines/battle-handover-line.d.ts
+/** Configuration options for the Battle handover line control measure. */
+interface BattleHandoverLineOptions extends LineLabelOptions, SmoothLineOptions {
+  /**
+   * Optional phase line naming: renders `PL <name>` just beyond each end of
+   * the line, additive to the fixed "BHL" labels. Empty or whitespace-only
+   * renders no label.
+   * @default none
+   */
+  phaseLineName?: string;
+  /**
+   * Prefix the `phaseLineName` label with "PL" (`"PL DAVID"`, or a bare
+   * "DAVID" when `false`). No effect when `phaseLineName` is empty — unlike
+   * Phase Line itself, this measure already carries its own fixed "BHL"
+   * label, so there is no bare "PL" fallback.
+   * @default true
+   */
+  includePrefix?: boolean;
+}
+/** Default options for the Battle handover line control measure. */
+declare const DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS: BattleHandoverLineOptions;
+/**
+ * Creates a Battle handover line control measure: a polyline through
+ * `positions` labeled "BHL" above the line near each end.
+ */
+declare function createBattleHandoverLine(positions: Position[], options?: BattleHandoverLineOptions): FeatureCollection<LineString | Point>;
+//#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;
+  /** Text height in projected meters — ground-anchored label size (ADR-0028). */
+  labelSize?: number;
+  /** Text height in CSS pixels — screen-anchored label size (ADR-0028). */
+  labelSizePixels?: number;
+}
+declare const DEFAULT_BLOCK_MISSION_TASK_OPTIONS: Required<Omit<BlockMissionTaskOptions, "labelSize" | "labelSizePixels">>;
+/**
+ * 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;
+  /** Text height in projected meters — ground-anchored label size (ADR-0028). */
+  labelSize?: number;
+  /** Text height in CSS pixels — screen-anchored label size (ADR-0028). */
+  labelSizePixels?: number;
+}
+/**
+ * Default options for the BREACH symbol.
+ */
+declare const DEFAULT_BREACH_OPTIONS: Required<Omit<BreachOptions, "labelSize" | "labelSizePixels">>;
+/**
+ * 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;
+  /** Text height in projected meters — ground-anchored label size (ADR-0028). */
+  labelSize?: number;
+  /** Text height in CSS pixels — screen-anchored label size (ADR-0028). */
+  labelSizePixels?: number;
+}
+/**
+ * Default options for the BYPASS symbol.
+ */
+declare const DEFAULT_BYPASS_OPTIONS: Required<Omit<BypassOptions, "labelSize" | "labelSizePixels">>;
+/**
+ * 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;
+  /** Text height in projected meters — ground-anchored label size (ADR-0028). */
+  labelSize?: number;
+  /** Text height in CSS pixels — screen-anchored label size (ADR-0028). */
+  labelSizePixels?: number;
+}
+/**
+ * Default options for the CANALIZE symbol.
+ */
+declare const DEFAULT_CANALIZE_OPTIONS: Required<Omit<CanalizeOptions, "labelSize" | "labelSizePixels">>;
+/**
+ * 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;
+  /** Text height in projected meters — ground-anchored label size (ADR-0028). */
+  labelSize?: number;
+  /** Text height in CSS pixels — screen-anchored label size (ADR-0028). */
+  labelSizePixels?: number;
+}
+/**
+ * Default options for the CLEAR symbol.
+ */
+declare const DEFAULT_CLEAR_OPTIONS: Required<Omit<ClearOptions, "labelSize" | "labelSizePixels">>;
+/**
+ * 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;
+  /** Text height in projected meters — ground-anchored label size (ADR-0028). */
+  labelSize?: number;
+  /** Text height in CSS pixels — screen-anchored label size (ADR-0028). */
+  labelSizePixels?: number;
+}
+declare const DEFAULT_DELAY_OPTIONS: Required<Omit<DelayOptions, "labelSize" | "labelSizePixels">>;
+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 extends SmoothLineOptions {
+  /**
+   * 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 toothSizePixels is provided along with metersPerPixel.
+   * @default 50
+   */
+  toothSize?: 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 toothSize when metersPerPixel is also provided.
+   * @default 10
+   */
+  toothSizePixels?: number;
+  /**
+   * The meters-per-pixel ratio at the current zoom level and latitude.
+   * Required when using toothSizePixels 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. Also
+ * carries the shared {@link AreaLabelOptions} label placement (a plain
+ * intersection, not a re-derivation, so the aliased
+ * {@link DEFAULT_FORTIFIED_AREA_OPTIONS} default still typechecks unchanged —
+ * `AreaLabelOptions`'s fields are all optional).
+ */
+type FortifiedAreaOptions = FortifiedLineOptions & AreaLabelOptions;
+declare const DEFAULT_FORTIFIED_AREA_OPTIONS: FortifiedAreaOptions;
+/**
+ * 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
+ * @param textAmplifiers - Field T (bare, no prefix — "TANGO", not "FA TANGO")
+ *   plus Field H/W/W1, centered on the pre-teeth boundary ring (see
+ *   `boundaryInput` below); no Field N — Fortified Area's L-15 template
+ *   carries no ENY marker.
+ * @returns A GeoJSON FeatureCollection containing the castellated Polygon
+ *   plus any label Points
+ */
+declare function createFortifiedArea(positions: Position[], options?: FortifiedAreaOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<Polygon | Point>;
+//#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>;
+  "light-line": ControlMeasureDefinition<"light-line", typeof createLightLine>;
+  "engineer-work-line": ControlMeasureDefinition<"engineer-work-line", typeof createEngineerWorkLine>;
+  "generic-c2-line": ControlMeasureDefinition<"generic-c2-line", typeof createGenericC2Line>;
+  "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>;
+  area: ControlMeasureDefinition<"area", typeof createArea>;
+  "assembly-area": ControlMeasureDefinition<"assembly-area", typeof createAssemblyArea>;
+  "joint-tactical-action-area": ControlMeasureDefinition<"joint-tactical-action-area", typeof createJointTacticalActionArea>;
+  "submarine-action-area": ControlMeasureDefinition<"submarine-action-area", typeof createSubmarineActionArea>;
+  "submarine-generated-action-area": ControlMeasureDefinition<"submarine-generated-action-area", typeof createSubmarineGeneratedActionArea>;
+  "drop-zone": ControlMeasureDefinition<"drop-zone", typeof createDropZone>;
+  "extraction-zone": ControlMeasureDefinition<"extraction-zone", typeof createExtractionZone>;
+  "landing-zone": ControlMeasureDefinition<"landing-zone", typeof createLandingZone>;
+  "pickup-zone": ControlMeasureDefinition<"pickup-zone", typeof createPickupZone>;
+  "assault-position": ControlMeasureDefinition<"assault-position", typeof createAssaultPosition>;
+  "attack-position": ControlMeasureDefinition<"attack-position", typeof createAttackPosition>;
+  "objective-area": ControlMeasureDefinition<"objective-area", typeof createObjectiveArea>;
+  "area-of-operations": ControlMeasureDefinition<"area-of-operations", typeof createAreaOfOperations>;
+  "named-area-of-interest": ControlMeasureDefinition<"named-area-of-interest", typeof createNamedAreaOfInterest>;
+  "target-area-of-interest": ControlMeasureDefinition<"target-area-of-interest", typeof createTargetAreaOfInterest>;
+  "airfield-zone": ControlMeasureDefinition<"airfield-zone", typeof createAirfieldZone>;
+  "base-camp": ControlMeasureDefinition<"base-camp", typeof createBaseCamp>;
+  "guerrilla-base": ControlMeasureDefinition<"guerrilla-base", typeof createGuerrillaBase>;
+  "generic-c2-area": ControlMeasureDefinition<"generic-c2-area", typeof createGenericC2Area>;
+  "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>;
+  line: ControlMeasureDefinition<"line", typeof createGenericLine>;
+  polygon: ControlMeasureDefinition<"polygon", typeof createGenericPolygon>;
+  rectangle: ControlMeasureDefinition<"rectangle", typeof createGenericRectangle>;
+  circle: ControlMeasureDefinition<"circle", typeof createGenericCircle>;
+  "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>;
+  "phase-line": ControlMeasureDefinition<"phase-line", typeof createPhaseLine>;
+  "handover-line": ControlMeasureDefinition<"handover-line", typeof createHandoverLine>;
+  "battle-handover-line": ControlMeasureDefinition<"battle-handover-line", typeof createBattleHandoverLine>;
+  "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>;
+  /** Free-text amplifier fields (MIL-STD-2525E Appendix L Table L-II); see `./text-amplifiers`. */
+  textAmplifiers?: TextAmplifiers;
+  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`, `properties`, and `textAmplifiers` 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;
+  /**
+   * Horizontal text alignment relative to the label point: `"start"` = the
+   * text begins at the point, `"end"` = it ends there. Absent = centered.
+   */
+  textAnchor?: "start" | "end";
+  /**
+   * Screen-anchored label size in CSS pixels — held constant on screen
+   * (ADR-0028). Mutually exclusive with `textSizeMeters`; absent both,
+   * adapters render their engine default, screen-fixed.
+   */
+  textSizePixels?: number;
+  /**
+   * Ground-anchored label text height in projected meters (ADR-0028).
+   * Adapters render `clamp(textSizeMeters / resolution, min, max)` px, per
+   * their configured clamp band.
+   */
+  textSizeMeters?: 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/freeze-orientation.d.ts
+/**
+ * Dispatches to a measure kind's `freezeOrientation` hook (see
+ * {@link import("./define").ControlMeasureDefinition.freezeOrientation}),
+ * pinning orientation-derived option defaults to their current concrete
+ * values ahead of a rigid rotation of `controlPoints`. Returns `undefined`
+ * when the kind declares no hook, or when the hook itself finds nothing to
+ * freeze. Edit hosts call this when a rotate gesture starts (ADR-0023).
+ */
+declare function freezeOrientationOptions<K extends ControlMeasureKind>(kind: K, controlPoints: Position[], options: OptionsByKind[K] | undefined): Partial<OptionsByKind[K]> | undefined;
+//#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/area15.d.ts
+declare const centerRadiusDrawRule: 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/draw-rules/rectangle.d.ts
+declare const rectangleDrawRule: 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) */
+  arcSegments?: 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 { getControlMeasureMetadata as $, ControlMeasureMetadata as $n, DEFAULT_GENERIC_CIRCLE_OPTIONS as $t, getMetersPerPixel as A, EncirclementOptions as An, DEFAULT_CANALIZE_OPTIONS as At, ControlMeasureSnapshot as B, GenericC2LineOptions as Bn, HandoverLineOptions as Bt, snapToMidpointPerpendicular as C, DEFAULT_LANDING_ZONE_OPTIONS as Cn, AntitankDitchOptions as Ct, BaselineFrameOrigin as D, AssemblyAreaOptions as Dn, ClearOptions as Dt, BaselineFrameOptions as E, JointTacticalActionAreaOptions as En, DelayOptions as Et, resolveStyleHints as F, DEFAULT_STRONG_POINT_OPTIONS as Fn, BlockMissionTaskOptions as Ft, cloneControlMeasure as G, LabelSizeOptions as Gn, AttackByFireOptions as Gt, StyleHints as H, EngineerWorkLineOptions as Hn, PhaseLineOptions as Ht, freezeOrientationOptions as I, StrongPointOptions as In, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as It, CONTROL_MEASURE_IDS as J, unproject as Jn, SupportByFireOptions as Jt, isKind as K, Point2D as Kn, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Kt, RenderOptions as L, BattlePositionOptions as Ln, BattleHandoverLineOptions as Lt, SimpleStyleProps as M, FinalProtectiveFireOptions as Mn, DEFAULT_BYPASS_OPTIONS as Mt, SimpleStyleRender as N, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as Nn, BreachOptions as Nt, createBaselineFrame as O, DEFAULT_ASSEMBLY_AREA_OPTIONS as On, DEFAULT_CLEAR_OPTIONS as Ot, toSimpleStyle as P, PrincipalDirectionOfFireOptions as Pn, DEFAULT_BREACH_OPTIONS as Pt, OptionsByKind as Q, ControlMeasureGeometryType as Qn, DEFAULT_AIRBORNE_ATTACK_OPTIONS as Qt, renderControlMeasure as R, DEFAULT_BATTLE_POSITION_OPTIONS as Rn, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as Rt, pointOnMidpointPerpendicularAxis as S, PickupZoneOptions as Sn, DEFAULT_ANTITANK_WALL_OPTIONS as St, BaselineFrameNormal as T, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as Tn, DEFAULT_DELAY_OPTIONS as Tt, controlMeasureIdFromFeature as U, DEFAULT_LIGHT_LINE_OPTIONS as Un, DEFAULT_FLOT_OPTIONS as Ut, FeaturePartProps as V, DEFAULT_ENGINEER_WORK_LINE_OPTIONS as Vn, DEFAULT_PHASE_LINE_OPTIONS as Vt, ControlMeasure as W, LightLineOptions as Wn, FLOTOptions as Wt, ControlMeasureId as X, DEFAULT_BOUNDARY_OPTIONS as Xn, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Xt, CONTROL_MEASURE_METADATA as Y, BoundaryOptions as Yn, AttackHelicopterOptions as Yt, ControlMeasureKind as Z, ControlMeasureGeometry as Zn, AirborneAttackOptions as Zt, blockDrawRule as _, calculateMetrics as _n, DEFAULT_FORTIFIED_AREA_OPTIONS as _t, rectangleDrawRule as a, DEFAULT_GENERIC_LINE_OPTIONS as an, TextAmplifierKey as ar, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as at, createMidpointPerpendicularDrawRule as b, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as bn, FortifiedLineOptions as bt, line24DrawRule as c, BlockArrowOptions as cn, normalizeTextAmplifiers as cr, ObstacleBypassEasyOptions as ct, line1DrawRule as d, ClassicArrowOptions as dn, DEFAULT_FIX_OPTIONS as dt, GenericCircleOptions as en, ParamDescriptor as er, getControlMeasureMetadataByValue as et, ambushDrawRule as f, DEFAULT_CLASSIC_ARROW_OPTIONS as fn, FixOptions as ft, disruptDrawRule as g, MainAttackOptions as gn, DEFAULT_BLOCK_OPTIONS as gt, centerRadiusDrawRule as h, DEFAULT_MAIN_ATTACK_OPTIONS as hn, BlockOptions as ht, DEFAULT_AMBUSH_OPTIONS as i, GenericPolygonOptions as in, TextAmplifierField as ir, ObstacleBypassImpossibleOptions as it, roundToFixed as j, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as jn, BypassOptions as jt, EPSILON as k, DEFAULT_ENCIRCLEMENT_OPTIONS as kn, CanalizeOptions as kt, line23DrawRule as l, DEFAULT_BLOCK_ARROW_OPTIONS as ln, AnchorTransformEvent as lr, DEFAULT_TURN_OPTIONS as lt, point12DrawRule as m, SupportingAttackOptions as mn, DisruptOptions as mt, TacticalArrowOptions as n, GenericRectangleOptions as nn, CanonicalTextAmplifiers as nr, listControlMeasureMetadata as nt, axis1DrawRule as o, GenericLineOptions as on, TextAmplifiers as or, ObstacleBypassDifficultOptions as ot, attackByFireDrawRule as p, DEFAULT_SUPPORTING_ATTACK_OPTIONS as pn, DEFAULT_DISRUPT_OPTIONS as pt, ControlMeasureStyle as q, project as qn, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as qt, AmbushOptions as r, DEFAULT_GENERIC_POLYGON_OPTIONS as rn, TEXT_AMPLIFIER_FIELDS as rr, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as rt, supportByFireDrawRule as s, BlockArrowHeadStyle as sn, canonicalTextAmplifierKey as sr, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as st, DEFAULT_TACTICAL_ARROW_OPTIONS as t, DEFAULT_GENERIC_RECTANGLE_OPTIONS as tn, TextAmplifierDescriptor as tr, getDefaultOptions as tt, turnDrawRule as u, ClassicArrowHeadStyle as un, ControlMeasureDrawRule as ur, TurnOptions as ut, MidpointPerpendicularDrawRuleOptions as v, computeInitialWidthPoint as vn, FortifiedAreaOptions as vt, BaselineFrame as w, LandingZoneOptions as wn, DEFAULT_ANTITANK_DITCH_OPTIONS as wt, getMidpointPerpendicularSignedDistance as x, DEFAULT_PICKUP_ZONE_OPTIONS as xn, AntitankWallOptions as xt, computeDefaultMidpointPerpendicularPoint as y, AreaOfOperationsOptions as yn, DEFAULT_FORTIFIED_LINE_OPTIONS as yt, ControlMeasureRender as z, DEFAULT_GENERIC_C2_LINE_OPTIONS as zn, DEFAULT_HANDOVER_LINE_OPTIONS as zt };