@orbat-mapper/control-measures 0.8.0 → 0.10.0

package/dist/{renderControlMeasure-BHIGHuop.mjs → renderControlMeasure-BcJiY40G.mjs}

@@ -214,6 +214,9 @@ function vecNorm(v) {
 	const m = vecMag(v);
 	return m === 0 ? [0, 0] : [v[0] / m, v[1] / m];
 }
+function midpoint(a, b) {
+	return vecScale(vecAdd(a, b), .5);
+}
 function pointToPointDistance(p1, p2) {
 	const dx = p2[0] - p1[0];
 	const dy = p2[1] - p1[1];
@@ -586,6 +589,24 @@ const area1DrawRule = {
 	}
 };
 //#endregion
+//#region src/draw-rules/area27.ts
+/**
+* Area27 anchor draw rule for Mobile Defense.
+*
+* 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 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.
@@ -723,7 +744,7 @@ const SECTOR_ANGLE_SNAP_RADIANS = Math.PI / 36;
 function derive$9(points) {
 	return clonePositions(points.slice(0, 3));
 }
-function guidePoints$1(points) {
+function guidePoints$2(points) {
 	return points.length < 3 ? clonePositions(points) : [];
 }
 /** Snap one radial Sector handle to a true-north angular increment. */
@@ -746,7 +767,7 @@ const sectorDrawRule = {
 	minimumUserPoints: 3,
 	canonicalPointCount: 3,
 	showGuide: true,
-	guidePoints: guidePoints$1,
+	guidePoints: guidePoints$2,
 	constrainAngles,
 	derive: derive$9,
 	transform(event) {
@@ -934,6 +955,28 @@ const turnDrawRule = {
 	}
 };
 //#endregion
+//#region src/draw-rules/line11.ts
+function firstFour(points) {
+	return clonePositions(points.slice(0, 4));
+}
+function guidePoints$1(points) {
+	if (points.length <= 2) return clonePositions(points);
+	if (points.length === 3) return [];
+	return clonePositions(points.slice(2, 4));
+}
+/** Line11 — four independent anchors defining the two sides of a bridge or gap. */
+const bridgeOrGapDrawRule = {
+	id: "line11:bridge-or-gap",
+	minimumUserPoints: 4,
+	canonicalPointCount: 4,
+	showGuide: true,
+	guidePoints: guidePoints$1,
+	derive: firstFour,
+	transform(event) {
+		return firstFour(event.next);
+	}
+};
+//#endregion
 //#region src/draw-rules/line23.ts
 /**
 * Line23 anchor draw rule for the Clear mission task.
@@ -2823,7 +2866,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
@@ -2831,7 +2874,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
@@ -4361,6 +4407,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 = {
@@ -5684,33 +5997,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
@@ -5743,6 +6059,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
@@ -5780,44 +6112,76 @@ const BATTLE_POSITION = defineControlMeasure({
 	}
 });
 //#endregion
-//#region src/internal/arrowhead.ts
+//#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: "fixed",
+		text: true
+	},
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: ECHELON_AREA_PARAMS,
+	textAmplifiers: AREA_UNIT_DESIGNATION_HOSTILE_AMPLIFIERS
+};
 /**
-* Builds a closed, filled arrowhead triangle ring in unprojected coordinates.
+* 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.
 *
-* `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.
+* @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 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]);
+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 = {
@@ -6063,6 +6427,167 @@ const BLOCK = defineControlMeasure({
 	previewSample: { controlPoints: [[0, .4], [0, -.4]] }
 });
 //#endregion
+//#region src/generators/cm27-protection-areas/bridge-or-gap.ts
+const FLARE_COMPONENT_RATIO = .25;
+const DEFAULT_BRIDGE_OR_GAP_OPTIONS = {};
+const BRIDGE_OR_GAP_METADATA = {
+	id: "bridge-or-gap",
+	name: "Bridge or Gap",
+	description: "An area within a minefield or obstacle belt, free of live mines or obstacles, whose width and direction allow a friendly force to pass through in tactical formation.",
+	entity: "Protection Areas",
+	entityType: "Bridge or Gap",
+	value: "271100",
+	minCoordinates: 4,
+	maxCoordinates: 4,
+	geometry: "line",
+	geometryTypes: ["LineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Line11",
+	capturesLabelSize: true,
+	textAmplifiers: [
+		{
+			key: "T",
+			label: "Unique designation",
+			description: "Field T — the bridge or gap's unique designation.",
+			maxLength: 21
+		},
+		{
+			key: "W",
+			label: "Effective from (DTG)",
+			description: "Field W — date-time group the bridge or gap becomes effective.",
+			placeholder: "051030Z",
+			maxLength: 16
+		},
+		{
+			key: "W1",
+			label: "Effective to (DTG)",
+			description: "Field W1 — date-time group the bridge or gap ceases to be effective.",
+			placeholder: "051600Z",
+			maxLength: 16
+		}
+	]
+};
+/**
+* One side: its two anchors, plus a 45-degree flare at each end splaying away
+* from the gap. `outward` only picks which way the side's own perpendicular
+* points -- the flare stays square to this side, so both ends flare by the
+* same quarter-length in each axis.
+*/
+function sideCoordinates(start, end, outward) {
+	const side = vecSub(end, start);
+	const length = vecMag(side);
+	if (length < 1e-6) return void 0;
+	const along = vecScale(side, 1 / length);
+	const normal = [-along[1], along[0]];
+	const component = length * FLARE_COMPONENT_RATIO;
+	const flareOut = vecScale(normal, vecDot(normal, outward) >= 0 ? component : -component);
+	return {
+		coordinates: [
+			vecAdd(vecAdd(start, vecScale(along, -component)), flareOut),
+			start,
+			end,
+			vecAdd(vecAdd(end, vecScale(along, component)), flareOut)
+		].map((point) => unproject(point[0], point[1])),
+		along,
+		length
+	};
+}
+function addLabels(features, frame, options, textAmplifiers) {
+	const { points, side1, side2, across, center } = frame;
+	const averageDirection = vecAdd(side1.along, side2.along);
+	const along = vecMag(averageDirection) >= 1e-6 ? vecNorm(averageDirection) : side1.along;
+	const sizeProps = labelSizeProps(options);
+	const labels = [];
+	if (textAmplifiers.T) pushLabel(labels, center, textAmplifiers.T, labelRotationAlong(along), sizeProps, void 0, "T");
+	const row = [];
+	if (textAmplifiers.W) row.push([
+		"W",
+		textAmplifiers.W,
+		-1,
+		"end"
+	]);
+	if (textAmplifiers.W1) row.push([
+		"W1",
+		textAmplifiers.W1,
+		1,
+		"start"
+	]);
+	if (row.length > 0) {
+		const averageLength = (side1.length + side2.length) / 2;
+		const windowRotation = labelRotationAlong(across);
+		const rowCenter = vecAdd(midpoint(points[1], points[3]), vecScale(along, averageLength * FLARE_COMPONENT_RATIO + resolveLabelOffsetMeters(options, 1)));
+		const separatorOffset = resolveLabelOffsetMeters(options, .15);
+		const paired = row.length === 2;
+		for (const [field, text, sign, anchor] of row) pushLabel(labels, paired ? vecAdd(rowCenter, vecScale(across, sign * separatorOffset)) : rowCenter, text, windowRotation, sizeProps, paired ? anchor : void 0, field);
+	}
+	features.push(...labels);
+}
+function createBridgeOrGap(coordinates, options = {}, textAmplifiers = {}) {
+	const points = coordinates.slice(0, 4).map((position) => project(position[0], position[1]));
+	const [p1, p2, p3, p4] = points;
+	const mid12 = midpoint(p1, p2);
+	const mid34 = midpoint(p3, p4);
+	const betweenMidpoints = vecSub(mid12, mid34);
+	const outward1 = vecMag(betweenMidpoints) >= 1e-6 ? vecNorm(betweenMidpoints) : vecNorm([p1[1] - p2[1], p2[0] - p1[0]]);
+	const outward2 = vecScale(outward1, -1);
+	const side1 = sideCoordinates(p1, p2, outward1);
+	const side2 = sideCoordinates(p3, p4, outward2);
+	if (!side1 || !side2) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const features = [{
+		type: "Feature",
+		properties: { part: "side-1" },
+		geometry: {
+			type: "LineString",
+			coordinates: side1.coordinates
+		}
+	}, {
+		type: "Feature",
+		properties: { part: "side-2" },
+		geometry: {
+			type: "LineString",
+			coordinates: side2.coordinates
+		}
+	}];
+	addLabels(features, {
+		points,
+		side1,
+		side2,
+		across: outward2,
+		center: midpoint(mid12, mid34)
+	}, options, textAmplifiers);
+	return {
+		type: "FeatureCollection",
+		features
+	};
+}
+const BRIDGE_OR_GAP = defineControlMeasure({
+	metadata: BRIDGE_OR_GAP_METADATA,
+	generator: createBridgeOrGap,
+	defaultOptions: DEFAULT_BRIDGE_OR_GAP_OPTIONS,
+	rule: bridgeOrGapDrawRule,
+	previewSample: {
+		controlPoints: [
+			[-.35, -.7],
+			[-.35, .45],
+			[.35, -.7],
+			[.35, .45]
+		],
+		textAmplifiers: {
+			T: "T",
+			W: "W",
+			W1: "W1"
+		},
+		options: { labelSize: 55 }
+	}
+});
+//#endregion
 //#region src/generators/cm99-generic-arrows/blockArrow.ts
 const DEFAULT_SMOOTH_RESOLUTION$5 = 12;
 const MIN_SMOOTH_RESOLUTION$1 = 2;
@@ -11227,6 +11752,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 = {
@@ -11616,6 +12290,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;
@@ -12856,6 +13717,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 = {
@@ -15233,6 +16145,7 @@ 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,
@@ -15248,6 +16161,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,
@@ -15256,6 +16171,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,
@@ -15289,10 +16205,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,
@@ -15340,6 +16262,7 @@ const DEFINITIONS = {
 		}
 	}),
 	block: BLOCK,
+	"bridge-or-gap": BRIDGE_OR_GAP,
 	disrupt: DISRUPT,
 	fix: FIX,
 	"fix-mission-task": FIX_MISSION_TASK,
@@ -15735,4 +16658,4 @@ function assertNever(value) {
 	throw new Error(`Unhandled control measure kind: ${String(value)}`);
 }
 //#endregion
-export { DEFAULT_COVER_OPTIONS as $, supportByFireDrawRule as $t, DEFAULT_RETIRE_OPTIONS as A, getMetersPerPixel as An, DEFAULT_ANTITANK_DITCH_OPTIONS as At, DEFAULT_HOLDING_LINE_OPTIONS as B, resolveAmplifierPlacement as Bt, DEFAULT_MAIN_ATTACK_OPTIONS as C, calculateMetrics as Cn, DEFAULT_BLOCK_ARROW_OPTIONS as Ct, DEFAULT_WITHDRAW_OPTIONS as D, sphericalBearing as Dn, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Dt, DEFAULT_WITHDRAW_UNDER_PRESSURE_OPTIONS as E, project as En, DEFAULT_BATTLE_POSITION_OPTIONS as Et, DEFAULT_FORTIFIED_LINE_OPTIONS as F, DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS as Ft, DEFAULT_FIX_OPTIONS as G, DEFAULT_PORTRAYAL as Gt, DEFAULT_PHASE_LINE_OPTIONS as H, DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS as Ht, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as I, DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS as It, DEFAULT_DISRUPT_OPTIONS as J, DEFAULT_SYMBOL_COLOR as Jt, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as K, DEFAULT_STROKE_DASH_CSS_PIXELS as Kt, DEFAULT_HANDOVER_LINE_OPTIONS as L, TEXT_AMPLIFIER_FIELDS as Lt, DEFAULT_PENETRATE_OPTIONS as M, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as Mt, DEFAULT_FRONTAL_ATTACK_OPTIONS as N, DEFAULT_AREA_DEFENSE_OPTIONS as Nt, DEFAULT_SEIZE_OPTIONS as O, unproject as On, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Ot, DEFAULT_FORTIFIED_AREA_OPTIONS as P, DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS as Pt, DEFAULT_DELAY_OPTIONS as Q, axis1DrawRule as Qt, DEFAULT_FORWARD_EDGE_OF_BATTLE_AREA_OPTIONS as R, canonicalTextAmplifierKey as Rt, DEFAULT_MINEFIELD_OPTIONS as S, createBaselineFrame as Sn, DEFAULT_BOUNDARY_OPTIONS as St, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as T, haversineDistance as Tn, DEFAULT_CONTAIN_OPTIONS as Tt, DEFAULT_FLOT_OPTIONS as U, DEFAULT_LINE_CAP as Ut, DEFAULT_BRIDGEHEAD_LINE_OPTIONS as V, DEFAULT_LABEL_HEIGHT_CSS_PIXELS as Vt, DEFAULT_FIX_MISSION_TASK_OPTIONS as W, DEFAULT_LINE_JOIN as Wt, DEFAULT_DISRUPT_MISSION_TASK_OPTIONS as X, DEFAULT_AIRBORNE_ATTACK_OPTIONS as Xt, DEFAULT_GUARD_OPTIONS as Y, DEFAULT_AMBUSH_OPTIONS as Yt, DEFAULT_DISENGAGE_OPTIONS as Z, rectangleDrawRule as Zt, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as _, computeDefaultMidpointPerpendicularPoint as _n, DEFAULT_BREACH_OPTIONS as _t, DEFINITIONS as a, line1DrawRule as an, DEFAULT_RADAR_SEARCH_DOCTRINE_OPTIONS as at, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as b, pointOnMidpointPerpendicularAxis as bn, DEFAULT_ENGINEER_WORK_LINE_OPTIONS as bt, getDefaultOptions as c, dynamicPointDrawRule as cn, DEFAULT_GENERIC_TEXT_OPTIONS as ct, DEFAULT_TURN_OPTIONS as d, point12DrawRule as dn, DEFAULT_GENERIC_POLYGON_OPTIONS as dt, line27DrawRule as en, DEFAULT_TACTICAL_ARROW_OPTIONS as et, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as f, penetrateDrawRule as fn, DEFAULT_GENERIC_LINE_OPTIONS as ft, SECONDARY_DIRECTION_OF_FIRE_DASH as g, containDrawRule as gn, DEFAULT_BYPASS_OPTIONS as gt, DEFAULT_SECONDARY_DIRECTION_OF_FIRE_OPTIONS as h, centerRadiusDrawRule as hn, DEFAULT_CANALIZE_OPTIONS as ht, CONTROL_MEASURE_METADATA as i, turnDrawRule as in, DEFAULT_CLEAR_OPTIONS as it, DEFAULT_REARWARD_PASSAGE_OF_LINES_OPTIONS as j, roundToFixed as jn, DEFAULT_ASSEMBLY_AREA_OPTIONS as jt, DEFAULT_SCREEN_OPTIONS as k, EPSILON as kn, DEFAULT_ANTITANK_WALL_OPTIONS as kt, listControlMeasureMetadata as l, sectorDrawRule as ln, DEFAULT_GENERIC_SECTOR_OPTIONS as lt, DEFAULT_STRONG_POINT_OPTIONS as m, blockDrawRule as mn, DEFAULT_CLASSIC_ARROW_OPTIONS as mt, resolveStyleHints as n, line24DrawRule as nn, DEFAULT_COUNTERATTACK_OPTIONS as nt, getControlMeasureMetadata as o, ambushDrawRule as on, RADAR_SEARCH_DOCTRINE_FILL_COLOR as ot, DEFAULT_RETAIN_OPTIONS as p, disruptDrawRule as pn, DEFAULT_GENERIC_CIRCLE_OPTIONS as pt, DEFAULT_ENCIRCLEMENT_OPTIONS as q, DEFAULT_STROKE_WIDTH_CSS_PIXELS as qt, CONTROL_MEASURE_IDS as r, line23DrawRule as rn, DEFAULT_SUPPORTING_ATTACK_OPTIONS as rt, getControlMeasureMetadataByValue as s, attackByFireDrawRule as sn, RADAR_SEARCH_DOCTRINE_STROKE_COLOR as st, renderControlMeasure as t, line26DrawRule as tn, DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS as tt, DEFAULT_TURNING_MOVEMENT_OPTIONS as u, staticPointDrawRule as un, DEFAULT_GENERIC_RECTANGLE_OPTIONS as ut, DEFAULT_PICKUP_ZONE_OPTIONS as v, createMidpointPerpendicularDrawRule as vn, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as vt, DEFAULT_LANDING_ZONE_OPTIONS as w, computeInitialWidthPoint as wn, DEFAULT_BLOCK_OPTIONS as wt, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as x, snapToMidpointPerpendicular as xn, DEFAULT_LIGHT_LINE_OPTIONS as xt, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as y, getMidpointPerpendicularSignedDistance as yn, DEFAULT_GENERIC_C2_LINE_OPTIONS as yt, DEFAULT_RELEASE_LINE_OPTIONS as z, normalizeTextAmplifiers 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 };