@orbat-mapper/control-measures 0.15.1 → 0.17.0

package/dist/{renderControlMeasure-qnu0Feey.mjs → renderControlMeasure-Bh62ZdEY.mjs}

@@ -237,6 +237,11 @@ function vecNorm(v) {
 	const m = vecMag(v);
 	return m === 0 ? [0, 0] : [v[0] / m, v[1] / m];
 }
+function vecRotate(v, radians) {
+	const cosine = Math.cos(radians);
+	const sine = Math.sin(radians);
+	return [v[0] * cosine - v[1] * sine, v[0] * sine + v[1] * cosine];
+}
 function midpoint(a, b) {
 	return vecScale(vecAdd(a, b), .5);
 }
@@ -300,10 +305,10 @@ function createWidthOptionHandles(config) {
 			}];
 		},
 		drag({ controlPoints, options, handleId, position }) {
-			const geometry = config.geometry(controlPoints, options);
-			if (!geometry || geometry.referenceHalfWidth < 1e-6) return void 0;
 			const rear = handleId === REAR_WIDTH_OPTION_HANDLE_ID;
 			if (!rear && !(handleId === "shaft-width")) return void 0;
+			const geometry = config.geometry(controlPoints, options);
+			if (!geometry || geometry.referenceHalfWidth < 1e-6) return void 0;
 			const from = rear ? geometry.spine[0] : geometry.spine.at(-2);
 			const to = rear ? geometry.spine[1] : geometry.spine.at(-1);
 			if (!from || !to) return void 0;
@@ -780,6 +785,18 @@ const disruptDrawRule = createMidpointPerpendicularDrawRule({
 	normal: "left"
 });
 //#endregion
+//#region src/draw-rules/area16.ts
+/**
+* Area16 — center + start/radius 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 occupyDrawRule = {
+	...centerRadiusDrawRule,
+	id: "area16:center-radius"
+};
+//#endregion
 //#region src/draw-rules/area17.ts
 /**
 * Area17 anchor draw rule for Penetrate.
@@ -1357,6 +1374,23 @@ const line32DrawRule = {
 	}
 };
 //#endregion
+//#region src/draw-rules/line33.ts
+/**
+* Line33 anchor draw rule for the Pursuit mission task.
+*
+* PT. 1 and PT. 2 define the straight portion. PT. 3 is constrained to the
+* perpendicular axis through PT. 2, where its signed distance determines the
+* semicircular arc's diameter and which side of the straight line it occupies.
+*/
+const line33DrawRule = createMidpointPerpendicularDrawRule({
+	id: "line33:pursuit",
+	origin: "p2",
+	defaultDistanceRatio: .6,
+	minimumUserPoints: 3,
+	minimumPreviewPoints: 2,
+	finishOnLastPointRepeat: true
+});
+//#endregion
 //#region src/draw-rules/polyline1.ts
 /**
 * Polyline1 anchors for the Infiltration Lane.
@@ -4564,7 +4598,7 @@ const AREA = defineControlMeasure({
 //#endregion
 //#region src/generators/cm15-maneuver-areas/area-defense.ts
 const DEFAULT_AREA_DEFENSE_OPTIONS = {
-	arrowOpeningAngle: 30,
+	openingAngle: 30,
 	labelOpeningAngle: 20,
 	barbCount: 6,
 	barbLengthRatio: .16,
@@ -4594,7 +4628,7 @@ const AREA_DEFENSE_METADATA = {
 	capturesLabelSize: true,
 	params: [
 		{
-			key: "arrowOpeningAngle",
+			key: "openingAngle",
 			presentationTier: "advanced",
 			label: "Arrow opening",
 			description: "Angular opening between the two arrow tips, in degrees",
@@ -4675,7 +4709,7 @@ function createAreaDefense(coordinates, options = {}) {
 		features: []
 	};
 	const upperTipAngle = Math.atan2(radiusVector[1], radiusVector[0]);
-	const arrowHalf = Math.min(120, Math.max(5, resolved.arrowOpeningAngle)) * Math.PI / 360;
+	const arrowHalf = Math.min(120, Math.max(5, resolved.openingAngle)) * Math.PI / 360;
 	const labelHalf = Math.min(90, Math.max(5, resolved.labelOpeningAngle)) * Math.PI / 360;
 	const labelCenter = upperTipAngle + arrowHalf - Math.PI;
 	const upperStart = labelCenter + labelHalf;
@@ -6111,7 +6145,7 @@ const DEFAULT_ATTACK_HELICOPTER_OPTIONS = {
 	symbolHeightRatio: .45,
 	triangleSizeRatio: .25,
 	bottomBarWidthRatio: 1.5,
-	bowtieWidthRatio: .8
+	bowTieWidthRatio: .8
 };
 const ATTACK_HELICOPTER_METADATA = {
 	id: "attack-helicopter",
@@ -6163,7 +6197,7 @@ const ATTACK_HELICOPTER_METADATA = {
 			step: .1
 		},
 		{
-			key: "bowtieWidthRatio",
+			key: "bowTieWidthRatio",
 			presentationTier: "advanced",
 			label: "Bowtie width",
 			description: "Size of the central bowtie relative to the reference triangle.",
@@ -6232,7 +6266,7 @@ function createAttackHelicopter(coordinates, options = {}) {
 			const symbolHeightRatio = options.symbolHeightRatio ?? DEFAULT_ATTACK_HELICOPTER_OPTIONS.symbolHeightRatio;
 			const triangleSizeRatio = options.triangleSizeRatio ?? DEFAULT_ATTACK_HELICOPTER_OPTIONS.triangleSizeRatio;
 			const bottomBarWidthRatio = options.bottomBarWidthRatio ?? DEFAULT_ATTACK_HELICOPTER_OPTIONS.bottomBarWidthRatio;
-			const bowtieWidthRatio = options.bowtieWidthRatio ?? DEFAULT_ATTACK_HELICOPTER_OPTIONS.bowtieWidthRatio;
+			const bowTieWidthRatio = options.bowTieWidthRatio ?? DEFAULT_ATTACK_HELICOPTER_OPTIONS.bowTieWidthRatio;
 			const baseUnit = headWidth * .45;
 			const shaftLength = headWidth * symbolHeightRatio;
 			const triHeight = baseUnit * triangleSizeRatio;
@@ -6278,7 +6312,7 @@ function createAttackHelicopter(coordinates, options = {}) {
 					coordinates: [unproject(pBarLeft[0], pBarLeft[1]), unproject(pBarRight[0], pBarRight[1])]
 				}
 			};
-			const bowTieSize = refTriHeight * bowtieWidthRatio;
+			const bowTieSize = refTriHeight * bowTieWidthRatio;
 			const bowTieHalfWidth = bowTieSize * .6;
 			const pBowTieRightBaseCenter = vecAdd(center, vecScale(u, bowTieSize));
 			const pBowTieRightTop = vecAdd(pBowTieRightBaseCenter, vecScale(n, bowTieHalfWidth));
@@ -9791,12 +9825,189 @@ const CLEAR = defineControlMeasure({
 	rule: line23DrawRule
 });
 //#endregion
+//#region src/generators/cm15-maneuver-areas/maneuver-arrow-task-shared.ts
+const DEFAULT_MANEUVER_ARROW_TASK_AMPLIFIER_OPTIONS = {
+	labelPosition: .25,
+	dtgPosition: .62,
+	labelPadding: 0
+};
+const DEFAULT_MANEUVER_ARROW_TASK_OPTIONS = {
+	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
+	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
+	smooth: false,
+	smoothResolution: 5,
+	crossbarLengthRatio: 1.1,
+	...DEFAULT_MANEUVER_ARROW_TASK_AMPLIFIER_OPTIONS
+};
+function createManeuverArrowTaskAmplifierLabels(geometry, options, textAmplifiers) {
+	const resolved = {
+		...DEFAULT_MANEUVER_ARROW_TASK_AMPLIFIER_OPTIONS,
+		...options
+	};
+	const centerline = geometry.shaftCenterline;
+	const { segments, totalLength } = polylineSegments(centerline);
+	if (segments.length === 0) return [];
+	const labels = [];
+	const sizeProps = labelSizeProps(resolved);
+	const labelFrame = pointAlongPolyline(segments, totalLength, clamp01(resolved.labelPosition));
+	if (labelFrame && textAmplifiers.T) pushLabel(labels, labelFrame.point, textAmplifiers.T, labelRotationAlong(labelFrame.along), sizeProps, void 0, "T");
+	const dtgFrame = pointAlongPolyline(segments, totalLength, clamp01(resolved.dtgPosition));
+	if (dtgFrame) {
+		const rowOffset = resolveLabelOffsetMeters(resolved, .55 + Math.max(0, resolved.labelPadding));
+		const rotation = labelRotationAlong(dtgFrame.along);
+		if (textAmplifiers.W) pushLabel(labels, vecAdd(dtgFrame.point, vecScale(dtgFrame.perp, rowOffset)), textAmplifiers.W, rotation, sizeProps, void 0, "W");
+		if (textAmplifiers.W1) pushLabel(labels, vecSub(dtgFrame.point, vecScale(dtgFrame.perp, rowOffset)), textAmplifiers.W1, rotation, sizeProps, void 0, "W1");
+	}
+	return labels;
+}
+function createManeuverArrowTask(coordinates, options, textAmplifiers, config) {
+	const merged = {
+		...DEFAULT_MANEUVER_ARROW_TASK_OPTIONS,
+		...options
+	};
+	const resolved = {
+		...merged,
+		rearWidthRatio: resolveRearWidthRatio(options, merged.shaftWidthRatio)
+	};
+	const { geometry } = processAttackGeometry(coordinates, resolved);
+	if (!geometry) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const outline = [
+		...geometry.shaftLeft,
+		geometry.headRing[0],
+		geometry.headRing[1],
+		geometry.headRing[2],
+		...[...geometry.shaftRight].reverse()
+	];
+	const centerline = geometry.shaftCenterline;
+	const { segments, totalLength } = polylineSegments(centerline);
+	if (segments.length === 0) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const tipVector = vecSub(geometry.ptTip, geometry.ptBase);
+	const tipDirection = vecNorm(tipVector);
+	const headWidth = vecMag(vecSub(geometry.headRing[0], geometry.headRing[2]));
+	let crossbarCenter;
+	let crossbarAlong;
+	let crossbarBaseWidth = headWidth;
+	if (config.crossbarAt === "tip") {
+		crossbarCenter = geometry.ptTip;
+		crossbarAlong = tipDirection;
+	} else {
+		const shaftPosition = Number.isFinite(config.crossbarAt.shaftPosition) ? clamp01(config.crossbarAt.shaftPosition) : 0;
+		const crossbarFrame = pointAlongPolyline(segments, totalLength, shaftPosition);
+		crossbarCenter = crossbarFrame.point;
+		crossbarAlong = crossbarFrame.along;
+		const rearWidth = vecMag(vecSub(geometry.shaftLeft[0], geometry.shaftRight[0]));
+		crossbarBaseWidth = rearWidth + (vecMag(vecSub(geometry.shaftLeft.at(-1), geometry.shaftRight.at(-1))) - rearWidth) * shaftPosition;
+	}
+	const crossbarLength = crossbarBaseWidth * Math.max(1, resolved.crossbarLengthRatio);
+	const crossbarPerp = [-crossbarAlong[1], crossbarAlong[0]];
+	const crossbar = [vecAdd(crossbarCenter, vecScale(crossbarPerp, crossbarLength / 2)), vecSub(crossbarCenter, vecScale(crossbarPerp, crossbarLength / 2))];
+	const features = [{
+		type: "Feature",
+		properties: { part: config.part },
+		geometry: {
+			type: "MultiLineString",
+			coordinates: [outline, crossbar].map((line) => line.map((point) => unproject(point[0], point[1])))
+		}
+	}];
+	const sizeProps = labelSizeProps(resolved);
+	const codePoint = vecAdd(geometry.ptBase, vecScale(tipVector, .55));
+	const labels = [{
+		type: "Feature",
+		properties: {
+			part: "label",
+			labelPlacement: false,
+			text: config.code,
+			rotation: labelRotationAlong(tipDirection),
+			...sizeProps
+		},
+		geometry: {
+			type: "Point",
+			coordinates: unproject(codePoint[0], codePoint[1])
+		}
+	}];
+	features.push(...labels, ...createManeuverArrowTaskAmplifierLabels(geometry, resolved, textAmplifiers));
+	return {
+		type: "FeatureCollection",
+		features
+	};
+}
+const MANEUVER_ARROW_TASK_AMPLIFIER_PARAMS = [
+	{
+		key: "labelPosition",
+		presentationTier: "advanced",
+		label: "Designation position",
+		description: "Position of Field T along the shaft, from tail (0) to head (1)",
+		type: "number",
+		min: 0,
+		max: 1,
+		step: .01
+	},
+	{
+		key: "dtgPosition",
+		presentationTier: "advanced",
+		label: "Date-time position",
+		description: "Position of Fields W/W1 along the shaft, from tail (0) to head (1)",
+		type: "number",
+		min: 0,
+		max: 1,
+		step: .01
+	},
+	{
+		key: "labelPadding",
+		presentationTier: "advanced",
+		label: "Label padding",
+		description: "Extra spacing between the W and W1 rows, in label heights",
+		type: "number",
+		min: 0,
+		max: 2,
+		step: .05
+	}
+];
+const MANEUVER_ARROW_TASK_PARAMS = [{
+	key: "crossbarLengthRatio",
+	presentationTier: "advanced",
+	label: "Straight line length",
+	description: "Crossbar length as a multiple of the arrowhead base width",
+	type: "number",
+	min: 1,
+	max: 2.5,
+	step: .1
+}, ...MANEUVER_ARROW_TASK_AMPLIFIER_PARAMS];
+const MANEUVER_ARROW_TASK_TEXT_AMPLIFIERS = [
+	{
+		key: "T",
+		label: "Unique designation",
+		description: "Field T — the maneuver's unique designation.",
+		placeholder: "DAVID",
+		maxLength: 21
+	},
+	{
+		key: "W",
+		label: "Start date-time group",
+		description: "Field W — the maneuver's start date-time group.",
+		placeholder: "080400ZOCT2008"
+	},
+	{
+		key: "W1",
+		label: "End date-time group",
+		description: "Field W1 — the maneuver's end date-time group.",
+		placeholder: "120300ZOCT2008"
+	}
+];
+//#endregion
 //#region src/generators/cm15-maneuver-areas/supportingAttack.ts
 const DEFAULT_SUPPORTING_ATTACK_OPTIONS = {
 	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
 	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
 	smooth: false,
-	smoothResolution: 5
+	smoothResolution: 5,
+	...DEFAULT_MANEUVER_ARROW_TASK_AMPLIFIER_OPTIONS
 };
 const SUPPORTING_ATTACK_METADATA = {
 	id: "supporting-attack",
@@ -9808,14 +10019,16 @@ const SUPPORTING_ATTACK_METADATA = {
 	value: "151404",
 	minCoordinates: 3,
 	geometry: "line",
-	geometryTypes: ["LineString"],
+	geometryTypes: ["LineString", "Point"],
 	paints: {
 		stroke: true,
 		fill: "none",
-		text: false
+		text: true
 	},
 	drawRule: "Axis1",
-	params: ATTACK_SHAFT_PARAMS
+	capturesLabelSize: true,
+	params: [...ATTACK_SHAFT_PARAMS, ...MANEUVER_ARROW_TASK_AMPLIFIER_PARAMS],
+	textAmplifiers: MANEUVER_ARROW_TASK_TEXT_AMPLIFIERS
 };
 /**
 * Generates a GeoJSON FeatureCollection for a Supporting Attack tactical symbol.
@@ -9827,7 +10040,7 @@ const SUPPORTING_ATTACK_METADATA = {
 * @param options - Configuration options.
 * @returns A GeoJSON FeatureCollection<LineString>.
 */
-function createSupportingAttack(coordinates, options = {}) {
+function createSupportingAttack(coordinates, options = {}, textAmplifiers = {}) {
 	const { geometry } = processAttackGeometry(coordinates, options);
 	if (!geometry) return {
 		type: "FeatureCollection",
@@ -9842,7 +10055,7 @@ function createSupportingAttack(coordinates, options = {}) {
 				type: "LineString",
 				coordinates: supportingAttackOutline(geometry)
 			}
-		}]
+		}, ...createManeuverArrowTaskAmplifierLabels(geometry, options, textAmplifiers)]
 	};
 }
 /**
@@ -9867,7 +10080,21 @@ const SUPPORTING_ATTACK = defineControlMeasure({
 	generator: createSupportingAttack,
 	defaultOptions: DEFAULT_SUPPORTING_ATTACK_OPTIONS,
 	rule: axis1DrawRule,
-	optionHandles: variableWidthAttackOptionHandles
+	optionHandles: variableWidthAttackOptionHandles,
+	previewSample: {
+		controlPoints: [
+			[1, 0],
+			[-.4, -.35],
+			[-1, -.8],
+			[.45, .55]
+		],
+		textAmplifiers: {
+			T: "DAVID",
+			W: "080400Z",
+			W1: "120300Z"
+		},
+		options: { labelSize: 80 }
+	}
 });
 //#endregion
 //#region src/generators/cm34-mission-tasks/counterattack.ts
@@ -9917,14 +10144,20 @@ const COUNTERATTACK_METADATA = {
 };
 /** Generates the Counterattack mission task (340600). */
 function createCounterattack(coordinates, options = {}, textAmplifiers = {}) {
-	const outline = createSupportingAttack(coordinates, options);
 	const { geometry } = processAttackGeometry(coordinates, options);
-	if (!geometry || outline.features.length === 0) return outline;
+	if (!geometry) return {
+		type: "FeatureCollection",
+		features: []
+	};
 	const dashedOutline = {
-		...outline.features[0],
+		type: "Feature",
 		properties: {
 			part: "counterattack",
 			style: { strokeDash: [...COUNTERATTACK_DASH] }
+		},
+		geometry: {
+			type: "LineString",
+			coordinates: supportingAttackOutline(geometry)
 		}
 	};
 	const { segments, totalLength } = polylineSegments(geometry.shaftCenterline);
@@ -10180,7 +10413,7 @@ function buildFieldOfFireV(coordinates, hSize, hWidth) {
 	};
 }
 //#endregion
-//#region src/generators/cm15-maneuver-areas/searchArea.ts
+//#region src/tactical-arrow-utils.ts
 const DEFAULT_ARROWHEAD_LENGTH_RATIO = .12;
 const DEFAULT_ARROWHEAD_WIDTH_RATIO = .5;
 const DEFAULT_ZIGZAG_START = .55;
@@ -10196,183 +10429,17 @@ const DEFAULT_TACTICAL_ARROW_OPTIONS = {
 	zigzagEnd: DEFAULT_ZIGZAG_END,
 	zigzagAmplitudeRatio: DEFAULT_ZIGZAG_AMPLITUDE_RATIO
 };
-const SEARCH_AREA_METADATA = {
-	id: "search-area",
-	name: "Search Area",
-	description: "Designates an area to examine systematically for specified persons, forces, materiel, or information.",
-	entity: "Maneuver Areas",
-	entityType: "Search Area",
-	value: "152200",
-	minCoordinates: 3,
-	maxCoordinates: 3,
-	geometry: "area",
-	geometryTypes: ["MultiLineString", "MultiPolygon"],
-	paints: {
-		stroke: true,
-		fill: "fixed",
-		text: false
-	},
-	drawRule: "Area21",
-	params: [
-		{
-			key: "arrowheadLengthRatio",
-			presentationTier: "advanced",
-			label: "Arrowhead length",
-			description: "Arrowhead length as a ratio of the total leg length",
-			type: "number",
-			min: 0,
-			max: .5,
-			step: .01
-		},
-		{
-			key: "arrowheadWidthRatio",
-			presentationTier: "advanced",
-			label: "Arrowhead width",
-			description: "Arrowhead base width as a multiple of the arrowhead length",
-			type: "number",
-			min: .05,
-			max: 2,
-			step: .1
-		},
-		{
-			key: "zigzagStart",
-			presentationTier: "advanced",
-			label: "Zigzag start",
-			description: "Point along the leg where the zigzag begins (0-1).",
-			type: "number",
-			min: 0,
-			max: 1,
-			step: .05
-		},
-		{
-			key: "zigzagEnd",
-			presentationTier: "advanced",
-			label: "Zigzag end",
-			description: "Point along the leg where the zigzag returns (0-1).",
-			type: "number",
-			min: 0,
-			max: 1,
-			step: .05
-		},
-		{
-			key: "zigzagAmplitudeRatio",
-			presentationTier: "advanced",
-			label: "Zigzag amplitude",
-			description: "Perpendicular kink offset as a ratio of leg length.",
-			type: "number",
-			min: 0,
-			max: .3,
-			step: .01
-		}
-	]
-};
-/**
-* Generates a GeoJSON FeatureCollection of a tactical "lightning" arrow.
-* Handles internal projection to maintain correct perpendicularity.
-*
-* @param coordinates - [Apex Point (PT1), Top Tail (PT2), Bottom Tail (PT3)]
-* @param options - Geometric configuration parameters
-* @returns A FeatureCollection containing a MultiLineString for bolts and a MultiPolygon for heads
-*/
-function createSearchArea(coordinates, options = {}) {
-	const { arrowheadLengthRatio = DEFAULT_ARROWHEAD_LENGTH_RATIO, arrowheadWidthRatio = DEFAULT_ARROWHEAD_WIDTH_RATIO, zigzagStart = DEFAULT_ZIGZAG_START, zigzagEnd = DEFAULT_ZIGZAG_END, zigzagAmplitudeRatio = DEFAULT_ZIGZAG_AMPLITUDE_RATIO } = options;
-	const safeArrowheadLengthRatio = Math.max(0, arrowheadLengthRatio);
-	const safeArrowheadWidthRatio = Math.max(0, arrowheadWidthRatio);
-	const safeZigzagStart = clamp01(zigzagStart);
-	const safeZigzagEnd = clamp01(zigzagEnd);
-	const safeZigzagAmplitudeRatio = Math.max(0, zigzagAmplitudeRatio);
-	const [c0, c1, c2] = coordinates;
-	const [p1, p2, p3] = [
-		project(c0[0], c0[1]),
-		project(c1[0], c1[1]),
-		project(c2[0], c2[1])
-	];
-	const shaftSegments = [];
-	const headPolygons = [];
-	const addLeg = (origin, tip, opposite) => {
-		const v = vecSub(tip, origin);
-		const totalLen = vecMag(v);
-		if (totalLen < 1e-6) return;
-		const u = vecNorm(v);
-		let n = [-u[1], u[0]];
-		const toOpp = vecSub(opposite, origin);
-		if (vecDot(n, toOpp) > 0) n = vecScale(n, -1);
-		const offset = totalLen * safeZigzagAmplitudeRatio;
-		const ptA = vecAdd(vecAdd(origin, vecScale(v, safeZigzagStart)), vecScale(n, offset));
-		const ptB = vecAdd(vecAdd(origin, vecScale(v, safeZigzagEnd)), vecScale(n, -offset));
-		const fv = vecSub(tip, ptB);
-		const fLen = vecMag(fv);
-		let fu = vecNorm(fv);
-		if (fLen < 1e-6) fu = u;
-		const headLen = totalLen * safeArrowheadLengthRatio;
-		const pBase = vecSub(tip, vecScale(fu, headLen));
-		const wingWidth = headLen * safeArrowheadWidthRatio;
-		const perp = [-fu[1], fu[0]];
-		const pWing1 = vecAdd(pBase, vecScale(perp, wingWidth));
-		const pWing2 = vecSub(pBase, vecScale(perp, wingWidth));
-		shaftSegments.push([
-			origin,
-			ptA,
-			ptB,
-			pBase
-		].map((p) => unproject(p[0], p[1])));
-		headPolygons.push([[
-			tip,
-			pWing1,
-			pWing2,
-			tip
-		].map((p) => unproject(p[0], p[1]))]);
-	};
-	addLeg(p1, p2, p3);
-	addLeg(p1, p3, p2);
-	const features = [];
-	if (shaftSegments.length > 0) features.push({
-		type: "Feature",
-		properties: { part: "shaft" },
-		geometry: {
-			type: "MultiLineString",
-			coordinates: shaftSegments
-		}
-	});
-	if (headPolygons.length > 0) features.push({
-		type: "Feature",
-		properties: {
-			part: "head",
-			fill: true,
-			style: SOLID_ACCENT_FILL
-		},
-		geometry: {
-			type: "MultiPolygon",
-			coordinates: headPolygons
-		}
-	});
-	return {
-		type: "FeatureCollection",
-		features
-	};
-}
-const SEARCH_AREA = defineControlMeasure({
-	metadata: SEARCH_AREA_METADATA,
-	generator: (controlPoints, options) => createSearchArea(asThreePoints(controlPoints), options),
-	defaultOptions: DEFAULT_TACTICAL_ARROW_OPTIONS,
-	rule: searchAreaDrawRule
-});
-//#endregion
-//#region src/generators/cm34-mission-tasks/security-task-shared.ts
-const DEFAULT_SECURITY_TASK_OPTIONS = {
-	...DEFAULT_TACTICAL_ARROW_OPTIONS,
-	labelInsetRatio: .2
-};
-const SECURITY_TASK_PARAMS = [
-	{
-		key: "arrowheadLengthRatio",
-		presentationTier: "advanced",
-		label: "Arrowhead length",
-		description: "Arrowhead length as a ratio of the total leg length",
-		type: "number",
-		min: 0,
-		max: .5,
-		step: .01
+/** The param descriptors every tactical-arrow leg exposes, in presentation order. */
+const TACTICAL_ARROW_PARAMS = [
+	{
+		key: "arrowheadLengthRatio",
+		presentationTier: "advanced",
+		label: "Arrowhead length",
+		description: "Arrowhead length as a ratio of the total leg length",
+		type: "number",
+		min: 0,
+		max: .5,
+		step: .01
 	},
 	{
 		key: "arrowheadWidthRatio",
@@ -10413,19 +10480,39 @@ const SECURITY_TASK_PARAMS = [
 		min: 0,
 		max: .3,
 		step: .01
-	},
-	{
-		key: "labelInsetRatio",
-		presentationTier: "advanced",
-		label: "Letter position",
-		description: "Inset of each task letter from PT. 2 or PT. 3 across the center opening",
-		type: "number",
-		min: .05,
-		max: .45,
-		step: .01
 	}
 ];
 /**
+* The single home of the tactical-arrow option contract: fills in the defaults
+* and applies the clamps the leg geometry relies on, so every measure carrying
+* a lightning leg reads the same ranges.
+*/
+function resolveTacticalArrowOptions(options) {
+	return {
+		arrowheadLengthRatio: Math.max(0, options.arrowheadLengthRatio ?? DEFAULT_ARROWHEAD_LENGTH_RATIO),
+		arrowheadWidthRatio: Math.max(0, options.arrowheadWidthRatio ?? DEFAULT_ARROWHEAD_WIDTH_RATIO),
+		zigzagStart: clamp01(options.zigzagStart ?? DEFAULT_ZIGZAG_START),
+		zigzagEnd: clamp01(options.zigzagEnd ?? DEFAULT_ZIGZAG_END),
+		zigzagAmplitudeRatio: Math.max(0, options.zigzagAmplitudeRatio ?? DEFAULT_ZIGZAG_AMPLITUDE_RATIO)
+	};
+}
+//#endregion
+//#region src/generators/cm34-mission-tasks/security-task-shared.ts
+const DEFAULT_SECURITY_TASK_OPTIONS = {
+	...DEFAULT_TACTICAL_ARROW_OPTIONS,
+	labelInsetRatio: .2
+};
+const SECURITY_TASK_PARAMS = [...TACTICAL_ARROW_PARAMS, {
+	key: "labelInsetRatio",
+	presentationTier: "advanced",
+	label: "Letter position",
+	description: "Inset of each task letter from PT. 2 or PT. 3 across the center opening",
+	type: "number",
+	min: .05,
+	max: .45,
+	step: .01
+}];
+/**
 * Shared Line26 geometry for the Cover, Guard, and Screen task family.
 * PT. 1/PT. 4 are the outward tips; PT. 2/PT. 3 are the inner shaft ends.
 * The opening between PT. 2 and PT. 3 is deliberately left clear for the
@@ -10443,13 +10530,7 @@ function createSecurityTaskSymbol(coordinates, config, options = {}) {
 		...DEFAULT_SECURITY_TASK_OPTIONS,
 		...options
 	};
-	const arrowOptions = {
-		arrowheadLengthRatio: Math.max(0, resolved.arrowheadLengthRatio),
-		arrowheadWidthRatio: Math.max(0, resolved.arrowheadWidthRatio),
-		zigzagStart: clamp(resolved.zigzagStart, 0, 1),
-		zigzagEnd: clamp(resolved.zigzagEnd, 0, 1),
-		zigzagAmplitudeRatio: Math.max(0, resolved.zigzagAmplitudeRatio)
-	};
+	const arrowOptions = resolveTacticalArrowOptions(resolved);
 	const lines = [createTacticalArrow(p2, p1, p3, arrowOptions), createTacticalArrow(p3, p4, p2, arrowOptions)].flatMap((arrow) => arrow ?? []);
 	if (lines.length === 0) return {
 		type: "FeatureCollection",
@@ -10641,18 +10722,16 @@ function createDelaySymbol(coordinates, options = {}) {
 		createArrowHead$1(p1, vecScale(dirLine, -1), lineLength * (options.arrowheadLengthRatio ?? DEFAULT_DELAY_OPTIONS.arrowheadLengthRatio), lineLength * (options.arrowheadWidthRatio ?? DEFAULT_DELAY_OPTIONS.arrowheadWidthRatio))
 	];
 	if (diameter >= 1e-6) lines.push(createSemicircleArc(p2, diameterEnd, dirLine, options.arcSegments ?? DEFAULT_DELAY_OPTIONS.arcSegments));
-	const lineFeature = {
-		type: "Feature",
-		properties: { part: "delay" },
-		geometry: {
-			type: "MultiLineString",
-			coordinates: lines
-		}
-	};
-	const lineRotation = Math.atan2(dirLine[1], dirLine[0]);
 	return {
 		type: "FeatureCollection",
-		features: [lineFeature, createLabelFeature(labelPoint, "D", normalizeRadians(Math.PI + lineRotation), {
+		features: [{
+			type: "Feature",
+			properties: { part: "delay" },
+			geometry: {
+				type: "MultiLineString",
+				coordinates: lines
+			}
+		}, createLabelFeature(labelPoint, "D", labelRotationAlong(dirLine), {
 			labelSize: options.labelSize,
 			labelSizePixels: options.labelSizePixels
 		})]
@@ -12713,7 +12792,7 @@ function createInfiltrationLane(coordinates, options = {}, textAmplifiers = {})
 			type: "Feature",
 			properties: {
 				part: "label",
-				labelPlacement: false,
+				labelPlacementKey: "T",
 				amplifierField: "T",
 				text: textAmplifiers.T,
 				rotation: labelRotationAlong(labelFrame.along),
@@ -13662,188 +13741,27 @@ const FORTIFIED_AREA = defineControlMeasure({
 	}
 });
 //#endregion
-//#region src/generators/cm15-maneuver-areas/maneuver-arrow-task-shared.ts
-const DEFAULT_MANEUVER_ARROW_TASK_OPTIONS = {
-	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
-	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
-	smooth: false,
-	smoothResolution: 5,
-	crossbarLengthRatio: 1.1,
-	labelPosition: .25,
-	dtgPosition: .62,
-	labelPadding: 0
-};
-function createManeuverArrowTask(coordinates, options, textAmplifiers, config) {
-	const merged = {
-		...DEFAULT_MANEUVER_ARROW_TASK_OPTIONS,
-		...options
-	};
-	const resolved = {
-		...merged,
-		rearWidthRatio: resolveRearWidthRatio(options, merged.shaftWidthRatio)
-	};
-	const { geometry } = processAttackGeometry(coordinates, resolved);
-	if (!geometry) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const outline = [
-		...geometry.shaftLeft,
-		geometry.headRing[0],
-		geometry.headRing[1],
-		geometry.headRing[2],
-		...[...geometry.shaftRight].reverse()
-	];
-	const centerline = geometry.shaftCenterline;
-	const { segments, totalLength } = polylineSegments(centerline);
-	if (segments.length === 0) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const tipVector = vecSub(geometry.ptTip, geometry.ptBase);
-	const tipDirection = vecNorm(tipVector);
-	const headWidth = vecMag(vecSub(geometry.headRing[0], geometry.headRing[2]));
-	let crossbarCenter;
-	let crossbarAlong;
-	let crossbarBaseWidth = headWidth;
-	if (config.crossbarAt === "tip") {
-		crossbarCenter = geometry.ptTip;
-		crossbarAlong = tipDirection;
-	} else {
-		const shaftPosition = Number.isFinite(config.crossbarAt.shaftPosition) ? clamp01(config.crossbarAt.shaftPosition) : 0;
-		const crossbarFrame = pointAlongPolyline(segments, totalLength, shaftPosition);
-		crossbarCenter = crossbarFrame.point;
-		crossbarAlong = crossbarFrame.along;
-		const rearWidth = vecMag(vecSub(geometry.shaftLeft[0], geometry.shaftRight[0]));
-		crossbarBaseWidth = rearWidth + (vecMag(vecSub(geometry.shaftLeft.at(-1), geometry.shaftRight.at(-1))) - rearWidth) * shaftPosition;
-	}
-	const crossbarLength = crossbarBaseWidth * Math.max(1, resolved.crossbarLengthRatio);
-	const crossbarPerp = [-crossbarAlong[1], crossbarAlong[0]];
-	const crossbar = [vecAdd(crossbarCenter, vecScale(crossbarPerp, crossbarLength / 2)), vecSub(crossbarCenter, vecScale(crossbarPerp, crossbarLength / 2))];
-	const features = [{
-		type: "Feature",
-		properties: { part: config.part },
-		geometry: {
-			type: "MultiLineString",
-			coordinates: [outline, crossbar].map((line) => line.map((point) => unproject(point[0], point[1])))
-		}
-	}];
-	const sizeProps = labelSizeProps(resolved);
-	const codePoint = vecAdd(geometry.ptBase, vecScale(tipVector, .55));
-	const labels = [{
-		type: "Feature",
-		properties: {
-			part: "label",
-			labelPlacement: false,
-			text: config.code,
-			rotation: labelRotationAlong(tipDirection),
-			...sizeProps
-		},
-		geometry: {
-			type: "Point",
-			coordinates: unproject(codePoint[0], codePoint[1])
-		}
-	}];
-	const labelFrame = pointAlongPolyline(segments, totalLength, clamp01(resolved.labelPosition));
-	if (labelFrame && textAmplifiers.T) pushLabel(labels, labelFrame.point, textAmplifiers.T, labelRotationAlong(labelFrame.along), sizeProps, void 0, "T");
-	const dtgFrame = pointAlongPolyline(segments, totalLength, clamp01(resolved.dtgPosition));
-	if (dtgFrame) {
-		const rowOffset = resolveLabelOffsetMeters(resolved, .55 + Math.max(0, resolved.labelPadding));
-		const rotation = labelRotationAlong(dtgFrame.along);
-		if (textAmplifiers.W) pushLabel(labels, vecAdd(dtgFrame.point, vecScale(dtgFrame.perp, rowOffset)), textAmplifiers.W, rotation, sizeProps, void 0, "W");
-		if (textAmplifiers.W1) pushLabel(labels, vecSub(dtgFrame.point, vecScale(dtgFrame.perp, rowOffset)), textAmplifiers.W1, rotation, sizeProps, void 0, "W1");
-	}
-	features.push(...labels);
-	return {
-		type: "FeatureCollection",
-		features
-	};
-}
-const MANEUVER_ARROW_TASK_PARAMS = [
-	{
-		key: "crossbarLengthRatio",
-		presentationTier: "advanced",
-		label: "Straight line length",
-		description: "Crossbar length as a multiple of the arrowhead base width",
-		type: "number",
-		min: 1,
-		max: 2.5,
-		step: .1
-	},
-	{
-		key: "labelPosition",
-		presentationTier: "advanced",
-		label: "Designation position",
-		description: "Position of Field T along the shaft, from tail (0) to head (1)",
-		type: "number",
-		min: 0,
-		max: 1,
-		step: .01
-	},
-	{
-		key: "dtgPosition",
-		presentationTier: "advanced",
-		label: "Date-time position",
-		description: "Position of Fields W/W1 along the shaft, from tail (0) to head (1)",
-		type: "number",
-		min: 0,
-		max: 1,
-		step: .01
-	},
-	{
-		key: "labelPadding",
-		presentationTier: "advanced",
-		label: "Label padding",
-		description: "Extra spacing between the W and W1 rows, in label heights",
-		type: "number",
-		min: 0,
-		max: 2,
-		step: .05
-	}
-];
-const MANEUVER_ARROW_TASK_TEXT_AMPLIFIERS = [
-	{
-		key: "T",
-		label: "Unique designation",
-		description: "Field T — the maneuver's unique designation.",
-		placeholder: "DAVID",
-		maxLength: 21
-	},
-	{
-		key: "W",
-		label: "Start date-time group",
-		description: "Field W — the maneuver's start date-time group.",
-		placeholder: "080400ZOCT2008"
-	},
-	{
-		key: "W1",
-		label: "End date-time group",
-		description: "Field W1 — the maneuver's end date-time group.",
-		placeholder: "120300ZOCT2008"
-	}
-];
-//#endregion
-//#region src/generators/cm15-maneuver-areas/frontal-attack.ts
-const DEFAULT_FRONTAL_ATTACK_OPTIONS = DEFAULT_MANEUVER_ARROW_TASK_OPTIONS;
-const FRONTAL_ATTACK_METADATA = {
-	id: "frontal-attack",
-	name: "Frontal Attack",
-	description: "An offensive maneuver in which the main action is directed against the front.",
-	entity: "Maneuver Areas",
-	entityType: "Frontal Attack",
-	value: "152700",
-	minCoordinates: 3,
-	geometry: "line",
-	geometryTypes: ["MultiLineString", "Point"],
-	paints: {
-		stroke: true,
-		fill: "none",
-		text: true
-	},
-	drawRule: "Axis1",
-	capturesLabelSize: true,
-	params: [...ATTACK_SHAFT_PARAMS, ...MANEUVER_ARROW_TASK_PARAMS],
-	textAmplifiers: MANEUVER_ARROW_TASK_TEXT_AMPLIFIERS
+//#region src/generators/cm15-maneuver-areas/frontal-attack.ts
+const DEFAULT_FRONTAL_ATTACK_OPTIONS = DEFAULT_MANEUVER_ARROW_TASK_OPTIONS;
+const FRONTAL_ATTACK_METADATA = {
+	id: "frontal-attack",
+	name: "Frontal Attack",
+	description: "An offensive maneuver in which the main action is directed against the front.",
+	entity: "Maneuver Areas",
+	entityType: "Frontal Attack",
+	value: "152700",
+	minCoordinates: 3,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Axis1",
+	capturesLabelSize: true,
+	params: [...ATTACK_SHAFT_PARAMS, ...MANEUVER_ARROW_TASK_PARAMS],
+	textAmplifiers: MANEUVER_ARROW_TASK_TEXT_AMPLIFIERS
 };
 function createFrontalAttack(coordinates, options = {}, textAmplifiers = {}) {
 	return createManeuverArrowTask(coordinates, options, textAmplifiers, {
@@ -13874,6 +13792,49 @@ const FRONTAL_ATTACK = defineControlMeasure({
 	}
 });
 //#endregion
+//#region src/generators/cm34-mission-tasks/forward-passage-of-lines.ts
+const DEFAULT_FORWARD_PASSAGE_OF_LINES_OPTIONS = DEFAULT_DELAY_OPTIONS;
+const FORWARD_PASSAGE_OF_LINES_METADATA = {
+	id: "forward-passage-of-lines",
+	name: "Forward Passage of Lines",
+	description: "Passes one force through another force's positions toward the enemy.",
+	entity: "Mission Tasks",
+	entityType: "Forward Passage of Lines",
+	value: "344100",
+	minCoordinates: 3,
+	maxCoordinates: 3,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Line24",
+	capturesLabelSize: true,
+	params: DELAY_PARAMS
+};
+function createForwardPassageOfLinesSymbol(coordinates, options = {}) {
+	return createDelayVariantSymbol(coordinates, {
+		glyph: "P(F)",
+		part: "forward-passage-of-lines"
+	}, options);
+}
+const FORWARD_PASSAGE_OF_LINES = defineControlMeasure({
+	metadata: FORWARD_PASSAGE_OF_LINES_METADATA,
+	generator: createForwardPassageOfLinesSymbol,
+	defaultOptions: DEFAULT_FORWARD_PASSAGE_OF_LINES_OPTIONS,
+	rule: line24DrawRule,
+	previewSample: {
+		controlPoints: [
+			[1, -.4],
+			[-1, -.4],
+			[0, .6]
+		],
+		options: { labelGapRatio: .42 }
+	}
+});
+//#endregion
 //#region src/generators/cm34-mission-tasks/isolate.ts
 /**
 * Default options for the ISOLATE symbol.
@@ -14012,6 +13973,327 @@ const ISOLATE = defineControlMeasure({
 	rule: isolateDrawRule
 });
 //#endregion
+//#region src/generators/cm34-mission-tasks/movement-to-contact.ts
+/** Default bolt length as a multiple of the shaft width at the arrow base. */
+const MOVEMENT_TO_CONTACT_BOLT_LENGTH_RATIO = 1;
+const DEFAULT_MOVEMENT_TO_CONTACT_BOLT_ANGLE = 45;
+const MOVEMENT_TO_CONTACT_BOLT_HANDLE_ID = "bolt-tip";
+const MOVEMENT_TO_CONTACT_STEM_SETBACK_RATIO = .22;
+const MOVEMENT_TO_CONTACT_STEM_OFFSET_RATIO = .55;
+const DEFAULT_MOVEMENT_TO_CONTACT_OPTIONS = {
+	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
+	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
+	smooth: false,
+	smoothResolution: 5,
+	...DEFAULT_TACTICAL_ARROW_OPTIONS,
+	...DEFAULT_MANEUVER_ARROW_TASK_AMPLIFIER_OPTIONS,
+	boltLengthRatio: MOVEMENT_TO_CONTACT_BOLT_LENGTH_RATIO,
+	boltAngle: DEFAULT_MOVEMENT_TO_CONTACT_BOLT_ANGLE
+};
+const MOVEMENT_TO_CONTACT_METADATA = {
+	id: "movement-to-contact",
+	name: "Movement to Contact",
+	description: "Develops the situation and establishes or regains contact with the enemy.",
+	entity: "Mission Tasks",
+	entityType: "Movement to Contact",
+	value: "342900",
+	minCoordinates: 3,
+	geometry: "line",
+	geometryTypes: [
+		"MultiLineString",
+		"MultiPolygon",
+		"Point"
+	],
+	paints: {
+		stroke: true,
+		fill: "fixed",
+		text: true
+	},
+	drawRule: "Axis1",
+	capturesLabelSize: true,
+	params: [
+		...ATTACK_SHAFT_PARAMS,
+		{
+			key: "boltLengthRatio",
+			presentationTier: "advanced",
+			label: "Bolt length",
+			description: "Bolt length as a multiple of the shaft width at the arrow base (2 or more is recommended).",
+			type: "number",
+			min: .1,
+			max: 6,
+			step: .1
+		},
+		{
+			key: "boltAngle",
+			presentationTier: "advanced",
+			label: "Bolt angle",
+			description: "Angle between each bolt and the main arrow axis, in degrees.",
+			type: "number",
+			min: 0,
+			max: 90,
+			step: 1
+		},
+		...TACTICAL_ARROW_PARAMS,
+		...MANEUVER_ARROW_TASK_AMPLIFIER_PARAMS
+	],
+	textAmplifiers: MANEUVER_ARROW_TASK_TEXT_AMPLIFIERS
+};
+function createBolt({ tip, arrowDirection, arrowBaseWidth, boltLengthRatio, boltAngle, side, options }) {
+	const arrowNormal = [-arrowDirection[1], arrowDirection[0]];
+	const direction = vecRotate(arrowDirection, side * (boltAngle * Math.PI / 180));
+	const boltNormal = [-direction[1], direction[0]];
+	const origin = vecAdd(vecAdd(tip, vecScale(arrowDirection, -arrowBaseWidth * MOVEMENT_TO_CONTACT_STEM_SETBACK_RATIO)), vecScale(arrowNormal, side * arrowBaseWidth * MOVEMENT_TO_CONTACT_STEM_OFFSET_RATIO));
+	const boltLength = arrowBaseWidth * boltLengthRatio;
+	const boltTip = vecAdd(origin, vecScale(direction, boltLength));
+	const zigzagAmplitude = boltLength * options.zigzagAmplitudeRatio;
+	const firstKink = vecAdd(vecAdd(origin, vecScale(direction, boltLength * options.zigzagStart)), vecScale(boltNormal, zigzagAmplitude));
+	const secondKink = vecAdd(vecAdd(origin, vecScale(direction, boltLength * options.zigzagEnd)), vecScale(boltNormal, -zigzagAmplitude));
+	const finalSegment = vecSub(boltTip, secondKink);
+	const finalDirection = vecMag(finalSegment) >= 1e-6 ? vecNorm(finalSegment) : direction;
+	const headLength = boltLength * options.arrowheadLengthRatio;
+	return {
+		origin,
+		tip: boltTip,
+		shaft: [
+			origin,
+			firstKink,
+			secondKink,
+			vecAdd(boltTip, vecScale(finalDirection, -headLength))
+		],
+		head: createArrowHeadRing(boltTip, finalDirection, headLength, headLength * options.arrowheadWidthRatio * 2)
+	};
+}
+function resolveMovementToContactGeometry(coordinates, options) {
+	const { geometry } = processAttackGeometry(coordinates, options);
+	if (!geometry) return null;
+	const direction = vecNorm(vecSub(geometry.ptTip, geometry.ptBase));
+	const arrowBaseWidth = vecMag(vecSub(geometry.shaftLeft.at(-1), geometry.shaftRight.at(-1)));
+	const boltLengthRatio = Math.max(0, options.boltLengthRatio ?? DEFAULT_MOVEMENT_TO_CONTACT_OPTIONS.boltLengthRatio);
+	const boltAngle = clamp(options.boltAngle ?? DEFAULT_MOVEMENT_TO_CONTACT_OPTIONS.boltAngle, 0, 90);
+	const boltOptions = resolveTacticalArrowOptions(options);
+	const create = (side) => createBolt({
+		tip: geometry.ptTip,
+		arrowDirection: direction,
+		arrowBaseWidth,
+		boltLengthRatio,
+		boltAngle,
+		side,
+		options: boltOptions
+	});
+	return {
+		geometry,
+		direction,
+		arrowBaseWidth,
+		bolts: [create(1), create(-1)]
+	};
+}
+/** Generates the Movement to Contact mission task (342900). */
+function createMovementToContact(coordinates, options = {}, textAmplifiers = {}) {
+	const resolved = resolveMovementToContactGeometry(coordinates, options);
+	if (!resolved) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const { geometry, bolts } = resolved;
+	return {
+		type: "FeatureCollection",
+		features: [
+			{
+				type: "Feature",
+				properties: { part: "body-and-bolts" },
+				geometry: {
+					type: "MultiLineString",
+					coordinates: [supportingAttackOutline(geometry), ...bolts.map((bolt) => bolt.shaft.map((point) => unproject(point[0], point[1])))]
+				}
+			},
+			{
+				type: "Feature",
+				properties: {
+					part: "bolt-heads",
+					fill: true,
+					style: SOLID_ACCENT_FILL
+				},
+				geometry: {
+					type: "MultiPolygon",
+					coordinates: bolts.map((bolt) => [bolt.head])
+				}
+			},
+			...createManeuverArrowTaskAmplifierLabels(geometry, options, textAmplifiers)
+		]
+	};
+}
+const MOVEMENT_TO_CONTACT = defineControlMeasure({
+	metadata: MOVEMENT_TO_CONTACT_METADATA,
+	generator: createMovementToContact,
+	defaultOptions: DEFAULT_MOVEMENT_TO_CONTACT_OPTIONS,
+	rule: axis1DrawRule,
+	optionHandles: {
+		get(controlPoints, options) {
+			const widthHandles = variableWidthAttackOptionHandles.get(controlPoints, options);
+			const resolved = resolveMovementToContactGeometry(controlPoints, options);
+			if (!resolved) return widthHandles;
+			return [...widthHandles, {
+				id: MOVEMENT_TO_CONTACT_BOLT_HANDLE_ID,
+				position: unproject(resolved.bolts[0].tip[0], resolved.bolts[0].tip[1])
+			}];
+		},
+		drag(event) {
+			if (event.handleId !== MOVEMENT_TO_CONTACT_BOLT_HANDLE_ID) return variableWidthAttackOptionHandles.drag(event);
+			const resolved = resolveMovementToContactGeometry(event.controlPoints, event.options);
+			if (!resolved || resolved.arrowBaseWidth < 1e-6) return void 0;
+			const fromOrigin = vecSub(project(event.position[0], event.position[1]), resolved.bolts[0].origin);
+			const length = vecMag(fromOrigin);
+			if (length < 1e-6) return { boltLengthRatio: 0 };
+			const cross = resolved.direction[0] * fromOrigin[1] - resolved.direction[1] * fromOrigin[0];
+			const dot = resolved.direction[0] * fromOrigin[0] + resolved.direction[1] * fromOrigin[1];
+			return {
+				boltLengthRatio: length / resolved.arrowBaseWidth,
+				boltAngle: clamp(Math.abs(Math.atan2(cross, dot) * 180 / Math.PI), 0, 90)
+			};
+		}
+	},
+	previewSample: {
+		controlPoints: [
+			[1, 0],
+			[-.4, -.35],
+			[-1, -.8],
+			[.45, .55]
+		],
+		textAmplifiers: {
+			T: "DAVID",
+			W: "080400Z",
+			W1: "120300Z"
+		},
+		options: { labelSize: 80 }
+	}
+});
+//#endregion
+//#region src/generators/cm34-mission-tasks/occupy.ts
+const DEFAULT_OCCUPY_OPTIONS = {
+	openingAngle: 30,
+	resolution: 64,
+	xSizeRatio: .2,
+	xAspectRatio: 1.5,
+	labelPadding: .2
+};
+const OCCUPY_METADATA = {
+	id: "occupy",
+	name: "Occupy",
+	description: "Moves a friendly force into an area so it can control that area.",
+	entity: "Mission Tasks",
+	entityType: "Occupy",
+	value: "341700",
+	minCoordinates: 2,
+	maxCoordinates: 2,
+	geometry: "area",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Area16",
+	capturesLabelSize: true,
+	params: [
+		{
+			key: "openingAngle",
+			presentationTier: "advanced",
+			label: "Opening",
+			description: "Angular width of the opening on the friendly side, in degrees",
+			type: "number",
+			min: 5,
+			max: 180,
+			step: 1
+		},
+		...ARC_RESOLUTION_PARAMS,
+		{
+			key: "xSizeRatio",
+			presentationTier: "advanced",
+			label: "X size",
+			description: "Overall size of the terminal X as a ratio of the symbol radius",
+			type: "number",
+			min: .02,
+			max: .75,
+			step: .01
+		},
+		{
+			key: "xAspectRatio",
+			presentationTier: "advanced",
+			label: "X aspect ratio",
+			description: "Width-to-height ratio of the terminal X",
+			type: "number",
+			min: .25,
+			max: 4,
+			step: .05
+		},
+		{
+			key: "labelPadding",
+			presentationTier: "advanced",
+			label: "O padding",
+			description: "Extra boundary clearance on each side of O, as a ratio of its height",
+			type: "number",
+			min: 0,
+			max: 2,
+			step: .05
+		}
+	]
+};
+const TAU$1 = Math.PI * 2;
+const MIN_LABEL_GAP_METERS$1 = 1;
+/** Generates the Occupy mission task symbol (341700). */
+function createOccupySymbol(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_OCCUPY_OPTIONS,
+		...options
+	};
+	const bulgeVector = [radiusVector[1], -radiusVector[0]];
+	const halfTurnResolution = normalizeArcResolution(resolved.resolution) / 2;
+	const boundarySpan = TAU$1 - Math.min(180, Math.max(5, resolved.openingAngle)) * Math.PI / 180;
+	const labelSweep = boundarySpan / 2;
+	const labelHeight = resolveLabelOffsetMeters(options, 1, radius * .12);
+	const labelPadding = Math.max(0, resolved.labelPadding);
+	const labelHalfGap = Math.min(boundarySpan / 4, Math.max(labelHeight * (LABEL_HALF_GLYPH_RATIO + labelPadding), MIN_LABEL_GAP_METERS$1) / radius);
+	const sampleArc = (from, to) => sampleProjectedArc(center, radiusVector, bulgeVector, from, to, halfTurnResolution);
+	const lines = [sampleArc(0, labelSweep - labelHalfGap), sampleArc(labelSweep + labelHalfGap, boundarySpan)];
+	const terminal = arcPointAt(center, radiusVector, bulgeVector, boundarySpan);
+	const radial = vecScale(vecSub(terminal, center), 1 / radius);
+	const tangent = [radial[1], -radial[0]];
+	const halfHeight = radius * Math.max(0, resolved.xSizeRatio) / 2;
+	const radialHalfWidth = vecScale(radial, halfHeight * Math.max(.25, resolved.xAspectRatio));
+	const tangentHalfHeight = vecScale(tangent, halfHeight);
+	const stroke = (diagonal) => [vecAdd(terminal, diagonal), vecSub(terminal, diagonal)].map((point) => unproject(point[0], point[1]));
+	lines.push(stroke(vecAdd(radialHalfWidth, tangentHalfHeight)), stroke(vecSub(radialHalfWidth, tangentHalfHeight)));
+	const labelPoint = arcPointAt(center, radiusVector, bulgeVector, labelSweep);
+	return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: { part: "occupy" },
+			geometry: {
+				type: "MultiLineString",
+				coordinates: lines
+			}
+		}, createLabelFeature(labelPoint, "O", Math.PI, options)]
+	};
+}
+const OCCUPY = defineControlMeasure({
+	metadata: OCCUPY_METADATA,
+	generator: createOccupySymbol,
+	defaultOptions: DEFAULT_OCCUPY_OPTIONS,
+	rule: occupyDrawRule,
+	previewSample: {
+		controlPoints: [[0, 0], [-.8, .2]],
+		options: { labelSize: 90 }
+	}
+});
+//#endregion
 //#region src/generators/cm34-mission-tasks/penetrate.ts
 const DEFAULT_PENETRATE_OPTIONS = {
 	arrowheadLengthRatio: .15,
@@ -14130,6 +14412,155 @@ const PENETRATE = defineControlMeasure({
 	] }
 });
 //#endregion
+//#region src/generators/cm34-mission-tasks/pursuit.ts
+const DEFAULT_PURSUIT_OPTIONS = {
+	arrowheadLengthRatio: .1,
+	arrowheadWidthRatio: .12,
+	terminalBarLengthRatio: 1.5,
+	labelPosition: .6,
+	labelGapRatio: .18,
+	resolution: 64
+};
+const PURSUIT_METADATA = {
+	id: "pursuit",
+	name: "Pursuit",
+	description: "A mission task to catch or cut off a hostile force attempting to escape, with the aim of destroying it.",
+	entity: "Mission Tasks",
+	entityType: "Pursuit",
+	value: "344000",
+	minCoordinates: 3,
+	maxCoordinates: 3,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Line33",
+	capturesLabelSize: true,
+	params: [
+		{
+			key: "arrowheadLengthRatio",
+			presentationTier: "advanced",
+			label: "Arrowhead length",
+			description: "Arrowhead length as a ratio of the arc diameter",
+			type: "number",
+			min: .01,
+			max: .5,
+			step: .01
+		},
+		{
+			key: "arrowheadWidthRatio",
+			presentationTier: "advanced",
+			label: "Arrowhead width",
+			description: "Arrowhead width as a ratio of the arc diameter",
+			type: "number",
+			min: .01,
+			max: .5,
+			step: .01
+		},
+		{
+			key: "terminalBarLengthRatio",
+			presentationTier: "advanced",
+			label: "Terminal bar length",
+			description: "Terminal bar length as a multiple of the arrowhead width",
+			type: "number",
+			min: .1,
+			max: 10,
+			step: .1
+		},
+		{
+			key: "labelPosition",
+			presentationTier: "advanced",
+			label: "Label position",
+			description: "Position of the P label along the straight portion",
+			type: "number",
+			min: 0,
+			max: 1,
+			step: .01
+		},
+		{
+			key: "labelGapRatio",
+			presentationTier: "advanced",
+			label: "Label gap",
+			description: "Size of the straight-line cutout holding the P label",
+			type: "number",
+			min: 0,
+			max: 1,
+			step: .01
+		},
+		...ARC_RESOLUTION_PARAMS
+	]
+};
+/** Generates the Pursuit mission task symbol (344000). */
+function createPursuit(coordinates, options = {}) {
+	const [c1, c2, c3] = coordinates;
+	const p1 = project(c1[0], c1[1]);
+	const p2 = project(c2[0], c2[1]);
+	const rawP3 = project(c3[0], c3[1]);
+	const frame = createProjectedBaselineFrame(p1, p2, {
+		origin: "p2",
+		normal: "right"
+	});
+	if (!frame) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const { direction: straightDirection, normal: diameterAxis, length: straightLength } = frame;
+	const signedDiameter = vecDot(vecSub(rawP3, frame.origin), diameterAxis);
+	const diameter = Math.abs(signedDiameter);
+	if (diameter < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const p3 = vecAdd(p2, vecScale(diameterAxis, signedDiameter));
+	const labelPoint = vecAdd(p1, vecScale(straightDirection, straightLength * clamp01(options.labelPosition ?? DEFAULT_PURSUIT_OPTIONS.labelPosition)));
+	const gapHalf = straightLength * clamp01(options.labelGapRatio ?? DEFAULT_PURSUIT_OPTIONS.labelGapRatio) / 2;
+	const gapStart = vecAdd(labelPoint, vecScale(straightDirection, -gapHalf));
+	const gapEnd = vecAdd(labelPoint, vecScale(straightDirection, gapHalf));
+	const center = midpoint(p2, p3);
+	const arc = sampleProjectedArc(center, vecSub(p2, center), vecScale(straightDirection, diameter / 2), 0, Math.PI, normalizeArcResolution(options.resolution) / 2);
+	const arrowheadLength = diameter * Math.max(0, options.arrowheadLengthRatio ?? DEFAULT_PURSUIT_OPTIONS.arrowheadLengthRatio);
+	const arrowheadWidth = diameter * Math.max(0, options.arrowheadWidthRatio ?? DEFAULT_PURSUIT_OPTIONS.arrowheadWidthRatio);
+	const arrowhead = createArrowHead$1(p3, vecScale(straightDirection, -1), arrowheadLength, arrowheadWidth);
+	const terminalBarHalf = arrowheadWidth * Math.max(0, options.terminalBarLengthRatio ?? DEFAULT_PURSUIT_OPTIONS.terminalBarLengthRatio) / 2;
+	const terminalStart = vecAdd(p3, vecScale(diameterAxis, terminalBarHalf));
+	const terminalEnd = vecSub(p3, vecScale(diameterAxis, terminalBarHalf));
+	const terminalBar = [unproject(terminalStart[0], terminalStart[1]), unproject(terminalEnd[0], terminalEnd[1])];
+	return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: { part: "pursuit" },
+			geometry: {
+				type: "MultiLineString",
+				coordinates: [
+					[c1, unproject(gapStart[0], gapStart[1])],
+					[unproject(gapEnd[0], gapEnd[1]), c2],
+					arc,
+					arrowhead,
+					terminalBar
+				]
+			}
+		}, createLabelFeature(labelPoint, "P", labelRotationAlong(straightDirection), options)]
+	};
+}
+const PURSUIT = defineControlMeasure({
+	metadata: PURSUIT_METADATA,
+	generator: createPursuit,
+	defaultOptions: DEFAULT_PURSUIT_OPTIONS,
+	rule: line33DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, .4],
+			[1, .4],
+			[0, -.6]
+		],
+		options: { labelSize: 100 }
+	}
+});
+//#endregion
 //#region src/generators/cm34-mission-tasks/rearward-passage-of-lines.ts
 const DEFAULT_REARWARD_PASSAGE_OF_LINES_OPTIONS = DEFAULT_DELAY_OPTIONS;
 const REARWARD_PASSAGE_OF_LINES_METADATA = {
@@ -14262,6 +14693,58 @@ const DEFAULT_SEIZE_OPTIONS = {
 	curveSegments: 48,
 	circleSegments: 64
 };
+const SEIZE_PARAMS = [
+	{
+		key: "arrowheadLengthRatio",
+		presentationTier: "advanced",
+		label: "Arrowhead length",
+		description: "Arrowhead length as a ratio of the PT. 2-to-PT. 4 span",
+		type: "number",
+		min: .01,
+		max: .5,
+		step: .01
+	},
+	{
+		key: "arrowheadWidthRatio",
+		presentationTier: "advanced",
+		label: "Arrowhead width",
+		description: "Arrowhead base width as a ratio of the PT. 2-to-PT. 4 span",
+		type: "number",
+		min: .01,
+		max: .5,
+		step: .01
+	},
+	{
+		key: "labelGapRatio",
+		presentationTier: "advanced",
+		label: "Label gap",
+		description: "Size of the curve gap holding the S label",
+		type: "number",
+		min: 0,
+		max: .5,
+		step: .01
+	},
+	{
+		key: "curveSegments",
+		presentationTier: "advanced",
+		label: "Curve segments",
+		description: "Number of straight segments used to approximate the circular arc",
+		type: "number",
+		min: 4,
+		max: 128,
+		step: 1
+	},
+	{
+		key: "circleSegments",
+		presentationTier: "advanced",
+		label: "Circle segments",
+		description: "Number of straight segments used to approximate the assigned-unit circle",
+		type: "number",
+		min: 12,
+		max: 128,
+		step: 1
+	}
+];
 const SEIZE_METADATA = {
 	id: "seize",
 	name: "Seize",
@@ -14280,58 +14763,7 @@ const SEIZE_METADATA = {
 	},
 	drawRule: "Line27",
 	capturesLabelSize: true,
-	params: [
-		{
-			key: "arrowheadLengthRatio",
-			presentationTier: "advanced",
-			label: "Arrowhead length",
-			description: "Arrowhead length as a ratio of the PT. 2-to-PT. 4 span",
-			type: "number",
-			min: .01,
-			max: .5,
-			step: .01
-		},
-		{
-			key: "arrowheadWidthRatio",
-			presentationTier: "advanced",
-			label: "Arrowhead width",
-			description: "Arrowhead base width as a ratio of the PT. 2-to-PT. 4 span",
-			type: "number",
-			min: .01,
-			max: .5,
-			step: .01
-		},
-		{
-			key: "labelGapRatio",
-			presentationTier: "advanced",
-			label: "Label gap",
-			description: "Size of the curve gap holding the S label",
-			type: "number",
-			min: 0,
-			max: .5,
-			step: .01
-		},
-		{
-			key: "curveSegments",
-			presentationTier: "advanced",
-			label: "Curve segments",
-			description: "Number of straight segments used to approximate the circular arc",
-			type: "number",
-			min: 4,
-			max: 128,
-			step: 1
-		},
-		{
-			key: "circleSegments",
-			presentationTier: "advanced",
-			label: "Circle segments",
-			description: "Number of straight segments used to approximate the assigned-unit circle",
-			type: "number",
-			min: 12,
-			max: 128,
-			step: 1
-		}
-	]
+	params: SEIZE_PARAMS
 };
 function positiveAngle(angle) {
 	const normalized = angle % (Math.PI * 2);
@@ -14361,8 +14793,8 @@ function threePointArc(start, middle, end) {
 		sweepAngle: positiveAngle(middleAngle - startAngle) <= counterclockwiseSweep ? counterclockwiseSweep : counterclockwiseSweep - Math.PI * 2
 	};
 }
-/** Generates the Seize mission task symbol (342300). */
-function createSeizeSymbol(coordinates, options = {}) {
+/** Shared geometry for mission tasks that use the Seize graphic. */
+function createSeizeLikeSymbol(coordinates, options = {}, label = "S", part = "seize") {
 	const [c1, c2, c3, c4] = coordinates;
 	const center = project(c1[0], c1[1]);
 	const start = project(c2[0], c2[1]);
@@ -14423,23 +14855,28 @@ function createSeizeSymbol(coordinates, options = {}) {
 		const angle = startAngle + index / circleSegments * Math.PI * 2;
 		circle.push(toPosition(vecAdd(center, [radius * Math.cos(angle), radius * Math.sin(angle)])));
 	}
+	const lines = [
+		circle,
+		firstArcPart,
+		secondArcPart,
+		createArrowHead$1(tip, arrowDirection, span * Math.max(0, options.arrowheadLengthRatio ?? DEFAULT_SEIZE_OPTIONS.arrowheadLengthRatio), span * Math.max(0, options.arrowheadWidthRatio ?? DEFAULT_SEIZE_OPTIONS.arrowheadWidthRatio))
+	];
 	return {
 		type: "FeatureCollection",
 		features: [{
 			type: "Feature",
-			properties: { part: "seize" },
+			properties: { part },
 			geometry: {
 				type: "MultiLineString",
-				coordinates: [
-					circle,
-					firstArcPart,
-					secondArcPart,
-					createArrowHead$1(tip, arrowDirection, span * Math.max(0, options.arrowheadLengthRatio ?? DEFAULT_SEIZE_OPTIONS.arrowheadLengthRatio), span * Math.max(0, options.arrowheadWidthRatio ?? DEFAULT_SEIZE_OPTIONS.arrowheadWidthRatio))
-				]
+				coordinates: lines
 			}
-		}, createLabelFeature(labelPoint, "S", labelRotationAlong(tangentAtLabel), options)]
+		}, createLabelFeature(labelPoint, label, labelRotationAlong(tangentAtLabel), options)]
 	};
 }
+/** Generates the Seize mission task symbol (342300). */
+function createSeizeSymbol(coordinates, options = {}) {
+	return createSeizeLikeSymbol(coordinates, options);
+}
 const SEIZE = defineControlMeasure({
 	metadata: SEIZE_METADATA,
 	generator: createSeizeSymbol,
@@ -14456,6 +14893,48 @@ const SEIZE = defineControlMeasure({
 	}
 });
 //#endregion
+//#region src/generators/cm34-mission-tasks/evacuate.ts
+const DEFAULT_EVACUATE_OPTIONS = DEFAULT_SEIZE_OPTIONS;
+const EVACUATE_METADATA = {
+	id: "evacuate",
+	name: "Evacuate",
+	description: "Removes personnel or materiel from a threatened area.",
+	entity: "Mission Tasks",
+	entityType: "Evacuation",
+	value: "344500",
+	minCoordinates: 4,
+	maxCoordinates: 4,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Line27",
+	capturesLabelSize: true,
+	params: SEIZE_PARAMS
+};
+/** Generates the Evacuate mission task symbol (344500). */
+function createEvacuateSymbol(coordinates, options = {}) {
+	return createSeizeLikeSymbol(coordinates, options, "E", "evacuate");
+}
+const EVACUATE = defineControlMeasure({
+	metadata: EVACUATE_METADATA,
+	generator: createEvacuateSymbol,
+	defaultOptions: DEFAULT_EVACUATE_OPTIONS,
+	rule: line27DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-.8, .35],
+			[-.45, .35],
+			[.15, .25],
+			[.85, -.55]
+		],
+		options: { labelSize: 100 }
+	}
+});
+//#endregion
 //#region src/generators/cm34-mission-tasks/withdraw.ts
 const DEFAULT_WITHDRAW_OPTIONS = DEFAULT_DELAY_OPTIONS;
 const WITHDRAW_METADATA = {
@@ -14534,6 +15013,216 @@ const WITHDRAW_UNDER_PRESSURE = defineControlMeasure({
 	}
 });
 //#endregion
+//#region src/generators/cm27-protection-areas/turn.ts
+const DEFAULT_TURN_OPTIONS = {
+	arrowheadLengthRatio: .16,
+	arrowheadWidthRatio: .16,
+	arcSegments: 64
+};
+const TURN_PARAMS = [
+	{
+		key: "arrowheadLengthRatio",
+		presentationTier: "advanced",
+		label: "Arrowhead length",
+		description: "Arrowhead length as a ratio of the rear-to-tip distance",
+		type: "number",
+		min: .01,
+		max: .5,
+		step: .01
+	},
+	{
+		key: "arrowheadWidthRatio",
+		presentationTier: "advanced",
+		label: "Arrowhead width",
+		description: "Arrowhead base width as a ratio of the rear-to-tip distance",
+		type: "number",
+		min: .01,
+		max: .5,
+		step: .01
+	},
+	{
+		key: "arcSegments",
+		presentationTier: "advanced",
+		label: "Arc segments",
+		description: "Number of line segments approximating the quarter-circle shaft.",
+		type: "number",
+		min: 4,
+		max: 128,
+		step: 1
+	}
+];
+const TURN_METADATA = {
+	id: "turn",
+	name: "Turn",
+	description: "Diverts an enemy formation from one avenue of approach to another or into an engagement area. The arrow indicates the desired direction of turn.",
+	entity: "Protection Areas",
+	entityType: "Obstacle Effects",
+	entitySubtype: "Turn",
+	value: "270504",
+	minCoordinates: 2,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "MultiPolygon"],
+	paints: {
+		stroke: true,
+		fill: "fixed",
+		text: false
+	},
+	drawRule: "Line10",
+	params: TURN_PARAMS
+};
+/**
+* Shared geometry for the Turn graphic: a quarter-circle shaft from PT2
+* (rear) to the arrowhead base, with the arrowhead continuing tangent to the
+* arc and placing its tip at PT1. PT3 selects which side of the PT2 -> PT1
+* chord contains the arc.
+*
+* `labelGapRatio` opens a gap centered on the arc midpoint, sized as a ratio
+* of the arc sweep, for measures that carry a doctrinal glyph there.
+*/
+function createTurnLikeSymbol(coordinates, options = {}, labelGapRatio = 0) {
+	const tip = project(coordinates[0][0], coordinates[0][1]);
+	const rear = project(coordinates[1][0], coordinates[1][1]);
+	const side = quarterArcSide(rear, tip, coordinates[2] ? project(coordinates[2][0], coordinates[2][1]) : void 0);
+	const rearToTip = vecSub(tip, rear);
+	const totalLength = vecMag(rearToTip);
+	if (totalLength < 1e-6) return { features: [] };
+	const requestedHeadLength = totalLength * (options.arrowheadLengthRatio ?? DEFAULT_TURN_OPTIONS.arrowheadLengthRatio);
+	const tangentComponent = Math.min(Math.max(requestedHeadLength, EPSILON), totalLength * .95) / Math.SQRT2;
+	const arcChordLength = Math.sqrt(totalLength * totalLength - tangentComponent * tangentComponent) - tangentComponent;
+	const chordOffset = Math.atan2(tangentComponent, arcChordLength + tangentComponent);
+	const headBase = vecAdd(rear, vecScale(rotate(vecNorm(rearToTip), side * chordOffset), arcChordLength));
+	const arc = createQuarterArc(rear, headBase, side);
+	if (!arc) return { features: [] };
+	const segmentCount = Math.round(Math.min(128, Math.max(4, options.arcSegments ?? DEFAULT_TURN_OPTIONS.arcSegments)));
+	const sampleArc = (from, to) => {
+		const count = Math.max(1, Math.ceil(segmentCount * (to - from)));
+		const points = [];
+		for (let i = 0; i <= count; i++) {
+			const progress = from + (to - from) * i / count;
+			const angle = arc.startAngle + arc.sweepAngle * progress;
+			points.push(unproject(arc.center[0] + arc.radius * Math.cos(angle), arc.center[1] + arc.radius * Math.sin(angle)));
+		}
+		return points;
+	};
+	const gapHalf = clamp01(labelGapRatio) / 2;
+	const arcParts = gapHalf > 0 ? [sampleArc(0, .5 - gapHalf), sampleArc(.5 + gapHalf, 1)] : [sampleArc(0, 1)];
+	const sweepSign = Math.sign(arc.sweepAngle);
+	const midAngle = arc.startAngle + arc.sweepAngle / 2;
+	const labelAnchor = {
+		point: arc.midpoint,
+		tangent: [-Math.sin(midAngle) * sweepSign, Math.cos(midAngle) * sweepSign]
+	};
+	const headWidth = totalLength * (options.arrowheadWidthRatio ?? DEFAULT_TURN_OPTIONS.arrowheadWidthRatio);
+	const arrowHead = createArrowHeadRing(tip, vecNorm(vecSub(tip, headBase)), vecMag(vecSub(tip, headBase)), headWidth);
+	return {
+		features: [{
+			type: "Feature",
+			properties: { part: "arc" },
+			geometry: {
+				type: "MultiLineString",
+				coordinates: arcParts
+			}
+		}, {
+			type: "Feature",
+			properties: {
+				part: "arrowhead",
+				fill: true,
+				style: SOLID_ACCENT_FILL
+			},
+			geometry: {
+				type: "MultiPolygon",
+				coordinates: [[[...arrowHead]]]
+			}
+		}],
+		labelAnchor
+	};
+}
+/**
+* Generates a quarter-circle shaft from PT2 (rear) to the arrowhead base.
+* The arrowhead continues tangent to the arc and places its tip at PT1.
+* PT3 selects which side of the PT2 -> PT1 chord contains the arc.
+*/
+function createTurn(coordinates, options = {}) {
+	return {
+		type: "FeatureCollection",
+		features: createTurnLikeSymbol(coordinates, options).features
+	};
+}
+function rotate(vector, angle) {
+	const cos = Math.cos(angle);
+	const sin = Math.sin(angle);
+	return [vector[0] * cos - vector[1] * sin, vector[0] * sin + vector[1] * cos];
+}
+const TURN = defineControlMeasure({
+	metadata: TURN_METADATA,
+	generator: createTurn,
+	defaultOptions: DEFAULT_TURN_OPTIONS,
+	rule: turnDrawRule
+});
+//#endregion
+//#region src/generators/cm34-mission-tasks/turn.ts
+const DEFAULT_TURN_MISSION_TASK_OPTIONS = {
+	...DEFAULT_TURN_OPTIONS,
+	arrowheadLengthRatio: .14,
+	arrowheadWidthRatio: .14,
+	labelGapRatio: .18
+};
+const TURN_MISSION_TASK_METADATA = {
+	id: "turn-mission-task",
+	name: "Turn",
+	description: "Causes an enemy force to move from one avenue of approach to another or into an engagement area.",
+	entity: "Mission Tasks",
+	entityType: "Turn",
+	value: "344700",
+	minCoordinates: 2,
+	geometry: "line",
+	geometryTypes: [
+		"MultiLineString",
+		"MultiPolygon",
+		"Point"
+	],
+	paints: {
+		stroke: true,
+		fill: "fixed",
+		text: true
+	},
+	drawRule: "Line10",
+	capturesLabelSize: true,
+	params: [...TURN_PARAMS, {
+		key: "labelGapRatio",
+		presentationTier: "advanced",
+		label: "Label gap",
+		description: "Size of the arc gap holding the doctrinal 'T' label",
+		type: "number",
+		min: 0,
+		max: 1,
+		step: .01
+	}]
+};
+/** Generates the TURN mission task symbol (344700). */
+function createTurnMissionTaskSymbol(coordinates, options = {}) {
+	const { features, labelAnchor } = createTurnLikeSymbol(coordinates, {
+		arrowheadLengthRatio: options.arrowheadLengthRatio ?? DEFAULT_TURN_MISSION_TASK_OPTIONS.arrowheadLengthRatio,
+		arrowheadWidthRatio: options.arrowheadWidthRatio ?? DEFAULT_TURN_MISSION_TASK_OPTIONS.arrowheadWidthRatio,
+		arcSegments: options.arcSegments ?? DEFAULT_TURN_MISSION_TASK_OPTIONS.arcSegments
+	}, options.labelGapRatio ?? DEFAULT_TURN_MISSION_TASK_OPTIONS.labelGapRatio);
+	if (!labelAnchor) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const label = createLabelFeature(labelAnchor.point, "T", labelRotationAlong(labelAnchor.tangent), options);
+	return {
+		type: "FeatureCollection",
+		features: [...features, label]
+	};
+}
+const TURN_MISSION_TASK = defineControlMeasure({
+	metadata: TURN_MISSION_TASK_METADATA,
+	generator: createTurnMissionTaskSymbol,
+	defaultOptions: DEFAULT_TURN_MISSION_TASK_OPTIONS,
+	rule: turnDrawRule
+});
+//#endregion
 //#region src/generators/cm15-maneuver-areas/jointTacticalActionArea.ts
 /** Default options for the Joint tactical action area control measure. */
 const DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS = {
@@ -14898,7 +15587,8 @@ const DEFAULT_MAIN_ATTACK_OPTIONS = {
 	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
 	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
 	smooth: false,
-	smoothResolution: 5
+	smoothResolution: 5,
+	...DEFAULT_MANEUVER_ARROW_TASK_AMPLIFIER_OPTIONS
 };
 const MAIN_ATTACK_METADATA = {
 	id: "main-attack",
@@ -14910,14 +15600,16 @@ const MAIN_ATTACK_METADATA = {
 	value: "151403",
 	minCoordinates: 3,
 	geometry: "line",
-	geometryTypes: ["MultiLineString"],
+	geometryTypes: ["MultiLineString", "Point"],
 	paints: {
 		stroke: true,
 		fill: "none",
-		text: false
+		text: true
 	},
 	drawRule: "Axis1",
-	params: ATTACK_SHAFT_PARAMS
+	capturesLabelSize: true,
+	params: [...ATTACK_SHAFT_PARAMS, ...MANEUVER_ARROW_TASK_AMPLIFIER_PARAMS],
+	textAmplifiers: MANEUVER_ARROW_TASK_TEXT_AMPLIFIERS
 };
 /**
 * Generates a GeoJSON FeatureCollection for a Main Attack tactical symbol.
@@ -14937,7 +15629,7 @@ const MAIN_ATTACK_METADATA = {
 * @param options - Configuration for ratios and properties.
 * @returns A GeoJSON FeatureCollection containing a single MultiLineString.
 */
-function createMainAttack(coordinates, options = {}) {
+function createMainAttack(coordinates, options = {}, textAmplifiers = {}) {
 	const { geometry } = processAttackGeometry(coordinates, options);
 	if (!geometry) return {
 		type: "FeatureCollection",
@@ -14956,7 +15648,7 @@ function createMainAttack(coordinates, options = {}) {
 					geometry.headRing.map((p) => unproject(p[0], p[1]))
 				]
 			}
-		}]
+		}, ...createManeuverArrowTaskAmplifierLabels(geometry, options, textAmplifiers)]
 	};
 }
 const MAIN_ATTACK = defineControlMeasure({
@@ -14964,7 +15656,21 @@ const MAIN_ATTACK = defineControlMeasure({
 	generator: createMainAttack,
 	defaultOptions: DEFAULT_MAIN_ATTACK_OPTIONS,
 	rule: axis1DrawRule,
-	optionHandles: variableWidthAttackOptionHandles
+	optionHandles: variableWidthAttackOptionHandles,
+	previewSample: {
+		controlPoints: [
+			[1, 0],
+			[-.4, -.35],
+			[-1, -.8],
+			[.45, .55]
+		],
+		textAmplifiers: {
+			T: "DAVID",
+			W: "080400Z",
+			W1: "120300Z"
+		},
+		options: { labelSize: 80 }
+	}
 });
 //#endregion
 //#region src/generators/cm27-protection-areas/mine-types.ts
@@ -16303,6 +17009,113 @@ const SECONDARY_DIRECTION_OF_FIRE = defineControlMeasure({
 	] }
 });
 //#endregion
+//#region src/generators/cm15-maneuver-areas/searchArea.ts
+const SEARCH_AREA_METADATA = {
+	id: "search-area",
+	name: "Search Area",
+	description: "Designates an area to examine systematically for specified persons, forces, materiel, or information.",
+	entity: "Maneuver Areas",
+	entityType: "Search Area",
+	value: "152200",
+	minCoordinates: 3,
+	maxCoordinates: 3,
+	geometry: "area",
+	geometryTypes: ["MultiLineString", "MultiPolygon"],
+	paints: {
+		stroke: true,
+		fill: "fixed",
+		text: false
+	},
+	drawRule: "Area21",
+	params: TACTICAL_ARROW_PARAMS
+};
+/**
+* Generates a GeoJSON FeatureCollection of a tactical "lightning" arrow.
+* Handles internal projection to maintain correct perpendicularity.
+*
+* @param coordinates - [Apex Point (PT1), Top Tail (PT2), Bottom Tail (PT3)]
+* @param options - Geometric configuration parameters
+* @returns A FeatureCollection containing a MultiLineString for bolts and a MultiPolygon for heads
+*/
+function createSearchArea(coordinates, options = {}) {
+	const { arrowheadLengthRatio: safeArrowheadLengthRatio, arrowheadWidthRatio: safeArrowheadWidthRatio, zigzagStart: safeZigzagStart, zigzagEnd: safeZigzagEnd, zigzagAmplitudeRatio: safeZigzagAmplitudeRatio } = resolveTacticalArrowOptions(options);
+	const [c0, c1, c2] = coordinates;
+	const [p1, p2, p3] = [
+		project(c0[0], c0[1]),
+		project(c1[0], c1[1]),
+		project(c2[0], c2[1])
+	];
+	const shaftSegments = [];
+	const headPolygons = [];
+	const addLeg = (origin, tip, opposite) => {
+		const v = vecSub(tip, origin);
+		const totalLen = vecMag(v);
+		if (totalLen < 1e-6) return;
+		const u = vecNorm(v);
+		let n = [-u[1], u[0]];
+		const toOpp = vecSub(opposite, origin);
+		if (vecDot(n, toOpp) > 0) n = vecScale(n, -1);
+		const offset = totalLen * safeZigzagAmplitudeRatio;
+		const ptA = vecAdd(vecAdd(origin, vecScale(v, safeZigzagStart)), vecScale(n, offset));
+		const ptB = vecAdd(vecAdd(origin, vecScale(v, safeZigzagEnd)), vecScale(n, -offset));
+		const fv = vecSub(tip, ptB);
+		const fLen = vecMag(fv);
+		let fu = vecNorm(fv);
+		if (fLen < 1e-6) fu = u;
+		const headLen = totalLen * safeArrowheadLengthRatio;
+		const pBase = vecSub(tip, vecScale(fu, headLen));
+		const wingWidth = headLen * safeArrowheadWidthRatio;
+		const perp = [-fu[1], fu[0]];
+		const pWing1 = vecAdd(pBase, vecScale(perp, wingWidth));
+		const pWing2 = vecSub(pBase, vecScale(perp, wingWidth));
+		shaftSegments.push([
+			origin,
+			ptA,
+			ptB,
+			pBase
+		].map((p) => unproject(p[0], p[1])));
+		headPolygons.push([[
+			tip,
+			pWing1,
+			pWing2,
+			tip
+		].map((p) => unproject(p[0], p[1]))]);
+	};
+	addLeg(p1, p2, p3);
+	addLeg(p1, p3, p2);
+	const features = [];
+	if (shaftSegments.length > 0) features.push({
+		type: "Feature",
+		properties: { part: "shaft" },
+		geometry: {
+			type: "MultiLineString",
+			coordinates: shaftSegments
+		}
+	});
+	if (headPolygons.length > 0) features.push({
+		type: "Feature",
+		properties: {
+			part: "head",
+			fill: true,
+			style: SOLID_ACCENT_FILL
+		},
+		geometry: {
+			type: "MultiPolygon",
+			coordinates: headPolygons
+		}
+	});
+	return {
+		type: "FeatureCollection",
+		features
+	};
+}
+const SEARCH_AREA = defineControlMeasure({
+	metadata: SEARCH_AREA_METADATA,
+	generator: (controlPoints, options) => createSearchArea(asThreePoints(controlPoints), options),
+	defaultOptions: DEFAULT_TACTICAL_ARROW_OPTIONS,
+	rule: searchAreaDrawRule
+});
+//#endregion
 //#region src/generators/cm15-maneuver-areas/strongPoint.ts
 const DEFAULT_SMOOTH_RESOLUTION = 16;
 /** Default options for the Strong Point control measure. */
@@ -16893,130 +17706,6 @@ const SUPPORT_BY_FIRE = defineControlMeasure({
 	rule: supportByFireDrawRule
 });
 //#endregion
-//#region src/generators/cm27-protection-areas/turn.ts
-const DEFAULT_TURN_OPTIONS = {
-	arrowheadLengthRatio: .16,
-	arrowheadWidthRatio: .16,
-	arcSegments: 64
-};
-const TURN_METADATA = {
-	id: "turn",
-	name: "Turn",
-	description: "Diverts an enemy formation from one avenue of approach to another or into an engagement area. The arrow indicates the desired direction of turn.",
-	entity: "Protection Areas",
-	entityType: "Obstacle Effects",
-	entitySubtype: "Turn",
-	value: "270504",
-	minCoordinates: 2,
-	geometry: "line",
-	geometryTypes: ["MultiLineString", "MultiPolygon"],
-	paints: {
-		stroke: true,
-		fill: "fixed",
-		text: false
-	},
-	drawRule: "Line10",
-	params: [
-		{
-			key: "arrowheadLengthRatio",
-			presentationTier: "advanced",
-			label: "Arrowhead length",
-			description: "Arrowhead length as a ratio of the rear-to-tip distance",
-			type: "number",
-			min: .01,
-			max: .5,
-			step: .01
-		},
-		{
-			key: "arrowheadWidthRatio",
-			presentationTier: "advanced",
-			label: "Arrowhead width",
-			description: "Arrowhead base width as a ratio of the rear-to-tip distance",
-			type: "number",
-			min: .01,
-			max: .5,
-			step: .01
-		},
-		{
-			key: "arcSegments",
-			presentationTier: "advanced",
-			label: "Arc segments",
-			description: "Number of line segments approximating the quarter-circle shaft.",
-			type: "number",
-			min: 4,
-			max: 128,
-			step: 1
-		}
-	]
-};
-/**
-* Generates a quarter-circle shaft from PT2 (rear) to the arrowhead base.
-* The arrowhead continues tangent to the arc and places its tip at PT1.
-* PT3 selects which side of the PT2 -> PT1 chord contains the arc.
-*/
-function createTurn(coordinates, options = {}) {
-	const tip = project(coordinates[0][0], coordinates[0][1]);
-	const rear = project(coordinates[1][0], coordinates[1][1]);
-	const side = quarterArcSide(rear, tip, coordinates[2] ? project(coordinates[2][0], coordinates[2][1]) : void 0);
-	const rearToTip = vecSub(tip, rear);
-	const totalLength = vecMag(rearToTip);
-	if (totalLength < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const requestedHeadLength = totalLength * (options.arrowheadLengthRatio ?? DEFAULT_TURN_OPTIONS.arrowheadLengthRatio);
-	const tangentComponent = Math.min(Math.max(requestedHeadLength, EPSILON), totalLength * .95) / Math.SQRT2;
-	const arcChordLength = Math.sqrt(totalLength * totalLength - tangentComponent * tangentComponent) - tangentComponent;
-	const chordOffset = Math.atan2(tangentComponent, arcChordLength + tangentComponent);
-	const headBase = vecAdd(rear, vecScale(rotate(vecNorm(rearToTip), side * chordOffset), arcChordLength));
-	const arc = createQuarterArc(rear, headBase, side);
-	if (!arc) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const segmentCount = Math.round(Math.min(128, Math.max(4, options.arcSegments ?? DEFAULT_TURN_OPTIONS.arcSegments)));
-	const arcCoordinates = [];
-	for (let i = 0; i <= segmentCount; i++) {
-		const angle = arc.startAngle + arc.sweepAngle * i / segmentCount;
-		arcCoordinates.push(unproject(arc.center[0] + arc.radius * Math.cos(angle), arc.center[1] + arc.radius * Math.sin(angle)));
-	}
-	const headWidth = totalLength * (options.arrowheadWidthRatio ?? DEFAULT_TURN_OPTIONS.arrowheadWidthRatio);
-	const arrowHead = createArrowHeadRing(tip, vecNorm(vecSub(tip, headBase)), vecMag(vecSub(tip, headBase)), headWidth);
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: { part: "arc" },
-			geometry: {
-				type: "MultiLineString",
-				coordinates: [arcCoordinates]
-			}
-		}, {
-			type: "Feature",
-			properties: {
-				part: "arrowhead",
-				fill: true,
-				style: SOLID_ACCENT_FILL
-			},
-			geometry: {
-				type: "MultiPolygon",
-				coordinates: [[[...arrowHead]]]
-			}
-		}]
-	};
-}
-function rotate(vector, angle) {
-	const cos = Math.cos(angle);
-	const sin = Math.sin(angle);
-	return [vector[0] * cos - vector[1] * sin, vector[0] * sin + vector[1] * cos];
-}
-const TURN = defineControlMeasure({
-	metadata: TURN_METADATA,
-	generator: createTurn,
-	defaultOptions: DEFAULT_TURN_OPTIONS,
-	rule: turnDrawRule
-});
-//#endregion
 //#region src/generators/cm15-maneuver-areas/turning-movement.ts
 const DEFAULT_CROSSBAR_POSITION = 0;
 const DEFAULT_TURNING_MOVEMENT_OPTIONS = {
@@ -17163,16 +17852,22 @@ const DEFINITIONS = {
 	disengage: DISENGAGE,
 	"disrupt-mission-task": DISRUPT_MISSION_TASK,
 	envelopment: ENVELOPMENT,
+	"forward-passage-of-lines": FORWARD_PASSAGE_OF_LINES,
 	infiltration: INFILTRATION,
 	guard: GUARD,
 	isolate: ISOLATE,
+	"movement-to-contact": MOVEMENT_TO_CONTACT,
+	occupy: OCCUPY,
 	penetrate: PENETRATE,
+	pursuit: PURSUIT,
 	"rearward-passage-of-lines": REARWARD_PASSAGE_OF_LINES,
 	retire: RETIRE,
 	screen: SCREEN,
 	seize: SEIZE,
+	evacuate: EVACUATE,
 	withdraw: WITHDRAW,
 	"withdraw-under-pressure": WITHDRAW_UNDER_PRESSURE,
+	"turn-mission-task": TURN_MISSION_TASK,
 	"antitank-ditch-under-construction": ANTITANK_DITCH_UNDER_CONSTRUCTION,
 	"antitank-ditch-completed": ANTITANK_DITCH_COMPLETED,
 	"antitank-wall": ANTITANK_WALL,
@@ -17597,4 +18292,4 @@ function assertNever(value) {
 	throw new Error(`Unhandled control measure kind: ${String(value)}`);
 }
 //#endregion
-export { DEFAULT_ENCIRCLEMENT_OPTIONS as $, DEFAULT_PORTRAYAL as $t, DEFAULT_RETIRE_OPTIONS as A, pointOnMidpointPerpendicularAxis as An, DEFAULT_BLOCK_OPTIONS as At, DEFAULT_LIMIT_OF_ADVANCE_OPTIONS as B, getMetersPerPixel as Bn, DEFAULT_ENGAGEMENT_AREA_OPTIONS as Bt, DEFAULT_MAIN_ATTACK_OPTIONS as C, blockDrawRule as Cn, DEFAULT_BREACH_OPTIONS as Ct, DEFAULT_WITHDRAW_OPTIONS as D, computeDefaultMidpointPerpendicularPoint as Dn, DEFAULT_LIGHT_LINE_OPTIONS as Dt, DEFAULT_WITHDRAW_UNDER_PRESSURE_OPTIONS as E, area27DrawRule as En, DEFAULT_ENGINEER_WORK_LINE_OPTIONS as Et, DEFAULT_FORTIFIED_LINE_OPTIONS as F, haversineDistance as Fn, DEFAULT_ANTITANK_WALL_OPTIONS as Ft, DEFAULT_HOLDING_LINE_OPTIONS as G, TEXT_AMPLIFIER_FIELDS as Gt, DEFAULT_HANDOVER_LINE_OPTIONS as H, DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS as Ht, DEFAULT_PROBABLE_LINE_OF_DEPLOYMENT_OPTIONS as I, project as In, DEFAULT_ANTITANK_DITCH_OPTIONS as It, DEFAULT_PHASE_LINE_OPTIONS as J, resolveAmplifierPlacement as Jt, DEFAULT_INFILTRATION_LANE_OPTIONS as K, canonicalTextAmplifierKey as Kt, PROBABLE_LINE_OF_DEPLOYMENT_DASH as L, sphericalBearing as Ln, DEFAULT_ASSEMBLY_AREA_OPTIONS as Lt, DEFAULT_PENETRATE_OPTIONS as M, createBaselineFrame as Mn, DEFAULT_BATTLE_POSITION_OPTIONS as Mt, DEFAULT_FRONTAL_ATTACK_OPTIONS as N, calculateMetrics as Nn, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Nt, DEFAULT_SEIZE_OPTIONS as O, createMidpointPerpendicularDrawRule as On, DEFAULT_BOUNDARY_OPTIONS as Ot, DEFAULT_FORTIFIED_AREA_OPTIONS as P, computeInitialWidthPoint as Pn, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Pt, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as Q, DEFAULT_LINE_JOIN as Qt, DEFAULT_LINE_OF_DEPARTURE_CONTACT_OPTIONS as R, unproject as Rn, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as Rt, DEFAULT_MINEFIELD_OPTIONS as S, disruptDrawRule as Sn, DEFAULT_BYPASS_OPTIONS as St, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as T, containDrawRule as Tn, DEFAULT_GENERIC_C2_LINE_OPTIONS as Tt, DEFAULT_FORWARD_EDGE_OF_BATTLE_AREA_OPTIONS as U, DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS as Ut, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as V, roundToFixed as Vn, DEFAULT_AREA_DEFENSE_OPTIONS as Vt, DEFAULT_RELEASE_LINE_OPTIONS as W, DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS as Wt, DEFAULT_FIX_MISSION_TASK_OPTIONS as X, DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS as Xt, DEFAULT_FLOT_OPTIONS as Y, DEFAULT_LABEL_HEIGHT_CSS_PIXELS as Yt, DEFAULT_FIX_OPTIONS as Z, DEFAULT_LINE_CAP as Zt, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as _, dynamicPointDrawRule as _n, DEFAULT_GENERIC_POLYGON_OPTIONS as _t, DEFINITIONS as a, rectangleDrawRule as an, DEFAULT_COVER_OPTIONS as at, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as b, point12DrawRule as bn, DEFAULT_CLASSIC_ARROW_OPTIONS as bt, getDefaultOptions as c, polyline1DrawRule as cn, DEFAULT_COUNTERATTACK_OPTIONS as ct, DEFAULT_TURN_OPTIONS as d, line24DrawRule as dn, DEFAULT_RADAR_SEARCH_DOCTRINE_OPTIONS as dt, DEFAULT_STROKE_DASH_CSS_PIXELS as en, DEFAULT_DISRUPT_OPTIONS as et, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as f, line23DrawRule as fn, RADAR_SEARCH_DOCTRINE_FILL_COLOR as ft, SECONDARY_DIRECTION_OF_FIRE_DASH as g, attackByFireDrawRule as gn, DEFAULT_GENERIC_RECTANGLE_OPTIONS as gt, DEFAULT_SECONDARY_DIRECTION_OF_FIRE_OPTIONS as h, ambushDrawRule as hn, DEFAULT_GENERIC_SECTOR_OPTIONS as ht, CONTROL_MEASURE_METADATA as i, DEFAULT_AIRBORNE_ATTACK_OPTIONS as in, DEFAULT_DELAY_OPTIONS as it, DEFAULT_REARWARD_PASSAGE_OF_LINES_OPTIONS as j, snapToMidpointPerpendicular as jn, DEFAULT_CONTAIN_OPTIONS as jt, DEFAULT_SCREEN_OPTIONS as k, getMidpointPerpendicularSignedDistance as kn, DEFAULT_BLOCK_ARROW_OPTIONS as kt, listControlMeasureMetadata as l, line27DrawRule as ln, DEFAULT_SUPPORTING_ATTACK_OPTIONS as lt, DEFAULT_STRONG_POINT_OPTIONS as m, line1DrawRule as mn, DEFAULT_GENERIC_TEXT_OPTIONS as mt, resolveStyleHints as n, DEFAULT_SYMBOL_COLOR as nn, DEFAULT_DISRUPT_MISSION_TASK_OPTIONS as nt, getControlMeasureMetadata as o, axis1DrawRule as on, DEFAULT_TACTICAL_ARROW_OPTIONS as ot, DEFAULT_RETAIN_OPTIONS as p, turnDrawRule as pn, RADAR_SEARCH_DOCTRINE_STROKE_COLOR as pt, DEFAULT_BRIDGEHEAD_LINE_OPTIONS as q, normalizeTextAmplifiers as qt, CONTROL_MEASURE_IDS as r, DEFAULT_AMBUSH_OPTIONS as rn, DEFAULT_DISENGAGE_OPTIONS as rt, getControlMeasureMetadataByValue as s, supportByFireDrawRule as sn, DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS as st, renderControlMeasure as t, DEFAULT_STROKE_WIDTH_CSS_PIXELS as tn, DEFAULT_GUARD_OPTIONS as tt, DEFAULT_TURNING_MOVEMENT_OPTIONS as u, line26DrawRule as un, DEFAULT_CLEAR_OPTIONS as ut, DEFAULT_PICKUP_ZONE_OPTIONS as v, sectorDrawRule as vn, DEFAULT_GENERIC_LINE_OPTIONS as vt, DEFAULT_LANDING_ZONE_OPTIONS as w, centerRadiusDrawRule as wn, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as wt, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as x, penetrateDrawRule as xn, DEFAULT_CANALIZE_OPTIONS as xt, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as y, staticPointDrawRule as yn, DEFAULT_GENERIC_CIRCLE_OPTIONS as yt, DEFAULT_LINE_OF_DEPARTURE_OPTIONS as z, EPSILON as zn, DEFAULT_MOBILE_DEFENSE_OPTIONS as zt };
+export { DEFAULT_FIX_MISSION_TASK_OPTIONS as $, DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS as $t, DEFAULT_SCREEN_OPTIONS as A, area27DrawRule as An, DEFAULT_LIGHT_LINE_OPTIONS as At, PROBABLE_LINE_OF_DEPLOYMENT_DASH as B, project as Bn, DEFAULT_ASSEMBLY_AREA_OPTIONS as Bt, DEFAULT_LANDING_ZONE_OPTIONS as C, point12DrawRule as Cn, DEFAULT_CLASSIC_ARROW_OPTIONS as Ct, DEFAULT_WITHDRAW_OPTIONS as D, blockDrawRule as Dn, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as Dt, DEFAULT_WITHDRAW_UNDER_PRESSURE_OPTIONS as E, disruptDrawRule as En, DEFAULT_BREACH_OPTIONS as Et, DEFAULT_MOVEMENT_TO_CONTACT_OPTIONS as F, snapToMidpointPerpendicular as Fn, DEFAULT_BATTLE_POSITION_OPTIONS as Ft, DEFAULT_HANDOVER_LINE_OPTIONS as G, roundToFixed as Gn, DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS as Gt, DEFAULT_LINE_OF_DEPARTURE_OPTIONS as H, unproject as Hn, DEFAULT_MOBILE_DEFENSE_OPTIONS as Ht, DEFAULT_FRONTAL_ATTACK_OPTIONS as I, createBaselineFrame as In, DEFAULT_ATTACK_HELICOPTER_OPTIONS as It, DEFAULT_HOLDING_LINE_OPTIONS as J, TEXT_AMPLIFIER_FIELDS as Jt, DEFAULT_FORWARD_EDGE_OF_BATTLE_AREA_OPTIONS as K, DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS as Kt, DEFAULT_FORTIFIED_AREA_OPTIONS as L, calculateMetrics as Ln, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Lt, DEFAULT_REARWARD_PASSAGE_OF_LINES_OPTIONS as M, createMidpointPerpendicularDrawRule as Mn, DEFAULT_BLOCK_ARROW_OPTIONS as Mt, DEFAULT_PENETRATE_OPTIONS as N, getMidpointPerpendicularSignedDistance as Nn, DEFAULT_BLOCK_OPTIONS as Nt, DEFAULT_EVACUATE_OPTIONS as O, centerRadiusDrawRule as On, DEFAULT_GENERIC_C2_LINE_OPTIONS as Ot, DEFAULT_OCCUPY_OPTIONS as P, pointOnMidpointPerpendicularAxis as Pn, DEFAULT_CONTAIN_OPTIONS as Pt, DEFAULT_FLOT_OPTIONS as Q, DEFAULT_LABEL_HEIGHT_CSS_PIXELS as Qt, DEFAULT_FORTIFIED_LINE_OPTIONS as R, computeInitialWidthPoint as Rn, DEFAULT_ANTITANK_WALL_OPTIONS as Rt, DEFAULT_MAIN_ATTACK_OPTIONS as S, staticPointDrawRule as Sn, DEFAULT_GENERIC_CIRCLE_OPTIONS as St, DEFAULT_TURN_OPTIONS as T, occupyDrawRule as Tn, DEFAULT_BYPASS_OPTIONS as Tt, DEFAULT_LIMIT_OF_ADVANCE_OPTIONS as U, EPSILON as Un, DEFAULT_ENGAGEMENT_AREA_OPTIONS as Ut, DEFAULT_LINE_OF_DEPARTURE_CONTACT_OPTIONS as V, sphericalBearing as Vn, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as Vt, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as W, getMetersPerPixel as Wn, DEFAULT_AREA_DEFENSE_OPTIONS as Wt, DEFAULT_BRIDGEHEAD_LINE_OPTIONS as X, normalizeTextAmplifiers as Xt, DEFAULT_INFILTRATION_LANE_OPTIONS as Y, canonicalTextAmplifierKey as Yt, DEFAULT_PHASE_LINE_OPTIONS as Z, resolveAmplifierPlacement as Zt, DEFAULT_PICKUP_ZONE_OPTIONS as _, line1DrawRule as _n, DEFAULT_GENERIC_TEXT_OPTIONS as _t, DEFINITIONS as a, DEFAULT_SYMBOL_COLOR as an, DEFAULT_DISRUPT_MISSION_TASK_OPTIONS as at, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as b, dynamicPointDrawRule as bn, DEFAULT_GENERIC_POLYGON_OPTIONS as bt, getDefaultOptions as c, rectangleDrawRule as cn, DEFAULT_COVER_OPTIONS as ct, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as d, polyline1DrawRule as dn, DEFAULT_COUNTERATTACK_OPTIONS as dt, DEFAULT_LINE_CAP as en, DEFAULT_FIX_OPTIONS as et, DEFAULT_RETAIN_OPTIONS as f, line27DrawRule as fn, DEFAULT_SUPPORTING_ATTACK_OPTIONS as ft, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as g, turnDrawRule as gn, RADAR_SEARCH_DOCTRINE_STROKE_COLOR as gt, SECONDARY_DIRECTION_OF_FIRE_DASH as h, line23DrawRule as hn, RADAR_SEARCH_DOCTRINE_FILL_COLOR as ht, CONTROL_MEASURE_METADATA as i, DEFAULT_STROKE_WIDTH_CSS_PIXELS as in, DEFAULT_GUARD_OPTIONS as it, DEFAULT_RETIRE_OPTIONS as j, computeDefaultMidpointPerpendicularPoint as jn, DEFAULT_BOUNDARY_OPTIONS as jt, DEFAULT_SEIZE_OPTIONS as k, containDrawRule as kn, DEFAULT_ENGINEER_WORK_LINE_OPTIONS as kt, listControlMeasureMetadata as l, axis1DrawRule as ln, DEFAULT_TACTICAL_ARROW_OPTIONS as lt, DEFAULT_SECONDARY_DIRECTION_OF_FIRE_OPTIONS as m, line24DrawRule as mn, DEFAULT_RADAR_SEARCH_DOCTRINE_OPTIONS as mt, resolveStyleHints as n, DEFAULT_PORTRAYAL as nn, DEFAULT_ENCIRCLEMENT_OPTIONS as nt, getControlMeasureMetadata as o, DEFAULT_AMBUSH_OPTIONS as on, DEFAULT_DISENGAGE_OPTIONS as ot, DEFAULT_STRONG_POINT_OPTIONS as p, line26DrawRule as pn, DEFAULT_CLEAR_OPTIONS as pt, DEFAULT_RELEASE_LINE_OPTIONS as q, DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS as qt, CONTROL_MEASURE_IDS as r, DEFAULT_STROKE_DASH_CSS_PIXELS as rn, DEFAULT_DISRUPT_OPTIONS as rt, getControlMeasureMetadataByValue as s, DEFAULT_AIRBORNE_ATTACK_OPTIONS as sn, DEFAULT_DELAY_OPTIONS as st, renderControlMeasure as t, DEFAULT_LINE_JOIN as tn, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as tt, DEFAULT_TURNING_MOVEMENT_OPTIONS as u, supportByFireDrawRule as un, DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS as ut, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as v, ambushDrawRule as vn, DEFAULT_GENERIC_SECTOR_OPTIONS as vt, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as w, penetrateDrawRule as wn, DEFAULT_CANALIZE_OPTIONS as wt, DEFAULT_MINEFIELD_OPTIONS as x, sectorDrawRule as xn, DEFAULT_GENERIC_LINE_OPTIONS as xt, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as y, attackByFireDrawRule as yn, DEFAULT_GENERIC_RECTANGLE_OPTIONS as yt, DEFAULT_PROBABLE_LINE_OF_DEPLOYMENT_OPTIONS as z, haversineDistance as zn, DEFAULT_ANTITANK_DITCH_OPTIONS as zt };