@orbat-mapper/control-measures 0.2.0-alpha.9 → 0.2.0

package/dist/{index-26Xb77jE.d.mts → index-DtgRm_dz.d.mts}

@@ -23,6 +23,13 @@ interface ControlMeasureDrawRule {
    * `minimumUserPoints` (no early preview).
    */
   readonly minimumPreviewPoints?: number;
+  /**
+   * Let a repeat click on the latest point commit the rule's early derived
+   * preview before `minimumUserPoints` raw anchors have been placed. Use only
+   * when `derive` produces a meaningful default canonical shape from
+   * `minimumPreviewPoints` points.
+   */
+  readonly finishOnLastPointRepeat?: boolean;
   /**
    * Opt a fixed-length draw into the standard dashed interaction guide. Fixed
    * shapes suppress guides by default because their generator preview is
@@ -145,6 +152,37 @@ type FriendlyKey = `${FriendlyName}${Suffix}`;
  * this is resolved to canonical form.
  */
 type TextAmplifiers = Partial<Record<TextAmplifierKey | FriendlyKey, string>>;
+/**
+ * Stable key for a non-amplifier generated label. The renderer assigns these
+ * from the label's part and per-part label ordinal when a generator has not
+ * supplied a doctrinal field key. Generators that can change a label's order
+ * should supply an explicit `labelPlacementKey` instead.
+ */
+type GeneratedLabelKey = `label:${string}`;
+/**
+ * Object form of a per-label override. `rotation` is in stored radians — the
+ * same convention as `FeaturePartProps.rotation` (adapters render the
+ * on-screen angle as `π − rotation`).
+ */
+interface LabelPlacementOverride {
+  position?: Position;
+  rotation?: number;
+}
+/** A per-label override: a bare anchor (legacy shorthand) or the object form. */
+type AmplifierPlacement = Position | LabelPlacementOverride;
+/**
+ * User-adjusted anchor positions (and, optionally, rotations) for doctrinal
+ * and generated text labels, keyed by a canonical `TextAmplifierKey` or a
+ * synthesized `GeneratedLabelKey`.
+ */
+type AmplifierPlacements = Record<string, AmplifierPlacement | undefined>;
+/**
+ * Resolves a raw placement entry to its object form: a bare `Position` is
+ * legacy shorthand for `{ position }`; an object form passes through only the
+ * fields that are actually valid (`position` must be a finite `[lon, lat]`,
+ * `rotation` a finite number); `undefined` resolves to `{}`.
+ */
+declare function resolveAmplifierPlacement(value: AmplifierPlacement | undefined): LabelPlacementOverride;
 /** Amplifier values resolved to canonical doctrinal keys, as generators receive them. */
 type CanonicalTextAmplifiers = Readonly<Partial<Record<TextAmplifierKey, string>>>;
 /**
@@ -174,7 +212,7 @@ declare function normalizeTextAmplifiers(input: TextAmplifiers | undefined): Can
 //#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"];
+declare const DRAW_RULE_IDS: readonly ["Area1", "Area7", "Area8", "Area11", "Area12", "Area15", "Area21", "Axis1", "Line1", "Line3", "Line9", "Line10", "Line23", "Line24", "Line26", "Line29", "Point1", "Point12", "Rectangle"];
 type DrawRuleId = (typeof DRAW_RULE_IDS)[number];
 interface BaseParamDescriptor {
   key: string;
@@ -206,6 +244,20 @@ 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;
+  /**
+   * Whether the value may contain explicit line breaks that a metadata-driven
+   * editor should let the user enter directly (a multi-row textarea rather
+   * than a single-line input), e.g. the generic Text measure's `text` option.
+   */
+  multiline?: boolean;
 }
 type ParamDescriptor = NumberParamDescriptor | BooleanParamDescriptor | ColorParamDescriptor | TextParamDescriptor | EnumParamDescriptor;
 /** Editor-facing description of one text amplifier field a measure accepts. */
@@ -248,6 +300,40 @@ interface ControlMeasureMetadata {
    * definition means adding such a measure stays a one-file change (ADR-0013).
    */
   capturesLabelSize?: boolean;
+  /**
+   * Static, per-kind declaration of what a rendered instance can paint — used
+   * by a host editor to decide which style controls (stroke color/width,
+   * fill toggle/pattern/color, text color) are meaningful to show for this
+   * kind. It describes the *kind*, not a particular instance: a `filled`
+   * boolean option still governs whether any given instance is actually
+   * filled, this only says whether fill control is meaningful at all.
+   */
+  paints: ControlMeasurePaintCapability;
+}
+/**
+ * A control measure's fill capability, per {@link ControlMeasurePaintCapability.fill}.
+ *
+ * - `"none"` — no emitted part is ever filled; a fill/fillColor/fillPattern
+ *   control would be inert.
+ * - `"fixed"` — a filled part exists, but the generator pins its
+ *   `fillPattern` (a solid accent like an echelon marker, or a doctrinal
+ *   hatch like Limited Access Area's back-hatch) — `cm.style.fillPattern`
+ *   never reaches it. `fillColor` is *not* pinned, so a fill color override
+ *   still reaches the part; only the pattern control is inert.
+ * - `"user"` — a filled part exists whose pattern the generator leaves
+ *   unset, so `cm.style.fillPattern` reaches the output. These are exactly
+ *   the kinds governed by a `filled` boolean {@link ParamDescriptor}
+ *   (polygon, rectangle, circle, block-arrow).
+ */
+type ControlMeasureFillCapability = "none" | "fixed" | "user";
+/** What a rendered control-measure kind can paint — see {@link ControlMeasureMetadata.paints}. */
+interface ControlMeasurePaintCapability {
+  /** Whether any emitted part is stroked (non-Point) geometry — gates a stroke color/width control. */
+  stroke: boolean;
+  /** Whether/how any emitted part is filled — see {@link ControlMeasureFillCapability}. */
+  fill: ControlMeasureFillCapability;
+  /** Whether the kind emits text label features — gates a text color control. */
+  text: boolean;
 }
 //#endregion
 //#region src/define.d.ts
@@ -256,6 +342,10 @@ interface ControlMeasureMetadata {
  * geometry, with per-feature properties that the renderer normalizes.
  */
 type AnyFeatureCollection = FeatureCollection<Geometry, Record<string, unknown> | null>;
+/** Read-only instance state that can affect generated geometry. */
+interface ControlMeasureGeneratorContext {
+  amplifierPlacements?: AmplifierPlacements;
+}
 /**
  * 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
@@ -266,9 +356,11 @@ type AnyFeatureCollection = FeatureCollection<Geometry, Record<string, unknown>
  *
  * 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.
+ * the parameter. The optional fourth parameter carries instance state needed
+ * while generating geometry derived from an individual label placement.
+ * Generators may omit either trailing parameter.
  */
-type ControlMeasureGenerator = (controlPoints: Position[], options: never, textAmplifiers?: CanonicalTextAmplifiers) => AnyFeatureCollection;
+type ControlMeasureGenerator = (controlPoints: Position[], options: never, textAmplifiers?: CanonicalTextAmplifiers, context?: ControlMeasureGeneratorContext) => AnyFeatureCollection;
 /**
  * Everything that defines one control measure, co-located with its generator.
  * `registry.ts` collects these into the single `DEFINITIONS` map, from which
@@ -314,6 +406,30 @@ interface ControlMeasureDefinition<Id extends string, G extends ControlMeasureGe
    * against the new orientation. See ADR-0023.
    */
   freezeOrientation?: (controlPoints: Position[], options: NonNullable<Parameters<G>[1]>) => Partial<NonNullable<Parameters<G>[1]>> | undefined;
+  /**
+   * Folds a box transform gesture's screen-space delta into option values for a
+   * graphic that persists orientation and/or size as options rather than in its
+   * geometry — single-point graphics (e.g. Text) have no geometry to encode
+   * them. Returns an options patch to merge onto the working options, or
+   * `undefined` when the kind carries no such option (or the delta is inert).
+   * Edit hosts call this at a rotate/scale gesture's commit, alongside the rigid
+   * transform of the control points, so the persisted rotation/size follow the
+   * box. The measure owns the unit/sign conversion (e.g. Text stores degrees
+   * clockwise-on-screen while the delta is radians). See ADR-0017/0023.
+   */
+  transformOptions?: (options: NonNullable<Parameters<G>[1]>, delta: BoxTransformDelta) => Partial<NonNullable<Parameters<G>[1]>> | undefined;
+}
+/**
+ * A box transform gesture's screen-space delta, folded into orientation- and
+ * size-carrying options by {@link ControlMeasureDefinition.transformOptions}.
+ * The transform box (ADR-0017) is the source: `scale` is the uniform corner
+ * -scale factor (`1` = no scaling), `rotationRadians` the rotate-grip delta
+ * (positive = clockwise on screen, matching the box angle convention; `0` = no
+ * rotation). A body translate reports neither (`{ scale: 1, rotationRadians: 0 }`).
+ */
+interface BoxTransformDelta {
+  scale: number;
+  rotationRadians: number;
 }
 /**
  * A measure's representative preview input. Shared between the typed
@@ -324,6 +440,12 @@ interface ControlMeasureDefinition<Id extends string, G extends ControlMeasureGe
 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
@@ -369,23 +491,10 @@ interface BoundaryOptions {
    * lock the T/AS text size to the glyph height.
    */
   metersPerPixel?: number;
-  /**
-   * Map zoom captured at draw-commit (`capturesLabelSize`). Forwarded onto the
-   * T/AS labels as `textSizeZoom` so a ground-anchored boundary's text scales
-   * with zoom like its meter-baked echelon glyph (maplibre).
-   */
-  labelSizeZoom?: number;
-  /**
-   * Map resolution (meters-per-pixel) captured at draw-commit
-   * (`capturesLabelSize`). Forwarded onto the T/AS labels as `textSizeResolution`
-   * so a ground-anchored boundary's text scales with zoom (OpenLayers), and used
-   * as the reference resolution that sizes the text to the glyph height.
-   */
-  labelSizeResolution?: number;
   /**
    * Number of label groups (echelon + designators), spaced evenly by cumulative
-   * arc length along the whole boundary. `1` places a single group at the
-   * midpoint of the total length (which may fall on any segment).
+   * arc length along the whole boundary. `1` places a single group at
+   * `labelPosition`, whose default is the midpoint of the total length.
    * @default 1
    */
   labelRepetitions?: number;
@@ -397,6 +506,13 @@ interface BoundaryOptions {
    * @default 1
    */
   labelSpacing?: number;
+  /**
+   * Position of a single label group as a fraction of cumulative arc length
+   * from the boundary's first control point (0) to its last (1). Ignored when
+   * `labelRepetitions > 1`.
+   * @default 0.5
+   */
+  labelPosition?: number;
   /**
    * Clearance between the line/echelon glyph and the unit labels, as a ratio
    * of the echelon glyph height (like `echelonPadding`). In `"along"` mode
@@ -450,9 +566,269 @@ declare const DEFAULT_BOUNDARY_OPTIONS: BoundaryOptions;
  */
 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;
+/**
+ * Great-circle distance in meters between two lon/lat positions (haversine on
+ * the WGS84 mean-radius sphere). Accurate at all scales — use this for
+ * measurement readouts (segment lengths, radii). Most generators still build
+ * geometry in projected Web Mercator meters, so at high latitudes a graphic's
+ * Mercator dimensions can exceed the true ground distance this returns; the
+ * generic circle is the exception — it samples at constant geodesic radius,
+ * so its ring and this readout agree exactly.
+ */
+declare const haversineDistance: (a: Position, b: Position) => number;
+//#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, textAmplifiers?: CanonicalTextAmplifiers): 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/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;
+  /**
+   * How a filled part's interior is painted. `"solid"` is explicit so a
+   * measure can override a patterned layer default (e.g. a hatch fill set
+   * at the façade). Pattern lines are drawn in the resolved fill color —
+   * alpha included, there is no separate opacity field. Renderers that
+   * cannot draw a pattern degrade to solid.
+   */
+  fillPattern?: FillPattern;
+  /**
+   * Display-time graphic opacity multiplier in `[0, 1]`; absent = fully
+   * opaque. Unlike `color`'s alpha, this fades the whole graphic — stroke,
+   * fill, patterns, and baked labels — as one knob, independent of the
+   * authored color. The resolver folds it into each resolved part's color
+   * alpha (`final alpha = opacity × color alpha`) rather than adding a new
+   * paint channel, so adapters and `toSimpleStyle` need no changes.
+   * Display-only: hit-testing and selection reason about color alpha, not
+   * this multiplier, so a graphic at `opacity: 0` stays fully selectable.
+   * Out-of-range values clamp to `[0, 1]`. See ADR-0040.
+   */
+  opacity?: number;
+  /**
+   * Render a contrast-aware halo behind label glyphs so text stays legible on
+   * busy backgrounds. Cascades like any other hint (graphicsStyle → measure →
+   * generator), letting a host switch halos on for every labeled measure
+   * rather than only the generic Text graphic.
+   *
+   * Text-only: the renderer applies it to features that carry `text` and drops
+   * it everywhere else, so a layer-level `true` never leaks onto plain stroked
+   * or filled parts. The halo *color* is not authored here — it is derived per
+   * feature from the resolved text color, so each label gets a halo that
+   * actually contrasts with it. Unlike the other hints this one is consumed by
+   * the renderer and lifted to a top-level `textHalo` feature property; it is
+   * never emitted on `properties.style`. See ADR-0042.
+   */
+  textHalo?: boolean;
+}
+/**
+ * How a filled part's interior is painted. See `ControlMeasureStyle.fillPattern`.
+ */
+type FillPattern = "solid" | "hatch" | "reverse-hatch" | "cross-hatch" | "horizontal" | "vertical" | "dots";
+//#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. */
-interface BattlePositionOptions {
+/**
+ * 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"`).
@@ -536,8 +912,12 @@ declare const DEFAULT_BATTLE_POSITION_OPTIONS: BattlePositionOptions;
  * @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 (designation, centered in the area) plus an
+ *   optional Field N "ENY" hostile marker at the west/east edges (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): FeatureCollection<MultiLineString | MultiPolygon>;
+declare function createBattlePosition(positions: Position[], options?: BattlePositionOptions, textAmplifiers?: CanonicalTextAmplifiers, context?: ControlMeasureGeneratorContext): FeatureCollection<MultiLineString | MultiPolygon | Point>;
 //#endregion
 //#region src/generators/cm15-maneuver-areas/strongPoint.d.ts
 /** Configuration options for the Strong Point control measure. */
@@ -553,8 +933,54 @@ declare const DEFAULT_STRONG_POINT_OPTIONS: StrongPointOptions;
  * @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 (designation, centered in the area) plus an
+ *   optional Field N "ENY" hostile marker at the west/east edges, same as
+ *   Battle Position.
  */
-declare function createStrongPoint(positions: Position[], options?: StrongPointOptions): FeatureCollection<MultiLineString | MultiPolygon>;
+declare function createStrongPoint(positions: Position[], options?: StrongPointOptions, textAmplifiers?: CanonicalTextAmplifiers, context?: ControlMeasureGeneratorContext): FeatureCollection<MultiLineString | MultiPolygon | Point>;
+//#endregion
+//#region src/generators/cm14-maneuver-lines/direction-of-attack-aviation.d.ts
+interface DirectionOfAttackAviationOptions extends LabelSizeOptions, SmoothLineOptions {
+  /** Arrowhead length as a ratio of the route's total length. @default 0.12 */
+  arrowheadLengthRatio?: number;
+  /** Arrowhead total width as a ratio of its length. @default 1.15 */
+  arrowheadWidthRatio?: number;
+  /** Bow-tie length as a ratio of the route's total length. @default 0.1 */
+  bowTieLengthRatio?: number;
+  /** Bow-tie total width as a ratio of its length. @default 0.5 */
+  bowTieWidthRatio?: number;
+  /** Bow-tie position as a fraction from tail (0) to tip (1). @default 1/3 */
+  bowTiePosition?: number;
+  /** Field T/W/W1 group position as a fraction from tail (0) to tip (1). @default 2/3 */
+  labelPosition?: number;
+  /** Extra spacing between the route and W/W1 rows, in label heights. @default 0 */
+  labelPadding?: number;
+}
+declare const DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS: DirectionOfAttackAviationOptions;
+/** Builds the route, aviation bow-tie, arrowhead, and optional T/W/W1 labels. */
+declare function createDirectionOfAttackAviation(coordinates: Position[], options?: DirectionOfAttackAviationOptions, textAmplifiers?: CanonicalTextAmplifiers, context?: ControlMeasureGeneratorContext): FeatureCollection<MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm14-maneuver-lines/direction-of-attack-shared.d.ts
+interface DirectionOfAttackLineOptions extends LabelSizeOptions, SmoothLineOptions {
+  arrowheadLengthRatio?: number;
+  arrowheadWidthRatio?: number;
+  /** Field T/W/W1 group position as a fraction from tail (0) to tip (1). */
+  labelPosition?: number;
+  labelPadding?: number;
+}
+//#endregion
+//#region src/generators/cm14-maneuver-lines/direction-of-main-attack.d.ts
+interface DirectionOfMainAttackOptions extends DirectionOfAttackLineOptions {
+  /** Thickness of the outlined arrowhead as a ratio of its length. @default 0.3 */
+  arrowheadOutlineRatio?: number;
+}
+declare const DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS: DirectionOfMainAttackOptions;
+declare function createDirectionOfMainAttack(coordinates: Position[], options?: DirectionOfMainAttackOptions, textAmplifiers?: CanonicalTextAmplifiers, context?: ControlMeasureGeneratorContext): FeatureCollection<MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm14-maneuver-lines/direction-of-supporting-attack.d.ts
+type DirectionOfSupportingAttackOptions = DirectionOfAttackLineOptions;
+declare const DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS: DirectionOfSupportingAttackOptions;
+declare function createDirectionOfSupportingAttack(coordinates: Position[], options?: DirectionOfSupportingAttackOptions, textAmplifiers?: CanonicalTextAmplifiers, context?: ControlMeasureGeneratorContext): FeatureCollection<MultiLineString | Point>;
 //#endregion
 //#region src/generators/cm14-maneuver-lines/principalDirectionOfFire.d.ts
 /**
@@ -581,6 +1007,119 @@ declare const DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS: Required<PrincipalDir
  */
 declare function createPrincipalDirectionOfFire(coordinates: Position[], options?: PrincipalDirectionOfFireOptions): FeatureCollection<MultiLineString, Record<string, never>>;
 //#endregion
+//#region src/generators/cm14-maneuver-lines/secondaryDirectionOfFire.d.ts
+/** Configuration options for the Secondary Direction of Fire tactical symbol. */
+type SecondaryDirectionOfFireOptions = PrincipalDirectionOfFireOptions;
+declare const DEFAULT_SECONDARY_DIRECTION_OF_FIRE_OPTIONS: Required<SecondaryDirectionOfFireOptions>;
+/** Dash and gap lengths used by the two fire-direction arms. */
+declare const SECONDARY_DIRECTION_OF_FIRE_DASH: readonly [6, 4];
+interface SecondaryDirectionOfFireProperties extends Record<string, unknown> {
+  part: "arms" | "arrowheads";
+  style: {
+    strokeDash: number[];
+  };
+}
+/**
+ * Creates the same V-shaped field-of-fire geometry as Principal Direction of
+ * Fire, with dashed arms and solid open arrowheads.
+ *
+ * @param coordinates - [PT 1 (vertex), PT 2 (tip), PT 3 (tip)]
+ * @param options - Arrowhead sizing parameters
+ */
+declare function createSecondaryDirectionOfFire(coordinates: Position[], options?: SecondaryDirectionOfFireOptions): FeatureCollection<MultiLineString, SecondaryDirectionOfFireProperties>;
+//#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";
+  /** Render an opaque light backdrop behind text placed over patterned geometry. */
+  textBackground?: boolean;
+  /** Render a contrast-aware halo behind the glyphs so text stays legible on busy backgrounds. */
+  textHalo?: boolean;
+  /** Halo color contrasting with the resolved text color; present only when `textHalo` is set. */
+  textHaloColor?: string;
+  /** Canonical field key for a text-amplifier label that may be repositioned. */
+  amplifierField?: TextAmplifierKey;
+  /** Stable key used to persist a user-adjusted anchor for any rendered label. */
+  labelPlacementKey?: string;
+  /**
+   * 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;
+  /**
+   * Multi-line justification within the text block (Text's `textAlign`
+   * option); the block itself stays centered on the anchor regardless of this
+   * value — unrelated to the block-shifting `textAnchor`.
+   */
+  textJustify?: "left" | "center" | "right";
+  /** Closed typography preset for a text label (Text's `textStyle` option). */
+  textStyle?: "regular" | "italic" | "light" | "caps";
+  /**
+   * Hide threshold in CSS pixels: when the derived on-screen text size exceeds
+   * this, adapters render nothing for the label instead of clamping (ADR-0037)
+   * and skip the default 8-24px ground clamp band.
+   */
+  textMaxSizePixels?: number;
+}
+/**
+ * Output of `renderControlMeasure`. A GeoJSON `FeatureCollection` whose
+ * features satisfy the `FeaturePartProps` stable-id contract. See ADR-0010.
+ */
+type ControlMeasureRender = FeatureCollection<Geometry, FeaturePartProps>;
+/**
+ * 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/generators/cm14-maneuver-lines/finalProtectiveFire.d.ts
 /**
  * Configuration options for the Final Protective Fire tactical symbols.
@@ -594,70 +1133,384 @@ interface FinalProtectiveFireOptions {
   /** 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).
+   * 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;
+  style?: StyleHints;
+};
+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 masks the
+ * boundary with a knockout gap wherever its text box touches the ring
+ * (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, context?: ControlMeasureGeneratorContext): 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, context?: ControlMeasureGeneratorContext): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/area-defense.d.ts
+interface AreaDefenseOptions extends LabelSizeOptions {
+  /** Angular opening between the two arrow tips, in degrees. */
+  arrowOpeningAngle?: number;
+  /** Angular opening occupied by the AD label, in degrees. */
+  labelOpeningAngle?: number;
+  /** Number of filled outward barbs distributed over both arcs. */
+  barbCount?: number;
+  /** Barb height as a ratio of the radius. */
+  barbLengthRatio?: number;
+  /** Open-arrowhead length as a ratio of the radius. */
+  arrowheadLengthRatio?: number;
+}
+declare const DEFAULT_AREA_DEFENSE_OPTIONS: Required<Omit<AreaDefenseOptions, keyof LabelSizeOptions>>;
+declare function createAreaDefense(coordinates: Position[], options?: AreaDefenseOptions): FeatureCollection<MultiLineString | MultiPolygon | 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, context?: ControlMeasureGeneratorContext): 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, context?: ControlMeasureGeneratorContext): 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, context?: ControlMeasureGeneratorContext): 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, context?: ControlMeasureGeneratorContext): 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, context?: ControlMeasureGeneratorContext): 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, context?: ControlMeasureGeneratorContext): 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, context?: ControlMeasureGeneratorContext): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/limitedAccessArea.d.ts
+/** Configuration options for the Limited Access Area control measure. */
+interface LimitedAccessAreaOptions extends AreaLabelOptions {
+  /** Round the area's corners through its control points. */
+  smooth?: boolean;
+  /** Number of samples per segment when smoothing is enabled. */
+  smoothResolution?: number;
+}
+/** Creates a back-hatched free area with a movable "LAA" label, centered by default. */
+declare function createLimitedAccessArea(positions: Position[], options?: LimitedAccessAreaOptions, textAmplifiers?: CanonicalTextAmplifiers, context?: ControlMeasureGeneratorContext): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm24-fire-areas/noFireAreaIrregular.d.ts
+/** Configuration options for the irregular No Fire Area control measure. */
+interface NoFireAreaIrregularOptions extends AreaLabelOptions {
+  /** Round the area's corners through its control points. */
+  smooth?: boolean;
+  /** Number of samples per segment when smoothing is enabled. */
+  smoothResolution?: number;
+}
+/** Creates a back-hatched irregular NFA with its centered movable label fields. */
+declare function createNoFireAreaIrregular(positions: Position[], options?: NoFireAreaIrregularOptions, textAmplifiers?: CanonicalTextAmplifiers, context?: ControlMeasureGeneratorContext): 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, context?: ControlMeasureGeneratorContext): 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) plus
+ * an `N` (Field N) ENY marker, per {@link labeledAreaFeatures}.
+ */
+declare function createAssaultPosition(positions: Position[], options?: AssaultPositionOptions, textAmplifiers?: CanonicalTextAmplifiers, context?: ControlMeasureGeneratorContext): 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) plus
+ * an `N` (Field N) ENY marker, per {@link labeledAreaFeatures}.
+ */
+declare function createAttackPosition(positions: Position[], options?: AttackPositionOptions, textAmplifiers?: CanonicalTextAmplifiers, context?: ControlMeasureGeneratorContext): 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) plus
+ * an `N` (Field N) ENY marker, per {@link labeledAreaFeatures}.
+ */
+declare function createObjectiveArea(positions: Position[], options?: ObjectiveAreaOptions, textAmplifiers?: CanonicalTextAmplifiers, context?: ControlMeasureGeneratorContext): 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, context?: ControlMeasureGeneratorContext): 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) plus
+ * an `N` (Field N) ENY marker, per {@link labeledAreaFeatures}.
+ */
+declare function createNamedAreaOfInterest(positions: Position[], options?: NamedAreaOfInterestOptions, textAmplifiers?: CanonicalTextAmplifiers, context?: ControlMeasureGeneratorContext): 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) plus
+ * an `N` (Field N) ENY marker, per {@link labeledAreaFeatures}.
+ */
+declare function createTargetAreaOfInterest(positions: Position[], options?: TargetAreaOfInterestOptions, textAmplifiers?: CanonicalTextAmplifiers, context?: ControlMeasureGeneratorContext): 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 (placed east of the area) plus an optional
+ *   Field N "ENY" hostile marker on the west/east edges.
+ */
+declare function createAirfieldZone(positions: Position[], options?: AirfieldZoneOptions, textAmplifiers?: CanonicalTextAmplifiers, context?: ControlMeasureGeneratorContext): 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
    */
-  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. */
-interface EncirclementOptions {
+  echelonSizePixels?: number;
   /**
-   * 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
+   * 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
    */
-  barbSpacingRatio?: number;
+  echelonPadding?: number;
   /**
-   * Barb length (height/amplitude) as a ratio of the symbol's mean radius.
-   * @default 0.16
+   * 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
    */
-  barbLengthRatio?: number;
+  echelonPosition?: number;
   /**
-   * Round the boundary by curving it through the control points (closed
-   * centripetal Catmull-Rom) before tracing the barbs.
-   * @default true
+   * 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.
    */
-  smooth?: boolean;
+  echelonAnchor?: number;
   /**
-   * Number of samples per segment when `smooth` is enabled.
-   * @default 16
+   * Meters-per-pixel at the current zoom/latitude. Stamped by the host when
+   * the measure is screen-anchored; required to resolve `echelonSizePixels`.
    */
-  smoothResolution?: number;
+  metersPerPixel?: number;
 }
-/** Default options for the Encirclement control measure. */
-declare const DEFAULT_ENCIRCLEMENT_OPTIONS: Required<EncirclementOptions>;
+//#endregion
+//#region src/generators/cm12-command-control-areas/base-camp.d.ts
+/** Configuration options for the Base camp control measure. */
+type BaseCampOptions = EchelonLabeledAreaOptions;
 /**
- * Creates an Encirclement tactical graphic: a complete smooth boundary ring
- * with outward arrowhead barbs resting on it. The boundary is an unfilled
- * Polygon; the barbs are open "V" strokes (a MultiLineString) whose base is the
- * boundary arc itself.
- *
- * @param positions - Area anchor points (>=3); the input contract is enforced
- *   at the render seam (ADR-0014).
- * @param options - {@link EncirclementOptions}.
+ * 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 createEncirclement(positions: Position[], options?: EncirclementOptions): FeatureCollection<Polygon | MultiLineString>;
+declare function createBaseCamp(positions: Position[], options?: BaseCampOptions, textAmplifiers?: CanonicalTextAmplifiers, context?: ControlMeasureGeneratorContext): FeatureCollection<Polygon | MultiLineString | MultiPolygon | Point>;
 //#endregion
-//#region src/projection.d.ts
-type Point2D = [number, number];
+//#region src/generators/cm12-command-control-areas/guerrilla-base.d.ts
+/** Configuration options for the Guerrilla base control measure. */
+type GuerrillaBaseOptions = EchelonLabeledAreaOptions;
 /**
- * Project WGS84 (Lon/Lat) to Web Mercator (Meters).
+ * 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 const project: (lon: number, lat: number) => Point2D;
+declare function createGuerrillaBase(positions: Position[], options?: GuerrillaBaseOptions, textAmplifiers?: CanonicalTextAmplifiers, context?: ControlMeasureGeneratorContext): 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;
 /**
- * Unproject Web Mercator (Meters) back to WGS84 (Lon/Lat).
+ * 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 const unproject: (x: number, y: number) => Position;
+declare function createGenericC2Area(positions: Position[], options?: GenericC2AreaOptions, textAmplifiers?: CanonicalTextAmplifiers, context?: ControlMeasureGeneratorContext): FeatureCollection<Polygon | MultiLineString | Point>;
 //#endregion
 //#region src/attack-utils.d.ts
 interface AttackOptions {
@@ -767,6 +1620,7 @@ declare const DEFAULT_CLASSIC_ARROW_OPTIONS: Required<ClassicArrowOptions>;
 declare function createClassicArrow(coordinates: Position[], options?: ClassicArrowOptions): FeatureCollection<LineString | Polygon, {
   part: "shaft" | "head";
   fill?: boolean;
+  style?: StyleHints;
 }>;
 //#endregion
 //#region src/generators/cm99-generic-arrows/blockArrow.d.ts
@@ -856,6 +1710,49 @@ declare function createGenericCircle(coordinates: Position[], options?: GenericC
   fill: boolean;
 }>;
 //#endregion
+//#region src/generators/cm99-generic-graphics/text.d.ts
+/** Configuration options for the generic Text control measure. */
+interface GenericTextOptions {
+  /** Plain text; explicit `\n` breaks lines — never auto-wraps. @default "Text" */
+  text?: string;
+  /**
+   * Placement of the text block relative to the anchor point, and the
+   * justification of its lines. `left` puts the anchor at the block's left edge
+   * (text extends rightward, lines left-justified); `right` puts the anchor at
+   * the right edge (text extends leftward, lines right-justified); `center`
+   * centers the block on the anchor (lines centered). Maps onto the existing
+   * block-shifting `textAnchor` prop (`left` → `start`, `right` → `end`, `center`
+   * → none) plus the `textJustify` prop; rotation always pivots at the anchor.
+   * @default "center"
+   */
+  textAlign?: "left" | "center" | "right";
+  /** Closed typography preset. `caps` uppercases `regular`; `light` is weight 300. @default "regular" */
+  textStyle?: "regular" | "italic" | "light" | "caps";
+  /** Clockwise rotation in degrees on screen. @default 0 */
+  rotation?: number;
+  /**
+   * Text height (cap height) in projected meters — ground-anchored
+   * (ADR-0020). Ignored whenever `sizePixels` is present.
+   */
+  sizeMeters?: number;
+  /**
+   * Text height in CSS pixels — screen-anchored (ADR-0020). A fresh draw is
+   * authored in pixels and bakes to `sizeMeters` on commit.
+   * @default 24
+   */
+  sizePixels?: number;
+  /**
+   * Hide threshold in CSS pixels: once the ground-derived on-screen size
+   * exceeds this, adapters hide the text entirely instead of clamping it
+   * (ADR-0037); there is no minimum, so the text just keeps shrinking on
+   * zoom-out.
+   * @default 200
+   */
+  maxSizePixels?: number;
+}
+declare const DEFAULT_GENERIC_TEXT_OPTIONS: GenericTextOptions;
+declare function createGenericText(coordinates: Position[], options?: GenericTextOptions): FeatureCollection<Point, Record<string, unknown>>;
+//#endregion
 //#region src/generators/cm15-maneuver-areas/airborneAttack.d.ts
 type AirborneAttackOptions = AttackOptions;
 declare const DEFAULT_AIRBORNE_ATTACK_OPTIONS: Required<AirborneAttackOptions>;
@@ -935,7 +1832,7 @@ declare function createAttackByFire(coordinates: Position[], options?: AttackByF
 /**
  * Configuration options for the FLOT (Forward Line of Own Troops) geometry.
  */
-interface FLOTOptions {
+interface FLOTOptions extends SmoothLineOptions, LineLabelOptions {
   /**
    * The radius of the semicircular arcs in meters.
    * Semicircles are placed tangent to each other (diameter = 2 * radius).
@@ -967,7 +1864,7 @@ interface FLOTOptions {
 /**
  * Default options for the FLOT graphic.
  */
-declare const DEFAULT_FLOT_OPTIONS: Required<Omit<FLOTOptions, "metersPerPixel">>;
+declare const DEFAULT_FLOT_OPTIONS: Required<Omit<FLOTOptions, keyof LineLabelOptions>>;
 /**
  * Creates a FLOT (Forward Line of Own Troops) tactical graphic.
  *
@@ -987,20 +1884,155 @@ declare const DEFAULT_FLOT_OPTIONS: Required<Omit<FLOTOptions, "metersPerPixel">
  * );
  * ```
  */
-declare function createFLOT(positions: Position[], options?: FLOTOptions): FeatureCollection<LineString>;
+declare function createFLOT(positions: Position[], options?: FLOTOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<LineString | Point>;
+//#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/forward-edge-of-battle-area.d.ts
+/** Configuration options for the Forward edge of the battle area control measure. */
+interface ForwardEdgeOfBattleAreaOptions extends LineLabelOptions, SmoothLineOptions {
+  /**
+   * Optional phase line naming: renders `PL <name>` just beyond each end of
+   * the line, additive to the fixed "FEBA" labels. Empty or whitespace-only
+   * renders no label.
+   * @default none
+   */
+  phaseLineName?: string;
+  /**
+   * Prefix the `phaseLineName` label with "PL" (`"PL MOCHA"`, or a bare
+   * "MOCHA" when `false`). No effect when `phaseLineName` is empty.
+   * @default true
+   */
+  includePrefix?: boolean;
+}
+/** Default options for the Forward edge of the battle area control measure. */
+declare const DEFAULT_FORWARD_EDGE_OF_BATTLE_AREA_OPTIONS: ForwardEdgeOfBattleAreaOptions;
+/**
+ * Creates a Forward edge of the battle area control measure: a polyline
+ * through `positions` labeled "FEBA" above the line near each end.
+ */
+declare function createForwardEdgeOfBattleArea(positions: Position[], options?: ForwardEdgeOfBattleAreaOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<LineString | Point>;
+//#endregion
+//#region src/generators/cm14-maneuver-lines/bridgehead-line.d.ts
+/** Configuration options for the Bridgehead line control measure. */
+interface BridgeheadLineOptions extends LineLabelOptions, SmoothLineOptions {
+  /** Optional phase-line name rendered beyond both ends of the line. */
+  phaseLineName?: string;
+  /** Prefix the phase-line name with "PL". @default true */
+  includePrefix?: boolean;
+}
+/** Default options for the Bridgehead line control measure. */
+declare const DEFAULT_BRIDGEHEAD_LINE_OPTIONS: BridgeheadLineOptions;
+/** Creates a Bridgehead line labeled "BL" above both ends. */
+declare function createBridgeheadLine(positions: Position[], options?: BridgeheadLineOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<LineString | Point>;
+//#endregion
+//#region src/generators/cm14-maneuver-lines/holding-line.d.ts
+/** Configuration options for the Holding line control measure. */
+interface HoldingLineOptions extends LineLabelOptions, SmoothLineOptions {
+  /** Optional phase-line name rendered beyond both ends of the line. */
+  phaseLineName?: string;
+  /** Prefix the phase-line name with "PL". @default true */
+  includePrefix?: boolean;
+}
+/** Default options for the Holding line control measure. */
+declare const DEFAULT_HOLDING_LINE_OPTIONS: HoldingLineOptions;
+/** Creates a Holding line labeled "HL" above both ends. */
+declare function createHoldingLine(positions: Position[], options?: HoldingLineOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<LineString | Point>;
+//#endregion
+//#region src/generators/cm14-maneuver-lines/release-line.d.ts
+/** Configuration options for the Release line control measure. */
+interface ReleaseLineOptions extends LineLabelOptions, SmoothLineOptions {
+  /** Optional phase-line name rendered beyond both ends of the line. */
+  phaseLineName?: string;
+  /** Prefix the phase-line name with "PL". @default true */
+  includePrefix?: boolean;
+}
+/** Default options for the Release line control measure. */
+declare const DEFAULT_RELEASE_LINE_OPTIONS: ReleaseLineOptions;
+/** Creates a Release line labeled "RL" above both ends. */
+declare function createReleaseLine(positions: Position[], options?: ReleaseLineOptions, 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, textAmplifiers?: CanonicalTextAmplifiers): 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, textAmplifiers?: CanonicalTextAmplifiers): 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;
-  /** Label height in CSS pixels at the draw/reference zoom. */
+  /** 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;
-  /** Map zoom at which labelSizePixels was captured. */
-  labelSizeZoom?: number;
-  /** Map resolution at which labelSizePixels was captured. */
-  labelSizeResolution?: number;
 }
-declare const DEFAULT_BLOCK_MISSION_TASK_OPTIONS: Required<Omit<BlockMissionTaskOptions, "labelSizePixels" | "labelSizeZoom" | "labelSizeResolution">>;
+declare const DEFAULT_BLOCK_MISSION_TASK_OPTIONS: Required<Omit<BlockMissionTaskOptions, "labelSize" | "labelSizePixels">>;
 /**
  * Generates a GeoJSON FeatureCollection for a BLOCK mission task symbol (340100).
  *
@@ -1024,17 +2056,15 @@ interface BreachOptions {
   tickAngle?: number;
   /** Gap for the 'B' label as a ratio of the front length (default: 0.2) */
   labelGapRatio?: number;
-  /** Label height in CSS pixels at the draw/reference zoom. */
+  /** 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;
-  /** Map zoom at which labelSizePixels was captured. */
-  labelSizeZoom?: number;
-  /** Map resolution at which labelSizePixels was captured. */
-  labelSizeResolution?: number;
 }
 /**
  * Default options for the BREACH symbol.
  */
-declare const DEFAULT_BREACH_OPTIONS: Required<Omit<BreachOptions, "labelSizePixels" | "labelSizeZoom" | "labelSizeResolution">>;
+declare const DEFAULT_BREACH_OPTIONS: Required<Omit<BreachOptions, "labelSize" | "labelSizePixels">>;
 /**
  * Generates a GeoJSON FeatureCollection for a BREACH mission task symbol (340200).
  *
@@ -1057,17 +2087,15 @@ interface BypassOptions {
   arrowheadLengthRatio?: number;
   /** Gap for the 'B' label as a ratio of the front length (default: 0.2) */
   labelGapRatio?: number;
-  /** Label height in CSS pixels at the draw/reference zoom. */
+  /** 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;
-  /** Map zoom at which labelSizePixels was captured. */
-  labelSizeZoom?: number;
-  /** Map resolution at which labelSizePixels was captured. */
-  labelSizeResolution?: number;
 }
 /**
  * Default options for the BYPASS symbol.
  */
-declare const DEFAULT_BYPASS_OPTIONS: Required<Omit<BypassOptions, "labelSizePixels" | "labelSizeZoom" | "labelSizeResolution">>;
+declare const DEFAULT_BYPASS_OPTIONS: Required<Omit<BypassOptions, "labelSize" | "labelSizePixels">>;
 /**
  * Generates a GeoJSON FeatureCollection for a BYPASS mission task symbol (340300).
  *
@@ -1092,17 +2120,15 @@ interface CanalizeOptions {
   tickAngle?: number;
   /** Gap for the 'C' label as a ratio of the front length (default: 0.2) */
   labelGapRatio?: number;
-  /** Label height in CSS pixels at the draw/reference zoom. */
+  /** 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;
-  /** Map zoom at which labelSizePixels was captured. */
-  labelSizeZoom?: number;
-  /** Map resolution at which labelSizePixels was captured. */
-  labelSizeResolution?: number;
 }
 /**
  * Default options for the CANALIZE symbol.
  */
-declare const DEFAULT_CANALIZE_OPTIONS: Required<Omit<CanalizeOptions, "labelSizePixels" | "labelSizeZoom" | "labelSizeResolution">>;
+declare const DEFAULT_CANALIZE_OPTIONS: Required<Omit<CanalizeOptions, "labelSize" | "labelSizePixels">>;
 /**
  * Generates a GeoJSON FeatureCollection for a CANALIZE mission task symbol (340400).
  *
@@ -1133,17 +2159,15 @@ interface ClearOptions {
   arrowheadWidthRatio?: number;
   /** Gap for the 'C' label as a ratio of the shaft length (default: 0.2). */
   labelGapRatio?: number;
-  /** Label height in CSS pixels at the draw/reference zoom. */
+  /** 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;
-  /** Map zoom at which labelSizePixels was captured. */
-  labelSizeZoom?: number;
-  /** Map resolution at which labelSizePixels was captured. */
-  labelSizeResolution?: number;
 }
 /**
  * Default options for the CLEAR symbol.
  */
-declare const DEFAULT_CLEAR_OPTIONS: Required<Omit<ClearOptions, "labelSizePixels" | "labelSizeZoom" | "labelSizeResolution">>;
+declare const DEFAULT_CLEAR_OPTIONS: Required<Omit<ClearOptions, "labelSize" | "labelSizePixels">>;
 /**
  * Generates a GeoJSON FeatureCollection for a CLEAR mission task symbol (340500).
  *
@@ -1167,6 +2191,51 @@ declare const DEFAULT_CLEAR_OPTIONS: Required<Omit<ClearOptions, "labelSizePixel
  */
 declare function createClearSymbol(coordinates: Position[], options?: ClearOptions): FeatureCollection<MultiLineString | Point>;
 //#endregion
+//#region src/generators/cm34-mission-tasks/counterattack.d.ts
+interface CounterattackOptions extends AttackOptions, LabelSizeOptions {
+  /** CATK label position along the shaft, from tail (0) to arrowhead base (1). */
+  labelPosition?: number;
+}
+declare const DEFAULT_COUNTERATTACK_OPTIONS: Required<Omit<CounterattackOptions, keyof LabelSizeOptions>>;
+/** Generates the Counterattack mission task (340600). */
+declare function createCounterattack(coordinates: Position[], options?: CounterattackOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<LineString | Point>;
+//#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
+//#region src/generators/cm34-mission-tasks/security-task-shared.d.ts
+interface SecurityTaskOptions extends TacticalArrowOptions {
+  /** Position of each task letter inward from PT. 2/PT. 3 as a ratio of the opening. */
+  labelInsetRatio?: 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;
+}
+//#endregion
+//#region src/generators/cm34-mission-tasks/cover.d.ts
+type CoverOptions = SecurityTaskOptions;
+declare const DEFAULT_COVER_OPTIONS: Required<Omit<SecurityTaskOptions, "labelSize" | "labelSizePixels">>;
+declare function createCoverSymbol(coordinates: Position[], options?: CoverOptions): 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). */
@@ -1177,16 +2246,19 @@ interface DelayOptions {
   labelGapRatio?: number;
   /** Number of segments used to approximate the 180-degree arc (default: 32). */
   arcSegments?: number;
-  /** Label height in CSS pixels at the draw/reference zoom. */
+  /** 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;
-  /** Map zoom at which labelSizePixels was captured. */
-  labelSizeZoom?: number;
-  /** Map resolution at which labelSizePixels was captured. */
-  labelSizeResolution?: number;
 }
-declare const DEFAULT_DELAY_OPTIONS: Required<Omit<DelayOptions, "labelSizePixels" | "labelSizeZoom" | "labelSizeResolution">>;
+declare 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/guard.d.ts
+type GuardOptions = SecurityTaskOptions;
+declare const DEFAULT_GUARD_OPTIONS: Required<Omit<SecurityTaskOptions, "labelSize" | "labelSizePixels">>;
+declare function createGuardSymbol(coordinates: Position[], options?: GuardOptions): FeatureCollection<MultiLineString | Point>;
+//#endregion
 //#region src/generators/cm34-mission-tasks/isolate.d.ts
 /**
  * Configuration options for the ISOLATE tactical mission task symbol.
@@ -1221,8 +2293,13 @@ interface IsolateOptions {
  */
 declare function createIsolateSymbol(coordinates: Position[], options?: IsolateOptions): FeatureCollection<MultiLineString>;
 //#endregion
+//#region src/generators/cm34-mission-tasks/screen.d.ts
+type ScreenOptions = SecurityTaskOptions;
+declare const DEFAULT_SCREEN_OPTIONS: Required<Omit<SecurityTaskOptions, "labelSize" | "labelSizePixels">>;
+declare function createScreenSymbol(coordinates: Position[], options?: ScreenOptions): FeatureCollection<MultiLineString | Point>;
+//#endregion
 //#region src/generators/cm29-protection-lines/antitankDitch.d.ts
-interface AntitankDitchOptions {
+interface AntitankDitchOptions extends SmoothLineOptions, LineLabelOptions {
   /**
    * The tooth depth in meters. Target tooth spacing is roughly 1.15x this depth.
    * Ignored when toothHeightPixels is provided with metersPerPixel.
@@ -1247,14 +2324,9 @@ interface AntitankDitchOptions {
    */
   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;
-}>;
+declare const DEFAULT_ANTITANK_DITCH_OPTIONS: Required<Omit<AntitankDitchOptions, keyof LineLabelOptions>>;
+declare function createAntitankDitchUnderConstruction(positions: Position[], options?: AntitankDitchOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<MultiLineString | Point>;
+declare function createAntitankDitchCompleted(positions: Position[], options?: AntitankDitchOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<MultiPolygon | Point>;
 //#endregion
 //#region src/generators/cm29-protection-lines/antitankWall.d.ts
 interface AntitankWallOptions extends AntitankDitchOptions {
@@ -1265,16 +2337,14 @@ interface AntitankWallOptions extends AntitankDitchOptions {
    */
   toothSpacingRatio?: number;
 }
-declare const DEFAULT_ANTITANK_WALL_OPTIONS: Required<Omit<AntitankWallOptions, "metersPerPixel">>;
-declare function createAntitankWall(positions: Position[], options?: AntitankWallOptions): FeatureCollection<MultiLineString, {
-  part: "wall";
-}>;
+declare const DEFAULT_ANTITANK_WALL_OPTIONS: Required<Omit<AntitankWallOptions, keyof LineLabelOptions>>;
+declare function createAntitankWall(positions: Position[], options?: AntitankWallOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<MultiLineString | Point>;
 //#endregion
 //#region src/generators/cm29-protection-lines/fortifiedLine.d.ts
 /**
  * Configuration options for the Fortified Line geometry.
  */
-interface FortifiedLineOptions {
+interface FortifiedLineOptions extends LineLabelOptions {
   /**
    * The size of the square teeth in meters.
    * This controls both the width and height of the castellated pattern.
@@ -1314,7 +2384,7 @@ interface FortifiedLineOptions {
 /**
  * Default options for the Fortified Line graphic.
  */
-declare const DEFAULT_FORTIFIED_LINE_OPTIONS: Required<Omit<FortifiedLineOptions, "metersPerPixel">>;
+declare const DEFAULT_FORTIFIED_LINE_OPTIONS: Required<Omit<FortifiedLineOptions, keyof LineLabelOptions>>;
 /**
  * Creates a Fortified Line tactical graphic.
  *
@@ -1325,16 +2395,20 @@ declare const DEFAULT_FORTIFIED_LINE_OPTIONS: Required<Omit<FortifiedLineOptions
  * @param options - Configuration options for the graphic
  * @returns A GeoJSON FeatureCollection containing the castellated LineString
  */
-declare function createFortifiedLine(positions: Position[], options?: FortifiedLineOptions): FeatureCollection<LineString>;
+declare function createFortifiedLine(positions: Position[], options?: FortifiedLineOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<LineString | Point>;
 //#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.
+ * 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;
-declare const DEFAULT_FORTIFIED_AREA_OPTIONS: Required<Omit<FortifiedLineOptions, "metersPerPixel">>;
+type FortifiedAreaOptions = FortifiedLineOptions & AreaLabelOptions;
+declare const DEFAULT_FORTIFIED_AREA_OPTIONS: FortifiedAreaOptions;
 /**
  * Creates a Fortified Area tactical graphic.
  *
@@ -1345,9 +2419,42 @@ declare const DEFAULT_FORTIFIED_AREA_OPTIONS: Required<Omit<FortifiedLineOptions
  *                    The first and last positions should match to close the polygon,
  *                    or it will be closed automatically.
  * @param options - Configuration options for the graphic
- * @returns A GeoJSON FeatureCollection containing the castellated Polygon
- */
-declare function createFortifiedArea(positions: Position[], options?: FortifiedAreaOptions): FeatureCollection<Polygon>;
+ * @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), and an optional Field N "ENY" hostile marker on
+ *   that ring's west/east edges, masking the castellated boundary beneath it.
+ * @param context - Persisted amplifier placements used to move or restore each
+ *   ENY cutout with its independently dragged label.
+ * @returns A GeoJSON FeatureCollection containing the castellated boundary
+ *   (a Polygon normally, or a gapped MultiLineString with Field N) plus any
+ *   label Points
+ */
+declare function createFortifiedArea(positions: Position[], options?: FortifiedAreaOptions, textAmplifiers?: CanonicalTextAmplifiers, context?: ControlMeasureGeneratorContext): FeatureCollection<Polygon | MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/maneuver-arrow-task-shared.d.ts
+interface ManeuverArrowTaskOptions extends AttackOptions, LabelSizeOptions {
+  /** Straight crossbar length as a multiple of the arrowhead base width. */
+  crossbarLengthRatio?: number;
+  /** Field T position along the shaft, from tail (0) to head (1). */
+  labelPosition?: number;
+  /** W/W1 position along the shaft, from tail (0) to head (1). */
+  dtgPosition?: number;
+  /** Extra W/W1 row spacing, in label heights. */
+  labelPadding?: number;
+}
+//#endregion
+//#region src/generators/cm15-maneuver-areas/frontal-attack.d.ts
+type FrontalAttackOptions = ManeuverArrowTaskOptions;
+declare const DEFAULT_FRONTAL_ATTACK_OPTIONS: FrontalAttackOptions;
+declare function createFrontalAttack(coordinates: Position[], options?: FrontalAttackOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm15-maneuver-areas/turning-movement.d.ts
+interface TurningMovementOptions extends ManeuverArrowTaskOptions {
+  /** Crossbar position along the shaft, from tail (0) to arrowhead base (1). */
+  crossbarPosition?: number;
+}
+declare const DEFAULT_TURNING_MOVEMENT_OPTIONS: TurningMovementOptions;
+declare function createTurningMovement(coordinates: Position[], options?: TurningMovementOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<MultiLineString | Point>;
 //#endregion
 //#region src/generators/cm27-protection-areas/block.d.ts
 type BlockOptions = Record<never, never>;
@@ -1493,17 +2600,47 @@ declare function createObstacleBypassImpossible(coordinates: Position[], options
  */
 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>>>;
+  "direction-of-attack-aviation": ControlMeasureDefinition<"direction-of-attack-aviation", typeof createDirectionOfAttackAviation>;
+  "direction-of-main-attack": ControlMeasureDefinition<"direction-of-main-attack", typeof createDirectionOfMainAttack>;
+  "direction-of-supporting-attack": ControlMeasureDefinition<"direction-of-supporting-attack", typeof createDirectionOfSupportingAttack>;
   "principal-direction-of-fire": ControlMeasureDefinition<"principal-direction-of-fire", typeof createPrincipalDirectionOfFire>;
+  "secondary-direction-of-fire": ControlMeasureDefinition<"secondary-direction-of-fire", typeof createSecondaryDirectionOfFire>;
   "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;
+    style?: StyleHints;
   }>>;
   encirclement: ControlMeasureDefinition<"encirclement", typeof createEncirclement>;
+  area: ControlMeasureDefinition<"area", typeof createArea>;
+  "area-defense": ControlMeasureDefinition<"area-defense", typeof createAreaDefense>;
+  "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>;
+  "limited-access-area": ControlMeasureDefinition<"limited-access-area", typeof createLimitedAccessArea>;
+  "no-fire-area-irregular": ControlMeasureDefinition<"no-fire-area-irregular", typeof createNoFireAreaIrregular>;
+  "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>;
@@ -1512,23 +2649,37 @@ declare const DEFINITIONS: {
   polygon: ControlMeasureDefinition<"polygon", typeof createGenericPolygon>;
   rectangle: ControlMeasureDefinition<"rectangle", typeof createGenericRectangle>;
   circle: ControlMeasureDefinition<"circle", typeof createGenericCircle>;
+  text: ControlMeasureDefinition<"text", typeof createGenericText>;
   "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>;
+  "forward-edge-of-battle-area": ControlMeasureDefinition<"forward-edge-of-battle-area", typeof createForwardEdgeOfBattleArea>;
+  "bridgehead-line": ControlMeasureDefinition<"bridgehead-line", typeof createBridgeheadLine>;
+  "holding-line": ControlMeasureDefinition<"holding-line", typeof createHoldingLine>;
+  "release-line": ControlMeasureDefinition<"release-line", typeof createReleaseLine>;
+  "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>;
+  counterattack: ControlMeasureDefinition<"counterattack", typeof createCounterattack>;
+  cover: ControlMeasureDefinition<"cover", typeof createCoverSymbol>;
   delay: ControlMeasureDefinition<"delay", typeof createDelaySymbol>;
+  guard: ControlMeasureDefinition<"guard", typeof createGuardSymbol>;
   isolate: ControlMeasureDefinition<"isolate", typeof createIsolateSymbol>;
+  screen: ControlMeasureDefinition<"screen", typeof createScreenSymbol>;
   "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>;
+  "frontal-attack": ControlMeasureDefinition<"frontal-attack", typeof createFrontalAttack>;
+  "turning-movement": ControlMeasureDefinition<"turning-movement", typeof createTurningMovement>;
   block: ControlMeasureDefinition<"block", typeof createBlock>;
   disrupt: ControlMeasureDefinition<"disrupt", typeof createDisrupt>;
   fix: ControlMeasureDefinition<"fix", typeof createFix>;
@@ -1562,30 +2713,6 @@ declare function getControlMeasureMetadata(id: ControlMeasureId): ControlMeasure
 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;
@@ -1596,13 +2723,15 @@ interface ControlMeasure<K extends ControlMeasureKind = ControlMeasureKind> {
   properties?: Record<string, unknown>;
   /** Free-text amplifier fields (MIL-STD-2525E Appendix L Table L-II); see `./text-amplifiers`. */
   textAmplifiers?: TextAmplifiers;
+  /** Optional user-adjusted anchors for independently rendered text amplifiers. */
+  amplifierPlacements?: AmplifierPlacements;
   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
+ * `graphic` half of TacticalDraw's `GraphicSnapshot`. 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.
@@ -1613,82 +2742,6 @@ declare function isKind<K extends ControlMeasureKind>(cm: ControlMeasure, kind:
  */
 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";
-  /** Label size in CSS pixels at the draw/reference zoom. */
-  textSizePixels?: number;
-  /** Map zoom at which textSizePixels was captured. */
-  textSizeZoom?: number;
-  /** Map resolution at which textSizePixels was captured. */
-  textSizeResolution?: number;
-}
-/**
- * Output of `renderControlMeasure`. A GeoJSON `FeatureCollection` whose
- * features satisfy the `FeaturePartProps` stable-id contract. See ADR-0010.
- */
-type ControlMeasureRender = FeatureCollection<Geometry, FeaturePartProps>;
-/**
- * A `ControlMeasure` paired with its `Render` at a single point in time.
- *
- * The unit delivered to `EditChangeEvent` listeners (as `measure` and
- * `previous`) and resolved from `TacticalDraw.draw()` / `.edit()`. The
- * `measure` half is a defensive clone (see `cloneControlMeasure`) so held
- * references remain valid after the originating session has closed.
- *
- * See ADR-0010.
- */
-interface ControlMeasureSnapshot<K extends ControlMeasureKind = ControlMeasureKind> {
-  measure: ControlMeasure<K>;
-  render: ControlMeasureRender;
-}
-/**
- * Recover the originating control measure id (`cmId`) from a feature emitted
- * by `renderControlMeasure`. The feature id must match the stable-id contract
- * `${cmId}:${part}:${index}`; otherwise this throws.
- */
-declare function controlMeasureIdFromFeature(feature: Feature<Geometry, FeaturePartProps> | {
-  id?: string | number;
-}): string;
-//#endregion
 //#region src/renderControlMeasure.d.ts
 interface RenderOptions {
   validationMode?: ValidationMode;
@@ -1718,6 +2771,16 @@ declare function renderControlMeasure<K extends ControlMeasureKind>(cm: ControlM
  * 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;
+/**
+ * Dispatches to a measure kind's `transformOptions` hook (see
+ * {@link import("./define").ControlMeasureDefinition.transformOptions}), folding
+ * a box transform gesture's `delta` (screen-space scale/rotation) into option
+ * values for a graphic that persists orientation/size as options rather than in
+ * geometry. Returns an options patch to merge, or `undefined` when the kind
+ * declares no hook (or the hook finds nothing to fold). Edit hosts call this at
+ * a rotate/scale gesture's commit (ADR-0017).
+ */
+declare function applyBoxTransformOptions<K extends ControlMeasureKind>(kind: K, options: OptionsByKind[K] | undefined, delta: BoxTransformDelta): Partial<OptionsByKind[K]> | undefined;
 //#endregion
 //#region src/styleResolver.d.ts
 /**
@@ -1765,8 +2828,9 @@ type SimpleStyleRender = FeatureCollection<Geometry, SimpleStyleProps>;
  * 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.
+ *  - `strokeDash` and `fillPattern` have no simplestyle equivalent and are
+ *    dropped — dashed sub-lines and patterned fills 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.
  */
@@ -1830,6 +2894,8 @@ interface MidpointPerpendicularDrawRuleOptions {
   minimumUserPoints?: number;
   /** Raw points at which a live preview can be derived. See {@link ControlMeasureDrawRule}. */
   minimumPreviewPoints?: number;
+  /** Allow a repeated last point to commit the early derived preview. */
+  finishOnLastPointRepeat?: boolean;
   /**
    * Index of the slot whose point is constrained to the perpendicular axis
    * through the configured origin of the other two ("baseline") slots. Must be
@@ -1931,6 +2997,19 @@ declare const line23DrawRule: ControlMeasureDrawRule;
  */
 declare const line24DrawRule: ControlMeasureDrawRule;
 //#endregion
+//#region src/draw-rules/line26.d.ts
+/**
+ * Line26 anchor draw rule for the Cover, Guard, and Screen security tasks.
+ *
+ * PT. 1/PT. 4 are the outward arrow tips and PT. 2/PT. 3 bound the opening
+ * reserved for the supported tactical symbol. All four anchors are free: the
+ * two sides may independently touch the symbols that define the task limits.
+ * During drawing, the cursor after PT. 1 supplies a provisional PT. 2 and the
+ * rule mirrors that first leg across a temporary center opening, so the full
+ * symbol is visible before PT. 2 is committed.
+ */
+declare const line26DrawRule: ControlMeasureDrawRule;
+//#endregion
 //#region src/draw-rules/area8.d.ts
 declare const supportByFireDrawRule: ControlMeasureDrawRule;
 //#endregion
@@ -1960,25 +3039,4 @@ interface AmbushOptions {
 }
 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 $, DEFAULT_GENERIC_LINE_OPTIONS as $t, getMetersPerPixel as A, ControlMeasureMetadata as An, DEFAULT_CANALIZE_OPTIONS as At, ControlMeasureSnapshot as B, AnchorTransformEvent as Bn, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Bt, snapToMidpointPerpendicular as C, StrongPointOptions as Cn, AntitankDitchOptions as Ct, BaselineFrameOrigin as D, DEFAULT_BOUNDARY_OPTIONS as Dn, ClearOptions as Dt, BaselineFrameOptions as E, BoundaryOptions as En, DelayOptions as Et, resolveStyleHints as F, TextAmplifierField as Fn, BlockMissionTaskOptions as Ft, cloneControlMeasure as G, AirborneAttackOptions as Gt, StyleHints as H, SupportByFireOptions as Ht, freezeOrientationOptions as I, TextAmplifierKey as In, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as It, CONTROL_MEASURE_IDS as J, GenericCircleOptions as Jt, isKind as K, DEFAULT_AIRBORNE_ATTACK_OPTIONS as Kt, RenderOptions as L, TextAmplifiers as Ln, DEFAULT_FLOT_OPTIONS as Lt, SimpleStyleProps as M, TextAmplifierDescriptor as Mn, DEFAULT_BYPASS_OPTIONS as Mt, SimpleStyleRender as N, CanonicalTextAmplifiers as Nn, BreachOptions as Nt, createBaselineFrame as O, ControlMeasureGeometry as On, DEFAULT_CLEAR_OPTIONS as Ot, toSimpleStyle as P, TEXT_AMPLIFIER_FIELDS as Pn, DEFAULT_BREACH_OPTIONS as Pt, OptionsByKind as Q, GenericPolygonOptions as Qt, renderControlMeasure as R, canonicalTextAmplifierKey as Rn, FLOTOptions as Rt, pointOnMidpointPerpendicularAxis as S, DEFAULT_STRONG_POINT_OPTIONS as Sn, DEFAULT_ANTITANK_WALL_OPTIONS as St, BaselineFrameNormal as T, DEFAULT_BATTLE_POSITION_OPTIONS as Tn, DEFAULT_DELAY_OPTIONS as Tt, controlMeasureIdFromFeature as U, AttackHelicopterOptions as Ut, FeaturePartProps as V, ControlMeasureDrawRule as Vn, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as Vt, ControlMeasure as W, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Wt, ControlMeasureId as X, GenericRectangleOptions as Xt, CONTROL_MEASURE_METADATA as Y, DEFAULT_GENERIC_RECTANGLE_OPTIONS as Yt, ControlMeasureKind as Z, DEFAULT_GENERIC_POLYGON_OPTIONS as Zt, blockDrawRule as _, EncirclementOptions as _n, DEFAULT_FORTIFIED_AREA_OPTIONS as _t, rectangleDrawRule as a, ClassicArrowOptions as an, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as at, createMidpointPerpendicularDrawRule as b, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as bn, FortifiedLineOptions as bt, line24DrawRule as c, SupportingAttackOptions as cn, ObstacleBypassEasyOptions as ct, line1DrawRule as d, calculateMetrics as dn, DEFAULT_FIX_OPTIONS as dt, GenericLineOptions as en, getControlMeasureMetadataByValue as et, ambushDrawRule as f, computeInitialWidthPoint as fn, FixOptions as ft, disruptDrawRule as g, DEFAULT_ENCIRCLEMENT_OPTIONS as gn, DEFAULT_BLOCK_OPTIONS as gt, centerRadiusDrawRule as h, unproject as hn, BlockOptions as ht, DEFAULT_AMBUSH_OPTIONS as i, ClassicArrowHeadStyle as in, ObstacleBypassImpossibleOptions as it, roundToFixed as j, ParamDescriptor as jn, BypassOptions as jt, EPSILON as k, ControlMeasureGeometryType as kn, CanalizeOptions as kt, line23DrawRule as l, DEFAULT_MAIN_ATTACK_OPTIONS as ln, DEFAULT_TURN_OPTIONS as lt, point12DrawRule as m, project as mn, DisruptOptions as mt, TacticalArrowOptions as n, BlockArrowOptions as nn, listControlMeasureMetadata as nt, axis1DrawRule as o, DEFAULT_CLASSIC_ARROW_OPTIONS as on, ObstacleBypassDifficultOptions as ot, attackByFireDrawRule as p, Point2D as pn, DEFAULT_DISRUPT_OPTIONS as pt, ControlMeasureStyle as q, DEFAULT_GENERIC_CIRCLE_OPTIONS as qt, AmbushOptions as r, DEFAULT_BLOCK_ARROW_OPTIONS as rn, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as rt, supportByFireDrawRule as s, DEFAULT_SUPPORTING_ATTACK_OPTIONS as sn, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as st, DEFAULT_TACTICAL_ARROW_OPTIONS as t, BlockArrowHeadStyle as tn, getDefaultOptions as tt, turnDrawRule as u, MainAttackOptions as un, TurnOptions as ut, MidpointPerpendicularDrawRuleOptions as v, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as vn, FortifiedAreaOptions as vt, BaselineFrame as w, BattlePositionOptions as wn, DEFAULT_ANTITANK_DITCH_OPTIONS as wt, getMidpointPerpendicularSignedDistance as x, PrincipalDirectionOfFireOptions as xn, AntitankWallOptions as xt, computeDefaultMidpointPerpendicularPoint as y, FinalProtectiveFireOptions as yn, DEFAULT_FORTIFIED_LINE_OPTIONS as yt, ControlMeasureRender as z, normalizeTextAmplifiers as zn, AttackByFireOptions as zt };
+export { DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as $, ControlMeasureRender as $n, AnchorTransformEvent as $r, BridgeheadLineOptions as $t, roundToFixed as A, DEFAULT_CLASSIC_ARROW_OPTIONS as An, unproject as Ar, DEFAULT_COVER_OPTIONS as At, cloneControlMeasure as B, PickupZoneOptions as Bn, TextAmplifierDescriptor as Br, DEFAULT_BYPASS_OPTIONS as Bt, BaselineFrame as C, DEFAULT_GENERIC_LINE_OPTIONS as Cn, EngineerWorkLineOptions as Cr, DEFAULT_SCREEN_OPTIONS as Ct, createBaselineFrame as D, DEFAULT_BLOCK_ARROW_OPTIONS as Dn, Point2D as Dr, DEFAULT_DELAY_OPTIONS as Dt, BaselineFrameOrigin as E, BlockArrowOptions as En, LabelSizeOptions as Er, GuardOptions as Et, applyBoxTransformOptions as F, calculateMetrics as Fn, ControlMeasureGeometry as Fr, ClearOptions as Ft, ControlMeasureKind as G, AssemblyAreaOptions as Gn, LabelPlacementOverride as Gr, BattleHandoverLineOptions as Gt, CONTROL_MEASURE_IDS as H, LandingZoneOptions as Hn, AmplifierPlacements as Hr, DEFAULT_BREACH_OPTIONS as Ht, freezeOrientationOptions as I, computeInitialWidthPoint as In, ControlMeasureGeometryType as Ir, DEFAULT_CLEAR_OPTIONS as It, getControlMeasureMetadataByValue as J, DEFAULT_AREA_DEFENSE_OPTIONS as Jn, TextAmplifierKey as Jr, HandoverLineOptions as Jt, OptionsByKind as K, DEFAULT_ASSEMBLY_AREA_OPTIONS as Kn, TEXT_AMPLIFIER_FIELDS as Kr, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as Kt, RenderOptions as L, AreaOfOperationsOptions as Ln, ControlMeasureMetadata as Lr, CanalizeOptions as Lt, SimpleStyleRender as M, SupportingAttackOptions as Mn, DEFAULT_BOUNDARY_OPTIONS as Mr, TacticalArrowOptions as Mt, toSimpleStyle as N, DEFAULT_MAIN_ATTACK_OPTIONS as Nn, BoxTransformDelta as Nr, CounterattackOptions as Nt, EPSILON as O, ClassicArrowHeadStyle as On, haversineDistance as Or, DelayOptions as Ot, resolveStyleHints as P, MainAttackOptions as Pn, ControlMeasureFillCapability as Pr, DEFAULT_COUNTERATTACK_OPTIONS as Pt, ObstacleBypassImpossibleOptions as Q, FinalProtectiveFireOptions as Qn, resolveAmplifierPlacement as Qr, HoldingLineOptions as Qt, renderControlMeasure as R, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as Rn, ControlMeasurePaintCapability as Rr, DEFAULT_CANALIZE_OPTIONS as Rt, snapToMidpointPerpendicular as S, GenericPolygonOptions as Sn, DEFAULT_ENGINEER_WORK_LINE_OPTIONS as Sr, DEFAULT_ANTITANK_DITCH_OPTIONS as St, BaselineFrameOptions as T, BlockArrowHeadStyle as Tn, LightLineOptions as Tr, DEFAULT_GUARD_OPTIONS as Tt, CONTROL_MEASURE_METADATA as U, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as Un, CanonicalTextAmplifiers as Ur, BlockMissionTaskOptions as Ut, isKind as V, DEFAULT_LANDING_ZONE_OPTIONS as Vn, AmplifierPlacement as Vr, BreachOptions as Vt, ControlMeasureId as W, JointTacticalActionAreaOptions as Wn, GeneratedLabelKey as Wr, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as Wt, listControlMeasureMetadata as X, EncirclementOptions as Xn, canonicalTextAmplifierKey as Xr, ReleaseLineOptions as Xt, getDefaultOptions as Y, DEFAULT_ENCIRCLEMENT_OPTIONS as Yn, TextAmplifiers as Yr, DEFAULT_RELEASE_LINE_OPTIONS as Yt, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as Z, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as Zn, normalizeTextAmplifiers as Zr, DEFAULT_HOLDING_LINE_OPTIONS as Zt, MidpointPerpendicularDrawRuleOptions as _, DEFAULT_GENERIC_CIRCLE_OPTIONS as _n, DEFAULT_BATTLE_POSITION_OPTIONS as _r, DEFAULT_FORTIFIED_LINE_OPTIONS as _t, supportByFireDrawRule as a, DEFAULT_FLOT_OPTIONS as an, SecondaryDirectionOfFireOptions as ar, DEFAULT_FIX_OPTIONS as at, getMidpointPerpendicularSignedDistance as b, GenericRectangleOptions as bn, DEFAULT_GENERIC_C2_LINE_OPTIONS as br, DEFAULT_ANTITANK_WALL_OPTIONS as bt, line23DrawRule as c, DEFAULT_ATTACK_BY_FIRE_OPTIONS as cn, DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS as cr, DisruptOptions as ct, ambushDrawRule as d, AttackHelicopterOptions as dn, DirectionOfMainAttackOptions as dr, DEFAULT_TURNING_MOVEMENT_OPTIONS as dt, ControlMeasureDrawRule as ei, DEFAULT_BRIDGEHEAD_LINE_OPTIONS as en, FeaturePartProps as er, ObstacleBypassDifficultOptions as et, attackByFireDrawRule as f, DEFAULT_ATTACK_HELICOPTER_OPTIONS as fn, DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS as fr, TurningMovementOptions as ft, blockDrawRule as g, GenericTextOptions as gn, BattlePositionOptions as gr, FortifiedAreaOptions as gt, disruptDrawRule as h, DEFAULT_GENERIC_TEXT_OPTIONS as hn, StrongPointOptions as hr, DEFAULT_FORTIFIED_AREA_OPTIONS as ht, axis1DrawRule as i, PhaseLineOptions as in, SECONDARY_DIRECTION_OF_FIRE_DASH as ir, TurnOptions as it, SimpleStyleProps as j, DEFAULT_SUPPORTING_ATTACK_OPTIONS as jn, BoundaryOptions as jr, DEFAULT_TACTICAL_ARROW_OPTIONS as jt, getMetersPerPixel as k, ClassicArrowOptions as kn, project as kr, CoverOptions as kt, turnDrawRule as l, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as ln, DirectionOfSupportingAttackOptions as lr, BlockOptions as lt, centerRadiusDrawRule as m, DEFAULT_AIRBORNE_ATTACK_OPTIONS as mn, DEFAULT_STRONG_POINT_OPTIONS as mr, FrontalAttackOptions as mt, DEFAULT_AMBUSH_OPTIONS as n, ForwardEdgeOfBattleAreaOptions as nn, controlMeasureIdFromFeature as nr, ObstacleBypassEasyOptions as nt, line26DrawRule as o, FLOTOptions as on, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as or, FixOptions as ot, point12DrawRule as p, AirborneAttackOptions as pn, DirectionOfAttackAviationOptions as pr, DEFAULT_FRONTAL_ATTACK_OPTIONS as pt, getControlMeasureMetadata as q, AreaDefenseOptions as qn, TextAmplifierField as qr, DEFAULT_HANDOVER_LINE_OPTIONS as qt, rectangleDrawRule as r, DEFAULT_PHASE_LINE_OPTIONS as rn, DEFAULT_SECONDARY_DIRECTION_OF_FIRE_OPTIONS as rr, DEFAULT_TURN_OPTIONS as rt, line24DrawRule as s, AttackByFireOptions as sn, PrincipalDirectionOfFireOptions as sr, DEFAULT_DISRUPT_OPTIONS as st, AmbushOptions as t, DEFAULT_FORWARD_EDGE_OF_BATTLE_AREA_OPTIONS as tn, StyleHints as tr, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as tt, line1DrawRule as u, SupportByFireOptions as un, DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS as ur, DEFAULT_BLOCK_OPTIONS as ut, computeDefaultMidpointPerpendicularPoint as v, GenericCircleOptions as vn, ControlMeasureStyle as vr, FortifiedLineOptions as vt, BaselineFrameNormal as w, GenericLineOptions as wn, DEFAULT_LIGHT_LINE_OPTIONS as wr, ScreenOptions as wt, pointOnMidpointPerpendicularAxis as x, DEFAULT_GENERIC_POLYGON_OPTIONS as xn, GenericC2LineOptions as xr, AntitankDitchOptions as xt, createMidpointPerpendicularDrawRule as y, DEFAULT_GENERIC_RECTANGLE_OPTIONS as yn, FillPattern as yr, AntitankWallOptions as yt, ControlMeasure as z, DEFAULT_PICKUP_ZONE_OPTIONS as zn, ParamDescriptor as zr, BypassOptions as zt };