@orbat-mapper/control-measures 0.19.0 → 0.20.0

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

@@ -1,3 +1,13 @@
+//#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,240 +285,6 @@ 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) {
-	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 };
-		}
-	};
-}
-/**
-* 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
-	});
-}
-const variableWidthAttackOptionHandles = createVariableWidthAttackOptionHandles();
-/**
-* The single home of the "rear inherits shaft" rule: an omitted `rearWidthRatio`
-* leaves the body parallel by matching the effective shaft ratio. Every
-* variable-width body resolves the option through here so the rule cannot drift.
-*/
-function resolveRearWidthRatio(options, shaftRatio) {
-	return options.rearWidthRatio ?? shaftRatio;
-}
-/**
-* Processes input coordinates and options to generate the core symbol geometry.
-* This handles validation, default values, projection, and geometry calculation.
-*/
-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 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;
-		}
-		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);
@@ -1558,18 +1334,242 @@ 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)
-		];
-	}
+//#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) {
+	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 };
+		}
+	};
+}
+/**
+* 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
+	});
+}
+const variableWidthAttackOptionHandles = createVariableWidthAttackOptionHandles();
+/**
+* The single home of the "rear inherits shaft" rule: an omitted `rearWidthRatio`
+* leaves the body parallel by matching the effective shaft ratio. Every
+* variable-width body resolves the option through here so the rule cannot drift.
+*/
+function resolveRearWidthRatio(options, shaftRatio) {
+	return options.rearWidthRatio ?? shaftRatio;
+}
+/**
+* Processes input coordinates and options to generate the core symbol geometry.
+* This handles validation, default values, projection, and geometry calculation.
+*/
+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 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;
+		}
+		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/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) {
@@ -1772,1723 +1772,2246 @@ const line25DrawRule = {
 	transform: (event) => clonePositions(event.next.slice(0, 2))
 };
 //#endregion
-//#region src/internal/echelon.ts
+//#region src/style.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 `++`.
+* 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 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"
+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
 };
-/** 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
-}))];
+/** 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
 /**
-* 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.
+* Wraps an angle (radians) into the half-open range (-π, π].
 */
-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 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;
 }
-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);
+/** Wraps a degree value into the canonical clockwise `[0, 360)` range. */
+function normalizeDegrees(degrees) {
+	return (degrees % 360 + 360) % 360;
 }
 /**
-* 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.
+* Flips a text rotation by π when it would otherwise read upside-down, keeping
+* the baseline pointing left-to-right (within ±90° of horizontal).
 */
-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 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/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"
+//#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
+	};
+}
+/**
+* Clamps and rounds a smooth-resolution option (samples per segment) onto
+* `[MIN_SMOOTH_RESOLUTION, MAX_SMOOTH_RESOLUTION]`, falling back to `fallback`
+* for non-finite input. The default varies per measure, so it's passed in.
+*/
+function normalizeSmoothResolution$2(value, fallback) {
+	if (!Number.isFinite(value)) return fallback;
+	return Math.min(64, Math.max(2, Math.round(value)));
+}
+/**
+* Shared param descriptors for {@link SmoothLineOptions}, modeled on
+* `SMOOTH_PATH_PARAMS` (cm99-generic-graphics/params.ts). Measures that add
+* their own params should spread these at the top of the array.
+*/
+const SMOOTH_LINE_PARAMS = [{
+	key: "smooth",
+	label: "Smooth",
+	description: "Round the line's corners by curving the path through the control points.",
+	type: "boolean"
 }, {
-	key: "toothSize",
-	label: "Tooth size",
-	description: "Size of the fortified-area teeth, in meters",
+	key: "smoothResolution",
+	presentationTier: "advanced",
+	label: "Smooth resolution",
+	description: "Number of samples per segment when smooth mode is enabled.",
 	type: "number",
-	min: 1,
-	max: 500,
+	min: 2,
+	max: 64,
 	step: 1,
-	unit: "m"
+	visibleWhen: (opts) => Boolean(opts.smooth)
 }];
-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
+/**
+* Applies {@link SmoothLineOptions} to projected vertices `verts`: runs
+* {@link catmullRom} at the resolved (clamped) sample resolution when `smooth`
+* is set, else returns `verts` unchanged.
+*/
+function smoothLineVerts(verts, options, defaultResolution) {
+	return options.smooth ? catmullRom(verts, normalizeSmoothResolution$2(options.smoothResolution ?? defaultResolution, defaultResolution)) : verts;
+}
+/**
+* Resamples a path into equal arc-length segments.
+*
+* This is useful for a repeated motif (such as a fortified tooth or FLOT
+* scallop) after smoothing. Catmull-Rom samples are evenly spaced in spline
+* parameter, not distance, so using them directly as motif boundaries causes
+* the motifs to bunch up where the curve's samples are closer together.
+*/
+function evenlySpacePath(points, targetSegmentLength) {
+	if (points.length < 2) return points;
+	const segmentLengths = [];
+	let totalLength = 0;
+	for (let i = 0; i < points.length - 1; i++) {
+		const length = vecMag(vecSub(points[i + 1], points[i]));
+		segmentLengths.push(length);
+		totalLength += length;
 	}
-];
-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
+	if (totalLength < 1e-6) return [points[0]];
+	const segmentCount = Math.max(1, Math.round(totalLength / targetSegmentLength));
+	const segmentLength = totalLength / segmentCount;
+	const out = [points[0]];
+	let sourceIndex = 0;
+	let sourceStart = points[0];
+	let consumed = 0;
+	for (let segment = 1; segment < segmentCount; segment++) {
+		const target = segment * segmentLength;
+		while (sourceIndex < segmentLengths.length - 1 && consumed + segmentLengths[sourceIndex] < target) {
+			consumed += segmentLengths[sourceIndex];
+			sourceIndex++;
+			sourceStart = points[sourceIndex];
+		}
+		const length = segmentLengths[sourceIndex];
+		if (length < 1e-6) continue;
+		const t = (target - consumed) / length;
+		const sourceEnd = points[sourceIndex + 1];
+		out.push([sourceStart[0] + (sourceEnd[0] - sourceStart[0]) * t, sourceStart[1] + (sourceEnd[1] - sourceStart[1]) * t]);
 	}
-];
-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
-};
+	out.push(points[points.length - 1]);
+	return out;
+}
+/** One centripetal Catmull-Rom sample at parameter `t` over control points `p0..p3`. */
+function catmullRomAt(p0, p1, p2, p3, t) {
+	const t2 = t * t;
+	const t3 = t2 * t;
+	return [.5 * (2 * p1[0] + (-p0[0] + p2[0]) * t + (2 * p0[0] - 5 * p1[0] + 4 * p2[0] - p3[0]) * t2 + (-p0[0] + 3 * p1[0] - 3 * p2[0] + p3[0]) * t3), .5 * (2 * p1[1] + (-p0[1] + p2[1]) * t + (2 * p0[1] - 5 * p1[1] + 4 * p2[1] - p3[1]) * t2 + (-p0[1] + 3 * p1[1] - 3 * p2[1] + p3[1]) * t3)];
+}
 /**
-* 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>.
+* Centripetal Catmull-Rom spline through `points`, sampled `samples` times per
+* segment. Endpoints are duplicated so the curve passes through them, so the
+* first and last points are preserved exactly. With `samples <= 1` (or fewer
+* than 3 points) it returns the input unchanged.
 */
-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]))
-			}
-		}]
-	};
+function catmullRom(points, samples) {
+	if (points.length < 3 || samples <= 1) return points;
+	const pts = [
+		points[0],
+		...points,
+		points[points.length - 1]
+	];
+	const out = [points[0]];
+	for (let i = 1; i < pts.length - 2; i++) {
+		const p0 = pts[i - 1];
+		const p1 = pts[i];
+		const p2 = pts[i + 1];
+		const p3 = pts[i + 2];
+		for (let s = 1; s <= samples; s++) out.push(catmullRomAt(p0, p1, p2, p3, s / samples));
+	}
+	return out;
 }
-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.
+* Closed centripetal Catmull-Rom: smooths a polygon ring through every vertex,
+* wrapping the control points around the seam. Returns a ring whose first and
+* last positions coincide (explicit closure). With `samples <= 1` (or fewer
+* than 3 points) it returns the input unchanged.
 */
-function reportValidationIssue(mode, message) {
-	const resolved = mode ?? "silent";
-	if (resolved === "throw") throw new Error(message);
-	if (resolved === "warn") console.warn(message);
-	return false;
+function closedCatmullRom(points, samples) {
+	const n = points.length;
+	if (n < 3 || samples <= 1) return points;
+	const out = [];
+	for (let i = 0; i < n; i++) {
+		const p0 = points[(i - 1 + n) % n];
+		const p1 = points[i];
+		const p2 = points[(i + 1) % n];
+		const p3 = points[(i + 2) % n];
+		for (let s = 0; s < samples; s++) out.push(catmullRomAt(p0, p1, p2, p3, s / samples));
+	}
+	out.push([...out[0]]);
+	return out;
 }
+//#endregion
+//#region src/internal/line-labels.ts
 /**
-* 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).
+* Stored label rotation for text running along projected direction `dir`.
+* Adapters render feature rotation with their `Math.PI - rotation` convention
+* (and Y-up projected space maps to Y-down screen as `-φ`), so we derive the
+* on-screen angle, keep its baseline left-to-right, then convert back. Sign-
+* independent: `labelRotationAlong(dir)` and `labelRotationAlong(vecScale(dir,
+* -1))` produce the same rotation, since the flip only depends on `dir`'s
+* quadrant, not the labeling caller's notion of "forward".
 */
-function asThreePoints(points) {
-	return [
-		points[0],
-		points[1],
-		points[2]
-	];
+function labelRotationAlong(dir) {
+	const rendered = -Math.atan2(dir[1], dir[0]);
+	return normalizeRadians(Math.PI - keepTextLeftToRight(rendered));
 }
-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]];
-};
-/**
-* 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 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))]);
-	}
+/** Resolves two echelon-unit rows from a caller-selected set of amplifiers. */
+function unitLabelsFromAmplifiers(amplifiers, fields) {
+	return [{
+		side: 1,
+		designator: amplifiers[fields.unit1.designator] ?? "",
+		country: amplifiers[fields.unit1.country] ?? ""
+	}, {
+		side: -1,
+		designator: amplifiers[fields.unit2.designator] ?? "",
+		country: amplifiers[fields.unit2.country] ?? ""
+	}];
+}
+/** Text size shared by an echelon glyph and its associated unit labels. */
+function echelonUnitLabelSize(echelonHeight, echelonSizePixels, metersPerPixel) {
+	const screenAnchored = echelonSizePixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0;
 	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {},
-			geometry: {
-				type: "MultiLineString",
-				coordinates: lines.map((line) => line.map((c) => unproject(c[0], c[1])))
-			}
-		}]
+		properties: screenAnchored ? { textSizePixels: echelonSizePixels } : { textSizeMeters: echelonHeight },
+		screenAnchored
 	};
 }
-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.
+* Emits a single combined `T (AS)` label per unit side (APP-6/MIL-STD-2525):
+* designator and country code share one text row rather than stacking.
 */
-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
-		});
+function pushUnitLabels(out, frame, units) {
+	const { center, perp, offset, rotation, labelSize } = frame;
+	for (const { side, designator, country, textAnchor, amplifierField } of units) {
+		let text;
+		if (designator.length > 0 && country.length > 0) text = `${designator} (${country})`;
+		else if (designator.length > 0) text = designator;
+		else if (country.length > 0) text = `(${country})`;
+		else continue;
+		pushLabel(out, vecAdd(center, vecScale(perp, side * offset)), text, rotation, labelSize, textAnchor, amplifierField);
 	}
 }
-/** 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).
+* Default clearance between an echelon glyph and its unit labels, as a ratio of
+* the glyph height — the value Boundary declares as its `labelPadding` default,
+* shared so other echelon-carrying lines land on the same spacing.
 */
-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));
+const ECHELON_UNIT_LABEL_PADDING = .4;
+/**
+* Emits Boundary-style unit labels around echelon groups. Along-line groups
+* straddle the line; standard-orientation groups on north/south segments form
+* one row crossing it, anchored outward from the glyph.
+*/
+function pushEchelonUnitLabels(out, groups, units, echelonHeight, labelPadding, labelSize) {
+	for (const { center, along, perp, rotateGroup, readingAxis, glyphWidth } of groups) {
+		if (rotateGroup) {
+			const sign = vecDot(perp, readingAxis) >= 0 ? 1 : -1;
+			const clearance = glyphWidth / 2 + Math.max(0, labelPadding) * echelonHeight;
+			pushUnitLabels(out, {
+				center,
+				perp: vecScale(readingAxis, sign),
+				offset: clearance,
+				rotation: labelRotationAlong(readingAxis),
+				labelSize
+			}, units.map((unit) => ({
+				...unit,
+				textAnchor: unit.side === sign ? "start" : "end"
+			})));
+			continue;
 		}
-		appendUnique(buffer, unproject(b[0], b[1]));
-		dist = segEnd;
+		pushUnitLabels(out, {
+			center,
+			perp,
+			offset: (.45 + Math.max(0, labelPadding)) * echelonHeight,
+			rotation: labelRotationAlong(along),
+			labelSize
+		}, units);
 	}
-	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 (-π, π].
+* Walks `verts` (projected meters) into non-degenerate {@link LineSegment}s,
+* skipping coincident vertices (ADR-0014, silent) the same way Boundary's
+* gap-carving does. Empty or fully-degenerate input yields `totalLength: 0`
+* and no segments.
 */
-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;
+function polylineSegments(verts) {
+	const segments = [];
+	let totalLength = 0;
+	for (let i = 0; i < verts.length - 1; i++) {
+		const a = verts[i];
+		const seg = vecSub(verts[i + 1], a);
+		const length = vecMag(seg);
+		if (length < 1e-6) continue;
+		const along = vecNorm(seg);
+		segments.push({
+			start: a,
+			along,
+			perp: [-along[1], along[0]],
+			length
+		});
+		totalLength += length;
+	}
+	return {
+		segments,
+		totalLength
+	};
 }
-/** Wraps a degree value into the canonical clockwise `[0, 360)` range. */
-function normalizeDegrees(degrees) {
-	return (degrees % 360 + 360) % 360;
+/** Resolves an along-line position onto the valid start-to-end range. */
+function clampLinePosition(value, fallback) {
+	return Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : fallback;
 }
 /**
-* Flips a text rotation by π when it would otherwise read upside-down, keeping
-* the baseline pointing left-to-right (within ±90° of horizontal).
+* Resolves a label/group repetition count to a positive whole number. Takes
+* `unknown` because the params panel's `visibleWhen` callbacks receive loosely
+* typed options; non-finite input falls back to a single group.
 */
-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;
+function resolveLabelRepetitions(value) {
+	const numeric = Number(value ?? 1);
+	return Number.isFinite(numeric) ? Math.max(1, Math.round(numeric)) : 1;
 }
-//#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.
+* Resolves the point at `fraction` (clamped to `[0, 1]`) of `totalLength`
+* along `segments`, walking cumulative arc length exactly like Boundary's
+* label-group placement: the segment containing the target distance absorbs
+* any floating-point overshoot, and the last segment absorbs a fraction of 1.
+* Returns `undefined` for an empty or degenerate (`totalLength < EPSILON`)
+* polyline.
 */
-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]];
+function pointAlongPolyline(segments, totalLength, fraction) {
+	if (segments.length === 0 || totalLength < 1e-6) return void 0;
+	const target = Math.min(1, Math.max(0, fraction)) * totalLength;
+	let acc = 0;
+	let seg = segments[segments.length - 1];
+	for (const candidate of segments) {
+		if (target <= acc + candidate.length) {
+			seg = candidate;
+			break;
+		}
+		acc += candidate.length;
+	}
+	const d = Math.max(0, Math.min(seg.length, target - acc));
 	return {
-		pts,
-		pathLength,
-		tip,
-		dir,
-		perp,
-		segLength
+		point: vecAdd(seg.start, vecScale(seg.along, d)),
+		along: seg.along,
+		perp: seg.perp
 	};
 }
 /**
-* Clamps and rounds a smooth-resolution option (samples per segment) onto
-* `[MIN_SMOOTH_RESOLUTION, MAX_SMOOTH_RESOLUTION]`, falling back to `fallback`
-* for non-finite input. The default varies per measure, so it's passed in.
-*/
-function normalizeSmoothResolution$2(value, fallback) {
-	if (!Number.isFinite(value)) return fallback;
-	return Math.min(64, Math.max(2, Math.round(value)));
-}
-/**
-* Shared param descriptors for {@link SmoothLineOptions}, modeled on
-* `SMOOTH_PATH_PARAMS` (cm99-generic-graphics/params.ts). Measures that add
-* their own params should spread these at the top of the array.
-*/
-const SMOOTH_LINE_PARAMS = [{
-	key: "smooth",
-	label: "Smooth",
-	description: "Round the line's corners by curving the path 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)
-}];
-/**
-* Applies {@link SmoothLineOptions} to projected vertices `verts`: runs
-* {@link catmullRom} at the resolved (clamped) sample resolution when `smooth`
-* is set, else returns `verts` unchanged.
+* Frames at the two extreme ends of a polyline (first and last non-degenerate
+* segment), with `along` pointing OUTWARD — past the start, or past the end —
+* so callers can place something just beyond the line's tips. Either or both
+* keys are absent when the polyline has no non-degenerate segment.
 */
-function smoothLineVerts(verts, options, defaultResolution) {
-	return options.smooth ? catmullRom(verts, normalizeSmoothResolution$2(options.smoothResolution ?? defaultResolution, defaultResolution)) : verts;
+function endFrames(verts) {
+	const { segments } = polylineSegments(verts);
+	if (segments.length === 0) return {};
+	const first = segments[0];
+	const last = segments[segments.length - 1];
+	const startAlong = vecScale(first.along, -1);
+	const endPoint = vecAdd(last.start, vecScale(last.along, last.length));
+	return {
+		start: {
+			point: first.start,
+			along: startAlong,
+			perp: [-startAlong[1], startAlong[0]]
+		},
+		end: {
+			point: endPoint,
+			along: last.along,
+			perp: last.perp
+		}
+	};
 }
 /**
-* Resamples a path into equal arc-length segments.
-*
-* This is useful for a repeated motif (such as a fortified tooth or FLOT
-* scallop) after smoothing. Catmull-Rom samples are evenly spaced in spline
-* parameter, not distance, so using them directly as motif boundaries causes
-* the motifs to bunch up where the curve's samples are closer together.
+* Resolves both tips' {@link EndTangent}s from the polyline's first and last
+* non-degenerate segments. Unlike {@link endFrames}, neither tangent is
+* negated for "outward" — both `perp`s derive from each segment's own forward
+* direction, so "above the line" (`+perp`) reads the same at both ends
+* instead of flipping at the start.
 */
-function evenlySpacePath(points, targetSegmentLength) {
-	if (points.length < 2) return points;
-	const segmentLengths = [];
-	let totalLength = 0;
-	for (let i = 0; i < points.length - 1; i++) {
-		const length = vecMag(vecSub(points[i + 1], points[i]));
-		segmentLengths.push(length);
-		totalLength += length;
-	}
-	if (totalLength < 1e-6) return [points[0]];
-	const segmentCount = Math.max(1, Math.round(totalLength / targetSegmentLength));
-	const segmentLength = totalLength / segmentCount;
-	const out = [points[0]];
-	let sourceIndex = 0;
-	let sourceStart = points[0];
-	let consumed = 0;
-	for (let segment = 1; segment < segmentCount; segment++) {
-		const target = segment * segmentLength;
-		while (sourceIndex < segmentLengths.length - 1 && consumed + segmentLengths[sourceIndex] < target) {
-			consumed += segmentLengths[sourceIndex];
-			sourceIndex++;
-			sourceStart = points[sourceIndex];
+function endTangents(verts) {
+	const { segments } = polylineSegments(verts);
+	if (segments.length === 0) return {};
+	const first = segments[0];
+	const last = segments[segments.length - 1];
+	const endPoint = vecAdd(last.start, vecScale(last.along, last.length));
+	return {
+		start: {
+			point: first.start,
+			interior: first.along,
+			perp: first.perp,
+			outwardX: -first.along[0]
+		},
+		end: {
+			point: endPoint,
+			interior: vecScale(last.along, -1),
+			perp: last.perp,
+			outwardX: last.along[0]
 		}
-		const length = segmentLengths[sourceIndex];
+	};
+}
+/** Nearest contact point on a polyline for a dragged label anchor. */
+function nearestPointOnPolyline(verts, target) {
+	let nearest;
+	let totalArc = 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 length = vecMag(seg);
 		if (length < 1e-6) continue;
-		const t = (target - consumed) / length;
-		const sourceEnd = points[sourceIndex + 1];
-		out.push([sourceStart[0] + (sourceEnd[0] - sourceStart[0]) * t, sourceStart[1] + (sourceEnd[1] - sourceStart[1]) * t]);
+		const along = vecScale(seg, 1 / length);
+		const t = Math.max(0, Math.min(length, vecDot(vecSub(target, a), along)));
+		const distance = vecMag(vecSub(target, vecAdd(a, vecScale(along, t))));
+		if (!nearest || distance < nearest.distance) nearest = {
+			along,
+			arc: totalArc + t,
+			distance,
+			edge: [a, b]
+		};
+		totalArc += length;
 	}
-	out.push(points[points.length - 1]);
-	return out;
+	return nearest ? {
+		...nearest,
+		totalArc
+	} : void 0;
 }
-/** One centripetal Catmull-Rom sample at parameter `t` over control points `p0..p3`. */
-function catmullRomAt(p0, p1, p2, p3, t) {
-	const t2 = t * t;
-	const t3 = t2 * t;
-	return [.5 * (2 * p1[0] + (-p0[0] + p2[0]) * t + (2 * p0[0] - 5 * p1[0] + 4 * p2[0] - p3[0]) * t2 + (-p0[0] + 3 * p1[0] - 3 * p2[0] + p3[0]) * t3), .5 * (2 * p1[1] + (-p0[1] + p2[1]) * t + (2 * p0[1] - 5 * p1[1] + 4 * p2[1] - p3[1]) * t2 + (-p0[1] + 3 * p1[1] - 3 * p2[1] + p3[1]) * t3)];
+/**
+* Half-extent of a possibly rotated `textWidth × textHeight` label box along
+* `direction` (the box's support function): a boundary running parallel to the
+* text needs roughly the label's width, one running perpendicular roughly its
+* height. `rotation` is the label's stored rotation — adapters render the
+* on-screen angle as `π − rotation`, and the absolute-value projections make
+* the result invariant under that sign convention.
+*/
+function labelHalfExtent(direction, textWidth, textHeight, rotation) {
+	const [widthAxis, heightAxis] = labelBoxAxes(rotation);
+	return boxSupport(direction, textWidth, textHeight, widthAxis, heightAxis);
+}
+/** The label box's local axes for a stored `rotation`: the along-text width
+*  axis and its perpendicular height axis. */
+function labelBoxAxes(rotation) {
+	const widthAxis = [Math.cos(rotation), Math.sin(rotation)];
+	return [widthAxis, [-widthAxis[1], widthAxis[0]]];
+}
+/** {@link labelHalfExtent} over already-resolved box axes. */
+function boxSupport(direction, textWidth, textHeight, widthAxis, heightAxis) {
+	return .5 * (textWidth * Math.abs(vecDot(direction, widthAxis)) + textHeight * Math.abs(vecDot(direction, heightAxis)));
 }
 /**
-* Centripetal Catmull-Rom spline through `points`, sampled `samples` times per
-* segment. Endpoints are duplicated so the curve passes through them, so the
-* first and last points are preserved exactly. With `samples <= 1` (or fewer
-* than 3 points) it returns the input unchanged.
+* Whether a `textWidth × textHeight` label box centered at `anchor` with
+* stored `rotation` overlaps the finite segment `[a, b]` — an exact
+* separating-axis test over the box's two axes plus the segment's normal.
+* The normal support alone (see {@link labelHalfExtent}) only tests against
+* the segment's infinite line: past an endpoint the anchor→contact offset is
+* tangential and that scalar comparison wrongly reads as clear, so masking
+* decisions must use this finite-segment test instead.
 */
-function catmullRom(points, samples) {
-	if (points.length < 3 || samples <= 1) return points;
-	const pts = [
-		points[0],
-		...points,
-		points[points.length - 1]
-	];
-	const out = [points[0]];
-	for (let i = 1; i < pts.length - 2; i++) {
-		const p0 = pts[i - 1];
-		const p1 = pts[i];
-		const p2 = pts[i + 1];
-		const p3 = pts[i + 2];
-		for (let s = 1; s <= samples; s++) out.push(catmullRomAt(p0, p1, p2, p3, s / samples));
+function labelBoxIntersectsSegment(anchor, a, b, textWidth, textHeight, rotation) {
+	const seg = vecSub(b, a);
+	const length = vecMag(seg);
+	const [widthAxis, heightAxis] = labelBoxAxes(rotation);
+	const ra = vecSub(a, anchor);
+	if (length < 1e-6) return Math.abs(vecDot(ra, widthAxis)) <= textWidth / 2 && Math.abs(vecDot(ra, heightAxis)) <= textHeight / 2;
+	const along = vecScale(seg, 1 / length);
+	const normal = [-along[1], along[0]];
+	if (Math.abs(vecDot(ra, normal)) > boxSupport(normal, textWidth, textHeight, widthAxis, heightAxis)) return false;
+	const rb = vecSub(b, anchor);
+	for (const [axis, half] of [[widthAxis, textWidth / 2], [heightAxis, textHeight / 2]]) {
+		const pa = vecDot(ra, axis);
+		const pb = vecDot(rb, axis);
+		if (Math.min(pa, pb) > half || Math.max(pa, pb) < -half) return false;
 	}
-	return out;
+	return true;
 }
 /**
-* Closed centripetal Catmull-Rom: smooths a polygon ring through every vertex,
-* wrapping the control points around the seam. Returns a ring whose first and
-* last positions coincide (explicit closure). With `samples <= 1` (or fewer
-* than 3 points) it returns the input unchanged.
+* Splits the polyline `points` into the pieces that fall outside a
+* `2*halfWidth × 2*halfHeight` label box centered at `anchor` with stored
+* `rotation` — the clipping counterpart to {@link labelBoxIntersectsSegment},
+* for ornament geometry (barbs, ticks) that must break around a glyph rather
+* than merely decide whether it collides.
+*
+* Each segment is clipped in the box's own frame with a two-slab parametric
+* test; pieces that rejoin across a shared vertex are merged so a polyline
+* crossing the box mid-span stays one line string per surviving run instead of
+* fragmenting at every interior vertex.
 */
-function closedCatmullRom(points, samples) {
-	const n = points.length;
-	if (n < 3 || samples <= 1) return points;
+function clipPolylineOutsideLabelBox(points, anchor, halfWidth, halfHeight, rotation) {
+	const [widthAxis, heightAxis] = labelBoxAxes(rotation);
 	const out = [];
-	for (let i = 0; i < n; i++) {
-		const p0 = points[(i - 1 + n) % n];
-		const p1 = points[i];
-		const p2 = points[(i + 1) % n];
-		const p3 = points[(i + 2) % n];
-		for (let s = 0; s < samples; s++) out.push(catmullRomAt(p0, p1, p2, p3, s / samples));
+	const append = (piece) => {
+		if (piece.length < 2 || vecMag(vecSub(piece[1], piece[0])) < 1e-6) return;
+		const previous = out.at(-1);
+		if (previous && vecMag(vecSub(previous.at(-1), piece[0])) < 1e-6) previous.push(...piece.slice(1));
+		else out.push(piece);
+	};
+	for (let i = 1; i < points.length; i++) {
+		const a = points[i - 1];
+		const b = points[i];
+		const delta = vecSub(b, a);
+		const relative = vecSub(a, anchor);
+		const origin = [vecDot(relative, widthAxis), vecDot(relative, heightAxis)];
+		const direction = [vecDot(delta, widthAxis), vecDot(delta, heightAxis)];
+		let enter = 0;
+		let exit = 1;
+		let intersects = true;
+		for (const [coordinate, rate, halfExtent] of [[
+			origin[0],
+			direction[0],
+			halfWidth
+		], [
+			origin[1],
+			direction[1],
+			halfHeight
+		]]) {
+			if (Math.abs(rate) < 1e-6) {
+				if (Math.abs(coordinate) > halfExtent) intersects = false;
+				continue;
+			}
+			const first = (-halfExtent - coordinate) / rate;
+			const second = (halfExtent - coordinate) / rate;
+			enter = Math.max(enter, Math.min(first, second));
+			exit = Math.min(exit, Math.max(first, second));
+			if (enter > exit) intersects = false;
+		}
+		if (!intersects || exit < 0 || enter > 1) {
+			append([a, b]);
+			continue;
+		}
+		const clippedEnter = Math.max(0, enter);
+		const clippedExit = Math.min(1, exit);
+		const pointAt = (t) => t <= 0 ? a : t >= 1 ? b : vecAdd(a, vecScale(delta, t));
+		if (clippedEnter > 0) append([a, pointAt(clippedEnter)]);
+		if (clippedExit < 1) append([pointAt(clippedExit), b]);
 	}
-	out.push([...out[0]]);
 	return out;
 }
-//#endregion
-//#region src/internal/line-labels.ts
+/** Default extra clearance for an intrinsic label that interrupts a stroke. */
+const DEFAULT_LABEL_KNOCKOUT_PADDING = .3;
+/** Field N descriptor shared by Line1 graphics that opt into hostile endpoint markers. */
+const HOSTILE_LINE_AMPLIFIER = {
+	key: "N",
+	label: "Hostile (ENY) marker",
+	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
+};
 /**
-* Stored label rotation for text running along projected direction `dir`.
-* Adapters render feature rotation with their `Math.PI - rotation` convention
-* (and Y-up projected space maps to Y-down screen as `-φ`), so we derive the
-* on-screen angle, keep its baseline left-to-right, then convert back. Sign-
-* independent: `labelRotationAlong(dir)` and `labelRotationAlong(vecScale(dir,
-* -1))` produce the same rotation, since the flip only depends on `dir`'s
-* quadrant, not the labeling caller's notion of "forward".
+* 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 labelRotationAlong(dir) {
-	const rendered = -Math.atan2(dir[1], dir[0]);
-	return normalizeRadians(Math.PI - keepTextLeftToRight(rendered));
+function labelSizeProps(options) {
+	const { labelSize, labelSizePixels } = options;
+	if (labelSizePixels !== void 0) return { textSizePixels: labelSizePixels };
+	if (labelSize !== void 0) return { textSizeMeters: labelSize };
+	return {};
 }
-/** Resolves two echelon-unit rows from a caller-selected set of amplifiers. */
-function unitLabelsFromAmplifiers(amplifiers, fields) {
-	return [{
-		side: 1,
-		designator: amplifiers[fields.unit1.designator] ?? "",
-		country: amplifiers[fields.unit1.country] ?? ""
-	}, {
-		side: -1,
-		designator: amplifiers[fields.unit2.designator] ?? "",
-		country: amplifiers[fields.unit2.country] ?? ""
-	}];
+/** 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])
+		}
+	});
 }
-/** Text size shared by an echelon glyph and its associated unit labels. */
-function echelonUnitLabelSize(echelonHeight, echelonSizePixels, metersPerPixel) {
-	const screenAnchored = echelonSizePixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0;
-	return {
-		properties: screenAnchored ? { textSizePixels: echelonSizePixels } : { textSizeMeters: echelonHeight },
-		screenAnchored
-	};
+/** 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;
 }
 /**
-* Emits a single combined `T (AS)` label per unit side (APP-6/MIL-STD-2525):
-* designator and country code share one text row rather than stacking.
+* 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 pushUnitLabels(out, frame, units) {
-	const { center, perp, offset, rotation, labelSize } = frame;
-	for (const { side, designator, country, textAnchor, amplifierField } of units) {
-		let text;
-		if (designator.length > 0 && country.length > 0) text = `${designator} (${country})`;
-		else if (designator.length > 0) text = designator;
-		else if (country.length > 0) text = `(${country})`;
-		else continue;
-		pushLabel(out, vecAdd(center, vecScale(perp, side * offset)), text, rotation, labelSize, textAnchor, amplifierField);
-	}
+function resolveLabelOffsetMeters(options, ratio, fallbackMeters = 50) {
+	const h = textHeight(options);
+	return h !== void 0 ? ratio * h : fallbackMeters;
 }
 /**
-* Default clearance between an echelon glyph and its unit labels, as a ratio of
-* the glyph height — the value Boundary declares as its `labelPadding` default,
-* shared so other echelon-carrying lines land on the same spacing.
-*/
-const ECHELON_UNIT_LABEL_PADDING = .4;
-/**
-* Emits Boundary-style unit labels around echelon groups. Along-line groups
-* straddle the line; standard-orientation groups on north/south segments form
-* one row crossing it, anchored outward from the glyph.
+* 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 pushEchelonUnitLabels(out, groups, units, echelonHeight, labelPadding, labelSize) {
-	for (const { center, along, perp, rotateGroup, readingAxis, glyphWidth } of groups) {
-		if (rotateGroup) {
-			const sign = vecDot(perp, readingAxis) >= 0 ? 1 : -1;
-			const clearance = glyphWidth / 2 + Math.max(0, labelPadding) * echelonHeight;
-			pushUnitLabels(out, {
-				center,
-				perp: vecScale(readingAxis, sign),
-				offset: clearance,
-				rotation: labelRotationAlong(readingAxis),
-				labelSize
-			}, units.map((unit) => ({
-				...unit,
-				textAnchor: unit.side === sign ? "start" : "end"
-			})));
-			continue;
-		}
-		pushUnitLabels(out, {
-			center,
-			perp,
-			offset: (.45 + Math.max(0, labelPadding)) * echelonHeight,
-			rotation: labelRotationAlong(along),
-			labelSize
-		}, units);
+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");
 	}
 }
 /**
-* Walks `verts` (projected meters) into non-degenerate {@link LineSegment}s,
-* skipping coincident vertices (ADR-0014, silent) the same way Boundary's
-* gap-carving does. Empty or fully-degenerate input yields `totalLength: 0`
-* and no segments.
+* 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.
 */
-function polylineSegments(verts) {
-	const segments = [];
-	let totalLength = 0;
-	for (let i = 0; i < verts.length - 1; i++) {
-		const a = verts[i];
-		const seg = vecSub(verts[i + 1], a);
-		const length = vecMag(seg);
-		if (length < 1e-6) continue;
-		const along = vecNorm(seg);
-		segments.push({
-			start: a,
-			along,
-			perp: [-along[1], along[0]],
-			length
-		});
-		totalLength += length;
-	}
+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 {
-		segments,
-		totalLength
+		width: measured.widthCssPixels * constructionScale,
+		height: measured.heightCssPixels * constructionScale
 	};
 }
-/** Resolves an along-line position onto the valid start-to-end range. */
-function clampLinePosition(value, fallback) {
-	return Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : fallback;
-}
 /**
-* Resolves a label/group repetition count to a positive whole number. Takes
-* `unknown` because the params panel's `visibleWhen` callbacks receive loosely
-* typed options; non-finite input falls back to a single group.
+* 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 resolveLabelRepetitions(value) {
-	const numeric = Number(value ?? 1);
-	return Number.isFinite(numeric) ? Math.max(1, Math.round(numeric)) : 1;
+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;
 }
 /**
-* Resolves the point at `fraction` (clamped to `[0, 1]`) of `totalLength`
-* along `segments`, walking cumulative arc length exactly like Boundary's
-* label-group placement: the segment containing the target distance absorbs
-* any floating-point overshoot, and the last segment absorbs a fraction of 1.
-* Returns `undefined` for an empty or degenerate (`totalLength < EPSILON`)
-* polyline.
+* {@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 pointAlongPolyline(segments, totalLength, fraction) {
-	if (segments.length === 0 || totalLength < 1e-6) return void 0;
-	const target = Math.min(1, Math.max(0, fraction)) * totalLength;
-	let acc = 0;
-	let seg = segments[segments.length - 1];
-	for (const candidate of segments) {
-		if (target <= acc + candidate.length) {
-			seg = candidate;
-			break;
-		}
-		acc += candidate.length;
-	}
-	const d = Math.max(0, Math.min(seg.length, target - acc));
-	return {
-		point: vecAdd(seg.start, vecScale(seg.along, d)),
-		along: seg.along,
-		perp: seg.perp
-	};
+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;
 }
 /**
-* Frames at the two extreme ends of a polyline (first and last non-degenerate
-* segment), with `along` pointing OUTWARD — past the start, or past the end —
-* so callers can place something just beyond the line's tips. Either or both
-* keys are absent when the polyline has no non-degenerate segment.
+* 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 endFrames(verts) {
-	const { segments } = polylineSegments(verts);
-	if (segments.length === 0) return {};
-	const first = segments[0];
-	const last = segments[segments.length - 1];
-	const startAlong = vecScale(first.along, -1);
-	const endPoint = vecAdd(last.start, vecScale(last.along, last.length));
-	return {
-		start: {
-			point: first.start,
-			along: startAlong,
-			perp: [-startAlong[1], startAlong[0]]
-		},
-		end: {
-			point: endPoint,
-			along: last.along,
-			perp: last.perp
-		}
-	};
+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 both tips' {@link EndTangent}s from the polyline's first and last
-* non-degenerate segments. Unlike {@link endFrames}, neither tangent is
-* negated for "outward" — both `perp`s derive from each segment's own forward
-* direction, so "above the line" (`+perp`) reads the same at both ends
-* instead of flipping at the start.
+* 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 endTangents(verts) {
-	const { segments } = polylineSegments(verts);
-	if (segments.length === 0) return {};
-	const first = segments[0];
-	const last = segments[segments.length - 1];
-	const endPoint = vecAdd(last.start, vecScale(last.along, last.length));
-	return {
-		start: {
-			point: first.start,
-			interior: first.along,
-			perp: first.perp,
-			outwardX: -first.along[0]
-		},
-		end: {
-			point: endPoint,
-			interior: vecScale(last.along, -1),
-			perp: last.perp,
-			outwardX: last.along[0]
-		}
-	};
-}
-/** Nearest contact point on a polyline for a dragged label anchor. */
-function nearestPointOnPolyline(verts, target) {
-	let nearest;
-	let totalArc = 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 length = vecMag(seg);
-		if (length < 1e-6) continue;
-		const along = vecScale(seg, 1 / length);
-		const t = Math.max(0, Math.min(length, vecDot(vecSub(target, a), along)));
-		const distance = vecMag(vecSub(target, vecAdd(a, vecScale(along, t))));
-		if (!nearest || distance < nearest.distance) nearest = {
-			along,
-			arc: totalArc + t,
-			distance,
-			edge: [a, b]
+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"
 		};
-		totalArc += length;
 	}
-	return nearest ? {
-		...nearest,
-		totalArc
-	} : void 0;
+	return frames;
 }
 /**
-* Half-extent of a possibly rotated `textWidth × textHeight` label box along
-* `direction` (the box's support function): a boundary running parallel to the
-* text needs roughly the label's width, one running perpendicular roughly its
-* height. `rotation` is the label's stored rotation — adapters render the
-* on-screen angle as `π − rotation`, and the absolute-value projections make
-* the result invariant under that sign convention.
+* 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 labelHalfExtent(direction, textWidth, textHeight, rotation) {
-	const [widthAxis, heightAxis] = labelBoxAxes(rotation);
-	return boxSupport(direction, textWidth, textHeight, widthAxis, heightAxis);
-}
-/** The label box's local axes for a stored `rotation`: the along-text width
-*  axis and its perpendicular height axis. */
-function labelBoxAxes(rotation) {
-	const widthAxis = [Math.cos(rotation), Math.sin(rotation)];
-	return [widthAxis, [-widthAxis[1], widthAxis[0]]];
+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);
+	}
 }
-/** {@link labelHalfExtent} over already-resolved box axes. */
-function boxSupport(direction, textWidth, textHeight, widthAxis, heightAxis) {
-	return .5 * (textWidth * Math.abs(vecDot(direction, widthAxis)) + textHeight * Math.abs(vecDot(direction, heightAxis)));
+/**
+* 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
 /**
-* Whether a `textWidth × textHeight` label box centered at `anchor` with
-* stored `rotation` overlaps the finite segment `[a, b]` — an exact
-* separating-axis test over the box's two axes plus the segment's normal.
-* The normal support alone (see {@link labelHalfExtent}) only tests against
-* the segment's infinite line: past an endpoint the anchor→contact offset is
-* tangential and that scalar comparison wrongly reads as clear, so masking
-* decisions must use this finite-segment test instead.
+* 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 labelBoxIntersectsSegment(anchor, a, b, textWidth, textHeight, rotation) {
-	const seg = vecSub(b, a);
-	const length = vecMag(seg);
-	const [widthAxis, heightAxis] = labelBoxAxes(rotation);
-	const ra = vecSub(a, anchor);
-	if (length < 1e-6) return Math.abs(vecDot(ra, widthAxis)) <= textWidth / 2 && Math.abs(vecDot(ra, heightAxis)) <= textHeight / 2;
-	const along = vecScale(seg, 1 / length);
-	const normal = [-along[1], along[0]];
-	if (Math.abs(vecDot(ra, normal)) > boxSupport(normal, textWidth, textHeight, widthAxis, heightAxis)) return false;
-	const rb = vecSub(b, anchor);
-	for (const [axis, half] of [[widthAxis, textWidth / 2], [heightAxis, textHeight / 2]]) {
-		const pa = vecDot(ra, axis);
-		const pb = vecDot(rb, axis);
-		if (Math.min(pa, pb) > half || Math.max(pa, pb) < -half) return false;
-	}
-	return true;
+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])
+	];
 }
 /**
-* Splits the polyline `points` into the pieces that fall outside a
-* `2*halfWidth × 2*halfHeight` label box centered at `anchor` with stored
-* `rotation` — the clipping counterpart to {@link labelBoxIntersectsSegment},
-* for ornament geometry (barbs, ticks) that must break around a glyph rather
-* than merely decide whether it collides.
-*
-* Each segment is clipped in the box's own frame with a two-slab parametric
-* test; pieces that rejoin across a shared vertex are merged so a polyline
-* crossing the box mid-span stays one line string per surviving run instead of
-* fragmenting at every interior vertex.
+* 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 clipPolylineOutsideLabelBox(points, anchor, halfWidth, halfHeight, rotation) {
-	const [widthAxis, heightAxis] = labelBoxAxes(rotation);
-	const out = [];
-	const append = (piece) => {
-		if (piece.length < 2 || vecMag(vecSub(piece[1], piece[0])) < 1e-6) return;
-		const previous = out.at(-1);
-		if (previous && vecMag(vecSub(previous.at(-1), piece[0])) < 1e-6) previous.push(...piece.slice(1));
-		else out.push(piece);
+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])
+		}
 	};
-	for (let i = 1; i < points.length; i++) {
-		const a = points[i - 1];
-		const b = points[i];
-		const delta = vecSub(b, a);
-		const relative = vecSub(a, anchor);
-		const origin = [vecDot(relative, widthAxis), vecDot(relative, heightAxis)];
-		const direction = [vecDot(delta, widthAxis), vecDot(delta, heightAxis)];
-		let enter = 0;
-		let exit = 1;
-		let intersects = true;
-		for (const [coordinate, rate, halfExtent] of [[
-			origin[0],
-			direction[0],
-			halfWidth
-		], [
-			origin[1],
-			direction[1],
-			halfHeight
-		]]) {
-			if (Math.abs(rate) < 1e-6) {
-				if (Math.abs(coordinate) > halfExtent) intersects = false;
-				continue;
+}
+/**
+* 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
+				]
 			}
-			const first = (-halfExtent - coordinate) / rate;
-			const second = (halfExtent - coordinate) / rate;
-			enter = Math.max(enter, Math.min(first, second));
-			exit = Math.min(exit, Math.max(first, second));
-			if (enter > exit) intersects = false;
+		}, createLabelFeature(rearMidpoint, config.labelText, labelRotation, config.labelOptions)]
+	};
+}
+//#endregion
+//#region src/generators/cm34-mission-tasks/cross-task-shared.ts
+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
 		}
-		if (!intersects || exit < 0 || enter > 1) {
-			append([a, b]);
-			continue;
+	};
+	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
+			]]);
 		}
-		const clippedEnter = Math.max(0, enter);
-		const clippedExit = Math.min(1, exit);
-		const pointAt = (t) => t <= 0 ? a : t >= 1 ? b : vecAdd(a, vecScale(delta, t));
-		if (clippedEnter > 0) append([a, pointAt(clippedEnter)]);
-		if (clippedExit < 1) append([pointAt(clippedExit), b]);
+		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
+			]
+		};
 	}
-	return out;
+	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
+		]
+	};
 }
-/** Default extra clearance for an intrinsic label that interrupts a stroke. */
-const DEFAULT_LABEL_KNOCKOUT_PADDING = .3;
-/** Field N descriptor shared by Line1 graphics that opt into hostile endpoint markers. */
-const HOSTILE_LINE_AMPLIFIER = {
+//#endregion
+//#region src/generators/cm34-mission-tasks/defeat.ts
+const DEFAULT_DEFEAT_OPTIONS = {
+	...DEFAULT_CROSS_TASK_OPTIONS,
+	crossAngle: 80
+};
+const DEFEAT_METADATA = {
+	id: "defeat",
+	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",
+	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",
+	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",
+	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 `++`.
+*/
+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 beyond both ends of the line.",
+	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));
 	}
-}
-/**
-* 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"
-		};
+	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 frames;
+	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
 /**
-* 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.
+* 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 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);
+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);
+}
 /**
-* 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
@@ -6317,7 +6840,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 +6883,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));
@@ -8357,130 +8880,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 +9120,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);
 }
@@ -10007,7 +10406,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 +10567,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 +11575,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 +11658,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 +11895,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 +12006,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 +12075,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 +12445,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 +13476,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)]
@@ -15047,7 +15446,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 +15572,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 +15888,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 +16083,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",
@@ -18698,6 +19097,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,
@@ -19135,4 +19538,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 $, project as $n, DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS as $t, DEFAULT_SECURE_OPTIONS as A, turnDrawRule as An, DEFAULT_GENERIC_CIRCLE_OPTIONS as At, DEFAULT_FORTIFIED_LINE_OPTIONS as B, occupyDrawRule as Bn, DEFAULT_BLOCK_ARROW_OPTIONS as Bt, DEFAULT_LANDING_ZONE_OPTIONS as C, computeInitialWidthPoint as Cn, RADAR_SEARCH_DOCTRINE_FILL_COLOR as Ct, DEFAULT_WITHDRAW_OPTIONS as D, line26DrawRule as Dn, DEFAULT_GENERIC_RECTANGLE_OPTIONS as Dt, DEFAULT_WITHDRAW_UNDER_PRESSURE_OPTIONS as E, line27DrawRule as En, DEFAULT_GENERIC_SECTOR_OPTIONS as Et, DEFAULT_PENETRATE_OPTIONS as F, sectorDrawRule as Fn, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as Ft, DEFAULT_LIMIT_OF_ADVANCE_OPTIONS as G, area27DrawRule as Gn, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Gt, PROBABLE_LINE_OF_DEPLOYMENT_DASH as H, blockDrawRule as Hn, DEFAULT_CONTAIN_OPTIONS as Ht, DEFAULT_OCCUPY_OPTIONS as I, staticPointDrawRule as In, DEFAULT_GENERIC_C2_LINE_OPTIONS as It, DEFAULT_FORWARD_EDGE_OF_BATTLE_AREA_OPTIONS as J, getMidpointPerpendicularSignedDistance as Jn, DEFAULT_ASSEMBLY_AREA_OPTIONS as Jt, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as K, computeDefaultMidpointPerpendicularPoint as Kn, DEFAULT_ANTITANK_WALL_OPTIONS as Kt, DEFAULT_MOVEMENT_TO_CONTACT_OPTIONS as L, point12DrawRule as Ln, DEFAULT_ENGINEER_WORK_LINE_OPTIONS as Lt, DEFAULT_RETIRE_OPTIONS as M, ambushDrawRule as Mn, DEFAULT_CANALIZE_OPTIONS as Mt, DEFAULT_RELIEF_IN_PLACE_OPTIONS as N, attackByFireDrawRule as Nn, DEFAULT_BYPASS_OPTIONS as Nt, DEFAULT_EVACUATE_OPTIONS as O, line24DrawRule as On, DEFAULT_GENERIC_POLYGON_OPTIONS as Ot, DEFAULT_REARWARD_PASSAGE_OF_LINES_OPTIONS as P, dynamicPointDrawRule as Pn, DEFAULT_BREACH_OPTIONS as Pt, DEFAULT_BRIDGEHEAD_LINE_OPTIONS as Q, haversineDistance as Qn, DEFAULT_AREA_DEFENSE_OPTIONS as Qt, DEFAULT_FRONTAL_ATTACK_OPTIONS as R, secureDrawRule as Rn, DEFAULT_LIGHT_LINE_OPTIONS as Rt, DEFAULT_MAIN_ATTACK_OPTIONS as S, calculateMetrics as Sn, DEFAULT_RADAR_SEARCH_DOCTRINE_OPTIONS as St, DEFAULT_TURN_OPTIONS as T, polyline1DrawRule as Tn, DEFAULT_GENERIC_TEXT_OPTIONS as Tt, DEFAULT_LINE_OF_DEPARTURE_CONTACT_OPTIONS as U, centerRadiusDrawRule as Un, DEFAULT_BATTLE_POSITION_OPTIONS as Ut, DEFAULT_PROBABLE_LINE_OF_DEPLOYMENT_OPTIONS as V, disruptDrawRule as Vn, DEFAULT_BLOCK_OPTIONS as Vt, DEFAULT_LINE_OF_DEPARTURE_OPTIONS as W, containDrawRule as Wn, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Wt, DEFAULT_HOLDING_LINE_OPTIONS as X, snapToMidpointPerpendicular as Xn, DEFAULT_MOBILE_DEFENSE_OPTIONS as Xt, DEFAULT_RELEASE_LINE_OPTIONS as Y, pointOnMidpointPerpendicularAxis as Yn, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as Yt, DEFAULT_INFILTRATION_LANE_OPTIONS as Z, createBaselineFrame as Zn, DEFAULT_ENGAGEMENT_AREA_OPTIONS as Zt, DEFAULT_PICKUP_ZONE_OPTIONS as _, DEFAULT_STROKE_DASH_CSS_PIXELS 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, rectangleDrawRule 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, sphericalBearing as er, DEFAULT_FLOT_OPTIONS as et, DEFAULT_RETAIN_OPTIONS as f, DEFAULT_LABEL_HEIGHT_CSS_PIXELS as fn, DEFAULT_DELAY_OPTIONS as ft, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as g, DEFAULT_PORTRAYAL as gn, DEFAULT_COUNTERATTACK_OPTIONS as gt, SECONDARY_DIRECTION_OF_FIRE_DASH as h, DEFAULT_LINE_JOIN as hn, DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS as ht, CONTROL_MEASURE_METADATA as i, normalizeTextAmplifiers as in, roundToFixed as ir, DEFAULT_ENCIRCLEMENT_OPTIONS as it, DEFAULT_SCREEN_OPTIONS as j, line1DrawRule as jn, DEFAULT_CLASSIC_ARROW_OPTIONS as jt, DEFAULT_SEIZE_OPTIONS as k, line23DrawRule 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, DEFAULT_LINE_CAP as mn, DEFAULT_TACTICAL_ARROW_OPTIONS as mt, resolveStyleHints as n, TEXT_AMPLIFIER_FIELDS as nn, EPSILON 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, DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS as pn, DEFAULT_COVER_OPTIONS as pt, DEFAULT_HANDOVER_LINE_OPTIONS as q, createMidpointPerpendicularDrawRule as qn, DEFAULT_ANTITANK_DITCH_OPTIONS as qt, CONTROL_MEASURE_IDS as r, canonicalTextAmplifierKey as rn, getMetersPerPixel 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, unproject 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, DEFAULT_STROKE_WIDTH_CSS_PIXELS as vn, DEFAULT_CORDON_AND_SEARCH_OPTIONS as vt, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as w, supportByFireDrawRule as wn, RADAR_SEARCH_DOCTRINE_STROKE_COLOR as wt, DEFAULT_MINEFIELD_OPTIONS as x, axis1DrawRule as xn, DEFAULT_CLEAR_OPTIONS as xt, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as y, DEFAULT_SYMBOL_COLOR as yn, DEFAULT_CORDON_AND_KNOCK_OPTIONS as yt, DEFAULT_FORTIFIED_AREA_OPTIONS as z, penetrateDrawRule as zn, DEFAULT_BOUNDARY_OPTIONS as zt };