@orbat-mapper/control-measures 0.10.0 → 0.12.0

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

@@ -130,15 +130,27 @@ const destinationPoint = (origin, distance, bearing) => {
 //#endregion
 //#region src/internal/vector-utils.ts
 /**
-* Offsets a polyline using Miter Joins or Round Joins.
+* Offsets a polyline to both sides at once, using Miter Joins or Round Joins.
+* `offsets` carries one half-width per vertex, so the outline may taper along
+* its centerline; both sides read the same array rather than materialising a
+* negated copy per geometry pass.
 */
-function offsetPolyline(points, offset, rounded = false, segments = 5) {
+function offsetPolylineSides(points, offsets, rounded = false, segments = 5) {
+	return {
+		left: offsetPolylineWithOffsets(points, offsets, rounded, segments, 1),
+		right: offsetPolylineWithOffsets(points, offsets, rounded, segments, -1)
+	};
+}
+/** One side of {@link offsetPolylineSides}; `sign` picks which. */
+function offsetPolylineWithOffsets(points, offsets, rounded, segments, sign) {
 	if (points.length < 2) return points;
+	if (offsets.length !== points.length) return points;
 	const result = [];
 	const N = points.length;
 	for (let i = 0; i < N; i++) {
 		const p = points[i];
 		if (!p) continue;
+		const offset = offsets[i] * sign;
 		if (i === 0) {
 			const next = points[i + 1];
 			if (next) {
@@ -195,6 +207,17 @@ function offsetPolyline(points, offset, rounded = false, segments = 5) {
 	}
 	return result;
 }
+/** Linearly interpolates values by distance along a polyline, not vertex count. */
+function interpolatePolylineValues(points, startValue, endValue) {
+	const distances = [0];
+	for (let i = 1; i < points.length; i++) distances.push(distances[i - 1] + vecMag(vecSub(points[i], points[i - 1])));
+	const totalLength = distances.at(-1) ?? 0;
+	if (totalLength < 1e-6) return points.map(() => endValue);
+	return distances.map((distance) => {
+		const progress = distance / totalLength;
+		return startValue + (endValue - startValue) * progress;
+	});
+}
 function vecAdd(a, b) {
 	return [a[0] + b[0], a[1] + b[1]];
 }
@@ -248,9 +271,81 @@ function lineIntersection(p1, p2, p3, p4) {
 }
 //#endregion
 //#region src/attack-utils.ts
-const DEFAULT_SHAFT_WIDTH_RATIO = .6;
+const DEFAULT_SHAFT_WIDTH_RATIO$1 = .6;
+const DEFAULT_REAR_WIDTH_RATIO = DEFAULT_SHAFT_WIDTH_RATIO$1;
 const SHAFT_MIN_RATIO = .1;
 const SHAFT_MAX_RATIO = .9;
+const REAR_WIDTH_OPTION_HANDLE_ID = "rear-width";
+const SHAFT_WIDTH_OPTION_HANDLE_ID = "shaft-width";
+/**
+* Creates the definition-owned rear-/shaft-width handle pair shared by every
+* variable-width arrow body. Callers supply only how their own geometry maps
+* onto {@link WidthHandleGeometry}; placement (the two ends of the left edge)
+* and the drag math (perpendicular distance from the dragged point to the
+* matching centerline segment, over the reference half-width) live here once.
+*/
+function createWidthOptionHandles(config) {
+	return {
+		get(controlPoints, options) {
+			const geometry = config.geometry(controlPoints, options);
+			const rearLeft = geometry?.leftEdge[0];
+			const neckLeft = geometry?.leftEdge.at(-1);
+			if (!rearLeft || !neckLeft) return [];
+			return [{
+				id: REAR_WIDTH_OPTION_HANDLE_ID,
+				position: unproject(rearLeft[0], rearLeft[1])
+			}, {
+				id: SHAFT_WIDTH_OPTION_HANDLE_ID,
+				position: unproject(neckLeft[0], neckLeft[1])
+			}];
+		},
+		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 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;
+			const ratio = clamp(pointToInfiniteLineDistance(project(position[0], position[1]), from, to) / geometry.referenceHalfWidth, config.minRatio, rear ? config.maxRearRatio : config.maxShaftRatio);
+			return rear ? { rearWidthRatio: ratio } : { shaftWidthRatio: ratio };
+		}
+	};
+}
+/**
+* The width handles for attack bodies built by {@link processAttackGeometry},
+* whose ratios are fractions of the arrowhead half-width. A coordinate resolver
+* lets derivative measures (Counterattack by Fire) map their authored Axis1
+* points to the body coordinates first.
+*/
+function createVariableWidthAttackOptionHandles(resolveCoordinates = (points) => points) {
+	return createWidthOptionHandles({
+		geometry(controlPoints, options) {
+			const coordinates = resolveCoordinates(controlPoints);
+			if (!coordinates) return null;
+			const { geometry } = processAttackGeometry(coordinates, options);
+			const outerLeft = geometry?.headRing[0];
+			if (!geometry || !outerLeft) return null;
+			return {
+				spine: geometry.shaftCenterline,
+				leftEdge: geometry.shaftLeft,
+				referenceHalfWidth: vecMag(vecSub(outerLeft, geometry.ptBase))
+			};
+		},
+		minRatio: SHAFT_MIN_RATIO,
+		maxRearRatio: 3,
+		maxShaftRatio: SHAFT_MAX_RATIO
+	});
+}
+const variableWidthAttackOptionHandles = createVariableWidthAttackOptionHandles();
+/**
+* The single home of the "rear inherits shaft" rule: an omitted `rearWidthRatio`
+* leaves the body parallel by matching the effective shaft ratio. Every
+* variable-width body resolves the option through here so the rule cannot drift.
+*/
+function resolveRearWidthRatio(options, shaftRatio) {
+	return options.rearWidthRatio ?? shaftRatio;
+}
 /**
 * Processes input coordinates and options to generate the core symbol geometry.
 * This handles validation, default values, projection, and geometry calculation.
@@ -259,6 +354,7 @@ function processAttackGeometry(coordinates, options = {}) {
 	const shaftRatio = clamp(options.shaftWidthRatio ?? .6, SHAFT_MIN_RATIO, SHAFT_MAX_RATIO);
 	const smooth = options.smooth ?? false;
 	const smoothResolution = options.smoothResolution ?? 5;
+	const rearRatio = clamp(resolveRearWidthRatio(options, shaftRatio), SHAFT_MIN_RATIO, 3);
 	const points = coordinates.map((c) => project(c[0], c[1]));
 	const numPoints = points.length;
 	const ptTip = points[0];
@@ -268,9 +364,9 @@ function processAttackGeometry(coordinates, options = {}) {
 		const p = points[i];
 		if (p) spinePoints.push(p);
 	}
-	return { geometry: calculateSymbolGeometry(ptTip, ptWidth, spinePoints, shaftRatio, smooth, smoothResolution) };
+	return { geometry: calculateSymbolGeometry(ptTip, ptWidth, spinePoints, shaftRatio, rearRatio, smooth, smoothResolution) };
 }
-function calculateSymbolGeometry(ptTip, ptWidth, spine, shaftRatio, smooth, smoothResolution) {
+function calculateSymbolGeometry(ptTip, ptWidth, spine, shaftRatio, rearWidthRatio, smooth, smoothResolution) {
 	const initialNeck = spine[spine.length - 1];
 	if (!initialNeck) return null;
 	const initialTipDir = vecNorm(vecSub(ptTip, initialNeck));
@@ -323,10 +419,11 @@ function calculateSymbolGeometry(ptTip, ptWidth, spine, shaftRatio, smooth, smoo
 		outerLeft
 	];
 	const fullSpine = [...remainingSpine, shaftEndCenter];
+	const { left: shaftLeft, right: shaftRight } = offsetPolylineSides(fullSpine, interpolatePolylineValues(fullSpine, headHalfWidth * rearWidthRatio, shaftHalfWidth), smooth, smoothResolution);
 	return {
 		shaftCenterline: fullSpine,
-		shaftLeft: offsetPolyline(fullSpine, shaftHalfWidth, smooth, smoothResolution),
-		shaftRight: offsetPolyline(fullSpine, -shaftHalfWidth, smooth, smoothResolution),
+		shaftLeft,
+		shaftRight,
 		headRing,
 		ptTip,
 		ptNeck,
@@ -563,7 +660,7 @@ function samePosition(a, b) {
 }
 //#endregion
 //#region src/draw-rules/area1.ts
-function derive$12(points) {
+function derive$14(points) {
 	return clonePositions(points);
 }
 /**
@@ -583,9 +680,9 @@ const area1DrawRule = {
 	id: "area1",
 	minimumUserPoints: 3,
 	closedRing: true,
-	derive: derive$12,
+	derive: derive$14,
 	transform(event) {
-		return derive$12(event.next);
+		return derive$14(event.next);
 	}
 };
 //#endregion
@@ -625,14 +722,14 @@ const containDrawRule = createMidpointPerpendicularDrawRule({
 * that fixes both the radius and the bearing of the symbol's opening. Both
 * points are user-clicked, so the canonical array is just the (clamped) input.
 */
-function derive$11(points) {
+function derive$13(points) {
 	return clonePositions(points.slice(0, 2));
 }
 const centerRadiusDrawRule = {
 	id: "area15:center-radius",
 	minimumUserPoints: 2,
 	canonicalPointCount: 2,
-	derive: derive$11,
+	derive: derive$13,
 	transform(event) {
 		const { previous, next, activePointIndex } = event;
 		if (activePointIndex === 0 && previous.length >= 2 && next.length >= 2) {
@@ -641,7 +738,7 @@ const centerRadiusDrawRule = {
 			const origin = previous[1];
 			return [clonePosition(next[0]), [origin[0] + dx, origin[1] + dy]];
 		}
-		return derive$11(next);
+		return derive$13(next);
 	}
 };
 /** Backward-compatible doctrinal name for Area15's shared center-radius rule. */
@@ -705,16 +802,16 @@ const point12DrawRule = createMidpointPerpendicularDrawRule({ id: "point12:obsta
 * Point1 — a single anchor point (e.g. Text's center). One user click commits
 * the measure; dragging the point simply translates it.
 */
-function derive$10(points) {
+function derive$12(points) {
 	return clonePositions(points.slice(0, 1));
 }
 const pointDrawRule = {
 	id: "point1:anchor",
 	minimumUserPoints: 1,
 	canonicalPointCount: 1,
-	derive: derive$10,
+	derive: derive$12,
 	transform(event) {
-		return derive$10(event.next);
+		return derive$12(event.next);
 	}
 };
 //#endregion
@@ -741,7 +838,7 @@ const SECTOR_ANGLE_SNAP_RADIANS = Math.PI / 36;
 * independently control a radius and a true-north azimuth. Dragging the anchor
 * translates both edge points so the sector retains its size and orientation.
 */
-function derive$9(points) {
+function derive$11(points) {
 	return clonePositions(points.slice(0, 3));
 }
 function guidePoints$2(points) {
@@ -769,7 +866,7 @@ const sectorDrawRule = {
 	showGuide: true,
 	guidePoints: guidePoints$2,
 	constrainAngles,
-	derive: derive$9,
+	derive: derive$11,
 	transform(event) {
 		const { previous, next, activePointIndex } = event;
 		if (activePointIndex === 0 && previous.length >= 3 && next.length >= 3) {
@@ -781,7 +878,7 @@ const sectorDrawRule = {
 				[previous[2][0] + dx, previous[2][1] + dy]
 			];
 		}
-		return derive$9(next);
+		return derive$11(next);
 	}
 };
 //#endregion
@@ -836,20 +933,20 @@ const ambushDrawRule = createMidpointPerpendicularDrawRule({
 });
 //#endregion
 //#region src/draw-rules/line1.ts
-function derive$8(points) {
+function derive$10(points) {
 	return clonePositions(points);
 }
 const line1DrawRule = {
 	id: "line1",
 	minimumUserPoints: 2,
-	derive: derive$8,
+	derive: derive$10,
 	transform(event) {
-		return derive$8(event.next);
+		return derive$10(event.next);
 	}
 };
 //#endregion
 //#region src/draw-rules/line3.ts
-function derive$7(points) {
+function derive$9(points) {
 	return clonePositions(points);
 }
 /**
@@ -864,23 +961,23 @@ const line3DrawRule = {
 	id: "line3",
 	minimumUserPoints: 3,
 	canonicalPointCount: 3,
-	derive: derive$7,
+	derive: derive$9,
 	transform(event) {
-		return derive$7(event.next);
+		return derive$9(event.next);
 	}
 };
 //#endregion
 //#region src/draw-rules/line9.ts
-function derive$6(points) {
+function derive$8(points) {
 	return clonePositions(points);
 }
 const line9DrawRule = {
 	id: "line9",
 	minimumUserPoints: 2,
 	canonicalPointCount: 2,
-	derive: derive$6,
+	derive: derive$8,
 	transform(event) {
-		return derive$6(event.next);
+		return derive$8(event.next);
 	}
 };
 //#endregion
@@ -1009,7 +1106,7 @@ const line24DrawRule = createMidpointPerpendicularDrawRule({
 });
 //#endregion
 //#region src/draw-rules/line26.ts
-function derive$5(points) {
+function derive$7(points) {
 	if (points.length === 2) {
 		const [p1, p2] = points;
 		const dx = p2[0] - p1[0];
@@ -1048,9 +1145,9 @@ const line26DrawRule = {
 	minimumUserPoints: 4,
 	minimumPreviewPoints: 2,
 	canonicalPointCount: 4,
-	derive: derive$5,
+	derive: derive$7,
 	transform(event) {
-		return derive$5(event.next);
+		return derive$7(event.next);
 	}
 };
 //#endregion
@@ -1063,7 +1160,7 @@ function deriveArcPoint(p1, p2, p4) {
 	if (!arc) return [(p2[0] + p4[0]) / 2, (p2[1] + p4[1]) / 2];
 	return unproject(arc.midpoint[0], arc.midpoint[1]);
 }
-function derive$4(points) {
+function derive$6(points) {
 	if (points.length < 2) return clonePositions(points);
 	const [p1, p2] = points;
 	if (points.length === 2) {
@@ -1102,7 +1199,7 @@ const line27DrawRule = {
 	minimumUserPoints: 3,
 	minimumPreviewPoints: 2,
 	canonicalPointCount: 4,
-	derive: derive$4,
+	derive: derive$6,
 	transform(event) {
 		const { previous, next, activePointIndex } = event;
 		if (activePointIndex === 0 && previous.length >= 4 && next.length >= 4) {
@@ -1134,6 +1231,124 @@ const line27DrawRule = {
 	}
 };
 //#endregion
+//#region src/draw-rules/line31.ts
+function derive$5(points) {
+	if (points.length === 2) {
+		const [c1, c3] = points;
+		const start = project(c1[0], c1[1]);
+		const span = vecSub(project(c3[0], c3[1]), start);
+		const p2 = vecAdd(start, vecScale(span, .5));
+		const p4 = vecAdd(vecAdd(start, vecScale(span, .75)), vecScale([-span[1], span[0]], .25));
+		return clonePositions([
+			c1,
+			unproject(p2[0], p2[1]),
+			c3,
+			unproject(p4[0], p4[1])
+		]);
+	}
+	const derived = clonePositions(points.slice(0, 4));
+	if (derived.length < 3) return derived;
+	const [c1, c2, c3] = derived;
+	const p1 = project(c1[0], c1[1]);
+	const p2 = project(c2[0], c2[1]);
+	const straight = vecSub(p2, p1);
+	if (vecMag(straight) === 0) return derived;
+	const diameter = vecMag(vecSub(project(c3[0], c3[1]), p2));
+	const anchor = vecAdd(p2, vecScale(vecNorm(straight), diameter));
+	derived[2] = unproject(anchor[0], anchor[1]);
+	return derived;
+}
+/**
+* The snapped PT. 4 for a semicircle spanning PT. 2 → PT. 3, in projected
+* meters. PT. 4 is the top of the selected semicircle, not a free point on its
+* circumference, so crossing the diameter flips which side holds the arc.
+* Returns `null` for a degenerate (zero-length) diameter.
+*/
+function orientationPoint(p2, p3, p4) {
+	const diameter = vecSub(p3, p2);
+	if (diameter[0] === 0 && diameter[1] === 0) return null;
+	const apex = vecAdd(midpoint(p2, p3), vecScale([-diameter[1], diameter[0]], quarterArcSide(p2, p3, p4) / 2));
+	return unproject(apex[0], apex[1]);
+}
+function snapOrientationToArc(points) {
+	if (points.length < 4) return points;
+	const snapped = orientationPoint(project(points[1][0], points[1][1]), project(points[2][0], points[2][1]), project(points[3][0], points[3][1]));
+	if (snapped) points[3] = snapped;
+	return points;
+}
+/** Line31 anchors for Envelopment; PT. 3 is constrained parallel to PT. 1 → PT. 2. */
+const line31DrawRule = {
+	id: "line31:envelopment",
+	minimumUserPoints: 2,
+	minimumPreviewPoints: 2,
+	canonicalPointCount: 4,
+	derive: derive$5,
+	transform(event) {
+		const { activePointIndex, next, previous } = event;
+		if (next.length < 4) return derive$5(next);
+		if (activePointIndex === 1) {
+			const points = clonePositions(next.slice(0, 4));
+			const p1 = project(points[0][0], points[0][1]);
+			const p2 = project(points[1][0], points[1][1]);
+			const p3 = project(points[2][0], points[2][1]);
+			const p4 = project(points[3][0], points[3][1]);
+			const span = vecSub(p3, p1);
+			const lengthSquared = vecDot(span, span);
+			if (lengthSquared === 0) return points;
+			const slid = vecAdd(p1, vecScale(span, Math.min(1, Math.max(0, vecDot(vecSub(p2, p1), span) / lengthSquared))));
+			points[1] = unproject(slid[0], slid[1]);
+			const snapped = orientationPoint(slid, p3, p4);
+			if (snapped) points[3] = snapped;
+			return points;
+		}
+		if (activePointIndex === 3) return snapOrientationToArc(clonePositions(next.slice(0, 4)));
+		if ((activePointIndex === 0 || activePointIndex === 2) && previous.length >= 4) {
+			const oldP1 = project(previous[0][0], previous[0][1]);
+			const oldP2 = project(previous[1][0], previous[1][1]);
+			const oldSpan = vecMag(vecSub(project(previous[2][0], previous[2][1]), oldP1));
+			const straightRatio = oldSpan === 0 ? .5 : vecMag(vecSub(oldP2, oldP1)) / oldSpan;
+			const points = clonePositions(next.slice(0, 4));
+			const p1 = project(points[0][0], points[0][1]);
+			const p3 = project(points[2][0], points[2][1]);
+			const p4 = project(points[3][0], points[3][1]);
+			const slid = vecAdd(p1, vecScale(vecSub(p3, p1), straightRatio));
+			points[1] = unproject(slid[0], slid[1]);
+			const snapped = orientationPoint(slid, p3, p4);
+			if (snapped) points[3] = snapped;
+			return points;
+		}
+		return snapOrientationToArc(derive$5(next));
+	}
+};
+//#endregion
+//#region src/draw-rules/line32.ts
+function derive$4(points) {
+	if (points.length === 2) {
+		const [c1, c3] = points;
+		const p2 = midpoint(project(c1[0], c1[1]), project(c3[0], c3[1]));
+		return clonePositions([
+			c1,
+			unproject(p2[0], p2[1]),
+			c3
+		]);
+	}
+	return clonePositions(points.slice(0, 3));
+}
+/** Line32 anchors for the two-click Infiltration mission task. */
+const line32DrawRule = {
+	id: "line32:infiltration",
+	minimumUserPoints: 2,
+	minimumPreviewPoints: 2,
+	canonicalPointCount: 3,
+	hiddenControlPointIndices: [1],
+	derive: derive$4,
+	transform(event) {
+		const { activePointIndex, next } = event;
+		if (next.length >= 3 && (activePointIndex === 0 || activePointIndex === 2)) return derive$4([next[0], next[2]]);
+		return derive$4(next);
+	}
+};
+//#endregion
 //#region src/draw-rules/area8.ts
 function derive$3(points) {
 	if (points.length < 2) return clonePositions(points);
@@ -1608,6 +1823,16 @@ const ATTACK_SHAFT_PARAMS = [
 		max: 1,
 		step: .05
 	},
+	{
+		key: "rearWidthRatio",
+		presentationTier: "advanced",
+		label: "Rear width",
+		description: "Width at the rear of the shaft as a ratio of the arrowhead width.",
+		type: "number",
+		min: .1,
+		max: 2,
+		step: .05
+	},
 	{
 		key: "smooth",
 		label: "Smooth",
@@ -1836,7 +2061,8 @@ const AREA_TEXT_AMPLIFIERS_DESIGNATION_HOSTILE = AREA_TEXT_AMPLIFIERS.filter((d)
 //#endregion
 //#region src/generators/cm15-maneuver-areas/airborneAttack.ts
 const DEFAULT_AIRBORNE_ATTACK_OPTIONS = {
-	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO,
+	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
+	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
 	smooth: false,
 	smoothResolution: 5
 };
@@ -1901,7 +2127,8 @@ const AIRBORNE_ATTACK = defineControlMeasure({
 	metadata: AIRBORNE_ATTACK_METADATA,
 	generator: createAirborneAttack,
 	defaultOptions: DEFAULT_AIRBORNE_ATTACK_OPTIONS,
-	rule: axis1DrawRule
+	rule: axis1DrawRule,
+	optionHandles: variableWidthAttackOptionHandles
 });
 /**
 * Reacts to an **input-contract** violation according to `mode`: `throw`
@@ -5738,7 +5965,8 @@ const ATTACK_BY_FIRE = defineControlMeasure({
 //#endregion
 //#region src/generators/cm15-maneuver-areas/attackHelicopter.ts
 const DEFAULT_ATTACK_HELICOPTER_OPTIONS = {
-	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO,
+	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
+	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
 	smooth: false,
 	smoothResolution: 5,
 	symbolHeightRatio: .45,
@@ -5957,7 +6185,8 @@ const ATTACK_HELICOPTER = defineControlMeasure({
 	metadata: ATTACK_HELICOPTER_METADATA,
 	generator: createAttackHelicopter,
 	defaultOptions: DEFAULT_ATTACK_HELICOPTER_OPTIONS,
-	rule: axis1DrawRule
+	rule: axis1DrawRule,
+	optionHandles: variableWidthAttackOptionHandles
 });
 //#endregion
 //#region src/generators/cm15-maneuver-areas/battlePosition.ts
@@ -6592,8 +6821,12 @@ const BRIDGE_OR_GAP = defineControlMeasure({
 const DEFAULT_SMOOTH_RESOLUTION$5 = 12;
 const MIN_SMOOTH_RESOLUTION$1 = 2;
 const MAX_SMOOTH_RESOLUTION$1 = 64;
+const DEFAULT_SHAFT_WIDTH_RATIO = .06;
+const MIN_SHAFT_WIDTH_RATIO = .01;
+const MAX_SHAFT_WIDTH_RATIO = .3;
 const DEFAULT_BLOCK_ARROW_OPTIONS = {
-	shaftWidthRatio: .06,
+	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO,
+	rearWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO,
 	arrowheadStyle: "triangle",
 	arrowheadWidthRatio: .18,
 	arrowheadLengthRatio: .22,
@@ -6625,8 +6858,18 @@ const BLOCK_ARROW_METADATA = {
 			label: "Shaft width",
 			description: "Shaft band width as a fraction of the total path length",
 			type: "number",
-			min: .01,
-			max: .3,
+			min: MIN_SHAFT_WIDTH_RATIO,
+			max: MAX_SHAFT_WIDTH_RATIO,
+			step: .01
+		},
+		{
+			key: "rearWidthRatio",
+			presentationTier: "advanced",
+			label: "Rear width",
+			description: "Width at the rear of the shaft as a fraction of the total path length",
+			type: "number",
+			min: MIN_SHAFT_WIDTH_RATIO,
+			max: MAX_SHAFT_WIDTH_RATIO,
 			step: .01
 		},
 		{
@@ -6717,25 +6960,42 @@ const BLOCK_ARROW_METADATA = {
 * right side of the shaft.
 */
 function createBlockArrow(coordinates, options = {}) {
-	const { shaftWidthRatio, arrowheadStyle, arrowheadWidthRatio, arrowheadLengthRatio, smooth, smoothResolution, filled } = {
-		...DEFAULT_BLOCK_ARROW_OPTIONS,
-		...options
-	};
-	const axis1 = axis1Geometry(coordinates);
-	const axis = arrowAxis(axis1.path);
-	if (!axis) return {
+	const resolved = resolveBlockArrowOptions(options);
+	const geometry = calculateBlockArrowGeometry(coordinates, resolved);
+	if (!geometry) return {
 		type: "FeatureCollection",
 		features: []
 	};
+	const { ring } = geometry;
+	return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: {
+				part: "body",
+				fill: resolved.filled
+			},
+			geometry: {
+				type: "Polygon",
+				coordinates: [ring.map((p) => unproject(p[0], p[1]))]
+			}
+		}]
+	};
+}
+function calculateBlockArrowGeometry(coordinates, options) {
+	const axis1 = axis1Geometry(coordinates);
+	const axis = arrowAxis(axis1.path);
+	if (!axis) return null;
 	const { pts, pathLength, tip, dir, perp, segLength } = axis;
-	const requestedHeadLen = axis1.headLength ?? pathLength * arrowheadLengthRatio;
+	const requestedHeadLen = axis1.headLength ?? pathLength * options.arrowheadLengthRatio;
 	const headLen = Math.min(requestedHeadLen, segLength * .95);
-	const halfShaft = pathLength * shaftWidthRatio / 2;
-	const halfHead = axis1.headHalfWidth ?? pathLength * arrowheadWidthRatio / 2;
+	const halfShaft = pathLength * options.shaftWidthRatio / 2;
+	const halfRear = pathLength * options.rearWidthRatio / 2;
+	const halfHead = axis1.headHalfWidth ?? pathLength * options.arrowheadWidthRatio / 2;
 	const onAxis = (d, side = 0) => [tip[0] - dir[0] * d + perp[0] * side, tip[1] - dir[1] * d + perp[1] * side];
 	let shaftEndDist;
 	let headPts;
-	switch (arrowheadStyle) {
+	switch (options.arrowheadStyle) {
 		case "barbed":
 			shaftEndDist = headLen * .55;
 			headPts = [
@@ -6793,9 +7053,9 @@ function createBlockArrow(coordinates, options = {}) {
 			break;
 	}
 	let spine = [...pts.slice(0, -1), onAxis(shaftEndDist)];
-	if (smooth) spine = catmullRom(spine, normalizeSmoothResolution$1(smoothResolution));
-	const leftSide = offsetPolyline(spine, halfShaft);
-	const rightSide = offsetPolyline(spine, -halfShaft);
+	if (options.smooth) spine = catmullRom(spine, normalizeSmoothResolution$1(options.smoothResolution));
+	const widths = interpolatePolylineValues(spine, halfRear, halfShaft);
+	const { left: leftSide, right: rightSide } = offsetPolylineSides(spine, widths);
 	const ring = [
 		...leftSide,
 		...headPts,
@@ -6803,18 +7063,20 @@ function createBlockArrow(coordinates, options = {}) {
 	];
 	ring.push(ring[0]);
 	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {
-				part: "body",
-				fill: filled
-			},
-			geometry: {
-				type: "Polygon",
-				coordinates: [ring.map((p) => unproject(p[0], p[1]))]
-			}
-		}]
+		ring,
+		spine,
+		leftSide,
+		pathLength
+	};
+}
+function resolveBlockArrowOptions(options) {
+	const resolved = {
+		...DEFAULT_BLOCK_ARROW_OPTIONS,
+		...options
+	};
+	return {
+		...resolved,
+		rearWidthRatio: resolveRearWidthRatio(options, resolved.shaftWidthRatio)
 	};
 }
 const BLOCK_ARROW = defineControlMeasure({
@@ -6822,6 +7084,20 @@ const BLOCK_ARROW = defineControlMeasure({
 	generator: createBlockArrow,
 	defaultOptions: DEFAULT_BLOCK_ARROW_OPTIONS,
 	rule: axis1DrawRule,
+	optionHandles: createWidthOptionHandles({
+		geometry(controlPoints, options) {
+			const geometry = calculateBlockArrowGeometry(controlPoints, resolveBlockArrowOptions(options));
+			if (!geometry) return null;
+			return {
+				spine: geometry.spine,
+				leftEdge: geometry.leftSide,
+				referenceHalfWidth: geometry.pathLength / 2
+			};
+		},
+		minRatio: MIN_SHAFT_WIDTH_RATIO,
+		maxRearRatio: MAX_SHAFT_WIDTH_RATIO,
+		maxShaftRatio: MAX_SHAFT_WIDTH_RATIO
+	}),
 	previewSample: {
 		controlPoints: [
 			[1.4, 0],
@@ -9274,7 +9550,8 @@ const CLEAR = defineControlMeasure({
 //#endregion
 //#region src/generators/cm15-maneuver-areas/supportingAttack.ts
 const DEFAULT_SUPPORTING_ATTACK_OPTIONS = {
-	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO,
+	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
+	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
 	smooth: false,
 	smoothResolution: 5
 };
@@ -9346,12 +9623,14 @@ const SUPPORTING_ATTACK = defineControlMeasure({
 	metadata: SUPPORTING_ATTACK_METADATA,
 	generator: createSupportingAttack,
 	defaultOptions: DEFAULT_SUPPORTING_ATTACK_OPTIONS,
-	rule: axis1DrawRule
+	rule: axis1DrawRule,
+	optionHandles: variableWidthAttackOptionHandles
 });
 //#endregion
 //#region src/generators/cm34-mission-tasks/counterattack.ts
 const DEFAULT_COUNTERATTACK_OPTIONS = {
-	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO,
+	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
+	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
 	smooth: false,
 	smoothResolution: 5,
 	labelPosition: 1
@@ -9436,6 +9715,7 @@ const COUNTERATTACK = defineControlMeasure({
 	generator: createCounterattack,
 	defaultOptions: DEFAULT_COUNTERATTACK_OPTIONS,
 	rule: axis1DrawRule,
+	optionHandles: variableWidthAttackOptionHandles,
 	previewSample: {
 		controlPoints: [
 			[1, 0],
@@ -9596,6 +9876,7 @@ const COUNTERATTACK_BY_FIRE = defineControlMeasure({
 	generator: createCounterattackByFire,
 	defaultOptions: DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS,
 	rule: counterattackByFireDrawRule,
+	optionHandles: createVariableWidthAttackOptionHandles(counterattackByFireBodyCoordinates),
 	previewSample: {
 		controlPoints: [
 			[1.35, 0],
@@ -10381,6 +10662,299 @@ const DISRUPT_MISSION_TASK = defineControlMeasure({
 	previewSample: { controlPoints: [[0, .4], [0, -.4]] }
 });
 //#endregion
+//#region src/generators/cm34-mission-tasks/envelopment.ts
+const DEFAULT_ENVELOPMENT_OPTIONS = {
+	arrowheadLengthRatio: .1,
+	arrowheadWidthRatio: .12,
+	labelPosition: .6,
+	labelGapRatio: .18,
+	resolution: 64
+};
+const ENVELOPMENT_METADATA = {
+	id: "envelopment",
+	name: "Envelopment",
+	description: "A form of maneuver in which an attacking force avoids an enemy’s principal defense by attacking along an assailable flank.",
+	entity: "Mission Tasks",
+	entityType: "Envelopment",
+	value: "343500",
+	minCoordinates: 4,
+	maxCoordinates: 4,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Line31",
+	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: "labelPosition",
+			presentationTier: "advanced",
+			label: "Label position",
+			description: "Position of the E 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 E label",
+			type: "number",
+			min: 0,
+			max: 1,
+			step: .01
+		},
+		...ARC_RESOLUTION_PARAMS
+	]
+};
+/** Generates the Envelopment mission task symbol (343500). */
+function createEnvelopment(coordinates, options = {}) {
+	const [c1, c2, c3, c4] = coordinates;
+	const p1 = project(c1[0], c1[1]);
+	const p2 = project(c2[0], c2[1]);
+	const diameterAnchor = project(c3[0], c3[1]);
+	const p4 = project(c4[0], c4[1]);
+	const straight = vecSub(p2, p1);
+	const straightLength = vecMag(straight);
+	const diameter = vecMag(vecSub(diameterAnchor, p2));
+	if (straightLength < 1e-6 || diameter < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const straightDirection = vecNorm(straight);
+	const p3 = vecAdd(p2, vecScale(straightDirection, diameter));
+	const labelPoint = vecAdd(p1, vecScale(straight, clamp01(options.labelPosition ?? DEFAULT_ENVELOPMENT_OPTIONS.labelPosition)));
+	const gapHalf = straightLength * clamp01(options.labelGapRatio ?? DEFAULT_ENVELOPMENT_OPTIONS.labelGapRatio) / 2;
+	const gapStart = vecAdd(labelPoint, vecScale(straightDirection, -gapHalf));
+	const gapEnd = vecAdd(labelPoint, vecScale(straightDirection, gapHalf));
+	const center = midpoint(p2, p3);
+	const startRadius = vecSub(p2, center);
+	let bulgeRadius = [-startRadius[1], startRadius[0]];
+	if (vecDot(vecSub(p4, center), bulgeRadius) < 0) bulgeRadius = vecScale(bulgeRadius, -1);
+	const arc = sampleProjectedArc(center, startRadius, bulgeRadius, 0, Math.PI, normalizeArcResolution(options.resolution) / 2);
+	const arrowhead = createArrowHead$1(p3, vecNorm(vecScale(bulgeRadius, -1)), diameter * Math.max(0, options.arrowheadLengthRatio ?? DEFAULT_ENVELOPMENT_OPTIONS.arrowheadLengthRatio), diameter * Math.max(0, options.arrowheadWidthRatio ?? DEFAULT_ENVELOPMENT_OPTIONS.arrowheadWidthRatio));
+	return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: { part: "envelopment" },
+			geometry: {
+				type: "MultiLineString",
+				coordinates: [
+					[c1, unproject(gapStart[0], gapStart[1])],
+					[unproject(gapEnd[0], gapEnd[1]), c2],
+					arc,
+					arrowhead
+				]
+			}
+		}, createLabelFeature(labelPoint, "E", labelRotationAlong(straightDirection), options)]
+	};
+}
+const ENVELOPMENT = defineControlMeasure({
+	metadata: ENVELOPMENT_METADATA,
+	generator: createEnvelopment,
+	defaultOptions: DEFAULT_ENVELOPMENT_OPTIONS,
+	rule: line31DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-.9, -.25],
+			[-.15, -.25],
+			[.85, -.25],
+			[.35, .45]
+		],
+		options: { labelSize: 100 }
+	}
+});
+//#endregion
+//#region src/generators/cm34-mission-tasks/infiltration.ts
+const DEFAULT_INFILTRATION_OPTIONS = {
+	arrowheadLengthRatio: .1,
+	arrowheadWidthRatio: .1,
+	labelPosition: .6,
+	labelGapRatio: .24,
+	resolution: 64
+};
+const INFILTRATION_METADATA = {
+	id: "infiltration",
+	name: "Infiltration",
+	description: "Moves forces through or into an area occupied by enemy forces without detection.",
+	entity: "Mission Tasks",
+	entityType: "Infiltration",
+	value: "343800",
+	minCoordinates: 3,
+	maxCoordinates: 3,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Line32",
+	capturesLabelSize: true,
+	params: [
+		{
+			key: "arrowheadLengthRatio",
+			presentationTier: "advanced",
+			label: "Arrowhead length",
+			description: "Arrowhead length as a ratio of the Point 1–Point 3 span",
+			type: "number",
+			min: .01,
+			max: .5,
+			step: .01
+		},
+		{
+			key: "arrowheadWidthRatio",
+			presentationTier: "advanced",
+			label: "Arrowhead width",
+			description: "Arrowhead width as a ratio of the Point 1–Point 3 span",
+			type: "number",
+			min: .01,
+			max: .5,
+			step: .01
+		},
+		{
+			key: "labelPosition",
+			presentationTier: "advanced",
+			label: "Label position",
+			description: "Position of the IN label along the initial straight portion",
+			type: "number",
+			min: 0,
+			max: 1,
+			step: .01
+		},
+		{
+			key: "labelGapRatio",
+			presentationTier: "advanced",
+			label: "Label gap",
+			description: "Size of the initial-line cutout holding the IN label",
+			type: "number",
+			min: 0,
+			max: 1,
+			step: .01
+		},
+		...ARC_RESOLUTION_PARAMS
+	]
+};
+const CENTERED_BEND_SINE = 2 * .1;
+const CENTERED_BEND_COSINE = Math.sqrt(1 - CENTERED_BEND_SINE * CENTERED_BEND_SINE);
+/**
+* Resolves the common tangent direction of the two Line32 quarter-circles.
+* For the doctrinal construction, PT. 1 and PT. 3 lie on parallel tangents on
+* opposite sides of PT. 2. Their midpoint offset from PT. 2 therefore lies on
+* that tangent axis. For a derived, centered PT. 2 the axis is mathematically
+* underdetermined, so a proportional doctrinal bend resolves it.
+*/
+function tangentDirection(p1, p2, p3) {
+	const axis = vecSub(vecScale(p2, 2), vecAdd(p1, p3));
+	const span = vecSub(p3, p1);
+	const spanLength = vecMag(span);
+	let direction;
+	if (vecMag(axis) < spanLength * .02) {
+		const chord = vecNorm(span);
+		direction = [chord[0] * CENTERED_BEND_COSINE - chord[1] * CENTERED_BEND_SINE, chord[0] * CENTERED_BEND_SINE + chord[1] * CENTERED_BEND_COSINE];
+	} else direction = vecNorm(axis);
+	if (vecDot(direction, span) < 0) direction = vecScale(direction, -1);
+	return direction;
+}
+/** Generates the Infiltration mission task symbol (343800). */
+function createInfiltration(coordinates, options = {}) {
+	const [c1, c2, c3] = coordinates;
+	const p1 = project(c1[0], c1[1]);
+	const p2 = project(c2[0], c2[1]);
+	const p3 = project(c3[0], c3[1]);
+	const spanLength = vecMag(vecSub(p3, p1));
+	if (spanLength < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const along = tangentDirection(p1, p2, p3);
+	const normal = [-along[1], along[0]];
+	const signedRadius = vecDot(vecSub(p1, p2), normal);
+	const radius = Math.abs(signedRadius);
+	if (radius < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const sideRadius = vecScale(normal, (signedRadius < 0 ? -1 : 1) * radius);
+	const alongRadius = vecScale(along, radius);
+	const firstCenter = vecSub(p2, alongRadius);
+	const arcStart = vecAdd(firstCenter, sideRadius);
+	const secondCenter = vecAdd(p2, alongRadius);
+	const arcEnd = vecSub(secondCenter, sideRadius);
+	const straight = vecSub(arcStart, p1);
+	const straightLength = vecMag(straight);
+	if (straightLength < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const arcResolution = normalizeArcResolution(options.resolution) / 2;
+	const firstArc = sampleProjectedArc(firstCenter, sideRadius, alongRadius, 0, Math.PI / 2, arcResolution);
+	const secondArc = sampleProjectedArc(secondCenter, vecScale(alongRadius, -1), vecScale(sideRadius, -1), 0, Math.PI / 2, arcResolution);
+	const labelPoint = vecAdd(p1, vecScale(straight, clamp01(options.labelPosition ?? DEFAULT_INFILTRATION_OPTIONS.labelPosition)));
+	const gapHalf = straightLength * clamp01(options.labelGapRatio ?? DEFAULT_INFILTRATION_OPTIONS.labelGapRatio) / 2;
+	const gapStart = vecAdd(labelPoint, vecScale(along, -gapHalf));
+	const gapEnd = vecAdd(labelPoint, vecScale(along, gapHalf));
+	const arrowhead = createArrowHead$1(p3, along, spanLength * Math.max(0, options.arrowheadLengthRatio ?? DEFAULT_INFILTRATION_OPTIONS.arrowheadLengthRatio), spanLength * Math.max(0, options.arrowheadWidthRatio ?? DEFAULT_INFILTRATION_OPTIONS.arrowheadWidthRatio));
+	return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: { part: "infiltration" },
+			geometry: {
+				type: "MultiLineString",
+				coordinates: [
+					[c1, unproject(gapStart[0], gapStart[1])],
+					[unproject(gapEnd[0], gapEnd[1]), unproject(arcStart[0], arcStart[1])],
+					firstArc,
+					secondArc,
+					[unproject(arcEnd[0], arcEnd[1]), c3],
+					arrowhead
+				]
+			}
+		}, createLabelFeature(labelPoint, "IN", labelRotationAlong(along), options)]
+	};
+}
+const INFILTRATION = defineControlMeasure({
+	metadata: INFILTRATION_METADATA,
+	generator: createInfiltration,
+	defaultOptions: DEFAULT_INFILTRATION_OPTIONS,
+	rule: line32DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-.9, .25],
+			[-.05, 0],
+			[.9, -.25]
+		],
+		options: { labelSize: 100 }
+	}
+});
+//#endregion
 //#region src/generators/cm34-mission-tasks/guard.ts
 const DEFAULT_GUARD_OPTIONS = DEFAULT_SECURITY_TASK_OPTIONS;
 const GUARD_METADATA = {
@@ -12742,7 +13316,8 @@ 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,
+	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
+	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
 	smooth: false,
 	smoothResolution: 5,
 	crossbarLengthRatio: 1.1,
@@ -12751,10 +13326,14 @@ const DEFAULT_MANEUVER_ARROW_TASK_OPTIONS = {
 	labelPadding: 0
 };
 function createManeuverArrowTask(coordinates, options, textAmplifiers, config) {
-	const resolved = {
+	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",
@@ -12775,17 +13354,22 @@ function createManeuverArrowTask(coordinates, options, textAmplifiers, config) {
 	};
 	const tipVector = vecSub(geometry.ptTip, geometry.ptBase);
 	const tipDirection = vecNorm(tipVector);
-	const crossbarLength = vecMag(vecSub(geometry.headRing[0], geometry.headRing[2])) * Math.max(1, resolved.crossbarLengthRatio);
+	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 crossbarFrame = pointAlongPolyline(segments, totalLength, Number.isFinite(config.crossbarAt.shaftPosition) ? clamp01(config.crossbarAt.shaftPosition) : 0);
+		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 = [{
@@ -12925,6 +13509,7 @@ const FRONTAL_ATTACK = defineControlMeasure({
 	generator: createFrontalAttack,
 	defaultOptions: DEFAULT_FRONTAL_ATTACK_OPTIONS,
 	rule: axis1DrawRule,
+	optionHandles: variableWidthAttackOptionHandles,
 	previewSample: {
 		controlPoints: [
 			[1, 0],
@@ -13962,7 +14547,8 @@ const NO_FIRE_AREA_IRREGULAR = defineControlMeasure({
 //#endregion
 //#region src/generators/cm15-maneuver-areas/mainAttack.ts
 const DEFAULT_MAIN_ATTACK_OPTIONS = {
-	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO,
+	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
+	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
 	smooth: false,
 	smoothResolution: 5
 };
@@ -13990,7 +14576,7 @@ const MAIN_ATTACK_METADATA = {
 *
 * The symbol consists of a single MultiLineString feature containing:
 * 1. **Arrowhead**: A line forming a "chevron" or "roof" shape.
-* 2. **Shaft**: Two parallel lines behind the arrow.
+* 2. **Shaft**: Two boundary lines behind the arrow, optionally flared toward the rear.
 *
 * The shaft is calculated to terminate exactly where it touches the inner walls
 * of the arrowhead, creating a seamless connection.
@@ -14029,7 +14615,8 @@ const MAIN_ATTACK = defineControlMeasure({
 	metadata: MAIN_ATTACK_METADATA,
 	generator: createMainAttack,
 	defaultOptions: DEFAULT_MAIN_ATTACK_OPTIONS,
-	rule: axis1DrawRule
+	rule: axis1DrawRule,
+	optionHandles: variableWidthAttackOptionHandles
 });
 //#endregion
 //#region src/generators/cm27-protection-areas/mine-types.ts
@@ -16226,6 +16813,8 @@ const DEFINITIONS = {
 	delay: DELAY,
 	disengage: DISENGAGE,
 	"disrupt-mission-task": DISRUPT_MISSION_TASK,
+	envelopment: ENVELOPMENT,
+	infiltration: INFILTRATION,
 	guard: GUARD,
 	isolate: ISOLATE,
 	penetrate: PENETRATE,
@@ -16246,6 +16835,7 @@ const DEFINITIONS = {
 		generator: createTurningMovement,
 		defaultOptions: DEFAULT_TURNING_MOVEMENT_OPTIONS,
 		rule: axis1DrawRule,
+		optionHandles: variableWidthAttackOptionHandles,
 		previewSample: {
 			controlPoints: [
 				[1, 0],