@orbat-mapper/control-measures 0.19.0 → 0.21.0

package/dist/{renderControlMeasure-C2YRB8uJ.mjs → renderControlMeasure-Cn4Yh917.mjs}

@@ -1,3 +1,50 @@
+//#region src/style.ts
+/**
+* Per-feature style hint pinning a filled part to a solid interior. Attach to
+* a generator's intrinsic doctrinal accents — arrowheads, teeth, echelon
+* glyphs, barbs, blades — so a patterned (`hatch`, `dots`, …) fill set at the graphicsStyle
+* or measure layer never bleeds into a small silhouette and ruins its
+* legibility. The renderer only reads style hints, so one shared instance is
+* safe to reuse across every accent feature.
+*/
+const SOLID_ACCENT_FILL = { fillPattern: "solid" };
+/**
+* Ultimate fallback for the symbol color when no `color` or per-channel
+* override is supplied at any layer. Keeps a zero-config render monocolor
+* black and guarantees filled parts still render filled. See ADR-0011.
+*/
+const DEFAULT_SYMBOL_COLOR = "#000000";
+//#endregion
+//#region src/portrayal.ts
+const DEFAULT_STROKE_WIDTH_CSS_PIXELS = 2;
+const DEFAULT_STROKE_DASH_CSS_PIXELS = Object.freeze([]);
+const DEFAULT_LINE_CAP = "round";
+const DEFAULT_LINE_JOIN = "round";
+const DEFAULT_LABEL_HEIGHT_CSS_PIXELS = 14;
+const DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS = {
+	min: 8,
+	max: 24
+};
+/** Shared absent-value portrayal defaults; render output remains sparse. */
+const DEFAULT_PORTRAYAL = Object.freeze({
+	symbolColor: DEFAULT_SYMBOL_COLOR,
+	strokeWidthCssPixels: 2,
+	strokeDashCssPixels: DEFAULT_STROKE_DASH_CSS_PIXELS,
+	lineCap: DEFAULT_LINE_CAP,
+	lineJoin: DEFAULT_LINE_JOIN,
+	labelHeightCssPixels: 14
+});
+//#endregion
+//#region src/define.ts
+/**
+* Identity helper that infers a definition's literal `Id` and precise generator
+* type `G`, so the registry's `typeof DEFINITIONS` carries each measure's exact
+* options type. Internal authoring API — not part of the published surface.
+*/
+function defineControlMeasure(definition) {
+	return definition;
+}
+//#endregion
 //#region src/internal/graphics-utils.ts
 /**
 * Small value used to avoid division by zero and floating-point precision issues.
@@ -275,334 +322,100 @@ function lineIntersection(p1, p2, p3, p4) {
 	return [x1 + ua * (x2 - x1), y1 + ua * (y2 - y1)];
 }
 //#endregion
-//#region src/attack-utils.ts
-const DEFAULT_SHAFT_WIDTH_RATIO$1 = .6;
-const DEFAULT_REAR_WIDTH_RATIO = DEFAULT_SHAFT_WIDTH_RATIO$1;
-const SHAFT_MIN_RATIO = .1;
-const SHAFT_MAX_RATIO = .9;
-const REAR_WIDTH_OPTION_HANDLE_ID = "rear-width";
-const SHAFT_WIDTH_OPTION_HANDLE_ID = "shaft-width";
-/**
-* Creates the definition-owned rear-/shaft-width handle pair shared by every
-* variable-width arrow body. Callers supply only how their own geometry maps
-* onto {@link WidthHandleGeometry}; placement (the two ends of the right edge)
-* and the drag math (perpendicular distance from the dragged point to the
-* matching centerline segment, over the reference half-width) live here once.
-*/
-function createWidthOptionHandles(config) {
+//#region src/draw-rules/baseline-frame.ts
+function createBaselineFrame(p1, p2, options = {}) {
+	return createProjectedBaselineFrame(project(p1[0], p1[1]), project(p2[0], p2[1]), options);
+}
+function createProjectedBaselineFrame(p1, p2, options = {}) {
+	const baseline = vecSub(p2, p1);
+	const length = vecMag(baseline);
+	if (length < 1e-6) return null;
+	const direction = vecNorm(baseline);
+	const normalSign = options.normal === "left" ? -1 : 1;
+	const normal = vecScale([direction[1], -direction[0]], normalSign);
+	const origin = getOrigin(p1, p2, options.origin ?? "midpoint");
 	return {
-		get(controlPoints, options) {
-			const geometry = config.geometry(controlPoints, options);
-			const rearRight = geometry?.rightEdge[0];
-			const neckRight = geometry?.rightEdge.at(-1);
-			if (!rearRight || !neckRight) return [];
-			return [{
-				id: REAR_WIDTH_OPTION_HANDLE_ID,
-				position: unproject(rearRight[0], rearRight[1])
-			}, {
-				id: SHAFT_WIDTH_OPTION_HANDLE_ID,
-				position: unproject(neckRight[0], neckRight[1])
-			}];
+		p1,
+		p2,
+		origin,
+		direction,
+		normal,
+		length,
+		signedNormalDistance(point) {
+			return vecDot(vecSub(project(point[0], point[1]), origin), normal);
 		},
-		drag({ controlPoints, options, handleId, position }) {
-			const rear = handleId === REAR_WIDTH_OPTION_HANDLE_ID;
-			if (!rear && !(handleId === "shaft-width")) return void 0;
-			const geometry = config.geometry(controlPoints, options);
-			if (!geometry || geometry.referenceHalfWidth < 1e-6) return void 0;
-			const from = rear ? geometry.spine[0] : geometry.spine.at(-2);
-			const to = rear ? geometry.spine[1] : geometry.spine.at(-1);
-			if (!from || !to) return void 0;
-			const ratio = clamp(pointToInfiniteLineDistance(project(position[0], position[1]), from, to) / geometry.referenceHalfWidth, config.minRatio, rear ? config.maxRearRatio : config.maxShaftRatio);
-			return rear ? { rearWidthRatio: ratio } : { shaftWidthRatio: ratio };
+		pointAtNormalDistance(distance) {
+			if (!Number.isFinite(distance)) return null;
+			const point = vecAdd(origin, vecScale(normal, distance));
+			return unproject(point[0], point[1]);
 		}
 	};
 }
-/**
-* The width handles for attack bodies built by {@link processAttackGeometry},
-* whose ratios are fractions of the arrowhead half-width. A coordinate resolver
-* lets derivative measures (Counterattack by Fire) map their authored Axis1
-* points to the body coordinates first.
-*/
-function createVariableWidthAttackOptionHandles(resolveCoordinates = (points) => points) {
-	return createWidthOptionHandles({
-		geometry(controlPoints, options) {
-			const coordinates = resolveCoordinates(controlPoints);
-			if (!coordinates) return null;
-			const { geometry } = processAttackGeometry(coordinates, options);
-			const outerLeft = geometry?.headRing[0];
-			if (!geometry || !outerLeft) return null;
-			return {
-				spine: geometry.shaftCenterline,
-				rightEdge: geometry.shaftRight,
-				referenceHalfWidth: vecMag(vecSub(outerLeft, geometry.ptBase))
-			};
-		},
-		minRatio: SHAFT_MIN_RATIO,
-		maxRearRatio: 3,
-		maxShaftRatio: SHAFT_MAX_RATIO
-	});
+function getOrigin(p1, p2, origin) {
+	if (origin === "p1") return p1;
+	if (origin === "p2") return p2;
+	return vecScale(vecAdd(p1, p2), .5);
 }
-const variableWidthAttackOptionHandles = createVariableWidthAttackOptionHandles();
-/**
-* The single home of the "rear inherits shaft" rule: an omitted `rearWidthRatio`
-* leaves the body parallel by matching the effective shaft ratio. Every
-* variable-width body resolves the option through here so the rule cannot drift.
-*/
-function resolveRearWidthRatio(options, shaftRatio) {
-	return options.rearWidthRatio ?? shaftRatio;
+//#endregion
+//#region src/draw-rules/util.ts
+function clonePosition(position) {
+	return [...position];
 }
-/**
-* Processes input coordinates and options to generate the core symbol geometry.
-* This handles validation, default values, projection, and geometry calculation.
-*/
-function processAttackGeometry(coordinates, options = {}) {
-	const shaftRatio = clamp(options.shaftWidthRatio ?? .6, SHAFT_MIN_RATIO, SHAFT_MAX_RATIO);
-	const smooth = options.smooth ?? false;
-	const smoothResolution = options.smoothResolution ?? 5;
-	const rearRatio = clamp(resolveRearWidthRatio(options, shaftRatio), SHAFT_MIN_RATIO, 3);
-	const points = coordinates.map((c) => project(c[0], c[1]));
-	const numPoints = points.length;
-	const ptTip = points[0];
-	const ptWidth = points[numPoints - 1];
-	const spinePoints = [];
-	for (let i = numPoints - 2; i >= 1; i--) {
-		const p = points[i];
-		if (p) spinePoints.push(p);
-	}
-	return { geometry: calculateSymbolGeometry(ptTip, ptWidth, spinePoints, shaftRatio, rearRatio, smooth, smoothResolution) };
+function clonePositions(positions) {
+	return positions.map(clonePosition);
 }
-function calculateSymbolGeometry(ptTip, ptWidth, spine, shaftRatio, rearWidthRatio, smooth, smoothResolution) {
-	const initialNeck = spine[spine.length - 1];
-	if (!initialNeck) return null;
-	const initialTipDir = vecNorm(vecSub(ptTip, initialNeck));
-	if (vecMag(initialTipDir) < 1e-6) return null;
-	const headHalfWidth = pointToInfiniteLineDistance(ptWidth, initialNeck, ptTip);
-	const vecTipToWidth = vecSub(ptTip, ptWidth);
-	const requestedHeadLength = Math.max(EPSILON, vecDot(vecTipToWidth, initialTipDir));
-	const path = [...spine, ptTip];
-	let totalArcLength = 0;
-	for (let i = 1; i < path.length; i++) totalArcLength += vecMag(vecSub(path[i], path[i - 1]));
-	const minimumShaftLength = Math.max(EPSILON, totalArcLength * .01);
-	let distanceRemaining = clamp(requestedHeadLength, EPSILON, Math.max(EPSILON, totalArcLength - minimumShaftLength));
-	let ptBase = ptTip;
-	let remainingSpine = spine;
-	for (let i = path.length - 1; i > 0; i--) {
-		const segmentEnd = path[i];
-		const segmentStart = path[i - 1];
-		const segment = vecSub(segmentStart, segmentEnd);
-		const segmentLength = vecMag(segment);
-		if (segmentLength < 1e-6) continue;
-		if (distanceRemaining < segmentLength) {
-			ptBase = vecAdd(segmentEnd, vecScale(segment, distanceRemaining / segmentLength));
-			remainingSpine = path.slice(0, i);
-			break;
+function samePosition(a, b) {
+	return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+}
+//#endregion
+//#region src/draw-rules/midpoint-perpendicular.ts
+function createMidpointPerpendicularDrawRule(options) {
+	const defaultDistanceRatio = options.defaultDistanceRatio ?? 1.5;
+	const variableLength = options.variableLength ?? false;
+	const constrainedIndex = options.constrainedIndex ?? 2;
+	const baselineIndexA = constrainedIndex === 0 ? 1 : 0;
+	const baselineIndexB = constrainedIndex === 0 ? 2 : 1;
+	const frameOrigin = options.origin ?? "midpoint";
+	const frameNormal = options.normal ?? "right";
+	function frameFor(p1, p2) {
+		return createBaselineFrame(p1, p2, {
+			origin: frameOrigin,
+			normal: frameNormal
+		});
+	}
+	/** Slot holding the constrained point in an array of `count` points. */
+	function constrainedIndexIn(count) {
+		return variableLength ? count - 1 : constrainedIndex;
+	}
+	function packSlots(points, baselineA, baselineB, constrained) {
+		const out = points.length > 3 ? clonePositions(points) : new Array(3);
+		out[baselineIndexA] = baselineA;
+		out[baselineIndexB] = baselineB;
+		out[constrainedIndexIn(out.length)] = constrained;
+		return out;
+	}
+	function snap(baselineA, baselineB, point) {
+		const frame = frameFor(baselineA, baselineB);
+		if (!frame) return null;
+		return frame.pointAtNormalDistance(frame.signedNormalDistance(point));
+	}
+	function derive(points) {
+		if (points.length < 2) return clonePositions(points);
+		if (points.length === 2) {
+			const baselineA = clonePosition(points[0]);
+			const baselineB = clonePosition(points[1]);
+			const frame = frameFor(baselineA, baselineB);
+			const derived = frame ? frame.pointAtNormalDistance(frame.length * defaultDistanceRatio) : null;
+			return derived ? packSlots([
+				baselineA,
+				baselineB,
+				derived
+			], baselineA, baselineB, derived) : [baselineA, baselineB];
 		}
-		distanceRemaining -= segmentLength;
-	}
-	const ptNeck = remainingSpine[remainingSpine.length - 1];
-	if (!ptNeck) return null;
-	const tipDir = vecNorm(vecSub(ptTip, ptNeck));
-	if (vecMag(tipDir) < 1e-6) return null;
-	const headLength = vecMag(vecSub(ptTip, ptBase));
-	const shaftHalfWidth = headHalfWidth * shaftRatio;
-	const perpDir = [-tipDir[1], tipDir[0]];
-	const outerLeft = vecAdd(ptBase, vecScale(perpDir, headHalfWidth));
-	const outerRight = vecAdd(ptBase, vecScale(perpDir, -headHalfWidth));
-	const innerLeft = vecAdd(ptBase, vecScale(perpDir, shaftHalfWidth));
-	const innerRight = vecAdd(ptBase, vecScale(perpDir, -shaftHalfWidth));
-	const notchDepth = headLength * shaftRatio;
-	const safeNotchDepth = Math.min(notchDepth, headLength - EPSILON);
-	const innerTip = vecAdd(ptBase, vecScale(tipDir, safeNotchDepth));
-	const shaftEndCenter = ptBase;
-	const headRing = [
-		outerLeft,
-		ptTip,
-		outerRight,
-		innerRight,
-		innerTip,
-		innerLeft,
-		outerLeft
-	];
-	const fullSpine = [...remainingSpine, shaftEndCenter];
-	const { left: shaftLeft, right: shaftRight } = offsetPolylineSides(fullSpine, interpolatePolylineValues(fullSpine, headHalfWidth * rearWidthRatio, shaftHalfWidth), smooth, smoothResolution);
-	return {
-		shaftCenterline: fullSpine,
-		shaftLeft,
-		shaftRight,
-		headRing,
-		ptTip,
-		ptNeck,
-		ptBase
-	};
-}
-/**
-* Calculates the relative metrics (longitudinal and lateral) of the width point
-* relative to the Tip-Neck axis.
-*
-* @param pts - Array of positions [Tip, Neck, ..., WidthPoint]
-* @returns { longitudinal: number, lateral: number } | null
-*/
-function calculateMetrics(pts) {
-	const tip = pts[0];
-	const neck = pts[1];
-	const widthPt = pts[pts.length - 1];
-	if (!tip || !neck || !widthPt) return null;
-	const tipM = project(tip[0], tip[1]);
-	const neckM = project(neck[0], neck[1]);
-	const widthM = project(widthPt[0], widthPt[1]);
-	const tx = tipM[0];
-	const ty = tipM[1];
-	const nx = neckM[0];
-	const ny = neckM[1];
-	const wx = widthM[0];
-	const wy = widthM[1];
-	const dx = tx - nx;
-	const dy = ty - ny;
-	const len = Math.sqrt(dx * dx + dy * dy);
-	if (len < 1e-6) return null;
-	const ax = dx / len;
-	const ay = dy / len;
-	const px = -ay;
-	const py = ax;
-	const vx = wx - tx;
-	const vy = wy - ty;
-	return {
-		longitudinal: vx * ax + vy * ay,
-		lateral: vx * px + vy * py
-	};
-}
-/**
-* Computes an initial Width Point based on the Tip and Neck positions.
-* It places the point perpendicular to the neck at a default distance relative to the length.
-*
-* @param tip - Tip position (Lon/Lat)
-* @param neck - Neck position (Lon/Lat)
-* @returns Width Point position (Lon/Lat)
-*/
-function computeInitialWidthPoint(tip, neck) {
-	const tipM = project(tip[0], tip[1]);
-	const neckM = project(neck[0], neck[1]);
-	const tx = tipM[0];
-	const ty = tipM[1];
-	const nx = neckM[0];
-	const ny = neckM[1];
-	const dx = tx - nx;
-	const dy = ty - ny;
-	const len = Math.sqrt(dx * dx + dy * dy);
-	if (len < 1e-6) return unproject(nx + 100, ny);
-	const ax = dx / len;
-	const ay = dy / len;
-	const widthRatio = .35;
-	const recessionRatio = .25;
-	const px = -ay;
-	const py = ax;
-	return unproject(tx - dx * recessionRatio + len * widthRatio * px, ty - dy * recessionRatio + len * widthRatio * py);
-}
-//#endregion
-//#region src/define.ts
-/**
-* Identity helper that infers a definition's literal `Id` and precise generator
-* type `G`, so the registry's `typeof DEFINITIONS` carries each measure's exact
-* options type. Internal authoring API — not part of the published surface.
-*/
-function defineControlMeasure(definition) {
-	return definition;
-}
-//#endregion
-//#region src/draw-rules/baseline-frame.ts
-function createBaselineFrame(p1, p2, options = {}) {
-	return createProjectedBaselineFrame(project(p1[0], p1[1]), project(p2[0], p2[1]), options);
-}
-function createProjectedBaselineFrame(p1, p2, options = {}) {
-	const baseline = vecSub(p2, p1);
-	const length = vecMag(baseline);
-	if (length < 1e-6) return null;
-	const direction = vecNorm(baseline);
-	const normalSign = options.normal === "left" ? -1 : 1;
-	const normal = vecScale([direction[1], -direction[0]], normalSign);
-	const origin = getOrigin(p1, p2, options.origin ?? "midpoint");
-	return {
-		p1,
-		p2,
-		origin,
-		direction,
-		normal,
-		length,
-		signedNormalDistance(point) {
-			return vecDot(vecSub(project(point[0], point[1]), origin), normal);
-		},
-		pointAtNormalDistance(distance) {
-			if (!Number.isFinite(distance)) return null;
-			const point = vecAdd(origin, vecScale(normal, distance));
-			return unproject(point[0], point[1]);
-		}
-	};
-}
-function getOrigin(p1, p2, origin) {
-	if (origin === "p1") return p1;
-	if (origin === "p2") return p2;
-	return vecScale(vecAdd(p1, p2), .5);
-}
-//#endregion
-//#region src/draw-rules/util.ts
-function clonePosition(position) {
-	return [...position];
-}
-function clonePositions(positions) {
-	return positions.map(clonePosition);
-}
-function samePosition(a, b) {
-	return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
-}
-//#endregion
-//#region src/draw-rules/midpoint-perpendicular.ts
-function createMidpointPerpendicularDrawRule(options) {
-	const defaultDistanceRatio = options.defaultDistanceRatio ?? 1.5;
-	const variableLength = options.variableLength ?? false;
-	const constrainedIndex = options.constrainedIndex ?? 2;
-	const baselineIndexA = constrainedIndex === 0 ? 1 : 0;
-	const baselineIndexB = constrainedIndex === 0 ? 2 : 1;
-	const frameOrigin = options.origin ?? "midpoint";
-	const frameNormal = options.normal ?? "right";
-	function frameFor(p1, p2) {
-		return createBaselineFrame(p1, p2, {
-			origin: frameOrigin,
-			normal: frameNormal
-		});
-	}
-	/** Slot holding the constrained point in an array of `count` points. */
-	function constrainedIndexIn(count) {
-		return variableLength ? count - 1 : constrainedIndex;
-	}
-	function packSlots(points, baselineA, baselineB, constrained) {
-		const out = points.length > 3 ? clonePositions(points) : new Array(3);
-		out[baselineIndexA] = baselineA;
-		out[baselineIndexB] = baselineB;
-		out[constrainedIndexIn(out.length)] = constrained;
-		return out;
-	}
-	function snap(baselineA, baselineB, point) {
-		const frame = frameFor(baselineA, baselineB);
-		if (!frame) return null;
-		return frame.pointAtNormalDistance(frame.signedNormalDistance(point));
-	}
-	function derive(points) {
-		if (points.length < 2) return clonePositions(points);
-		if (points.length === 2) {
-			const baselineA = clonePosition(points[0]);
-			const baselineB = clonePosition(points[1]);
-			const frame = frameFor(baselineA, baselineB);
-			const derived = frame ? frame.pointAtNormalDistance(frame.length * defaultDistanceRatio) : null;
-			return derived ? packSlots([
-				baselineA,
-				baselineB,
-				derived
-			], baselineA, baselineB, derived) : [baselineA, baselineB];
-		}
-		const baselineA = clonePosition(points[baselineIndexA]);
-		const baselineB = clonePosition(points[baselineIndexB]);
-		const rawConstrained = points[constrainedIndexIn(points.length)];
-		return packSlots(points, baselineA, baselineB, snap(baselineA, baselineB, rawConstrained) ?? clonePosition(rawConstrained));
+		const baselineA = clonePosition(points[baselineIndexA]);
+		const baselineB = clonePosition(points[baselineIndexB]);
+		const rawConstrained = points[constrainedIndexIn(points.length)];
+		return packSlots(points, baselineA, baselineB, snap(baselineA, baselineB, rawConstrained) ?? clonePosition(rawConstrained));
 	}
 	return {
 		id: options.id,
@@ -1558,1177 +1371,495 @@ const supportByFireDrawRule = {
 	}
 };
 //#endregion
-//#region src/draw-rules/axis1.ts
-function derive$2(points) {
-	if (points.length < 2) return clonePositions(points);
-	if (points.length === 2) {
-		const tip = clonePosition(points[0]);
-		const neck = clonePosition(points[1]);
-		return [
-			tip,
-			neck,
-			computeInitialWidthPoint(tip, neck)
-		];
-	}
-	return clonePositions(points);
-}
-function projectWidthIntoFrame(next, longitudinal, lateral) {
-	const tip = next[0];
-	const neck = next[1];
-	if (!tip || !neck) return null;
-	const tipM = project(tip[0], tip[1]);
-	const neckM = project(neck[0], neck[1]);
-	const dx = tipM[0] - neckM[0];
-	const dy = tipM[1] - neckM[1];
-	const len = Math.sqrt(dx * dx + dy * dy);
-	if (len < 1e-6) return null;
-	const ax = dx / len;
-	const ay = dy / len;
-	const px = -ay;
-	const py = ax;
-	return unproject(tipM[0] + longitudinal * ax + lateral * px, tipM[1] + longitudinal * ay + lateral * py);
-}
-function packWithWidth(next, width) {
-	const out = clonePositions(next);
-	out[out.length - 1] = width;
-	return out;
-}
-const axis1DrawRule = {
-	id: "axis1",
-	minimumUserPoints: 2,
-	trailingFixedSlots: 1,
-	derive: derive$2,
-	transform(event) {
-		const { previous, next, activePointIndex } = event;
-		if (next.length < 3 || previous.length < 3) return derive$2(next);
-		if (!(activePointIndex === 0 || activePointIndex === 1)) return clonePositions(next);
-		const metrics = calculateMetrics(previous);
-		if (!metrics) return clonePositions(next);
-		const projected = projectWidthIntoFrame(next, metrics.longitudinal, metrics.lateral);
-		if (!projected) return clonePositions(next);
-		return packWithWidth(next, projected);
-	}
-};
+//#region src/attack-utils.ts
+const DEFAULT_SHAFT_WIDTH_RATIO$1 = .6;
+const DEFAULT_REAR_WIDTH_RATIO = DEFAULT_SHAFT_WIDTH_RATIO$1;
+const SHAFT_MIN_RATIO = .1;
+const SHAFT_MAX_RATIO = .9;
+const REAR_WIDTH_OPTION_HANDLE_ID = "rear-width";
+const SHAFT_WIDTH_OPTION_HANDLE_ID = "shaft-width";
 /**
-* Recesses the CATK body from P1. The original P1 remains the tip of the fire
-* arrow, while P2 and the remaining Axis1 points continue to shape the body.
-*/
-function counterattackByFireBodyCoordinates(points) {
-	const fireTipCoordinate = points[0];
-	const neckCoordinate = points[1];
-	if (!fireTipCoordinate || !neckCoordinate) return null;
-	const fireTip = project(fireTipCoordinate[0], fireTipCoordinate[1]);
-	const terminal = vecSub(fireTip, project(neckCoordinate[0], neckCoordinate[1]));
-	if (vecMag(terminal) < 1e-6) return null;
-	const bodyTip = vecAdd(fireTip, vecScale(terminal, -.3));
-	return [unproject(bodyTip[0], bodyTip[1]), ...points.slice(1)];
-}
-function restoreFireTip(points, fireTip) {
-	if (points.length > 0 && fireTip) points[0] = clonePosition(fireTip);
-	return points;
-}
-/**
-* Axis1 interaction for Counterattack by Fire, with its width frame anchored
-* to the recessed CATK body tip rather than P1, which belongs to the separate
-* fire arrow.
+* Creates the definition-owned rear-/shaft-width handle pair shared by every
+* variable-width arrow body. Callers supply only how their own geometry maps
+* onto {@link WidthHandleGeometry}; placement (the two ends of the right edge)
+* and the drag math (perpendicular distance from the dragged point to the
+* matching centerline segment, over the reference half-width) live here once.
 */
-const counterattackByFireDrawRule = {
-	...axis1DrawRule,
-	id: "axis1:counterattack-by-fire",
-	derive(points) {
-		const bodyPoints = counterattackByFireBodyCoordinates(points);
-		if (!bodyPoints) return axis1DrawRule.derive(points);
-		return restoreFireTip(axis1DrawRule.derive(bodyPoints), points[0]);
-	},
-	transform(event) {
-		const previousBody = counterattackByFireBodyCoordinates(event.previous);
-		const nextBody = counterattackByFireBodyCoordinates(event.next);
-		if (!previousBody || !nextBody) return axis1DrawRule.transform(event);
-		return restoreFireTip(axis1DrawRule.transform({
-			...event,
-			previous: previousBody,
-			next: nextBody
-		}), event.next[0]);
-	}
-};
-//#endregion
-//#region src/draw-rules/area21.ts
-function derive$1(points) {
-	if (points.length === 2) return clonePositions([
-		points[0],
-		points[1],
-		points[1]
-	]);
-	return clonePositions(points);
+function createWidthOptionHandles(config) {
+	return {
+		get(controlPoints, options) {
+			const geometry = config.geometry(controlPoints, options);
+			const rearRight = geometry?.rightEdge[0];
+			const neckRight = geometry?.rightEdge.at(-1);
+			if (!rearRight || !neckRight) return [];
+			return [{
+				id: REAR_WIDTH_OPTION_HANDLE_ID,
+				position: unproject(rearRight[0], rearRight[1])
+			}, {
+				id: SHAFT_WIDTH_OPTION_HANDLE_ID,
+				position: unproject(neckRight[0], neckRight[1])
+			}];
+		},
+		drag({ controlPoints, options, handleId, position }) {
+			const rear = handleId === REAR_WIDTH_OPTION_HANDLE_ID;
+			if (!rear && !(handleId === "shaft-width")) return void 0;
+			const geometry = config.geometry(controlPoints, options);
+			if (!geometry || geometry.referenceHalfWidth < 1e-6) return void 0;
+			const from = rear ? geometry.spine[0] : geometry.spine.at(-2);
+			const to = rear ? geometry.spine[1] : geometry.spine.at(-1);
+			if (!from || !to) return void 0;
+			const ratio = clamp(pointToInfiniteLineDistance(project(position[0], position[1]), from, to) / geometry.referenceHalfWidth, config.minRatio, rear ? config.maxRearRatio : config.maxShaftRatio);
+			return rear ? { rearWidthRatio: ratio } : { shaftWidthRatio: ratio };
+		}
+	};
 }
-const searchAreaDrawRule = {
-	id: "area21:search-area",
-	minimumUserPoints: 3,
-	minimumPreviewPoints: 2,
-	canonicalPointCount: 3,
-	derive: derive$1,
-	transform(event) {
-		return derive$1(event.next);
-	}
-};
-//#endregion
-//#region src/draw-rules/rectangle.ts
 /**
-* Oriented rectangle: P1 and P2 are adjacent corners and define the first
-* edge. P3 is the next corner, constrained to the perpendicular through P2.
-* The generator derives the fourth corner.
+* The width handles for attack bodies built by {@link processAttackGeometry},
+* whose ratios are fractions of the arrowhead half-width. A coordinate resolver
+* lets derivative measures (Counterattack by Fire) map their authored Axis1
+* points to the body coordinates first.
 */
-function derive(points) {
-	if (points.length < 2) return clonePositions(points);
-	const p1 = clonePosition(points[0]);
-	const p2 = clonePosition(points[1]);
-	if (points.length === 2) return [
-		p1,
-		p2,
-		clonePosition(p2)
-	];
-	const frame = createBaselineFrame(p1, p2, {
-		origin: "p2",
-		normal: "right"
+function createVariableWidthAttackOptionHandles(resolveCoordinates = (points) => points) {
+	return createWidthOptionHandles({
+		geometry(controlPoints, options) {
+			const coordinates = resolveCoordinates(controlPoints);
+			if (!coordinates) return null;
+			const { geometry } = processAttackGeometry(coordinates, options);
+			const outerLeft = geometry?.headRing[0];
+			if (!geometry || !outerLeft) return null;
+			return {
+				spine: geometry.shaftCenterline,
+				rightEdge: geometry.shaftRight,
+				referenceHalfWidth: vecMag(vecSub(outerLeft, geometry.ptBase))
+			};
+		},
+		minRatio: SHAFT_MIN_RATIO,
+		maxRearRatio: 3,
+		maxShaftRatio: SHAFT_MAX_RATIO
 	});
-	return [
-		p1,
-		p2,
-		frame?.pointAtNormalDistance(frame.signedNormalDistance(points[2])) ?? clonePosition(points[2])
-	];
 }
-function guidePoints(points) {
-	const canonical = derive(points);
-	if (canonical.length < 3) return canonical;
-	const [c1, c2, c3] = canonical;
-	if (!c1 || !c2 || !c3) return canonical;
-	if (c2[0] === c3[0] && c2[1] === c3[1]) return [c1, c2];
-	const p1 = project(c1[0], c1[1]);
-	const p2 = project(c2[0], c2[1]);
-	const p4 = vecAdd(p1, vecSub(project(c3[0], c3[1]), p2));
-	return [
-		c1,
-		c2,
-		c3,
-		unproject(p4[0], p4[1]),
-		clonePosition(c1)
-	];
+const variableWidthAttackOptionHandles = createVariableWidthAttackOptionHandles();
+/**
+* The single home of the "rear inherits shaft" rule: an omitted `rearWidthRatio`
+* leaves the body parallel by matching the effective shaft ratio. Every
+* variable-width body resolves the option through here so the rule cannot drift.
+*/
+function resolveRearWidthRatio(options, shaftRatio) {
+	return options.rearWidthRatio ?? shaftRatio;
 }
-function snapToAxis(point, origin, direction) {
-	const snapped = vecAdd(origin, vecScale(direction, vecDot(vecSub(project(point[0], point[1]), origin), direction)));
-	return unproject(snapped[0], snapped[1]);
+/**
+* Processes input coordinates and options to generate the core symbol geometry.
+* This handles validation, default values, projection, and geometry calculation.
+*/
+function processAttackGeometry(coordinates, options = {}) {
+	const shaftRatio = clamp(options.shaftWidthRatio ?? .6, SHAFT_MIN_RATIO, SHAFT_MAX_RATIO);
+	const smooth = options.smooth ?? false;
+	const smoothResolution = options.smoothResolution ?? 5;
+	const rearRatio = clamp(resolveRearWidthRatio(options, shaftRatio), SHAFT_MIN_RATIO, 3);
+	const points = coordinates.map((c) => project(c[0], c[1]));
+	const numPoints = points.length;
+	const ptTip = points[0];
+	const ptWidth = points[numPoints - 1];
+	const spinePoints = [];
+	for (let i = numPoints - 2; i >= 1; i--) {
+		const p = points[i];
+		if (p) spinePoints.push(p);
+	}
+	return { geometry: calculateSymbolGeometry(ptTip, ptWidth, spinePoints, shaftRatio, rearRatio, smooth, smoothResolution) };
 }
-const rectangleDrawRule = {
-	id: "rectangle",
-	minimumUserPoints: 3,
-	minimumPreviewPoints: 2,
-	canonicalPointCount: 3,
-	showGuide: true,
-	guidePoints,
-	derive,
-	transform(event) {
-		const { previous, next, activePointIndex } = event;
-		if (previous.length < 3 || next.length < 3) return derive(next);
-		const frame = createBaselineFrame(previous[0], previous[1], {
-			origin: "p2",
-			normal: "right"
-		});
-		if (!frame) return derive(next);
-		if (activePointIndex === 0) return [
-			snapToAxis(next[0], frame.p2, frame.direction),
-			clonePosition(previous[1]),
-			clonePosition(previous[2])
-		];
-		if (activePointIndex === 1) {
-			const p2 = snapToAxis(next[1], frame.p1, frame.direction);
-			const delta = vecSub(project(p2[0], p2[1]), frame.p2);
-			const projectedP3 = vecAdd(project(previous[2][0], previous[2][1]), delta);
-			const p3 = unproject(projectedP3[0], projectedP3[1]);
-			return [
-				clonePosition(previous[0]),
-				p2,
-				p3
-			];
-		}
-		if (activePointIndex === 2) {
-			const p3 = frame.pointAtNormalDistance(frame.signedNormalDistance(next[2]));
-			if (p3) return [
-				clonePosition(previous[0]),
-				clonePosition(previous[1]),
-				p3
-			];
+function calculateSymbolGeometry(ptTip, ptWidth, spine, shaftRatio, rearWidthRatio, smooth, smoothResolution) {
+	const initialNeck = spine[spine.length - 1];
+	if (!initialNeck) return null;
+	const initialTipDir = vecNorm(vecSub(ptTip, initialNeck));
+	if (vecMag(initialTipDir) < 1e-6) return null;
+	const headHalfWidth = pointToInfiniteLineDistance(ptWidth, initialNeck, ptTip);
+	const vecTipToWidth = vecSub(ptTip, ptWidth);
+	const requestedHeadLength = Math.max(EPSILON, vecDot(vecTipToWidth, initialTipDir));
+	const path = [...spine, ptTip];
+	let totalArcLength = 0;
+	for (let i = 1; i < path.length; i++) totalArcLength += vecMag(vecSub(path[i], path[i - 1]));
+	const minimumShaftLength = Math.max(EPSILON, totalArcLength * .01);
+	let distanceRemaining = clamp(requestedHeadLength, EPSILON, Math.max(EPSILON, totalArcLength - minimumShaftLength));
+	let ptBase = ptTip;
+	let remainingSpine = spine;
+	for (let i = path.length - 1; i > 0; i--) {
+		const segmentEnd = path[i];
+		const segmentStart = path[i - 1];
+		const segment = vecSub(segmentStart, segmentEnd);
+		const segmentLength = vecMag(segment);
+		if (segmentLength < 1e-6) continue;
+		if (distanceRemaining < segmentLength) {
+			ptBase = vecAdd(segmentEnd, vecScale(segment, distanceRemaining / segmentLength));
+			remainingSpine = path.slice(0, i);
+			break;
 		}
-		return derive(next);
+		distanceRemaining -= segmentLength;
 	}
-};
-//#endregion
-//#region src/draw-rules/line25.ts
-/** Line25: PT. 1 is the arrow tip; PT. 2 is the rear of the symbol. */
-const line25DrawRule = {
-	id: "line25",
-	minimumUserPoints: 2,
-	canonicalPointCount: 2,
-	derive: (points) => clonePositions(points.slice(0, 2)),
-	transform: (event) => clonePositions(event.next.slice(0, 2))
-};
-//#endregion
-//#region src/internal/echelon.ts
+	const ptNeck = remainingSpine[remainingSpine.length - 1];
+	if (!ptNeck) return null;
+	const tipDir = vecNorm(vecSub(ptTip, ptNeck));
+	if (vecMag(tipDir) < 1e-6) return null;
+	const headLength = vecMag(vecSub(ptTip, ptBase));
+	const shaftHalfWidth = headHalfWidth * shaftRatio;
+	const perpDir = [-tipDir[1], tipDir[0]];
+	const outerLeft = vecAdd(ptBase, vecScale(perpDir, headHalfWidth));
+	const outerRight = vecAdd(ptBase, vecScale(perpDir, -headHalfWidth));
+	const innerLeft = vecAdd(ptBase, vecScale(perpDir, shaftHalfWidth));
+	const innerRight = vecAdd(ptBase, vecScale(perpDir, -shaftHalfWidth));
+	const notchDepth = headLength * shaftRatio;
+	const safeNotchDepth = Math.min(notchDepth, headLength - EPSILON);
+	const innerTip = vecAdd(ptBase, vecScale(tipDir, safeNotchDepth));
+	const shaftEndCenter = ptBase;
+	const headRing = [
+		outerLeft,
+		ptTip,
+		outerRight,
+		innerRight,
+		innerTip,
+		innerLeft,
+		outerLeft
+	];
+	const fullSpine = [...remainingSpine, shaftEndCenter];
+	const { left: shaftLeft, right: shaftRight } = offsetPolylineSides(fullSpine, interpolatePolylineValues(fullSpine, headHalfWidth * rearWidthRatio, shaftHalfWidth), smooth, smoothResolution);
+	return {
+		shaftCenterline: fullSpine,
+		shaftLeft,
+		shaftRight,
+		headRing,
+		ptTip,
+		ptNeck,
+		ptBase
+	};
+}
 /**
-* APP-6 echelon (Field B) glyph vocabulary, shared by the control measures that
-* stamp a unit-size amplifier onto their geometry (Boundary, Battle Position).
+* Calculates the relative metrics (longitudinal and lateral) of the width point
+* relative to the Tip-Neck axis.
 *
-* A compact port of the APP-6 echelon designs, modeled on milsymbol but
-* expressed as parametric geometry so it bakes into GeoJSON and strokes
-* monocolor (ADR-0023). Every glyph is built from three primitives — vertical
-* bars, crosses, and dots — plus the team/crew ring and command `++`.
+* @param pts - Array of positions [Tip, Neck, ..., WidthPoint]
+* @returns { longitudinal: number, lateral: number } | null
 */
-const ECHELONS = {
-	team: {
-		kind: "ring",
-		count: 1,
-		label: "Team/Crew"
-	},
-	crew: {
-		kind: "ring",
-		count: 1
-	},
-	squad: {
-		kind: "dots",
-		count: 1,
-		label: "Squad"
-	},
-	section: {
-		kind: "dots",
-		count: 2,
-		label: "Section"
-	},
-	platoon: {
-		kind: "dots",
-		count: 3,
-		label: "Platoon"
-	},
-	company: {
-		kind: "bars",
-		count: 1,
-		label: "Company"
-	},
-	battalion: {
-		kind: "bars",
-		count: 2,
-		label: "Battalion"
-	},
-	regiment: {
-		kind: "bars",
-		count: 3,
-		label: "Regiment"
-	},
-	brigade: {
-		kind: "crosses",
-		count: 1,
-		label: "Brigade"
-	},
-	division: {
-		kind: "crosses",
-		count: 2,
-		label: "Division"
-	},
-	corps: {
-		kind: "crosses",
-		count: 3,
-		label: "Corps"
-	},
-	army: {
-		kind: "crosses",
-		count: 4,
-		label: "Army"
-	},
-	"army-group": {
-		kind: "crosses",
-		count: 5,
-		label: "Army Group"
-	},
-	region: {
-		kind: "crosses",
-		count: 6,
-		label: "Region"
-	},
-	command: {
-		kind: "command",
-		count: 2,
-		label: "Command"
-	}
-};
-/** Symbol-form aliases (`"XX"`, `"II"`, `"•••"`, …) → canonical echelon key. */
-const ECHELON_ALIASES = {
-	ø: "team",
-	"•": "squad",
-	"••": "section",
-	"•••": "platoon",
-	i: "company",
-	ii: "battalion",
-	iii: "regiment",
-	x: "brigade",
-	xx: "division",
-	xxx: "corps",
-	xxxx: "army",
-	xxxxx: "army-group",
-	xxxxxx: "region",
-	"++": "command"
-};
-/** Enum options for the params panel, derived from {@link ECHELONS}. */
-const ECHELON_PARAM_OPTIONS = [{
-	label: "None",
-	value: "none"
-}, ...Object.entries(ECHELONS).filter(([, spec]) => spec.label !== void 0).map(([value, spec]) => ({
-	label: spec.label,
-	value
-}))];
+function calculateMetrics(pts) {
+	const tip = pts[0];
+	const neck = pts[1];
+	const widthPt = pts[pts.length - 1];
+	if (!tip || !neck || !widthPt) return null;
+	const tipM = project(tip[0], tip[1]);
+	const neckM = project(neck[0], neck[1]);
+	const widthM = project(widthPt[0], widthPt[1]);
+	const tx = tipM[0];
+	const ty = tipM[1];
+	const nx = neckM[0];
+	const ny = neckM[1];
+	const wx = widthM[0];
+	const wy = widthM[1];
+	const dx = tx - nx;
+	const dy = ty - ny;
+	const len = Math.sqrt(dx * dx + dy * dy);
+	if (len < 1e-6) return null;
+	const ax = dx / len;
+	const ay = dy / len;
+	const px = -ay;
+	const py = ax;
+	const vx = wx - tx;
+	const vy = wy - ty;
+	return {
+		longitudinal: vx * ax + vy * ay,
+		lateral: vx * px + vy * py
+	};
+}
 /**
-* 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.
+* Computes an initial Width Point based on the Tip and Neck positions.
+* It places the point perpendicular to the neck at a default distance relative to the length.
+*
+* @param tip - Tip position (Lon/Lat)
+* @param neck - Neck position (Lon/Lat)
+* @returns Width Point position (Lon/Lat)
 */
-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);
+function computeInitialWidthPoint(tip, neck) {
+	const tipM = project(tip[0], tip[1]);
+	const neckM = project(neck[0], neck[1]);
+	const tx = tipM[0];
+	const ty = tipM[1];
+	const nx = neckM[0];
+	const ny = neckM[1];
+	const dx = tx - nx;
+	const dy = ty - ny;
+	const len = Math.sqrt(dx * dx + dy * dy);
+	if (len < 1e-6) return unproject(nx + 100, ny);
+	const ax = dx / len;
+	const ay = dy / len;
+	const widthRatio = .35;
+	const recessionRatio = .25;
+	const px = -ay;
+	const py = ax;
+	return unproject(tx - dx * recessionRatio + len * widthRatio * px, ty - dy * recessionRatio + len * widthRatio * py);
 }
-function resolveEchelon(echelon) {
-	const key = echelon.trim().toLowerCase();
-	if (key.length === 0) return void 0;
-	const alias = ECHELON_ALIASES[key];
-	return ECHELONS[key] ?? (alias ? ECHELONS[alias] : void 0);
+//#endregion
+//#region src/draw-rules/axis1.ts
+function derive$2(points) {
+	if (points.length < 2) return clonePositions(points);
+	if (points.length === 2) {
+		const tip = clonePosition(points[0]);
+		const neck = clonePosition(points[1]);
+		return [
+			tip,
+			neck,
+			computeInitialWidthPoint(tip, neck)
+		];
+	}
+	return clonePositions(points);
 }
-/**
-* Builds the echelon glyph centered at `center`, with its baseline along
-* `along` and `perp` (both unit vectors), `h` meters tall. Returns the glyph's
-* `strokes` (open polylines), `fills` (closed rings drawn as solid shapes —
-* the squad/section/platoon dots), and its intrinsic width along the line; the
-* caller adds the configurable side padding to derive the line gap.
-*/
-function buildEchelonGlyph(center, along, perp, h, spec) {
-	const P = (a, p) => {
-		const q = vecAdd(vecAdd(center, vecScale(along, a)), vecScale(perp, p));
-		return unproject(q[0], q[1]);
-	};
-	const ring = (a, r) => {
-		const pts = [];
-		const steps = 16;
-		for (let i = 0; i <= steps; i++) {
-			const t = 2 * Math.PI * i / steps;
-			pts.push(P(a + r * Math.cos(t), r * Math.sin(t)));
-		}
-		return pts;
-	};
-	const strokes = [];
-	const fills = [];
-	const half = h / 2;
-	switch (spec.kind) {
-		case "bars": {
-			const spacing = h * .8;
-			const total = (spec.count - 1) * spacing;
-			for (let j = 0; j < spec.count; j++) {
-				const a = -total / 2 + j * spacing;
-				strokes.push([P(a, -half), P(a, half)]);
-			}
-			return {
-				strokes,
-				fills,
-				width: total
-			};
-		}
-		case "crosses": {
-			const w = h;
-			const spacing = h * 1.4;
-			const total = (spec.count - 1) * spacing;
-			for (let j = 0; j < spec.count; j++) {
-				const a0 = -total / 2 + j * spacing;
-				strokes.push([P(a0 - w / 2, -half), P(a0 + w / 2, half)]);
-				strokes.push([P(a0 - w / 2, half), P(a0 + w / 2, -half)]);
-			}
-			return {
-				strokes,
-				fills,
-				width: total + w
-			};
-		}
-		case "dots": {
-			const r = h * .3;
-			const spacing = h * 1.2;
-			const total = (spec.count - 1) * spacing;
-			for (let j = 0; j < spec.count; j++) fills.push(ring(-total / 2 + j * spacing, r));
-			return {
-				strokes,
-				fills,
-				width: total + 2 * r
-			};
-		}
-		case "ring": {
-			const r = h * .6;
-			strokes.push(ring(0, r));
-			strokes.push([P(-h * .8, -h * .4), P(h * .8, h * .4)]);
-			return {
-				strokes,
-				fills,
-				width: h * 1.6
-			};
-		}
-		case "command": {
-			const arm = h * .5;
-			const spacing = h * 1.4;
-			const total = (spec.count - 1) * spacing;
-			for (let j = 0; j < spec.count; j++) {
-				const a0 = -total / 2 + j * spacing;
-				strokes.push([P(a0 - arm, 0), P(a0 + arm, 0)]);
-				strokes.push([P(a0, -half), P(a0, half)]);
-			}
-			return {
-				strokes,
-				fills,
-				width: total + 2 * arm
-			};
-		}
+function projectWidthIntoFrame(next, longitudinal, lateral) {
+	const tip = next[0];
+	const neck = next[1];
+	if (!tip || !neck) return null;
+	const tipM = project(tip[0], tip[1]);
+	const neckM = project(neck[0], neck[1]);
+	const dx = tipM[0] - neckM[0];
+	const dy = tipM[1] - neckM[1];
+	const len = Math.sqrt(dx * dx + dy * dy);
+	if (len < 1e-6) return null;
+	const ax = dx / len;
+	const ay = dy / len;
+	const px = -ay;
+	const py = ax;
+	return unproject(tipM[0] + longitudinal * ax + lateral * px, tipM[1] + longitudinal * ay + lateral * py);
+}
+function packWithWidth(next, width) {
+	const out = clonePositions(next);
+	out[out.length - 1] = width;
+	return out;
+}
+const axis1DrawRule = {
+	id: "axis1",
+	minimumUserPoints: 2,
+	trailingFixedSlots: 1,
+	derive: derive$2,
+	transform(event) {
+		const { previous, next, activePointIndex } = event;
+		if (next.length < 3 || previous.length < 3) return derive$2(next);
+		if (!(activePointIndex === 0 || activePointIndex === 1)) return clonePositions(next);
+		const metrics = calculateMetrics(previous);
+		if (!metrics) return clonePositions(next);
+		const projected = projectWidthIntoFrame(next, metrics.longitudinal, metrics.lateral);
+		if (!projected) return clonePositions(next);
+		return packWithWidth(next, projected);
 	}
+};
+/**
+* Recesses the CATK body from P1. The original P1 remains the tip of the fire
+* arrow, while P2 and the remaining Axis1 points continue to shape the body.
+*/
+function counterattackByFireBodyCoordinates(points) {
+	const fireTipCoordinate = points[0];
+	const neckCoordinate = points[1];
+	if (!fireTipCoordinate || !neckCoordinate) return null;
+	const fireTip = project(fireTipCoordinate[0], fireTipCoordinate[1]);
+	const terminal = vecSub(fireTip, project(neckCoordinate[0], neckCoordinate[1]));
+	if (vecMag(terminal) < 1e-6) return null;
+	const bodyTip = vecAdd(fireTip, vecScale(terminal, -.3));
+	return [unproject(bodyTip[0], bodyTip[1]), ...points.slice(1)];
 }
-//#endregion
-//#region src/generators/cm15-maneuver-areas/params.ts
-const AREA_SMOOTH_PARAMS = [{
-	key: "smooth",
-	label: "Smooth",
-	description: "Round the area's corners by curving the boundary through the control points.",
-	type: "boolean"
-}, {
-	key: "smoothResolution",
-	presentationTier: "advanced",
-	label: "Smooth resolution",
-	description: "Number of samples per segment when smooth mode is enabled.",
-	type: "number",
-	min: 2,
-	max: 64,
-	step: 1,
-	visibleWhen: (opts) => Boolean(opts.smooth)
-}];
-const ATTACK_SHAFT_PARAMS = [
-	{
-		key: "shaftWidthRatio",
-		presentationTier: "advanced",
-		label: "Shaft width",
-		description: "Arrow shaft width as a ratio of the arrowhead width",
-		type: "number",
-		min: .1,
-		max: 1,
-		step: .05
-	},
-	{
-		key: "rearWidthRatio",
-		presentationTier: "advanced",
-		label: "Rear width",
-		description: "Width at the rear of the shaft as a ratio of the arrowhead width.",
-		type: "number",
-		min: .1,
-		max: 2,
-		step: .05
-	},
-	{
-		key: "smooth",
-		label: "Smooth",
-		description: "Round the corners where the shaft changes direction.",
-		type: "boolean"
+function restoreFireTip(points, fireTip) {
+	if (points.length > 0 && fireTip) points[0] = clonePosition(fireTip);
+	return points;
+}
+/**
+* Axis1 interaction for Counterattack by Fire, with its width frame anchored
+* to the recessed CATK body tip rather than P1, which belongs to the separate
+* fire arrow.
+*/
+const counterattackByFireDrawRule = {
+	...axis1DrawRule,
+	id: "axis1:counterattack-by-fire",
+	derive(points) {
+		const bodyPoints = counterattackByFireBodyCoordinates(points);
+		if (!bodyPoints) return axis1DrawRule.derive(points);
+		return restoreFireTip(axis1DrawRule.derive(bodyPoints), points[0]);
 	},
-	{
-		key: "smoothResolution",
-		presentationTier: "advanced",
-		label: "Smooth resolution",
-		description: "Number of segments approximating each rounded bend when smooth mode is enabled.",
-		type: "number",
-		min: 1,
-		max: 20,
-		step: 1,
-		visibleWhen: (opts) => opts.smooth === true
+	transform(event) {
+		const previousBody = counterattackByFireBodyCoordinates(event.previous);
+		const nextBody = counterattackByFireBodyCoordinates(event.next);
+		if (!previousBody || !nextBody) return axis1DrawRule.transform(event);
+		return restoreFireTip(axis1DrawRule.transform({
+			...event,
+			previous: previousBody,
+			next: nextBody
+		}), event.next[0]);
 	}
-];
-const FIRE_ARROW_PARAMS = [
-	{
-		key: "arrowheadWidthRatio",
-		presentationTier: "advanced",
-		label: "Arrowhead width",
-		description: "Arrowhead width as a ratio of the shaft length",
-		type: "number",
-		min: .05,
-		max: 1,
-		step: .01
-	},
-	{
-		key: "rearLineLengthRatio",
-		presentationTier: "advanced",
-		label: "Rear line length",
-		description: "Length of the rear flare lines as a ratio of the head",
-		type: "number",
-		min: .05,
-		max: 1,
-		step: .01
-	},
-	{
-		key: "rearLineAngle",
-		presentationTier: "advanced",
-		label: "Rear line angle",
-		description: "Angle of the rear flare lines, in degrees",
-		type: "number",
-		min: 0,
-		max: 90,
-		step: 1
+};
+//#endregion
+//#region src/draw-rules/area21.ts
+function derive$1(points) {
+	if (points.length === 2) return clonePositions([
+		points[0],
+		points[1],
+		points[1]
+	]);
+	return clonePositions(points);
+}
+const searchAreaDrawRule = {
+	id: "area21:search-area",
+	minimumUserPoints: 3,
+	minimumPreviewPoints: 2,
+	canonicalPointCount: 3,
+	derive: derive$1,
+	transform(event) {
+		return derive$1(event.next);
 	}
-];
-const FORTIFIED_AREA_SIZE_PARAMS = [{
-	key: "toothSizePixels",
-	label: "Tooth size",
-	description: "Size of the fortified-area teeth, in pixels",
-	type: "number",
-	min: 5,
-	max: 50,
-	step: 1,
-	unit: "px"
-}, {
-	key: "toothSize",
-	label: "Tooth size",
-	description: "Size of the fortified-area teeth, in meters",
-	type: "number",
-	min: 1,
-	max: 500,
-	step: 1,
-	unit: "m"
-}];
-const ENCIRCLEMENT_PARAMS = [
-	{
-		key: "smooth",
-		label: "Smooth",
-		description: "Round the boundary by curving it through the control points.",
-		type: "boolean"
-	},
-	{
-		key: "smoothResolution",
-		presentationTier: "advanced",
-		label: "Smooth resolution",
-		description: "Number of samples per segment when smooth mode is enabled.",
-		type: "number",
-		min: 2,
-		max: 64,
-		step: 1,
-		visibleWhen: (opts) => Boolean(opts.smooth)
-	},
-	{
-		key: "barbSpacingRatio",
-		presentationTier: "advanced",
-		label: "Spacing",
-		description: "Spacing between barbs as a ratio of the symbol radius (smaller is denser).",
-		type: "number",
-		min: .15,
-		max: 1.5,
-		step: .05
-	},
-	{
-		key: "barbLengthRatio",
-		presentationTier: "advanced",
-		label: "Barb length",
-		description: "Barb height as a ratio of the symbol radius (amplitude).",
-		type: "number",
-		min: .02,
-		max: .5,
-		step: .01
-	}
-];
-const FORTIFIED_AREA_PARAMS = [...AREA_SMOOTH_PARAMS, ...FORTIFIED_AREA_SIZE_PARAMS];
-const AREA_LABEL_PADDING_PARAM = {
-	key: "labelPadding",
-	presentationTier: "advanced",
-	label: "Label padding",
-	description: "Extra spacing between or around the area's labels, as a ratio of label height",
-	type: "number",
-	min: 0,
-	max: 2,
-	step: .05
-};
-const MULTILINE_AREA_LABEL_PARAM = {
-	key: "multilineLabel",
-	label: "Multiline label",
-	description: "Place the doctrinal label above Field T on separate centered lines",
-	type: "boolean"
-};
-const LABELED_AREA_PARAMS = [...AREA_SMOOTH_PARAMS, AREA_LABEL_PADDING_PARAM];
-const PREFIXED_LABELED_AREA_PARAMS = [
-	...AREA_SMOOTH_PARAMS,
-	MULTILINE_AREA_LABEL_PARAM,
-	AREA_LABEL_PADDING_PARAM
-];
-const ECHELON_GLYPH_PARAMS = [
-	{
-		key: "echelon",
-		label: "Echelon",
-		description: "Field B unit-size amplifier, drawn on the boundary.",
-		type: "enum",
-		presentationTier: "primary",
-		semanticRole: "doctrinal",
-		options: ECHELON_PARAM_OPTIONS
-	},
-	{
-		key: "echelonSizePixels",
-		label: "Echelon size",
-		description: "Echelon glyph height in screen pixels.",
-		type: "number",
-		min: 8,
-		max: 48,
-		step: 1,
-		unit: "px"
-	},
-	{
-		key: "echelonSize",
-		label: "Echelon size",
-		description: "Echelon glyph height in meters.",
-		type: "number",
-		min: 50,
-		max: 2e4,
-		step: 50,
-		unit: "m"
-	},
-	{
-		key: "echelonPadding",
-		presentationTier: "advanced",
-		label: "Echelon padding",
-		description: "Gap on each side of the echelon, as a ratio of its height.",
-		type: "number",
-		min: 0,
-		max: 2,
-		step: .05
-	},
-	{
-		key: "echelonPosition",
-		presentationTier: "advanced",
-		label: "Echelon position",
-		description: "Slide the echelon along the boundary, as a fraction of the perimeter from the bottom edge.",
-		type: "number",
-		min: -.5,
-		max: .5,
-		step: .01
-	}
-];
-const ECHELON_AREA_PARAMS = [
-	...AREA_SMOOTH_PARAMS,
-	...ECHELON_GLYPH_PARAMS,
-	AREA_LABEL_PADDING_PARAM
-];
-const PREFIXED_ECHELON_AREA_PARAMS = [
-	...AREA_SMOOTH_PARAMS,
-	MULTILINE_AREA_LABEL_PARAM,
-	...ECHELON_GLYPH_PARAMS,
-	AREA_LABEL_PADDING_PARAM
-];
-const AREA_DESIGNATION_AMPLIFIER = {
-	key: "T",
-	label: "Unique designation",
-	description: "Field T — the unit's designation, centered in the area.",
-	maxLength: 21
-};
-const AREA_HOSTILE_AMPLIFIER = {
-	key: "N",
-	label: "Hostile (ENY) marker",
-	description: "Field N — literal \"ENY\" marker at the area's west and east edges.",
-	placeholder: "ENY",
-	maxLength: 3
 };
-const AREA_TEXT_AMPLIFIERS = [
-	{
-		key: "T",
-		label: "Unique designation",
-		description: "Field T — the area's unique designation.",
-		maxLength: 21
-	},
-	{
-		key: "H",
-		label: "Additional information",
-		description: "Field H — additional free-text information, shown below the designation.",
-		maxLength: 20
-	},
-	{
-		key: "W",
-		label: "Effective from (DTG)",
-		description: "Field W — date-time group the area becomes effective.",
-		placeholder: "051030Z",
-		maxLength: 16
-	},
-	{
-		key: "W1",
-		label: "Effective to (DTG)",
-		description: "Field W1 — date-time group the area ceases to be effective.",
-		maxLength: 16
-	},
-	AREA_HOSTILE_AMPLIFIER
-];
-const AREA_UNIT_DESIGNATION_HOSTILE_AMPLIFIERS = [AREA_DESIGNATION_AMPLIFIER, AREA_HOSTILE_AMPLIFIER];
-/** {@link AREA_TEXT_AMPLIFIERS} without the H (additional information) field,
-*  for measures whose template omits that row but keeps the W/W1 window and
-*  the N (hostile) marker (Submarine Action Area, Submarine-Generated Action
-*  Area). */
-const AREA_TEXT_AMPLIFIERS_NO_ADDITIONAL_INFO = AREA_TEXT_AMPLIFIERS.filter((d) => d.key !== "H");
-/** {@link AREA_TEXT_AMPLIFIERS} reduced to just the designation (Field T) and
-*  hostile marker (Field N), for measures whose template carries no
-*  additional-information or date-time-group rows (Area, Drop Zone,
-*  Extraction Zone). */
-const AREA_TEXT_AMPLIFIERS_DESIGNATION_HOSTILE = AREA_TEXT_AMPLIFIERS.filter((d) => d.key === "T" || d.key === "N");
 //#endregion
-//#region src/generators/cm15-maneuver-areas/airborneAttack.ts
-const DEFAULT_AIRBORNE_ATTACK_OPTIONS = {
-	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
-	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
-	smooth: false,
-	smoothResolution: 5
-};
-const AIRBORNE_ATTACK_METADATA = {
-	id: "airborne-attack",
-	name: "Airborne Attack",
-	description: "Airborne or aviation axis of advance.",
-	entity: "Maneuver Areas",
-	entityType: "Axis of Advance",
-	entitySubtype: "Airborne Attack",
-	value: "151401",
-	minCoordinates: 3,
-	geometry: "line",
-	geometryTypes: ["LineString"],
-	paints: {
-		stroke: true,
-		fill: "none",
-		text: false
-	},
-	drawRule: "Axis1",
-	params: ATTACK_SHAFT_PARAMS
-};
+//#region src/draw-rules/rectangle.ts
 /**
-* Generates a GeoJSON FeatureCollection for an Airborne Attack tactical symbol.
-*
-* The symbol is similar to Supporting Attack but features a crossover point
-* between the shaft and the head (Points 1 and 2/Neck).
-*
-* @param coordinates - An array of GeoJSON Positions.
-* @param options - Configuration options.
-* @returns A GeoJSON FeatureCollection<LineString>.
+* Oriented rectangle: P1 and P2 are adjacent corners and define the first
+* edge. P3 is the next corner, constrained to the perpendicular through P2.
+* The generator derives the fourth corner.
 */
-function createAirborneAttack(coordinates, options = {}) {
-	const { geometry } = processAttackGeometry(coordinates, options);
-	if (!geometry) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const shaftLeftToNeck = geometry.shaftLeft.slice(0, -1);
-	const shaftRightToNeck = geometry.shaftRight.slice(0, -1);
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {},
-			geometry: {
-				type: "LineString",
-				coordinates: [
-					...shaftLeftToNeck,
-					geometry.headRing[3],
-					geometry.headRing[2],
-					geometry.headRing[1],
-					geometry.headRing[0],
-					geometry.headRing[5],
-					...[...shaftRightToNeck].reverse()
-				].map((p) => unproject(p[0], p[1]))
-			}
-		}]
-	};
-}
-const AIRBORNE_ATTACK = defineControlMeasure({
-	metadata: AIRBORNE_ATTACK_METADATA,
-	generator: createAirborneAttack,
-	defaultOptions: DEFAULT_AIRBORNE_ATTACK_OPTIONS,
-	rule: axis1DrawRule,
-	optionHandles: variableWidthAttackOptionHandles
-});
-/**
-* Reacts to an **input-contract** violation according to `mode`: `throw`
-* raises, `warn` logs, `silent` (the default) does neither. Always returns
-* `false` so a caller can `return reportValidationIssue(...)` from a guard.
-*
-* Governs the *input contract* only (control-point count and finiteness),
-* checked once at the render seam — not geometric degeneracy, which always
-* yields an empty render silently. See ADR-0014 and the `CONTEXT.md` terms.
-*/
-function reportValidationIssue(mode, message) {
-	const resolved = mode ?? "silent";
-	if (resolved === "throw") throw new Error(message);
-	if (resolved === "warn") console.warn(message);
-	return false;
+function derive(points) {
+	if (points.length < 2) return clonePositions(points);
+	const p1 = clonePosition(points[0]);
+	const p2 = clonePosition(points[1]);
+	if (points.length === 2) return [
+		p1,
+		p2,
+		clonePosition(p2)
+	];
+	const frame = createBaselineFrame(p1, p2, {
+		origin: "p2",
+		normal: "right"
+	});
+	return [
+		p1,
+		p2,
+		frame?.pointAtNormalDistance(frame.signedNormalDistance(points[2])) ?? clonePosition(points[2])
+	];
 }
-/**
-* Narrows a control-point array to the fixed `[PT1, PT2, PT3]` tuple the ambush
-* and search-area generators require. The render seam has already validated
-* that at least three valid points are present (ADR-0014), so this is a pure
-* cast with no runtime guard. Used by those measures' definition adapters so
-* the generators keep their precise tuple parameter (ADR-0013).
-*/
-function asThreePoints(points) {
+function guidePoints(points) {
+	const canonical = derive(points);
+	if (canonical.length < 3) return canonical;
+	const [c1, c2, c3] = canonical;
+	if (!c1 || !c2 || !c3) return canonical;
+	if (c2[0] === c3[0] && c2[1] === c3[1]) return [c1, c2];
+	const p1 = project(c1[0], c1[1]);
+	const p2 = project(c2[0], c2[1]);
+	const p4 = vecAdd(p1, vecSub(project(c3[0], c3[1]), p2));
 	return [
-		points[0],
-		points[1],
-		points[2]
+		c1,
+		c2,
+		c3,
+		unproject(p4[0], p4[1]),
+		clonePosition(c1)
 	];
 }
-const DEFAULT_AMBUSH_OPTIONS = {
-	arrowheadLengthRatio: .15,
-	arrowheadWidthRatio: .5,
-	hatchLengthRatio: .15,
-	hatchCount: 5,
-	curveDepthRatio: .25,
-	arcSegments: 30
-};
-const AMBUSH_METADATA = {
-	id: "ambush",
-	name: "Ambush",
-	description: "A variation of attack from concealed positions against a moving or temporarily halted enemy.",
-	entity: "Maneuver Lines",
-	entityType: "Ambush",
-	value: "141700",
-	minCoordinates: 3,
-	maxCoordinates: 3,
-	geometry: "line",
-	geometryTypes: ["MultiLineString"],
-	paints: {
-		stroke: true,
-		fill: "none",
-		text: false
-	},
-	drawRule: "Line29",
-	params: [
-		{
-			key: "arrowheadLengthRatio",
-			presentationTier: "advanced",
-			label: "Arrowhead length",
-			description: "Arrowhead length as a ratio of the chord span",
-			type: "number",
-			min: .01,
-			max: .5,
-			step: .01
-		},
-		{
-			key: "arrowheadWidthRatio",
-			presentationTier: "advanced",
-			label: "Arrowhead width",
-			description: "Arrowhead base width as a multiple of the arrowhead length",
-			type: "number",
-			min: .05,
-			max: 2,
-			step: .01
-		},
-		{
-			key: "hatchLengthRatio",
-			presentationTier: "advanced",
-			label: "Hatch length",
-			description: "Length of the parallel hatches as a fraction of the chord span",
-			type: "number",
-			min: .01,
-			max: .5,
-			step: .01
-		},
-		{
-			key: "hatchCount",
-			presentationTier: "advanced",
-			label: "Hatch count",
-			description: "Number of parallel hatches spaced along the curve",
-			type: "number",
-			min: 0,
-			max: 20,
-			step: 1
-		},
-		{
-			key: "curveDepthRatio",
-			presentationTier: "advanced",
-			label: "Curve depth",
-			description: "How far the back line bends toward the tip, as a fraction of the chord span",
-			type: "number",
-			min: 0,
-			max: 1,
-			step: .01
-		},
-		{
-			key: "arcSegments",
-			label: "Arc segments",
-			description: "Number of segments used to render the curve",
-			type: "number",
-			presentationTier: "advanced",
-			min: 4,
-			max: 96,
-			step: 1
+function snapToAxis(point, origin, direction) {
+	const snapped = vecAdd(origin, vecScale(direction, vecDot(vecSub(project(point[0], point[1]), origin), direction)));
+	return unproject(snapped[0], snapped[1]);
+}
+const rectangleDrawRule = {
+	id: "rectangle",
+	minimumUserPoints: 3,
+	minimumPreviewPoints: 2,
+	canonicalPointCount: 3,
+	showGuide: true,
+	guidePoints,
+	derive,
+	transform(event) {
+		const { previous, next, activePointIndex } = event;
+		if (previous.length < 3 || next.length < 3) return derive(next);
+		const frame = createBaselineFrame(previous[0], previous[1], {
+			origin: "p2",
+			normal: "right"
+		});
+		if (!frame) return derive(next);
+		if (activePointIndex === 0) return [
+			snapToAxis(next[0], frame.p2, frame.direction),
+			clonePosition(previous[1]),
+			clonePosition(previous[2])
+		];
+		if (activePointIndex === 1) {
+			const p2 = snapToAxis(next[1], frame.p1, frame.direction);
+			const delta = vecSub(project(p2[0], p2[1]), frame.p2);
+			const projectedP3 = vecAdd(project(previous[2][0], previous[2][1]), delta);
+			const p3 = unproject(projectedP3[0], projectedP3[1]);
+			return [
+				clonePosition(previous[0]),
+				p2,
+				p3
+			];
 		}
-	]
+		if (activePointIndex === 2) {
+			const p3 = frame.pointAtNormalDistance(frame.signedNormalDistance(next[2]));
+			if (p3) return [
+				clonePosition(previous[0]),
+				clonePosition(previous[1]),
+				p3
+			];
+		}
+		return derive(next);
+	}
 };
-const quadBezier = (t, a, b, c) => {
-	const it = 1 - t;
-	return [it * it * a[0] + 2 * it * t * b[0] + t * t * c[0], it * it * a[1] + 2 * it * t * b[1] + t * t * c[1]];
+//#endregion
+//#region src/draw-rules/line25.ts
+/** Line25: PT. 1 is the arrow tip; PT. 2 is the rear of the symbol. */
+const line25DrawRule = {
+	id: "line25",
+	minimumUserPoints: 2,
+	canonicalPointCount: 2,
+	derive: (points) => clonePositions(points.slice(0, 2)),
+	transform: (event) => clonePositions(event.next.slice(0, 2))
 };
+//#endregion
+//#region src/internal/angle-utils.ts
 /**
-* Generates a GeoJSON FeatureCollection for an AMBUSH tactical symbol.
-* Handles internal projection to maintain strict perpendicularity and parallel hatching.
-*
-* @param coordinates - [PT 1 (Target Tip), PT 2 (Back Chord End), PT 3 (Back Chord End)]
-* @param options - Geometric and styling parameters
-* @returns GeoJSON FeatureCollection containing LineString components
+* Wraps an angle (radians) into the half-open range (-π, π].
 */
-function createAmbushSymbol(coordinates, options = {}) {
-	const { arrowheadLengthRatio, arrowheadWidthRatio, hatchLengthRatio, hatchCount, curveDepthRatio, arcSegments } = {
-		...DEFAULT_AMBUSH_OPTIONS,
-		...options
-	};
-	const safeArcSegments = Math.max(1, Math.floor(arcSegments));
-	const safeHatchCount = Math.max(0, Math.floor(hatchCount));
-	const safeArrowheadLengthRatio = Math.max(0, arrowheadLengthRatio);
-	const safeArrowheadWidthRatio = Math.max(0, arrowheadWidthRatio);
-	const safeHatchLengthRatio = Math.max(0, hatchLengthRatio);
-	const safeCurveDepthRatio = Math.max(0, curveDepthRatio);
-	const [p1, p2, p3] = coordinates.map((coord) => project(coord[0], coord[1]));
-	const mid = vecScale(vecAdd(p2, p3), .5);
-	const v23 = vecSub(p3, p2);
-	const span = vecMag(v23);
-	if (span < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const dir23 = vecNorm(v23);
-	const n = [-dir23[1], dir23[0]];
-	const dist = vecDot(vecSub(p1, mid), n);
-	const side = dist >= 0 ? 1 : -1;
-	const ctrl = vecAdd(mid, vecScale(n, side * span * safeCurveDepthRatio));
-	const shaftOrigin = quadBezier(.5, p2, ctrl, p3);
-	const adjP1 = vecAdd(shaftOrigin, vecScale(n, side * Math.max(0, Math.abs(dist) - span * safeCurveDepthRatio * .5)));
-	const lines = [];
-	lines.push([shaftOrigin, adjP1]);
-	const hL = span * safeArrowheadLengthRatio;
-	const hw = hL * safeArrowheadWidthRatio;
-	const hBase = vecSub(adjP1, vecScale(n, side * hL));
-	const perp = [-n[1], n[0]];
-	lines.push([
-		vecAdd(hBase, vecScale(perp, hw)),
-		adjP1,
-		vecSub(hBase, vecScale(perp, hw))
-	]);
-	const curve = [];
-	for (let i = 0; i <= safeArcSegments; i++) {
-		const t = i / safeArcSegments;
-		curve.push(quadBezier(t, p2, ctrl, p3));
-	}
-	lines.push(curve);
-	const hatchLengthActual = span * safeHatchLengthRatio;
-	for (let i = 1; i <= safeHatchCount; i++) {
-		const pt = quadBezier(i / (safeHatchCount + 1), p2, ctrl, p3);
-		lines.push([pt, vecSub(pt, vecScale(n, side * hatchLengthActual))]);
-	}
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {},
-			geometry: {
-				type: "MultiLineString",
-				coordinates: lines.map((line) => line.map((c) => unproject(c[0], c[1])))
-			}
-		}]
-	};
-}
-const AMBUSH = defineControlMeasure({
-	metadata: AMBUSH_METADATA,
-	generator: (controlPoints, options) => createAmbushSymbol(asThreePoints(controlPoints), options),
-	defaultOptions: DEFAULT_AMBUSH_OPTIONS,
-	rule: ambushDrawRule
-});
-//#endregion
-//#region src/internal/gapped-line.ts
-/**
-* Pushes the arc-length gap `[g0, g1]` onto `gaps`, normalizing it onto
-* `[0, total)` and splitting it into two intervals when it straddles a ring
-* seam ({@link buildGappedLine} walks a flat array and does not wrap on its
-* own). Use this for closed rings; open polylines can push {@link ArcGap}s
-* directly.
-*/
-function pushWrappedGap(gaps, g0, g1, total) {
-	if (g1 - g0 >= total) {
-		gaps.push({
-			g0: 0,
-			g1: total
-		});
-		return;
-	}
-	const lo = (g0 % total + total) % total;
-	const hi = (g1 % total + total) % total;
-	if (lo <= hi) gaps.push({
-		g0: lo,
-		g1: hi
-	});
-	else {
-		gaps.push({
-			g0: lo,
-			g1: total
-		});
-		gaps.push({
-			g0: 0,
-			g1: hi
-		});
-	}
-}
-/** Whether the global arc position `arc` falls inside any of `gaps` (each
-*  already normalized onto `[0, total)` by {@link pushWrappedGap}, so a plain
-*  per-gap interval test suffices). Shared by the boundary-decoration measures
-*  that suppress a glyph/tic/barb sitting on top of a masking gap. */
-function arcInGaps(arc, gaps) {
-	return gaps.some((g) => arc >= g.g0 && arc <= g.g1);
-}
-/** Appends `position` unless it coincides with the buffer's current tail. */
-function appendUnique(buffer, position) {
-	const tail = buffer[buffer.length - 1];
-	if (tail && Math.abs(tail[0] - position[0]) < 1e-9 && Math.abs(tail[1] - position[1]) < 1e-9) return;
-	buffer.push(position);
-}
-/**
-* Builds the polyline as MultiLineString rings, splitting it with a gap at each
-* echelon position. `gaps` holds global arc-length intervals (distance from the
-* start of the whole polyline) to carve out — a single gap can span several
-* short segments, which matters when the line has been smoothed into many
-* samples. Works for both open polylines and closed rings (pass a vertex array
-* whose first and last positions coincide).
-*/
-function buildGappedLine(verts, gaps) {
-	const parts = [];
-	let buffer = [];
-	const flush = () => {
-		if (buffer.length >= 2) parts.push(buffer);
-		buffer = [];
-	};
-	if (verts.length === 0) return parts;
-	const merged = [];
-	for (const g of [...gaps].sort((x, y) => x.g0 - y.g0)) {
-		const last = merged[merged.length - 1];
-		if (last && g.g0 <= last.g1) last.g1 = Math.max(last.g1, g.g1);
-		else merged.push({ ...g });
-	}
-	appendUnique(buffer, unproject(verts[0][0], verts[0][1]));
-	let dist = 0;
-	for (let i = 0; i < verts.length - 1; i++) {
-		const a = verts[i];
-		const b = verts[i + 1];
-		const seg = vecSub(b, a);
-		const L = vecMag(seg);
-		if (L < 1e-6) continue;
-		const segStart = dist;
-		const segEnd = dist + L;
-		const along = vecNorm(seg);
-		const pointAt = (globalD) => {
-			const q = vecAdd(a, vecScale(along, globalD - segStart));
-			return unproject(q[0], q[1]);
-		};
-		for (const g of merged) {
-			if (g.g1 <= segStart || g.g0 >= segEnd) continue;
-			const g0 = Math.max(segStart, g.g0);
-			const g1 = Math.min(segEnd, g.g1);
-			if (g1 <= g0) continue;
-			appendUnique(buffer, pointAt(g0));
-			flush();
-			buffer.push(pointAt(g1));
-		}
-		appendUnique(buffer, unproject(b[0], b[1]));
-		dist = segEnd;
-	}
-	flush();
-	return parts;
-}
-//#endregion
-//#region src/style.ts
-/**
-* Per-feature style hint pinning a filled part to a solid interior. Attach to
-* a generator's intrinsic doctrinal accents — arrowheads, teeth, echelon
-* glyphs, barbs, blades — so a patterned (`hatch`, `dots`, …) fill set at the graphicsStyle
-* or measure layer never bleeds into a small silhouette and ruins its
-* legibility. The renderer only reads style hints, so one shared instance is
-* safe to reuse across every accent feature.
-*/
-const SOLID_ACCENT_FILL = { fillPattern: "solid" };
-/**
-* Ultimate fallback for the symbol color when no `color` or per-channel
-* override is supplied at any layer. Keeps a zero-config render monocolor
-* black and guarantees filled parts still render filled. See ADR-0011.
-*/
-const DEFAULT_SYMBOL_COLOR = "#000000";
-//#endregion
-//#region src/portrayal.ts
-const DEFAULT_STROKE_WIDTH_CSS_PIXELS = 2;
-const DEFAULT_STROKE_DASH_CSS_PIXELS = Object.freeze([]);
-const DEFAULT_LINE_CAP = "round";
-const DEFAULT_LINE_JOIN = "round";
-const DEFAULT_LABEL_HEIGHT_CSS_PIXELS = 14;
-const DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS = {
-	min: 8,
-	max: 24
-};
-/** Shared absent-value portrayal defaults; render output remains sparse. */
-const DEFAULT_PORTRAYAL = Object.freeze({
-	symbolColor: DEFAULT_SYMBOL_COLOR,
-	strokeWidthCssPixels: 2,
-	strokeDashCssPixels: DEFAULT_STROKE_DASH_CSS_PIXELS,
-	lineCap: DEFAULT_LINE_CAP,
-	lineJoin: DEFAULT_LINE_JOIN,
-	labelHeightCssPixels: 14
-});
-//#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;
-}
-/** Wraps a degree value into the canonical clockwise `[0, 360)` range. */
-function normalizeDegrees(degrees) {
-	return (degrees % 360 + 360) % 360;
-}
-/**
-* 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.
-* Returns `null` for degenerate input (fewer than two points, a zero-length
-* path, or a zero-length final segment) so the caller can decide what to emit.
-*/
-function arrowAxis(coordinates) {
-	if (coordinates.length < 2) return null;
-	const pts = coordinates.map((c) => project(c[0], c[1]));
-	let pathLength = 0;
-	for (let i = 0; i < pts.length - 1; i++) pathLength += Math.hypot(pts[i + 1][0] - pts[i][0], pts[i + 1][1] - pts[i][1]);
-	const tip = pts[pts.length - 1];
-	const prev = pts[pts.length - 2];
-	const hx = tip[0] - prev[0];
-	const hy = tip[1] - prev[1];
-	const segLength = Math.hypot(hx, hy);
-	if (segLength === 0 || pathLength === 0) return null;
-	const dir = [hx / segLength, hy / segLength];
-	const perp = [-dir[1], dir[0]];
-	return {
-		pts,
-		pathLength,
-		tip,
-		dir,
-		perp,
-		segLength
+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;
+}
+/** Wraps a degree value into the canonical clockwise `[0, 360)` range. */
+function normalizeDegrees(degrees) {
+	return (degrees % 360 + 360) % 360;
+}
+/**
+* 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.
+* Returns `null` for degenerate input (fewer than two points, a zero-length
+* path, or a zero-length final segment) so the caller can decide what to emit.
+*/
+function arrowAxis(coordinates) {
+	if (coordinates.length < 2) return null;
+	const pts = coordinates.map((c) => project(c[0], c[1]));
+	let pathLength = 0;
+	for (let i = 0; i < pts.length - 1; i++) pathLength += Math.hypot(pts[i + 1][0] - pts[i][0], pts[i + 1][1] - pts[i][1]);
+	const tip = pts[pts.length - 1];
+	const prev = pts[pts.length - 2];
+	const hx = tip[0] - prev[0];
+	const hy = tip[1] - prev[1];
+	const segLength = Math.hypot(hx, hy);
+	if (segLength === 0 || pathLength === 0) return null;
+	const dir = [hx / segLength, hy / segLength];
+	const perp = [-dir[1], dir[0]];
+	return {
+		pts,
+		pathLength,
+		tip,
+		dir,
+		perp,
+		segLength
 	};
 }
 /**
@@ -3209,286 +2340,1699 @@ const DEFAULT_LABEL_KNOCKOUT_PADDING = .3;
 const HOSTILE_LINE_AMPLIFIER = {
 	key: "N",
 	label: "Hostile (ENY) marker",
-	description: "Field N — literal \"ENY\" marker beyond both ends of the line.",
+	description: "Field N — literal \"ENY\" marker beyond both ends of the line.",
+	placeholder: "ENY",
+	maxLength: 3
+};
+/** Label-padding control shared by label-bearing graphics. */
+const LABEL_PADDING_PARAM = {
+	key: "labelPadding",
+	presentationTier: "advanced",
+	label: "Label padding",
+	description: "Extra clearance around labels, as a ratio of the label height",
+	type: "number",
+	min: 0,
+	max: 2,
+	step: .05
+};
+/**
+* Resolves {@link LabelSizeOptions} into the single text-size property the
+* label feature carries (ADR-0028): `textSizePixels` when screen-anchored
+* (`labelSizePixels` present — pixels win over a stray `labelSize`),
+* `textSizeMeters` when ground-anchored (`labelSize` alone), or neither, in
+* which case adapters render their engine default, screen-fixed.
+*/
+function labelSizeProps(options) {
+	const { labelSize, labelSizePixels } = options;
+	if (labelSizePixels !== void 0) return { textSizePixels: labelSizePixels };
+	if (labelSize !== void 0) return { textSizeMeters: labelSize };
+	return {};
+}
+/** Pushes a `part: "label"` Point feature at projected `point`. */
+function pushLabel(out, point, text, rotation, sizeProps, textAnchor, amplifierField, labelPlacementKey) {
+	out.push({
+		type: "Feature",
+		properties: {
+			part: "label",
+			text,
+			rotation,
+			...textAnchor ? { textAnchor } : {},
+			...amplifierField ? { amplifierField } : {},
+			...labelPlacementKey ? { labelPlacementKey } : {},
+			...sizeProps
+		},
+		geometry: {
+			type: "Point",
+			coordinates: unproject(point[0], point[1])
+		}
+	});
+}
+/** Ratio of resolved label height (`labelSize`, or `labelSizePixels × metersPerPixel`) used as end-label clearance. */
+const END_LABEL_CLEARANCE_RATIO = .3;
+/** Ratio of resolved label height used to inset "above" end labels from the tip. */
+const ABOVE_LABEL_INSET_RATIO = .3;
+/** Ratio of resolved label height used as the "above" end labels' perpendicular offset. */
+const ABOVE_LABEL_OFFSET_RATIO = .6;
+function textHeight(options) {
+	const { labelSize, labelSizePixels, metersPerPixel } = options;
+	if (labelSizePixels !== void 0) return metersPerPixel !== void 0 && metersPerPixel > 0 ? labelSizePixels * metersPerPixel : void 0;
+	return labelSize;
+}
+/**
+* Label offset in meters: `ratio` × the label's resolved height (`labelSize`
+* meters, or `labelSizePixels × metersPerPixel` when screen-anchored), or
+* `fallbackMeters` when no size resolves (e.g. no map resolution yet). The fallback is small
+* relative to typical control measure spans — the same order of magnitude as
+* Boundary's own smallest label offsets — so a fixed label still reads as "just
+* clear of the line" rather than crowding it or floating away. Callers supply
+* their own ratio (end-label clearance, "above" inset/offset, center-group
+* offset) but share this single resolution+fallback rule.
+*/
+function resolveLabelOffsetMeters(options, ratio, fallbackMeters = 50) {
+	const h = textHeight(options);
+	return h !== void 0 ? ratio * h : fallbackMeters;
+}
+/**
+* Places one label just beyond each end of `verts` (projected meters), along
+* the outward direction of that end's segment, reading along the line
+* ({@link labelRotationAlong} is sign-independent, so the outward-pointing
+* `along` reads correctly). `textForEnd` supplies each end's text — a shared
+* string, or a function keyed by which end; an empty string skips that end.
+*
+* `textAnchor` is chosen so the text grows AWAY from the line: adapters flip
+* a label's rendered baseline (via {@link keepTextLeftToRight}) whenever its
+* direction points leftward, and that flip happens exactly when `along[0] <
+* 0` (same quadrant test `labelRotationAlong` relies on) — mirroring
+* Boundary's `vecDot` sign trick, "start" anchors the text at the point when
+* there is no flip, "end" when there is, so the anchored edge always sits at
+* the point and the text body always extends outward.
+*/
+function pushEndLabels(out, verts, textForEnd, options = {}) {
+	const frames = endFrames(verts);
+	const sizeProps = labelSizeProps(options);
+	const clearance = resolveLabelOffsetMeters(options, END_LABEL_CLEARANCE_RATIO + Math.max(0, options.labelPadding ?? 0));
+	for (const end of ["start", "end"]) {
+		const frame = frames[end];
+		if (!frame) continue;
+		const text = typeof textForEnd === "string" ? textForEnd : textForEnd(end);
+		if (text.length === 0) continue;
+		pushLabel(out, vecAdd(frame.point, vecScale(frame.along, clearance)), text, labelRotationAlong(frame.along), sizeProps, frame.along[0] >= 0 ? "start" : "end");
+	}
+}
+/**
+* Approximate sans-serif character width/height ratio, used to estimate a
+* label's rendered text width from its character count when no live text
+* measurement is available at generator time.
+*/
+const LABEL_CHAR_ASPECT_RATIO = .6;
+/**
+* Half a single glyph's width, as a ratio of its height — the base boundary
+* gap a measure reserves for one intrinsic capital letter (Retain's R,
+* Contain's C). Wider than half `LABEL_CHAR_ASPECT_RATIO` because these
+* glyphs are stamped alone rather than averaged over a word.
+*/
+const LABEL_HALF_GLYPH_RATIO = .45;
+/** Estimated rendered width of `text` given its resolved label height in meters. */
+function estimatedTextWidth(text, textHeightMeters) {
+	return text.length * LABEL_CHAR_ASPECT_RATIO * textHeightMeters;
+}
+/** Resolve the label's final display size, then measure and convert it to construction metres. */
+function resolveTextMetrics(text, options, context, style = "regular", fallbackHeightMeters = 50) {
+	const legacyHeight = resolveLabelOffsetMeters(options, 1, fallbackHeightMeters);
+	const constructionScale = context?.constructionMetersPerCssPixel;
+	if (!(constructionScale !== void 0 && constructionScale > 0)) return {
+		width: estimatedTextWidth(text, legacyHeight),
+		height: legacyHeight
+	};
+	let sizeCssPixels;
+	if (options.labelSizePixels !== void 0) sizeCssPixels = options.labelSizePixels;
+	else if (options.labelSize !== void 0) {
+		const requested = options.labelSize / constructionScale;
+		const requestedBand = context?.labelSizeClampCssPixels;
+		const band = requestedBand && Number.isFinite(requestedBand.min) && requestedBand.min >= 0 && Number.isFinite(requestedBand.max) && requestedBand.max >= 0 ? requestedBand : DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS;
+		const min = Math.min(band.min, band.max);
+		const max = Math.max(band.min, band.max);
+		sizeCssPixels = Math.min(max, Math.max(min, requested));
+	} else sizeCssPixels = 14;
+	const fallbackHeight = sizeCssPixels * constructionScale;
+	const measured = context?.measureText?.({
+		text,
+		style,
+		sizeCssPixels
+	});
+	if (!measured || !Number.isFinite(measured.widthCssPixels) || measured.widthCssPixels < 0 || !Number.isFinite(measured.heightCssPixels) || measured.heightCssPixels < 0) return {
+		width: estimatedTextWidth(text, fallbackHeight),
+		height: fallbackHeight
+	};
+	return {
+		width: measured.widthCssPixels * constructionScale,
+		height: measured.heightCssPixels * constructionScale
+	};
+}
+/**
+* Half-length of the knockout required for a label along `direction`.
+*
+* The text box itself is always cleared; `labelPadding` adds symmetric clearance expressed in
+* resolved label heights. Keeping this calculation here gives every generator the same public
+* label-clearance interface while hiding font measurement and rotated-box projection details.
+*/
+function labelKnockoutHalfExtent(text, direction, rotation, options, context, defaultPadding = 0) {
+	const metrics = resolveTextMetrics(text, options, context);
+	const padding = Math.max(0, options.labelPadding ?? defaultPadding) * metrics.height;
+	return labelHalfExtent(direction, metrics.width, metrics.height, rotation) + padding;
+}
+/**
+* {@link labelKnockoutHalfExtent} expressed as a fraction of an arc's angular
+* sweep, for generators that carve their knockout in arc-progress space rather
+* than in meters. Clamped to `0.5` so the gap can never exceed the arc.
+*/
+function arcKnockoutHalfFraction(halfExtentMeters, radius, sweepAngle) {
+	const arcLength = radius * Math.abs(sweepAngle);
+	if (!(arcLength > 1e-6)) return .5;
+	return Math.min(.5, Math.max(0, halfExtentMeters) / arcLength);
+}
+/** The end-label text for a phase-line naming, or `""` when unnamed. */
+function phaseLineLabelText(name, includePrefix) {
+	if (!name) return "";
+	return includePrefix ? `PL ${name}` : name;
+}
+/**
+* Places a Field N hostile marker beyond each end of `verts`, following the
+* same tangent, rotation, anchor, size, and padding conventions as
+* {@link pushEndLabels}. When another beyond-tip label is present, its
+* estimated width is added so the hostile marker remains outermost.
+*/
+function pushHostileEndLabels(out, verts, hostileText, options = {}, occupiedTextForEnd = "", context) {
+	if (!hostileText) return;
+	const frames = endFrames(verts);
+	const sizeProps = labelSizeProps(options);
+	for (const end of ["start", "end"]) {
+		const frame = frames[end];
+		if (!frame) continue;
+		const occupiedText = typeof occupiedTextForEnd === "string" ? occupiedTextForEnd : occupiedTextForEnd(end);
+		const metrics = resolveTextMetrics(occupiedText || hostileText, options, context);
+		const clearance = (END_LABEL_CLEARANCE_RATIO + Math.max(0, options.labelPadding ?? 0)) * metrics.height;
+		const distance = clearance + (occupiedText ? metrics.width + clearance : 0);
+		pushLabel(out, vecAdd(frame.point, vecScale(frame.along, distance)), hostileText, labelRotationAlong(frame.along), sizeProps, frame.along[0] >= 0 ? "start" : "end", "N", `label:N:${end}`);
+	}
+}
+/**
+* Resolves the {@link AboveEndFrame} at each tip of `verts` (projected meters):
+* a base point inset from the tip toward the interior, the segment's own
+* natural `perp` (so "above" = `+perp` reads the same at both ends), the
+* one-row perpendicular `offset`, the along-line `rotation`, and the
+* interior-growing `textAnchor`. Shared by {@link pushEndLabelsAbove} (one
+* label per tip, at `base + perp·offset`) and generic-c2-line's dual
+* above/below amplifier labels (`base ± perp·offset`), so both build on the
+* same tangent/inset/anchor math instead of re-deriving it.
+*/
+function aboveEndFrames(verts, options) {
+	const tangents = endTangents(verts);
+	const inset = resolveLabelOffsetMeters(options, ABOVE_LABEL_INSET_RATIO);
+	const offset = resolveLabelOffsetMeters(options, ABOVE_LABEL_OFFSET_RATIO + Math.max(0, options.labelPadding ?? 0));
+	const frames = {};
+	for (const end of ["start", "end"]) {
+		const tangent = tangents[end];
+		if (!tangent) continue;
+		frames[end] = {
+			base: vecAdd(tangent.point, vecScale(tangent.interior, inset)),
+			perp: tangent.perp,
+			offset,
+			rotation: labelRotationAlong(tangent.interior),
+			textAnchor: tangent.outwardX >= 0 ? "end" : "start"
+		};
+	}
+	return frames;
+}
+/**
+* Places one label above each end of `verts` (projected meters), inset
+* slightly from the tip and anchored toward the line's interior — the MIL-
+* STD-2525E template convention for fixed end labels like "LL"/"HOL"/"BHL"
+* (as opposed to Phase Line's "beyond the tip" placement, see
+* {@link pushEndLabels}). Placement comes from {@link aboveEndFrames}, which
+* generic-c2-line's H/T-above + W/W1-below labels share. `textForEnd` supplies
+* each end's text — a shared string, or a function keyed by which end; an empty
+* string skips that end.
+*/
+function pushEndLabelsAbove(out, verts, textForEnd, options = {}) {
+	const frames = aboveEndFrames(verts, options);
+	const sizeProps = labelSizeProps(options);
+	for (const end of ["start", "end"]) {
+		const frame = frames[end];
+		if (!frame) continue;
+		const text = typeof textForEnd === "string" ? textForEnd : textForEnd(end);
+		if (text.length === 0) continue;
+		pushLabel(out, vecAdd(frame.base, vecScale(frame.perp, frame.offset)), text, frame.rotation, sizeProps, frame.textAnchor);
+	}
+}
+/**
+* Convenience for measures that are just a polyline with a fixed label at
+* each end: builds the LineString through `positions` plus its end labels
+* (via {@link pushEndLabels} or {@link pushEndLabelsAbove}, per `placement`)
+* as a complete FeatureCollection.
+*/
+function fixedLabelLineFeatures(positions, options, textForEnd, hostileText, context) {
+	const { part, placement = "beyond", phaseLineName, includePrefix = true, lineStyle, smooth, smoothResolution, ...sizeOptions } = options;
+	const verts = smoothLineVerts(positions.map((p) => project(p[0], p[1])), {
+		smooth,
+		smoothResolution
+	}, 12);
+	const lineCoordinates = smooth ? verts.map((v) => unproject(v[0], v[1])) : positions;
+	const features = [{
+		type: "Feature",
+		properties: lineStyle === void 0 ? { part } : {
+			part,
+			style: lineStyle
+		},
+		geometry: {
+			type: "LineString",
+			coordinates: lineCoordinates
+		}
+	}];
+	const labelFeatures = [];
+	if (placement === "above") pushEndLabelsAbove(labelFeatures, verts, textForEnd, sizeOptions);
+	else pushEndLabels(labelFeatures, verts, textForEnd, sizeOptions);
+	const nameText = phaseLineLabelText(phaseLineName?.trim(), includePrefix);
+	if (nameText) pushEndLabels(labelFeatures, verts, nameText, sizeOptions);
+	pushHostileEndLabels(labelFeatures, verts, hostileText, sizeOptions, nameText || (placement === "beyond" ? textForEnd : ""), context);
+	features.push(...labelFeatures);
+	return {
+		type: "FeatureCollection",
+		features
+	};
+}
+//#endregion
+//#region src/generators/cm34-mission-tasks/shared.ts
+/**
+* Builds an open chevron arrowhead (left → tip → right) as unprojected
+* coordinates. The tip sits at `tip`, pointing along `dir`, with the base set
+* back by `length` and spanning `width` perpendicular to the shaft. Mirrors the
+* `createArrowHead` helper used by the attack-family generators.
+*/
+function createArrowHead$2(tip, dir, length, width) {
+	const norm = [-dir[1], dir[0]];
+	const base = vecSub(tip, vecScale(dir, length));
+	const left = vecAdd(base, vecScale(norm, width / 2));
+	const right = vecSub(base, vecScale(norm, width / 2));
+	return [
+		unproject(left[0], left[1]),
+		unproject(tip[0], tip[1]),
+		unproject(right[0], right[1])
+	];
+}
+/**
+* Builds the glyph label as a Point feature, forwarding the resolved size
+* anchor (`textSizeMeters`/`textSizePixels`, ADR-0028) to adapters for
+* styling. `point` is in projected meters; the rotation must already be in
+* the generator's feature-rotation convention. Shared by every mission-task
+* measure that centers a glyph on its symbol.
+*/
+function createLabelFeature(point, text, rotation, labelSize = {}) {
+	return {
+		type: "Feature",
+		properties: {
+			part: "label",
+			labelPlacement: false,
+			text,
+			rotation,
+			...labelSizeProps(labelSize)
+		},
+		geometry: {
+			type: "Point",
+			coordinates: unproject(point[0], point[1])
+		}
+	};
+}
+/**
+* Shared scaffold for the "bracket" mission-task symbols (breach, bypass,
+* canalize). Owns the three-sided bracket: a front opening (PT. 1 / PT. 2), a
+* rear line parallel to it through PT. 3, and a glyph centered on the rear line.
+* Each measure supplies only its end caps and label glyph via
+* {@link BracketSymbolConfig}.
+*
+* Input Points:
+* - PT. 1: Front opening endpoint (top/left)
+* - PT. 2: Front opening endpoint (bottom/right) - defines height with PT. 1
+* - PT. 3: Rear point - defines length and orientation
+*
+* Geometric Construction:
+* 1. PT. 1 and PT. 2 define the front opening (facing enemy/objective)
+* 2. A parallel line is projected through PT. 3 with identical height
+* 3. LineString follows: PT. 1 → Rear Top → Rear Bottom → PT. 2
+* 4. Measure-specific end caps at PT. 1 and PT. 2
+* 5. Label point at midpoint of rear line (styled with OpenLayers Text)
+*
+* @param coordinates - [PT. 1, PT. 2, PT. 3] as Position arrays
+* @param config - Per-measure end caps, label glyph, and sizing
+* @returns GeoJSON FeatureCollection containing MultiLineString and Point features
+*/
+function createBracketSymbol(coordinates, config, context) {
+	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 vFront = vecSub(p2, p1);
+	const frontLength = vecMag(vFront);
+	if (frontLength < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const dirFront = vecNorm(vFront);
+	const frontMidpoint = vecScale(vecAdd(p1, p2), .5);
+	const vToRear = vecSub(p3, frontMidpoint);
+	const perpDir = [-dirFront[1], dirFront[0]];
+	const perpDistance = vToRear[0] * perpDir[0] + vToRear[1] * perpDir[1];
+	const halfFront = vecScale(dirFront, frontLength / 2);
+	const rearMidpoint = vecAdd(frontMidpoint, vecScale(perpDir, perpDistance));
+	const rearTop = vecSub(rearMidpoint, halfFront);
+	const rearBottom = vecAdd(rearMidpoint, halfFront);
+	const rearLineRotation = Math.atan2(dirFront[1], dirFront[0]);
+	const renderedLabelRotation = Math.PI - (rearLineRotation - Math.PI / 2);
+	const labelRotation = normalizeRadians(Math.PI - keepTextLeftToRight(renderedLabelRotation));
+	const gapHalf = Math.min(frontLength / 2, labelKnockoutHalfExtent(config.labelText, dirFront, labelRotation, config.labelOptions ?? {}, context));
+	const gapPt1 = vecAdd(rearMidpoint, vecScale(dirFront, -gapHalf));
+	const gapPt2 = vecAdd(rearMidpoint, vecScale(dirFront, gapHalf));
+	const [topCap, bottomCap] = config.buildEndCaps({
+		p1,
+		p2,
+		dirFront,
+		perpDir,
+		frontLength,
+		rearTop
+	});
+	return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: { part: config.part },
+			geometry: {
+				type: "MultiLineString",
+				coordinates: [
+					topCap,
+					[
+						unproject(p1[0], p1[1]),
+						unproject(rearTop[0], rearTop[1]),
+						unproject(gapPt1[0], gapPt1[1])
+					],
+					[
+						unproject(gapPt2[0], gapPt2[1]),
+						unproject(rearBottom[0], rearBottom[1]),
+						unproject(p2[0], p2[1])
+					],
+					bottomCap
+				]
+			}
+		}, createLabelFeature(rearMidpoint, config.labelText, labelRotation, config.labelOptions)]
+	};
+}
+/** The single sized dimension every cross-symbol mission task shares. */
+const CROSS_TASK_SIZE_PAIR = {
+	id: "size",
+	label: "Size",
+	pixels: "sizePixels",
+	meters: "sizeMeters",
+	defaultUnit: "px",
+	rendering: "geometry",
+	fallbackMeters: 1e3
+};
+const DEFAULT_CROSS_TASK_OPTIONS = {
+	sizePixels: 80,
+	rotation: 0,
+	crossAngle: 2 * Math.atan(.55) * 180 / Math.PI,
+	labelPadding: DEFAULT_LABEL_KNOCKOUT_PADDING
+};
+const CROSS_TASK_PARAMS = [
+	{
+		key: "crossAngle",
+		presentationTier: "advanced",
+		label: "Cross angle",
+		description: "Opening angle between the two right-hand arms. Changes height while preserving width.",
+		type: "number",
+		min: 10,
+		max: 150,
+		step: 1,
+		unit: "°"
+	},
+	{
+		key: "sizePixels",
+		label: "Size",
+		description: "Width of the complete symbol in screen pixels.",
+		type: "number",
+		min: 16,
+		max: 400,
+		step: 1,
+		unit: "px"
+	},
+	{
+		key: "labelPadding",
+		presentationTier: "advanced",
+		label: "Label padding",
+		description: "Extra clearance around the doctrinal letter, as a ratio of its resolved height.",
+		type: "number",
+		min: 0,
+		max: 2,
+		step: .05
+	},
+	{
+		key: "sizeMeters",
+		label: "Size",
+		description: "Overall width of the static symbol.",
+		type: "number",
+		min: 10,
+		max: 1e5,
+		step: 10,
+		unit: "m"
+	},
+	{
+		key: "rotation",
+		label: "Rotation",
+		description: "Clockwise rotation of the static symbol.",
+		type: "number",
+		min: 0,
+		max: 360,
+		step: 1,
+		unit: "°"
+	}
+];
+function transformCrossTaskOptions(options, { scale, rotationRadians }) {
+	const patch = {};
+	if (scale !== 1 && Number.isFinite(scale) && scale > 0) if (options.sizePixels !== void 0 || options.sizeMeters === void 0) patch.sizePixels = (options.sizePixels ?? DEFAULT_CROSS_TASK_OPTIONS.sizePixels) * scale;
+	else patch.sizeMeters = options.sizeMeters * scale;
+	if (rotationRadians !== 0 && Number.isFinite(rotationRadians)) patch.rotation = normalizeDegrees((options.rotation ?? 0) + rotationRadians * 180 / Math.PI);
+	return Object.keys(patch).length ? patch : void 0;
+}
+/** The doctrinal letter each cross task centers. */
+const CROSS_TASK_GLYPHS = {
+	destroy: "D",
+	defeat: "D",
+	neutralize: "N",
+	suppress: "S"
+};
+/** Milsymbol 3.0.4, iconparts/tactical-points.js: TP.DESTROY / TP.NEUTRALIZE / TP.SUPPRESS.
+* Default to the 200 × 110 cross and 45-unit glyph; crossAngle adjusts its height. The center gap
+* follows resolved text metrics and padding rather than milsymbol’s fixed 30 units.
+* SVG's y=103 text anchor compensates for its font baseline; our labels are centered.
+*/
+function createCrossTaskSymbol(coordinates, options, kind, context = {}) {
+	const anchor = coordinates[0];
+	if (!anchor) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const center = project(anchor[0], anchor[1]);
+	const pixels = options.sizePixels ?? (options.sizeMeters === void 0 ? DEFAULT_CROSS_TASK_OPTIONS.sizePixels : void 0);
+	const width = pixels !== void 0 && options.metersPerPixel !== void 0 && options.metersPerPixel > 0 ? pixels * options.metersPerPixel : options.sizeMeters ?? 1e3;
+	if (!Number.isFinite(width) || width <= 0) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const scale = width / 200;
+	const rotation = (options.rotation ?? 0) * Math.PI / 180;
+	const cos = Math.cos(rotation);
+	const sin = Math.sin(rotation);
+	const local = (x, y) => unproject(center[0] + scale * (x * cos + y * sin), center[1] + scale * (-x * sin + y * cos));
+	const glyph = CROSS_TASK_GLYPHS[kind];
+	const labelOptions = {
+		labelSize: 45 * scale,
+		labelPadding: options.labelPadding
+	};
+	const labelContext = {
+		...context,
+		labelSizeClampCssPixels: {
+			min: 0,
+			max: Number.MAX_VALUE
+		}
+	};
+	const requestedAngle = options.crossAngle ?? DEFAULT_CROSS_TASK_OPTIONS.crossAngle;
+	const angle = Number.isFinite(requestedAngle) ? Math.min(150, Math.max(10, requestedAngle)) : DEFAULT_CROSS_TASK_OPTIONS.crossAngle;
+	const crossSlope = Math.tan(angle * Math.PI / 360);
+	const diagonalScale = Math.hypot(1, crossSlope);
+	const gap = Math.min(100, labelKnockoutHalfExtent(glyph, [1 / diagonalScale, crossSlope / diagonalScale], Math.PI, labelOptions, labelContext, DEFAULT_CROSS_TASK_OPTIONS.labelPadding) / (scale * diagonalScale));
+	const label = createLabelFeature(center, glyph, Math.PI - rotation, labelOptions);
+	if (pixels !== void 0) {
+		delete label.properties.textSizeMeters;
+		label.properties.textSizePixels = pixels * 45 / 200;
+	} else label.properties.textMaxSizePixels = Number.MAX_SAFE_INTEGER;
+	const resolution = context.constructionMetersPerCssPixel ?? options.metersPerPixel;
+	const strokeWidth = (pixels ?? (resolution && resolution > 0 ? width / resolution : 80)) * (kind === "defeat" ? 8 : 4) / 200;
+	if (gap >= 100) return {
+		type: "FeatureCollection",
+		features: [label]
+	};
+	if (kind === "defeat") {
+		const shafts = [];
+		const heads = [];
+		const headLength = Math.min(32, (100 - gap) * diagonalScale * .65);
+		const halfHeadWidth = headLength * .56;
+		for (const xSign of [-1, 1]) for (const ySign of [-1, 1]) {
+			const ux = xSign / diagonalScale;
+			const uy = ySign * crossSlope / diagonalScale;
+			const tipX = xSign * gap;
+			const tipY = ySign * gap * crossSlope;
+			const baseX = tipX + ux * headLength;
+			const baseY = tipY + uy * headLength;
+			shafts.push([local(xSign * 100, ySign * 100 * crossSlope), local(baseX, baseY)]);
+			const tip = local(tipX, tipY);
+			heads.push([[
+				tip,
+				local(baseX - uy * halfHeadWidth, baseY + ux * halfHeadWidth),
+				local(baseX + uy * halfHeadWidth, baseY - ux * halfHeadWidth),
+				tip
+			]]);
+		}
+		return {
+			type: "FeatureCollection",
+			features: [
+				{
+					type: "Feature",
+					properties: {
+						part: "defeat",
+						style: { strokeWidth }
+					},
+					geometry: {
+						type: "MultiLineString",
+						coordinates: shafts
+					}
+				},
+				{
+					type: "Feature",
+					properties: {
+						part: "arrowheads",
+						fill: true,
+						style: {
+							...SOLID_ACCENT_FILL,
+							strokeWidth: 0,
+							strokeDash: []
+						}
+					},
+					geometry: {
+						type: "MultiPolygon",
+						coordinates: heads
+					}
+				},
+				label
+			]
+		};
+	}
+	const dashLength = 24;
+	const diagonalLines = (slope, dashed) => {
+		const lines = [];
+		for (const [start, end] of [[gap, 100], [-100, -gap]]) {
+			if (!dashed) {
+				lines.push([local(start, start * slope), local(end, end * slope)]);
+				continue;
+			}
+			const length = (end - start) * diagonalScale;
+			for (let distance = 0; distance < length; distance += 34) {
+				const x1 = start + distance / diagonalScale;
+				const x2 = start + Math.min(distance + dashLength, length) / diagonalScale;
+				lines.push([local(x1, x1 * slope), local(x2, x2 * slope)]);
+			}
+		}
+		return lines;
+	};
+	return {
+		type: "FeatureCollection",
+		features: [
+			{
+				type: "Feature",
+				properties: {
+					part: kind,
+					style: {
+						strokeWidth,
+						...kind === "suppress" ? { strokeDash: [] } : {}
+					}
+				},
+				geometry: {
+					type: "MultiLineString",
+					coordinates: diagonalLines(-crossSlope, kind === "suppress")
+				}
+			},
+			{
+				type: "Feature",
+				properties: {
+					part: `${kind}-rising`,
+					style: {
+						strokeWidth,
+						...kind !== "destroy" ? { strokeDash: [] } : {}
+					}
+				},
+				geometry: {
+					type: "MultiLineString",
+					coordinates: diagonalLines(crossSlope, kind !== "destroy")
+				}
+			},
+			label
+		]
+	};
+}
+//#endregion
+//#region src/generators/cm34-mission-tasks/defeat.ts
+const DEFAULT_DEFEAT_OPTIONS = {
+	...DEFAULT_CROSS_TASK_OPTIONS,
+	crossAngle: 80
+};
+const DEFEAT_METADATA = {
+	id: "defeat",
+	sizePairs: [CROSS_TASK_SIZE_PAIR],
+	name: "Defeat",
+	description: "Renders an enemy force unable or unwilling to achieve its objectives.",
+	entity: "Mission Tasks",
+	entityType: "Defeat",
+	value: "344300",
+	minCoordinates: 1,
+	maxCoordinates: 1,
+	geometry: "point",
+	geometryTypes: [
+		"MultiLineString",
+		"MultiPolygon",
+		"Point"
+	],
+	paints: {
+		stroke: true,
+		fill: "fixed",
+		text: true
+	},
+	drawRule: "Point2",
+	uniformSizing: true,
+	labelGeometryUsesResolvedMetrics: true,
+	params: CROSS_TASK_PARAMS
+};
+/** Generates the Defeat mission task (344300) around its sole center anchor. */
+function createDefeatSymbol(coordinates, options = {}, _textAmplifiers = {}, context = {}) {
+	return createCrossTaskSymbol(coordinates, {
+		...options,
+		crossAngle: Number.isFinite(options.crossAngle) ? options.crossAngle : DEFAULT_DEFEAT_OPTIONS.crossAngle
+	}, "defeat", context);
+}
+const DEFEAT = defineControlMeasure({
+	metadata: DEFEAT_METADATA,
+	generator: createDefeatSymbol,
+	defaultOptions: DEFAULT_DEFEAT_OPTIONS,
+	rule: staticPointDrawRule,
+	transformOptions: transformCrossTaskOptions,
+	previewSample: {
+		controlPoints: [[0, 0]],
+		options: { sizeMeters: 1e3 }
+	}
+});
+//#endregion
+//#region src/generators/cm34-mission-tasks/suppress.ts
+const DEFAULT_SUPPRESS_OPTIONS = DEFAULT_CROSS_TASK_OPTIONS;
+const SUPPRESS_METADATA = {
+	id: "suppress",
+	sizePairs: [CROSS_TASK_SIZE_PAIR],
+	name: "Suppress",
+	description: "Temporarily degrades an enemy force or weapon system below the level needed to accomplish its mission.",
+	entity: "Mission Tasks",
+	entityType: "Suppress",
+	value: "342800",
+	minCoordinates: 1,
+	maxCoordinates: 1,
+	geometry: "point",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Point2",
+	uniformSizing: true,
+	labelGeometryUsesResolvedMetrics: true,
+	params: CROSS_TASK_PARAMS
+};
+/** Generates the Suppress mission task (342800) around its sole center anchor. */
+function createSuppressSymbol(coordinates, options = {}, _textAmplifiers = {}, context = {}) {
+	return createCrossTaskSymbol(coordinates, options, "suppress", context);
+}
+const SUPPRESS = defineControlMeasure({
+	metadata: SUPPRESS_METADATA,
+	generator: createSuppressSymbol,
+	defaultOptions: DEFAULT_SUPPRESS_OPTIONS,
+	rule: staticPointDrawRule,
+	transformOptions: transformCrossTaskOptions,
+	previewSample: {
+		controlPoints: [[0, 0]],
+		options: { sizeMeters: 1e3 }
+	}
+});
+//#endregion
+//#region src/generators/cm34-mission-tasks/neutralize.ts
+const DEFAULT_NEUTRALIZE_OPTIONS = DEFAULT_CROSS_TASK_OPTIONS;
+const NEUTRALIZE_METADATA = {
+	id: "neutralize",
+	sizePairs: [CROSS_TASK_SIZE_PAIR],
+	name: "Neutralize",
+	description: "Renders enemy personnel or materiel incapable of interfering with an operation.",
+	entity: "Mission Tasks",
+	entityType: "Neutralize",
+	value: "341600",
+	minCoordinates: 1,
+	maxCoordinates: 1,
+	geometry: "point",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Point2",
+	uniformSizing: true,
+	labelGeometryUsesResolvedMetrics: true,
+	params: CROSS_TASK_PARAMS
+};
+/** Generates the Neutralize mission task (341600) around its sole center anchor. */
+function createNeutralizeSymbol(coordinates, options = {}, _textAmplifiers = {}, context = {}) {
+	return createCrossTaskSymbol(coordinates, options, "neutralize", context);
+}
+const NEUTRALIZE = defineControlMeasure({
+	metadata: NEUTRALIZE_METADATA,
+	generator: createNeutralizeSymbol,
+	defaultOptions: DEFAULT_NEUTRALIZE_OPTIONS,
+	rule: staticPointDrawRule,
+	transformOptions: transformCrossTaskOptions,
+	previewSample: {
+		controlPoints: [[0, 0]],
+		options: { sizeMeters: 1e3 }
+	}
+});
+//#endregion
+//#region src/generators/cm34-mission-tasks/destroy.ts
+const DEFAULT_DESTROY_OPTIONS = DEFAULT_CROSS_TASK_OPTIONS;
+const DESTROY_METADATA = {
+	id: "destroy",
+	sizePairs: [CROSS_TASK_SIZE_PAIR],
+	name: "Destroy",
+	description: "Renders an enemy force or capability physically combat-ineffective until reconstituted.",
+	entity: "Mission Tasks",
+	entityType: "Destroy",
+	value: "340900",
+	minCoordinates: 1,
+	maxCoordinates: 1,
+	geometry: "point",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Point2",
+	uniformSizing: true,
+	labelGeometryUsesResolvedMetrics: true,
+	params: CROSS_TASK_PARAMS
+};
+/** Generates the Destroy mission task (340900) around its sole center anchor. */
+function createDestroySymbol(coordinates, options = {}, _textAmplifiers = {}, context = {}) {
+	return createCrossTaskSymbol(coordinates, options, "destroy", context);
+}
+const DESTROY = defineControlMeasure({
+	metadata: DESTROY_METADATA,
+	generator: createDestroySymbol,
+	defaultOptions: DEFAULT_DESTROY_OPTIONS,
+	rule: staticPointDrawRule,
+	transformOptions: transformCrossTaskOptions,
+	previewSample: {
+		controlPoints: [[0, 0]],
+		options: { sizeMeters: 1e3 }
+	}
+});
+//#endregion
+//#region src/internal/echelon.ts
+/**
+* APP-6 echelon (Field B) glyph vocabulary, shared by the control measures that
+* stamp a unit-size amplifier onto their geometry (Boundary, Battle Position).
+*
+* A compact port of the APP-6 echelon designs, modeled on milsymbol but
+* expressed as parametric geometry so it bakes into GeoJSON and strokes
+* monocolor (ADR-0023). Every glyph is built from three primitives — vertical
+* bars, crosses, and dots — plus the team/crew ring and command `++`.
+*/
+/** Shared echelon dimension for every measure that stamps a unit-size amplifier. */
+const ECHELON_SIZE_PAIR = {
+	id: "echelon",
+	label: "Echelon size",
+	pixels: "echelonSizePixels",
+	meters: "echelonSize",
+	defaultUnit: "m",
+	rendering: "geometry"
+};
+const ECHELONS = {
+	team: {
+		kind: "ring",
+		count: 1,
+		label: "Team/Crew"
+	},
+	crew: {
+		kind: "ring",
+		count: 1
+	},
+	squad: {
+		kind: "dots",
+		count: 1,
+		label: "Squad"
+	},
+	section: {
+		kind: "dots",
+		count: 2,
+		label: "Section"
+	},
+	platoon: {
+		kind: "dots",
+		count: 3,
+		label: "Platoon"
+	},
+	company: {
+		kind: "bars",
+		count: 1,
+		label: "Company"
+	},
+	battalion: {
+		kind: "bars",
+		count: 2,
+		label: "Battalion"
+	},
+	regiment: {
+		kind: "bars",
+		count: 3,
+		label: "Regiment"
+	},
+	brigade: {
+		kind: "crosses",
+		count: 1,
+		label: "Brigade"
+	},
+	division: {
+		kind: "crosses",
+		count: 2,
+		label: "Division"
+	},
+	corps: {
+		kind: "crosses",
+		count: 3,
+		label: "Corps"
+	},
+	army: {
+		kind: "crosses",
+		count: 4,
+		label: "Army"
+	},
+	"army-group": {
+		kind: "crosses",
+		count: 5,
+		label: "Army Group"
+	},
+	region: {
+		kind: "crosses",
+		count: 6,
+		label: "Region"
+	},
+	command: {
+		kind: "command",
+		count: 2,
+		label: "Command"
+	}
+};
+/** Symbol-form aliases (`"XX"`, `"II"`, `"•••"`, …) → canonical echelon key. */
+const ECHELON_ALIASES = {
+	ø: "team",
+	"•": "squad",
+	"••": "section",
+	"•••": "platoon",
+	i: "company",
+	ii: "battalion",
+	iii: "regiment",
+	x: "brigade",
+	xx: "division",
+	xxx: "corps",
+	xxxx: "army",
+	xxxxx: "army-group",
+	xxxxxx: "region",
+	"++": "command"
+};
+/** Enum options for the params panel, derived from {@link ECHELONS}. */
+const ECHELON_PARAM_OPTIONS = [{
+	label: "None",
+	value: "none"
+}, ...Object.entries(ECHELONS).filter(([, spec]) => spec.label !== void 0).map(([value, spec]) => ({
+	label: spec.label,
+	value
+}))];
+/**
+* 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);
+}
+function resolveEchelon(echelon) {
+	const key = echelon.trim().toLowerCase();
+	if (key.length === 0) return void 0;
+	const alias = ECHELON_ALIASES[key];
+	return ECHELONS[key] ?? (alias ? ECHELONS[alias] : void 0);
+}
+/**
+* Builds the echelon glyph centered at `center`, with its baseline along
+* `along` and `perp` (both unit vectors), `h` meters tall. Returns the glyph's
+* `strokes` (open polylines), `fills` (closed rings drawn as solid shapes —
+* the squad/section/platoon dots), and its intrinsic width along the line; the
+* caller adds the configurable side padding to derive the line gap.
+*/
+function buildEchelonGlyph(center, along, perp, h, spec) {
+	const P = (a, p) => {
+		const q = vecAdd(vecAdd(center, vecScale(along, a)), vecScale(perp, p));
+		return unproject(q[0], q[1]);
+	};
+	const ring = (a, r) => {
+		const pts = [];
+		const steps = 16;
+		for (let i = 0; i <= steps; i++) {
+			const t = 2 * Math.PI * i / steps;
+			pts.push(P(a + r * Math.cos(t), r * Math.sin(t)));
+		}
+		return pts;
+	};
+	const strokes = [];
+	const fills = [];
+	const half = h / 2;
+	switch (spec.kind) {
+		case "bars": {
+			const spacing = h * .8;
+			const total = (spec.count - 1) * spacing;
+			for (let j = 0; j < spec.count; j++) {
+				const a = -total / 2 + j * spacing;
+				strokes.push([P(a, -half), P(a, half)]);
+			}
+			return {
+				strokes,
+				fills,
+				width: total
+			};
+		}
+		case "crosses": {
+			const w = h;
+			const spacing = h * 1.4;
+			const total = (spec.count - 1) * spacing;
+			for (let j = 0; j < spec.count; j++) {
+				const a0 = -total / 2 + j * spacing;
+				strokes.push([P(a0 - w / 2, -half), P(a0 + w / 2, half)]);
+				strokes.push([P(a0 - w / 2, half), P(a0 + w / 2, -half)]);
+			}
+			return {
+				strokes,
+				fills,
+				width: total + w
+			};
+		}
+		case "dots": {
+			const r = h * .3;
+			const spacing = h * 1.2;
+			const total = (spec.count - 1) * spacing;
+			for (let j = 0; j < spec.count; j++) fills.push(ring(-total / 2 + j * spacing, r));
+			return {
+				strokes,
+				fills,
+				width: total + 2 * r
+			};
+		}
+		case "ring": {
+			const r = h * .6;
+			strokes.push(ring(0, r));
+			strokes.push([P(-h * .8, -h * .4), P(h * .8, h * .4)]);
+			return {
+				strokes,
+				fills,
+				width: h * 1.6
+			};
+		}
+		case "command": {
+			const arm = h * .5;
+			const spacing = h * 1.4;
+			const total = (spec.count - 1) * spacing;
+			for (let j = 0; j < spec.count; j++) {
+				const a0 = -total / 2 + j * spacing;
+				strokes.push([P(a0 - arm, 0), P(a0 + arm, 0)]);
+				strokes.push([P(a0, -half), P(a0, half)]);
+			}
+			return {
+				strokes,
+				fills,
+				width: total + 2 * arm
+			};
+		}
+	}
+}
+//#endregion
+//#region src/generators/cm15-maneuver-areas/params.ts
+const AREA_SMOOTH_PARAMS = [{
+	key: "smooth",
+	label: "Smooth",
+	description: "Round the area's corners by curving the boundary through the control points.",
+	type: "boolean"
+}, {
+	key: "smoothResolution",
+	presentationTier: "advanced",
+	label: "Smooth resolution",
+	description: "Number of samples per segment when smooth mode is enabled.",
+	type: "number",
+	min: 2,
+	max: 64,
+	step: 1,
+	visibleWhen: (opts) => Boolean(opts.smooth)
+}];
+const ATTACK_SHAFT_PARAMS = [
+	{
+		key: "shaftWidthRatio",
+		presentationTier: "advanced",
+		label: "Shaft width",
+		description: "Arrow shaft width as a ratio of the arrowhead width",
+		type: "number",
+		min: .1,
+		max: 1,
+		step: .05
+	},
+	{
+		key: "rearWidthRatio",
+		presentationTier: "advanced",
+		label: "Rear width",
+		description: "Width at the rear of the shaft as a ratio of the arrowhead width.",
+		type: "number",
+		min: .1,
+		max: 2,
+		step: .05
+	},
+	{
+		key: "smooth",
+		label: "Smooth",
+		description: "Round the corners where the shaft changes direction.",
+		type: "boolean"
+	},
+	{
+		key: "smoothResolution",
+		presentationTier: "advanced",
+		label: "Smooth resolution",
+		description: "Number of segments approximating each rounded bend when smooth mode is enabled.",
+		type: "number",
+		min: 1,
+		max: 20,
+		step: 1,
+		visibleWhen: (opts) => opts.smooth === true
+	}
+];
+const FIRE_ARROW_PARAMS = [
+	{
+		key: "arrowheadWidthRatio",
+		presentationTier: "advanced",
+		label: "Arrowhead width",
+		description: "Arrowhead width as a ratio of the shaft length",
+		type: "number",
+		min: .05,
+		max: 1,
+		step: .01
+	},
+	{
+		key: "rearLineLengthRatio",
+		presentationTier: "advanced",
+		label: "Rear line length",
+		description: "Length of the rear flare lines as a ratio of the head",
+		type: "number",
+		min: .05,
+		max: 1,
+		step: .01
+	},
+	{
+		key: "rearLineAngle",
+		presentationTier: "advanced",
+		label: "Rear line angle",
+		description: "Angle of the rear flare lines, in degrees",
+		type: "number",
+		min: 0,
+		max: 90,
+		step: 1
+	}
+];
+const FORTIFIED_AREA_SIZE_PARAMS = [{
+	key: "toothSizePixels",
+	label: "Tooth size",
+	description: "Size of the fortified-area teeth, in pixels",
+	type: "number",
+	min: 5,
+	max: 50,
+	step: 1,
+	unit: "px"
+}, {
+	key: "toothSize",
+	label: "Tooth size",
+	description: "Size of the fortified-area teeth, in meters",
+	type: "number",
+	min: 1,
+	max: 500,
+	step: 1,
+	unit: "m"
+}];
+const ENCIRCLEMENT_PARAMS = [
+	{
+		key: "smooth",
+		label: "Smooth",
+		description: "Round the boundary by curving it through the control points.",
+		type: "boolean"
+	},
+	{
+		key: "smoothResolution",
+		presentationTier: "advanced",
+		label: "Smooth resolution",
+		description: "Number of samples per segment when smooth mode is enabled.",
+		type: "number",
+		min: 2,
+		max: 64,
+		step: 1,
+		visibleWhen: (opts) => Boolean(opts.smooth)
+	},
+	{
+		key: "barbSpacingRatio",
+		presentationTier: "advanced",
+		label: "Spacing",
+		description: "Spacing between barbs as a ratio of the symbol radius (smaller is denser).",
+		type: "number",
+		min: .15,
+		max: 1.5,
+		step: .05
+	},
+	{
+		key: "barbLengthRatio",
+		presentationTier: "advanced",
+		label: "Barb length",
+		description: "Barb height as a ratio of the symbol radius (amplitude).",
+		type: "number",
+		min: .02,
+		max: .5,
+		step: .01
+	}
+];
+const FORTIFIED_AREA_PARAMS = [...AREA_SMOOTH_PARAMS, ...FORTIFIED_AREA_SIZE_PARAMS];
+const AREA_LABEL_PADDING_PARAM = {
+	key: "labelPadding",
+	presentationTier: "advanced",
+	label: "Label padding",
+	description: "Extra spacing between or around the area's labels, as a ratio of label height",
+	type: "number",
+	min: 0,
+	max: 2,
+	step: .05
+};
+const MULTILINE_AREA_LABEL_PARAM = {
+	key: "multilineLabel",
+	label: "Multiline label",
+	description: "Place the doctrinal label above Field T on separate centered lines",
+	type: "boolean"
+};
+const LABELED_AREA_PARAMS = [...AREA_SMOOTH_PARAMS, AREA_LABEL_PADDING_PARAM];
+const PREFIXED_LABELED_AREA_PARAMS = [
+	...AREA_SMOOTH_PARAMS,
+	MULTILINE_AREA_LABEL_PARAM,
+	AREA_LABEL_PADDING_PARAM
+];
+const ECHELON_GLYPH_PARAMS = [
+	{
+		key: "echelon",
+		label: "Echelon",
+		description: "Field B unit-size amplifier, drawn on the boundary.",
+		type: "enum",
+		presentationTier: "primary",
+		semanticRole: "doctrinal",
+		options: ECHELON_PARAM_OPTIONS
+	},
+	{
+		key: "echelonSizePixels",
+		label: "Echelon size",
+		description: "Echelon glyph height in screen pixels.",
+		type: "number",
+		min: 8,
+		max: 48,
+		step: 1,
+		unit: "px"
+	},
+	{
+		key: "echelonSize",
+		label: "Echelon size",
+		description: "Echelon glyph height in meters.",
+		type: "number",
+		min: 50,
+		max: 2e4,
+		step: 50,
+		unit: "m"
+	},
+	{
+		key: "echelonPadding",
+		presentationTier: "advanced",
+		label: "Echelon padding",
+		description: "Gap on each side of the echelon, as a ratio of its height.",
+		type: "number",
+		min: 0,
+		max: 2,
+		step: .05
+	},
+	{
+		key: "echelonPosition",
+		presentationTier: "advanced",
+		label: "Echelon position",
+		description: "Slide the echelon along the boundary, as a fraction of the perimeter from the bottom edge.",
+		type: "number",
+		min: -.5,
+		max: .5,
+		step: .01
+	}
+];
+const ECHELON_AREA_PARAMS = [
+	...AREA_SMOOTH_PARAMS,
+	...ECHELON_GLYPH_PARAMS,
+	AREA_LABEL_PADDING_PARAM
+];
+const PREFIXED_ECHELON_AREA_PARAMS = [
+	...AREA_SMOOTH_PARAMS,
+	MULTILINE_AREA_LABEL_PARAM,
+	...ECHELON_GLYPH_PARAMS,
+	AREA_LABEL_PADDING_PARAM
+];
+const AREA_DESIGNATION_AMPLIFIER = {
+	key: "T",
+	label: "Unique designation",
+	description: "Field T — the unit's designation, centered in the area.",
+	maxLength: 21
+};
+const AREA_HOSTILE_AMPLIFIER = {
+	key: "N",
+	label: "Hostile (ENY) marker",
+	description: "Field N — literal \"ENY\" marker at the area's west and east edges.",
 	placeholder: "ENY",
 	maxLength: 3
 };
-/** Label-padding control shared by label-bearing graphics. */
-const LABEL_PADDING_PARAM = {
-	key: "labelPadding",
-	presentationTier: "advanced",
-	label: "Label padding",
-	description: "Extra clearance around labels, as a ratio of the label height",
-	type: "number",
-	min: 0,
-	max: 2,
-	step: .05
+const AREA_TEXT_AMPLIFIERS = [
+	{
+		key: "T",
+		label: "Unique designation",
+		description: "Field T — the area's unique designation.",
+		maxLength: 21
+	},
+	{
+		key: "H",
+		label: "Additional information",
+		description: "Field H — additional free-text information, shown below the designation.",
+		maxLength: 20
+	},
+	{
+		key: "W",
+		label: "Effective from (DTG)",
+		description: "Field W — date-time group the area becomes effective.",
+		placeholder: "051030Z",
+		maxLength: 16
+	},
+	{
+		key: "W1",
+		label: "Effective to (DTG)",
+		description: "Field W1 — date-time group the area ceases to be effective.",
+		maxLength: 16
+	},
+	AREA_HOSTILE_AMPLIFIER
+];
+const AREA_UNIT_DESIGNATION_HOSTILE_AMPLIFIERS = [AREA_DESIGNATION_AMPLIFIER, AREA_HOSTILE_AMPLIFIER];
+/** {@link AREA_TEXT_AMPLIFIERS} without the H (additional information) field,
+*  for measures whose template omits that row but keeps the W/W1 window and
+*  the N (hostile) marker (Submarine Action Area, Submarine-Generated Action
+*  Area). */
+const AREA_TEXT_AMPLIFIERS_NO_ADDITIONAL_INFO = AREA_TEXT_AMPLIFIERS.filter((d) => d.key !== "H");
+/** {@link AREA_TEXT_AMPLIFIERS} reduced to just the designation (Field T) and
+*  hostile marker (Field N), for measures whose template carries no
+*  additional-information or date-time-group rows (Area, Drop Zone,
+*  Extraction Zone). */
+const AREA_TEXT_AMPLIFIERS_DESIGNATION_HOSTILE = AREA_TEXT_AMPLIFIERS.filter((d) => d.key === "T" || d.key === "N");
+//#endregion
+//#region src/generators/cm15-maneuver-areas/airborneAttack.ts
+const DEFAULT_AIRBORNE_ATTACK_OPTIONS = {
+	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
+	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
+	smooth: false,
+	smoothResolution: 5
+};
+const AIRBORNE_ATTACK_METADATA = {
+	id: "airborne-attack",
+	name: "Airborne Attack",
+	description: "Airborne or aviation axis of advance.",
+	entity: "Maneuver Areas",
+	entityType: "Axis of Advance",
+	entitySubtype: "Airborne Attack",
+	value: "151401",
+	minCoordinates: 3,
+	geometry: "line",
+	geometryTypes: ["LineString"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: false
+	},
+	drawRule: "Axis1",
+	params: ATTACK_SHAFT_PARAMS
 };
 /**
-* Resolves {@link LabelSizeOptions} into the single text-size property the
-* label feature carries (ADR-0028): `textSizePixels` when screen-anchored
-* (`labelSizePixels` present — pixels win over a stray `labelSize`),
-* `textSizeMeters` when ground-anchored (`labelSize` alone), or neither, in
-* which case adapters render their engine default, screen-fixed.
-*/
-function labelSizeProps(options) {
-	const { labelSize, labelSizePixels } = options;
-	if (labelSizePixels !== void 0) return { textSizePixels: labelSizePixels };
-	if (labelSize !== void 0) return { textSizeMeters: labelSize };
-	return {};
-}
-/** Pushes a `part: "label"` Point feature at projected `point`. */
-function pushLabel(out, point, text, rotation, sizeProps, textAnchor, amplifierField, labelPlacementKey) {
-	out.push({
-		type: "Feature",
-		properties: {
-			part: "label",
-			text,
-			rotation,
-			...textAnchor ? { textAnchor } : {},
-			...amplifierField ? { amplifierField } : {},
-			...labelPlacementKey ? { labelPlacementKey } : {},
-			...sizeProps
-		},
-		geometry: {
-			type: "Point",
-			coordinates: unproject(point[0], point[1])
-		}
-	});
-}
-/** Ratio of resolved label height (`labelSize`, or `labelSizePixels × metersPerPixel`) used as end-label clearance. */
-const END_LABEL_CLEARANCE_RATIO = .3;
-/** Ratio of resolved label height used to inset "above" end labels from the tip. */
-const ABOVE_LABEL_INSET_RATIO = .3;
-/** Ratio of resolved label height used as the "above" end labels' perpendicular offset. */
-const ABOVE_LABEL_OFFSET_RATIO = .6;
-function textHeight(options) {
-	const { labelSize, labelSizePixels, metersPerPixel } = options;
-	if (labelSizePixels !== void 0) return metersPerPixel !== void 0 && metersPerPixel > 0 ? labelSizePixels * metersPerPixel : void 0;
-	return labelSize;
-}
-/**
-* Label offset in meters: `ratio` × the label's resolved height (`labelSize`
-* meters, or `labelSizePixels × metersPerPixel` when screen-anchored), or
-* `fallbackMeters` when no size resolves (e.g. no map resolution yet). The fallback is small
-* relative to typical control measure spans — the same order of magnitude as
-* Boundary's own smallest label offsets — so a fixed label still reads as "just
-* clear of the line" rather than crowding it or floating away. Callers supply
-* their own ratio (end-label clearance, "above" inset/offset, center-group
-* offset) but share this single resolution+fallback rule.
-*/
-function resolveLabelOffsetMeters(options, ratio, fallbackMeters = 50) {
-	const h = textHeight(options);
-	return h !== void 0 ? ratio * h : fallbackMeters;
-}
-/**
-* Places one label just beyond each end of `verts` (projected meters), along
-* the outward direction of that end's segment, reading along the line
-* ({@link labelRotationAlong} is sign-independent, so the outward-pointing
-* `along` reads correctly). `textForEnd` supplies each end's text — a shared
-* string, or a function keyed by which end; an empty string skips that end.
+* Generates a GeoJSON FeatureCollection for an Airborne Attack tactical symbol.
 *
-* `textAnchor` is chosen so the text grows AWAY from the line: adapters flip
-* a label's rendered baseline (via {@link keepTextLeftToRight}) whenever its
-* direction points leftward, and that flip happens exactly when `along[0] <
-* 0` (same quadrant test `labelRotationAlong` relies on) — mirroring
-* Boundary's `vecDot` sign trick, "start" anchors the text at the point when
-* there is no flip, "end" when there is, so the anchored edge always sits at
-* the point and the text body always extends outward.
-*/
-function pushEndLabels(out, verts, textForEnd, options = {}) {
-	const frames = endFrames(verts);
-	const sizeProps = labelSizeProps(options);
-	const clearance = resolveLabelOffsetMeters(options, END_LABEL_CLEARANCE_RATIO + Math.max(0, options.labelPadding ?? 0));
-	for (const end of ["start", "end"]) {
-		const frame = frames[end];
-		if (!frame) continue;
-		const text = typeof textForEnd === "string" ? textForEnd : textForEnd(end);
-		if (text.length === 0) continue;
-		pushLabel(out, vecAdd(frame.point, vecScale(frame.along, clearance)), text, labelRotationAlong(frame.along), sizeProps, frame.along[0] >= 0 ? "start" : "end");
-	}
-}
-/**
-* Approximate sans-serif character width/height ratio, used to estimate a
-* label's rendered text width from its character count when no live text
-* measurement is available at generator time.
-*/
-const LABEL_CHAR_ASPECT_RATIO = .6;
-/**
-* Half a single glyph's width, as a ratio of its height — the base boundary
-* gap a measure reserves for one intrinsic capital letter (Retain's R,
-* Contain's C). Wider than half `LABEL_CHAR_ASPECT_RATIO` because these
-* glyphs are stamped alone rather than averaged over a word.
+* The symbol is similar to Supporting Attack but features a crossover point
+* between the shaft and the head (Points 1 and 2/Neck).
+*
+* @param coordinates - An array of GeoJSON Positions.
+* @param options - Configuration options.
+* @returns A GeoJSON FeatureCollection<LineString>.
 */
-const LABEL_HALF_GLYPH_RATIO = .45;
-/** Estimated rendered width of `text` given its resolved label height in meters. */
-function estimatedTextWidth(text, textHeightMeters) {
-	return text.length * LABEL_CHAR_ASPECT_RATIO * textHeightMeters;
-}
-/** Resolve the label's final display size, then measure and convert it to construction metres. */
-function resolveTextMetrics(text, options, context, style = "regular", fallbackHeightMeters = 50) {
-	const legacyHeight = resolveLabelOffsetMeters(options, 1, fallbackHeightMeters);
-	const constructionScale = context?.constructionMetersPerCssPixel;
-	if (!(constructionScale !== void 0 && constructionScale > 0)) return {
-		width: estimatedTextWidth(text, legacyHeight),
-		height: legacyHeight
-	};
-	let sizeCssPixels;
-	if (options.labelSizePixels !== void 0) sizeCssPixels = options.labelSizePixels;
-	else if (options.labelSize !== void 0) {
-		const requested = options.labelSize / constructionScale;
-		const requestedBand = context?.labelSizeClampCssPixels;
-		const band = requestedBand && Number.isFinite(requestedBand.min) && requestedBand.min >= 0 && Number.isFinite(requestedBand.max) && requestedBand.max >= 0 ? requestedBand : DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS;
-		const min = Math.min(band.min, band.max);
-		const max = Math.max(band.min, band.max);
-		sizeCssPixels = Math.min(max, Math.max(min, requested));
-	} else sizeCssPixels = 14;
-	const fallbackHeight = sizeCssPixels * constructionScale;
-	const measured = context?.measureText?.({
-		text,
-		style,
-		sizeCssPixels
-	});
-	if (!measured || !Number.isFinite(measured.widthCssPixels) || measured.widthCssPixels < 0 || !Number.isFinite(measured.heightCssPixels) || measured.heightCssPixels < 0) return {
-		width: estimatedTextWidth(text, fallbackHeight),
-		height: fallbackHeight
+function createAirborneAttack(coordinates, options = {}) {
+	const { geometry } = processAttackGeometry(coordinates, options);
+	if (!geometry) return {
+		type: "FeatureCollection",
+		features: []
 	};
+	const shaftLeftToNeck = geometry.shaftLeft.slice(0, -1);
+	const shaftRightToNeck = geometry.shaftRight.slice(0, -1);
 	return {
-		width: measured.widthCssPixels * constructionScale,
-		height: measured.heightCssPixels * constructionScale
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: {},
+			geometry: {
+				type: "LineString",
+				coordinates: [
+					...shaftLeftToNeck,
+					geometry.headRing[3],
+					geometry.headRing[2],
+					geometry.headRing[1],
+					geometry.headRing[0],
+					geometry.headRing[5],
+					...[...shaftRightToNeck].reverse()
+				].map((p) => unproject(p[0], p[1]))
+			}
+		}]
 	};
 }
+const AIRBORNE_ATTACK = defineControlMeasure({
+	metadata: AIRBORNE_ATTACK_METADATA,
+	generator: createAirborneAttack,
+	defaultOptions: DEFAULT_AIRBORNE_ATTACK_OPTIONS,
+	rule: axis1DrawRule,
+	optionHandles: variableWidthAttackOptionHandles
+});
 /**
-* Half-length of the knockout required for a label along `direction`.
+* Reacts to an **input-contract** violation according to `mode`: `throw`
+* raises, `warn` logs, `silent` (the default) does neither. Always returns
+* `false` so a caller can `return reportValidationIssue(...)` from a guard.
 *
-* The text box itself is always cleared; `labelPadding` adds symmetric clearance expressed in
-* resolved label heights. Keeping this calculation here gives every generator the same public
-* label-clearance interface while hiding font measurement and rotated-box projection details.
+* Governs the *input contract* only (control-point count and finiteness),
+* checked once at the render seam — not geometric degeneracy, which always
+* yields an empty render silently. See ADR-0014 and the `CONTEXT.md` terms.
 */
-function labelKnockoutHalfExtent(text, direction, rotation, options, context, defaultPadding = 0) {
-	const metrics = resolveTextMetrics(text, options, context);
-	const padding = Math.max(0, options.labelPadding ?? defaultPadding) * metrics.height;
-	return labelHalfExtent(direction, metrics.width, metrics.height, rotation) + padding;
+function reportValidationIssue(mode, message) {
+	const resolved = mode ?? "silent";
+	if (resolved === "throw") throw new Error(message);
+	if (resolved === "warn") console.warn(message);
+	return false;
 }
 /**
-* {@link labelKnockoutHalfExtent} expressed as a fraction of an arc's angular
-* sweep, for generators that carve their knockout in arc-progress space rather
-* than in meters. Clamped to `0.5` so the gap can never exceed the arc.
+* Narrows a control-point array to the fixed `[PT1, PT2, PT3]` tuple the ambush
+* and search-area generators require. The render seam has already validated
+* that at least three valid points are present (ADR-0014), so this is a pure
+* cast with no runtime guard. Used by those measures' definition adapters so
+* the generators keep their precise tuple parameter (ADR-0013).
 */
-function arcKnockoutHalfFraction(halfExtentMeters, radius, sweepAngle) {
-	const arcLength = radius * Math.abs(sweepAngle);
-	if (!(arcLength > 1e-6)) return .5;
-	return Math.min(.5, Math.max(0, halfExtentMeters) / arcLength);
-}
-/** The end-label text for a phase-line naming, or `""` when unnamed. */
-function phaseLineLabelText(name, includePrefix) {
-	if (!name) return "";
-	return includePrefix ? `PL ${name}` : name;
+function asThreePoints(points) {
+	return [
+		points[0],
+		points[1],
+		points[2]
+	];
 }
+const DEFAULT_AMBUSH_OPTIONS = {
+	arrowheadLengthRatio: .15,
+	arrowheadWidthRatio: .5,
+	hatchLengthRatio: .15,
+	hatchCount: 5,
+	curveDepthRatio: .25,
+	arcSegments: 30
+};
+const AMBUSH_METADATA = {
+	id: "ambush",
+	name: "Ambush",
+	description: "A variation of attack from concealed positions against a moving or temporarily halted enemy.",
+	entity: "Maneuver Lines",
+	entityType: "Ambush",
+	value: "141700",
+	minCoordinates: 3,
+	maxCoordinates: 3,
+	geometry: "line",
+	geometryTypes: ["MultiLineString"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: false
+	},
+	drawRule: "Line29",
+	params: [
+		{
+			key: "arrowheadLengthRatio",
+			presentationTier: "advanced",
+			label: "Arrowhead length",
+			description: "Arrowhead length as a ratio of the chord span",
+			type: "number",
+			min: .01,
+			max: .5,
+			step: .01
+		},
+		{
+			key: "arrowheadWidthRatio",
+			presentationTier: "advanced",
+			label: "Arrowhead width",
+			description: "Arrowhead base width as a multiple of the arrowhead length",
+			type: "number",
+			min: .05,
+			max: 2,
+			step: .01
+		},
+		{
+			key: "hatchLengthRatio",
+			presentationTier: "advanced",
+			label: "Hatch length",
+			description: "Length of the parallel hatches as a fraction of the chord span",
+			type: "number",
+			min: .01,
+			max: .5,
+			step: .01
+		},
+		{
+			key: "hatchCount",
+			presentationTier: "advanced",
+			label: "Hatch count",
+			description: "Number of parallel hatches spaced along the curve",
+			type: "number",
+			min: 0,
+			max: 20,
+			step: 1
+		},
+		{
+			key: "curveDepthRatio",
+			presentationTier: "advanced",
+			label: "Curve depth",
+			description: "How far the back line bends toward the tip, as a fraction of the chord span",
+			type: "number",
+			min: 0,
+			max: 1,
+			step: .01
+		},
+		{
+			key: "arcSegments",
+			label: "Arc segments",
+			description: "Number of segments used to render the curve",
+			type: "number",
+			presentationTier: "advanced",
+			min: 4,
+			max: 96,
+			step: 1
+		}
+	]
+};
+const quadBezier = (t, a, b, c) => {
+	const it = 1 - t;
+	return [it * it * a[0] + 2 * it * t * b[0] + t * t * c[0], it * it * a[1] + 2 * it * t * b[1] + t * t * c[1]];
+};
 /**
-* Places a Field N hostile marker beyond each end of `verts`, following the
-* same tangent, rotation, anchor, size, and padding conventions as
-* {@link pushEndLabels}. When another beyond-tip label is present, its
-* estimated width is added so the hostile marker remains outermost.
+* Generates a GeoJSON FeatureCollection for an AMBUSH tactical symbol.
+* Handles internal projection to maintain strict perpendicularity and parallel hatching.
+*
+* @param coordinates - [PT 1 (Target Tip), PT 2 (Back Chord End), PT 3 (Back Chord End)]
+* @param options - Geometric and styling parameters
+* @returns GeoJSON FeatureCollection containing LineString components
 */
-function pushHostileEndLabels(out, verts, hostileText, options = {}, occupiedTextForEnd = "", context) {
-	if (!hostileText) return;
-	const frames = endFrames(verts);
-	const sizeProps = labelSizeProps(options);
-	for (const end of ["start", "end"]) {
-		const frame = frames[end];
-		if (!frame) continue;
-		const occupiedText = typeof occupiedTextForEnd === "string" ? occupiedTextForEnd : occupiedTextForEnd(end);
-		const metrics = resolveTextMetrics(occupiedText || hostileText, options, context);
-		const clearance = (END_LABEL_CLEARANCE_RATIO + Math.max(0, options.labelPadding ?? 0)) * metrics.height;
-		const distance = clearance + (occupiedText ? metrics.width + clearance : 0);
-		pushLabel(out, vecAdd(frame.point, vecScale(frame.along, distance)), hostileText, labelRotationAlong(frame.along), sizeProps, frame.along[0] >= 0 ? "start" : "end", "N", `label:N:${end}`);
+function createAmbushSymbol(coordinates, options = {}) {
+	const { arrowheadLengthRatio, arrowheadWidthRatio, hatchLengthRatio, hatchCount, curveDepthRatio, arcSegments } = {
+		...DEFAULT_AMBUSH_OPTIONS,
+		...options
+	};
+	const safeArcSegments = Math.max(1, Math.floor(arcSegments));
+	const safeHatchCount = Math.max(0, Math.floor(hatchCount));
+	const safeArrowheadLengthRatio = Math.max(0, arrowheadLengthRatio);
+	const safeArrowheadWidthRatio = Math.max(0, arrowheadWidthRatio);
+	const safeHatchLengthRatio = Math.max(0, hatchLengthRatio);
+	const safeCurveDepthRatio = Math.max(0, curveDepthRatio);
+	const [p1, p2, p3] = coordinates.map((coord) => project(coord[0], coord[1]));
+	const mid = vecScale(vecAdd(p2, p3), .5);
+	const v23 = vecSub(p3, p2);
+	const span = vecMag(v23);
+	if (span < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const dir23 = vecNorm(v23);
+	const n = [-dir23[1], dir23[0]];
+	const dist = vecDot(vecSub(p1, mid), n);
+	const side = dist >= 0 ? 1 : -1;
+	const ctrl = vecAdd(mid, vecScale(n, side * span * safeCurveDepthRatio));
+	const shaftOrigin = quadBezier(.5, p2, ctrl, p3);
+	const adjP1 = vecAdd(shaftOrigin, vecScale(n, side * Math.max(0, Math.abs(dist) - span * safeCurveDepthRatio * .5)));
+	const lines = [];
+	lines.push([shaftOrigin, adjP1]);
+	const hL = span * safeArrowheadLengthRatio;
+	const hw = hL * safeArrowheadWidthRatio;
+	const hBase = vecSub(adjP1, vecScale(n, side * hL));
+	const perp = [-n[1], n[0]];
+	lines.push([
+		vecAdd(hBase, vecScale(perp, hw)),
+		adjP1,
+		vecSub(hBase, vecScale(perp, hw))
+	]);
+	const curve = [];
+	for (let i = 0; i <= safeArcSegments; i++) {
+		const t = i / safeArcSegments;
+		curve.push(quadBezier(t, p2, ctrl, p3));
+	}
+	lines.push(curve);
+	const hatchLengthActual = span * safeHatchLengthRatio;
+	for (let i = 1; i <= safeHatchCount; i++) {
+		const pt = quadBezier(i / (safeHatchCount + 1), p2, ctrl, p3);
+		lines.push([pt, vecSub(pt, vecScale(n, side * hatchLengthActual))]);
 	}
+	return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: {},
+			geometry: {
+				type: "MultiLineString",
+				coordinates: lines.map((line) => line.map((c) => unproject(c[0], c[1])))
+			}
+		}]
+	};
 }
+const AMBUSH = defineControlMeasure({
+	metadata: AMBUSH_METADATA,
+	generator: (controlPoints, options) => createAmbushSymbol(asThreePoints(controlPoints), options),
+	defaultOptions: DEFAULT_AMBUSH_OPTIONS,
+	rule: ambushDrawRule
+});
+//#endregion
+//#region src/internal/gapped-line.ts
 /**
-* Resolves the {@link AboveEndFrame} at each tip of `verts` (projected meters):
-* a base point inset from the tip toward the interior, the segment's own
-* natural `perp` (so "above" = `+perp` reads the same at both ends), the
-* one-row perpendicular `offset`, the along-line `rotation`, and the
-* interior-growing `textAnchor`. Shared by {@link pushEndLabelsAbove} (one
-* label per tip, at `base + perp·offset`) and generic-c2-line's dual
-* above/below amplifier labels (`base ± perp·offset`), so both build on the
-* same tangent/inset/anchor math instead of re-deriving it.
+* Pushes the arc-length gap `[g0, g1]` onto `gaps`, normalizing it onto
+* `[0, total)` and splitting it into two intervals when it straddles a ring
+* seam ({@link buildGappedLine} walks a flat array and does not wrap on its
+* own). Use this for closed rings; open polylines can push {@link ArcGap}s
+* directly.
 */
-function aboveEndFrames(verts, options) {
-	const tangents = endTangents(verts);
-	const inset = resolveLabelOffsetMeters(options, ABOVE_LABEL_INSET_RATIO);
-	const offset = resolveLabelOffsetMeters(options, ABOVE_LABEL_OFFSET_RATIO + Math.max(0, options.labelPadding ?? 0));
-	const frames = {};
-	for (const end of ["start", "end"]) {
-		const tangent = tangents[end];
-		if (!tangent) continue;
-		frames[end] = {
-			base: vecAdd(tangent.point, vecScale(tangent.interior, inset)),
-			perp: tangent.perp,
-			offset,
-			rotation: labelRotationAlong(tangent.interior),
-			textAnchor: tangent.outwardX >= 0 ? "end" : "start"
-		};
+function pushWrappedGap(gaps, g0, g1, total) {
+	if (g1 - g0 >= total) {
+		gaps.push({
+			g0: 0,
+			g1: total
+		});
+		return;
+	}
+	const lo = (g0 % total + total) % total;
+	const hi = (g1 % total + total) % total;
+	if (lo <= hi) gaps.push({
+		g0: lo,
+		g1: hi
+	});
+	else {
+		gaps.push({
+			g0: lo,
+			g1: total
+		});
+		gaps.push({
+			g0: 0,
+			g1: hi
+		});
 	}
-	return frames;
 }
-/**
-* Places one label above each end of `verts` (projected meters), inset
-* slightly from the tip and anchored toward the line's interior — the MIL-
-* STD-2525E template convention for fixed end labels like "LL"/"HOL"/"BHL"
-* (as opposed to Phase Line's "beyond the tip" placement, see
-* {@link pushEndLabels}). Placement comes from {@link aboveEndFrames}, which
-* generic-c2-line's H/T-above + W/W1-below labels share. `textForEnd` supplies
-* each end's text — a shared string, or a function keyed by which end; an empty
-* string skips that end.
-*/
-function pushEndLabelsAbove(out, verts, textForEnd, options = {}) {
-	const frames = aboveEndFrames(verts, options);
-	const sizeProps = labelSizeProps(options);
-	for (const end of ["start", "end"]) {
-		const frame = frames[end];
-		if (!frame) continue;
-		const text = typeof textForEnd === "string" ? textForEnd : textForEnd(end);
-		if (text.length === 0) continue;
-		pushLabel(out, vecAdd(frame.base, vecScale(frame.perp, frame.offset)), text, frame.rotation, sizeProps, frame.textAnchor);
-	}
+/** Whether the global arc position `arc` falls inside any of `gaps` (each
+*  already normalized onto `[0, total)` by {@link pushWrappedGap}, so a plain
+*  per-gap interval test suffices). Shared by the boundary-decoration measures
+*  that suppress a glyph/tic/barb sitting on top of a masking gap. */
+function arcInGaps(arc, gaps) {
+	return gaps.some((g) => arc >= g.g0 && arc <= g.g1);
+}
+/** Appends `position` unless it coincides with the buffer's current tail. */
+function appendUnique(buffer, position) {
+	const tail = buffer[buffer.length - 1];
+	if (tail && Math.abs(tail[0] - position[0]) < 1e-9 && Math.abs(tail[1] - position[1]) < 1e-9) return;
+	buffer.push(position);
 }
 /**
-* Convenience for measures that are just a polyline with a fixed label at
-* each end: builds the LineString through `positions` plus its end labels
-* (via {@link pushEndLabels} or {@link pushEndLabelsAbove}, per `placement`)
-* as a complete FeatureCollection.
+* Builds the polyline as MultiLineString rings, splitting it with a gap at each
+* echelon position. `gaps` holds global arc-length intervals (distance from the
+* start of the whole polyline) to carve out — a single gap can span several
+* short segments, which matters when the line has been smoothed into many
+* samples. Works for both open polylines and closed rings (pass a vertex array
+* whose first and last positions coincide).
 */
-function fixedLabelLineFeatures(positions, options, textForEnd, hostileText, context) {
-	const { part, placement = "beyond", phaseLineName, includePrefix = true, lineStyle, smooth, smoothResolution, ...sizeOptions } = options;
-	const verts = smoothLineVerts(positions.map((p) => project(p[0], p[1])), {
-		smooth,
-		smoothResolution
-	}, 12);
-	const lineCoordinates = smooth ? verts.map((v) => unproject(v[0], v[1])) : positions;
-	const features = [{
-		type: "Feature",
-		properties: lineStyle === void 0 ? { part } : {
-			part,
-			style: lineStyle
-		},
-		geometry: {
-			type: "LineString",
-			coordinates: lineCoordinates
-		}
-	}];
-	const labelFeatures = [];
-	if (placement === "above") pushEndLabelsAbove(labelFeatures, verts, textForEnd, sizeOptions);
-	else pushEndLabels(labelFeatures, verts, textForEnd, sizeOptions);
-	const nameText = phaseLineLabelText(phaseLineName?.trim(), includePrefix);
-	if (nameText) pushEndLabels(labelFeatures, verts, nameText, sizeOptions);
-	pushHostileEndLabels(labelFeatures, verts, hostileText, sizeOptions, nameText || (placement === "beyond" ? textForEnd : ""), context);
-	features.push(...labelFeatures);
-	return {
-		type: "FeatureCollection",
-		features
+function buildGappedLine(verts, gaps) {
+	const parts = [];
+	let buffer = [];
+	const flush = () => {
+		if (buffer.length >= 2) parts.push(buffer);
+		buffer = [];
 	};
+	if (verts.length === 0) return parts;
+	const merged = [];
+	for (const g of [...gaps].sort((x, y) => x.g0 - y.g0)) {
+		const last = merged[merged.length - 1];
+		if (last && g.g0 <= last.g1) last.g1 = Math.max(last.g1, g.g1);
+		else merged.push({ ...g });
+	}
+	appendUnique(buffer, unproject(verts[0][0], verts[0][1]));
+	let dist = 0;
+	for (let i = 0; i < verts.length - 1; i++) {
+		const a = verts[i];
+		const b = verts[i + 1];
+		const seg = vecSub(b, a);
+		const L = vecMag(seg);
+		if (L < 1e-6) continue;
+		const segStart = dist;
+		const segEnd = dist + L;
+		const along = vecNorm(seg);
+		const pointAt = (globalD) => {
+			const q = vecAdd(a, vecScale(along, globalD - segStart));
+			return unproject(q[0], q[1]);
+		};
+		for (const g of merged) {
+			if (g.g1 <= segStart || g.g0 >= segEnd) continue;
+			const g0 = Math.max(segStart, g.g0);
+			const g1 = Math.min(segEnd, g.g1);
+			if (g1 <= g0) continue;
+			appendUnique(buffer, pointAt(g0));
+			flush();
+			buffer.push(pointAt(g1));
+		}
+		appendUnique(buffer, unproject(b[0], b[1]));
+		dist = segEnd;
+	}
+	flush();
+	return parts;
 }
 //#endregion
 //#region src/text-amplifiers.ts
@@ -5693,6 +6237,7 @@ const freezeEchelonLabeledAreaAnchor = makeFreezeEchelonAnchor({
 const DEFAULT_BASE_CAMP_OPTIONS = DEFAULT_ECHELON_LABELED_AREA_OPTIONS;
 const BASE_CAMP_METADATA = {
 	id: "base-camp",
+	sizePairs: [ECHELON_SIZE_PAIR],
 	name: "Base camp",
 	description: "An evolving military facility that supports military operations of a deployed unit and provides the necessary support and services for sustained operations.",
 	entity: "Command and Control Areas",
@@ -5752,6 +6297,7 @@ const BASE_CAMP = defineControlMeasure({
 const DEFAULT_GUERRILLA_BASE_OPTIONS = DEFAULT_ECHELON_LABELED_AREA_OPTIONS;
 const GUERRILLA_BASE_METADATA = {
 	id: "guerrilla-base",
+	sizePairs: [ECHELON_SIZE_PAIR],
 	name: "Guerrilla base",
 	description: "A temporary site where guerrilla installations, headquarters, and units are located.",
 	entity: "Command and Control Areas",
@@ -5997,6 +6543,15 @@ const ANTITANK_WALL_PARAMS = [...ANTITANK_DITCH_PARAMS, {
 const DEFAULT_TOOTH_HEIGHT = 50;
 const DEFAULT_TOOTH_HEIGHT_PIXELS = 10;
 const DEFAULT_TOOTH_WIDTH_RATIO$1 = 1.15;
+/** Shared by both ditch variants and by the antitank wall built on the same teeth. */
+const TOOTH_HEIGHT_SIZE_PAIR = {
+	id: "tooth-height",
+	label: "Tooth height",
+	pixels: "toothHeightPixels",
+	meters: "toothHeight",
+	defaultUnit: "m",
+	rendering: "geometry"
+};
 const DEFAULT_ANTITANK_DITCH_OPTIONS = {
 	toothHeight: DEFAULT_TOOTH_HEIGHT,
 	toothHeightPixels: DEFAULT_TOOTH_HEIGHT_PIXELS,
@@ -6006,6 +6561,7 @@ const DEFAULT_ANTITANK_DITCH_OPTIONS = {
 };
 const ANTITANK_DITCH_UNDER_CONSTRUCTION_METADATA = {
 	id: "antitank-ditch-under-construction",
+	sizePairs: [TOOTH_HEIGHT_SIZE_PAIR],
 	name: "Ditch - Under Construction",
 	description: "Antitank ditch obstacle under construction.",
 	entity: "Protection Lines",
@@ -6028,6 +6584,7 @@ const ANTITANK_DITCH_UNDER_CONSTRUCTION_METADATA = {
 };
 const ANTITANK_DITCH_COMPLETED_METADATA = {
 	id: "antitank-ditch-completed",
+	sizePairs: [TOOTH_HEIGHT_SIZE_PAIR],
 	name: "Ditch - Completed",
 	description: "Completed antitank ditch obstacle.",
 	entity: "Protection Lines",
@@ -6161,6 +6718,7 @@ const DEFAULT_ANTITANK_WALL_OPTIONS = {
 };
 const ANTITANK_WALL_METADATA = {
 	id: "antitank-wall",
+	sizePairs: [TOOTH_HEIGHT_SIZE_PAIR],
 	name: "Antitank Wall",
 	description: "Antitank wall obstacle.",
 	entity: "Protection Lines",
@@ -6317,7 +6875,7 @@ function createAttackByFire(coordinates, options = {}) {
 	const p2Back = vecAdd(p2, vecScale(dirBackLeft, backLen));
 	const p3Back = vecAdd(p3, vecScale(dirBackRight, backLen));
 	const headWidth = lenShaft * arrowheadWidthRatio;
-	const headFeatures = createArrowHead$2(pTip, dirShaft, headWidth, headWidth);
+	const headFeatures = createArrowHead$1(pTip, dirShaft, headWidth, headWidth);
 	return {
 		type: "FeatureCollection",
 		features: [
@@ -6360,7 +6918,7 @@ function createAttackByFire(coordinates, options = {}) {
 		]
 	};
 }
-function createArrowHead$2(tip, dir, length, width) {
+function createArrowHead$1(tip, dir, length, width) {
 	const norm = [-dir[1], dir[0]];
 	const base = vecSub(tip, vecScale(dir, length));
 	const left = vecAdd(base, vecScale(norm, width / 2));
@@ -6625,6 +7183,7 @@ const DEFAULT_BATTLE_POSITION_OPTIONS = {
 };
 const BATTLE_POSITION_METADATA = {
 	id: "battle-position",
+	sizePairs: [ECHELON_SIZE_PAIR],
 	name: "Battle Position",
 	description: "A defensive location oriented on a likely enemy avenue of approach, labeled with the echelon of the occupying unit.",
 	entity: "Maneuver Areas",
@@ -6768,6 +7327,7 @@ const BATTLE_POSITION_PREPARED_DASH = [6, 4];
 const DEFAULT_BATTLE_POSITION_PREPARED_OPTIONS = { ...DEFAULT_BATTLE_POSITION_OPTIONS };
 const BATTLE_POSITION_PREPARED_METADATA = {
 	id: "battle-position-prepared",
+	sizePairs: [ECHELON_SIZE_PAIR],
 	name: "Battle Position Prepared (P) but not Occupied",
 	description: "A battle position that has been prepared for occupation but is not yet occupied, drawn with a dashed boundary and a (P)-prefixed designation.",
 	entity: "Maneuver Areas",
@@ -7735,6 +8295,7 @@ const DEFAULT_BOUNDARY_OPTIONS = {
 };
 const BOUNDARY_METADATA = {
 	id: "boundary",
+	sizePairs: [ECHELON_SIZE_PAIR],
 	name: "Boundary",
 	description: "Delineates the area of responsibility between two adjacent units, labeled with the echelon and the designators of the units it separates.",
 	entity: "Command and Control Lines",
@@ -8152,6 +8713,7 @@ const DEFAULT_GENERIC_C2_LINE_OPTIONS = {
 };
 const GENERIC_C2_LINE_METADATA = {
 	id: "generic-c2-line",
+	sizePairs: [ECHELON_SIZE_PAIR],
 	name: "Generic command and control line",
 	description: "Illustrative command-and-control-style line (not part of MIL-STD-2525E) carrying optional echelon glyphs, additional-information/designation text above it, and an effective date-time-group window below it.",
 	entity: "Command and Control Lines",
@@ -8357,130 +8919,6 @@ const GENERIC_C2_LINE = defineControlMeasure({
 	}
 });
 //#endregion
-//#region src/generators/cm34-mission-tasks/shared.ts
-/**
-* Builds an open chevron arrowhead (left → tip → right) as unprojected
-* coordinates. The tip sits at `tip`, pointing along `dir`, with the base set
-* back by `length` and spanning `width` perpendicular to the shaft. Mirrors the
-* `createArrowHead` helper used by the attack-family generators.
-*/
-function createArrowHead$1(tip, dir, length, width) {
-	const norm = [-dir[1], dir[0]];
-	const base = vecSub(tip, vecScale(dir, length));
-	const left = vecAdd(base, vecScale(norm, width / 2));
-	const right = vecSub(base, vecScale(norm, width / 2));
-	return [
-		unproject(left[0], left[1]),
-		unproject(tip[0], tip[1]),
-		unproject(right[0], right[1])
-	];
-}
-/**
-* Builds the glyph label as a Point feature, forwarding the resolved size
-* anchor (`textSizeMeters`/`textSizePixels`, ADR-0028) to adapters for
-* styling. `point` is in projected meters; the rotation must already be in
-* the generator's feature-rotation convention. Shared by every mission-task
-* measure that centers a glyph on its symbol.
-*/
-function createLabelFeature(point, text, rotation, labelSize = {}) {
-	return {
-		type: "Feature",
-		properties: {
-			part: "label",
-			labelPlacement: false,
-			text,
-			rotation,
-			...labelSizeProps(labelSize)
-		},
-		geometry: {
-			type: "Point",
-			coordinates: unproject(point[0], point[1])
-		}
-	};
-}
-/**
-* Shared scaffold for the "bracket" mission-task symbols (breach, bypass,
-* canalize). Owns the three-sided bracket: a front opening (PT. 1 / PT. 2), a
-* rear line parallel to it through PT. 3, and a glyph centered on the rear line.
-* Each measure supplies only its end caps and label glyph via
-* {@link BracketSymbolConfig}.
-*
-* Input Points:
-* - PT. 1: Front opening endpoint (top/left)
-* - PT. 2: Front opening endpoint (bottom/right) - defines height with PT. 1
-* - PT. 3: Rear point - defines length and orientation
-*
-* Geometric Construction:
-* 1. PT. 1 and PT. 2 define the front opening (facing enemy/objective)
-* 2. A parallel line is projected through PT. 3 with identical height
-* 3. LineString follows: PT. 1 → Rear Top → Rear Bottom → PT. 2
-* 4. Measure-specific end caps at PT. 1 and PT. 2
-* 5. Label point at midpoint of rear line (styled with OpenLayers Text)
-*
-* @param coordinates - [PT. 1, PT. 2, PT. 3] as Position arrays
-* @param config - Per-measure end caps, label glyph, and sizing
-* @returns GeoJSON FeatureCollection containing MultiLineString and Point features
-*/
-function createBracketSymbol(coordinates, config, context) {
-	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 vFront = vecSub(p2, p1);
-	const frontLength = vecMag(vFront);
-	if (frontLength < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const dirFront = vecNorm(vFront);
-	const frontMidpoint = vecScale(vecAdd(p1, p2), .5);
-	const vToRear = vecSub(p3, frontMidpoint);
-	const perpDir = [-dirFront[1], dirFront[0]];
-	const perpDistance = vToRear[0] * perpDir[0] + vToRear[1] * perpDir[1];
-	const halfFront = vecScale(dirFront, frontLength / 2);
-	const rearMidpoint = vecAdd(frontMidpoint, vecScale(perpDir, perpDistance));
-	const rearTop = vecSub(rearMidpoint, halfFront);
-	const rearBottom = vecAdd(rearMidpoint, halfFront);
-	const rearLineRotation = Math.atan2(dirFront[1], dirFront[0]);
-	const renderedLabelRotation = Math.PI - (rearLineRotation - Math.PI / 2);
-	const labelRotation = normalizeRadians(Math.PI - keepTextLeftToRight(renderedLabelRotation));
-	const gapHalf = Math.min(frontLength / 2, labelKnockoutHalfExtent(config.labelText, dirFront, labelRotation, config.labelOptions ?? {}, context));
-	const gapPt1 = vecAdd(rearMidpoint, vecScale(dirFront, -gapHalf));
-	const gapPt2 = vecAdd(rearMidpoint, vecScale(dirFront, gapHalf));
-	const [topCap, bottomCap] = config.buildEndCaps({
-		p1,
-		p2,
-		dirFront,
-		perpDir,
-		frontLength,
-		rearTop
-	});
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: { part: config.part },
-			geometry: {
-				type: "MultiLineString",
-				coordinates: [
-					topCap,
-					[
-						unproject(p1[0], p1[1]),
-						unproject(rearTop[0], rearTop[1]),
-						unproject(gapPt1[0], gapPt1[1])
-					],
-					[
-						unproject(gapPt2[0], gapPt2[1]),
-						unproject(rearBottom[0], rearBottom[1]),
-						unproject(p2[0], p2[1])
-					],
-					bottomCap
-				]
-			}
-		}, createLabelFeature(rearMidpoint, config.labelText, labelRotation, config.labelOptions)]
-	};
-}
-//#endregion
 //#region src/generators/cm34-mission-tasks/block.ts
 const DEFAULT_STEM_RATIO = 1.5;
 const DEFAULT_BLOCK_MISSION_TASK_OPTIONS = { labelPadding: DEFAULT_LABEL_KNOCKOUT_PADDING };
@@ -8721,7 +9159,7 @@ function createBypassSymbol(coordinates, options = {}, _textAmplifiers = {}, con
 		buildEndCaps: ({ p1, p2, frontLength, rearTop }) => {
 			const arrowheadLength = frontLength * arrowheadLengthRatio;
 			const arrowDir = vecNorm(vecSub(p1, rearTop));
-			return [createArrowHead$1(p1, arrowDir, arrowheadLength, arrowheadLength), createArrowHead$1(p2, arrowDir, arrowheadLength, arrowheadLength)];
+			return [createArrowHead$2(p1, arrowDir, arrowheadLength, arrowheadLength), createArrowHead$2(p2, arrowDir, arrowheadLength, arrowheadLength)];
 		}
 	}, context);
 }
@@ -9607,6 +10045,14 @@ const DEFAULT_GENERIC_TEXT_OPTIONS = {
 };
 const GENERIC_TEXT_METADATA = {
 	id: "text",
+	sizePairs: [{
+		id: "size",
+		label: "Size",
+		pixels: "sizePixels",
+		meters: "sizeMeters",
+		defaultUnit: "px",
+		rendering: "text"
+	}],
 	name: "Text",
 	description: "A non-doctrinal free-standing text label anchored at a single point.",
 	entity: "Generic Graphics",
@@ -10007,7 +10453,7 @@ function createClearSymbol(coordinates, options = {}, _textAmplifiers = {}, cont
 			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));
+		lines.push(createArrowHead$2(tip, arrowDir, arrowheadLength, arrowheadWidth));
 	});
 	const mainFeature = {
 		type: "Feature",
@@ -10168,7 +10614,7 @@ function createIsolateVariantSymbol(coordinates, options, config, context = {})
 	const barbLength = radius * barbLengthRatio;
 	const lines = [sampleArc(0, labelSweep - labelHalfGap), sampleArc(labelSweep + labelHalfGap, arcSpan)];
 	const tipDir = [Math.sin(endAngle), -Math.cos(endAngle)];
-	lines.push(createArrowHead$1(pointOnCircle(endAngle), tipDir, barbLength, barbLength));
+	lines.push(createArrowHead$2(pointOnCircle(endAngle), tipDir, barbLength, barbLength));
 	const halfWidth = Math.asin(Math.min(1, barbLength / 2 / radius));
 	const tipRadius = Math.max(0, radius - barbLength);
 	const steps = Math.max(1, barbCount);
@@ -11176,7 +11622,7 @@ function createDelayTaskSymbol(coordinates, config, options, context) {
 	const lines = [
 		[unproject(p1[0], p1[1]), unproject(gapStart[0], gapStart[1])],
 		[unproject(gapEnd[0], gapEnd[1]), unproject(p2[0], p2[1])],
-		createArrowHead$1(p1, vecScale(dirLine, -1), lineLength * (options.arrowheadLengthRatio ?? DEFAULT_DELAY_OPTIONS.arrowheadLengthRatio), lineLength * (options.arrowheadWidthRatio ?? DEFAULT_DELAY_OPTIONS.arrowheadWidthRatio))
+		createArrowHead$2(p1, vecScale(dirLine, -1), lineLength * (options.arrowheadLengthRatio ?? DEFAULT_DELAY_OPTIONS.arrowheadLengthRatio), lineLength * (options.arrowheadWidthRatio ?? DEFAULT_DELAY_OPTIONS.arrowheadWidthRatio))
 	];
 	if (diameter >= 1e-6) lines.push(createSemicircleArc(p2, diameterEnd, dirLine, options.arcSegments ?? DEFAULT_DELAY_OPTIONS.arcSegments));
 	return {
@@ -11259,8 +11705,8 @@ function createHairpinSymbol(coordinates, config, options = {}) {
 					...upperArm,
 					createSemicircleArc(p2, p3, upperDirection, options.arcSegments ?? DEFAULT_DELAY_OPTIONS.arcSegments),
 					[unproject(p4[0], p4[1]), unproject(p3[0], p3[1])],
-					createArrowHead$1(p1, vecScale(upperDirection, -1), upperLength * arrowheadLengthRatio, upperLength * arrowheadWidthRatio),
-					createArrowHead$1(p3, lowerDirection, lowerLength * arrowheadLengthRatio, lowerLength * arrowheadWidthRatio)
+					createArrowHead$2(p1, vecScale(upperDirection, -1), upperLength * arrowheadLengthRatio, upperLength * arrowheadWidthRatio),
+					createArrowHead$2(p3, lowerDirection, lowerLength * arrowheadLengthRatio, lowerLength * arrowheadWidthRatio)
 				]
 			}
 		}, label]
@@ -11496,12 +11942,12 @@ function createDisruptMissionTaskSymbol(coordinates, options = {}, _textAmplifie
 				coordinates: [
 					[p1LonLat, p2LonLat],
 					[[...p1LonLat], unproject(topTip[0], topTip[1])],
-					createArrowHead$1(topTip, arrowDirection, headLength, headWidth),
+					createArrowHead$2(topTip, arrowDirection, headLength, headWidth),
 					[unproject(rearEnd[0], rearEnd[1]), unproject(gapStart[0], gapStart[1])],
 					[unproject(gapEnd[0], gapEnd[1]), unproject(middleTip[0], middleTip[1])],
-					createArrowHead$1(middleTip, arrowDirection, headLength, headWidth),
+					createArrowHead$2(middleTip, arrowDirection, headLength, headWidth),
 					[[...p2LonLat], unproject(bottomTip[0], bottomTip[1])],
-					createArrowHead$1(bottomTip, arrowDirection, headLength, headWidth)
+					createArrowHead$2(bottomTip, arrowDirection, headLength, headWidth)
 				]
 			}
 		}, createLabelFeature(labelPoint, "D", labelRotation, {
@@ -11607,7 +12053,7 @@ function createEnvelopment(coordinates, options = {}, _textAmplifiers = {}, cont
 	let bulgeRadius = [-startRadius[1], startRadius[0]];
 	if (vecDot(vecSub(p4, center), bulgeRadius) < 0) bulgeRadius = vecScale(bulgeRadius, -1);
 	const arc = sampleProjectedArc(center, startRadius, bulgeRadius, 0, Math.PI, normalizeArcResolution(options.resolution) / 2);
-	const arrowhead = createArrowHead$1(p3, vecNorm(vecScale(bulgeRadius, -1)), diameter * Math.max(0, options.arrowheadLengthRatio ?? DEFAULT_ENVELOPMENT_OPTIONS.arrowheadLengthRatio), diameter * Math.max(0, options.arrowheadWidthRatio ?? DEFAULT_ENVELOPMENT_OPTIONS.arrowheadWidthRatio));
+	const arrowhead = createArrowHead$2(p3, vecNorm(vecScale(bulgeRadius, -1)), diameter * Math.max(0, options.arrowheadLengthRatio ?? DEFAULT_ENVELOPMENT_OPTIONS.arrowheadLengthRatio), diameter * Math.max(0, options.arrowheadWidthRatio ?? DEFAULT_ENVELOPMENT_OPTIONS.arrowheadWidthRatio));
 	return {
 		type: "FeatureCollection",
 		features: [{
@@ -11676,7 +12122,7 @@ function createExploitation(coordinates, _options = {}) {
 		features: []
 	};
 	const direction = vecNorm(axis);
-	const chevron = (tip) => createArrowHead$1(tip, direction, finLength * Math.SQRT1_2, finLength * Math.SQRT2);
+	const chevron = (tip) => createArrowHead$2(tip, direction, finLength * Math.SQRT1_2, finLength * Math.SQRT2);
 	const [finLeft, , finRight] = chevron(p2);
 	return {
 		type: "FeatureCollection",
@@ -12046,7 +12492,7 @@ function createInfiltration(coordinates, options = {}, _textAmplifiers = {}, con
 	const gapHalf = Math.min(straightLength * Math.min(labelPosition, 1 - labelPosition), labelKnockoutHalfExtent("IN", along, labelRotation, options, context, DEFAULT_INFILTRATION_OPTIONS.labelPadding));
 	const gapStart = vecAdd(labelPoint, vecScale(along, -gapHalf));
 	const gapEnd = vecAdd(labelPoint, vecScale(along, gapHalf));
-	const arrowhead = createArrowHead$1(p3, along, spanLength * Math.max(0, options.arrowheadLengthRatio ?? DEFAULT_INFILTRATION_OPTIONS.arrowheadLengthRatio), spanLength * Math.max(0, options.arrowheadWidthRatio ?? DEFAULT_INFILTRATION_OPTIONS.arrowheadWidthRatio));
+	const arrowhead = createArrowHead$2(p3, along, spanLength * Math.max(0, options.arrowheadLengthRatio ?? DEFAULT_INFILTRATION_OPTIONS.arrowheadLengthRatio), spanLength * Math.max(0, options.arrowheadWidthRatio ?? DEFAULT_INFILTRATION_OPTIONS.arrowheadWidthRatio));
 	return {
 		type: "FeatureCollection",
 		features: [{
@@ -13077,7 +13523,7 @@ function createFixMissionTaskSymbol(coordinates, options = {}, _textAmplifiers =
 						toPosition(zigzagExit),
 						toPosition(tip)
 					],
-					createArrowHead$1(tip, along, arrowheadLength, arrowheadWidth)
+					createArrowHead$2(tip, along, arrowheadLength, arrowheadWidth)
 				]
 			}
 		}, createLabelFeature(labelCenter, "F", labelRotation, options)]
@@ -13110,6 +13556,14 @@ const DEFAULT_FLOT_OPTIONS = {
 };
 const FLOT_METADATA = {
 	id: "flot",
+	sizePairs: [{
+		id: "radius",
+		label: "Radius",
+		pixels: "radiusPixels",
+		meters: "radius",
+		defaultUnit: "m",
+		rendering: "geometry"
+	}],
 	name: "Forward line of own troops (FLOT)",
 	description: "Indicates the most forward positions of friendly forces at a specific time.",
 	entity: "Maneuver Lines",
@@ -14280,6 +14734,15 @@ const PROBABLE_LINE_OF_DEPLOYMENT = defineControlMeasure({
 });
 //#endregion
 //#region src/generators/cm29-protection-lines/fortifiedLine.ts
+/** Shared by the fortified line and the fortified area built from it. */
+const TOOTH_SIZE_SIZE_PAIR = {
+	id: "tooth-size",
+	label: "Tooth size",
+	pixels: "toothSizePixels",
+	meters: "toothSize",
+	defaultUnit: "m",
+	rendering: "geometry"
+};
 const DEFAULT_TOOTH_SIZE = 50;
 const DEFAULT_TOOTH_SIZE_PIXELS = 10;
 const DEFAULT_SMOOTH_RESOLUTION$1 = 16;
@@ -14294,6 +14757,7 @@ const DEFAULT_FORTIFIED_LINE_OPTIONS = {
 };
 const FORTIFIED_LINE_METADATA = {
 	id: "fortified-line",
+	sizePairs: [TOOTH_SIZE_SIZE_PAIR],
 	name: "Fortified Line",
 	description: "Fortified line with castellated square-wave boundary.",
 	entity: "Protection Lines",
@@ -14451,6 +14915,7 @@ const FORTIFIED_LINE = defineControlMeasure({
 const DEFAULT_FORTIFIED_AREA_OPTIONS = DEFAULT_FORTIFIED_LINE_OPTIONS;
 const FORTIFIED_AREA_METADATA = {
 	id: "fortified-area",
+	sizePairs: [TOOTH_SIZE_SIZE_PAIR],
 	name: "Fortified Area",
 	description: "A specified geographical locality with constructed defensive works as protection against attack.",
 	entity: "Maneuver Areas",
@@ -15047,7 +15512,7 @@ function createPenetrateSymbol(coordinates, options = {}, _textAmplifiers = {},
 					[coordinates[0], coordinates[1]],
 					[unproject(tail[0], tail[1]), unproject(gapStart[0], gapStart[1])],
 					[unproject(gapEnd[0], gapEnd[1]), unproject(tip[0], tip[1])],
-					createArrowHead$1(tip, arrowDirection, headLength, headWidth)
+					createArrowHead$2(tip, arrowDirection, headLength, headWidth)
 				]
 			}
 		}, createLabelFeature(labelPoint, "P", labelRotation, {
@@ -15173,7 +15638,7 @@ function createPursuit(coordinates, options = {}, _textAmplifiers = {}, context
 	const arc = sampleProjectedArc(center, vecSub(p2, center), vecScale(straightDirection, diameter / 2), 0, Math.PI, normalizeArcResolution(options.resolution) / 2);
 	const arrowheadLength = diameter * Math.max(0, options.arrowheadLengthRatio ?? DEFAULT_PURSUIT_OPTIONS.arrowheadLengthRatio);
 	const arrowheadWidth = diameter * Math.max(0, options.arrowheadWidthRatio ?? DEFAULT_PURSUIT_OPTIONS.arrowheadWidthRatio);
-	const arrowhead = createArrowHead$1(p3, vecScale(straightDirection, -1), arrowheadLength, arrowheadWidth);
+	const arrowhead = createArrowHead$2(p3, vecScale(straightDirection, -1), arrowheadLength, arrowheadWidth);
 	const terminalBarHalf = arrowheadWidth * Math.max(0, options.terminalBarLengthRatio ?? DEFAULT_PURSUIT_OPTIONS.terminalBarLengthRatio) / 2;
 	const terminalStart = vecAdd(p3, vecScale(diameterAxis, terminalBarHalf));
 	const terminalEnd = vecSub(p3, vecScale(diameterAxis, terminalBarHalf));
@@ -15489,7 +15954,7 @@ function createSecureSymbol(coordinates, options = {}, _textAmplifiers = {}, con
 	const lines = [
 		sampleArc(0, labelSweep - labelHalfGap),
 		sampleArc(labelSweep + labelHalfGap, boundarySpan),
-		createArrowHead$1(terminal, tangent, radius * Math.max(0, resolved.arrowheadLengthRatio), radius * Math.max(0, resolved.arrowheadWidthRatio))
+		createArrowHead$2(terminal, tangent, radius * Math.max(0, resolved.arrowheadLengthRatio), radius * Math.max(0, resolved.arrowheadWidthRatio))
 	];
 	const labelPoint = arcPointAt(center, radiusVector, bulgeVector, labelSweep);
 	return {
@@ -15684,7 +16149,7 @@ function createSeizeLikeSymbol(coordinates, options = {}, label = "S", part = "s
 		circle,
 		firstArcPart,
 		secondArcPart,
-		createArrowHead$1(tip, arrowDirection, span * Math.max(0, options.arrowheadLengthRatio ?? DEFAULT_SEIZE_OPTIONS.arrowheadLengthRatio), span * Math.max(0, options.arrowheadWidthRatio ?? DEFAULT_SEIZE_OPTIONS.arrowheadWidthRatio))
+		createArrowHead$2(tip, arrowDirection, span * Math.max(0, options.arrowheadLengthRatio ?? DEFAULT_SEIZE_OPTIONS.arrowheadLengthRatio), span * Math.max(0, options.arrowheadWidthRatio ?? DEFAULT_SEIZE_OPTIONS.arrowheadWidthRatio))
 	];
 	return {
 		type: "FeatureCollection",
@@ -16561,6 +17026,15 @@ const DEFAULT_MINEFIELD_OPTIONS = {
 const DEFAULT_MINEFIELD_SIZE_METERS = 1e3;
 const MINEFIELD_METADATA = {
 	id: "minefield",
+	sizePairs: [{
+		id: "size",
+		label: "Size",
+		pixels: "sizePixels",
+		meters: "sizeMeters",
+		defaultUnit: "px",
+		rendering: "geometry",
+		fallbackMeters: DEFAULT_MINEFIELD_SIZE_METERS
+	}],
 	name: "Minefield",
 	description: "A static point symbol identifying a minefield and its mine type.",
 	entity: "Protection Areas",
@@ -17954,6 +18428,7 @@ const DEFAULT_SMOOTH_RESOLUTION = 16;
 const DEFAULT_STRONG_POINT_OPTIONS = { ...DEFAULT_BATTLE_POSITION_OPTIONS };
 const STRONG_POINT_METADATA = {
 	id: "strong-point",
+	sizePairs: [ECHELON_SIZE_PAIR],
 	name: "Strong Point",
 	description: "A key point in a defensive position, usually strongly fortified and heavily armed, around which other positions are grouped for its protection.",
 	entity: "Maneuver Areas",
@@ -18698,6 +19173,10 @@ const DEFINITIONS = {
 	guard: GUARD,
 	isolate: ISOLATE,
 	"movement-to-contact": MOVEMENT_TO_CONTACT,
+	destroy: DESTROY,
+	defeat: DEFEAT,
+	neutralize: NEUTRALIZE,
+	suppress: SUPPRESS,
 	occupy: OCCUPY,
 	penetrate: PENETRATE,
 	pursuit: PURSUIT,
@@ -18751,18 +19230,27 @@ const DEFINITIONS = {
 };
 /** Insertion-ordered list of every control-measure id. */
 const CONTROL_MEASURE_IDS = Object.keys(DEFINITIONS);
-/**
-* Merges a definition's resolved `rule` object back onto its metadata,
-* preserving ADR-0005's `getControlMeasureMetadata` shape. Definitions whose
-* `drawRule` id has no implementation leave `rule` undefined.
-*/
-function withRule(definition) {
-	return definition.rule ? {
+/** The shared label dimension materialized for capture-enabled definitions. */
+const LABEL_SIZE_PAIR = {
+	id: "label",
+	label: "Label size",
+	pixels: "labelSizePixels",
+	meters: "labelSize",
+	defaultUnit: "px",
+	defaultValue: 14,
+	rendering: "text",
+	captureOnDraw: true
+};
+/** Resolve definition-owned metadata and the shared label-capture capability. */
+function resolveMetadata(definition) {
+	const sizePairs = [...definition.metadata.sizePairs ?? [], ...definition.metadata.capturesLabelSize ? [LABEL_SIZE_PAIR] : []];
+	return {
 		...definition.metadata,
-		rule: definition.rule
-	} : definition.metadata;
+		...definition.rule ? { rule: definition.rule } : {},
+		sizePairs
+	};
 }
-const CONTROL_MEASURE_METADATA = Object.fromEntries(Object.entries(DEFINITIONS).map(([id, definition]) => [id, withRule(definition)]));
+const CONTROL_MEASURE_METADATA = Object.fromEntries(Object.entries(DEFINITIONS).map(([id, definition]) => [id, resolveMetadata(definition)]));
 const CONTROL_MEASURE_METADATA_LIST = Object.values(CONTROL_MEASURE_METADATA);
 const CONTROL_MEASURE_METADATA_BY_VALUE = CONTROL_MEASURE_METADATA_LIST.reduce((acc, metadata) => {
 	acc[metadata.value] = metadata;
@@ -19135,4 +19623,4 @@ function assertNever(value) {
 	throw new Error(`Unhandled control measure kind: ${String(value)}`);
 }
 //#endregion
-export { DEFAULT_PHASE_LINE_OPTIONS as $, getMetersPerPixel as $n, DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS as $t, DEFAULT_SECURE_OPTIONS as A, staticPointDrawRule as An, DEFAULT_GENERIC_CIRCLE_OPTIONS as At, DEFAULT_FORTIFIED_LINE_OPTIONS as B, computeDefaultMidpointPerpendicularPoint as Bn, DEFAULT_BLOCK_ARROW_OPTIONS as Bt, DEFAULT_LANDING_ZONE_OPTIONS as C, line23DrawRule as Cn, RADAR_SEARCH_DOCTRINE_FILL_COLOR as Ct, DEFAULT_WITHDRAW_OPTIONS as D, attackByFireDrawRule as Dn, DEFAULT_GENERIC_RECTANGLE_OPTIONS as Dt, DEFAULT_WITHDRAW_UNDER_PRESSURE_OPTIONS as E, ambushDrawRule as En, DEFAULT_GENERIC_SECTOR_OPTIONS as Et, DEFAULT_PENETRATE_OPTIONS as F, disruptDrawRule as Fn, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as Ft, DEFAULT_LIMIT_OF_ADVANCE_OPTIONS as G, createBaselineFrame as Gn, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Gt, PROBABLE_LINE_OF_DEPLOYMENT_DASH as H, getMidpointPerpendicularSignedDistance as Hn, DEFAULT_CONTAIN_OPTIONS as Ht, DEFAULT_OCCUPY_OPTIONS as I, blockDrawRule as In, DEFAULT_GENERIC_C2_LINE_OPTIONS as It, DEFAULT_FORWARD_EDGE_OF_BATTLE_AREA_OPTIONS as J, haversineDistance as Jn, DEFAULT_ASSEMBLY_AREA_OPTIONS as Jt, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as K, calculateMetrics as Kn, DEFAULT_ANTITANK_WALL_OPTIONS as Kt, DEFAULT_MOVEMENT_TO_CONTACT_OPTIONS as L, centerRadiusDrawRule as Ln, DEFAULT_ENGINEER_WORK_LINE_OPTIONS as Lt, DEFAULT_RETIRE_OPTIONS as M, secureDrawRule as Mn, DEFAULT_CANALIZE_OPTIONS as Mt, DEFAULT_RELIEF_IN_PLACE_OPTIONS as N, penetrateDrawRule as Nn, DEFAULT_BYPASS_OPTIONS as Nt, DEFAULT_EVACUATE_OPTIONS as O, dynamicPointDrawRule as On, DEFAULT_GENERIC_POLYGON_OPTIONS as Ot, DEFAULT_REARWARD_PASSAGE_OF_LINES_OPTIONS as P, occupyDrawRule as Pn, DEFAULT_BREACH_OPTIONS as Pt, DEFAULT_BRIDGEHEAD_LINE_OPTIONS as Q, EPSILON as Qn, DEFAULT_AREA_DEFENSE_OPTIONS as Qt, DEFAULT_FRONTAL_ATTACK_OPTIONS as R, containDrawRule as Rn, DEFAULT_LIGHT_LINE_OPTIONS as Rt, DEFAULT_MAIN_ATTACK_OPTIONS as S, line24DrawRule as Sn, DEFAULT_RADAR_SEARCH_DOCTRINE_OPTIONS as St, DEFAULT_TURN_OPTIONS as T, line1DrawRule as Tn, DEFAULT_GENERIC_TEXT_OPTIONS as Tt, DEFAULT_LINE_OF_DEPARTURE_CONTACT_OPTIONS as U, pointOnMidpointPerpendicularAxis as Un, DEFAULT_BATTLE_POSITION_OPTIONS as Ut, DEFAULT_PROBABLE_LINE_OF_DEPLOYMENT_OPTIONS as V, createMidpointPerpendicularDrawRule as Vn, DEFAULT_BLOCK_OPTIONS as Vt, DEFAULT_LINE_OF_DEPARTURE_OPTIONS as W, snapToMidpointPerpendicular as Wn, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Wt, DEFAULT_HOLDING_LINE_OPTIONS as X, sphericalBearing as Xn, DEFAULT_MOBILE_DEFENSE_OPTIONS as Xt, DEFAULT_RELEASE_LINE_OPTIONS as Y, project as Yn, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as Yt, DEFAULT_INFILTRATION_LANE_OPTIONS as Z, unproject as Zn, DEFAULT_ENGAGEMENT_AREA_OPTIONS as Zt, DEFAULT_PICKUP_ZONE_OPTIONS as _, axis1DrawRule as _n, DEFAULT_SUPPORTING_ATTACK_OPTIONS as _t, DEFINITIONS as a, resolveAmplifierPlacement as an, DEFAULT_DISRUPT_OPTIONS as at, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as b, line27DrawRule as bn, DEFAULT_ISOLATE_OPTIONS as bt, getDefaultOptions as c, DEFAULT_LINE_CAP as cn, createFollowAndAssume as ct, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as d, DEFAULT_STROKE_DASH_CSS_PIXELS as dn, DEFAULT_DEMONSTRATE_OPTIONS as dt, DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS as en, roundToFixed as er, DEFAULT_FLOT_OPTIONS as et, DEFAULT_RETAIN_OPTIONS as f, DEFAULT_STROKE_WIDTH_CSS_PIXELS as fn, DEFAULT_DELAY_OPTIONS as ft, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as g, rectangleDrawRule as gn, DEFAULT_COUNTERATTACK_OPTIONS as gt, SECONDARY_DIRECTION_OF_FIRE_DASH as h, DEFAULT_AIRBORNE_ATTACK_OPTIONS as hn, DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS as ht, CONTROL_MEASURE_METADATA as i, normalizeTextAmplifiers as in, DEFAULT_ENCIRCLEMENT_OPTIONS as it, DEFAULT_SCREEN_OPTIONS as j, point12DrawRule as jn, DEFAULT_CLASSIC_ARROW_OPTIONS as jt, DEFAULT_SEIZE_OPTIONS as k, sectorDrawRule as kn, DEFAULT_GENERIC_LINE_OPTIONS as kt, listControlMeasureMetadata as l, DEFAULT_LINE_JOIN as ln, DEFAULT_DISRUPT_MISSION_TASK_OPTIONS as lt, DEFAULT_SECONDARY_DIRECTION_OF_FIRE_OPTIONS as m, DEFAULT_AMBUSH_OPTIONS as mn, DEFAULT_TACTICAL_ARROW_OPTIONS as mt, resolveStyleHints as n, TEXT_AMPLIFIER_FIELDS as nn, DEFAULT_FIX_OPTIONS as nt, getControlMeasureMetadata as o, DEFAULT_LABEL_HEIGHT_CSS_PIXELS as on, DEFAULT_GUARD_OPTIONS as ot, DEFAULT_STRONG_POINT_OPTIONS as p, DEFAULT_SYMBOL_COLOR as pn, DEFAULT_COVER_OPTIONS as pt, DEFAULT_HANDOVER_LINE_OPTIONS as q, computeInitialWidthPoint as qn, DEFAULT_ANTITANK_DITCH_OPTIONS as qt, CONTROL_MEASURE_IDS as r, canonicalTextAmplifierKey as rn, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as rt, getControlMeasureMetadataByValue as s, DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS as sn, createFollowAndSupport as st, renderControlMeasure as t, DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS as tn, DEFAULT_FIX_MISSION_TASK_OPTIONS as tt, DEFAULT_TURNING_MOVEMENT_OPTIONS as u, DEFAULT_PORTRAYAL as un, DEFAULT_DISENGAGE_OPTIONS as ut, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as v, supportByFireDrawRule as vn, DEFAULT_CORDON_AND_SEARCH_OPTIONS as vt, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as w, turnDrawRule as wn, RADAR_SEARCH_DOCTRINE_STROKE_COLOR as wt, DEFAULT_MINEFIELD_OPTIONS as x, line26DrawRule as xn, DEFAULT_CLEAR_OPTIONS as xt, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as y, polyline1DrawRule as yn, DEFAULT_CORDON_AND_KNOCK_OPTIONS as yt, DEFAULT_FORTIFIED_AREA_OPTIONS as z, area27DrawRule as zn, DEFAULT_BOUNDARY_OPTIONS as zt };
+export { DEFAULT_PHASE_LINE_OPTIONS as $, DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS as $n, DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS as $t, DEFAULT_SECURE_OPTIONS as A, secureDrawRule as An, DEFAULT_GENERIC_CIRCLE_OPTIONS as At, DEFAULT_FORTIFIED_LINE_OPTIONS as B, getMidpointPerpendicularSignedDistance as Bn, DEFAULT_BLOCK_ARROW_OPTIONS as Bt, DEFAULT_LANDING_ZONE_OPTIONS as C, line1DrawRule as Cn, RADAR_SEARCH_DOCTRINE_FILL_COLOR as Ct, DEFAULT_WITHDRAW_OPTIONS as D, sectorDrawRule as Dn, DEFAULT_GENERIC_RECTANGLE_OPTIONS as Dt, DEFAULT_WITHDRAW_UNDER_PRESSURE_OPTIONS as E, dynamicPointDrawRule as En, DEFAULT_GENERIC_SECTOR_OPTIONS as Et, DEFAULT_PENETRATE_OPTIONS as F, centerRadiusDrawRule as Fn, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as Ft, DEFAULT_LIMIT_OF_ADVANCE_OPTIONS as G, project as Gn, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Gt, PROBABLE_LINE_OF_DEPLOYMENT_DASH as H, snapToMidpointPerpendicular as Hn, DEFAULT_CONTAIN_OPTIONS as Ht, DEFAULT_OCCUPY_OPTIONS as I, containDrawRule as In, DEFAULT_GENERIC_C2_LINE_OPTIONS as It, DEFAULT_FORWARD_EDGE_OF_BATTLE_AREA_OPTIONS as J, EPSILON as Jn, DEFAULT_ASSEMBLY_AREA_OPTIONS as Jt, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as K, sphericalBearing as Kn, DEFAULT_ANTITANK_WALL_OPTIONS as Kt, DEFAULT_MOVEMENT_TO_CONTACT_OPTIONS as L, area27DrawRule as Ln, DEFAULT_ENGINEER_WORK_LINE_OPTIONS as Lt, DEFAULT_RETIRE_OPTIONS as M, occupyDrawRule as Mn, DEFAULT_CANALIZE_OPTIONS as Mt, DEFAULT_RELIEF_IN_PLACE_OPTIONS as N, disruptDrawRule as Nn, DEFAULT_BYPASS_OPTIONS as Nt, DEFAULT_EVACUATE_OPTIONS as O, staticPointDrawRule as On, DEFAULT_GENERIC_POLYGON_OPTIONS as Ot, DEFAULT_REARWARD_PASSAGE_OF_LINES_OPTIONS as P, blockDrawRule as Pn, DEFAULT_BREACH_OPTIONS as Pt, DEFAULT_BRIDGEHEAD_LINE_OPTIONS as Q, DEFAULT_LABEL_HEIGHT_CSS_PIXELS as Qn, DEFAULT_AREA_DEFENSE_OPTIONS as Qt, DEFAULT_FRONTAL_ATTACK_OPTIONS as R, computeDefaultMidpointPerpendicularPoint as Rn, DEFAULT_LIGHT_LINE_OPTIONS as Rt, DEFAULT_MAIN_ATTACK_OPTIONS as S, turnDrawRule as Sn, DEFAULT_RADAR_SEARCH_DOCTRINE_OPTIONS as St, DEFAULT_TURN_OPTIONS as T, attackByFireDrawRule as Tn, DEFAULT_GENERIC_TEXT_OPTIONS as Tt, DEFAULT_LINE_OF_DEPARTURE_CONTACT_OPTIONS as U, createBaselineFrame as Un, DEFAULT_BATTLE_POSITION_OPTIONS as Ut, DEFAULT_PROBABLE_LINE_OF_DEPLOYMENT_OPTIONS as V, pointOnMidpointPerpendicularAxis as Vn, DEFAULT_BLOCK_OPTIONS as Vt, DEFAULT_LINE_OF_DEPARTURE_OPTIONS as W, haversineDistance as Wn, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Wt, DEFAULT_HOLDING_LINE_OPTIONS as X, isFiniteNumber as Xn, DEFAULT_MOBILE_DEFENSE_OPTIONS as Xt, DEFAULT_RELEASE_LINE_OPTIONS as Y, getMetersPerPixel as Yn, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as Yt, DEFAULT_INFILTRATION_LANE_OPTIONS as Z, roundToFixed as Zn, DEFAULT_ENGAGEMENT_AREA_OPTIONS as Zt, DEFAULT_PICKUP_ZONE_OPTIONS as _, polyline1DrawRule as _n, DEFAULT_SUPPORTING_ATTACK_OPTIONS as _t, DEFINITIONS as a, resolveAmplifierPlacement as an, DEFAULT_SYMBOL_COLOR as ar, DEFAULT_DISRUPT_OPTIONS as at, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as b, line24DrawRule as bn, DEFAULT_ISOLATE_OPTIONS as bt, getDefaultOptions as c, DEFAULT_DESTROY_OPTIONS as cn, createFollowAndAssume as ct, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as d, DEFAULT_DEFEAT_OPTIONS as dn, DEFAULT_DEMONSTRATE_OPTIONS as dt, DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS as en, DEFAULT_LINE_CAP as er, DEFAULT_FLOT_OPTIONS as et, DEFAULT_RETAIN_OPTIONS as f, rectangleDrawRule as fn, DEFAULT_DELAY_OPTIONS as ft, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as g, supportByFireDrawRule as gn, DEFAULT_COUNTERATTACK_OPTIONS as gt, SECONDARY_DIRECTION_OF_FIRE_DASH as h, computeInitialWidthPoint as hn, DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS as ht, CONTROL_MEASURE_METADATA as i, normalizeTextAmplifiers as in, DEFAULT_STROKE_WIDTH_CSS_PIXELS as ir, DEFAULT_ENCIRCLEMENT_OPTIONS as it, DEFAULT_SCREEN_OPTIONS as j, penetrateDrawRule as jn, DEFAULT_CLASSIC_ARROW_OPTIONS as jt, DEFAULT_SEIZE_OPTIONS as k, point12DrawRule as kn, DEFAULT_GENERIC_LINE_OPTIONS as kt, listControlMeasureMetadata as l, DEFAULT_NEUTRALIZE_OPTIONS as ln, DEFAULT_DISRUPT_MISSION_TASK_OPTIONS as lt, DEFAULT_SECONDARY_DIRECTION_OF_FIRE_OPTIONS as m, calculateMetrics as mn, DEFAULT_TACTICAL_ARROW_OPTIONS as mt, resolveStyleHints as n, TEXT_AMPLIFIER_FIELDS as nn, DEFAULT_PORTRAYAL as nr, DEFAULT_FIX_OPTIONS as nt, getControlMeasureMetadata as o, DEFAULT_AMBUSH_OPTIONS as on, DEFAULT_GUARD_OPTIONS as ot, DEFAULT_STRONG_POINT_OPTIONS as p, axis1DrawRule as pn, DEFAULT_COVER_OPTIONS as pt, DEFAULT_HANDOVER_LINE_OPTIONS as q, unproject as qn, DEFAULT_ANTITANK_DITCH_OPTIONS as qt, CONTROL_MEASURE_IDS as r, canonicalTextAmplifierKey as rn, DEFAULT_STROKE_DASH_CSS_PIXELS as rr, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as rt, getControlMeasureMetadataByValue as s, DEFAULT_AIRBORNE_ATTACK_OPTIONS as sn, createFollowAndSupport as st, renderControlMeasure as t, DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS as tn, DEFAULT_LINE_JOIN as tr, DEFAULT_FIX_MISSION_TASK_OPTIONS as tt, DEFAULT_TURNING_MOVEMENT_OPTIONS as u, DEFAULT_SUPPRESS_OPTIONS as un, DEFAULT_DISENGAGE_OPTIONS as ut, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as v, line27DrawRule as vn, DEFAULT_CORDON_AND_SEARCH_OPTIONS as vt, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as w, ambushDrawRule as wn, RADAR_SEARCH_DOCTRINE_STROKE_COLOR as wt, DEFAULT_MINEFIELD_OPTIONS as x, line23DrawRule as xn, DEFAULT_CLEAR_OPTIONS as xt, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as y, line26DrawRule as yn, DEFAULT_CORDON_AND_KNOCK_OPTIONS as yt, DEFAULT_FORTIFIED_AREA_OPTIONS as z, createMidpointPerpendicularDrawRule as zn, DEFAULT_BOUNDARY_OPTIONS as zt };