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

package/dist/{index-26Xb77jE.d.mts → index-85rqbfeE.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", "Area17", "Area21", "Axis1", "Line1", "Line3", "Line9", "Line10", "Line23", "Line24", "Line26", "Line27", "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.
@@ -603,13 +1142,19 @@ declare const DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS: Required<FinalProtectiveFir
 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. */
-interface EncirclementOptions {
+/**
+ * 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
@@ -629,35 +1174,343 @@ interface EncirclementOptions {
    */
   smooth?: boolean;
   /**
-   * Number of samples per segment when `smooth` is enabled.
-   * @default 16
+   * 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
+   */
+  echelonSizePixels?: number;
+  /**
+   * Gap left on each side of the echelon glyph, as a ratio of the glyph
+   * height. `0` butts the boundary against the glyph; larger values widen
+   * the break.
+   * @default 0.3
+   */
+  echelonPadding?: number;
+  /**
+   * Slides the echelon along the boundary, as a signed fraction of the total
+   * perimeter measured from its default anchor on the bottom edge.
+   * @default 0
+   */
+  echelonPosition?: number;
+  /**
+   * Absolute anchor for the echelon glyph, as a fraction of the total
+   * perimeter measured from the ring seam, wrapped into `[0, 1)`. See Battle
+   * Position's `echelonAnchor` (ADR-0023) — edit controllers freeze this via
+   * the `freezeOrientation` hook the moment a rotate gesture starts.
+   */
+  echelonAnchor?: number;
+  /**
+   * Meters-per-pixel at the current zoom/latitude. Stamped by the host when
+   * the measure is screen-anchored; required to resolve `echelonSizePixels`.
    */
-  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,57 @@ 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/cm34-mission-tasks/counterattack-by-fire.d.ts
+type CounterattackByFireOptions = CounterattackOptions;
+declare const DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS: Required<Omit<CounterattackByFireOptions, keyof LabelSizeOptions>>;
+/** Generates the Counterattack by Fire mission task (340700). */
+declare function createCounterattackByFire(coordinates: Position[], options?: CounterattackByFireOptions, textAmplifiers?: CanonicalTextAmplifiers): FeatureCollection<LineString | MultiLineString | Polygon | 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 +2252,47 @@ 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/disengage.d.ts
+type DisengageOptions = DelayOptions;
+declare const DEFAULT_DISENGAGE_OPTIONS: Required<Omit<DelayOptions, "labelSize" | "labelSizePixels">>;
+declare function createDisengageSymbol(coordinates: Position[], options?: DisengageOptions): FeatureCollection<MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm34-mission-tasks/disrupt.d.ts
+interface DisruptMissionTaskOptions {
+  /** Middle arrow length as a ratio of the PT.3-controlled top arrow (default: 0.65). */
+  middleArrowLengthRatio?: number;
+  /** Bottom arrow length as a ratio of the PT.3-controlled top arrow (default: 0.45). */
+  bottomArrowLengthRatio?: number;
+  /** Rear middle shaft length as a ratio of the top arrow (default: 0.25). */
+  shaftLengthRatio?: number;
+  /** Arrowhead depth as a ratio of the spine length (default: 0.15). */
+  arrowheadLengthRatio?: number;
+  /** Arrowhead width as a ratio of the spine length (default: 0.2). */
+  arrowheadWidthRatio?: number;
+  /** Gap for the 'D' label as a ratio of the top arrow length (default: 0.2). */
+  labelGapRatio?: number;
+  /** Text height in projected meters — ground-anchored label size (ADR-0028). */
+  labelSize?: number;
+  /** Text height in CSS pixels — screen-anchored label size (ADR-0028). */
+  labelSizePixels?: number;
+}
+declare const DEFAULT_DISRUPT_MISSION_TASK_OPTIONS: Required<Omit<DisruptMissionTaskOptions, "labelSize" | "labelSizePixels">>;
+/** Generates the DISRUPT mission task symbol (341000). */
+declare function createDisruptMissionTaskSymbol(coordinates: Position[], options?: DisruptMissionTaskOptions): 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 +2327,68 @@ interface IsolateOptions {
  */
 declare function createIsolateSymbol(coordinates: Position[], options?: IsolateOptions): FeatureCollection<MultiLineString>;
 //#endregion
+//#region src/generators/cm34-mission-tasks/penetrate.d.ts
+interface PenetrateOptions {
+  /** Arrowhead depth as a ratio of the barrier length (default: 0.15). */
+  arrowheadLengthRatio?: number;
+  /** Arrowhead width as a ratio of the barrier length (default: 0.2). */
+  arrowheadWidthRatio?: number;
+  /** Gap for the 'P' label as a ratio of the shaft length (default: 0.2). */
+  labelGapRatio?: number;
+  /** Text height in projected meters — ground-anchored label size (ADR-0028). */
+  labelSize?: number;
+  /** Text height in CSS pixels — screen-anchored label size (ADR-0028). */
+  labelSizePixels?: number;
+}
+declare const DEFAULT_PENETRATE_OPTIONS: Required<Omit<PenetrateOptions, "labelSize" | "labelSizePixels">>;
+/** Generates the PENETRATE mission task symbol (341800). */
+declare function createPenetrateSymbol(coordinates: Position[], options?: PenetrateOptions): FeatureCollection<MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm34-mission-tasks/rearward-passage-of-lines.d.ts
+type RearwardPassageOfLinesOptions = DelayOptions;
+declare const DEFAULT_REARWARD_PASSAGE_OF_LINES_OPTIONS: Required<Omit<DelayOptions, "labelSize" | "labelSizePixels">>;
+declare function createRearwardPassageOfLinesSymbol(coordinates: Position[], options?: RearwardPassageOfLinesOptions): FeatureCollection<MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm34-mission-tasks/retire.d.ts
+type RetireOptions = DelayOptions;
+declare const DEFAULT_RETIRE_OPTIONS: Required<Omit<DelayOptions, "labelSize" | "labelSizePixels">>;
+/** Generates the RETIRE/RETIREMENT mission task symbol (342000). */
+declare function createRetireSymbol(coordinates: Position[], options?: RetireOptions): FeatureCollection<MultiLineString | Point>;
+//#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/cm34-mission-tasks/seize.d.ts
+interface SeizeOptions extends LabelSizeOptions {
+  /** Arrowhead depth as a ratio of the PT. 2-to-PT. 4 span. */
+  arrowheadLengthRatio?: number;
+  /** Arrowhead base width as a ratio of the PT. 2-to-PT. 4 span. */
+  arrowheadWidthRatio?: number;
+  /** Gap around the intrinsic S label as a ratio of the arc sweep. */
+  labelGapRatio?: number;
+  /** Number of segments used to approximate the circular arc. */
+  curveSegments?: number;
+  /** Number of segments used to approximate the assigned-unit circle. */
+  circleSegments?: number;
+}
+declare const DEFAULT_SEIZE_OPTIONS: Required<Omit<SeizeOptions, keyof LabelSizeOptions>>;
+/** Generates the Seize mission task symbol (342300). */
+declare function createSeizeSymbol(coordinates: Position[], options?: SeizeOptions): FeatureCollection<MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm34-mission-tasks/withdraw.d.ts
+type WithdrawOptions = DelayOptions;
+declare const DEFAULT_WITHDRAW_OPTIONS: Required<Omit<DelayOptions, "labelSize" | "labelSizePixels">>;
+declare function createWithdrawSymbol(coordinates: Position[], options?: WithdrawOptions): FeatureCollection<MultiLineString | Point>;
+//#endregion
+//#region src/generators/cm34-mission-tasks/withdraw-under-pressure.d.ts
+type WithdrawUnderPressureOptions = DelayOptions;
+declare const DEFAULT_WITHDRAW_UNDER_PRESSURE_OPTIONS: Required<Omit<DelayOptions, "labelSize" | "labelSizePixels">>;
+declare function createWithdrawUnderPressureSymbol(coordinates: Position[], options?: WithdrawUnderPressureOptions): 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 +2413,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 +2426,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 +2473,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 +2484,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 +2508,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>;
@@ -1413,6 +2609,27 @@ declare const DEFAULT_FIX_OPTIONS: Required<FixOptions>;
  */
 declare function createFix(coordinates: Position[], options?: FixOptions): FeatureCollection<MultiLineString>;
 //#endregion
+//#region src/generators/cm34-mission-tasks/fix.d.ts
+interface FixMissionTaskOptions extends LabelSizeOptions {
+  /** Arrowhead depth as a ratio of the PT2-PT1 axis. */
+  arrowheadLengthRatio?: number;
+  /** Arrowhead base width as a ratio of the PT2-PT1 axis. */
+  arrowheadWidthRatio?: number;
+  /** Start of the zigzag body along the axis, measured from PT2. */
+  zigzagStartRatio?: number;
+  /** End of the zigzag body along the axis, measured from PT2. */
+  zigzagEndRatio?: number;
+  /** Number of upward zigzag peaks. */
+  zigzagPeakCount?: number;
+  /** Position of the intrinsic F label along the axis, measured from PT2. */
+  labelPositionRatio?: number;
+  /** Gap around the intrinsic F label as a ratio of the axis length. */
+  labelGapRatio?: number;
+}
+declare const DEFAULT_FIX_MISSION_TASK_OPTIONS: Required<Omit<FixMissionTaskOptions, keyof LabelSizeOptions>>;
+/** Generates the Fix mission task symbol (341100). */
+declare function createFixMissionTaskSymbol(coordinates: Position[], options?: FixMissionTaskOptions): FeatureCollection<MultiLineString | Point>;
+//#endregion
 //#region src/generators/cm27-protection-areas/turn.d.ts
 interface TurnOptions {
   arrowheadLengthRatio?: number;
@@ -1493,17 +2710,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,26 +2759,50 @@ 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>;
+  "counterattack-by-fire": ControlMeasureDefinition<"counterattack-by-fire", typeof createCounterattackByFire>;
+  cover: ControlMeasureDefinition<"cover", typeof createCoverSymbol>;
   delay: ControlMeasureDefinition<"delay", typeof createDelaySymbol>;
+  disengage: ControlMeasureDefinition<"disengage", typeof createDisengageSymbol>;
+  "disrupt-mission-task": ControlMeasureDefinition<"disrupt-mission-task", typeof createDisruptMissionTaskSymbol>;
+  guard: ControlMeasureDefinition<"guard", typeof createGuardSymbol>;
   isolate: ControlMeasureDefinition<"isolate", typeof createIsolateSymbol>;
+  penetrate: ControlMeasureDefinition<"penetrate", typeof createPenetrateSymbol>;
+  "rearward-passage-of-lines": ControlMeasureDefinition<"rearward-passage-of-lines", typeof createRearwardPassageOfLinesSymbol>;
+  retire: ControlMeasureDefinition<"retire", typeof createRetireSymbol>;
+  screen: ControlMeasureDefinition<"screen", typeof createScreenSymbol>;
+  seize: ControlMeasureDefinition<"seize", typeof createSeizeSymbol>;
+  withdraw: ControlMeasureDefinition<"withdraw", typeof createWithdrawSymbol>;
+  "withdraw-under-pressure": ControlMeasureDefinition<"withdraw-under-pressure", typeof createWithdrawUnderPressureSymbol>;
   "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>;
+  "fix-mission-task": ControlMeasureDefinition<"fix-mission-task", typeof createFixMissionTaskSymbol>;
   turn: ControlMeasureDefinition<"turn", typeof createTurn>;
   "obstacle-bypass-easy": ControlMeasureDefinition<"obstacle-bypass-easy", typeof createObstacleBypassEasy>;
   "obstacle-bypass-difficult": ControlMeasureDefinition<"obstacle-bypass-difficult", typeof createObstacleBypassDifficult>;
@@ -1562,30 +2833,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 +2843,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 +2862,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 +2891,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 +2948,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 +3014,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
@@ -1867,6 +3053,15 @@ declare const disruptDrawRule: ControlMeasureDrawRule;
 //#region src/draw-rules/area15.d.ts
 declare const centerRadiusDrawRule: ControlMeasureDrawRule;
 //#endregion
+//#region src/draw-rules/area17.d.ts
+/**
+ * Area17 anchor draw rule for Penetrate.
+ *
+ * PT.1/PT.2 are the free barrier endpoints. PT.3 is the arrow tail,
+ * constrained to the perpendicular axis through the barrier midpoint.
+ */
+declare const penetrateDrawRule: ControlMeasureDrawRule;
+//#endregion
 //#region src/draw-rules/point12.d.ts
 /**
  * Point12 anchor draw rule for the obstacle-bypass family.
@@ -1931,6 +3126,31 @@ 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/line27.d.ts
+/**
+ * Line27 anchor draw rule for the Seize mission task.
+ *
+ * PT. 1 is the circle center, PT. 2 fixes its radius and the curved arrow's
+ * start, derived PT. 3 lies on and selects the circular arc, and the user's
+ * third click becomes PT. 4 (the arrow tip). PT. 3 remains directly editable
+ * after commit. Dragging PT. 1 carries PT. 2 with it so the assigned-unit
+ * circle keeps its radius.
+ */
+declare const line27DrawRule: ControlMeasureDrawRule;
+//#endregion
 //#region src/draw-rules/area8.d.ts
 declare const supportByFireDrawRule: ControlMeasureDrawRule;
 //#endregion
@@ -1960,25 +3180,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_IMPOSSIBLE_OPTIONS as $, DEFAULT_SUPPORTING_ATTACK_OPTIONS as $n, BoundaryOptions as $r, CounterattackByFireOptions as $t, EPSILON as A, DEFAULT_ATTACK_BY_FIRE_OPTIONS as An, DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS as Ar, WithdrawOptions as At, renderControlMeasure as B, GenericCircleOptions as Bn, ControlMeasureStyle as Br, PenetrateOptions as Bt, pointOnMidpointPerpendicularAxis as C, DEFAULT_FORWARD_EDGE_OF_BATTLE_AREA_OPTIONS as Cn, StyleHints as Cr, AntitankWallOptions as Ct, BaselineFrameOptions as D, DEFAULT_FLOT_OPTIONS as Dn, SecondaryDirectionOfFireOptions as Dr, DEFAULT_WITHDRAW_UNDER_PRESSURE_OPTIONS as Dt, BaselineFrameNormal as E, PhaseLineOptions as En, SECONDARY_DIRECTION_OF_FIRE_DASH as Er, DEFAULT_ANTITANK_DITCH_OPTIONS as Et, toSimpleStyle as F, AirborneAttackOptions as Fn, DirectionOfAttackAviationOptions as Fr, DEFAULT_RETIRE_OPTIONS as Ft, CONTROL_MEASURE_METADATA as G, DEFAULT_GENERIC_LINE_OPTIONS as Gn, EngineerWorkLineOptions as Gr, DEFAULT_DISENGAGE_OPTIONS as Gt, cloneControlMeasure as H, GenericRectangleOptions as Hn, DEFAULT_GENERIC_C2_LINE_OPTIONS as Hr, GuardOptions as Ht, resolveStyleHints as I, DEFAULT_AIRBORNE_ATTACK_OPTIONS as In, DEFAULT_STRONG_POINT_OPTIONS as Ir, RetireOptions as It, OptionsByKind as J, BlockArrowOptions as Jn, LabelSizeOptions as Jr, DelayOptions as Jt, ControlMeasureId as K, GenericLineOptions as Kn, DEFAULT_LIGHT_LINE_OPTIONS as Kr, DisengageOptions as Kt, applyBoxTransformOptions as L, DEFAULT_GENERIC_TEXT_OPTIONS as Ln, StrongPointOptions as Lr, DEFAULT_REARWARD_PASSAGE_OF_LINES_OPTIONS as Lt, roundToFixed as M, SupportByFireOptions as Mn, DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS as Mr, SeizeOptions as Mt, SimpleStyleProps as N, AttackHelicopterOptions as Nn, DirectionOfMainAttackOptions as Nr, DEFAULT_SCREEN_OPTIONS as Nt, BaselineFrameOrigin as O, FLOTOptions as On, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as Or, WithdrawUnderPressureOptions as Ot, SimpleStyleRender as P, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Pn, DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS as Pr, ScreenOptions as Pt, listControlMeasureMetadata as Q, DEFAULT_CLASSIC_ARROW_OPTIONS as Qn, unproject as Qr, TacticalArrowOptions as Qt, freezeOrientationOptions as R, GenericTextOptions as Rn, BattlePositionOptions as Rr, RearwardPassageOfLinesOptions as Rt, getMidpointPerpendicularSignedDistance as S, ControlMeasureDrawRule as Si, DEFAULT_BRIDGEHEAD_LINE_OPTIONS as Sn, FeaturePartProps as Sr, FortifiedLineOptions as St, BaselineFrame as T, DEFAULT_PHASE_LINE_OPTIONS as Tn, DEFAULT_SECONDARY_DIRECTION_OF_FIRE_OPTIONS as Tr, AntitankDitchOptions as Tt, isKind as U, DEFAULT_GENERIC_POLYGON_OPTIONS as Un, GenericC2LineOptions as Ur, DEFAULT_DISRUPT_MISSION_TASK_OPTIONS as Ut, ControlMeasure as V, DEFAULT_GENERIC_RECTANGLE_OPTIONS as Vn, FillPattern as Vr, DEFAULT_GUARD_OPTIONS as Vt, CONTROL_MEASURE_IDS as W, GenericPolygonOptions as Wn, DEFAULT_ENGINEER_WORK_LINE_OPTIONS as Wr, DisruptMissionTaskOptions as Wt, getControlMeasureMetadataByValue as X, ClassicArrowHeadStyle as Xn, haversineDistance as Xr, DEFAULT_COVER_OPTIONS as Xt, getControlMeasureMetadata as Y, DEFAULT_BLOCK_ARROW_OPTIONS as Yn, Point2D as Yr, CoverOptions as Yt, getDefaultOptions as Z, ClassicArrowOptions as Zn, project as Zr, DEFAULT_TACTICAL_ARROW_OPTIONS as Zt, disruptDrawRule as _, TextAmplifiers as _i, DEFAULT_RELEASE_LINE_OPTIONS as _n, DEFAULT_ENCIRCLEMENT_OPTIONS as _r, DEFAULT_FRONTAL_ATTACK_OPTIONS as _t, supportByFireDrawRule as a, ControlMeasureMetadata as ai, CanalizeOptions as an, AreaOfOperationsOptions as ar, DEFAULT_TURN_OPTIONS as at, computeDefaultMidpointPerpendicularPoint as b, resolveAmplifierPlacement as bi, HoldingLineOptions as bn, FinalProtectiveFireOptions as br, FortifiedAreaOptions as bt, line24DrawRule as c, TextAmplifierDescriptor as ci, DEFAULT_BYPASS_OPTIONS as cn, PickupZoneOptions as cr, FixMissionTaskOptions as ct, line1DrawRule as d, CanonicalTextAmplifiers as di, BlockMissionTaskOptions as dn, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as dr, DEFAULT_DISRUPT_OPTIONS as dt, DEFAULT_BOUNDARY_OPTIONS as ei, DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS as en, SupportingAttackOptions as er, ObstacleBypassImpossibleOptions as et, ambushDrawRule as f, GeneratedLabelKey as fi, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as fn, JointTacticalActionAreaOptions as fr, DisruptOptions as ft, centerRadiusDrawRule as g, TextAmplifierKey as gi, HandoverLineOptions as gn, DEFAULT_AREA_DEFENSE_OPTIONS as gr, TurningMovementOptions as gt, penetrateDrawRule as h, TextAmplifierField as hi, DEFAULT_HANDOVER_LINE_OPTIONS as hn, AreaDefenseOptions as hr, DEFAULT_TURNING_MOVEMENT_OPTIONS as ht, axis1DrawRule as i, ControlMeasureGeometryType as ii, DEFAULT_CLEAR_OPTIONS as in, computeInitialWidthPoint as ir, ObstacleBypassEasyOptions as it, getMetersPerPixel as j, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as jn, DirectionOfSupportingAttackOptions as jr, DEFAULT_SEIZE_OPTIONS as jt, createBaselineFrame as k, AttackByFireOptions as kn, PrincipalDirectionOfFireOptions as kr, DEFAULT_WITHDRAW_OPTIONS as kt, line23DrawRule as l, AmplifierPlacement as li, BreachOptions as ln, DEFAULT_LANDING_ZONE_OPTIONS as lr, DEFAULT_FIX_OPTIONS as lt, point12DrawRule as m, TEXT_AMPLIFIER_FIELDS as mi, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as mn, DEFAULT_ASSEMBLY_AREA_OPTIONS as mr, DEFAULT_BLOCK_OPTIONS as mt, DEFAULT_AMBUSH_OPTIONS as n, ControlMeasureFillCapability as ni, DEFAULT_COUNTERATTACK_OPTIONS as nn, MainAttackOptions as nr, ObstacleBypassDifficultOptions as nt, line27DrawRule as o, ControlMeasurePaintCapability as oi, DEFAULT_CANALIZE_OPTIONS as on, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as or, TurnOptions as ot, attackByFireDrawRule as p, LabelPlacementOverride as pi, BattleHandoverLineOptions as pn, AssemblyAreaOptions as pr, BlockOptions as pt, ControlMeasureKind as q, BlockArrowHeadStyle as qn, LightLineOptions as qr, DEFAULT_DELAY_OPTIONS as qt, rectangleDrawRule as r, ControlMeasureGeometry as ri, ClearOptions as rn, calculateMetrics as rr, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as rt, line26DrawRule as s, ParamDescriptor as si, BypassOptions as sn, DEFAULT_PICKUP_ZONE_OPTIONS as sr, DEFAULT_FIX_MISSION_TASK_OPTIONS as st, AmbushOptions as t, BoxTransformDelta as ti, CounterattackOptions as tn, DEFAULT_MAIN_ATTACK_OPTIONS as tr, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as tt, turnDrawRule as u, AmplifierPlacements as ui, DEFAULT_BREACH_OPTIONS as un, LandingZoneOptions as ur, FixOptions as ut, blockDrawRule as v, canonicalTextAmplifierKey as vi, ReleaseLineOptions as vn, EncirclementOptions as vr, FrontalAttackOptions as vt, snapToMidpointPerpendicular as w, ForwardEdgeOfBattleAreaOptions as wn, controlMeasureIdFromFeature as wr, DEFAULT_ANTITANK_WALL_OPTIONS as wt, createMidpointPerpendicularDrawRule as x, AnchorTransformEvent as xi, BridgeheadLineOptions as xn, ControlMeasureRender as xr, DEFAULT_FORTIFIED_LINE_OPTIONS as xt, MidpointPerpendicularDrawRuleOptions as y, normalizeTextAmplifiers as yi, DEFAULT_HOLDING_LINE_OPTIONS as yn, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as yr, DEFAULT_FORTIFIED_AREA_OPTIONS as yt, RenderOptions as z, DEFAULT_GENERIC_CIRCLE_OPTIONS as zn, DEFAULT_BATTLE_POSITION_OPTIONS as zr, DEFAULT_PENETRATE_OPTIONS as zt };