@orbat-mapper/control-measures 0.7.0 → 0.9.0

package/dist/{renderControlMeasure-GsV4DV3r.mjs → renderControlMeasure-D9mfP_gv.mjs}

@@ -586,20 +586,34 @@ const area1DrawRule = {
 	}
 };
 //#endregion
-//#region src/draw-rules/area11.ts
-const blockDrawRule = createMidpointPerpendicularDrawRule({ id: "area11:block" });
-//#endregion
-//#region src/draw-rules/area12.ts
+//#region src/draw-rules/area27.ts
 /**
-* Area12 anchor draw rule for Disrupt.
+* Area27 anchor draw rule for Mobile Defense.
 *
-* P1/P2 are the free spine endpoints. P3 is the longest-arrow tip, constrained
-* to the perpendicular axis through P1 (not the baseline midpoint).
+* PT. 1 is the arrow tip and PT. 2 is the end of the straight-line portion.
+* PT. 3 fixes the diameter and side of the 180-degree arc, constrained to the
+* perpendicular axis through PT. 2 so the arc stays perpendicular to the
+* action line when any of the three handles is edited.
 */
-const disruptDrawRule = createMidpointPerpendicularDrawRule({
-	id: "area12:disrupt",
-	origin: "p1",
-	normal: "left"
+const area27DrawRule = createMidpointPerpendicularDrawRule({
+	id: "area27:mobile-defense",
+	minimumUserPoints: 3,
+	minimumPreviewPoints: 2,
+	origin: "p2",
+	normal: "left",
+	defaultDistanceRatio: .6
+});
+//#endregion
+//#region src/draw-rules/area5.ts
+/**
+* Area5 — PT. 1/PT. 2 define the open diameter and PT. 3 defines the arrow end.
+* The arrow stays on the perpendicular bisector of the diameter.
+*/
+const containDrawRule = createMidpointPerpendicularDrawRule({
+	id: "area5:contain",
+	minimumUserPoints: 3,
+	defaultDistanceRatio: -1.5,
+	minimumPreviewPoints: 2
 });
 //#endregion
 //#region src/draw-rules/area15.ts
@@ -630,6 +644,34 @@ const centerRadiusDrawRule = {
 /** Backward-compatible doctrinal name for Area15's shared center-radius rule. */
 const isolateDrawRule = centerRadiusDrawRule;
 //#endregion
+//#region src/draw-rules/area6.ts
+/**
+* Area6 — center + start point, mechanically identical to Area15. It re-labels
+* the shared behaviour rather than aliasing it because a definition's `rule.id`
+* must carry its `metadata.drawRule` as a prefix (see the registry invariant in
+* `__tests__/metadata-registry.spec.ts`, ADR-0013).
+*/
+const retainDrawRule = {
+	...centerRadiusDrawRule,
+	id: "area6:center-radius"
+};
+//#endregion
+//#region src/draw-rules/area11.ts
+const blockDrawRule = createMidpointPerpendicularDrawRule({ id: "area11:block" });
+//#endregion
+//#region src/draw-rules/area12.ts
+/**
+* Area12 anchor draw rule for Disrupt.
+*
+* P1/P2 are the free spine endpoints. P3 is the longest-arrow tip, constrained
+* to the perpendicular axis through P1 (not the baseline midpoint).
+*/
+const disruptDrawRule = createMidpointPerpendicularDrawRule({
+	id: "area12:disrupt",
+	origin: "p1",
+	normal: "left"
+});
+//#endregion
 //#region src/draw-rules/area17.ts
 /**
 * Area17 anchor draw rule for Penetrate.
@@ -2674,6 +2716,13 @@ function pushEndLabels(out, verts, textForEnd, options = {}) {
 * measurement is available at generator time.
 */
 const LABEL_CHAR_ASPECT_RATIO = .6;
+/**
+* Half a single glyph's width, as a ratio of its height — the base boundary
+* gap a measure reserves for one intrinsic capital letter (Retain's R,
+* Contain's C). Wider than half `LABEL_CHAR_ASPECT_RATIO` because these
+* glyphs are stamped alone rather than averaged over a word.
+*/
+const LABEL_HALF_GLYPH_RATIO = .45;
 /** Estimated rendered width of `text` given its resolved label height in meters. */
 function estimatedTextWidth(text, textHeightMeters) {
 	return text.length * LABEL_CHAR_ASPECT_RATIO * textHeightMeters;
@@ -2792,7 +2841,7 @@ function pushEndLabelsAbove(out, verts, textForEnd, options = {}) {
 * as a complete FeatureCollection.
 */
 function fixedLabelLineFeatures(positions, options, textForEnd, hostileText, context) {
-	const { part, placement = "beyond", phaseLineName, includePrefix = true, smooth, smoothResolution, ...sizeOptions } = options;
+	const { part, placement = "beyond", phaseLineName, includePrefix = true, lineStyle, smooth, smoothResolution, ...sizeOptions } = options;
 	const verts = smoothLineVerts(positions.map((p) => project(p[0], p[1])), {
 		smooth,
 		smoothResolution
@@ -2800,7 +2849,10 @@ function fixedLabelLineFeatures(positions, options, textForEnd, hostileText, con
 	const lineCoordinates = smooth ? verts.map((v) => unproject(v[0], v[1])) : positions;
 	const features = [{
 		type: "Feature",
-		properties: { part },
+		properties: lineStyle === void 0 ? { part } : {
+			part,
+			style: lineStyle
+		},
 		geometry: {
 			type: "LineString",
 			coordinates: lineCoordinates
@@ -4205,13 +4257,13 @@ const AREA_DEFENSE_METADATA = {
 		}
 	]
 };
-function pointOnCircle(center, radius, angle) {
+function pointOnCircle$1(center, radius, angle) {
 	return vecAdd(center, [radius * Math.cos(angle), radius * Math.sin(angle)]);
 }
-function sampleArc$1(center, radius, start, end) {
+function sampleArc$2(center, radius, start, end) {
 	const span = end - start;
 	const segments = Math.max(8, Math.round(48 * Math.abs(span) / Math.PI));
-	return Array.from({ length: segments + 1 }, (_, index) => pointOnCircle(center, radius, start + span * index / segments));
+	return Array.from({ length: segments + 1 }, (_, index) => pointOnCircle$1(center, radius, start + span * index / segments));
 }
 function openArrowhead(tip, direction, length) {
 	const base = vecSub(tip, [direction[0] * length, direction[1] * length]);
@@ -4242,8 +4294,8 @@ function createAreaDefense(coordinates, options = {}) {
 	const upperEnd = upperTipAngle;
 	const lowerStart = labelCenter - labelHalf;
 	const lowerEnd = upperTipAngle + arrowHalf * 2 - Math.PI * 2;
-	const upperArc = sampleArc$1(center, radius, upperStart, upperEnd);
-	const lowerArc = sampleArc$1(center, radius, lowerStart, lowerEnd);
+	const upperArc = sampleArc$2(center, radius, upperStart, upperEnd);
+	const lowerArc = sampleArc$2(center, radius, lowerStart, lowerEnd);
 	const arrowLength = radius * Math.max(0, resolved.arrowheadLengthRatio);
 	const upperDirection = [-Math.sin(upperEnd), Math.cos(upperEnd)];
 	const lowerDirection = [Math.sin(lowerEnd), -Math.cos(lowerEnd)];
@@ -4268,17 +4320,17 @@ function createAreaDefense(coordinates, options = {}) {
 	const barbPolygons = [];
 	for (const arc of barbArcs) for (let ordinal = 1; ordinal <= arc.count; ordinal++) {
 		const angle = arc.start + (arc.end - arc.start) * ordinal / (arc.count + 1);
-		const left = pointOnCircle(center, radius, angle - barbHalfAngle);
-		const right = pointOnCircle(center, radius, angle + barbHalfAngle);
+		const left = pointOnCircle$1(center, radius, angle - barbHalfAngle);
+		const right = pointOnCircle$1(center, radius, angle + barbHalfAngle);
 		const ring = [
 			left,
-			pointOnCircle(center, radius + barbLength, angle),
+			pointOnCircle$1(center, radius + barbLength, angle),
 			right,
 			left
 		].map((point) => unproject(point[0], point[1]));
 		barbPolygons.push([ring]);
 	}
-	const labelPoint = pointOnCircle(center, radius, labelCenter);
+	const labelPoint = pointOnCircle$1(center, radius, labelCenter);
 	return {
 		type: "FeatureCollection",
 		features: [
@@ -4330,6 +4382,273 @@ const AREA_DEFENSE = defineControlMeasure({
 	}
 });
 //#endregion
+//#region src/generators/cm15-maneuver-areas/engagementArea.ts
+/** Default options for the Engagement area control measure. */
+const DEFAULT_ENGAGEMENT_AREA_OPTIONS = {
+	smooth: false,
+	smoothResolution: 16
+};
+const ENGAGEMENT_AREA_METADATA = {
+	id: "engagement-area",
+	name: "Engagement area",
+	description: "An area where the commander intends to contain and destroy an enemy force with the massed effects of all available weapons and supporting systems.",
+	entity: "Maneuver Areas",
+	entityType: "Engagement Area",
+	value: "151300",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: [
+		"Polygon",
+		"MultiLineString",
+		"Point"
+	],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: LABELED_AREA_PARAMS,
+	textAmplifiers: AREA_TEXT_AMPLIFIERS_DESIGNATION_HOSTILE
+};
+/**
+* Creates an Engagement area control measure: a closed area through
+* `positions` labeled at its center with the doctrinal `EA` designation plus
+* an optional Field T unique designation and Field N ENY marker.
+*/
+function createEngagementArea(positions, options = {}, textAmplifiers = {}, context = {}) {
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "EA"), context.amplifierPlacements, context);
+}
+const ENGAGEMENT_AREA = defineControlMeasure({
+	metadata: ENGAGEMENT_AREA_METADATA,
+	generator: createEngagementArea,
+	defaultOptions: DEFAULT_ENGAGEMENT_AREA_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: { T: "ALPHA" },
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
+//#region src/internal/arrowhead.ts
+/**
+* Builds a closed, filled arrowhead triangle ring in unprojected coordinates.
+*
+* `tip` is the point of the arrow, `dir` the unit direction the arrow points,
+* `length` the distance from tip back to the base, and `width` the base width.
+* The returned ring is `[left, tip, right, left]`.
+*/
+function createArrowHeadRing(tip, dir, length, width) {
+	const perp = [-dir[1], dir[0]];
+	const base = vecSub(tip, vecScale(dir, length));
+	const left = vecAdd(base, vecScale(perp, width / 2));
+	const right = vecSub(base, vecScale(perp, width / 2));
+	return [
+		unproject(left[0], left[1]),
+		unproject(tip[0], tip[1]),
+		unproject(right[0], right[1]),
+		unproject(left[0], left[1])
+	];
+}
+//#endregion
+//#region src/internal/projected-arc.ts
+/** The arc point at `angle`, in projected meters. */
+function arcPointAt(center, startRadius, bulgeRadius, angle) {
+	return vecAdd(center, vecAdd(vecScale(startRadius, Math.cos(angle)), vecScale(bulgeRadius, Math.sin(angle))));
+}
+/**
+* Samples the arc from `start` to `end` radians as unprojected positions.
+* `resolution` is the segment count a full half-turn would use, so the density
+* of a partial arc stays proportional to how much of the circle it covers.
+*/
+function sampleProjectedArc(center, startRadius, bulgeRadius, start, end, resolution) {
+	const segments = Math.max(2, Math.ceil(resolution * Math.abs(end - start) / Math.PI));
+	return Array.from({ length: segments + 1 }, (_, index) => {
+		const point = arcPointAt(center, startRadius, bulgeRadius, start + (end - start) * index / segments);
+		return unproject(point[0], point[1]);
+	});
+}
+//#endregion
+//#region src/generators/cm15-maneuver-areas/mobile-defense.ts
+const DEFAULT_MOBILE_DEFENSE_OPTIONS = { labelPadding: 0 };
+const MOBILE_DEFENSE_METADATA = {
+	id: "mobile-defense",
+	name: "Mobile Defense",
+	description: "A defensive maneuver that uses terrain, fires, and maneuver to defeat an attacking enemy force.",
+	entity: "Maneuver Areas",
+	entityType: "Mobile Defense",
+	value: "152800",
+	minCoordinates: 3,
+	maxCoordinates: 3,
+	geometry: "area",
+	geometryTypes: [
+		"MultiLineString",
+		"MultiPolygon",
+		"Point"
+	],
+	paints: {
+		stroke: true,
+		fill: "fixed",
+		text: true
+	},
+	drawRule: "Area27",
+	capturesLabelSize: true,
+	params: [{
+		key: "labelPadding",
+		presentationTier: "advanced",
+		label: "Label padding",
+		description: "Extra clearance around MD, as a ratio of label height",
+		type: "number",
+		min: 0,
+		max: 2,
+		step: .05
+	}]
+};
+const ARC_RESOLUTION = 48;
+const STRAIGHT_ARROW_LENGTH_RATIO = .12;
+const STRAIGHT_ARROW_WIDTH_RATIO = .12;
+const TOP_STRAIGHT_BARB_POSITION_RATIO = .25;
+const FIRST_BARB_POSITION_RATIO = .29;
+const FIRST_BARB_CLEARANCE_RATIO = .01;
+const BARB_WIDTH_RATIO = .45;
+const BARB_LENGTH_RATIO = .42;
+const ARC_BARB_BASE_SEGMENTS = 8;
+function createBarb(center, along, outward, width, length) {
+	const left = vecAdd(center, vecScale(along, width / 2));
+	const right = vecSub(center, vecScale(along, width / 2));
+	const tip = vecAdd(center, vecScale(outward, length));
+	return [
+		toPosition(left),
+		toPosition(tip),
+		toPosition(right),
+		toPosition(left)
+	];
+}
+function createArcBarb(center, startRadius, bulgeRadius, angle, halfWidthAngle, length) {
+	const point = arcPointAt(center, startRadius, bulgeRadius, angle);
+	const outward = vecNorm(vecSub(point, center));
+	const baseStart = arcPointAt(center, startRadius, bulgeRadius, angle - halfWidthAngle);
+	const baseEnd = arcPointAt(center, startRadius, bulgeRadius, angle + halfWidthAngle);
+	const sagitta = vecMag(startRadius) * (1 - Math.cos(halfWidthAngle));
+	const tip = vecAdd(point, vecScale(outward, Math.max(0, length - sagitta)));
+	const curvedBase = Array.from({ length: 9 }, (_, index) => toPosition(arcPointAt(center, startRadius, bulgeRadius, angle - halfWidthAngle + 2 * halfWidthAngle * index / ARC_BARB_BASE_SEGMENTS)));
+	return [
+		toPosition(baseStart),
+		toPosition(tip),
+		toPosition(baseEnd),
+		...curvedBase.slice(1, -1).reverse(),
+		toPosition(baseStart)
+	];
+}
+function createMobileDefense(coordinates, options = {}, _textAmplifiers = {}, context = {}) {
+	const p1 = project(coordinates[0][0], coordinates[0][1]);
+	const p2 = project(coordinates[1][0], coordinates[1][1]);
+	const p3 = project(coordinates[2][0], coordinates[2][1]);
+	const lineVector = vecSub(p2, p1);
+	const diameterVector = vecSub(p3, p2);
+	const lineLength = vecMag(lineVector);
+	const diameter = vecMag(diameterVector);
+	if (lineLength < 1e-6 || diameter < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const lineDirection = vecNorm(lineVector);
+	const lineNormal = [-lineDirection[1], lineDirection[0]];
+	const center = vecAdd(p2, vecScale(diameterVector, .5));
+	const startRadius = vecScale(diameterVector, .5);
+	const bulgeRadius = [startRadius[1], -startRadius[0]];
+	const arrowLength = lineLength * STRAIGHT_ARROW_LENGTH_RATIO;
+	const arrowWidth = lineLength * STRAIGHT_ARROW_WIDTH_RATIO;
+	const topStart = vecAdd(vecAdd(p1, diameterVector), vecScale(lineDirection, arrowLength));
+	const labelPoint = arcPointAt(center, startRadius, bulgeRadius, Math.PI / 2);
+	const metrics = resolveTextMetrics("MD", options, context);
+	const padding = Math.max(0, options.labelPadding ?? DEFAULT_MOBILE_DEFENSE_OPTIONS.labelPadding);
+	const halfGap = Math.min(Math.PI * diameter / 4 - EPSILON, metrics.height / 2 + metrics.height * padding);
+	const gapAngle = Math.max(0, halfGap / (diameter / 2));
+	const upperArc = sampleProjectedArc(center, startRadius, bulgeRadius, 0, Math.PI / 2 - gapAngle, ARC_RESOLUTION);
+	const lowerArc = sampleProjectedArc(center, startRadius, bulgeRadius, Math.PI / 2 + gapAngle, Math.PI, ARC_RESOLUTION);
+	const boundary = [
+		[toPosition(topStart), toPosition(p3)],
+		[toPosition(p1), toPosition(p2)],
+		upperArc,
+		lowerArc,
+		createArrowHeadRing(p1, vecScale(lineDirection, -1), arrowLength, arrowWidth).slice(0, -1)
+	];
+	const firstBarbClearance = lineLength * FIRST_BARB_CLEARANCE_RATIO;
+	const availableStraightLength = lineLength - arrowLength - firstBarbClearance;
+	const barbScale = Math.min(diameter, availableStraightLength / BARB_WIDTH_RATIO);
+	const barbWidth = barbScale * BARB_WIDTH_RATIO;
+	const barbLength = barbScale * BARB_LENGTH_RATIO;
+	const firstBarbDistance = Math.min(lineLength - barbWidth / 2, Math.max(lineLength * FIRST_BARB_POSITION_RATIO, arrowLength + barbWidth / 2 + firstBarbClearance));
+	const arcBarbHalfWidthAngle = Math.asin(Math.min(1, barbWidth / diameter));
+	const barbs = [
+		[createBarb(vecAdd(topStart, vecScale(vecSub(p3, topStart), TOP_STRAIGHT_BARB_POSITION_RATIO)), lineDirection, lineNormal, barbWidth, barbLength)],
+		[createBarb(vecAdd(p1, vecScale(lineDirection, firstBarbDistance)), lineDirection, vecScale(lineNormal, -1), barbWidth, barbLength)],
+		[createArcBarb(center, startRadius, bulgeRadius, arcBarbHalfWidthAngle, arcBarbHalfWidthAngle, barbLength)],
+		[createArcBarb(center, startRadius, bulgeRadius, Math.PI - arcBarbHalfWidthAngle, arcBarbHalfWidthAngle, barbLength)]
+	];
+	return {
+		type: "FeatureCollection",
+		features: [
+			{
+				type: "Feature",
+				properties: { part: "mobile-defense" },
+				geometry: {
+					type: "MultiLineString",
+					coordinates: boundary
+				}
+			},
+			{
+				type: "Feature",
+				properties: {
+					part: "barbs",
+					fill: true,
+					style: SOLID_ACCENT_FILL
+				},
+				geometry: {
+					type: "MultiPolygon",
+					coordinates: barbs
+				}
+			},
+			{
+				type: "Feature",
+				properties: {
+					part: "label",
+					labelPlacement: false,
+					text: "MD",
+					rotation: labelRotationAlong(lineDirection),
+					...labelSizeProps(options)
+				},
+				geometry: {
+					type: "Point",
+					coordinates: toPosition(labelPoint)
+				}
+			}
+		]
+	};
+}
+const MOBILE_DEFENSE = defineControlMeasure({
+	metadata: MOBILE_DEFENSE_METADATA,
+	generator: createMobileDefense,
+	defaultOptions: DEFAULT_MOBILE_DEFENSE_OPTIONS,
+	rule: area27DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.25],
+			[.65, -.25],
+			[.65, .35]
+		],
+		options: { labelSize: 90 }
+	}
+});
+//#endregion
 //#region src/generators/cm12-command-control-areas/area-of-operations.ts
 /** Default options for the Area of operations control measure. */
 const DEFAULT_AREA_OF_OPERATIONS_OPTIONS = {
@@ -5653,33 +5972,36 @@ const BATTLE_POSITION_METADATA = {
 	textAmplifiers: AREA_UNIT_DESIGNATION_HOSTILE_AMPLIFIERS
 };
 /**
-* Creates a Battle Position control measure: a closed area through `positions`
-* carrying a single echelon (Field B) glyph straddling its boundary — anchored
-* to the bottom edge by default, slidable via `echelonPosition`.
+* Shared body of Battle Position and its dashed sibling, Battle Position
+* Prepared (P) but not Occupied: the closed (optionally smoothed) ring, the
+* Field B echelon glyph straddling the boundary with its masking gap, the
+* centered Field T designation and Field N "ENY" markers, and the gapped
+* boundary that merges every mask (ADR-0023). The two measures differ only in
+* the `namePrefix` put in front of Field T and the intrinsic `boundaryStyle`
+* the boundary feature carries, so both are parameters here — mirroring
+* `echelon-labeled-area.ts`'s role for Base Camp / Guerrilla Base.
 *
-* @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).
+* Strong Point deliberately keeps its own copy: its perimeter tics are new
+* geometry, not a parameter swap.
 */
-function createBattlePosition(positions, options = {}, textAmplifiers = {}, context = {}) {
+function battlePositionAreaFeatures(positions, options, textAmplifiers, context, variant = {}) {
 	const { echelon = DEFAULT_BATTLE_POSITION_OPTIONS.echelon, echelonSize = DEFAULT_BATTLE_POSITION_OPTIONS.echelonSize, echelonSizePixels, echelonPadding = DEFAULT_BATTLE_POSITION_OPTIONS.echelonPadding, echelonPosition = DEFAULT_BATTLE_POSITION_OPTIONS.echelonPosition, echelonAnchor, metersPerPixel, smooth = DEFAULT_BATTLE_POSITION_OPTIONS.smooth, smoothResolution = DEFAULT_BATTLE_POSITION_OPTIONS.smoothResolution } = options;
 	const h = resolveEchelonHeight(echelonSize, echelonSizePixels, metersPerPixel);
 	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION$6);
 	const { strokes, fills, gaps } = placeEchelon(buildAreaPerimeter(verts), h, echelon, echelonPadding, echelonPosition, echelonAnchor);
 	const labelFeatures = [];
 	const enyGaps = pushAreaLabels(labelFeatures, verts, {
-		name: textAmplifiers.T,
+		name: variant.namePrefix ? composeAreaName(variant.namePrefix, textAmplifiers.T) : textAmplifiers.T,
 		hostile: textAmplifiers.N
 	}, options, context.amplifierPlacements, void 0, context);
 	const boundaryCoords = buildGappedLine(verts, [...gaps, ...enyGaps]);
 	const features = [];
 	if (boundaryCoords.length > 0) features.push({
 		type: "Feature",
-		properties: { part: "boundary" },
+		properties: variant.boundaryStyle ? {
+			part: "boundary",
+			style: variant.boundaryStyle
+		} : { part: "boundary" },
 		geometry: {
 			type: "MultiLineString",
 			coordinates: boundaryCoords
@@ -5712,6 +6034,22 @@ function createBattlePosition(positions, options = {}, textAmplifiers = {}, cont
 	};
 }
 /**
+* Creates a Battle Position control measure: a closed area through `positions`
+* carrying a single echelon (Field B) glyph straddling its boundary — anchored
+* to the bottom edge by default, slidable via `echelonPosition`.
+*
+* @param positions - Area anchor points (≥3); the input contract is enforced at
+*   the render seam (ADR-0014).
+* @param options - {@link BattlePositionOptions}.
+* @param textAmplifiers - Field T (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).
+*/
+function createBattlePosition(positions, options = {}, textAmplifiers = {}, context = {}) {
+	return battlePositionAreaFeatures(positions, options, textAmplifiers, context);
+}
+/**
 * `freezeOrientation` hook (ADR-0023) shared by Battle Position and Strong
 * Point: pins the echelon anchor to its current bottom-edge fraction so a
 * subsequent rigid rotation of `controlPoints` (e.g. the transform box's
@@ -5749,32 +6087,276 @@ const BATTLE_POSITION = defineControlMeasure({
 	}
 });
 //#endregion
-//#region src/generators/cm27-protection-areas/block.ts
-const DEFAULT_STEM_RATIO$1 = 1.5;
-const BLOCK_METADATA = {
-	id: "block",
-	name: "Block",
-	description: "Integrates fires and obstacles to stop an attacker along an avenue of approach or prevent it from passing through an engagement area. Establishes a limit of enemy advance.",
-	entity: "Protection Areas",
-	entityType: "Obstacle Effects",
-	entitySubtype: "Block",
-	value: "270501",
-	minCoordinates: 2,
-	geometry: "line",
-	geometryTypes: ["LineString"],
+//#region src/generators/cm15-maneuver-areas/battlePositionPrepared.ts
+/** Intrinsic dash pattern of the prepared-but-not-occupied boundary. */
+const BATTLE_POSITION_PREPARED_DASH = [6, 4];
+/** Default options for the Battle Position Prepared control measure. */
+const DEFAULT_BATTLE_POSITION_PREPARED_OPTIONS = { ...DEFAULT_BATTLE_POSITION_OPTIONS };
+const BATTLE_POSITION_PREPARED_METADATA = {
+	id: "battle-position-prepared",
+	name: "Battle Position Prepared (P) but not Occupied",
+	description: "A battle position that has been prepared for occupation but is not yet occupied, drawn with a dashed boundary and a (P)-prefixed designation.",
+	entity: "Maneuver Areas",
+	entityType: "Battle Position",
+	entitySubtype: "Battle Position Prepared (P) but not Occupied",
+	value: "151202",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: [
+		"MultiLineString",
+		"MultiPolygon",
+		"Point"
+	],
 	paints: {
 		stroke: true,
-		fill: "none",
-		text: false
+		fill: "fixed",
+		text: true
 	},
-	drawRule: "Area11"
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: ECHELON_AREA_PARAMS,
+	textAmplifiers: AREA_UNIT_DESIGNATION_HOSTILE_AMPLIFIERS
 };
-const DEFAULT_BLOCK_OPTIONS = {};
 /**
-* Generates a GeoJSON FeatureCollection for a "Block" tactical symbol (T-shape).
+* Creates a Battle Position Prepared (P) but not Occupied control measure: a
+* Battle Position whose boundary carries an intrinsic dash and whose centered
+* designation is prefixed with `(P)`. Delegates to
+* {@link battlePositionAreaFeatures}, the shared Battle Position body.
 *
-* @param coordinates - An array of GeoJSON Positions (Lon/Lat).
-* Expects exactly 3 points:
+* @param positions - Area anchor points (≥3); the input contract is enforced at
+*   the render seam (ADR-0014).
+* @param options - {@link BattlePositionPreparedOptions}.
+* @param textAmplifiers - Field T (designation, centered in the area and
+*   prefixed with `(P)`) plus an optional Field N "ENY" hostile marker at the
+*   west/east edges.
+*/
+function createBattlePositionPrepared(positions, options = {}, textAmplifiers = {}, context = {}) {
+	return battlePositionAreaFeatures(positions, options, textAmplifiers, context, {
+		namePrefix: "(P)",
+		boundaryStyle: { strokeDash: [...BATTLE_POSITION_PREPARED_DASH] }
+	});
+}
+const BATTLE_POSITION_PREPARED = defineControlMeasure({
+	metadata: BATTLE_POSITION_PREPARED_METADATA,
+	generator: createBattlePositionPrepared,
+	defaultOptions: DEFAULT_BATTLE_POSITION_PREPARED_OPTIONS,
+	rule: area1DrawRule,
+	freezeOrientation: freezeEchelonAnchor,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: { T: "MARS" },
+		options: {
+			echelonSize: 200,
+			smooth: true,
+			labelSize: 96
+		}
+	}
+});
+//#endregion
+//#region src/generators/cm15-maneuver-areas/contain.ts
+const DEFAULT_CONTAIN_OPTIONS = {
+	labelPadding: .2,
+	resolution: 32
+};
+const CONTAIN_METADATA = {
+	id: "contain",
+	name: "Contain",
+	description: "Stops, holds, or surrounds enemy forces and prevents them from withdrawing or using them elsewhere.",
+	entity: "Maneuver Areas",
+	entityType: "Battle Position",
+	entitySubtype: "Contain",
+	value: "151204",
+	minCoordinates: 3,
+	maxCoordinates: 3,
+	geometry: "area",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Area5",
+	capturesLabelSize: true,
+	textAmplifiers: [AREA_HOSTILE_AMPLIFIER],
+	params: [{
+		key: "labelPadding",
+		presentationTier: "advanced",
+		label: "Label padding",
+		description: "Extra clearance around C and ENY, as a ratio of label height",
+		type: "number",
+		min: 0,
+		max: 2,
+		step: .05
+	}, {
+		key: "resolution",
+		presentationTier: "advanced",
+		label: "Resolution",
+		description: "Number of segments used to approximate the semicircle",
+		type: "number",
+		min: 8,
+		max: 128,
+		step: 1
+	}]
+};
+/** Where the ENY label sits along the arrow, as a ratio of its full length. */
+const HOSTILE_LABEL_POSITION_RATIO = .55;
+/** Creates the Contain semicircle, inward tics, center-pointing arrow, and C label. */
+function createContain(coordinates, options = {}, textAmplifiers = {}, context = {}) {
+	const p1 = project(coordinates[0][0], coordinates[0][1]);
+	const p2 = project(coordinates[1][0], coordinates[1][1]);
+	const p3 = project(coordinates[2][0], coordinates[2][1]);
+	const diameterLength = vecMag(vecSub(p2, p1));
+	if (diameterLength < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const center = [(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2];
+	const arrowVector = vecSub(p3, center);
+	const arrowLength = vecMag(arrowVector);
+	if (arrowLength < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const radius = diameterLength / 2;
+	const openingDirection = vecNorm(arrowVector);
+	const labelRotation = labelRotationAlong(openingDirection);
+	const startRadius = vecSub(p1, center);
+	const bulgeRadius = vecScale(openingDirection, -radius);
+	const h = Math.min(radius * .45, Math.max(EPSILON, resolveLabelOffsetMeters(options, 1, radius * .12)));
+	const labelPadding = Math.max(0, options.labelPadding ?? DEFAULT_CONTAIN_OPTIONS.labelPadding);
+	const resolution = Math.round(Math.min(128, Math.max(8, options.resolution ?? DEFAULT_CONTAIN_OPTIONS.resolution)));
+	const hostileText = textAmplifiers.N ?? "ENY";
+	const labelHalfAngle = Math.min(Math.PI / 3, h * (LABEL_HALF_GLYPH_RATIO + labelPadding) / radius);
+	const labelAngle = Math.PI / 2;
+	const boundary = [sampleProjectedArc(center, startRadius, bulgeRadius, 0, labelAngle - labelHalfAngle, resolution), sampleProjectedArc(center, startRadius, bulgeRadius, labelAngle + labelHalfAngle, Math.PI, resolution)];
+	const tics = [];
+	const spacingAngle = h / radius;
+	for (let angle = spacingAngle / 2; angle < Math.PI; angle += spacingAngle) {
+		if (Math.abs(angle - labelAngle) <= labelHalfAngle) continue;
+		const outer = arcPointAt(center, startRadius, bulgeRadius, angle);
+		const inner = vecAdd(outer, vecScale(vecNorm(vecSub(center, outer)), h));
+		tics.push([unproject(outer[0], outer[1]), unproject(inner[0], inner[1])]);
+	}
+	const arrowhead = createArrowHeadRing(center, vecScale(openingDirection, -1), h, h).slice(0, 3);
+	const arrow = [];
+	const hostilePoint = vecAdd(center, vecScale(arrowVector, HOSTILE_LABEL_POSITION_RATIO));
+	if (hostileText) {
+		const metrics = resolveTextMetrics(hostileText, options, context);
+		const maximumHalfGap = arrowLength * Math.min(HOSTILE_LABEL_POSITION_RATIO, 1 - HOSTILE_LABEL_POSITION_RATIO);
+		const halfGap = Math.min(maximumHalfGap, metrics.width / 2 + labelPadding * metrics.height);
+		const farGapEdge = vecAdd(hostilePoint, vecScale(openingDirection, halfGap));
+		const nearGapEdge = vecAdd(hostilePoint, vecScale(openingDirection, -halfGap));
+		arrow.push([unproject(p3[0], p3[1]), unproject(farGapEdge[0], farGapEdge[1])], [unproject(nearGapEdge[0], nearGapEdge[1]), unproject(center[0], center[1])]);
+	} else arrow.push([unproject(p3[0], p3[1]), unproject(center[0], center[1])]);
+	arrow.push(arrowhead);
+	const labelPoint = arcPointAt(center, startRadius, bulgeRadius, labelAngle);
+	const sizeProps = labelSizeProps(options);
+	const features = [
+		{
+			type: "Feature",
+			properties: { part: "boundary" },
+			geometry: {
+				type: "MultiLineString",
+				coordinates: boundary
+			}
+		},
+		{
+			type: "Feature",
+			properties: { part: "tics" },
+			geometry: {
+				type: "MultiLineString",
+				coordinates: tics
+			}
+		},
+		{
+			type: "Feature",
+			properties: { part: "arrow" },
+			geometry: {
+				type: "MultiLineString",
+				coordinates: arrow
+			}
+		},
+		{
+			type: "Feature",
+			properties: {
+				part: "label",
+				labelPlacement: false,
+				text: "C",
+				rotation: labelRotation,
+				...sizeProps
+			},
+			geometry: {
+				type: "Point",
+				coordinates: unproject(labelPoint[0], labelPoint[1])
+			}
+		}
+	];
+	if (hostileText) features.push({
+		type: "Feature",
+		properties: {
+			part: "label",
+			labelPlacement: false,
+			amplifierField: "N",
+			text: hostileText,
+			rotation: labelRotation,
+			...sizeProps
+		},
+		geometry: {
+			type: "Point",
+			coordinates: unproject(hostilePoint[0], hostilePoint[1])
+		}
+	});
+	return {
+		type: "FeatureCollection",
+		features
+	};
+}
+const CONTAIN = defineControlMeasure({
+	metadata: CONTAIN_METADATA,
+	generator: createContain,
+	defaultOptions: DEFAULT_CONTAIN_OPTIONS,
+	rule: containDrawRule,
+	previewSample: {
+		controlPoints: [
+			[0, .7],
+			[0, -.7],
+			[1.5, 0]
+		],
+		options: { labelSize: 90 }
+	}
+});
+//#endregion
+//#region src/generators/cm27-protection-areas/block.ts
+const DEFAULT_STEM_RATIO$1 = 1.5;
+const BLOCK_METADATA = {
+	id: "block",
+	name: "Block",
+	description: "Integrates fires and obstacles to stop an attacker along an avenue of approach or prevent it from passing through an engagement area. Establishes a limit of enemy advance.",
+	entity: "Protection Areas",
+	entityType: "Obstacle Effects",
+	entitySubtype: "Block",
+	value: "270501",
+	minCoordinates: 2,
+	geometry: "line",
+	geometryTypes: ["LineString"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: false
+	},
+	drawRule: "Area11"
+};
+const DEFAULT_BLOCK_OPTIONS = {};
+/**
+* Generates a GeoJSON FeatureCollection for a "Block" tactical symbol (T-shape).
+*
+* @param coordinates - An array of GeoJSON Positions (Lon/Lat).
+* Expects exactly 3 points:
 * - PT1 & PT2: Endpoints of the vertical line.
 * - PT3: Defines the endpoint of the horizontal line (stem).
 * @param options - Configuration options.
@@ -7965,7 +8547,7 @@ function clockwiseSweepDegrees(leftAzimuth, rightAzimuth, collapseToleranceDegre
 	return sweep === 0 && rawSweep !== 0 ? 360 : sweep;
 }
 /** Samples an arc of `sweepDegrees` at `radius`, starting from `leftAzimuth`. */
-function sampleArc(anchor, radius, leftAzimuth, sweepDegrees, resolution) {
+function sampleArc$1(anchor, radius, leftAzimuth, sweepDegrees, resolution) {
 	const segmentCount = Math.max(1, Math.ceil(sweepDegrees / 360 * resolution));
 	return Array.from({ length: segmentCount + 1 }, (_, index) => {
 		return destinationPoint(anchor, radius, (leftAzimuth + index / segmentCount * sweepDegrees) * Math.PI / 180);
@@ -7973,8 +8555,8 @@ function sampleArc(anchor, radius, leftAzimuth, sweepDegrees, resolution) {
 }
 /** Closed ring tracing the outer arc, back along the inner arc, and closed. */
 function annularSectorRing(anchor, innerRadius, outerRadius, leftAzimuth, sweepDegrees, resolution) {
-	const outerArc = sampleArc(anchor, outerRadius, leftAzimuth, sweepDegrees, resolution);
-	const innerArc = sampleArc(anchor, innerRadius, leftAzimuth, sweepDegrees, resolution).reverse();
+	const outerArc = sampleArc$1(anchor, outerRadius, leftAzimuth, sweepDegrees, resolution);
+	const innerArc = sampleArc$1(anchor, innerRadius, leftAzimuth, sweepDegrees, resolution).reverse();
 	return [
 		...outerArc,
 		...innerArc,
@@ -8680,27 +9262,6 @@ const COUNTERATTACK = defineControlMeasure({
 	}
 });
 //#endregion
-//#region src/internal/arrowhead.ts
-/**
-* Builds a closed, filled arrowhead triangle ring in unprojected coordinates.
-*
-* `tip` is the point of the arrow, `dir` the unit direction the arrow points,
-* `length` the distance from tip back to the base, and `width` the base width.
-* The returned ring is `[left, tip, right, left]`.
-*/
-function createArrowHeadRing(tip, dir, length, width) {
-	const perp = [-dir[1], dir[0]];
-	const base = vecSub(tip, vecScale(dir, length));
-	const left = vecAdd(base, vecScale(perp, width / 2));
-	const right = vecSub(base, vecScale(perp, width / 2));
-	return [
-		unproject(left[0], left[1]),
-		unproject(tip[0], tip[1]),
-		unproject(right[0], right[1]),
-		unproject(left[0], left[1])
-	];
-}
-//#endregion
 //#region src/generators/cm34-mission-tasks/counterattack-by-fire.ts
 const DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS = { ...DEFAULT_COUNTERATTACK_OPTIONS };
 /** Length of the solid fire arrowhead relative to the recessed P1 extension. */
@@ -11005,6 +11566,155 @@ const BRIDGEHEAD_LINE = defineControlMeasure({
 	}
 });
 //#endregion
+//#region src/generators/cm14-maneuver-lines/params.ts
+/** Phase-line naming controls shared by the fixed-label Line1 maneuver lines. */
+function phaseLineNameParams(placeholder) {
+	return [
+		{
+			key: "phaseLineName",
+			presentationTier: "primary",
+			semanticRole: "doctrinal",
+			label: "Phase line name",
+			description: "Name the line as a phase line — rendered \"PL <name>\" beyond each end of the line.",
+			type: "text",
+			placeholder,
+			maxLength: 21,
+			field: "T"
+		},
+		{
+			key: "includePrefix",
+			label: "Show PL prefix",
+			description: "Prefix the phase line name with \"PL\" (or show the bare name).",
+			type: "boolean",
+			visibleWhen: (opts) => Boolean(String(opts.phaseLineName ?? "").trim())
+		},
+		LINE_LABEL_PADDING_PARAM
+	];
+}
+//#endregion
+//#region src/generators/cm14-maneuver-lines/final-coordination-line.ts
+/** Default options for the Final coordination line control measure. */
+const DEFAULT_FINAL_COORDINATION_LINE_OPTIONS = {
+	includePrefix: true,
+	smooth: false,
+	smoothResolution: 12
+};
+const FINAL_COORDINATION_LINE_METADATA = {
+	id: "final-coordination-line",
+	name: "Final coordination line",
+	description: "A line close to the enemy position used to coordinate the lifting or shifting of supporting fires with the final deployment of maneuver elements.",
+	entity: "Maneuver Lines",
+	entityType: "Final Coordination Line",
+	value: "140700",
+	minCoordinates: 2,
+	geometry: "line",
+	geometryTypes: ["LineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Line1",
+	capturesLabelSize: true,
+	params: [...SMOOTH_LINE_PARAMS, ...phaseLineNameParams("OPAL")],
+	textAmplifiers: [HOSTILE_LINE_AMPLIFIER]
+};
+/** Creates a Final coordination line labeled "FCL" above both ends. */
+function createFinalCoordinationLine(positions, options = {}, textAmplifiers = {}, context = {}) {
+	return fixedLabelLineFeatures(positions, {
+		part: "final-coordination-line",
+		placement: "above",
+		...options
+	}, "FCL", textAmplifiers.N, context);
+}
+const FINAL_COORDINATION_LINE = defineControlMeasure({
+	metadata: FINAL_COORDINATION_LINE_METADATA,
+	generator: createFinalCoordinationLine,
+	defaultOptions: DEFAULT_FINAL_COORDINATION_LINE_OPTIONS,
+	rule: line1DrawRule,
+	previewSample: {
+		controlPoints: [[-1, 0], [1, 0]],
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
+//#region src/generators/cm14-maneuver-lines/airhead-line.ts
+/** Clearance between the boundary's southernmost point and the caption, as a
+*  ratio of the caption's height. */
+const CAPTION_CLEARANCE_RATIO = .9;
+/** Default options for the Airhead line control measure. */
+const DEFAULT_AIRHEAD_LINE_OPTIONS = {
+	smooth: false,
+	smoothResolution: 16
+};
+const AIRHEAD_LINE_METADATA = {
+	id: "airhead-line",
+	name: "Airhead line",
+	description: "A line denoting the limits of the objective area for an airborne assault.",
+	entity: "Maneuver Lines",
+	entityType: "Airhead Line",
+	value: "141300",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: [
+		"Polygon",
+		"MultiLineString",
+		"Point"
+	],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: LABELED_AREA_PARAMS,
+	textAmplifiers: AREA_TEXT_AMPLIFIERS_DESIGNATION_HOSTILE
+};
+/** Creates an Airhead line: a closed boundary captioned "AIRHEAD LINE" below. */
+function createAirheadLine(positions, options = {}, textAmplifiers = {}, context = {}) {
+	const { smooth = false, smoothResolution = 16, ...labelOptions } = options;
+	const verts = buildClosedRing(positions, smooth, smoothResolution, 16);
+	const labelFeatures = [];
+	const gaps = pushAreaLabels(labelFeatures, verts, composeAreaLabelTexts(textAmplifiers, ""), labelOptions, context.amplifierPlacements, void 0, context);
+	const [cx] = ringCentroid(verts);
+	const minY = Math.min(...verts.map((vertex) => vertex[1]));
+	const clearance = resolveLabelOffsetMeters(labelOptions, CAPTION_CLEARANCE_RATIO + Math.max(0, labelOptions.labelPadding ?? 0));
+	labelFeatures.push({
+		type: "Feature",
+		properties: {
+			part: "label",
+			labelPlacementKey: "label:airhead-line",
+			text: "AIRHEAD LINE",
+			rotation: HORIZONTAL_LABEL_ROTATION,
+			...labelSizeProps(labelOptions)
+		},
+		geometry: {
+			type: "Point",
+			coordinates: unproject(cx, minY - clearance)
+		}
+	});
+	return {
+		type: "FeatureCollection",
+		features: [boundaryFeature(verts, gaps), ...labelFeatures]
+	};
+}
+const AIRHEAD_LINE = defineControlMeasure({
+	metadata: AIRHEAD_LINE_METADATA,
+	generator: createAirheadLine,
+	defaultOptions: DEFAULT_AIRHEAD_LINE_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.4],
+			[1, -.4],
+			[1, .6],
+			[-1, .6]
+		],
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
 //#region src/generators/cm14-maneuver-lines/holding-line.ts
 /** Default options for the Holding line control measure. */
 const DEFAULT_HOLDING_LINE_OPTIONS = {
@@ -11394,6 +12104,193 @@ const BATTLE_HANDOVER_LINE = defineControlMeasure({
 	}
 });
 //#endregion
+//#region src/generators/cm14-maneuver-lines/limit-of-advance.ts
+/** Default options for the Limit of advance control measure. */
+const DEFAULT_LIMIT_OF_ADVANCE_OPTIONS = {
+	includePrefix: true,
+	smooth: false,
+	smoothResolution: 12
+};
+const LIMIT_OF_ADVANCE_METADATA = {
+	id: "limit-of-advance",
+	name: "Limit of advance",
+	description: "An easily recognized terrain feature beyond which attacking elements will not advance.",
+	entity: "Maneuver Lines",
+	entityType: "Limit of Advance",
+	value: "140900",
+	minCoordinates: 2,
+	geometry: "line",
+	geometryTypes: ["LineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Line1",
+	capturesLabelSize: true,
+	params: [...SMOOTH_LINE_PARAMS, ...phaseLineNameParams("RUBY")],
+	textAmplifiers: [HOSTILE_LINE_AMPLIFIER]
+};
+/** Creates a Limit of advance line labeled "LOA" above both ends. */
+function createLimitOfAdvance(positions, options = {}, textAmplifiers = {}, context = {}) {
+	return fixedLabelLineFeatures(positions, {
+		part: "limit-of-advance",
+		placement: "above",
+		...options
+	}, "LOA", textAmplifiers.N, context);
+}
+const LIMIT_OF_ADVANCE = defineControlMeasure({
+	metadata: LIMIT_OF_ADVANCE_METADATA,
+	generator: createLimitOfAdvance,
+	defaultOptions: DEFAULT_LIMIT_OF_ADVANCE_OPTIONS,
+	rule: line1DrawRule,
+	previewSample: {
+		controlPoints: [[-1, 0], [1, 0]],
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
+//#region src/generators/cm14-maneuver-lines/line-of-departure.ts
+/** Default options for the Line of departure control measure. */
+const DEFAULT_LINE_OF_DEPARTURE_OPTIONS = {
+	includePrefix: true,
+	smooth: false,
+	smoothResolution: 12
+};
+const LINE_OF_DEPARTURE_METADATA = {
+	id: "line-of-departure",
+	name: "Line of departure",
+	description: "A line designated to coordinate the departure of attacking elements.",
+	entity: "Maneuver Lines",
+	entityType: "Line of Departure",
+	value: "141000",
+	minCoordinates: 2,
+	geometry: "line",
+	geometryTypes: ["LineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Line1",
+	capturesLabelSize: true,
+	params: [...SMOOTH_LINE_PARAMS, ...phaseLineNameParams("JADE")],
+	textAmplifiers: [HOSTILE_LINE_AMPLIFIER]
+};
+/** Creates a Line of departure labeled "LD" above both ends. */
+function createLineOfDeparture(positions, options = {}, textAmplifiers = {}, context = {}) {
+	return fixedLabelLineFeatures(positions, {
+		part: "line-of-departure",
+		placement: "above",
+		...options
+	}, "LD", textAmplifiers.N, context);
+}
+const LINE_OF_DEPARTURE = defineControlMeasure({
+	metadata: LINE_OF_DEPARTURE_METADATA,
+	generator: createLineOfDeparture,
+	defaultOptions: DEFAULT_LINE_OF_DEPARTURE_OPTIONS,
+	rule: line1DrawRule,
+	previewSample: {
+		controlPoints: [[-1, 0], [1, 0]],
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
+//#region src/generators/cm14-maneuver-lines/line-of-departure-contact.ts
+/** Default options for the Line of departure / line of contact control measure. */
+const DEFAULT_LINE_OF_DEPARTURE_CONTACT_OPTIONS = {
+	includePrefix: true,
+	smooth: false,
+	smoothResolution: 12
+};
+const LINE_OF_DEPARTURE_CONTACT_METADATA = {
+	id: "line-of-departure-contact",
+	name: "Line of departure / line of contact",
+	description: "The designation of forward friendly positions as the line of departure when opposing forces are in contact.",
+	entity: "Maneuver Lines",
+	entityType: "Line of Departure / Line of Contact",
+	value: "141100",
+	minCoordinates: 2,
+	geometry: "line",
+	geometryTypes: ["LineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Line1",
+	capturesLabelSize: true,
+	params: [...SMOOTH_LINE_PARAMS, ...phaseLineNameParams("AMBER")],
+	textAmplifiers: [HOSTILE_LINE_AMPLIFIER]
+};
+/** Creates a Line of departure / line of contact labeled "LD/LC" above both ends. */
+function createLineOfDepartureContact(positions, options = {}, textAmplifiers = {}, context = {}) {
+	return fixedLabelLineFeatures(positions, {
+		part: "line-of-departure-contact",
+		placement: "above",
+		...options
+	}, "LD/LC", textAmplifiers.N, context);
+}
+const LINE_OF_DEPARTURE_CONTACT = defineControlMeasure({
+	metadata: LINE_OF_DEPARTURE_CONTACT_METADATA,
+	generator: createLineOfDepartureContact,
+	defaultOptions: DEFAULT_LINE_OF_DEPARTURE_CONTACT_OPTIONS,
+	rule: line1DrawRule,
+	previewSample: {
+		controlPoints: [[-1, 0], [1, 0]],
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
+//#region src/generators/cm14-maneuver-lines/probable-line-of-deployment.ts
+/** Default options for the Probable line of deployment control measure. */
+const DEFAULT_PROBABLE_LINE_OF_DEPLOYMENT_OPTIONS = {
+	includePrefix: true,
+	smooth: false,
+	smoothResolution: 12
+};
+/** Intrinsic doctrinal dash pattern for Probable Line of Deployment. */
+const PROBABLE_LINE_OF_DEPLOYMENT_DASH = [6, 4];
+const PROBABLE_LINE_OF_DEPLOYMENT_METADATA = {
+	id: "probable-line-of-deployment",
+	name: "Probable line of deployment",
+	description: "A line selected on the ground, usually the last covered and concealed position prior to the objective and forward of the line of departure, where attacking units deploy prior to beginning an assault.",
+	entity: "Maneuver Lines",
+	entityType: "Probable Line of Deployment",
+	value: "141200",
+	minCoordinates: 2,
+	geometry: "line",
+	geometryTypes: ["LineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Line1",
+	capturesLabelSize: true,
+	params: [...SMOOTH_LINE_PARAMS, ...phaseLineNameParams("ONYX")],
+	textAmplifiers: [HOSTILE_LINE_AMPLIFIER]
+};
+/** Creates a Probable line of deployment labeled "PLD" above both ends, with a dashed stroke. */
+function createProbableLineOfDeployment(positions, options = {}, textAmplifiers = {}, context = {}) {
+	return fixedLabelLineFeatures(positions, {
+		part: "probable-line-of-deployment",
+		placement: "above",
+		lineStyle: { strokeDash: [...PROBABLE_LINE_OF_DEPLOYMENT_DASH] },
+		...options
+	}, "PLD", textAmplifiers.N, context);
+}
+const PROBABLE_LINE_OF_DEPLOYMENT = defineControlMeasure({
+	metadata: PROBABLE_LINE_OF_DEPLOYMENT_METADATA,
+	generator: createProbableLineOfDeployment,
+	defaultOptions: DEFAULT_PROBABLE_LINE_OF_DEPLOYMENT_OPTIONS,
+	rule: line1DrawRule,
+	previewSample: {
+		controlPoints: [[-1, 0], [1, 0]],
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
 //#region src/generators/cm29-protection-lines/fortifiedLine.ts
 const DEFAULT_TOOTH_SIZE = 50;
 const DEFAULT_TOOTH_SIZE_PIXELS = 10;
@@ -12634,6 +13531,57 @@ const LANDING_ZONE = defineControlMeasure({
 	}
 });
 //#endregion
+//#region src/generators/cm15-maneuver-areas/penetration-box.ts
+/** Default options for the Penetration box control measure. */
+const DEFAULT_PENETRATION_BOX_OPTIONS = {
+	smooth: false,
+	smoothResolution: 16
+};
+const PENETRATION_BOX_METADATA = {
+	id: "penetration-box",
+	name: "Penetration box",
+	description: "An area in which a force ruptures the enemy's defense on a narrow front to break the continuity of the defensive system.",
+	entity: "Maneuver Areas",
+	entityType: "Penetration Box",
+	value: "151900",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: [
+		"Polygon",
+		"MultiLineString",
+		"Point"
+	],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: LABELED_AREA_PARAMS,
+	textAmplifiers: AREA_TEXT_AMPLIFIERS_DESIGNATION_HOSTILE
+};
+/** Creates a Penetration box: a bare closed area through `positions`. */
+function createPenetrationBox(positions, options = {}, textAmplifiers = {}, context = {}) {
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, ""), context.amplifierPlacements, context);
+}
+const PENETRATION_BOX = defineControlMeasure({
+	metadata: PENETRATION_BOX_METADATA,
+	generator: createPenetrationBox,
+	defaultOptions: DEFAULT_PENETRATION_BOX_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: {},
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
 //#region src/generators/cm15-maneuver-areas/limitedAccessArea.ts
 /** Default options for the Limited Access Area control measure. */
 const DEFAULT_LIMITED_ACCESS_AREA_OPTIONS = {
@@ -14379,6 +15327,180 @@ const STRONG_POINT = defineControlMeasure({
 	}
 });
 //#endregion
+//#region src/generators/cm15-maneuver-areas/retain.ts
+const DEFAULT_RETAIN_OPTIONS = {
+	openingAngle: 30,
+	arrowheadLengthRatio: .1,
+	arrowheadWidthRatio: .12,
+	labelPadding: 0
+};
+const RETAIN_METADATA = {
+	id: "retain",
+	name: "Retain",
+	description: "Ensures that a terrain feature controlled by a friendly force remains secure.",
+	entity: "Maneuver Areas",
+	entityType: "Battle Position",
+	entitySubtype: "Retain",
+	value: "151205",
+	minCoordinates: 2,
+	maxCoordinates: 2,
+	geometry: "area",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Area6",
+	capturesLabelSize: true,
+	params: [
+		{
+			key: "openingAngle",
+			presentationTier: "advanced",
+			label: "Opening",
+			description: "Angular opening on the friendly side, in degrees",
+			type: "number",
+			min: 5,
+			max: 120,
+			step: 1
+		},
+		{
+			key: "arrowheadLengthRatio",
+			presentationTier: "advanced",
+			label: "Arrowhead length",
+			description: "Open-arrowhead length as a ratio of the symbol radius",
+			type: "number",
+			min: .02,
+			max: .5,
+			step: .01
+		},
+		{
+			key: "arrowheadWidthRatio",
+			presentationTier: "advanced",
+			label: "Arrowhead width",
+			description: "Open-arrowhead base width as a ratio of the symbol radius",
+			type: "number",
+			min: .02,
+			max: .5,
+			step: .01
+		},
+		{
+			key: "labelPadding",
+			presentationTier: "advanced",
+			label: "R padding",
+			description: "Extra boundary clearance on each side of R, as a ratio of its height",
+			type: "number",
+			min: 0,
+			max: 2,
+			step: .05
+		}
+	]
+};
+const TAU = Math.PI * 2;
+/** Smallest visible boundary gap, in projected meters, for tiny label heights. */
+const MIN_LABEL_GAP_METERS = 1;
+function pointOnCircle(center, radius, angle) {
+	return vecAdd(center, [radius * Math.cos(angle), radius * Math.sin(angle)]);
+}
+function sampleArc(center, radius, start, end) {
+	const segments = Math.max(8, Math.ceil(48 * Math.abs(end - start) / Math.PI));
+	return Array.from({ length: segments + 1 }, (_, index) => {
+		const point = pointOnCircle(center, radius, start + (end - start) * index / segments);
+		return unproject(point[0], point[1]);
+	});
+}
+/** Creates the Retain boundary, outward tics, and intrinsic R label. */
+function createRetain(coordinates, options = {}) {
+	const center = project(coordinates[0][0], coordinates[0][1]);
+	const radiusVector = vecSub(project(coordinates[1][0], coordinates[1][1]), center);
+	const radius = vecMag(radiusVector);
+	if (radius < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const resolved = {
+		...DEFAULT_RETAIN_OPTIONS,
+		...options
+	};
+	const startAngle = Math.atan2(radiusVector[1], radiusVector[0]);
+	const opening = Math.min(120, Math.max(5, resolved.openingAngle)) * Math.PI / 180;
+	const h = resolveLabelOffsetMeters(options, 1, radius * .1);
+	const labelPadding = Math.max(0, resolved.labelPadding);
+	const boundarySpan = TAU - opening;
+	const labelDistance = Math.PI - opening / 2;
+	const labelCenter = startAngle - labelDistance;
+	const labelHalfGap = Math.min(Math.PI / 2, Math.max(h * (LABEL_HALF_GLYPH_RATIO + labelPadding), MIN_LABEL_GAP_METERS) / radius);
+	const labelStart = startAngle - labelDistance + labelHalfGap;
+	const labelEnd = startAngle - labelDistance - labelHalfGap;
+	const boundaryEnd = startAngle - boundarySpan;
+	const arrowTip = pointOnCircle(center, radius, boundaryEnd);
+	const arrowheadLength = radius * Math.max(0, resolved.arrowheadLengthRatio);
+	const arrowheadWidth = radius * Math.max(0, resolved.arrowheadWidthRatio);
+	const boundary = [
+		sampleArc(center, radius, startAngle, labelStart),
+		sampleArc(center, radius, labelEnd, boundaryEnd),
+		createArrowHeadRing(arrowTip, [Math.sin(boundaryEnd), -Math.cos(boundaryEnd)], arrowheadLength, arrowheadWidth).slice(0, 3)
+	];
+	const tics = [];
+	const spacingAngle = Math.max(h / radius, Math.PI / 180);
+	const arrowClearanceAngle = (arrowheadLength + arrowheadWidth / 2 + h / 2) / radius;
+	for (let distance = spacingAngle / 2; distance < boundarySpan - arrowClearanceAngle; distance += spacingAngle) {
+		if (distance > labelDistance - labelHalfGap && distance < labelDistance + labelHalfGap) continue;
+		const angle = startAngle - distance;
+		const cos = Math.cos(angle);
+		const sin = Math.sin(angle);
+		const innerX = center[0] + radius * cos;
+		const innerY = center[1] + radius * sin;
+		tics.push([unproject(innerX, innerY), unproject(innerX + h * cos, innerY + h * sin)]);
+	}
+	const labelPoint = pointOnCircle(center, radius, labelCenter);
+	return {
+		type: "FeatureCollection",
+		features: [
+			{
+				type: "Feature",
+				properties: { part: "boundary" },
+				geometry: {
+					type: "MultiLineString",
+					coordinates: boundary
+				}
+			},
+			{
+				type: "Feature",
+				properties: { part: "tics" },
+				geometry: {
+					type: "MultiLineString",
+					coordinates: tics
+				}
+			},
+			{
+				type: "Feature",
+				properties: {
+					part: "label",
+					labelPlacement: false,
+					text: "R",
+					rotation: Math.PI,
+					...labelSizeProps(options)
+				},
+				geometry: {
+					type: "Point",
+					coordinates: unproject(labelPoint[0], labelPoint[1])
+				}
+			}
+		]
+	};
+}
+const RETAIN = defineControlMeasure({
+	metadata: RETAIN_METADATA,
+	generator: createRetain,
+	defaultOptions: DEFAULT_RETAIN_OPTIONS,
+	rule: retainDrawRule,
+	previewSample: {
+		controlPoints: [[0, 0], [-.8, .2]],
+		options: { labelSize: 90 }
+	}
+});
+//#endregion
 //#region src/generators/cm15-maneuver-areas/submarineActionArea.ts
 /** Default options for the Submarine action area control measure. */
 const DEFAULT_SUBMARINE_ACTION_AREA_OPTIONS = {
@@ -14837,7 +15959,10 @@ const DEFINITIONS = {
 	"engineer-work-line": ENGINEER_WORK_LINE,
 	"generic-c2-line": GENERIC_C2_LINE,
 	"battle-position": BATTLE_POSITION,
+	"battle-position-prepared": BATTLE_POSITION_PREPARED,
+	contain: CONTAIN,
 	"strong-point": STRONG_POINT,
+	retain: RETAIN,
 	ambush: AMBUSH,
 	"direction-of-attack-aviation": DIRECTION_OF_ATTACK_AVIATION,
 	"direction-of-main-attack": DIRECTION_OF_MAIN_ATTACK,
@@ -14850,6 +15975,8 @@ const DEFINITIONS = {
 	encirclement: ENCIRCLEMENT,
 	area: AREA,
 	"area-defense": AREA_DEFENSE,
+	"engagement-area": ENGAGEMENT_AREA,
+	"mobile-defense": MOBILE_DEFENSE,
 	"assembly-area": ASSEMBLY_AREA,
 	"joint-tactical-action-area": JOINT_TACTICAL_ACTION_AREA,
 	"submarine-action-area": SUBMARINE_ACTION_AREA,
@@ -14858,6 +15985,7 @@ const DEFINITIONS = {
 	"extraction-zone": EXTRACTION_ZONE,
 	"landing-zone": LANDING_ZONE,
 	"limited-access-area": LIMITED_ACCESS_AREA,
+	"penetration-box": PENETRATION_BOX,
 	"no-fire-area-irregular": NO_FIRE_AREA_IRREGULAR,
 	"minefield-dynamic": DYNAMIC_MINEFIELD,
 	"mined-area": MINED_AREA,
@@ -14891,10 +16019,16 @@ const DEFINITIONS = {
 	"phase-line": PHASE_LINE,
 	"forward-edge-of-battle-area": FORWARD_EDGE_OF_BATTLE_AREA,
 	"bridgehead-line": BRIDGEHEAD_LINE,
+	"final-coordination-line": FINAL_COORDINATION_LINE,
+	"airhead-line": AIRHEAD_LINE,
 	"holding-line": HOLDING_LINE,
 	"release-line": RELEASE_LINE,
 	"handover-line": HANDOVER_LINE,
 	"battle-handover-line": BATTLE_HANDOVER_LINE,
+	"limit-of-advance": LIMIT_OF_ADVANCE,
+	"line-of-departure": LINE_OF_DEPARTURE,
+	"line-of-departure-contact": LINE_OF_DEPARTURE_CONTACT,
+	"probable-line-of-deployment": PROBABLE_LINE_OF_DEPLOYMENT,
 	"block-mission-task": BLOCK_MISSION_TASK,
 	breach: BREACH,
 	bypass: BYPASS,
@@ -15337,4 +16471,4 @@ function assertNever(value) {
 	throw new Error(`Unhandled control measure kind: ${String(value)}`);
 }
 //#endregion
-export { DEFAULT_TACTICAL_ARROW_OPTIONS as $, line26DrawRule as $t, DEFAULT_REARWARD_PASSAGE_OF_LINES_OPTIONS as A, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as At, DEFAULT_BRIDGEHEAD_LINE_OPTIONS as B, DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS as Bt, DEFAULT_LANDING_ZONE_OPTIONS as C, project as Cn, DEFAULT_BLOCK_OPTIONS as Ct, DEFAULT_SEIZE_OPTIONS as D, getMetersPerPixel as Dn, DEFAULT_ANTITANK_WALL_OPTIONS as Dt, DEFAULT_WITHDRAW_OPTIONS as E, EPSILON as En, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Et, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as F, TEXT_AMPLIFIER_FIELDS as Ft, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as G, DEFAULT_STROKE_WIDTH_CSS_PIXELS as Gt, DEFAULT_FLOT_OPTIONS as H, DEFAULT_LINE_JOIN as Ht, DEFAULT_HANDOVER_LINE_OPTIONS as I, canonicalTextAmplifierKey as It, DEFAULT_GUARD_OPTIONS as J, DEFAULT_AIRBORNE_ATTACK_OPTIONS as Jt, DEFAULT_ENCIRCLEMENT_OPTIONS as K, DEFAULT_SYMBOL_COLOR as Kt, DEFAULT_FORWARD_EDGE_OF_BATTLE_AREA_OPTIONS as L, normalizeTextAmplifiers as Lt, DEFAULT_FRONTAL_ATTACK_OPTIONS as M, DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS as Mt, DEFAULT_FORTIFIED_AREA_OPTIONS as N, DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS as Nt, DEFAULT_SCREEN_OPTIONS as O, roundToFixed as On, DEFAULT_ANTITANK_DITCH_OPTIONS as Ot, DEFAULT_FORTIFIED_LINE_OPTIONS as P, DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS as Pt, DEFAULT_COVER_OPTIONS as Q, line27DrawRule as Qt, DEFAULT_RELEASE_LINE_OPTIONS as R, resolveAmplifierPlacement as Rt, DEFAULT_MAIN_ATTACK_OPTIONS as S, haversineDistance as Sn, DEFAULT_BLOCK_ARROW_OPTIONS as St, DEFAULT_WITHDRAW_UNDER_PRESSURE_OPTIONS as T, unproject as Tn, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Tt, DEFAULT_FIX_MISSION_TASK_OPTIONS as U, DEFAULT_PORTRAYAL as Ut, DEFAULT_PHASE_LINE_OPTIONS as V, DEFAULT_LINE_CAP as Vt, DEFAULT_FIX_OPTIONS as W, DEFAULT_STROKE_DASH_CSS_PIXELS as Wt, DEFAULT_DISENGAGE_OPTIONS as X, axis1DrawRule as Xt, DEFAULT_DISRUPT_MISSION_TASK_OPTIONS as Y, rectangleDrawRule as Yt, DEFAULT_DELAY_OPTIONS as Z, supportByFireDrawRule as Zt, DEFAULT_PICKUP_ZONE_OPTIONS as _, pointOnMidpointPerpendicularAxis as _n, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as _t, DEFINITIONS as a, attackByFireDrawRule as an, RADAR_SEARCH_DOCTRINE_FILL_COLOR as at, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as b, calculateMetrics as bn, DEFAULT_LIGHT_LINE_OPTIONS as bt, getDefaultOptions as c, staticPointDrawRule as cn, DEFAULT_GENERIC_SECTOR_OPTIONS as ct, DEFAULT_TURN_OPTIONS as d, centerRadiusDrawRule as dn, DEFAULT_GENERIC_LINE_OPTIONS as dt, line24DrawRule as en, DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS as et, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as f, disruptDrawRule as fn, DEFAULT_GENERIC_CIRCLE_OPTIONS as ft, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as g, getMidpointPerpendicularSignedDistance as gn, DEFAULT_BREACH_OPTIONS as gt, SECONDARY_DIRECTION_OF_FIRE_DASH as h, createMidpointPerpendicularDrawRule as hn, DEFAULT_BYPASS_OPTIONS as ht, CONTROL_MEASURE_METADATA as i, ambushDrawRule as in, DEFAULT_RADAR_SEARCH_DOCTRINE_OPTIONS as it, DEFAULT_PENETRATE_OPTIONS as j, DEFAULT_AREA_DEFENSE_OPTIONS as jt, DEFAULT_RETIRE_OPTIONS as k, DEFAULT_ASSEMBLY_AREA_OPTIONS as kt, listControlMeasureMetadata as l, point12DrawRule as ln, DEFAULT_GENERIC_RECTANGLE_OPTIONS as lt, DEFAULT_SECONDARY_DIRECTION_OF_FIRE_OPTIONS as m, computeDefaultMidpointPerpendicularPoint as mn, DEFAULT_CANALIZE_OPTIONS as mt, resolveStyleHints as n, turnDrawRule as nn, DEFAULT_SUPPORTING_ATTACK_OPTIONS as nt, getControlMeasureMetadata as o, dynamicPointDrawRule as on, RADAR_SEARCH_DOCTRINE_STROKE_COLOR as ot, DEFAULT_STRONG_POINT_OPTIONS as p, blockDrawRule as pn, DEFAULT_CLASSIC_ARROW_OPTIONS as pt, DEFAULT_DISRUPT_OPTIONS as q, DEFAULT_AMBUSH_OPTIONS as qt, CONTROL_MEASURE_IDS as r, line1DrawRule as rn, DEFAULT_CLEAR_OPTIONS as rt, getControlMeasureMetadataByValue as s, sectorDrawRule as sn, DEFAULT_GENERIC_TEXT_OPTIONS as st, renderControlMeasure as t, line23DrawRule as tn, DEFAULT_COUNTERATTACK_OPTIONS as tt, DEFAULT_TURNING_MOVEMENT_OPTIONS as u, penetrateDrawRule as un, DEFAULT_GENERIC_POLYGON_OPTIONS as ut, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as v, snapToMidpointPerpendicular as vn, DEFAULT_GENERIC_C2_LINE_OPTIONS as vt, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as w, sphericalBearing as wn, DEFAULT_BATTLE_POSITION_OPTIONS as wt, DEFAULT_MINEFIELD_OPTIONS as x, computeInitialWidthPoint as xn, DEFAULT_BOUNDARY_OPTIONS as xt, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as y, createBaselineFrame as yn, DEFAULT_ENGINEER_WORK_LINE_OPTIONS as yt, DEFAULT_HOLDING_LINE_OPTIONS as z, DEFAULT_LABEL_HEIGHT_CSS_PIXELS as zt };
+export { DEFAULT_DISRUPT_OPTIONS as $, DEFAULT_STROKE_DASH_CSS_PIXELS as $t, DEFAULT_RETIRE_OPTIONS as A, createBaselineFrame as An, DEFAULT_CONTAIN_OPTIONS as At, DEFAULT_LIMIT_OF_ADVANCE_OPTIONS as B, DEFAULT_AREA_DEFENSE_OPTIONS as Bt, DEFAULT_MAIN_ATTACK_OPTIONS as C, containDrawRule as Cn, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as Ct, DEFAULT_WITHDRAW_OPTIONS as D, getMidpointPerpendicularSignedDistance as Dn, DEFAULT_BOUNDARY_OPTIONS as Dt, DEFAULT_WITHDRAW_UNDER_PRESSURE_OPTIONS as E, createMidpointPerpendicularDrawRule as En, DEFAULT_LIGHT_LINE_OPTIONS as Et, DEFAULT_FORTIFIED_LINE_OPTIONS as F, sphericalBearing as Fn, DEFAULT_ANTITANK_DITCH_OPTIONS as Ft, DEFAULT_HOLDING_LINE_OPTIONS as G, canonicalTextAmplifierKey as Gt, DEFAULT_HANDOVER_LINE_OPTIONS as H, DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS as Ht, DEFAULT_PROBABLE_LINE_OF_DEPLOYMENT_OPTIONS as I, unproject as In, DEFAULT_ASSEMBLY_AREA_OPTIONS as It, DEFAULT_FLOT_OPTIONS as J, DEFAULT_LABEL_HEIGHT_CSS_PIXELS as Jt, DEFAULT_BRIDGEHEAD_LINE_OPTIONS as K, normalizeTextAmplifiers as Kt, PROBABLE_LINE_OF_DEPLOYMENT_DASH as L, EPSILON as Ln, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as Lt, DEFAULT_PENETRATE_OPTIONS as M, computeInitialWidthPoint as Mn, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Mt, DEFAULT_FRONTAL_ATTACK_OPTIONS as N, haversineDistance as Nn, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Nt, DEFAULT_SEIZE_OPTIONS as O, pointOnMidpointPerpendicularAxis as On, DEFAULT_BLOCK_ARROW_OPTIONS as Ot, DEFAULT_FORTIFIED_AREA_OPTIONS as P, project as Pn, DEFAULT_ANTITANK_WALL_OPTIONS as Pt, DEFAULT_ENCIRCLEMENT_OPTIONS as Q, DEFAULT_PORTRAYAL as Qt, DEFAULT_LINE_OF_DEPARTURE_CONTACT_OPTIONS as R, getMetersPerPixel as Rn, DEFAULT_MOBILE_DEFENSE_OPTIONS as Rt, DEFAULT_MINEFIELD_OPTIONS as S, centerRadiusDrawRule as Sn, DEFAULT_BREACH_OPTIONS as St, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as T, computeDefaultMidpointPerpendicularPoint as Tn, DEFAULT_ENGINEER_WORK_LINE_OPTIONS as Tt, DEFAULT_FORWARD_EDGE_OF_BATTLE_AREA_OPTIONS as U, DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS as Ut, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as V, DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS as Vt, DEFAULT_RELEASE_LINE_OPTIONS as W, TEXT_AMPLIFIER_FIELDS as Wt, DEFAULT_FIX_OPTIONS as X, DEFAULT_LINE_CAP as Xt, DEFAULT_FIX_MISSION_TASK_OPTIONS as Y, DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS as Yt, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as Z, DEFAULT_LINE_JOIN as Zt, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as _, staticPointDrawRule as _n, DEFAULT_GENERIC_LINE_OPTIONS as _t, DEFINITIONS as a, axis1DrawRule as an, DEFAULT_TACTICAL_ARROW_OPTIONS as at, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as b, disruptDrawRule as bn, DEFAULT_CANALIZE_OPTIONS as bt, getDefaultOptions as c, line26DrawRule as cn, DEFAULT_SUPPORTING_ATTACK_OPTIONS as ct, DEFAULT_TURN_OPTIONS as d, turnDrawRule as dn, RADAR_SEARCH_DOCTRINE_FILL_COLOR as dt, DEFAULT_STROKE_WIDTH_CSS_PIXELS as en, DEFAULT_GUARD_OPTIONS as et, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as f, line1DrawRule as fn, RADAR_SEARCH_DOCTRINE_STROKE_COLOR as ft, SECONDARY_DIRECTION_OF_FIRE_DASH as g, sectorDrawRule as gn, DEFAULT_GENERIC_POLYGON_OPTIONS as gt, DEFAULT_SECONDARY_DIRECTION_OF_FIRE_OPTIONS as h, dynamicPointDrawRule as hn, DEFAULT_GENERIC_RECTANGLE_OPTIONS as ht, CONTROL_MEASURE_METADATA as i, rectangleDrawRule as in, DEFAULT_COVER_OPTIONS as it, DEFAULT_REARWARD_PASSAGE_OF_LINES_OPTIONS as j, calculateMetrics as jn, DEFAULT_BATTLE_POSITION_OPTIONS as jt, DEFAULT_SCREEN_OPTIONS as k, snapToMidpointPerpendicular as kn, DEFAULT_BLOCK_OPTIONS as kt, listControlMeasureMetadata as l, line24DrawRule as ln, DEFAULT_CLEAR_OPTIONS as lt, DEFAULT_STRONG_POINT_OPTIONS as m, attackByFireDrawRule as mn, DEFAULT_GENERIC_SECTOR_OPTIONS as mt, resolveStyleHints as n, DEFAULT_AMBUSH_OPTIONS as nn, DEFAULT_DISENGAGE_OPTIONS as nt, getControlMeasureMetadata as o, supportByFireDrawRule as on, DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS as ot, DEFAULT_RETAIN_OPTIONS as p, ambushDrawRule as pn, DEFAULT_GENERIC_TEXT_OPTIONS as pt, DEFAULT_PHASE_LINE_OPTIONS as q, resolveAmplifierPlacement as qt, CONTROL_MEASURE_IDS as r, DEFAULT_AIRBORNE_ATTACK_OPTIONS as rn, DEFAULT_DELAY_OPTIONS as rt, getControlMeasureMetadataByValue as s, line27DrawRule as sn, DEFAULT_COUNTERATTACK_OPTIONS as st, renderControlMeasure as t, DEFAULT_SYMBOL_COLOR as tn, DEFAULT_DISRUPT_MISSION_TASK_OPTIONS as tt, DEFAULT_TURNING_MOVEMENT_OPTIONS as u, line23DrawRule as un, DEFAULT_RADAR_SEARCH_DOCTRINE_OPTIONS as ut, DEFAULT_PICKUP_ZONE_OPTIONS as v, point12DrawRule as vn, DEFAULT_GENERIC_CIRCLE_OPTIONS as vt, DEFAULT_LANDING_ZONE_OPTIONS as w, area27DrawRule as wn, DEFAULT_GENERIC_C2_LINE_OPTIONS as wt, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as x, blockDrawRule as xn, DEFAULT_BYPASS_OPTIONS as xt, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as y, penetrateDrawRule as yn, DEFAULT_CLASSIC_ARROW_OPTIONS as yt, DEFAULT_LINE_OF_DEPARTURE_OPTIONS as z, roundToFixed as zn, DEFAULT_ENGAGEMENT_AREA_OPTIONS as zt };