@orbat-mapper/control-measures 0.2.0-alpha.11 → 0.2.0-alpha.13

package/dist/{renderControlMeasure-NKEYq3Fg.mjs → renderControlMeasure-CoBRpbJT.mjs}

@@ -510,7 +510,7 @@ function samePosition(a, b) {
 }
 //#endregion
 //#region src/draw-rules/area1.ts
-function derive$8(points) {
+function derive$9(points) {
 	return clonePositions(points);
 }
 /**
@@ -530,9 +530,9 @@ const area1DrawRule = {
 	id: "area1",
 	minimumUserPoints: 3,
 	closedRing: true,
-	derive: derive$8,
+	derive: derive$9,
 	transform(event) {
-		return derive$8(event.next);
+		return derive$9(event.next);
 	}
 };
 //#endregion
@@ -558,14 +558,14 @@ const disruptDrawRule = 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$7(points) {
+function derive$8(points) {
 	return clonePositions(points.slice(0, 2));
 }
 const centerRadiusDrawRule = {
 	id: "area15:center-radius",
 	minimumUserPoints: 2,
 	canonicalPointCount: 2,
-	derive: derive$7,
+	derive: derive$8,
 	transform(event) {
 		const { previous, next, activePointIndex } = event;
 		if (activePointIndex === 0 && previous.length >= 2 && next.length >= 2) {
@@ -574,7 +574,7 @@ const centerRadiusDrawRule = {
 			const origin = previous[1];
 			return [clonePosition(next[0]), [origin[0] + dx, origin[1] + dy]];
 		}
-		return derive$7(next);
+		return derive$8(next);
 	}
 };
 /** Backward-compatible doctrinal name for Area15's shared center-radius rule. */
@@ -619,20 +619,20 @@ const ambushDrawRule = createMidpointPerpendicularDrawRule({
 });
 //#endregion
 //#region src/draw-rules/line1.ts
-function derive$6(points) {
+function derive$7(points) {
 	return clonePositions(points);
 }
 const line1DrawRule = {
 	id: "line1",
 	minimumUserPoints: 2,
-	derive: derive$6,
+	derive: derive$7,
 	transform(event) {
-		return derive$6(event.next);
+		return derive$7(event.next);
 	}
 };
 //#endregion
 //#region src/draw-rules/line3.ts
-function derive$5(points) {
+function derive$6(points) {
 	return clonePositions(points);
 }
 /**
@@ -647,23 +647,23 @@ const line3DrawRule = {
 	id: "line3",
 	minimumUserPoints: 3,
 	canonicalPointCount: 3,
-	derive: derive$5,
+	derive: derive$6,
 	transform(event) {
-		return derive$5(event.next);
+		return derive$6(event.next);
 	}
 };
 //#endregion
 //#region src/draw-rules/line9.ts
-function derive$4(points) {
+function derive$5(points) {
 	return clonePositions(points);
 }
 const line9DrawRule = {
 	id: "line9",
 	minimumUserPoints: 2,
 	canonicalPointCount: 2,
-	derive: derive$4,
+	derive: derive$5,
 	transform(event) {
-		return derive$4(event.next);
+		return derive$5(event.next);
 	}
 };
 //#endregion
@@ -768,6 +768,52 @@ const line24DrawRule = createMidpointPerpendicularDrawRule({
 	minimumPreviewPoints: 2
 });
 //#endregion
+//#region src/draw-rules/line26.ts
+function derive$4(points) {
+	if (points.length === 2) {
+		const [p1, p2] = points;
+		const dx = p2[0] - p1[0];
+		const dy = p2[1] - p1[1];
+		const p3 = [p2[0] + dx * .5, p2[1] + dy * .5];
+		return clonePositions([
+			p1,
+			p2,
+			p3,
+			[p3[0] + dx, p3[1] + dy]
+		]);
+	}
+	if (points.length === 3) {
+		const [p1, p2, p3] = points;
+		return clonePositions([
+			p1,
+			p2,
+			p3,
+			[p3[0] + p2[0] - p1[0], p3[1] + p2[1] - p1[1]]
+		]);
+	}
+	return clonePositions(points);
+}
+/**
+* Line26 anchor draw rule for the Cover, Guard, and Screen security tasks.
+*
+* PT. 1/PT. 4 are the outward arrow tips and PT. 2/PT. 3 bound the opening
+* reserved for the supported tactical symbol. All four anchors are free: the
+* two sides may independently touch the symbols that define the task limits.
+* During drawing, the cursor after PT. 1 supplies a provisional PT. 2 and the
+* rule mirrors that first leg across a temporary center opening, so the full
+* symbol is visible before PT. 2 is committed.
+*/
+const line26DrawRule = {
+	id: "line26",
+	minimumUserPoints: 4,
+	minimumPreviewPoints: 2,
+	canonicalPointCount: 4,
+	derive: derive$4,
+	transform(event) {
+		return derive$4(event.next);
+	}
+};
+//#endregion
 //#region src/draw-rules/area8.ts
 function derive$3(points) {
 	if (points.length < 2) return clonePositions(points);
@@ -1761,6 +1807,27 @@ function buildGappedLine(verts, gaps) {
 	return parts;
 }
 //#endregion
+//#region src/internal/angle-utils.ts
+/**
+* Wraps an angle (radians) into the half-open range (-π, π].
+*/
+function normalizeRadians(angle) {
+	let normalized = angle % (Math.PI * 2);
+	if (normalized > Math.PI) normalized -= Math.PI * 2;
+	if (normalized <= -Math.PI) normalized += Math.PI * 2;
+	return normalized;
+}
+/**
+* Flips a text rotation by π when it would otherwise read upside-down, keeping
+* the baseline pointing left-to-right (within ±90° of horizontal).
+*/
+function keepTextLeftToRight(rotation) {
+	const normalized = normalizeRadians(rotation);
+	if (normalized > Math.PI / 2) return normalized - Math.PI;
+	if (normalized < -Math.PI / 2) return normalized + Math.PI;
+	return normalized;
+}
+//#endregion
 //#region src/internal/sketch.ts
 /**
 * Projects `coordinates` and derives the arrow's tip, heading and total length.
@@ -1826,6 +1893,46 @@ const SMOOTH_LINE_PARAMS = [{
 function smoothLineVerts(verts, options, defaultResolution) {
 	return options.smooth ? catmullRom(verts, normalizeSmoothResolution$2(options.smoothResolution ?? defaultResolution, defaultResolution)) : verts;
 }
+/**
+* Resamples a path into equal arc-length segments.
+*
+* This is useful for a repeated motif (such as a fortified tooth or FLOT
+* scallop) after smoothing. Catmull-Rom samples are evenly spaced in spline
+* parameter, not distance, so using them directly as motif boundaries causes
+* the motifs to bunch up where the curve's samples are closer together.
+*/
+function evenlySpacePath(points, targetSegmentLength) {
+	if (points.length < 2) return points;
+	const segmentLengths = [];
+	let totalLength = 0;
+	for (let i = 0; i < points.length - 1; i++) {
+		const length = vecMag(vecSub(points[i + 1], points[i]));
+		segmentLengths.push(length);
+		totalLength += length;
+	}
+	if (totalLength < 1e-6) return [points[0]];
+	const segmentCount = Math.max(1, Math.round(totalLength / targetSegmentLength));
+	const segmentLength = totalLength / segmentCount;
+	const out = [points[0]];
+	let sourceIndex = 0;
+	let sourceStart = points[0];
+	let consumed = 0;
+	for (let segment = 1; segment < segmentCount; segment++) {
+		const target = segment * segmentLength;
+		while (sourceIndex < segmentLengths.length - 1 && consumed + segmentLengths[sourceIndex] < target) {
+			consumed += segmentLengths[sourceIndex];
+			sourceIndex++;
+			sourceStart = points[sourceIndex];
+		}
+		const length = segmentLengths[sourceIndex];
+		if (length < 1e-6) continue;
+		const t = (target - consumed) / length;
+		const sourceEnd = points[sourceIndex + 1];
+		out.push([sourceStart[0] + (sourceEnd[0] - sourceStart[0]) * t, sourceStart[1] + (sourceEnd[1] - sourceStart[1]) * t]);
+	}
+	out.push(points[points.length - 1]);
+	return out;
+}
 /** One centripetal Catmull-Rom sample at parameter `t` over control points `p0..p3`. */
 function catmullRomAt(p0, p1, p2, p3, t) {
 	const t2 = t * t;
@@ -1876,177 +1983,6 @@ function closedCatmullRom(points, samples) {
 	return out;
 }
 //#endregion
-//#region src/internal/area-echelon.ts
-/**
-* Twice the ring's signed area (shoelace). Positive when the ring winds
-* counter-clockwise in projected (y-up) coordinates. Exported for reuse by
-* `area-labels.ts`'s polygon-centroid label placement, so the area centroid
-* shares this one derivation instead of re-deriving it.
-*/
-function ringSignedArea2(verts) {
-	let area2 = 0;
-	for (let i = 0; i < verts.length - 1; i++) {
-		const a = verts[i];
-		const b = verts[i + 1];
-		area2 += a[0] * b[1] - b[0] * a[1];
-	}
-	return area2;
-}
-/**
-* Projects `positions` and returns a closed ring (first == last), optionally
-* smoothed through the control points with a closed centripetal Catmull-Rom
-* spline. A trailing vertex that duplicates the first (already-closed input)
-* is dropped before closing/smoothing.
-*/
-function buildClosedRing(positions, smooth, smoothResolution, defaultSmoothResolution) {
-	const projected = positions.map((p) => project(p[0], p[1]));
-	const ringPts = projected.length > 1 && Math.abs(projected[0][0] - projected[projected.length - 1][0]) < 1e-6 && Math.abs(projected[0][1] - projected[projected.length - 1][1]) < 1e-6 ? projected.slice(0, -1) : projected;
-	return smooth ? closedCatmullRom(ringPts, normalizeSmoothResolution$2(smoothResolution, defaultSmoothResolution)) : [...ringPts, ringPts[0]];
-}
-/**
-* Walks a closed ring into per-segment metadata (unit direction, outward
-* normal, cumulative arc length) plus the total perimeter and the arc-length
-* anchor of the bottom edge — the segment whose midpoint sits lowest (min
-* projected y), the side opposite the front.
-*/
-function buildAreaPerimeter(verts) {
-	const ccw = ringSignedArea2(verts) > 0;
-	const segs = [];
-	let totalLength = 0;
-	let anchorTarget = 0;
-	let lowest = Infinity;
-	for (let i = 0; i < verts.length - 1; i++) {
-		const a = verts[i];
-		const b = verts[i + 1];
-		const edge = vecSub(b, a);
-		const length = vecMag(edge);
-		if (length < 1e-6) continue;
-		const along = vecNorm(edge);
-		const mid = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
-		const perp = ccw ? [along[1], -along[0]] : [-along[1], along[0]];
-		segs.push({
-			start: a,
-			along,
-			perp,
-			length,
-			arcStart: totalLength
-		});
-		if (mid[1] < lowest) {
-			lowest = mid[1];
-			anchorTarget = totalLength + length / 2;
-		}
-		totalLength += length;
-	}
-	return {
-		verts,
-		segs,
-		totalLength,
-		anchorTarget
-	};
-}
-/** Resolves the arc-length `target` to a point and the segment frame it lands on. */
-function pointOnRing(segs, target) {
-	let seg = segs[segs.length - 1];
-	for (const candidate of segs) if (target < candidate.arcStart + candidate.length) {
-		seg = candidate;
-		break;
-	}
-	return {
-		point: vecAdd(seg.start, vecScale(seg.along, target - seg.arcStart)),
-		seg
-	};
-}
-/**
-* Effective echelon glyph height in meters. Screen-anchored when a pixel size
-* is supplied with a live resolution; ground-anchored (meters) otherwise.
-* Clamped strictly positive.
-*/
-function resolveEchelonHeight(echelonSize, echelonSizePixels, metersPerPixel) {
-	let h = echelonSize;
-	if (echelonSizePixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0) h = echelonSizePixels * metersPerPixel;
-	return Math.max(EPSILON, h);
-}
-/** Wraps `x` into `[0, 1)`, treating `x` as a fraction (matches the arc-length wrap below). */
-function wrap01(x) {
-	return (x % 1 + 1) % 1;
-}
-/**
-* Places the Field B echelon glyph on the perimeter and computes its masking
-* gap, anchored by default to the bottom edge and slid by `echelonPosition`
-* (a signed fraction of the perimeter, wrapping at the seam). When
-* `echelonAnchor` is supplied, it replaces the bottom-edge anchor with an
-* absolute perimeter fraction (measured from the ring seam) — see
-* `BattlePositionOptions.echelonAnchor` for why (ADR-0023 rotate-freeze).
-* Returns empty geometry when the echelon resolves to none or the ring is
-* degenerate.
-*/
-function placeEchelon(perimeter, h, echelon, echelonPadding, echelonPosition, echelonAnchor) {
-	const { segs, totalLength, anchorTarget } = perimeter;
-	const spec = resolveEchelon(echelon);
-	if (!spec || segs.length === 0 || totalLength < 1e-6) return {
-		strokes: [],
-		fills: [],
-		gaps: []
-	};
-	const target = (((echelonAnchor !== void 0 ? wrap01(echelonAnchor) * totalLength : anchorTarget) + echelonPosition * totalLength) % totalLength + totalLength) % totalLength;
-	const { point, seg } = pointOnRing(segs, target);
-	const { strokes, fills, width } = buildEchelonGlyph(point, seg.along, seg.perp, h, spec);
-	const gaps = [];
-	const halfGap = width / 2 + Math.max(0, echelonPadding) * h;
-	pushWrappedGap(gaps, target - halfGap, target + halfGap, totalLength);
-	return {
-		strokes,
-		fills,
-		gaps
-	};
-}
-/**
-* Factory for the `freezeOrientation` hook (ADR-0023) shared by every
-* echelon-carrying closed-area measure (Battle Position, Strong Point, Base
-* Camp, Guerrilla Base): pins the echelon anchor to its current bottom-edge
-* fraction so a subsequent rigid rotation of `controlPoints` (e.g. the
-* transform box's rotate grip) does not re-derive a different "bottom edge"
-* against the rotated geometry. `defaults` supplies the measure's own
-* `echelon`/`smooth`/`smoothResolution` defaults, since each measure's
-* `DEFAULT_*_OPTIONS` differ (e.g. Battle Position's `echelon: "battalion"`
-* vs. Base Camp/Guerrilla Base's `echelon: "none"`).
-*
-* The returned hook returns `undefined` — nothing to freeze — when:
-*  - `echelonAnchor` is already set (previously frozen or user-authored), or
-*  - the echelon resolves to none (nothing visible to pin), or
-*  - the ring is degenerate (no segments, or a near-zero perimeter).
-*/
-function makeFreezeEchelonAnchor(defaults) {
-	return function freezeEchelonAnchor(controlPoints, options) {
-		if (options.echelonAnchor !== void 0) return void 0;
-		if (!resolveEchelon(options.echelon ?? defaults.echelon)) return void 0;
-		const perimeter = buildAreaPerimeter(buildClosedRing(controlPoints, options.smooth ?? defaults.smooth, options.smoothResolution ?? defaults.smoothResolution, defaults.smoothResolution));
-		if (perimeter.segs.length === 0 || perimeter.totalLength < 1e-6) return void 0;
-		return { echelonAnchor: perimeter.anchorTarget / perimeter.totalLength };
-	};
-}
-//#endregion
-//#region src/internal/angle-utils.ts
-/**
-* Wraps an angle (radians) into the half-open range (-π, π].
-*/
-function normalizeRadians(angle) {
-	let normalized = angle % (Math.PI * 2);
-	if (normalized > Math.PI) normalized -= Math.PI * 2;
-	if (normalized <= -Math.PI) normalized += Math.PI * 2;
-	return normalized;
-}
-/**
-* Flips a text rotation by π when it would otherwise read upside-down, keeping
-* the baseline pointing left-to-right (within ±90° of horizontal).
-*/
-function keepTextLeftToRight(rotation) {
-	const normalized = normalizeRadians(rotation);
-	if (normalized > Math.PI / 2) return normalized - Math.PI;
-	if (normalized < -Math.PI / 2) return normalized + Math.PI;
-	return normalized;
-}
-//#endregion
 //#region src/internal/line-labels.ts
 /**
 * Stored label rotation for text running along projected direction `dir`.
@@ -2067,13 +2003,13 @@ function labelRotationAlong(dir) {
 */
 function pushUnitLabels(out, frame, units) {
 	const { center, perp, offset, rotation, labelSize } = frame;
-	for (const { side, designator, country, textAnchor } of units) {
+	for (const { side, designator, country, textAnchor, amplifierField } of units) {
 		let text;
 		if (designator.length > 0 && country.length > 0) text = `${designator} (${country})`;
 		else if (designator.length > 0) text = designator;
 		else if (country.length > 0) text = `(${country})`;
 		else continue;
-		pushLabel(out, vecAdd(center, vecScale(perp, side * offset)), text, rotation, labelSize, textAnchor);
+		pushLabel(out, vecAdd(center, vecScale(perp, side * offset)), text, rotation, labelSize, textAnchor, amplifierField);
 	}
 }
 /**
@@ -2199,7 +2135,7 @@ function labelSizeProps(options) {
 	return {};
 }
 /** Pushes a `part: "label"` Point feature at projected `point`. */
-function pushLabel(out, point, text, rotation, sizeProps, textAnchor) {
+function pushLabel(out, point, text, rotation, sizeProps, textAnchor, amplifierField) {
 	out.push({
 		type: "Feature",
 		properties: {
@@ -2207,6 +2143,7 @@ function pushLabel(out, point, text, rotation, sizeProps, textAnchor) {
 			text,
 			rotation,
 			...textAnchor ? { textAnchor } : {},
+			...amplifierField ? { amplifierField } : {},
 			...sizeProps
 		},
 		geometry: {
@@ -2349,16 +2286,662 @@ function fixedLabelLineFeatures(positions, options, textForEnd) {
 	};
 }
 //#endregion
-//#region src/internal/area-labels.ts
-/** Stored label rotation for horizontal (screen-upright) area text — adapters
-*  render feature rotation as `π − rotation`, so `π` renders as `0`. Exported
-*  for reuse by measures that place a horizontal label outside the area's
-*  boundary (e.g. Airfield Zone's Field H). */
-const HORIZONTAL_LABEL_ROTATION = Math.PI;
-/** Row pitch, as a ratio of the resolved label height, between stacked
-*  name/H/W-W1 rows (see {@link pushAreaLabels}). */
-const ROW_PITCH_RATIO = 1.2;
-/** Clearance, as a ratio of the resolved label height, added on top of each
+//#region src/generators/cm14-maneuver-lines/direction-of-attack-shared.ts
+const DEFAULT_DIRECTION_ARROWHEAD_LENGTH_RATIO = .12;
+const DEFAULT_DIRECTION_ARROWHEAD_WIDTH_RATIO = 1.15;
+const DEFAULT_DIRECTION_LABEL_POSITION = .5;
+/** Approximate sans-serif character width/height ratio used for the T knockout. */
+const LABEL_CHAR_ASPECT_RATIO = .6;
+/** Clear space on each side of T, as a ratio of the resolved label height. */
+const LABEL_GAP_CLEARANCE_RATIO = .3;
+function nonNegative$1(value, fallback) {
+	return Number.isFinite(value) ? Math.max(0, value) : fallback;
+}
+/** Resolves an along-line position option onto the valid tail-to-tip range. */
+function clampLinePosition(value, fallback) {
+	return Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : fallback;
+}
+/** Arc-length knockout centered on an along-route text label. */
+function directionLabelGap(totalLength, fraction, text, options) {
+	if (!text) return void 0;
+	const textHeight = resolveLabelOffsetMeters(options, 1);
+	const textWidth = text.length * LABEL_CHAR_ASPECT_RATIO * textHeight;
+	const clearance = (LABEL_GAP_CLEARANCE_RATIO + Math.max(0, options.labelPadding ?? 0)) * textHeight;
+	const halfGap = textWidth / 2 + clearance;
+	const center = fraction * totalLength;
+	return {
+		g0: Math.max(0, center - halfGap),
+		g1: Math.min(totalLength, center + halfGap)
+	};
+}
+function createDirectionOfAttackLine(coordinates, options, textAmplifiers, config) {
+	const verts = smoothLineVerts(coordinates.slice().reverse().map((position) => project(position[0], position[1])), options, 12);
+	const { segments, totalLength } = polylineSegments(verts);
+	if (segments.length === 0) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const last = segments[segments.length - 1];
+	const tip = vecAdd(last.start, vecScale(last.along, last.length));
+	const length = Math.min(totalLength, totalLength * nonNegative$1(options.arrowheadLengthRatio, DEFAULT_DIRECTION_ARROWHEAD_LENGTH_RATIO));
+	const innerHalfWidth = length * nonNegative$1(options.arrowheadWidthRatio, DEFAULT_DIRECTION_ARROWHEAD_WIDTH_RATIO) / 2;
+	const base = vecSub(tip, vecScale(last.along, length));
+	const innerLeft = vecAdd(base, vecScale(last.perp, innerHalfWidth));
+	const innerRight = vecSub(base, vecScale(last.perp, innerHalfWidth));
+	const arrowhead = config.outlineRatio ? (() => {
+		const ratio = Math.max(0, config.outlineRatio);
+		const outerHalfWidth = innerHalfWidth * (1 + ratio);
+		const outerLeft = vecAdd(base, vecScale(last.perp, outerHalfWidth));
+		return [
+			innerLeft,
+			tip,
+			innerRight,
+			vecSub(base, vecScale(last.perp, outerHalfWidth)),
+			vecAdd(tip, vecScale(last.along, length * ratio)),
+			outerLeft,
+			innerLeft
+		];
+	})() : [
+		innerLeft,
+		tip,
+		innerRight
+	];
+	const labelPosition = clampLinePosition(options.labelPosition, DEFAULT_DIRECTION_LABEL_POSITION);
+	const labelGap = directionLabelGap(totalLength, labelPosition, textAmplifiers.T, options);
+	const lines = [...buildGappedLine(verts, labelGap ? [labelGap] : []), arrowhead.map((point) => unproject(point[0], point[1]))];
+	const features = [{
+		type: "Feature",
+		properties: { part: config.part },
+		geometry: {
+			type: "MultiLineString",
+			coordinates: lines
+		}
+	}];
+	const frame = pointAlongPolyline(segments, totalLength, labelPosition);
+	if (!frame) return {
+		type: "FeatureCollection",
+		features
+	};
+	const labels = [];
+	const rotation = labelRotationAlong(frame.along);
+	const sizeProps = labelSizeProps(options);
+	if (textAmplifiers.T) pushLabel(labels, frame.point, textAmplifiers.T, rotation, sizeProps, void 0, "T");
+	const rowOffset = resolveLabelOffsetMeters(options, 1 + Math.max(0, options.labelPadding ?? 0));
+	if (textAmplifiers.W) pushLabel(labels, vecSub(frame.point, vecScale(frame.perp, rowOffset)), textAmplifiers.W, rotation, sizeProps, void 0, "W");
+	if (textAmplifiers.W1) pushLabel(labels, vecSub(frame.point, vecScale(frame.perp, rowOffset * 2)), textAmplifiers.W1, rotation, sizeProps, void 0, "W1");
+	features.push(...labels);
+	return {
+		type: "FeatureCollection",
+		features
+	};
+}
+const DIRECTION_OF_ATTACK_PARAMS = [
+	{
+		key: "arrowheadLengthRatio",
+		label: "Arrowhead length",
+		description: "Arrowhead length as a ratio of the route's total length",
+		type: "number",
+		min: .01,
+		max: .5,
+		step: .01
+	},
+	{
+		key: "arrowheadWidthRatio",
+		label: "Arrowhead width",
+		description: "Arrowhead total width as a ratio of its length",
+		type: "number",
+		min: .1,
+		max: 2,
+		step: .05
+	},
+	{
+		key: "labelPosition",
+		label: "Label position",
+		description: "Position of the T/W/W1 group along the route, from tail (0) to tip (1)",
+		type: "number",
+		min: 0,
+		max: 1,
+		step: .01
+	},
+	{
+		key: "labelPadding",
+		label: "Label padding",
+		description: "Extra spacing between the route and the date-time rows, in label heights",
+		type: "number",
+		min: 0,
+		max: 2,
+		step: .05
+	}
+];
+const DIRECTION_OF_ATTACK_TEXT_AMPLIFIERS = [
+	{
+		key: "T",
+		label: "Unique designation",
+		description: "Field T — the attack route's unique designation.",
+		placeholder: "MAIN",
+		maxLength: 21
+	},
+	{
+		key: "W",
+		label: "Start date-time group",
+		description: "Field W — the route's start date-time group.",
+		placeholder: "080400ZOCT2008"
+	},
+	{
+		key: "W1",
+		label: "End date-time group",
+		description: "Field W1 — the route's end date-time group.",
+		placeholder: "120300ZOCT2008"
+	}
+];
+const DIRECTION_OF_ATTACK_PREVIEW_TEXT = {
+	W: "080400ZOCT2008",
+	W1: "120300ZOCT2008"
+};
+//#endregion
+//#region src/generators/cm14-maneuver-lines/direction-of-attack-aviation.ts
+const DEFAULT_ARROWHEAD_LENGTH_RATIO$1 = .12;
+const DEFAULT_ARROWHEAD_WIDTH_RATIO$1 = 1.15;
+const DEFAULT_BOW_TIE_LENGTH_RATIO = .1;
+const DEFAULT_BOW_TIE_WIDTH_RATIO = .5;
+const DEFAULT_BOW_TIE_POSITION = 1 / 3;
+const DEFAULT_LABEL_POSITION = 2 / 3;
+const DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS = {
+	arrowheadLengthRatio: DEFAULT_ARROWHEAD_LENGTH_RATIO$1,
+	arrowheadWidthRatio: DEFAULT_ARROWHEAD_WIDTH_RATIO$1,
+	bowTieLengthRatio: DEFAULT_BOW_TIE_LENGTH_RATIO,
+	bowTieWidthRatio: DEFAULT_BOW_TIE_WIDTH_RATIO,
+	bowTiePosition: DEFAULT_BOW_TIE_POSITION,
+	labelPosition: DEFAULT_LABEL_POSITION,
+	labelPadding: 0,
+	smooth: false,
+	smoothResolution: 12
+};
+const DIRECTION_OF_ATTACK_AVIATION_METADATA = {
+	id: "direction-of-attack-aviation",
+	name: "Direction of Attack — Airborne/Aviation",
+	description: "The direction or route of an airborne or aviation attack.",
+	entity: "Maneuver Lines",
+	entityType: "Direction of Attack",
+	entitySubtype: "Airborne/Aviation",
+	value: "140601",
+	minCoordinates: 2,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	drawRule: "Line1",
+	capturesLabelSize: true,
+	params: [
+		...SMOOTH_LINE_PARAMS,
+		{
+			key: "arrowheadLengthRatio",
+			label: "Arrowhead length",
+			description: "Arrowhead length as a ratio of the route's total length",
+			type: "number",
+			min: .01,
+			max: .5,
+			step: .01
+		},
+		{
+			key: "arrowheadWidthRatio",
+			label: "Arrowhead width",
+			description: "Arrowhead total width as a ratio of its length",
+			type: "number",
+			min: .1,
+			max: 2,
+			step: .05
+		},
+		{
+			key: "bowTieLengthRatio",
+			label: "Bow-tie length",
+			description: "Aviation mark length as a ratio of the route's total length",
+			type: "number",
+			min: .02,
+			max: .3,
+			step: .01
+		},
+		{
+			key: "bowTieWidthRatio",
+			label: "Bow-tie width",
+			description: "Aviation mark total width as a ratio of its length",
+			type: "number",
+			min: .1,
+			max: 1.5,
+			step: .05
+		},
+		{
+			key: "bowTiePosition",
+			label: "Bow-tie position",
+			description: "Position of the aviation mark along the route, from tail (0) to tip (1)",
+			type: "number",
+			min: 0,
+			max: 1,
+			step: .01
+		},
+		{
+			key: "labelPosition",
+			label: "Label position",
+			description: "Position of the T/W/W1 group along the route, from tail (0) to tip (1)",
+			type: "number",
+			min: 0,
+			max: 1,
+			step: .01
+		},
+		{
+			key: "labelPadding",
+			label: "Label padding",
+			description: "Extra spacing between the route and the date-time rows, in label heights",
+			type: "number",
+			min: 0,
+			max: 2,
+			step: .05
+		}
+	],
+	textAmplifiers: [
+		{
+			key: "T",
+			label: "Unique designation",
+			description: "Field T — the attack route's unique designation.",
+			placeholder: "AVON",
+			maxLength: 21
+		},
+		{
+			key: "W",
+			label: "Start date-time group",
+			description: "Field W — the route's start date-time group.",
+			placeholder: "080400ZOCT2008"
+		},
+		{
+			key: "W1",
+			label: "End date-time group",
+			description: "Field W1 — the route's end date-time group.",
+			placeholder: "120300ZOCT2008"
+		}
+	]
+};
+function nonNegative(value, fallback) {
+	return Number.isFinite(value) ? Math.max(0, value) : fallback;
+}
+function pointAtDistance(verts, distance) {
+	let walked = 0;
+	for (let i = 0; i < verts.length - 1; i++) {
+		const a = verts[i];
+		const delta = vecSub(verts[i + 1], a);
+		const length = vecMag(delta);
+		if (length < 1e-6) continue;
+		if (distance <= walked + length) return vecAdd(a, vecScale(delta, (distance - walked) / length));
+		walked += length;
+	}
+	return verts[verts.length - 1];
+}
+/** Builds the route, aviation bow-tie, arrowhead, and optional T/W/W1 labels. */
+function createDirectionOfAttackAviation(coordinates, options = {}, textAmplifiers = {}) {
+	const resolved = {
+		...DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS,
+		...options
+	};
+	const verts = smoothLineVerts(coordinates.slice().reverse().map((position) => project(position[0], position[1])), resolved, 12);
+	const { segments, totalLength } = polylineSegments(verts);
+	if (segments.length === 0 || totalLength < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const bowTieLength = Math.min(totalLength, totalLength * nonNegative(resolved.bowTieLengthRatio, DEFAULT_BOW_TIE_LENGTH_RATIO));
+	const bowTiePosition = clampLinePosition(resolved.bowTiePosition, DEFAULT_BOW_TIE_POSITION);
+	const labelPosition = clampLinePosition(resolved.labelPosition, DEFAULT_LABEL_POSITION);
+	const bowTieCenterDistance = totalLength * bowTiePosition;
+	const bowTieStartDistance = Math.max(0, bowTieCenterDistance - bowTieLength / 2);
+	const bowTieEndDistance = Math.min(totalLength, bowTieCenterDistance + bowTieLength / 2);
+	const bowTieStart = pointAtDistance(verts, bowTieStartDistance);
+	const bowTieEnd = pointAtDistance(verts, bowTieEndDistance);
+	const last = segments[segments.length - 1];
+	const tip = vecAdd(last.start, vecScale(last.along, last.length));
+	const arrowheadLength = Math.min(totalLength * nonNegative(resolved.arrowheadLengthRatio, DEFAULT_ARROWHEAD_LENGTH_RATIO$1), totalLength);
+	const arrowheadHalfWidth = arrowheadLength * nonNegative(resolved.arrowheadWidthRatio, DEFAULT_ARROWHEAD_WIDTH_RATIO$1) / 2;
+	const arrowBase = vecSub(tip, vecScale(last.along, arrowheadLength));
+	const arrowLeft = vecAdd(arrowBase, vecScale(last.perp, arrowheadHalfWidth));
+	const arrowRight = vecSub(arrowBase, vecScale(last.perp, arrowheadHalfWidth));
+	if (!bowTieStart || !bowTieEnd) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const bowTieAlong = vecNorm(vecSub(bowTieEnd, bowTieStart));
+	if (vecMag(bowTieAlong) < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const bowTiePerp = [-bowTieAlong[1], bowTieAlong[0]];
+	const bowTieHalfWidth = bowTieLength * nonNegative(resolved.bowTieWidthRatio, DEFAULT_BOW_TIE_WIDTH_RATIO) / 2;
+	const bowTieA = vecAdd(bowTieStart, vecScale(bowTiePerp, bowTieHalfWidth));
+	const bowTieB = vecSub(bowTieStart, vecScale(bowTiePerp, bowTieHalfWidth));
+	const bowTieC = vecAdd(bowTieEnd, vecScale(bowTiePerp, bowTieHalfWidth));
+	const bowTieD = vecSub(bowTieEnd, vecScale(bowTiePerp, bowTieHalfWidth));
+	const labelGap = directionLabelGap(totalLength, labelPosition, textAmplifiers.T, resolved);
+	const features = [{
+		type: "Feature",
+		properties: { part: "direction-of-attack-aviation" },
+		geometry: {
+			type: "MultiLineString",
+			coordinates: [
+				...buildGappedLine(verts, [{
+					g0: bowTieStartDistance,
+					g1: bowTieEndDistance
+				}, ...labelGap ? [labelGap] : []]),
+				[
+					arrowLeft,
+					tip,
+					arrowRight
+				].map((point) => unproject(point[0], point[1])),
+				[
+					bowTieA,
+					bowTieB,
+					bowTieC,
+					bowTieD,
+					bowTieA
+				].map((point) => unproject(point[0], point[1]))
+			]
+		}
+	}];
+	const labelFrame = pointAlongPolyline(segments, totalLength, labelPosition);
+	if (labelFrame) {
+		const labels = [];
+		const rotation = labelRotationAlong(labelFrame.along);
+		const sizeProps = labelSizeProps(resolved);
+		if (textAmplifiers.T) pushLabel(labels, labelFrame.point, textAmplifiers.T, rotation, sizeProps, void 0, "T");
+		const rowOffset = resolveLabelOffsetMeters(resolved, 1 + Math.max(0, resolved.labelPadding ?? 0));
+		if (textAmplifiers.W) pushLabel(labels, vecSub(labelFrame.point, vecScale(labelFrame.perp, rowOffset)), textAmplifiers.W, rotation, sizeProps, void 0, "W");
+		if (textAmplifiers.W1) pushLabel(labels, vecSub(labelFrame.point, vecScale(labelFrame.perp, rowOffset * 2)), textAmplifiers.W1, rotation, sizeProps, void 0, "W1");
+		features.push(...labels);
+	}
+	return {
+		type: "FeatureCollection",
+		features
+	};
+}
+const DIRECTION_OF_ATTACK_AVIATION = defineControlMeasure({
+	metadata: DIRECTION_OF_ATTACK_AVIATION_METADATA,
+	generator: createDirectionOfAttackAviation,
+	defaultOptions: DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS,
+	rule: line1DrawRule,
+	previewSample: {
+		controlPoints: [[1, 0], [-1, 0]],
+		textAmplifiers: {
+			T: "AVON",
+			W: "080400ZOCT2008",
+			W1: "120300ZOCT2008"
+		},
+		options: { labelSize: 80 }
+	}
+});
+//#endregion
+//#region src/generators/cm14-maneuver-lines/direction-of-main-attack.ts
+const DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS = {
+	arrowheadLengthRatio: DEFAULT_DIRECTION_ARROWHEAD_LENGTH_RATIO,
+	arrowheadWidthRatio: DEFAULT_DIRECTION_ARROWHEAD_WIDTH_RATIO,
+	arrowheadOutlineRatio: .3,
+	labelPosition: DEFAULT_DIRECTION_LABEL_POSITION,
+	labelPadding: 0,
+	smooth: false,
+	smoothResolution: 12
+};
+const DIRECTION_OF_MAIN_ATTACK_METADATA = {
+	id: "direction-of-main-attack",
+	name: "Direction of Main Attack",
+	description: "The direction or route of the primary attack.",
+	entity: "Maneuver Lines",
+	entityType: "Direction of Attack",
+	entitySubtype: "Main Attack",
+	value: "140602",
+	minCoordinates: 2,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	drawRule: "Line1",
+	capturesLabelSize: true,
+	params: [
+		...SMOOTH_LINE_PARAMS,
+		...DIRECTION_OF_ATTACK_PARAMS,
+		{
+			key: "arrowheadOutlineRatio",
+			label: "Arrowhead outline",
+			description: "Outlined arrowhead thickness as a ratio of its length",
+			type: "number",
+			min: .05,
+			max: .75,
+			step: .05
+		}
+	],
+	textAmplifiers: DIRECTION_OF_ATTACK_TEXT_AMPLIFIERS
+};
+function createDirectionOfMainAttack(coordinates, options = {}, textAmplifiers = {}) {
+	const resolved = {
+		...DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS,
+		...options
+	};
+	return createDirectionOfAttackLine(coordinates, resolved, textAmplifiers, {
+		part: "direction-of-main-attack",
+		outlineRatio: resolved.arrowheadOutlineRatio
+	});
+}
+const DIRECTION_OF_MAIN_ATTACK = defineControlMeasure({
+	metadata: DIRECTION_OF_MAIN_ATTACK_METADATA,
+	generator: createDirectionOfMainAttack,
+	defaultOptions: DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS,
+	rule: line1DrawRule,
+	previewSample: {
+		controlPoints: [[1, 0], [-1, 0]],
+		textAmplifiers: {
+			T: "MAIN",
+			...DIRECTION_OF_ATTACK_PREVIEW_TEXT
+		},
+		options: { labelSize: 80 }
+	}
+});
+//#endregion
+//#region src/generators/cm14-maneuver-lines/direction-of-supporting-attack.ts
+const DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS = {
+	arrowheadLengthRatio: DEFAULT_DIRECTION_ARROWHEAD_LENGTH_RATIO,
+	arrowheadWidthRatio: DEFAULT_DIRECTION_ARROWHEAD_WIDTH_RATIO,
+	labelPosition: DEFAULT_DIRECTION_LABEL_POSITION,
+	labelPadding: 0,
+	smooth: false,
+	smoothResolution: 12
+};
+const DIRECTION_OF_SUPPORTING_ATTACK_METADATA = {
+	id: "direction-of-supporting-attack",
+	name: "Direction of Supporting Attack",
+	description: "The direction or route of an attack that supports the main effort.",
+	entity: "Maneuver Lines",
+	entityType: "Direction of Attack",
+	entitySubtype: "Supporting Attack",
+	value: "140603",
+	minCoordinates: 2,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	drawRule: "Line1",
+	capturesLabelSize: true,
+	params: [...SMOOTH_LINE_PARAMS, ...DIRECTION_OF_ATTACK_PARAMS],
+	textAmplifiers: DIRECTION_OF_ATTACK_TEXT_AMPLIFIERS
+};
+function createDirectionOfSupportingAttack(coordinates, options = {}, textAmplifiers = {}) {
+	return createDirectionOfAttackLine(coordinates, {
+		...DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS,
+		...options
+	}, textAmplifiers, { part: "direction-of-supporting-attack" });
+}
+const DIRECTION_OF_SUPPORTING_ATTACK = defineControlMeasure({
+	metadata: DIRECTION_OF_SUPPORTING_ATTACK_METADATA,
+	generator: createDirectionOfSupportingAttack,
+	defaultOptions: DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS,
+	rule: line1DrawRule,
+	previewSample: {
+		controlPoints: [[1, 0], [-1, 0]],
+		textAmplifiers: {
+			T: "YALU",
+			...DIRECTION_OF_ATTACK_PREVIEW_TEXT
+		},
+		options: { labelSize: 80 }
+	}
+});
+//#endregion
+//#region src/internal/area-echelon.ts
+/**
+* Twice the ring's signed area (shoelace). Positive when the ring winds
+* counter-clockwise in projected (y-up) coordinates. Exported for reuse by
+* `area-labels.ts`'s polygon-centroid label placement, so the area centroid
+* shares this one derivation instead of re-deriving it.
+*/
+function ringSignedArea2(verts) {
+	let area2 = 0;
+	for (let i = 0; i < verts.length - 1; i++) {
+		const a = verts[i];
+		const b = verts[i + 1];
+		area2 += a[0] * b[1] - b[0] * a[1];
+	}
+	return area2;
+}
+/**
+* Projects `positions` and returns a closed ring (first == last), optionally
+* smoothed through the control points with a closed centripetal Catmull-Rom
+* spline. A trailing vertex that duplicates the first (already-closed input)
+* is dropped before closing/smoothing.
+*/
+function buildClosedRing(positions, smooth, smoothResolution, defaultSmoothResolution) {
+	const projected = positions.map((p) => project(p[0], p[1]));
+	const ringPts = projected.length > 1 && Math.abs(projected[0][0] - projected[projected.length - 1][0]) < 1e-6 && Math.abs(projected[0][1] - projected[projected.length - 1][1]) < 1e-6 ? projected.slice(0, -1) : projected;
+	return smooth ? closedCatmullRom(ringPts, normalizeSmoothResolution$2(smoothResolution, defaultSmoothResolution)) : [...ringPts, ringPts[0]];
+}
+/**
+* Walks a closed ring into per-segment metadata (unit direction, outward
+* normal, cumulative arc length) plus the total perimeter and the arc-length
+* anchor of the bottom edge — the segment whose midpoint sits lowest (min
+* projected y), the side opposite the front.
+*/
+function buildAreaPerimeter(verts) {
+	const ccw = ringSignedArea2(verts) > 0;
+	const segs = [];
+	let totalLength = 0;
+	let anchorTarget = 0;
+	let lowest = Infinity;
+	for (let i = 0; i < verts.length - 1; i++) {
+		const a = verts[i];
+		const b = verts[i + 1];
+		const edge = vecSub(b, a);
+		const length = vecMag(edge);
+		if (length < 1e-6) continue;
+		const along = vecNorm(edge);
+		const mid = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+		const perp = ccw ? [along[1], -along[0]] : [-along[1], along[0]];
+		segs.push({
+			start: a,
+			along,
+			perp,
+			length,
+			arcStart: totalLength
+		});
+		if (mid[1] < lowest) {
+			lowest = mid[1];
+			anchorTarget = totalLength + length / 2;
+		}
+		totalLength += length;
+	}
+	return {
+		verts,
+		segs,
+		totalLength,
+		anchorTarget
+	};
+}
+/** Resolves the arc-length `target` to a point and the segment frame it lands on. */
+function pointOnRing(segs, target) {
+	let seg = segs[segs.length - 1];
+	for (const candidate of segs) if (target < candidate.arcStart + candidate.length) {
+		seg = candidate;
+		break;
+	}
+	return {
+		point: vecAdd(seg.start, vecScale(seg.along, target - seg.arcStart)),
+		seg
+	};
+}
+/**
+* Effective echelon glyph height in meters. Screen-anchored when a pixel size
+* is supplied with a live resolution; ground-anchored (meters) otherwise.
+* Clamped strictly positive.
+*/
+function resolveEchelonHeight(echelonSize, echelonSizePixels, metersPerPixel) {
+	let h = echelonSize;
+	if (echelonSizePixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0) h = echelonSizePixels * metersPerPixel;
+	return Math.max(EPSILON, h);
+}
+/** Wraps `x` into `[0, 1)`, treating `x` as a fraction (matches the arc-length wrap below). */
+function wrap01(x) {
+	return (x % 1 + 1) % 1;
+}
+/**
+* Places the Field B echelon glyph on the perimeter and computes its masking
+* gap, anchored by default to the bottom edge and slid by `echelonPosition`
+* (a signed fraction of the perimeter, wrapping at the seam). When
+* `echelonAnchor` is supplied, it replaces the bottom-edge anchor with an
+* absolute perimeter fraction (measured from the ring seam) — see
+* `BattlePositionOptions.echelonAnchor` for why (ADR-0023 rotate-freeze).
+* Returns empty geometry when the echelon resolves to none or the ring is
+* degenerate.
+*/
+function placeEchelon(perimeter, h, echelon, echelonPadding, echelonPosition, echelonAnchor) {
+	const { segs, totalLength, anchorTarget } = perimeter;
+	const spec = resolveEchelon(echelon);
+	if (!spec || segs.length === 0 || totalLength < 1e-6) return {
+		strokes: [],
+		fills: [],
+		gaps: []
+	};
+	const target = (((echelonAnchor !== void 0 ? wrap01(echelonAnchor) * totalLength : anchorTarget) + echelonPosition * totalLength) % totalLength + totalLength) % totalLength;
+	const { point, seg } = pointOnRing(segs, target);
+	const { strokes, fills, width } = buildEchelonGlyph(point, seg.along, seg.perp, h, spec);
+	const gaps = [];
+	const halfGap = width / 2 + Math.max(0, echelonPadding) * h;
+	pushWrappedGap(gaps, target - halfGap, target + halfGap, totalLength);
+	return {
+		strokes,
+		fills,
+		gaps
+	};
+}
+/**
+* Factory for the `freezeOrientation` hook (ADR-0023) shared by every
+* echelon-carrying closed-area measure (Battle Position, Strong Point, Base
+* Camp, Guerrilla Base): pins the echelon anchor to its current bottom-edge
+* fraction so a subsequent rigid rotation of `controlPoints` (e.g. the
+* transform box's rotate grip) does not re-derive a different "bottom edge"
+* against the rotated geometry. `defaults` supplies the measure's own
+* `echelon`/`smooth`/`smoothResolution` defaults, since each measure's
+* `DEFAULT_*_OPTIONS` differ (e.g. Battle Position's `echelon: "battalion"`
+* vs. Base Camp/Guerrilla Base's `echelon: "none"`).
+*
+* The returned hook returns `undefined` — nothing to freeze — when:
+*  - `echelonAnchor` is already set (previously frozen or user-authored), or
+*  - the echelon resolves to none (nothing visible to pin), or
+*  - the ring is degenerate (no segments, or a near-zero perimeter).
+*/
+function makeFreezeEchelonAnchor(defaults) {
+	return function freezeEchelonAnchor(controlPoints, options) {
+		if (options.echelonAnchor !== void 0) return void 0;
+		if (!resolveEchelon(options.echelon ?? defaults.echelon)) return void 0;
+		const perimeter = buildAreaPerimeter(buildClosedRing(controlPoints, options.smooth ?? defaults.smooth, options.smoothResolution ?? defaults.smoothResolution, defaults.smoothResolution));
+		if (perimeter.segs.length === 0 || perimeter.totalLength < 1e-6) return void 0;
+		return { echelonAnchor: perimeter.anchorTarget / perimeter.totalLength };
+	};
+}
+//#endregion
+//#region src/internal/area-labels.ts
+/** Stored label rotation for horizontal (screen-upright) area text — adapters
+*  render feature rotation as `π − rotation`, so `π` renders as `0`. Exported
+*  for reuse by measures that place a horizontal label outside the area's
+*  boundary (e.g. Airfield Zone's Field H). */
+const HORIZONTAL_LABEL_ROTATION = Math.PI;
+/** Row pitch, as a ratio of the resolved label height, between stacked
+*  name/H/W-W1 rows (see {@link pushAreaLabels}). */
+const ROW_PITCH_RATIO = 1.2;
+/** Clearance, as a ratio of the resolved label height, added on top of each
 *  ENY marker's own half-width/half-height when carving its boundary
 *  knockout gap (see {@link pushAreaLabels}). */
 const ENY_CLEARANCE_RATIO = .3;
@@ -2431,12 +3014,6 @@ function ringCentroid(verts) {
 	const factor = 1 / (3 * area2);
 	return [cx * factor, cy * factor];
 }
-/** Joins the W/W1 date-time-group pair as `"W - W1"`; a single supplied value
-*  passes through unchanged; neither set yields `""`. */
-function joinDtg(start, end) {
-	if (start && end) return `${start} - ${end}`;
-	return start ?? end ?? "";
-}
 /**
 * Points where the closed ring `verts` crosses the horizontal line
 * `y = target`, one per crossing edge, plus the ring's total arc length —
@@ -2480,7 +3057,7 @@ function ringCrossingsAtY(verts, target) {
 * {@link buildGappedLine} uses) an "ENY" marker knocks out of the boundary —
 * empty unless `texts.hostile` was placed.
 *
-* Rows are `[name, additionalInformation, joinDtg(dtgStart, dtgEnd)]`,
+* Rows are `[name (T), additionalInformation (H), dtgStart (W), dtgEnd (W1)]`,
 * filtered to non-empty text, stacked around the ring's {@link ringCentroid}
 * at `pitch = resolveLabelOffsetMeters(options, 1.2 + labelPadding)` (the 50m
 * no-size fallback applies until a live label size is captured — see
@@ -2514,14 +3091,18 @@ function pushAreaLabels(out, ringVerts, texts, options = {}) {
 	const padding = Math.max(0, options.labelPadding ?? 0);
 	const [cx, cy] = ringCentroid(ringVerts);
 	const rows = [
-		texts.name,
-		texts.additionalInformation,
-		joinDtg(texts.dtgStart, texts.dtgEnd)
-	].filter((s) => Boolean(s && s.length > 0));
+		[texts.name, "T"],
+		[texts.additionalInformation, "H"],
+		[texts.dtgStart, "W"],
+		[texts.dtgEnd, "W1"]
+	].flatMap(([text, field]) => text ? [{
+		text,
+		field
+	}] : []);
 	if (rows.length > 0) {
 		const pitch = resolveLabelOffsetMeters(options, ROW_PITCH_RATIO + padding);
-		rows.forEach((text, i) => {
-			pushLabel(out, [cx, cy + ((rows.length - 1) / 2 - i) * pitch], text, HORIZONTAL_LABEL_ROTATION, sizeProps);
+		rows.forEach(({ text, field }, i) => {
+			pushLabel(out, [cx, cy + ((rows.length - 1) / 2 - i) * pitch], text, HORIZONTAL_LABEL_ROTATION, sizeProps, void 0, field);
 		});
 	}
 	const gaps = [];
@@ -2535,7 +3116,7 @@ function pushAreaLabels(out, ringVerts, texts, options = {}) {
 			const textWidth = texts.hostile.length * ENY_CHAR_ASPECT_RATIO * textHeight;
 			const clearance = (ENY_CLEARANCE_RATIO + padding) * textHeight;
 			for (const crossing of [west, east]) {
-				pushLabel(out, [crossing.x, cy], texts.hostile, HORIZONTAL_LABEL_ROTATION, sizeProps);
+				pushLabel(out, [crossing.x, cy], texts.hostile, HORIZONTAL_LABEL_ROTATION, sizeProps, void 0, "N");
 				const halfExtent = .5 * (textWidth * Math.abs(crossing.along[0]) + textHeight * Math.abs(crossing.along[1])) + clearance;
 				pushWrappedGap(gaps, crossing.arc - halfExtent, crossing.arc + halfExtent, totalArc);
 			}
@@ -2623,20 +3204,217 @@ const AREA_METADATA = {
 function createArea(positions, options = {}, textAmplifiers = {}) {
 	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, ""));
 }
-const AREA = defineControlMeasure({
-	metadata: AREA_METADATA,
-	generator: createArea,
-	defaultOptions: DEFAULT_AREA_OPTIONS,
-	rule: area1DrawRule,
+const AREA = defineControlMeasure({
+	metadata: AREA_METADATA,
+	generator: createArea,
+	defaultOptions: DEFAULT_AREA_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: {},
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
+//#region src/generators/cm15-maneuver-areas/area-defense.ts
+const DEFAULT_AREA_DEFENSE_OPTIONS = {
+	arrowOpeningAngle: 30,
+	labelOpeningAngle: 20,
+	barbCount: 6,
+	barbLengthRatio: .16,
+	arrowheadLengthRatio: .18
+};
+const AREA_DEFENSE_METADATA = {
+	id: "area-defense",
+	name: "Area Defense",
+	description: "A defensive posture oriented in all directions and focused on retaining specified terrain.",
+	entity: "Maneuver Areas",
+	entityType: "Area Defense",
+	value: "152600",
+	minCoordinates: 2,
+	maxCoordinates: 2,
+	geometry: "area",
+	geometryTypes: [
+		"MultiLineString",
+		"MultiPolygon",
+		"Point"
+	],
+	drawRule: "Area15",
+	capturesLabelSize: true,
+	params: [
+		{
+			key: "arrowOpeningAngle",
+			label: "Arrow opening",
+			description: "Angular opening between the two arrow tips, in degrees",
+			type: "number",
+			min: 5,
+			max: 120,
+			step: 1
+		},
+		{
+			key: "labelOpeningAngle",
+			label: "AD opening",
+			description: "Angular opening occupied by the AD label, in degrees",
+			type: "number",
+			min: 5,
+			max: 90,
+			step: 1
+		},
+		{
+			key: "barbCount",
+			label: "Barbs",
+			description: "Number of filled outward barbs distributed around the defense",
+			type: "number",
+			min: 2,
+			max: 20,
+			step: 1
+		},
+		{
+			key: "barbLengthRatio",
+			label: "Barb length",
+			description: "Barb height as a ratio of the symbol radius",
+			type: "number",
+			min: .02,
+			max: .5,
+			step: .01
+		},
+		{
+			key: "arrowheadLengthRatio",
+			label: "Arrowhead length",
+			description: "Open-arrowhead length as a ratio of the symbol radius",
+			type: "number",
+			min: .02,
+			max: .5,
+			step: .01
+		}
+	]
+};
+function pointOnCircle(center, radius, angle) {
+	return vecAdd(center, [radius * Math.cos(angle), radius * Math.sin(angle)]);
+}
+function sampleArc(center, radius, start, end) {
+	const span = end - start;
+	const segments = Math.max(8, Math.round(48 * Math.abs(span) / Math.PI));
+	return Array.from({ length: segments + 1 }, (_, index) => pointOnCircle(center, radius, start + span * index / segments));
+}
+function openArrowhead(tip, direction, length) {
+	const base = vecSub(tip, [direction[0] * length, direction[1] * length]);
+	const perp = [-direction[1], direction[0]];
+	return [
+		vecAdd(base, [perp[0] * length * .55, perp[1] * length * .55]),
+		tip,
+		vecSub(base, [perp[0] * length * .55, perp[1] * length * .55])
+	];
+}
+function createAreaDefense(coordinates, options = {}) {
+	const resolved = {
+		...DEFAULT_AREA_DEFENSE_OPTIONS,
+		...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 upperTipAngle = Math.atan2(radiusVector[1], radiusVector[0]);
+	const arrowHalf = Math.min(120, Math.max(5, resolved.arrowOpeningAngle)) * 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;
+	const upperEnd = upperTipAngle;
+	const lowerStart = labelCenter - labelHalf;
+	const lowerEnd = upperTipAngle + arrowHalf * 2 - Math.PI * 2;
+	const upperArc = sampleArc(center, radius, upperStart, upperEnd);
+	const lowerArc = sampleArc(center, radius, lowerStart, lowerEnd);
+	const arrowLength = radius * Math.max(0, resolved.arrowheadLengthRatio);
+	const upperDirection = [-Math.sin(upperEnd), Math.cos(upperEnd)];
+	const lowerDirection = [Math.sin(lowerEnd), -Math.cos(lowerEnd)];
+	const lineParts = [
+		upperArc,
+		lowerArc,
+		openArrowhead(upperArc.at(-1), upperDirection, arrowLength),
+		openArrowhead(lowerArc.at(-1), lowerDirection, arrowLength)
+	];
+	const barbCount = Math.max(2, Math.round(resolved.barbCount));
+	const barbLength = radius * Math.max(0, resolved.barbLengthRatio);
+	const barbHalfAngle = Math.asin(Math.min(1, barbLength / 2 / radius));
+	const barbArcs = [{
+		start: upperStart,
+		end: upperEnd,
+		count: Math.ceil(barbCount / 2)
+	}, {
+		start: lowerStart,
+		end: lowerEnd,
+		count: Math.floor(barbCount / 2)
+	}];
+	const barbPolygons = [];
+	for (const arc of barbArcs) for (let ordinal = 1; ordinal <= arc.count; ordinal++) {
+		const angle = arc.start + (arc.end - arc.start) * ordinal / (arc.count + 1);
+		const left = pointOnCircle(center, radius, angle - barbHalfAngle);
+		const right = pointOnCircle(center, radius, angle + barbHalfAngle);
+		const ring = [
+			left,
+			pointOnCircle(center, radius + barbLength, angle),
+			right,
+			left
+		].map((point) => unproject(point[0], point[1]));
+		barbPolygons.push([ring]);
+	}
+	const labelPoint = pointOnCircle(center, radius, labelCenter);
+	return {
+		type: "FeatureCollection",
+		features: [
+			{
+				type: "Feature",
+				properties: { part: "area-defense" },
+				geometry: {
+					type: "MultiLineString",
+					coordinates: lineParts.map((line) => line.map((point) => unproject(point[0], point[1])))
+				}
+			},
+			{
+				type: "Feature",
+				properties: {
+					part: "barbs",
+					fill: true
+				},
+				geometry: {
+					type: "MultiPolygon",
+					coordinates: barbPolygons
+				}
+			},
+			{
+				type: "Feature",
+				properties: {
+					part: "label",
+					labelPlacement: false,
+					text: "AD",
+					rotation: Math.PI,
+					...labelSizeProps(options)
+				},
+				geometry: {
+					type: "Point",
+					coordinates: unproject(labelPoint[0], labelPoint[1])
+				}
+			}
+		]
+	};
+}
+const AREA_DEFENSE = defineControlMeasure({
+	metadata: AREA_DEFENSE_METADATA,
+	generator: createAreaDefense,
+	defaultOptions: DEFAULT_AREA_DEFENSE_OPTIONS,
+	rule: centerRadiusDrawRule,
 	previewSample: {
-		controlPoints: [
-			[-1, -.5],
-			[1, -.5],
-			[1, .5],
-			[-1, .5]
-		],
-		textAmplifiers: {},
-		options: { labelSize: 96 }
+		controlPoints: [[0, 0], [-.77, .21]],
+		options: { labelSize: 90 }
 	}
 });
 //#endregion
@@ -2893,7 +3671,7 @@ function createAirfieldZone(positions, options = {}, textAmplifiers = {}) {
 	}
 	if (textAmplifiers.H) {
 		const labelFeatures = [];
-		pushLabel(labelFeatures, [maxX + H_LABEL_OFFSET_RATIO * resolveLabelOffsetMeters(labelOptions, 1), cy], textAmplifiers.H, HORIZONTAL_LABEL_ROTATION, labelSizeProps(labelOptions), "start");
+		pushLabel(labelFeatures, [maxX + H_LABEL_OFFSET_RATIO * resolveLabelOffsetMeters(labelOptions, 1), cy], textAmplifiers.H, HORIZONTAL_LABEL_ROTATION, labelSizeProps(labelOptions), "start", "H");
 		features.push(...labelFeatures);
 	}
 	return {
@@ -3339,7 +4117,11 @@ function generateAntitankDitchTriangles(projectedPoints, toothHeight, toothWidth
 * unchanged (no project/unproject round trip) when smoothing is off.
 */
 function smoothedDitchBasePath(positions, options) {
-	return smoothLineVerts(positions.map((position) => project(position[0], position[1])), options, 16);
+	const projectedPoints = positions.map((position) => project(position[0], position[1]));
+	const smoothedPath = smoothLineVerts(projectedPoints, options, 16);
+	const toothHeight = calculateAntitankDitchHeight(options);
+	const toothWidthRatio = Math.max(EPSILON, options.toothWidthRatio ?? DEFAULT_TOOTH_WIDTH_RATIO$1);
+	return options.smooth && projectedPoints.length >= 3 ? evenlySpacePath(smoothedPath, toothWidthRatio * toothHeight) : smoothedPath;
 }
 function buildAntitankDitchTriangles(basePath, options) {
 	return generateAntitankDitchTriangles(basePath, calculateAntitankDitchHeight(options), options.toothWidthRatio ?? DEFAULT_TOOTH_WIDTH_RATIO$1);
@@ -3447,6 +4229,8 @@ function createAntitankWall(positions, options = {}) {
 	const toothHeight = calculateAntitankDitchHeight(options);
 	const toothWidthRatio = options.toothWidthRatio ?? DEFAULT_TOOTH_WIDTH_RATIO;
 	const toothSpacingRatio = options.toothSpacingRatio ?? DEFAULT_TOOTH_SPACING_RATIO;
+	const projectedPoints = positions.map((position) => project(position[0], position[1]));
+	const smoothedPath = smoothLineVerts(projectedPoints, options, 16);
 	return {
 		type: "FeatureCollection",
 		features: [{
@@ -3454,7 +4238,7 @@ function createAntitankWall(positions, options = {}) {
 			properties: { part: "wall" },
 			geometry: {
 				type: "MultiLineString",
-				coordinates: [generateAntitankWallPoints(smoothLineVerts(positions.map((position) => project(position[0], position[1])), options, 16), toothHeight, toothWidthRatio, toothSpacingRatio).map((point) => unproject(point[0], point[1]))]
+				coordinates: [generateAntitankWallPoints(options.smooth && projectedPoints.length >= 3 ? evenlySpacePath(smoothedPath, Math.max(EPSILON, toothWidthRatio) * toothHeight) : smoothedPath, toothHeight, toothWidthRatio, toothSpacingRatio).map((point) => unproject(point[0], point[1]))]
 			}
 		}]
 	};
@@ -4716,11 +5500,13 @@ function createEngineerWorkLine(positions, options = {}, textAmplifiers = {}) {
 		const units = [{
 			side: 1,
 			designator: textAmplifiers.T ?? "",
-			country: textAmplifiers.AS ?? ""
+			country: textAmplifiers.AS ?? "",
+			amplifierField: "T"
 		}, {
 			side: -1,
 			designator: textAmplifiers.T1 ?? "",
-			country: textAmplifiers.AS1 ?? ""
+			country: textAmplifiers.AS1 ?? "",
+			amplifierField: "T1"
 		}];
 		const labelFeatures = [];
 		pushUnitLabels(labelFeatures, {
@@ -4920,6 +5706,7 @@ function createLabelFeature(point, text, rotation, labelSize = {}) {
 		type: "Feature",
 		properties: {
 			part: "label",
+			labelPlacement: false,
 			text,
 			rotation,
 			...labelSizeProps(labelSize)
@@ -5020,7 +5807,7 @@ const DEFAULT_BLOCK_MISSION_TASK_OPTIONS = { labelGapRatio: .2 };
 const BLOCK_MISSION_TASK_METADATA = {
 	id: "block-mission-task",
 	name: "Block",
-	description: "A tactical mission task that denies the enemy access to an area or prevents enemy advance in a direction or along an avenue of approach.",
+	description: "Denies the enemy access to an area or prevents the enemy's advance in a direction or along an avenue of approach.",
 	entity: "Mission Tasks",
 	entityType: "Block",
 	value: "340100",
@@ -5112,7 +5899,7 @@ const DEFAULT_BREACH_OPTIONS = {
 const BREACH_METADATA = {
 	id: "breach",
 	name: "Breach",
-	description: "A tactical mission task in which a unit breaks through or establishes a passage through an enemy obstacle.",
+	description: "Employs all available means to break through or secure a passage through an enemy defense, obstacle, minefield, or fortification.",
 	entity: "Mission Tasks",
 	entityType: "Breach",
 	value: "340200",
@@ -5208,7 +5995,7 @@ const DEFAULT_BYPASS_OPTIONS = {
 const BYPASS_METADATA = {
 	id: "bypass",
 	name: "Bypass",
-	description: "A tactical mission task in which a unit maneuvers around an obstacle, position, or enemy force to maintain the momentum of the operation.",
+	description: "Maneuvers around an obstacle, position, or enemy force to maintain the momentum of the operation.",
 	entity: "Mission Tasks",
 	entityType: "Bypass",
 	value: "340300",
@@ -5283,7 +6070,7 @@ const DEFAULT_CANALIZE_OPTIONS = {
 const CANALIZE_METADATA = {
 	id: "canalize",
 	name: "Canalize",
-	description: "Canalize is a tactical mission task in which a unit restricts enemy movement to a narrow zone",
+	description: "Restricts enemy movement to a narrow zone by exploiting terrain coupled with the use of obstacles, fires, or friendly maneuver.",
 	entity: "Mission Tasks",
 	entityType: "Canalize",
 	value: "340400",
@@ -5904,184 +6691,576 @@ function createGenericRectangle(coordinates, options = {}) {
 		p1
 	].map((point) => unproject(point[0], point[1]));
 	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {
-				part: "rectangle",
-				fill
-			},
-			geometry: {
-				type: "Polygon",
-				coordinates: [ring]
-			}
-		}]
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: {
+				part: "rectangle",
+				fill
+			},
+			geometry: {
+				type: "Polygon",
+				coordinates: [ring]
+			}
+		}]
+	};
+}
+const GENERIC_RECTANGLE = defineControlMeasure({
+	metadata: GENERIC_RECTANGLE_METADATA,
+	generator: createGenericRectangle,
+	defaultOptions: DEFAULT_GENERIC_RECTANGLE_OPTIONS,
+	rule: rectangleDrawRule,
+	previewSample: { controlPoints: [
+		[-.9, -.55],
+		[.9, -.55],
+		[.9, .55]
+	] }
+});
+//#endregion
+//#region src/generators/cm34-mission-tasks/clear.ts
+/**
+* Default options for the CLEAR symbol.
+*/
+const DEFAULT_CLEAR_OPTIONS = {
+	arrowInsetRatio: .15,
+	arrowheadLengthRatio: .15,
+	arrowheadWidthRatio: .2,
+	labelGapRatio: .2
+};
+const CLEAR_METADATA = {
+	id: "clear",
+	name: "Clear",
+	description: "Removes all enemy forces and eliminates organized resistance within an assigned area.",
+	entity: "Mission Tasks",
+	entityType: "Clear",
+	value: "340500",
+	minCoordinates: 3,
+	maxCoordinates: 3,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	drawRule: "Line23",
+	capturesLabelSize: true,
+	params: [
+		{
+			key: "arrowInsetRatio",
+			label: "Arrow padding",
+			description: "Padding between the line endpoints and the outer arrows, as a ratio of height",
+			type: "number",
+			min: 0,
+			max: .45,
+			step: .01
+		},
+		{
+			key: "arrowheadLengthRatio",
+			label: "Arrowhead length",
+			description: "Arrowhead length as a ratio of the symbol height",
+			type: "number",
+			min: .01,
+			max: 1,
+			step: .01
+		},
+		{
+			key: "arrowheadWidthRatio",
+			label: "Arrowhead width",
+			description: "Arrowhead base width as a ratio of the symbol height",
+			type: "number",
+			min: .01,
+			max: 1,
+			step: .01
+		},
+		{
+			key: "labelGapRatio",
+			label: "Label gap",
+			description: "Size of the shaft gap holding the 'C' label, as a ratio of the shaft length",
+			type: "number",
+			min: 0,
+			max: 1,
+			step: .01
+		}
+	]
+};
+/**
+* Generates a GeoJSON FeatureCollection for a CLEAR mission task symbol (340500).
+*
+* A vertical line (PT. 1 → PT. 2) with three arrows pointing at it,
+* perpendicular to the line. The arrows come from the rear — the side PT. 3
+* sits on — and their tips touch the vertical line; each carries a shaft
+* reaching back to the rear. The arrows are evenly spaced along the line, so
+* the middle arrow's tip sits at the midpoint of the vertical line and its
+* shaft carries the 'C' glyph. The arrows stay perpendicular to the vertical
+* line at any rotation.
+*
+* Input Points:
+* - PT. 1: Top endpoint of the vertical line
+* - PT. 2: Bottom endpoint of the vertical line — defines height with PT. 1
+* - PT. 3: Rear point — defines the shaft length (and which side the arrows
+*   come from)
+*
+* @param coordinates - [PT. 1, PT. 2, PT. 3] as Position arrays
+* @param options - Configuration options
+* @returns GeoJSON FeatureCollection containing MultiLineString and Point features
+*/
+function createClearSymbol(coordinates, options = {}) {
+	const arrowInsetRatio = Math.min(.49, Math.max(0, options.arrowInsetRatio ?? DEFAULT_CLEAR_OPTIONS.arrowInsetRatio));
+	const arrowheadLengthRatio = options.arrowheadLengthRatio ?? DEFAULT_CLEAR_OPTIONS.arrowheadLengthRatio;
+	const arrowheadWidthRatio = options.arrowheadWidthRatio ?? DEFAULT_CLEAR_OPTIONS.arrowheadWidthRatio;
+	const labelGapRatio = options.labelGapRatio ?? DEFAULT_CLEAR_OPTIONS.labelGapRatio;
+	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 vLine = vecSub(p2, p1);
+	const height = vecMag(vLine);
+	if (height < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const dirLine = vecScale(vLine, 1 / height);
+	const midLine = vecScale(vecAdd(p1, p2), .5);
+	const rawPerp = [-dirLine[1], dirLine[0]];
+	const perpToRear = vecScale(rawPerp, vecDot(vecSub(p3, midLine), rawPerp) < 0 ? -1 : 1);
+	const shaftLength = Math.abs(vecDot(vecSub(p3, midLine), rawPerp));
+	const arrowDir = vecScale(perpToRear, -1);
+	const arrowheadLength = height * arrowheadLengthRatio;
+	const arrowheadWidth = height * arrowheadWidthRatio;
+	const tipAt = (t) => vecAdd(p1, vecScale(dirLine, t * height));
+	const lines = [[unproject(p1[0], p1[1]), unproject(p2[0], p2[1])]];
+	const fullTs = [
+		arrowInsetRatio,
+		.5,
+		1 - arrowInsetRatio
+	];
+	const labelIndex = 1;
+	fullTs.forEach((t, i) => {
+		const tip = tipAt(t);
+		const rearEnd = vecAdd(tip, vecScale(perpToRear, shaftLength));
+		if (i === labelIndex && shaftLength > 1e-6) {
+			const labelCenter = vecAdd(tip, vecScale(perpToRear, shaftLength * .5));
+			const gapHalf = shaftLength * labelGapRatio / 2;
+			const gapRear = vecAdd(labelCenter, vecScale(perpToRear, gapHalf));
+			const gapTip = vecAdd(labelCenter, vecScale(perpToRear, -gapHalf));
+			lines.push([unproject(rearEnd[0], rearEnd[1]), unproject(gapRear[0], gapRear[1])]);
+			lines.push([unproject(gapTip[0], gapTip[1]), unproject(tip[0], tip[1])]);
+		} else if (shaftLength > 1e-6) lines.push([unproject(rearEnd[0], rearEnd[1]), unproject(tip[0], tip[1])]);
+		lines.push(createArrowHead$1(tip, arrowDir, arrowheadLength, arrowheadWidth));
+	});
+	const mainFeature = {
+		type: "Feature",
+		properties: { part: "clear" },
+		geometry: {
+			type: "MultiLineString",
+			coordinates: lines
+		}
+	};
+	const lineRotation = Math.atan2(dirLine[1], dirLine[0]);
+	const renderedLabelRotation = Math.PI - (lineRotation - Math.PI / 2);
+	const labelRotation = normalizeRadians(Math.PI - keepTextLeftToRight(renderedLabelRotation));
+	const labelTip = tipAt(fullTs[labelIndex]);
+	return {
+		type: "FeatureCollection",
+		features: [mainFeature, createLabelFeature(shaftLength > 1e-6 ? vecAdd(labelTip, vecScale(perpToRear, shaftLength * .5)) : labelTip, "C", labelRotation, {
+			labelSize: options.labelSize,
+			labelSizePixels: options.labelSizePixels
+		})]
+	};
+}
+const CLEAR = defineControlMeasure({
+	metadata: CLEAR_METADATA,
+	generator: createClearSymbol,
+	defaultOptions: DEFAULT_CLEAR_OPTIONS,
+	rule: line23DrawRule
+});
+//#endregion
+//#region src/internal/field-of-fire.ts
+/**
+* Builds the open (stroked) arrowhead at the outward tip of one arm. The two
+* barbs are sized relative to that arm's own length, so each arm's head scales
+* independently (Line3 — arms vary independently). Returns `null` when the arm
+* has collapsed to zero length.
+*/
+function arrowheadAt(vertex, tip, hSize, hWidth) {
+	const v = vecSub(tip, vertex);
+	const armLength = vecMag(v);
+	if (armLength < 1e-6) return null;
+	const dir = vecNorm(v);
+	const perp = [-dir[1], dir[0]];
+	const headLength = armLength * hSize;
+	const halfWidth = headLength * hWidth;
+	const base = vecSub(tip, vecScale(dir, headLength));
+	return [
+		vecAdd(base, vecScale(perp, halfWidth)),
+		tip,
+		vecSub(base, vecScale(perp, halfWidth))
+	];
+}
+/**
+* Projects the vertex (PT 1) and up to two tips and builds the V of arms, each
+* arm ending in an open arrowhead. Renders one arm per tip, so two points
+* (vertex + one tip) draws the single arm being placed — the live feedback
+* after PT 1 — and three points draws the full V. Points beyond the third are
+* ignored (input contract, ADR-0014).
+*
+* Returns `null` if any arm is degenerate (collapsed to zero length), the
+* silent ADR-0014 empty-render signal.
+*/
+function buildFieldOfFireV(coordinates, hSize, hWidth) {
+	const vertexCoord = coordinates[0];
+	const vertex = project(vertexCoord[0], vertexCoord[1]);
+	const tips = coordinates.slice(1, 3).map((c) => project(c[0], c[1]));
+	const lines = [];
+	for (const tip of tips) {
+		const head = arrowheadAt(vertex, tip, hSize, hWidth);
+		if (!head) return null;
+		lines.push([vertex, tip], head);
+	}
+	return {
+		vertex,
+		tips,
+		lines
 	};
 }
-const GENERIC_RECTANGLE = defineControlMeasure({
-	metadata: GENERIC_RECTANGLE_METADATA,
-	generator: createGenericRectangle,
-	defaultOptions: DEFAULT_GENERIC_RECTANGLE_OPTIONS,
-	rule: rectangleDrawRule,
-	previewSample: { controlPoints: [
-		[-.9, -.55],
-		[.9, -.55],
-		[.9, .55]
-	] }
-});
 //#endregion
-//#region src/generators/cm34-mission-tasks/clear.ts
+//#region src/generators/cm15-maneuver-areas/searchArea.ts
+const DEFAULT_ARROWHEAD_LENGTH_RATIO = .12;
+const DEFAULT_ARROWHEAD_WIDTH_RATIO = .5;
+const DEFAULT_ZIGZAG_START = .55;
+const DEFAULT_ZIGZAG_END = .45;
+const DEFAULT_ZIGZAG_AMPLITUDE_RATIO = .07;
 /**
-* Default options for the CLEAR symbol.
+* Default options for the tactical arrow.
 */
-const DEFAULT_CLEAR_OPTIONS = {
-	arrowInsetRatio: .15,
-	arrowheadLengthRatio: .15,
-	arrowheadWidthRatio: .2,
-	labelGapRatio: .2
+const DEFAULT_TACTICAL_ARROW_OPTIONS = {
+	arrowheadLengthRatio: DEFAULT_ARROWHEAD_LENGTH_RATIO,
+	arrowheadWidthRatio: DEFAULT_ARROWHEAD_WIDTH_RATIO,
+	zigzagStart: DEFAULT_ZIGZAG_START,
+	zigzagEnd: DEFAULT_ZIGZAG_END,
+	zigzagAmplitudeRatio: DEFAULT_ZIGZAG_AMPLITUDE_RATIO
 };
-const CLEAR_METADATA = {
-	id: "clear",
-	name: "Clear",
-	description: "Clear is a tactical mission task that requires a unit to remove all enemy forces and eliminate organized resistance within an assigned area.",
-	entity: "Mission Tasks",
-	entityType: "Clear",
-	value: "340500",
+const SEARCH_AREA_METADATA = {
+	id: "search-area",
+	name: "Search Area",
+	description: "Search area graphic with paired lightning-style arrows.",
+	entity: "Maneuver Areas",
+	entityType: "Search Area",
+	value: "152200",
 	minCoordinates: 3,
 	maxCoordinates: 3,
-	geometry: "line",
-	geometryTypes: ["MultiLineString", "Point"],
-	drawRule: "Line23",
-	capturesLabelSize: true,
+	geometry: "area",
+	geometryTypes: ["MultiLineString", "MultiPolygon"],
+	drawRule: "Area21",
 	params: [
-		{
-			key: "arrowInsetRatio",
-			label: "Arrow padding",
-			description: "Padding between the line endpoints and the outer arrows, as a ratio of height",
-			type: "number",
-			min: 0,
-			max: .45,
-			step: .01
-		},
 		{
 			key: "arrowheadLengthRatio",
 			label: "Arrowhead length",
-			description: "Arrowhead length as a ratio of the symbol height",
+			description: "Arrowhead length as a ratio of the total leg length",
 			type: "number",
-			min: .01,
-			max: 1,
+			min: 0,
+			max: .5,
 			step: .01
 		},
 		{
 			key: "arrowheadWidthRatio",
 			label: "Arrowhead width",
-			description: "Arrowhead base width as a ratio of the symbol height",
+			description: "Arrowhead base width as a multiple of the arrowhead length",
 			type: "number",
-			min: .01,
+			min: .05,
+			max: 2,
+			step: .1
+		},
+		{
+			key: "zigzagStart",
+			label: "Zigzag start",
+			description: "Point along the leg where the zigzag begins (0-1).",
+			type: "number",
+			min: 0,
 			max: 1,
-			step: .01
+			step: .05
 		},
 		{
-			key: "labelGapRatio",
-			label: "Label gap",
-			description: "Size of the shaft gap holding the 'C' label, as a ratio of the shaft length",
+			key: "zigzagEnd",
+			label: "Zigzag end",
+			description: "Point along the leg where the zigzag returns (0-1).",
 			type: "number",
 			min: 0,
 			max: 1,
+			step: .05
+		},
+		{
+			key: "zigzagAmplitudeRatio",
+			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 for a CLEAR mission task symbol (340500).
-*
-* A vertical line (PT. 1 → PT. 2) with three arrows pointing at it,
-* perpendicular to the line. The arrows come from the rear — the side PT. 3
-* sits on — and their tips touch the vertical line; each carries a shaft
-* reaching back to the rear. The arrows are evenly spaced along the line, so
-* the middle arrow's tip sits at the midpoint of the vertical line and its
-* shaft carries the 'C' glyph. The arrows stay perpendicular to the vertical
-* line at any rotation.
-*
-* Input Points:
-* - PT. 1: Top endpoint of the vertical line
-* - PT. 2: Bottom endpoint of the vertical line — defines height with PT. 1
-* - PT. 3: Rear point — defines the shaft length (and which side the arrows
-*   come from)
+* Generates a GeoJSON FeatureCollection of a tactical "lightning" arrow.
+* Handles internal projection to maintain correct perpendicularity.
 *
-* @param coordinates - [PT. 1, PT. 2, PT. 3] as Position arrays
-* @param options - Configuration options
-* @returns GeoJSON FeatureCollection containing MultiLineString and Point features
+* @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
+		},
+		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",
+		label: "Arrowhead length",
+		description: "Arrowhead length as a ratio of the total leg length",
+		type: "number",
+		min: 0,
+		max: .5,
+		step: .01
+	},
+	{
+		key: "arrowheadWidthRatio",
+		label: "Arrowhead width",
+		description: "Arrowhead base width as a multiple of the arrowhead length",
+		type: "number",
+		min: .05,
+		max: 2,
+		step: .1
+	},
+	{
+		key: "zigzagStart",
+		label: "Zigzag start",
+		description: "Point along the leg where the zigzag begins (0-1).",
+		type: "number",
+		min: 0,
+		max: 1,
+		step: .05
+	},
+	{
+		key: "zigzagEnd",
+		label: "Zigzag end",
+		description: "Point along the leg where the zigzag returns (0-1).",
+		type: "number",
+		min: 0,
+		max: 1,
+		step: .05
+	},
+	{
+		key: "zigzagAmplitudeRatio",
+		label: "Zigzag amplitude",
+		description: "Perpendicular kink offset as a ratio of leg length.",
+		type: "number",
+		min: 0,
+		max: .3,
+		step: .01
+	},
+	{
+		key: "labelInsetRatio",
+		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
+* supported tactical symbol, which is explanatory rather than part of this
+* control measure. The task glyph is repeated on either side of that opening.
 */
-function createClearSymbol(coordinates, options = {}) {
-	const arrowInsetRatio = Math.min(.49, Math.max(0, options.arrowInsetRatio ?? DEFAULT_CLEAR_OPTIONS.arrowInsetRatio));
-	const arrowheadLengthRatio = options.arrowheadLengthRatio ?? DEFAULT_CLEAR_OPTIONS.arrowheadLengthRatio;
-	const arrowheadWidthRatio = options.arrowheadWidthRatio ?? DEFAULT_CLEAR_OPTIONS.arrowheadWidthRatio;
-	const labelGapRatio = options.labelGapRatio ?? DEFAULT_CLEAR_OPTIONS.labelGapRatio;
-	const [c1, c2, c3] = coordinates;
+function createSecurityTaskSymbol(coordinates, config, options = {}) {
+	const { taskGlyph, part } = config;
+	const [c1, c2, c3, c4] = coordinates;
 	const p1 = project(c1[0], c1[1]);
 	const p2 = project(c2[0], c2[1]);
 	const p3 = project(c3[0], c3[1]);
-	const vLine = vecSub(p2, p1);
-	const height = vecMag(vLine);
-	if (height < 1e-6) return {
+	const p4 = project(c4[0], c4[1]);
+	const resolved = {
+		...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 lines = [createTacticalArrow(p2, p1, p3, arrowOptions), createTacticalArrow(p3, p4, p2, arrowOptions)].flatMap((arrow) => arrow ?? []);
+	if (lines.length === 0) return {
 		type: "FeatureCollection",
 		features: []
 	};
-	const dirLine = vecScale(vLine, 1 / height);
-	const midLine = vecScale(vecAdd(p1, p2), .5);
-	const rawPerp = [-dirLine[1], dirLine[0]];
-	const perpToRear = vecScale(rawPerp, vecDot(vecSub(p3, midLine), rawPerp) < 0 ? -1 : 1);
-	const shaftLength = Math.abs(vecDot(vecSub(p3, midLine), rawPerp));
-	const arrowDir = vecScale(perpToRear, -1);
-	const arrowheadLength = height * arrowheadLengthRatio;
-	const arrowheadWidth = height * arrowheadWidthRatio;
-	const tipAt = (t) => vecAdd(p1, vecScale(dirLine, t * height));
-	const lines = [[unproject(p1[0], p1[1]), unproject(p2[0], p2[1])]];
-	const fullTs = [
-		arrowInsetRatio,
-		.5,
-		1 - arrowInsetRatio
-	];
-	const labelIndex = 1;
-	fullTs.forEach((t, i) => {
-		const tip = tipAt(t);
-		const rearEnd = vecAdd(tip, vecScale(perpToRear, shaftLength));
-		if (i === labelIndex && shaftLength > 1e-6) {
-			const labelCenter = vecAdd(tip, vecScale(perpToRear, shaftLength * .5));
-			const gapHalf = shaftLength * labelGapRatio / 2;
-			const gapRear = vecAdd(labelCenter, vecScale(perpToRear, gapHalf));
-			const gapTip = vecAdd(labelCenter, vecScale(perpToRear, -gapHalf));
-			lines.push([unproject(rearEnd[0], rearEnd[1]), unproject(gapRear[0], gapRear[1])]);
-			lines.push([unproject(gapTip[0], gapTip[1]), unproject(tip[0], tip[1])]);
-		} else if (shaftLength > 1e-6) lines.push([unproject(rearEnd[0], rearEnd[1]), unproject(tip[0], tip[1])]);
-		lines.push(createArrowHead$1(tip, arrowDir, arrowheadLength, arrowheadWidth));
-	});
-	const mainFeature = {
+	const features = [{
 		type: "Feature",
-		properties: { part: "clear" },
+		properties: { part },
 		geometry: {
 			type: "MultiLineString",
 			coordinates: lines
 		}
-	};
-	const lineRotation = Math.atan2(dirLine[1], dirLine[0]);
-	const renderedLabelRotation = Math.PI - (lineRotation - Math.PI / 2);
-	const labelRotation = normalizeRadians(Math.PI - keepTextLeftToRight(renderedLabelRotation));
-	const labelTip = tipAt(fullTs[labelIndex]);
-	return {
-		type: "FeatureCollection",
-		features: [mainFeature, createLabelFeature(shaftLength > 1e-6 ? vecAdd(labelTip, vecScale(perpToRear, shaftLength * .5)) : labelTip, "C", labelRotation, {
+	}];
+	const gap = vecSub(p3, p2);
+	if (vecMag(gap) >= 1e-6) {
+		const gapDir = vecNorm(gap);
+		const inset = clamp(resolved.labelInsetRatio, .05, .45);
+		const rotation = labelRotationAlong(gapDir);
+		const size = {
 			labelSize: options.labelSize,
 			labelSizePixels: options.labelSizePixels
-		})]
+		};
+		features.push(createLabelFeature(vecAdd(p2, vecScale(gap, inset)), taskGlyph, rotation, size), createLabelFeature(vecAdd(p3, vecScale(gap, -inset)), taskGlyph, rotation, size));
+	}
+	return {
+		type: "FeatureCollection",
+		features
 	};
 }
-const CLEAR = defineControlMeasure({
-	metadata: CLEAR_METADATA,
-	generator: createClearSymbol,
-	defaultOptions: DEFAULT_CLEAR_OPTIONS,
-	rule: line23DrawRule
+/** A Search Area-style lightning shaft with a Principal Direction of Fire open head. */
+function createTacticalArrow(origin, tip, opposite, options) {
+	const leg = vecSub(tip, origin);
+	const totalLegLength = vecMag(leg);
+	if (totalLegLength < 1e-6) return void 0;
+	const legDirection = vecNorm(leg);
+	let normal = [-legDirection[1], legDirection[0]];
+	if (vecDot(normal, vecSub(opposite, origin)) > 0) normal = vecScale(normal, -1);
+	const amplitude = totalLegLength * options.zigzagAmplitudeRatio;
+	const zigzagPointA = vecAdd(vecAdd(origin, vecScale(leg, options.zigzagStart)), vecScale(normal, amplitude));
+	const zigzagPointB = vecAdd(vecAdd(origin, vecScale(leg, options.zigzagEnd)), vecScale(normal, -amplitude));
+	const arrowhead = arrowheadAt(origin, tip, options.arrowheadLengthRatio, options.arrowheadWidthRatio);
+	if (!arrowhead) return void 0;
+	return [[
+		origin,
+		zigzagPointA,
+		zigzagPointB,
+		tip
+	], arrowhead].map((line) => line.map((point) => unproject(point[0], point[1])));
+}
+//#endregion
+//#region src/generators/cm34-mission-tasks/cover.ts
+const DEFAULT_COVER_OPTIONS = DEFAULT_SECURITY_TASK_OPTIONS;
+const COVER_METADATA = {
+	id: "cover",
+	name: "Cover",
+	description: "Protects the main body by fighting to gain time while observing and reporting information and preventing enemy ground observation of and direct fire against the main body; unlike a screen or guard, a covering force is tactically self-contained and operates independently of the main body.",
+	entity: "Mission Tasks",
+	entityType: "Security",
+	entitySubtype: "Cover",
+	value: "342201",
+	minCoordinates: 4,
+	maxCoordinates: 4,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	drawRule: "Line26",
+	capturesLabelSize: true,
+	params: SECURITY_TASK_PARAMS
+};
+function createCoverSymbol(coordinates, options = {}) {
+	return createSecurityTaskSymbol(coordinates, {
+		taskGlyph: "C",
+		part: "cover"
+	}, options);
+}
+const COVER = defineControlMeasure({
+	metadata: COVER_METADATA,
+	generator: createCoverSymbol,
+	defaultOptions: DEFAULT_COVER_OPTIONS,
+	rule: line26DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, 0],
+			[-.3, 0],
+			[.3, 0],
+			[1, 0]
+		],
+		options: { labelSize: 90 }
+	}
 });
 //#endregion
 //#region src/generators/cm34-mission-tasks/delay.ts
@@ -6094,7 +7273,7 @@ const DEFAULT_DELAY_OPTIONS = {
 const DELAY_METADATA = {
 	id: "delay",
 	name: "Delay",
-	description: "Delay is a tactical mission task in which a force under pressure trades space for time by slowing enemy momentum and inflicting maximum damage without becoming decisively engaged.",
+	description: "Trades space for time while under pressure, slowing the enemy's momentum and inflicting maximum damage without becoming decisively engaged.",
 	entity: "Mission Tasks",
 	entityType: "Delay",
 	value: "340800",
@@ -6209,6 +7388,46 @@ const DELAY = defineControlMeasure({
 	rule: line24DrawRule
 });
 //#endregion
+//#region src/generators/cm34-mission-tasks/guard.ts
+const DEFAULT_GUARD_OPTIONS = DEFAULT_SECURITY_TASK_OPTIONS;
+const GUARD_METADATA = {
+	id: "guard",
+	name: "Guard",
+	description: "Protects the main body by fighting to gain time while observing and reporting information and preventing enemy ground observation of and direct fire against the main body; a guard force operates within supporting range of the main body and cannot operate independently of it.",
+	entity: "Mission Tasks",
+	entityType: "Security",
+	entitySubtype: "Guard",
+	value: "342202",
+	minCoordinates: 4,
+	maxCoordinates: 4,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	drawRule: "Line26",
+	capturesLabelSize: true,
+	params: SECURITY_TASK_PARAMS
+};
+function createGuardSymbol(coordinates, options = {}) {
+	return createSecurityTaskSymbol(coordinates, {
+		taskGlyph: "G",
+		part: "guard"
+	}, options);
+}
+const GUARD = defineControlMeasure({
+	metadata: GUARD_METADATA,
+	generator: createGuardSymbol,
+	defaultOptions: DEFAULT_GUARD_OPTIONS,
+	rule: line26DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, 0],
+			[-.3, 0],
+			[.3, 0],
+			[1, 0]
+		],
+		options: { labelSize: 90 }
+	}
+});
+//#endregion
 //#region src/internal/arrowhead.ts
 /**
 * Builds a closed, filled arrowhead triangle ring in unprojected coordinates.
@@ -6671,55 +7890,6 @@ const EXTRACTION_ZONE = defineControlMeasure({
 	}
 });
 //#endregion
-//#region src/internal/field-of-fire.ts
-/**
-* Builds the open (stroked) arrowhead at the outward tip of one arm. The two
-* barbs are sized relative to that arm's own length, so each arm's head scales
-* independently (Line3 — arms vary independently). Returns `null` when the arm
-* has collapsed to zero length.
-*/
-function arrowheadAt(vertex, tip, hSize, hWidth) {
-	const v = vecSub(tip, vertex);
-	const armLength = vecMag(v);
-	if (armLength < 1e-6) return null;
-	const dir = vecNorm(v);
-	const perp = [-dir[1], dir[0]];
-	const headLength = armLength * hSize;
-	const halfWidth = headLength * hWidth;
-	const base = vecSub(tip, vecScale(dir, headLength));
-	return [
-		vecAdd(base, vecScale(perp, halfWidth)),
-		tip,
-		vecSub(base, vecScale(perp, halfWidth))
-	];
-}
-/**
-* Projects the vertex (PT 1) and up to two tips and builds the V of arms, each
-* arm ending in an open arrowhead. Renders one arm per tip, so two points
-* (vertex + one tip) draws the single arm being placed — the live feedback
-* after PT 1 — and three points draws the full V. Points beyond the third are
-* ignored (input contract, ADR-0014).
-*
-* Returns `null` if any arm is degenerate (collapsed to zero length), the
-* silent ADR-0014 empty-render signal.
-*/
-function buildFieldOfFireV(coordinates, hSize, hWidth) {
-	const vertexCoord = coordinates[0];
-	const vertex = project(vertexCoord[0], vertexCoord[1]);
-	const tips = coordinates.slice(1, 3).map((c) => project(c[0], c[1]));
-	const lines = [];
-	for (const tip of tips) {
-		const head = arrowheadAt(vertex, tip, hSize, hWidth);
-		if (!head) return null;
-		lines.push([vertex, tip], head);
-	}
-	return {
-		vertex,
-		tips,
-		lines
-	};
-}
-//#endregion
 //#region src/generators/cm14-maneuver-lines/finalProtectiveFire.ts
 const BLADE_LENGTH_FRACTION = .8;
 const DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS = {
@@ -7177,10 +8347,12 @@ function createFLOT(positions, options = {}) {
 	if (radiusPixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0) effectiveRadius = radiusPixels * metersPerPixel;
 	const safeRadius = Math.max(EPSILON, effectiveRadius);
 	const safeArcSegments = Math.max(3, Math.round(arcSegments));
-	const basePath = smoothLineVerts(positions.map((p) => project(p[0], p[1])), {
+	const projectedPoints = positions.map((p) => project(p[0], p[1]));
+	const smoothedPath = smoothLineVerts(projectedPoints, {
 		smooth,
 		smoothResolution
 	}, 16);
+	const basePath = smooth && projectedPoints.length >= 3 ? evenlySpacePath(smoothedPath, 2 * safeRadius) : smoothedPath;
 	const allPoints = [];
 	for (let i = 0; i < basePath.length - 1; i++) {
 		const p1 = basePath[i];
@@ -7571,7 +8743,7 @@ function createFortifiedLine(positions, options = {}) {
 			properties: {},
 			geometry: {
 				type: "LineString",
-				coordinates: generateFortifiedPoints(smooth ? catmullRom(projectedPoints, normalizeSmoothResolution$2(smoothResolution, DEFAULT_SMOOTH_RESOLUTION$1)) : projectedPoints, safeSize).map((p) => unproject(p[0], p[1]))
+				coordinates: generateFortifiedPoints(smooth ? evenlySpacePath(catmullRom(projectedPoints, normalizeSmoothResolution$2(smoothResolution, DEFAULT_SMOOTH_RESOLUTION$1)), 2 * safeSize) : projectedPoints, safeSize).map((p) => unproject(p[0], p[1]))
 			}
 		}]
 	};
@@ -7623,7 +8795,7 @@ function createFortifiedArea(positions, options = {}, textAmplifiers = {}) {
 	const safeSize = calculateEffectiveSize(options);
 	const projected = positions.map((p) => project(p[0], p[1]));
 	const ringPts = projected.length > 1 && vecMag(vecSub(projected[0], projected[projected.length - 1])) < 1e-6 ? projected.slice(0, -1) : projected;
-	const boundaryInput = smooth ? closedCatmullRom(ringPts, normalizeSmoothResolution$2(smoothResolution, DEFAULT_FORTIFIED_AREA_OPTIONS.smoothResolution)) : [...ringPts, ringPts[0]];
+	const boundaryInput = smooth ? evenlySpacePath(closedCatmullRom(ringPts, normalizeSmoothResolution$2(smoothResolution, DEFAULT_FORTIFIED_AREA_OPTIONS.smoothResolution)), 2 * safeSize) : [...ringPts, ringPts[0]];
 	const boundaryPoints = generateFortifiedPoints(boundaryInput, safeSize);
 	if (boundaryPoints.length > 0) {
 		const firstPt = boundaryPoints[0];
@@ -7631,41 +8803,235 @@ function createFortifiedArea(positions, options = {}, textAmplifiers = {}) {
 		if (vecMag(vecSub(firstPt, lastPt)) > 1e-6) boundaryPoints.push(firstPt);
 		else boundaryPoints[boundaryPoints.length - 1] = firstPt;
 	}
-	const features = [{
-		type: "Feature",
-		properties: {},
-		geometry: {
-			type: "Polygon",
-			coordinates: [boundaryPoints.map((p) => unproject(p[0], p[1]))]
-		}
-	}];
-	const labelFeatures = [];
-	pushAreaLabels(labelFeatures, boundaryInput, {
-		name: textAmplifiers.T,
-		additionalInformation: textAmplifiers.H,
-		dtgStart: textAmplifiers.W,
-		dtgEnd: textAmplifiers.W1
-	}, options);
-	features.push(...labelFeatures);
-	return {
-		type: "FeatureCollection",
-		features
-	};
+	const features = [{
+		type: "Feature",
+		properties: {},
+		geometry: {
+			type: "Polygon",
+			coordinates: [boundaryPoints.map((p) => unproject(p[0], p[1]))]
+		}
+	}];
+	const labelFeatures = [];
+	pushAreaLabels(labelFeatures, boundaryInput, {
+		name: textAmplifiers.T,
+		additionalInformation: textAmplifiers.H,
+		dtgStart: textAmplifiers.W,
+		dtgEnd: textAmplifiers.W1
+	}, options);
+	features.push(...labelFeatures);
+	return {
+		type: "FeatureCollection",
+		features
+	};
+}
+const FORTIFIED_AREA = defineControlMeasure({
+	metadata: FORTIFIED_AREA_METADATA,
+	generator: createFortifiedArea,
+	defaultOptions: DEFAULT_FORTIFIED_AREA_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: { T: "TANGO" },
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
+//#region src/generators/cm15-maneuver-areas/maneuver-arrow-task-shared.ts
+const DEFAULT_MANEUVER_ARROW_TASK_OPTIONS = {
+	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO,
+	smooth: false,
+	smoothResolution: 5,
+	crossbarLengthRatio: 1.1,
+	labelPosition: .25,
+	dtgPosition: .62,
+	labelPadding: 0
+};
+function midpoint(a, b) {
+	return vecScale(vecAdd(a, b), .5);
+}
+function createManeuverArrowTask(coordinates, options, textAmplifiers, config) {
+	const resolved = {
+		...DEFAULT_MANEUVER_ARROW_TASK_OPTIONS,
+		...options
+	};
+	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.shaftLeft.map((left, index) => midpoint(left, geometry.shaftRight[index]));
+	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 crossbarLength = vecMag(vecSub(geometry.headRing[0], geometry.headRing[2])) * Math.max(1, resolved.crossbarLengthRatio);
+	let crossbarCenter;
+	let crossbarAlong;
+	if (config.crossbarAt === "tip") {
+		crossbarCenter = geometry.ptTip;
+		crossbarAlong = tipDirection;
+	} else {
+		crossbarCenter = centerline[0];
+		crossbarAlong = segments[0].along;
+	}
+	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",
+		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",
+		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",
+		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",
+		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"],
+	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, {
+		part: "frontal-attack",
+		code: "A",
+		crossbarAt: "tip"
+	});
 }
-const FORTIFIED_AREA = defineControlMeasure({
-	metadata: FORTIFIED_AREA_METADATA,
-	generator: createFortifiedArea,
-	defaultOptions: DEFAULT_FORTIFIED_AREA_OPTIONS,
-	rule: area1DrawRule,
+const FRONTAL_ATTACK = defineControlMeasure({
+	metadata: FRONTAL_ATTACK_METADATA,
+	generator: createFrontalAttack,
+	defaultOptions: DEFAULT_FRONTAL_ATTACK_OPTIONS,
+	rule: axis1DrawRule,
 	previewSample: {
 		controlPoints: [
-			[-1, -.5],
-			[1, -.5],
-			[1, .5],
-			[-1, .5]
+			[1, 0],
+			[-.4, -.35],
+			[-1, -.8],
+			[.45, .55]
 		],
-		textAmplifiers: { T: "TANGO" },
-		options: { labelSize: 96 }
+		textAmplifiers: {
+			T: "FOX",
+			W: "080400Z",
+			W1: "120300Z"
+		},
+		options: { labelSize: 80 }
 	}
 });
 //#endregion
@@ -7681,7 +9047,7 @@ const DEFAULT_ISOLATE_OPTIONS = {
 const ISOLATE_METADATA = {
 	id: "isolate",
 	name: "Isolate",
-	description: "Isolate is a tactical mission task in which a unit seals off an enemy, physically and psychologically, from sources of support and denies it freedom of movement.",
+	description: "Seals off an enemy, physically and psychologically, from sources of support, denies it freedom of movement, and prevents it from having contact with other enemy forces.",
 	entity: "Mission Tasks",
 	entityType: "Isolate",
 	value: "341500",
@@ -7799,6 +9165,46 @@ const ISOLATE = defineControlMeasure({
 	rule: isolateDrawRule
 });
 //#endregion
+//#region src/generators/cm34-mission-tasks/screen.ts
+const DEFAULT_SCREEN_OPTIONS = DEFAULT_SECURITY_TASK_OPTIONS;
+const SCREEN_METADATA = {
+	id: "screen",
+	name: "Screen",
+	description: "Provides early warning to the protected force through observation, identification, reporting, and continuous surveillance of the enemy.",
+	entity: "Mission Tasks",
+	entityType: "Security",
+	entitySubtype: "Screen",
+	value: "342203",
+	minCoordinates: 4,
+	maxCoordinates: 4,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	drawRule: "Line26",
+	capturesLabelSize: true,
+	params: SECURITY_TASK_PARAMS
+};
+function createScreenSymbol(coordinates, options = {}) {
+	return createSecurityTaskSymbol(coordinates, {
+		taskGlyph: "S",
+		part: "screen"
+	}, options);
+}
+const SCREEN = defineControlMeasure({
+	metadata: SCREEN_METADATA,
+	generator: createScreenSymbol,
+	defaultOptions: DEFAULT_SCREEN_OPTIONS,
+	rule: line26DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, 0],
+			[-.3, 0],
+			[.3, 0],
+			[1, 0]
+		],
+		options: { labelSize: 90 }
+	}
+});
+//#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 = {
@@ -8645,173 +10051,6 @@ const PRINCIPAL_DIRECTION_OF_FIRE = defineControlMeasure({
 	] }
 });
 //#endregion
-//#region src/generators/cm15-maneuver-areas/searchArea.ts
-const DEFAULT_ARROWHEAD_LENGTH_RATIO = .12;
-const DEFAULT_ARROWHEAD_WIDTH_RATIO = .5;
-const DEFAULT_ZIGZAG_START = .55;
-const DEFAULT_ZIGZAG_END = .45;
-const DEFAULT_ZIGZAG_AMPLITUDE_RATIO = .07;
-/**
-* Default options for the tactical arrow.
-*/
-const DEFAULT_TACTICAL_ARROW_OPTIONS = {
-	arrowheadLengthRatio: DEFAULT_ARROWHEAD_LENGTH_RATIO,
-	arrowheadWidthRatio: DEFAULT_ARROWHEAD_WIDTH_RATIO,
-	zigzagStart: DEFAULT_ZIGZAG_START,
-	zigzagEnd: DEFAULT_ZIGZAG_END,
-	zigzagAmplitudeRatio: DEFAULT_ZIGZAG_AMPLITUDE_RATIO
-};
-const SEARCH_AREA_METADATA = {
-	id: "search-area",
-	name: "Search Area",
-	description: "Search area graphic with paired lightning-style arrows.",
-	entity: "Maneuver Areas",
-	entityType: "Search Area",
-	value: "152200",
-	minCoordinates: 3,
-	maxCoordinates: 3,
-	geometry: "area",
-	geometryTypes: ["MultiLineString", "MultiPolygon"],
-	drawRule: "Area21",
-	params: [
-		{
-			key: "arrowheadLengthRatio",
-			label: "Arrowhead length",
-			description: "Arrowhead length as a ratio of the total leg length",
-			type: "number",
-			min: 0,
-			max: .5,
-			step: .01
-		},
-		{
-			key: "arrowheadWidthRatio",
-			label: "Arrowhead width",
-			description: "Arrowhead base width as a multiple of the arrowhead length",
-			type: "number",
-			min: .05,
-			max: 2,
-			step: .1
-		},
-		{
-			key: "zigzagStart",
-			label: "Zigzag start",
-			description: "Point along the leg where the zigzag begins (0-1).",
-			type: "number",
-			min: 0,
-			max: 1,
-			step: .05
-		},
-		{
-			key: "zigzagEnd",
-			label: "Zigzag end",
-			description: "Point along the leg where the zigzag returns (0-1).",
-			type: "number",
-			min: 0,
-			max: 1,
-			step: .05
-		},
-		{
-			key: "zigzagAmplitudeRatio",
-			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
-		},
-		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. */
@@ -9371,6 +10610,37 @@ function rotate(vector, 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_TURNING_MOVEMENT_OPTIONS = DEFAULT_MANEUVER_ARROW_TASK_OPTIONS;
+const TURNING_MOVEMENT_METADATA = {
+	id: "turning-movement",
+	name: "Turning Movement",
+	description: "A maneuver that passes around or over an enemy's principal defensive positions to secure objectives to the enemy's rear.",
+	entity: "Maneuver Areas",
+	entityType: "Turning Movement",
+	value: "152900",
+	minCoordinates: 3,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	drawRule: "Axis1",
+	capturesLabelSize: true,
+	params: [...ATTACK_SHAFT_PARAMS, ...MANEUVER_ARROW_TASK_PARAMS],
+	textAmplifiers: MANEUVER_ARROW_TASK_TEXT_AMPLIFIERS
+};
+function createTurningMovement(coordinates, options = {}, textAmplifiers = {}) {
+	return createManeuverArrowTask(coordinates, options, textAmplifiers, {
+		part: "turning-movement",
+		code: "T",
+		crossbarAt: "tail"
+	});
+}
 //#endregion
 //#region src/registry.ts
 /**
@@ -9389,12 +10659,16 @@ const DEFINITIONS = {
 	"battle-position": BATTLE_POSITION,
 	"strong-point": STRONG_POINT,
 	ambush: AMBUSH,
+	"direction-of-attack-aviation": DIRECTION_OF_ATTACK_AVIATION,
+	"direction-of-main-attack": DIRECTION_OF_MAIN_ATTACK,
+	"direction-of-supporting-attack": DIRECTION_OF_SUPPORTING_ATTACK,
 	"principal-direction-of-fire": PRINCIPAL_DIRECTION_OF_FIRE,
 	"final-protective-fire-left": FINAL_PROTECTIVE_FIRE_LEFT,
 	"final-protective-fire-right": FINAL_PROTECTIVE_FIRE_RIGHT,
 	"search-area": SEARCH_AREA,
 	encirclement: ENCIRCLEMENT,
 	area: AREA,
+	"area-defense": AREA_DEFENSE,
 	"assembly-area": ASSEMBLY_AREA,
 	"joint-tactical-action-area": JOINT_TACTICAL_ACTION_AREA,
 	"submarine-action-area": SUBMARINE_ACTION_AREA,
@@ -9434,22 +10708,41 @@ const DEFINITIONS = {
 	bypass: BYPASS,
 	canalize: CANALIZE,
 	clear: CLEAR,
+	cover: COVER,
 	delay: DELAY,
+	guard: GUARD,
 	isolate: ISOLATE,
+	screen: SCREEN,
 	"antitank-ditch-under-construction": ANTITANK_DITCH_UNDER_CONSTRUCTION,
 	"antitank-ditch-completed": ANTITANK_DITCH_COMPLETED,
 	"antitank-wall": ANTITANK_WALL,
 	"fortified-line": FORTIFIED_LINE,
 	"fortified-area": FORTIFIED_AREA,
+	"frontal-attack": FRONTAL_ATTACK,
+	"turning-movement": defineControlMeasure({
+		metadata: TURNING_MOVEMENT_METADATA,
+		generator: createTurningMovement,
+		defaultOptions: DEFAULT_TURNING_MOVEMENT_OPTIONS,
+		rule: axis1DrawRule,
+		previewSample: {
+			controlPoints: [
+				[1, 0],
+				[-.4, -.35],
+				[-1, -.8],
+				[.45, .55]
+			],
+			textAmplifiers: {
+				T: "DAVID",
+				W: "080400Z",
+				W1: "120300Z"
+			},
+			options: { labelSize: 80 }
+		}
+	}),
 	block: BLOCK,
 	disrupt: DISRUPT,
 	fix: FIX,
-	turn: defineControlMeasure({
-		metadata: TURN_METADATA,
-		generator: createTurn,
-		defaultOptions: DEFAULT_TURN_OPTIONS,
-		rule: turnDrawRule
-	}),
+	turn: TURN,
 	"obstacle-bypass-easy": OBSTACLE_BYPASS_EASY,
 	"obstacle-bypass-difficult": OBSTACLE_BYPASS_DIFFICULT,
 	"obstacle-bypass-impossible": OBSTACLE_BYPASS_IMPOSSIBLE
@@ -9691,7 +10984,16 @@ function normalizeTextAmplifiers(input) {
 * `properties.style` when non-empty.
 */
 function renderControlMeasure(cm, opts) {
-	const features = dispatchControlMeasure(cm, opts).features.map((feature, index) => normalizeFeature(cm.id, feature, index, cm.style, opts?.graphicsStyle));
+	const raw = dispatchControlMeasure(cm, opts);
+	const generatedLabelOrdinals = /* @__PURE__ */ new Map();
+	const features = raw.features.map((feature, index) => {
+		const sourceProps = feature.properties ?? {};
+		const part = typeof sourceProps.part === "string" && sourceProps.part.length > 0 ? sourceProps.part : "main";
+		const isGeneratedLabel = sourceProps.labelPlacement !== false && !(typeof sourceProps.amplifierField === "string" && canonicalTextAmplifierKey(sourceProps.amplifierField)) && !(typeof sourceProps.labelPlacementKey === "string" && sourceProps.labelPlacementKey.length > 0) && typeof sourceProps.text === "string" && feature.geometry.type === "Point";
+		const generatedLabelOrdinal = isGeneratedLabel ? generatedLabelOrdinals.get(part) ?? 0 : index;
+		if (isGeneratedLabel) generatedLabelOrdinals.set(part, generatedLabelOrdinal + 1);
+		return normalizeFeature(cm.id, feature, index, generatedLabelOrdinal, cm.style, opts?.graphicsStyle, cm.amplifierPlacements);
+	});
 	const bbox = computeBBox(features);
 	return {
 		type: "FeatureCollection",
@@ -9723,7 +11025,20 @@ function validateInputContract(points, metadata, mode) {
 	if (points.some((point) => !isValidPosition(point))) return reportValidationIssue(mode, `"${metadata.id}" control points must contain finite [lon, lat] values.`);
 	return true;
 }
-function normalizeFeature(id, feature, index, measureStyle, graphicsStyle) {
+/**
+* The `amplifierPlacements` key that repositions this feature, if any: the
+* canonical amplifier field when the generator declared one, an explicit
+* `labelPlacementKey`, or a synthesized `label:<part>:<ordinal>` key for any
+* other point label — unless the generator opted out via
+* `labelPlacement: false`.
+*/
+function resolveLabelPlacementKey(sourceProps, amplifierField, text, geometryType, part, generatedLabelOrdinal) {
+	if (sourceProps.labelPlacement === false) return void 0;
+	if (amplifierField) return amplifierField;
+	if (typeof sourceProps.labelPlacementKey === "string" && sourceProps.labelPlacementKey.length > 0) return sourceProps.labelPlacementKey;
+	if (text !== void 0 && geometryType === "Point") return `label:${part}:${generatedLabelOrdinal}`;
+}
+function normalizeFeature(id, feature, index, generatedLabelOrdinal, measureStyle, graphicsStyle, amplifierPlacements) {
 	const sourceProps = feature.properties ?? {};
 	const part = typeof sourceProps.part === "string" && sourceProps.part.length > 0 ? sourceProps.part : "main";
 	const generatorStyle = typeof sourceProps.style === "object" && sourceProps.style !== null ? sourceProps.style : void 0;
@@ -9734,6 +11049,13 @@ function normalizeFeature(id, feature, index, measureStyle, graphicsStyle) {
 	const textSizePixels = typeof sourceProps.textSizePixels === "number" ? sourceProps.textSizePixels : void 0;
 	const textSizeMeters = typeof sourceProps.textSizeMeters === "number" ? sourceProps.textSizeMeters : void 0;
 	const textAnchor = sourceProps.textAnchor === "start" || sourceProps.textAnchor === "end" ? sourceProps.textAnchor : void 0;
+	const amplifierField = typeof sourceProps.amplifierField === "string" ? canonicalTextAmplifierKey(sourceProps.amplifierField) : void 0;
+	const labelPlacementKey = resolveLabelPlacementKey(sourceProps, amplifierField, text, feature.geometry.type, part, generatedLabelOrdinal);
+	const placement = labelPlacementKey ? amplifierPlacements?.[labelPlacementKey] : void 0;
+	const geometry = placement && isValidPosition(placement) && feature.geometry.type === "Point" ? {
+		...feature.geometry,
+		coordinates: [...placement]
+	} : feature.geometry;
 	return {
 		type: "Feature",
 		id: `${id}:${part}:${index}`,
@@ -9744,10 +11066,12 @@ function normalizeFeature(id, feature, index, measureStyle, graphicsStyle) {
 			...text !== void 0 ? { text } : {},
 			...rotation !== void 0 ? { rotation } : {},
 			...textAnchor !== void 0 ? { textAnchor } : {},
+			...amplifierField !== void 0 ? { amplifierField } : {},
+			...labelPlacementKey !== void 0 ? { labelPlacementKey } : {},
 			...textSizePixels !== void 0 ? { textSizePixels } : {},
 			...textSizeMeters !== void 0 ? { textSizeMeters } : {}
 		},
-		geometry: feature.geometry
+		geometry
 	};
 }
 function computeBBox(features) {
@@ -9796,4 +11120,4 @@ function assertNever(value) {
 	throw new Error(`Unhandled control measure kind: ${String(value)}`);
 }
 //#endregion
-export { DEFAULT_BATTLE_POSITION_OPTIONS as $, DEFAULT_PHASE_LINE_OPTIONS as A, unproject as At, DEFAULT_GENERIC_LINE_OPTIONS as B, DEFAULT_MAIN_ATTACK_OPTIONS as C, getMidpointPerpendicularSignedDistance as Ct, DEFAULT_FORTIFIED_LINE_OPTIONS as D, calculateMetrics as Dt, DEFAULT_FORTIFIED_AREA_OPTIONS as E, createBaselineFrame as Et, DEFAULT_DISRUPT_OPTIONS as F, DEFAULT_BREACH_OPTIONS as G, DEFAULT_CLASSIC_ARROW_OPTIONS as H, DEFAULT_DELAY_OPTIONS as I, DEFAULT_ENGINEER_WORK_LINE_OPTIONS as J, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as K, DEFAULT_CLEAR_OPTIONS as L, DEFAULT_FIX_OPTIONS as M, getMetersPerPixel as Mt, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as N, roundToFixed as Nt, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as O, computeInitialWidthPoint as Ot, DEFAULT_ENCIRCLEMENT_OPTIONS as P, DEFAULT_BLOCK_OPTIONS as Q, DEFAULT_GENERIC_RECTANGLE_OPTIONS as R, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as S, createMidpointPerpendicularDrawRule as St, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as T, snapToMidpointPerpendicular as Tt, DEFAULT_CANALIZE_OPTIONS as U, DEFAULT_GENERIC_CIRCLE_OPTIONS as V, DEFAULT_BYPASS_OPTIONS as W, DEFAULT_BOUNDARY_OPTIONS as X, DEFAULT_LIGHT_LINE_OPTIONS as Y, DEFAULT_BLOCK_ARROW_OPTIONS as Z, DEFAULT_TACTICAL_ARROW_OPTIONS as _, point12DrawRule as _t, resolveStyleHints as a, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as at, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as b, blockDrawRule as bt, DEFINITIONS as c, rectangleDrawRule as ct, getDefaultOptions as d, line24DrawRule as dt, DEFAULT_ATTACK_HELICOPTER_OPTIONS as et, listControlMeasureMetadata as f, line23DrawRule as ft, DEFAULT_STRONG_POINT_OPTIONS as g, attackByFireDrawRule as gt, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as h, ambushDrawRule as ht, normalizeTextAmplifiers as i, DEFAULT_ASSEMBLY_AREA_OPTIONS as it, DEFAULT_FLOT_OPTIONS as j, EPSILON as jt, DEFAULT_HANDOVER_LINE_OPTIONS as k, project as kt, getControlMeasureMetadata as l, axis1DrawRule as lt, DEFAULT_SUPPORTING_ATTACK_OPTIONS as m, line1DrawRule as mt, TEXT_AMPLIFIER_FIELDS as n, DEFAULT_ANTITANK_WALL_OPTIONS as nt, CONTROL_MEASURE_IDS as o, DEFAULT_AMBUSH_OPTIONS as ot, DEFAULT_TURN_OPTIONS as p, turnDrawRule as pt, DEFAULT_GENERIC_C2_LINE_OPTIONS as q, canonicalTextAmplifierKey as r, DEFAULT_ANTITANK_DITCH_OPTIONS as rt, CONTROL_MEASURE_METADATA as s, DEFAULT_AIRBORNE_ATTACK_OPTIONS as st, renderControlMeasure as t, DEFAULT_ATTACK_BY_FIRE_OPTIONS as tt, getControlMeasureMetadataByValue as u, supportByFireDrawRule as ut, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as v, centerRadiusDrawRule as vt, DEFAULT_LANDING_ZONE_OPTIONS as w, pointOnMidpointPerpendicularAxis as wt, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as x, computeDefaultMidpointPerpendicularPoint as xt, DEFAULT_PICKUP_ZONE_OPTIONS as y, disruptDrawRule as yt, DEFAULT_GENERIC_POLYGON_OPTIONS as z };
+export { DEFAULT_ENGINEER_WORK_LINE_OPTIONS as $, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as A, blockDrawRule as At, DEFAULT_COVER_OPTIONS as B, unproject as Bt, DEFAULT_MAIN_ATTACK_OPTIONS as C, turnDrawRule as Ct, DEFAULT_FRONTAL_ATTACK_OPTIONS as D, point12DrawRule as Dt, DEFAULT_SCREEN_OPTIONS as E, attackByFireDrawRule as Et, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as F, snapToMidpointPerpendicular as Ft, DEFAULT_GENERIC_LINE_OPTIONS as G, DEFAULT_CLEAR_OPTIONS as H, getMetersPerPixel as Ht, DEFAULT_ENCIRCLEMENT_OPTIONS as I, createBaselineFrame as It, DEFAULT_CANALIZE_OPTIONS as J, DEFAULT_GENERIC_CIRCLE_OPTIONS as K, DEFAULT_DISRUPT_OPTIONS as L, calculateMetrics as Lt, DEFAULT_PHASE_LINE_OPTIONS as M, createMidpointPerpendicularDrawRule as Mt, DEFAULT_FLOT_OPTIONS as N, getMidpointPerpendicularSignedDistance as Nt, DEFAULT_FORTIFIED_AREA_OPTIONS as O, centerRadiusDrawRule as Ot, DEFAULT_FIX_OPTIONS as P, pointOnMidpointPerpendicularAxis as Pt, DEFAULT_GENERIC_C2_LINE_OPTIONS as Q, DEFAULT_GUARD_OPTIONS as R, computeInitialWidthPoint as Rt, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as S, line23DrawRule as St, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as T, ambushDrawRule as Tt, DEFAULT_GENERIC_RECTANGLE_OPTIONS as U, roundToFixed as Ut, DEFAULT_TACTICAL_ARROW_OPTIONS as V, EPSILON as Vt, DEFAULT_GENERIC_POLYGON_OPTIONS as W, DEFAULT_BREACH_OPTIONS as X, DEFAULT_BYPASS_OPTIONS as Y, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as Z, DEFAULT_STRONG_POINT_OPTIONS as _, rectangleDrawRule as _t, resolveStyleHints as a, DEFAULT_ATTACK_HELICOPTER_OPTIONS as at, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as b, line26DrawRule as bt, DEFINITIONS as c, DEFAULT_ANTITANK_DITCH_OPTIONS as ct, getDefaultOptions as d, DEFAULT_AREA_DEFENSE_OPTIONS as dt, DEFAULT_LIGHT_LINE_OPTIONS as et, listControlMeasureMetadata as f, DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS as ft, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as g, DEFAULT_AIRBORNE_ATTACK_OPTIONS as gt, DEFAULT_SUPPORTING_ATTACK_OPTIONS as h, DEFAULT_AMBUSH_OPTIONS as ht, normalizeTextAmplifiers as i, DEFAULT_BATTLE_POSITION_OPTIONS as it, DEFAULT_HANDOVER_LINE_OPTIONS as j, computeDefaultMidpointPerpendicularPoint as jt, DEFAULT_FORTIFIED_LINE_OPTIONS as k, disruptDrawRule as kt, getControlMeasureMetadata as l, DEFAULT_ASSEMBLY_AREA_OPTIONS as lt, DEFAULT_TURN_OPTIONS as m, DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS as mt, TEXT_AMPLIFIER_FIELDS as n, DEFAULT_BLOCK_ARROW_OPTIONS as nt, CONTROL_MEASURE_IDS as o, DEFAULT_ATTACK_BY_FIRE_OPTIONS as ot, DEFAULT_TURNING_MOVEMENT_OPTIONS as p, DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS as pt, DEFAULT_CLASSIC_ARROW_OPTIONS as q, canonicalTextAmplifierKey as r, DEFAULT_BLOCK_OPTIONS as rt, CONTROL_MEASURE_METADATA as s, DEFAULT_ANTITANK_WALL_OPTIONS as st, renderControlMeasure as t, DEFAULT_BOUNDARY_OPTIONS as tt, getControlMeasureMetadataByValue as u, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as ut, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as v, axis1DrawRule as vt, DEFAULT_LANDING_ZONE_OPTIONS as w, line1DrawRule as wt, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as x, line24DrawRule as xt, DEFAULT_PICKUP_ZONE_OPTIONS as y, supportByFireDrawRule as yt, DEFAULT_DELAY_OPTIONS as z, project as zt };