@orbat-mapper/control-measures 0.2.0-alpha.0 → 0.2.0-alpha.2

package/dist/index.mjs

@@ -1,4967 +1,4 @@
-//#region src/internal/graphics-utils.ts
-/**
-* Small value used to avoid division by zero and floating-point precision issues.
-*/
-const EPSILON = 1e-6;
-/**
-* Clamps a value to the range [0, 1].
-*/
-const clamp01 = (v) => Math.min(1, Math.max(0, v));
-/**
-* Clamps a value to the range [min, max].
-*/
-const clamp = (v, min, max) => Math.min(Math.max(v, min), max);
-/**
-* Type guard for finite numbers.
-*/
-const isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
-/**
-* Validates that a position array contains at least two finite coordinates.
-*/
-const isValidPosition = (p) => Array.isArray(p) && p.length >= 2 && isFiniteNumber(p[0]) && isFiniteNumber(p[1]);
-/**
-* Rounds a number to a specified number of decimal places.
-*/
-const roundToFixed = (v, precision = 6) => {
-	const m = Math.pow(10, precision);
-	return Math.round(v * m) / m;
-};
-/**
-* Earth's circumference at the equator in meters.
-*/
-const EARTH_CIRCUMFERENCE = 40075016.686;
-/**
-* Standard tile size in pixels for Web Mercator projection.
-*/
-const TILE_SIZE = 256;
-/**
-* Calculates the meters-per-pixel ratio at a given latitude and zoom level.
-*
-* This is essential for maintaining consistent visual sizes on the map
-* regardless of zoom level. The formula accounts for:
-* - The Web Mercator projection's tile-based structure
-* - The latitude-dependent scale distortion in Mercator projection
-*
-* @param latitude - The latitude in degrees (affects scale due to projection)
-* @param zoomLevel - The current map zoom level
-* @returns The number of meters represented by one pixel at the given location and zoom
-*
-* @example
-* ```typescript
-* // At zoom 10, latitude 45°
-* const mpp = getMetersPerPixel(45, 10);
-* // To get a 20-pixel radius in meters:
-* const radiusMeters = 20 * mpp;
-* ```
-*/
-const getMetersPerPixel = (latitude, zoomLevel) => {
-	const metersPerPixelAtEquator = EARTH_CIRCUMFERENCE / (TILE_SIZE * Math.pow(2, zoomLevel));
-	const latitudeRadians = latitude * Math.PI / 180;
-	return metersPerPixelAtEquator * Math.cos(latitudeRadians);
-};
-//#endregion
-//#region src/projection.ts
-/**
-* Project WGS84 (Lon/Lat) to Web Mercator (Meters).
-*/
-const project = (lon, lat) => {
-	const x = lon * 20037508.34 / 180;
-	let y = Math.log(Math.tan((90 + lat) * Math.PI / 360)) / (Math.PI / 180);
-	y = y * 20037508.34 / 180;
-	return [x, y];
-};
-/**
-* Unproject Web Mercator (Meters) back to WGS84 (Lon/Lat).
-*/
-const unproject = (x, y) => {
-	const lon = x * 180 / 20037508.34;
-	let lat = y * 180 / 20037508.34;
-	lat = 180 / Math.PI * (2 * Math.atan(Math.exp(lat * Math.PI / 180)) - Math.PI / 2);
-	return [roundToFixed(lon), roundToFixed(lat)];
-};
-//#endregion
-//#region src/internal/vector-utils.ts
-/**
-* Offsets a polyline using Miter Joins or Round Joins.
-*/
-function offsetPolyline(points, offset, rounded = false, segments = 5) {
-	if (points.length < 2) return points;
-	const result = [];
-	const N = points.length;
-	for (let i = 0; i < N; i++) {
-		const p = points[i];
-		if (!p) continue;
-		if (i === 0) {
-			const next = points[i + 1];
-			if (next) {
-				const dir = vecNorm(vecSub(next, p));
-				const normal = [-dir[1], dir[0]];
-				result.push(vecAdd(p, vecScale(normal, offset)));
-			}
-			continue;
-		}
-		if (i === N - 1) {
-			const prev = points[i - 1];
-			if (prev) {
-				const dir = vecNorm(vecSub(p, prev));
-				const normal = [-dir[1], dir[0]];
-				result.push(vecAdd(p, vecScale(normal, offset)));
-			}
-			continue;
-		}
-		const prev = points[i - 1];
-		const next = points[i + 1];
-		if (!prev || !next) continue;
-		const v1 = vecNorm(vecSub(p, prev));
-		const v2 = vecNorm(vecSub(next, p));
-		const n1 = [-v1[1], v1[0]];
-		const n2 = [-v2[1], v2[0]];
-		const cross = v1[0] * v2[1] - v1[1] * v2[0];
-		if (rounded && (offset > 0 && cross < -1e-6 || offset < 0 && cross > 1e-6)) {
-			const angle1 = Math.atan2(n1[1], n1[0]);
-			let diff = Math.atan2(n2[1], n2[0]) - angle1;
-			if (offset > 0) {
-				while (diff > EPSILON) diff -= 2 * Math.PI;
-				while (diff < -2 * Math.PI) diff += 2 * Math.PI;
-			} else {
-				while (diff < -1e-6) diff += 2 * Math.PI;
-				while (diff > 2 * Math.PI) diff -= 2 * Math.PI;
-			}
-			const segmentCount = Math.max(1, segments);
-			for (let j = 0; j <= segmentCount; j++) {
-				const t = j / segmentCount;
-				const theta = angle1 + diff * t;
-				const nx = Math.cos(theta);
-				const ny = Math.sin(theta);
-				result.push([p[0] + nx * offset, p[1] + ny * offset]);
-			}
-		} else {
-			const tangent = vecNorm(vecAdd(v1, v2));
-			const miter = [-tangent[1], tangent[0]];
-			const dot = vecDot(miter, n1);
-			const miterLimit = 3;
-			const scaleFactor = Math.abs(dot) < 1e-6 ? 1 : 1 / dot;
-			const normal = vecScale(miter, Math.min(scaleFactor, miterLimit));
-			result.push(vecAdd(p, vecScale(normal, offset)));
-		}
-	}
-	return result;
-}
-function vecAdd(a, b) {
-	return [a[0] + b[0], a[1] + b[1]];
-}
-function vecSub(a, b) {
-	return [a[0] - b[0], a[1] - b[1]];
-}
-function vecScale(v, s) {
-	return [v[0] * s, v[1] * s];
-}
-function vecDot(a, b) {
-	return a[0] * b[0] + a[1] * b[1];
-}
-function vecMag(v) {
-	return Math.sqrt(v[0] * v[0] + v[1] * v[1]);
-}
-function vecNorm(v) {
-	const m = vecMag(v);
-	return m === 0 ? [0, 0] : [v[0] / m, v[1] / m];
-}
-function pointToPointDistance(p1, p2) {
-	const dx = p2[0] - p1[0];
-	const dy = p2[1] - p1[1];
-	return Math.sqrt(dx * dx + dy * dy);
-}
-function pointToInfiniteLineDistance(p, a, b) {
-	const ab = vecSub(b, a);
-	const ap = vecSub(p, a);
-	const abLenSq = ab[0] * ab[0] + ab[1] * ab[1];
-	if (abLenSq < 1e-6) return pointToPointDistance(p, a);
-	const t = vecDot(ap, ab) / abLenSq;
-	return pointToPointDistance(p, [a[0] + t * ab[0], a[1] + t * ab[1]]);
-}
-/**
-* Calculates intersection of two line segments p1-p2 and p3-p4.
-* Returns null if parallel. Assuming they cross as per design.
-*/
-function lineIntersection(p1, p2, p3, p4) {
-	const x1 = p1[0], y1 = p1[1];
-	const x2 = p2[0], y2 = p2[1];
-	const x3 = p3[0], y3 = p3[1];
-	const x4 = p4[0], y4 = p4[1];
-	const denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
-	if (Math.abs(denom) < 1e-6) return null;
-	const ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denom;
-	return [x1 + ua * (x2 - x1), y1 + ua * (y2 - y1)];
-}
-//#endregion
-//#region src/attack-utils.ts
-const DEFAULT_SHAFT_WIDTH_RATIO = .6;
-const SHAFT_MIN_RATIO = .1;
-const SHAFT_MAX_RATIO = .9;
-/**
-* 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 roundedBends = options.roundedBends ?? false;
-	const bendSegments = options.bendSegments ?? 5;
-	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, roundedBends, bendSegments) };
-}
-function calculateSymbolGeometry(ptTip, ptWidth, spine, shaftRatio, roundedBends, bendSegments) {
-	const ptNeck = spine[spine.length - 1];
-	if (!ptNeck) return null;
-	const tipDir = vecNorm(vecSub(ptTip, ptNeck));
-	if (vecMag(tipDir) < 1e-6) return null;
-	const headHalfWidth = pointToInfiniteLineDistance(ptWidth, ptNeck, ptTip);
-	const vecTipToWidth = vecSub(ptTip, ptWidth);
-	const maxHeadLength = Math.max(0, vecMag(vecSub(ptTip, ptNeck)) - .1);
-	const headLength = clamp(vecDot(vecTipToWidth, tipDir), EPSILON, maxHeadLength);
-	const ptBase = vecSub(ptTip, vecScale(tipDir, headLength));
-	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 innerTip = vecAdd(ptBase, vecScale(tipDir, Math.min(notchDepth, headLength - EPSILON)));
-	const shaftEndCenter = ptBase;
-	const headRing = [
-		outerLeft,
-		ptTip,
-		outerRight,
-		innerRight,
-		innerTip,
-		innerLeft,
-		outerLeft
-	];
-	const fullSpine = [...spine, shaftEndCenter];
-	return {
-		shaftLeft: offsetPolyline(fullSpine, shaftHalfWidth, roundedBends, bendSegments),
-		shaftRight: offsetPolyline(fullSpine, -shaftHalfWidth, roundedBends, bendSegments),
-		headRing,
-		ptTip,
-		ptNeck,
-		ptBase
-	};
-}
-/**
-* Calculates the relative metrics (longitudinal and lateral) of the width point
-* relative to the Tip-Neck axis.
-*
-* @param pts - Array of positions [Tip, Neck, ..., WidthPoint]
-* @returns { longitudinal: number, lateral: number } | null
-*/
-function calculateMetrics(pts) {
-	const tip = pts[0];
-	const neck = pts[1];
-	const widthPt = pts[pts.length - 1];
-	if (!tip || !neck || !widthPt) return null;
-	const tipM = project(tip[0], tip[1]);
-	const neckM = project(neck[0], neck[1]);
-	const widthM = project(widthPt[0], widthPt[1]);
-	const tx = tipM[0];
-	const ty = tipM[1];
-	const nx = neckM[0];
-	const ny = neckM[1];
-	const wx = widthM[0];
-	const wy = widthM[1];
-	const dx = tx - nx;
-	const dy = ty - ny;
-	const len = Math.sqrt(dx * dx + dy * dy);
-	if (len < 1e-6) return null;
-	const ax = dx / len;
-	const ay = dy / len;
-	const px = -ay;
-	const py = ax;
-	const vx = wx - tx;
-	const vy = wy - ty;
-	return {
-		longitudinal: vx * ax + vy * ay,
-		lateral: vx * px + vy * py
-	};
-}
-/**
-* Computes an initial Width Point based on the Tip and Neck positions.
-* It places the point perpendicular to the neck at a default distance relative to the length.
-*
-* @param tip - Tip position (Lon/Lat)
-* @param neck - Neck position (Lon/Lat)
-* @returns Width Point position (Lon/Lat)
-*/
-function computeInitialWidthPoint(tip, neck) {
-	const tipM = project(tip[0], tip[1]);
-	const neckM = project(neck[0], neck[1]);
-	const tx = tipM[0];
-	const ty = tipM[1];
-	const nx = neckM[0];
-	const ny = neckM[1];
-	const dx = tx - nx;
-	const dy = ty - ny;
-	const len = Math.sqrt(dx * dx + dy * dy);
-	if (len < 1e-6) return unproject(nx + 100, ny);
-	const ax = dx / len;
-	const ay = dy / len;
-	const widthRatio = .35;
-	const recessionRatio = .25;
-	const px = -ay;
-	const py = ax;
-	return unproject(tx - dx * recessionRatio + len * widthRatio * px, ty - dy * recessionRatio + len * widthRatio * py);
-}
-//#endregion
-//#region src/define.ts
-/**
-* Identity helper that infers a definition's literal `Id` and precise generator
-* type `G`, so the registry's `typeof DEFINITIONS` carries each measure's exact
-* options type. Internal authoring API — not part of the published surface.
-*/
-function defineControlMeasure(definition) {
-	return definition;
-}
-//#endregion
-//#region src/draw-rules/baseline-frame.ts
-function createBaselineFrame(p1, p2, options = {}) {
-	return createProjectedBaselineFrame(project(p1[0], p1[1]), project(p2[0], p2[1]), options);
-}
-function createProjectedBaselineFrame(p1, p2, options = {}) {
-	const baseline = vecSub(p2, p1);
-	const length = vecMag(baseline);
-	if (length < 1e-6) return null;
-	const direction = vecNorm(baseline);
-	const normalSign = options.normal === "left" ? -1 : 1;
-	const normal = vecScale([direction[1], -direction[0]], normalSign);
-	const origin = getOrigin(p1, p2, options.origin ?? "midpoint");
-	return {
-		p1,
-		p2,
-		origin,
-		direction,
-		normal,
-		length,
-		signedNormalDistance(point) {
-			return vecDot(vecSub(project(point[0], point[1]), origin), normal);
-		},
-		pointAtNormalDistance(distance) {
-			if (!Number.isFinite(distance)) return null;
-			const point = vecAdd(origin, vecScale(normal, distance));
-			return unproject(point[0], point[1]);
-		}
-	};
-}
-function getOrigin(p1, p2, origin) {
-	if (origin === "p1") return p1;
-	if (origin === "p2") return p2;
-	return vecScale(vecAdd(p1, p2), .5);
-}
-//#endregion
-//#region src/draw-rules/util.ts
-function clonePosition(position) {
-	return [...position];
-}
-function clonePositions(positions) {
-	return positions.map(clonePosition);
-}
-function samePosition$1(a, b) {
-	return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
-}
-//#endregion
-//#region src/draw-rules/midpoint-perpendicular.ts
-function createMidpointPerpendicularDrawRule(options) {
-	const defaultDistanceRatio = options.defaultDistanceRatio ?? 1.5;
-	const constrainedIndex = options.constrainedIndex ?? 2;
-	const baselineIndexA = constrainedIndex === 0 ? 1 : 0;
-	const baselineIndexB = constrainedIndex === 0 ? 2 : 1;
-	const frameOrigin = options.origin ?? "midpoint";
-	const frameNormal = options.normal ?? "right";
-	function frameFor(p1, p2) {
-		return createBaselineFrame(p1, p2, {
-			origin: frameOrigin,
-			normal: frameNormal
-		});
-	}
-	function packSlots(baselineA, baselineB, constrained) {
-		const out = new Array(3);
-		out[baselineIndexA] = baselineA;
-		out[baselineIndexB] = baselineB;
-		out[constrainedIndex] = constrained;
-		return out;
-	}
-	function snap(baselineA, baselineB, point) {
-		const frame = frameFor(baselineA, baselineB);
-		if (!frame) return null;
-		return frame.pointAtNormalDistance(frame.signedNormalDistance(point));
-	}
-	function derive(points) {
-		if (points.length < 2) return clonePositions(points);
-		if (points.length === 2) {
-			const baselineA = clonePosition(points[0]);
-			const baselineB = clonePosition(points[1]);
-			const frame = frameFor(baselineA, baselineB);
-			const derived = frame ? frame.pointAtNormalDistance(frame.length * defaultDistanceRatio) : null;
-			return derived ? packSlots(baselineA, baselineB, derived) : [baselineA, baselineB];
-		}
-		const baselineA = clonePosition(points[baselineIndexA]);
-		const baselineB = clonePosition(points[baselineIndexB]);
-		const rawConstrained = points[constrainedIndex];
-		return packSlots(baselineA, baselineB, snap(baselineA, baselineB, rawConstrained) ?? clonePosition(rawConstrained));
-	}
-	return {
-		id: options.id,
-		minimumUserPoints: options.minimumUserPoints ?? 2,
-		minimumPreviewPoints: options.minimumPreviewPoints,
-		canonicalPointCount: 3,
-		derive,
-		transform(event) {
-			const { previous, next, activePointIndex } = event;
-			if (previous.length < 3 || next.length < 3) return derive(next);
-			const oldBaselineA = previous[baselineIndexA];
-			const oldBaselineB = previous[baselineIndexB];
-			const oldConstrained = previous[constrainedIndex];
-			const newBaselineA = next[baselineIndexA];
-			const newBaselineB = next[baselineIndexB];
-			const newConstrained = next[constrainedIndex];
-			if (!oldBaselineA || !oldBaselineB || !oldConstrained || !newBaselineA || !newBaselineB || !newConstrained) return derive(next);
-			const baselineAMoved = !samePosition(newBaselineA, oldBaselineA);
-			const baselineBMoved = !samePosition(newBaselineB, oldBaselineB);
-			const constrainedMoved = !samePosition(newConstrained, oldConstrained);
-			const draggingBaseline = activePointIndex === baselineIndexA || activePointIndex === baselineIndexB;
-			const draggingConstrained = activePointIndex === constrainedIndex;
-			if (draggingBaseline || (baselineAMoved || baselineBMoved) && !constrainedMoved) {
-				const oldFrame = frameFor(oldBaselineA, oldBaselineB);
-				const newFrame = frameFor(newBaselineA, newBaselineB);
-				if (oldFrame && newFrame) {
-					const distance = oldFrame.signedNormalDistance(oldConstrained);
-					const adjusted = newFrame.pointAtNormalDistance(distance);
-					if (adjusted) return packSlots(clonePosition(newBaselineA), clonePosition(newBaselineB), adjusted);
-				}
-			} else if (draggingConstrained || !baselineAMoved && !baselineBMoved && constrainedMoved) {
-				const adjusted = snap(newBaselineA, newBaselineB, newConstrained);
-				if (adjusted) return packSlots(clonePosition(newBaselineA), clonePosition(newBaselineB), adjusted);
-			}
-			return derive(next);
-		}
-	};
-}
-function computeDefaultMidpointPerpendicularPoint(p1, p2, distanceRatio = 1.5) {
-	const frame = frameFor(p1, p2);
-	if (!frame) return null;
-	return frame.pointAtNormalDistance(frame.length * distanceRatio);
-}
-function getMidpointPerpendicularSignedDistance(p1, p2, controlPoint) {
-	const frame = frameFor(p1, p2);
-	if (!frame) return null;
-	return frame.signedNormalDistance(controlPoint);
-}
-function pointOnMidpointPerpendicularAxis(p1, p2, distance) {
-	if (distance === null) return null;
-	const frame = frameFor(p1, p2);
-	if (!frame) return null;
-	return frame.pointAtNormalDistance(distance);
-}
-function snapToMidpointPerpendicular(p1, p2, controlPoint) {
-	const frame = frameFor(p1, p2);
-	if (!frame) return null;
-	return frame.pointAtNormalDistance(frame.signedNormalDistance(controlPoint));
-}
-function frameFor(p1, p2) {
-	return createBaselineFrame(p1, p2, {
-		origin: "midpoint",
-		normal: "right"
-	});
-}
-function samePosition(a, b) {
-	return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
-}
-//#endregion
-//#region src/draw-rules/area11.ts
-const blockDrawRule = createMidpointPerpendicularDrawRule({ id: "area11:block" });
-//#endregion
-//#region src/draw-rules/area12.ts
-/**
-* Area12 anchor draw rule for Disrupt.
-*
-* P1/P2 are the free spine endpoints. P3 is the longest-arrow tip, constrained
-* to the perpendicular axis through P1 (not the baseline midpoint).
-*/
-const disruptDrawRule = createMidpointPerpendicularDrawRule({
-	id: "area12:disrupt",
-	origin: "p1",
-	normal: "left"
-});
-//#endregion
-//#region src/draw-rules/area15.ts
-/**
-* Area15 — center + radius. PT. 1 is the center point; PT. 2 is the start point
-* that fixes both the radius and the bearing of the symbol's opening. Both
-* points are user-clicked, so the canonical array is just the (clamped) input.
-*/
-function derive$6(points) {
-	return clonePositions(points.slice(0, 2));
-}
-const isolateDrawRule = {
-	id: "area15:isolate",
-	minimumUserPoints: 2,
-	canonicalPointCount: 2,
-	derive: derive$6,
-	transform(event) {
-		const { previous, next, activePointIndex } = event;
-		if (activePointIndex === 0 && previous.length >= 2 && next.length >= 2) {
-			const dx = next[0][0] - previous[0][0];
-			const dy = next[0][1] - previous[0][1];
-			const origin = previous[1];
-			return [clonePosition(next[0]), [origin[0] + dx, origin[1] + dy]];
-		}
-		return derive$6(next);
-	}
-};
-//#endregion
-//#region src/draw-rules/point12.ts
-/**
-* Point12 anchor draw rule for the obstacle-bypass family.
-*
-* Shared by `obstacle-bypass-easy`, `obstacle-bypass-difficult`, and
-* `obstacle-bypass-impossible`: P1/P2 are the arrowhead tips and define the
-* opening; P3 is constrained to the perpendicular axis through
-* `midpoint(P1, P2)` and defines the rear of the symbol. Rear-line decoration
-* (plain, zigzag, barrier marks) is a generator concern, not a draw-rule one.
-*/
-const point12DrawRule = createMidpointPerpendicularDrawRule({ id: "point12:obstacle-bypass" });
-//#endregion
-//#region src/draw-rules/area7.ts
-/**
-* Area7 anchor draw rule for Attack By Fire.
-*
-* P2/P3 are the free back-line endpoints; P1 (slot index 0) is the arrowhead
-* tip, constrained to the perpendicular axis through `midpoint(P2, P3)`.
-*/
-const attackByFireDrawRule = createMidpointPerpendicularDrawRule({
-	id: "area7:attack-by-fire",
-	constrainedIndex: 0,
-	defaultDistanceRatio: -1.5
-});
-//#endregion
-//#region src/draw-rules/line29.ts
-/**
-* Line29 anchor draw rule for Ambush.
-*
-* P2/P3 are the free back-line endpoints; P1 (slot index 0) is the arrowhead
-* tip, constrained to the perpendicular axis through `midpoint(P2, P3)`.
-*/
-const ambushDrawRule = createMidpointPerpendicularDrawRule({
-	id: "line29:ambush",
-	constrainedIndex: 0,
-	defaultDistanceRatio: -.5
-});
-//#endregion
-//#region src/draw-rules/line1.ts
-function derive$5(points) {
-	return clonePositions(points);
-}
-const line1DrawRule = {
-	id: "line1",
-	minimumUserPoints: 2,
-	derive: derive$5,
-	transform(event) {
-		return derive$5(event.next);
-	}
-};
-//#endregion
-//#region src/draw-rules/line3.ts
-function derive$4(points) {
-	return clonePositions(points);
-}
-/**
-* Line3 anchor draw rule (e.g. Final Protective Fire / Principal Direction of
-* Fire).
-*
-* Three fully free anchor points: P1 (slot index 0) is the vertex, P2/P3 are
-* the arrowhead tips. The arms' lengths and orientations vary independently, so
-* there is no constraint between slots — every handle moves on its own.
-*/
-const line3DrawRule = {
-	id: "line3",
-	minimumUserPoints: 3,
-	canonicalPointCount: 3,
-	derive: derive$4,
-	transform(event) {
-		return derive$4(event.next);
-	}
-};
-//#endregion
-//#region src/draw-rules/line9.ts
-function derive$3(points) {
-	return clonePositions(points);
-}
-const line9DrawRule = {
-	id: "line9",
-	minimumUserPoints: 2,
-	canonicalPointCount: 2,
-	derive: derive$3,
-	transform(event) {
-		return derive$3(event.next);
-	}
-};
-//#endregion
-//#region src/internal/quarter-arc.ts
-function quarterArcSide(start, end, hint, fallback = 1) {
-	if (!hint) return fallback;
-	const chord = vecSub(end, start);
-	const offset = vecSub(hint, vecScale(vecAdd(start, end), .5));
-	const cross = chord[0] * offset[1] - chord[1] * offset[0];
-	return Math.abs(cross) < 1e-6 ? fallback : cross > 0 ? 1 : -1;
-}
-/**
-* Builds the minor 90-degree circular arc from `start` to `end`.
-*
-* `side` selects which side of the directed chord contains the arc itself:
-* `1` is left of start -> end, and `-1` is right.
-*/
-function createQuarterArc(start, end, side) {
-	const chord = vecSub(end, start);
-	const chordLength = vecMag(chord);
-	if (chordLength < 1e-6) return null;
-	const chordDir = vecNorm(chord);
-	const leftNormal = [-chordDir[1], chordDir[0]];
-	const center = vecAdd(vecScale(vecAdd(start, end), .5), vecScale(leftNormal, -side * chordLength / 2));
-	const radius = chordLength / Math.SQRT2;
-	const startAngle = Math.atan2(start[1] - center[1], start[0] - center[0]);
-	const sweepAngle = -side * Math.PI / 2;
-	const midpointAngle = startAngle + sweepAngle / 2;
-	return {
-		center,
-		radius,
-		startAngle,
-		sweepAngle,
-		midpoint: vecAdd(center, [radius * Math.cos(midpointAngle), radius * Math.sin(midpointAngle)])
-	};
-}
-//#endregion
-//#region src/draw-rules/line10.ts
-function deriveWithSide(points, preservedSide) {
-	if (points.length < 2) return clonePositions(points);
-	const p1 = clonePosition(points[0]);
-	const p2 = clonePosition(points[1]);
-	const tip = project(p1[0], p1[1]);
-	const rear = project(p2[0], p2[1]);
-	const hint = points[2] ? project(points[2][0], points[2][1]) : void 0;
-	const arc = createQuarterArc(rear, tip, preservedSide ?? quarterArcSide(rear, tip, hint));
-	return arc ? [
-		p1,
-		p2,
-		unproject(arc.midpoint[0], arc.midpoint[1])
-	] : [p1, p2];
-}
-function sideFrom(points) {
-	const tip = project(points[0][0], points[0][1]);
-	return quarterArcSide(project(points[1][0], points[1][1]), tip, project(points[2][0], points[2][1]));
-}
-/**
-* Line10 — PT1 is the arrow tip, PT2 is the rear, and derived PT3 selects
-* which side of the PT2 -> PT1 chord contains the 90-degree arc.
-*/
-const turnDrawRule = {
-	id: "line10:turn",
-	minimumUserPoints: 2,
-	canonicalPointCount: 3,
-	derive: deriveWithSide,
-	transform(event) {
-		const { previous, next, activePointIndex } = event;
-		if (previous.length < 3 || next.length < 3) return deriveWithSide(next);
-		const endpointMoved = !samePosition$1(previous[0], next[0]) || !samePosition$1(previous[1], next[1]);
-		if (activePointIndex === 0 || activePointIndex === 1 || endpointMoved) return deriveWithSide(next, sideFrom(previous));
-		return deriveWithSide(next);
-	}
-};
-//#endregion
-//#region src/draw-rules/line23.ts
-/**
-* Line23 anchor draw rule for the Clear mission task.
-*
-* P1/P2 are the endpoints of the symbol's vertical line (its height); P3 is
-* constrained to the perpendicular axis through `midpoint(P1, P2)` and defines
-* the rear of the symbol (the shaft length). Geometrically identical to the
-* obstacle-bypass `Point12` rule, but kept as its own spec id to match the
-* doctrinal draw rule for Clear.
-*/
-const line23DrawRule = createMidpointPerpendicularDrawRule({ id: "line23:clear" });
-//#endregion
-//#region src/draw-rules/line24.ts
-/**
-* Line24 anchor draw rule for the Delay mission task.
-*
-* PT. 1 and PT. 2 are the free straight-line endpoints. PT. 3 is constrained to
-* the perpendicular axis through PT. 2, where its signed distance from PT. 2
-* defines the semicircular arc diameter and side. Unlike the sibling Line23
-* (Clear) rule, the third point must be placed explicitly (three user clicks),
-* with a two-point live preview before commit.
-*/
-const line24DrawRule = createMidpointPerpendicularDrawRule({
-	id: "line24:delay",
-	origin: "p2",
-	defaultDistanceRatio: .6,
-	minimumUserPoints: 3,
-	minimumPreviewPoints: 2
-});
-//#endregion
-//#region src/draw-rules/area8.ts
-function derive$2(points) {
-	if (points.length < 2) return clonePositions(points);
-	if (points.length !== 2) return clonePositions(points.slice(0, 4));
-	const p1 = clonePosition(points[0]);
-	const p2 = clonePosition(points[1]);
-	const frame = createBaselineFrame(p1, p2, {
-		origin: "p1",
-		normal: "left"
-	});
-	if (!frame) return [p1, p2];
-	const offset = vecScale(frame.normal, frame.length);
-	const p3Projected = vecAdd(frame.p1, offset);
-	const p4Projected = vecAdd(frame.p2, offset);
-	return [
-		p1,
-		p2,
-		unproject(p3Projected[0], p3Projected[1]),
-		unproject(p4Projected[0], p4Projected[1])
-	];
-}
-const supportByFireDrawRule = {
-	id: "area8:support-by-fire",
-	minimumUserPoints: 2,
-	canonicalPointCount: 4,
-	derive: derive$2,
-	transform(event) {
-		const { next } = event;
-		if (next.length === 4) return clonePositions(next);
-		return derive$2(next);
-	}
-};
-//#endregion
-//#region src/draw-rules/axis1.ts
-function derive$1(points) {
-	if (points.length < 2) return clonePositions(points);
-	if (points.length === 2) {
-		const tip = clonePosition(points[0]);
-		const neck = clonePosition(points[1]);
-		return [
-			tip,
-			neck,
-			computeInitialWidthPoint(tip, neck)
-		];
-	}
-	return clonePositions(points);
-}
-function projectWidthIntoFrame(next, longitudinal, lateral) {
-	const tip = next[0];
-	const neck = next[1];
-	if (!tip || !neck) return null;
-	const tipM = project(tip[0], tip[1]);
-	const neckM = project(neck[0], neck[1]);
-	const dx = tipM[0] - neckM[0];
-	const dy = tipM[1] - neckM[1];
-	const len = Math.sqrt(dx * dx + dy * dy);
-	if (len < 1e-6) return null;
-	const ax = dx / len;
-	const ay = dy / len;
-	const px = -ay;
-	const py = ax;
-	return unproject(tipM[0] + longitudinal * ax + lateral * px, tipM[1] + longitudinal * ay + lateral * py);
-}
-function packWithWidth(next, width) {
-	const out = clonePositions(next);
-	out[out.length - 1] = width;
-	return out;
-}
-const axis1DrawRule = {
-	id: "axis1",
-	minimumUserPoints: 2,
-	trailingFixedSlots: 1,
-	derive: derive$1,
-	transform(event) {
-		const { previous, next, activePointIndex } = event;
-		if (next.length < 3 || previous.length < 3) return derive$1(next);
-		if (!(activePointIndex === 0 || activePointIndex === 1)) return clonePositions(next);
-		const metrics = calculateMetrics(previous);
-		if (!metrics) return clonePositions(next);
-		const projected = projectWidthIntoFrame(next, metrics.longitudinal, metrics.lateral);
-		if (!projected) return clonePositions(next);
-		return packWithWidth(next, projected);
-	}
-};
-//#endregion
-//#region src/draw-rules/area21.ts
-function derive(points) {
-	if (points.length === 2) return clonePositions([
-		points[0],
-		points[1],
-		points[1]
-	]);
-	return clonePositions(points);
-}
-const searchAreaDrawRule = {
-	id: "area21:search-area",
-	minimumUserPoints: 3,
-	minimumPreviewPoints: 2,
-	canonicalPointCount: 3,
-	derive,
-	transform(event) {
-		return derive(event.next);
-	}
-};
-//#endregion
-//#region src/generators/cm15-maneuver-areas/params.ts
-const ATTACK_SHAFT_PARAMS = [
-	{
-		key: "shaftWidthRatio",
-		label: "Shaft width",
-		description: "Arrow shaft width as a ratio of the arrowhead width.",
-		type: "number",
-		min: .1,
-		max: 1,
-		step: .05
-	},
-	{
-		key: "roundedBends",
-		label: "Rounded bends",
-		description: "Round the corners where the shaft changes direction.",
-		type: "boolean"
-	},
-	{
-		key: "bendSegments",
-		label: "Bend segments",
-		description: "Number of segments approximating each rounded bend.",
-		type: "number",
-		min: 1,
-		max: 20,
-		step: 1,
-		visibleWhen: (opts) => opts.roundedBends === true
-	}
-];
-const FIRE_ARROW_PARAMS = [
-	{
-		key: "arrowTipWidthRatio",
-		label: "Arrow tip width",
-		description: "Width of the arrow tip as a ratio of the head width.",
-		type: "number",
-		min: .05,
-		max: 1,
-		step: .01
-	},
-	{
-		key: "backLineLengthRatio",
-		label: "Back line length",
-		description: "Length of the rear flare lines as a ratio of the head.",
-		type: "number",
-		min: .05,
-		max: 1,
-		step: .01
-	},
-	{
-		key: "backLineAngle",
-		label: "Back line angle",
-		description: "Angle of the rear flare lines, in degrees.",
-		type: "number",
-		min: 0,
-		max: 90,
-		step: 1
-	}
-];
-const FORTIFIED_PARAMS$1 = [{
-	key: "sizePixels",
-	label: "Size",
-	description: "Size of the fortified-line teeth, in pixels.",
-	type: "number",
-	min: 5,
-	max: 50,
-	step: 1,
-	unit: "px"
-}, {
-	key: "size",
-	label: "Size",
-	description: "Size of the fortified-line teeth, in meters.",
-	type: "number",
-	min: 1,
-	max: 500,
-	step: 1,
-	unit: "m"
-}];
-//#endregion
-//#region src/generators/cm15-maneuver-areas/airborneAttack.ts
-const DEFAULT_AIRBORNE_ATTACK_OPTIONS = {
-	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO,
-	roundedBends: false,
-	bendSegments: 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"],
-	drawRule: "Axis1",
-	params: ATTACK_SHAFT_PARAMS
-};
-/**
-* 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>.
-*/
-function createAirborneAttack(coordinates, options = {}) {
-	const { geometry } = processAttackGeometry(coordinates, options);
-	if (!geometry) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const shaftLeftToNeck = geometry.shaftLeft.slice(0, -1);
-	const shaftRightToNeck = geometry.shaftRight.slice(0, -1);
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {},
-			geometry: {
-				type: "LineString",
-				coordinates: [
-					...shaftLeftToNeck,
-					geometry.headRing[3],
-					geometry.headRing[2],
-					geometry.headRing[1],
-					geometry.headRing[0],
-					geometry.headRing[5],
-					...[...shaftRightToNeck].reverse()
-				].map((p) => unproject(p[0], p[1]))
-			}
-		}]
-	};
-}
-const AIRBORNE_ATTACK = defineControlMeasure({
-	metadata: AIRBORNE_ATTACK_METADATA,
-	generator: createAirborneAttack,
-	defaultOptions: DEFAULT_AIRBORNE_ATTACK_OPTIONS,
-	rule: axis1DrawRule
-});
-/**
-* Reacts to an **input-contract** violation according to `mode`: `throw`
-* raises, `warn` logs, `silent` (the default) does neither. Always returns
-* `false` so a caller can `return reportValidationIssue(...)` from a guard.
-*
-* Governs the *input contract* only (control-point count and finiteness),
-* checked once at the render seam — not geometric degeneracy, which always
-* yields an empty render silently. See ADR-0014 and the `CONTEXT.md` terms.
-*/
-function reportValidationIssue(mode, message) {
-	const resolved = mode ?? "silent";
-	if (resolved === "throw") throw new Error(message);
-	if (resolved === "warn") console.warn(message);
-	return false;
-}
-/**
-* Narrows a control-point array to the fixed `[PT1, PT2, PT3]` tuple the ambush
-* and search-area generators require. The render seam has already validated
-* that at least three valid points are present (ADR-0014), so this is a pure
-* cast with no runtime guard. Used by those measures' definition adapters so
-* the generators keep their precise tuple parameter (ADR-0013).
-*/
-function asThreePoints(points) {
-	return [
-		points[0],
-		points[1],
-		points[2]
-	];
-}
-const DEFAULT_AMBUSH_OPTIONS = {
-	hSize: .15,
-	hWidth: .5,
-	hLen: .15,
-	hCount: 5,
-	cDepth: .25,
-	resolution: 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"],
-	drawRule: "Line29",
-	params: [
-		{
-			key: "hSize",
-			label: "Head size",
-			description: "Arrowhead length as a fraction of the chord span",
-			type: "number",
-			min: .01,
-			max: .5,
-			step: .01
-		},
-		{
-			key: "hWidth",
-			label: "Head width",
-			description: "Arrowhead wing spread relative to its length",
-			type: "number",
-			min: .05,
-			max: 2,
-			step: .01
-		},
-		{
-			key: "hLen",
-			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: "hCount",
-			label: "Hatch count",
-			description: "Number of parallel hatches spaced along the curve",
-			type: "number",
-			min: 0,
-			max: 20,
-			step: 1
-		},
-		{
-			key: "cDepth",
-			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: "resolution",
-			label: "Resolution",
-			description: "Number of segments used to render the curve",
-			type: "number",
-			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 { hSize, hWidth, hLen, hCount, cDepth, resolution } = {
-		...DEFAULT_AMBUSH_OPTIONS,
-		...options
-	};
-	const safeResolution = Math.max(1, Math.floor(resolution));
-	const safeHCount = Math.max(0, Math.floor(hCount));
-	const safeHSize = Math.max(0, hSize);
-	const safeHWidth = Math.max(0, hWidth);
-	const safeHLen = Math.max(0, hLen);
-	const safeCDepth = Math.max(0, cDepth);
-	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 * safeCDepth));
-	const shaftOrigin = quadBezier(.5, p2, ctrl, p3);
-	const adjP1 = vecAdd(shaftOrigin, vecScale(n, side * Math.max(0, Math.abs(dist) - span * safeCDepth * .5)));
-	const lines = [];
-	lines.push([shaftOrigin, adjP1]);
-	const hL = span * safeHSize;
-	const hw = hL * safeHWidth;
-	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 <= safeResolution; i++) {
-		const t = i / safeResolution;
-		curve.push(quadBezier(t, p2, ctrl, p3));
-	}
-	lines.push(curve);
-	const hLenActual = span * safeHLen;
-	for (let i = 1; i <= safeHCount; i++) {
-		const pt = quadBezier(i / (safeHCount + 1), p2, ctrl, p3);
-		lines.push([pt, vecSub(pt, vecScale(n, side * hLenActual))]);
-	}
-	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/generators/cm29-protection-lines/params.ts
-const FORTIFIED_PARAMS = [{
-	key: "sizePixels",
-	label: "Size",
-	description: "Side length of the square crenellations",
-	type: "number",
-	min: 5,
-	max: 50,
-	step: 1,
-	unit: "px"
-}, {
-	key: "size",
-	label: "Size",
-	description: "Side length of the square crenellations",
-	type: "number",
-	min: 1,
-	max: 500,
-	step: 1,
-	unit: "m"
-}];
-const ANTITANK_DITCH_PARAMS = [
-	{
-		key: "toothHeightPixels",
-		label: "Tooth height",
-		description: "Perpendicular depth of each triangular tooth",
-		type: "number",
-		min: 5,
-		max: 50,
-		step: 1,
-		unit: "px"
-	},
-	{
-		key: "toothHeight",
-		label: "Tooth height",
-		description: "Perpendicular depth of each triangular tooth",
-		type: "number",
-		min: 1,
-		max: 500,
-		step: 1,
-		unit: "m"
-	},
-	{
-		key: "toothWidthRatio",
-		label: "Tooth width ratio",
-		description: "Tooth base span as a multiple of height",
-		type: "number",
-		min: .5,
-		max: 3,
-		step: .05,
-		unit: "x"
-	}
-];
-const ANTITANK_WALL_PARAMS = [...ANTITANK_DITCH_PARAMS, {
-	key: "toothSpacingRatio",
-	label: "Tooth spacing ratio",
-	description: "Gap between teeth as a multiple of base width",
-	type: "number",
-	min: 0,
-	max: 3,
-	step: .05,
-	unit: "x"
-}];
-//#endregion
-//#region src/generators/cm29-protection-lines/antitankDitch.ts
-const DEFAULT_TOOTH_HEIGHT = 50;
-const DEFAULT_TOOTH_HEIGHT_PIXELS = 10;
-const DEFAULT_TOOTH_WIDTH_RATIO$1 = 1.15;
-const DEFAULT_ANTITANK_DITCH_OPTIONS = {
-	toothHeight: DEFAULT_TOOTH_HEIGHT,
-	toothHeightPixels: DEFAULT_TOOTH_HEIGHT_PIXELS,
-	toothWidthRatio: DEFAULT_TOOTH_WIDTH_RATIO$1
-};
-const ANTITANK_DITCH_UNDER_CONSTRUCTION_METADATA = {
-	id: "antitank-ditch-under-construction",
-	name: "Ditch - Under Construction",
-	description: "Antitank ditch obstacle under construction.",
-	entity: "Protection Lines",
-	entityType: "Antitank Obstacles",
-	entitySubtype: "Ditch - Under Construction",
-	value: "290201",
-	minCoordinates: 2,
-	geometry: "line",
-	geometryTypes: ["MultiLineString"],
-	drawRule: "Line1",
-	params: ANTITANK_DITCH_PARAMS
-};
-const ANTITANK_DITCH_COMPLETED_METADATA = {
-	id: "antitank-ditch-completed",
-	name: "Ditch - Completed",
-	description: "Completed antitank ditch obstacle.",
-	entity: "Protection Lines",
-	entityType: "Antitank Obstacles",
-	entitySubtype: "Ditch - Completed",
-	value: "290202",
-	minCoordinates: 2,
-	geometry: "line",
-	geometryTypes: ["MultiPolygon"],
-	drawRule: "Line1",
-	params: ANTITANK_DITCH_PARAMS
-};
-function calculateAntitankDitchHeight(options) {
-	const { toothHeight = DEFAULT_TOOTH_HEIGHT, toothHeightPixels, metersPerPixel } = options;
-	if (toothHeightPixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0) return Math.max(EPSILON, toothHeightPixels * metersPerPixel);
-	return Math.max(EPSILON, toothHeight);
-}
-function generateAntitankDitchTriangles(projectedPoints, toothHeight, toothWidthRatio = DEFAULT_TOOTH_WIDTH_RATIO$1) {
-	const triangles = [];
-	const targetPeriod = Math.max(EPSILON, toothWidthRatio) * toothHeight;
-	for (let i = 0; i < projectedPoints.length - 1; i++) {
-		const p1 = projectedPoints[i];
-		const p2 = projectedPoints[i + 1];
-		const segmentVec = vecSub(p2, p1);
-		const segmentLength = vecMag(segmentVec);
-		if (segmentLength < 1e-6) continue;
-		const segmentDir = vecNorm(segmentVec);
-		const perpDir = [-segmentDir[1], segmentDir[0]];
-		const toothCount = Math.max(1, Math.round(segmentLength / targetPeriod));
-		const period = segmentLength / toothCount;
-		for (let toothIndex = 0; toothIndex < toothCount; toothIndex++) {
-			const baseStart = vecAdd(p1, vecScale(segmentDir, period * toothIndex));
-			const baseEnd = vecAdd(p1, vecScale(segmentDir, period * (toothIndex + 1)));
-			const tip = vecAdd(vecAdd(baseStart, vecScale(segmentDir, period / 2)), vecScale(perpDir, toothHeight));
-			triangles.push([
-				baseStart,
-				tip,
-				baseEnd
-			]);
-		}
-	}
-	return triangles;
-}
-function buildAntitankDitchTriangles(positions, options) {
-	const toothHeight = calculateAntitankDitchHeight(options);
-	const toothWidthRatio = options.toothWidthRatio ?? DEFAULT_TOOTH_WIDTH_RATIO$1;
-	return generateAntitankDitchTriangles(positions.map((position) => project(position[0], position[1])), toothHeight, toothWidthRatio);
-}
-function createAntitankDitchUnderConstruction(positions, options = {}) {
-	const triangles = buildAntitankDitchTriangles(positions, options);
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: { part: "ditch" },
-			geometry: {
-				type: "MultiLineString",
-				coordinates: [positions.map((position) => [position[0], position[1]]), ...triangles.map((triangle) => triangle.map((point) => unproject(point[0], point[1])))]
-			}
-		}]
-	};
-}
-function createAntitankDitchCompleted(positions, options = {}) {
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {
-				part: "teeth",
-				fill: true
-			},
-			geometry: {
-				type: "MultiPolygon",
-				coordinates: buildAntitankDitchTriangles(positions, options).map((triangle) => {
-					return [[...triangle, triangle[0]].map((point) => unproject(point[0], point[1]))];
-				})
-			}
-		}]
-	};
-}
-const ANTITANK_DITCH_UNDER_CONSTRUCTION = defineControlMeasure({
-	metadata: ANTITANK_DITCH_UNDER_CONSTRUCTION_METADATA,
-	generator: createAntitankDitchUnderConstruction,
-	defaultOptions: DEFAULT_ANTITANK_DITCH_OPTIONS,
-	rule: line1DrawRule
-});
-const ANTITANK_DITCH_COMPLETED = defineControlMeasure({
-	metadata: ANTITANK_DITCH_COMPLETED_METADATA,
-	generator: createAntitankDitchCompleted,
-	defaultOptions: DEFAULT_ANTITANK_DITCH_OPTIONS,
-	rule: line1DrawRule
-});
-//#endregion
-//#region src/generators/cm29-protection-lines/antitankWall.ts
-const DEFAULT_TOOTH_SPACING_RATIO = 1.35;
-const DEFAULT_TOOTH_WIDTH_RATIO = 2.2;
-const DEFAULT_ANTITANK_WALL_OPTIONS = {
-	...DEFAULT_ANTITANK_DITCH_OPTIONS,
-	toothWidthRatio: DEFAULT_TOOTH_WIDTH_RATIO,
-	toothSpacingRatio: DEFAULT_TOOTH_SPACING_RATIO
-};
-const ANTITANK_WALL_METADATA = {
-	id: "antitank-wall",
-	name: "Antitank Wall",
-	description: "Antitank wall obstacle.",
-	entity: "Protection Lines",
-	entityType: "Antitank Obstacles",
-	entitySubtype: "Antitank Wall",
-	value: "290204",
-	minCoordinates: 2,
-	geometry: "line",
-	geometryTypes: ["MultiLineString"],
-	drawRule: "Line1",
-	params: ANTITANK_WALL_PARAMS
-};
-function generateAntitankWallPoints(projectedPoints, toothHeight, toothWidthRatio = DEFAULT_TOOTH_WIDTH_RATIO, toothSpacingRatio = DEFAULT_TOOTH_SPACING_RATIO) {
-	if (projectedPoints.length < 2) return projectedPoints;
-	const wallPoints = [];
-	const safeToothHeight = Math.max(EPSILON, toothHeight);
-	const safeToothWidthRatio = Math.max(EPSILON, toothWidthRatio);
-	const safeToothSpacingRatio = Math.max(0, toothSpacingRatio);
-	const targetPeriod = safeToothWidthRatio * safeToothHeight;
-	for (let i = 0; i < projectedPoints.length - 1; i++) {
-		const p1 = projectedPoints[i];
-		const p2 = projectedPoints[i + 1];
-		const segmentVec = vecSub(p2, p1);
-		const segmentLength = vecMag(segmentVec);
-		if (wallPoints.length === 0) wallPoints.push(p1);
-		if (segmentLength < 1e-6) continue;
-		const segmentDir = vecNorm(segmentVec);
-		const perpDir = [segmentDir[1], -segmentDir[0]];
-		const toothCount = Math.max(1, Math.round(segmentLength / targetPeriod));
-		const period = segmentLength / toothCount;
-		const toothBase = Math.max(EPSILON, period / (1 + safeToothSpacingRatio));
-		const shoulder = (period - toothBase) / 2;
-		for (let toothIndex = 0; toothIndex < toothCount; toothIndex++) {
-			const baseStartDistance = period * toothIndex + shoulder;
-			const baseStart = vecAdd(p1, vecScale(segmentDir, baseStartDistance));
-			const baseEnd = vecAdd(p1, vecScale(segmentDir, baseStartDistance + toothBase));
-			const tip = vecAdd(vecAdd(baseStart, vecScale(segmentDir, toothBase / 2)), vecScale(perpDir, safeToothHeight));
-			wallPoints.push(baseStart, tip, baseEnd);
-		}
-		wallPoints.push(p2);
-	}
-	return wallPoints;
-}
-function createAntitankWall(positions, options = {}) {
-	const toothHeight = calculateAntitankDitchHeight(options);
-	const toothWidthRatio = options.toothWidthRatio ?? DEFAULT_TOOTH_WIDTH_RATIO;
-	const toothSpacingRatio = options.toothSpacingRatio ?? DEFAULT_TOOTH_SPACING_RATIO;
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: { part: "wall" },
-			geometry: {
-				type: "MultiLineString",
-				coordinates: [generateAntitankWallPoints(positions.map((position) => project(position[0], position[1])), toothHeight, toothWidthRatio, toothSpacingRatio).map((point) => unproject(point[0], point[1]))]
-			}
-		}]
-	};
-}
-const ANTITANK_WALL = defineControlMeasure({
-	metadata: ANTITANK_WALL_METADATA,
-	generator: createAntitankWall,
-	defaultOptions: DEFAULT_ANTITANK_WALL_OPTIONS,
-	rule: line1DrawRule
-});
-//#endregion
-//#region src/generators/cm15-maneuver-areas/attackByFire.ts
-const DEFAULT_ATTACK_BY_FIRE_OPTIONS = {
-	arrowTipWidthRatio: .3,
-	backLineLengthRatio: .3,
-	backLineAngle: 45
-};
-const ATTACK_BY_FIRE_METADATA = {
-	id: "attack-by-fire",
-	name: "Attack by Fire",
-	description: "Attack by fire graphic with base, shaft, and arrowhead.",
-	entity: "Maneuver Areas",
-	entityType: "Attack by Fire",
-	value: "152000",
-	minCoordinates: 3,
-	geometry: "line",
-	geometryTypes: ["LineString"],
-	drawRule: "Area7",
-	params: FIRE_ARROW_PARAMS
-};
-/**
-* Generates a GeoJSON FeatureCollection for an Attack By Fire tactical graphic.
-*
-* Input:
-* - PT1: Arrow Tip (Target)
-* - PT2: Left Base
-* - PT3: Right Base
-*
-* Logic:
-* - Shaft: Midpoint(PT2, PT3) -> PT1
-* - Base Line: PT2 -> PT3
-* - Wings: Splayed out from PT2 and PT3
-*/
-function createAttackByFire(coordinates, options = {}) {
-	const featureProps = {};
-	const arrowTipWidthRatio = options.arrowTipWidthRatio ?? DEFAULT_ATTACK_BY_FIRE_OPTIONS.arrowTipWidthRatio;
-	const backLineLengthRatio = options.backLineLengthRatio ?? DEFAULT_ATTACK_BY_FIRE_OPTIONS.backLineLengthRatio;
-	const backLineAngle = options.backLineAngle ?? DEFAULT_ATTACK_BY_FIRE_OPTIONS.backLineAngle;
-	const c1 = coordinates[0];
-	const c2 = coordinates[1];
-	const c3 = coordinates[2];
-	const p1 = project(c1[0], c1[1]);
-	const p2 = project(c2[0], c2[1]);
-	const p3 = project(c3[0], c3[1]);
-	const frame = createProjectedBaselineFrame(p2, p3, {
-		origin: "midpoint",
-		normal: "right"
-	});
-	if (!frame) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const pMid = frame.origin;
-	const signedTipDistance = vecDot(vecSub(p1, pMid), frame.normal);
-	if (Math.abs(signedTipDistance) < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const pTip = vecAdd(pMid, vecScale(frame.normal, signedTipDistance));
-	const dirShaft = signedTipDistance >= 0 ? frame.normal : vecScale(frame.normal, -1);
-	const lenShaft = Math.abs(signedTipDistance);
-	const lenBase = frame.length;
-	const dirBase = frame.direction;
-	const angleRad = backLineAngle * Math.PI / 180;
-	const baseAngle = -Math.PI / 2;
-	const angleLeft = baseAngle - angleRad;
-	const dirBackLeft = [dirBase[0] * Math.cos(angleLeft) - dirBase[1] * Math.sin(angleLeft), dirBase[0] * Math.sin(angleLeft) + dirBase[1] * Math.cos(angleLeft)];
-	const angleRight = baseAngle + angleRad;
-	const dirBackRight = [dirBase[0] * Math.cos(angleRight) - dirBase[1] * Math.sin(angleRight), dirBase[0] * Math.sin(angleRight) + dirBase[1] * Math.cos(angleRight)];
-	const backLen = lenBase * backLineLengthRatio;
-	const p2Back = vecAdd(p2, vecScale(dirBackLeft, backLen));
-	const p3Back = vecAdd(p3, vecScale(dirBackRight, backLen));
-	const headWidth = lenShaft * arrowTipWidthRatio;
-	const headFeatures = createArrowHead$2(pTip, dirShaft, headWidth, headWidth);
-	return {
-		type: "FeatureCollection",
-		features: [
-			{
-				type: "Feature",
-				properties: featureProps,
-				geometry: {
-					type: "LineString",
-					coordinates: [unproject(p2[0], p2[1]), unproject(p2Back[0], p2Back[1])]
-				}
-			},
-			{
-				type: "Feature",
-				properties: featureProps,
-				geometry: {
-					type: "LineString",
-					coordinates: [unproject(p3[0], p3[1]), unproject(p3Back[0], p3Back[1])]
-				}
-			},
-			{
-				type: "Feature",
-				properties: featureProps,
-				geometry: {
-					type: "LineString",
-					coordinates: [unproject(pMid[0], pMid[1]), unproject(pTip[0], pTip[1])]
-				}
-			},
-			{
-				type: "Feature",
-				properties: featureProps,
-				geometry: {
-					type: "LineString",
-					coordinates: [unproject(p2[0], p2[1]), unproject(p3[0], p3[1])]
-				}
-			},
-			...headFeatures.map((f) => ({
-				...f,
-				properties: featureProps
-			}))
-		]
-	};
-}
-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 [{
-		type: "Feature",
-		geometry: {
-			type: "LineString",
-			coordinates: [
-				unproject(left[0], left[1]),
-				unproject(tip[0], tip[1]),
-				unproject(right[0], right[1])
-			]
-		},
-		properties: {}
-	}];
-}
-const ATTACK_BY_FIRE = defineControlMeasure({
-	metadata: ATTACK_BY_FIRE_METADATA,
-	generator: createAttackByFire,
-	defaultOptions: DEFAULT_ATTACK_BY_FIRE_OPTIONS,
-	rule: attackByFireDrawRule
-});
-//#endregion
-//#region src/generators/cm15-maneuver-areas/attackHelicopter.ts
-const DEFAULT_ATTACK_HELICOPTER_OPTIONS = {
-	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO,
-	roundedBends: false,
-	bendSegments: 5,
-	symbolHeightRatio: .45,
-	triangleSizeRatio: .25,
-	bottomBarWidthRatio: 1.5,
-	bowtieWidthRatio: .8
-};
-const ATTACK_HELICOPTER_METADATA = {
-	id: "attack-helicopter",
-	name: "Attack Helicopter",
-	description: "Attack helicopter axis of advance.",
-	entity: "Maneuver Areas",
-	entityType: "Axis of Advance",
-	entitySubtype: "Attack Helicopter",
-	value: "151402",
-	minCoordinates: 3,
-	geometry: "line",
-	geometryTypes: ["LineString", "Polygon"],
-	drawRule: "Axis1",
-	params: [
-		...ATTACK_SHAFT_PARAMS,
-		{
-			key: "symbolHeightRatio",
-			label: "Symbol height",
-			description: "Height of the helicopter symbol as a ratio of the head width.",
-			type: "number",
-			min: .1,
-			max: 1.5,
-			step: .05
-		},
-		{
-			key: "triangleSizeRatio",
-			label: "Triangle size",
-			description: "Size of the top triangle relative to the reference unit.",
-			type: "number",
-			min: .1,
-			max: .8,
-			step: .05
-		},
-		{
-			key: "bottomBarWidthRatio",
-			label: "Bottom bar width",
-			description: "Width of the bottom bar relative to the reference triangle.",
-			type: "number",
-			min: .5,
-			max: 3,
-			step: .1
-		},
-		{
-			key: "bowtieWidthRatio",
-			label: "Bowtie width",
-			description: "Size of the central bowtie relative to the reference triangle.",
-			type: "number",
-			min: .2,
-			max: 2,
-			step: .1
-		}
-	]
-};
-/**
-* Generates a GeoJSON FeatureCollection for an Attack Helicopter tactical symbol.
-*
-* The symbol is based on the Airborne Attack (bow tie) geometry but features
-* an additional symbol (vertical line + triangle) at the crossover point.
-*
-* @param coordinates - An array of GeoJSON Positions.
-* @param options - Configuration options.
-* @returns A GeoJSON FeatureCollection containing the main graphic and the symbol.
-*/
-function createAttackHelicopter(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);
-	if (geometry.shaftLeft.length < 2 || geometry.shaftRight.length < 2) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const pL = geometry.shaftLeft[geometry.shaftLeft.length - 2];
-	const pIR = geometry.headRing[3];
-	const pR = geometry.shaftRight[geometry.shaftRight.length - 2];
-	const pIL = geometry.headRing[5];
-	if (!pL || !pIR || !pR || !pIL) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const center = lineIntersection(pL, pIR, pR, pIL);
-	const features = [{
-		type: "Feature",
-		properties: {},
-		geometry: {
-			type: "LineString",
-			coordinates: [
-				...shaftLeftToNeck,
-				pIR,
-				geometry.headRing[2],
-				geometry.headRing[1],
-				geometry.headRing[0],
-				pIL,
-				...[...shaftRightToNeck].reverse()
-			].map((p) => unproject(p[0], p[1]))
-		}
-	}];
-	if (center) {
-		const neck = geometry.ptNeck;
-		const tip = geometry.ptTip;
-		const d = vecSub(tip, neck);
-		if (vecMag(d) > 0) {
-			const u = vecNorm(d);
-			const n = [-u[1], u[0]];
-			const headWidth = Math.sqrt(Math.pow(geometry.headRing[0][0] - geometry.headRing[2][0], 2) + Math.pow(geometry.headRing[0][1] - geometry.headRing[2][1], 2));
-			const symbolHeightRatio = options.symbolHeightRatio ?? DEFAULT_ATTACK_HELICOPTER_OPTIONS.symbolHeightRatio;
-			const triangleSizeRatio = options.triangleSizeRatio ?? DEFAULT_ATTACK_HELICOPTER_OPTIONS.triangleSizeRatio;
-			const bottomBarWidthRatio = options.bottomBarWidthRatio ?? DEFAULT_ATTACK_HELICOPTER_OPTIONS.bottomBarWidthRatio;
-			const bowtieWidthRatio = options.bowtieWidthRatio ?? DEFAULT_ATTACK_HELICOPTER_OPTIONS.bowtieWidthRatio;
-			const baseUnit = headWidth * .45;
-			const shaftLength = headWidth * symbolHeightRatio;
-			const triHeight = baseUnit * triangleSizeRatio;
-			const triHalfWidth = triHeight * .8;
-			const refTriHeight = baseUnit * .25;
-			const refTriHalfWidth = refTriHeight * .8;
-			const lineLengthUp = shaftLength - triHeight;
-			const lineLengthDown = shaftLength;
-			const pLineTop = vecAdd(center, vecScale(n, lineLengthUp));
-			const pLineBottom = vecSub(center, vecScale(n, lineLengthDown));
-			const verticalLineFeature = {
-				type: "Feature",
-				properties: {},
-				geometry: {
-					type: "LineString",
-					coordinates: [unproject(pLineTop[0], pLineTop[1]), unproject(pLineBottom[0], pLineBottom[1])]
-				}
-			};
-			const pTriTip = vecAdd(pLineTop, vecScale(n, triHeight));
-			const pTriLeft = vecAdd(pLineTop, vecScale(u, triHalfWidth));
-			const pTriRight = vecSub(pLineTop, vecScale(u, triHalfWidth));
-			const triFeature = {
-				type: "Feature",
-				properties: { fill: "currentColor" },
-				geometry: {
-					type: "Polygon",
-					coordinates: [[
-						unproject(pTriTip[0], pTriTip[1]),
-						unproject(pTriRight[0], pTriRight[1]),
-						unproject(pTriLeft[0], pTriLeft[1]),
-						unproject(pTriTip[0], pTriTip[1])
-					]]
-				}
-			};
-			const barHalfWidth = refTriHalfWidth * bottomBarWidthRatio;
-			const pBarLeft = vecAdd(pLineBottom, vecScale(u, barHalfWidth));
-			const pBarRight = vecSub(pLineBottom, vecScale(u, barHalfWidth));
-			const barFeature = {
-				type: "Feature",
-				properties: {},
-				geometry: {
-					type: "LineString",
-					coordinates: [unproject(pBarLeft[0], pBarLeft[1]), unproject(pBarRight[0], pBarRight[1])]
-				}
-			};
-			const bowTieSize = refTriHeight * bowtieWidthRatio;
-			const bowTieHalfWidth = bowTieSize * .6;
-			const pBowTieRightBaseCenter = vecAdd(center, vecScale(u, bowTieSize));
-			const pBowTieRightTop = vecAdd(pBowTieRightBaseCenter, vecScale(n, bowTieHalfWidth));
-			const pBowTieRightBottom = vecSub(pBowTieRightBaseCenter, vecScale(n, bowTieHalfWidth));
-			const bowTieRightFeature = {
-				type: "Feature",
-				properties: { fill: "currentColor" },
-				geometry: {
-					type: "Polygon",
-					coordinates: [[
-						unproject(center[0], center[1]),
-						unproject(pBowTieRightTop[0], pBowTieRightTop[1]),
-						unproject(pBowTieRightBottom[0], pBowTieRightBottom[1]),
-						unproject(center[0], center[1])
-					]]
-				}
-			};
-			const pBowTieLeftBaseCenter = vecSub(center, vecScale(u, bowTieSize));
-			const pBowTieLeftTop = vecAdd(pBowTieLeftBaseCenter, vecScale(n, bowTieHalfWidth));
-			const pBowTieLeftBottom = vecSub(pBowTieLeftBaseCenter, vecScale(n, bowTieHalfWidth));
-			const bowTieLeftFeature = {
-				type: "Feature",
-				properties: { fill: "currentColor" },
-				geometry: {
-					type: "Polygon",
-					coordinates: [[
-						unproject(center[0], center[1]),
-						unproject(pBowTieLeftTop[0], pBowTieLeftTop[1]),
-						unproject(pBowTieLeftBottom[0], pBowTieLeftBottom[1]),
-						unproject(center[0], center[1])
-					]]
-				}
-			};
-			features.push(verticalLineFeature, triFeature, barFeature, bowTieRightFeature, bowTieLeftFeature);
-		}
-	}
-	return {
-		type: "FeatureCollection",
-		features
-	};
-}
-const ATTACK_HELICOPTER = defineControlMeasure({
-	metadata: ATTACK_HELICOPTER_METADATA,
-	generator: createAttackHelicopter,
-	defaultOptions: DEFAULT_ATTACK_HELICOPTER_OPTIONS,
-	rule: axis1DrawRule
-});
-//#endregion
-//#region src/generators/cm27-protection-areas/block.ts
-const DEFAULT_STEM_RATIO$1 = 1.5;
-const BLOCK_METADATA = {
-	id: "block",
-	name: "Block",
-	description: "An obstacle effect that integrates fire planning and obstacle effort to stop an attacker along a specific avenue of approach or prevent the attacking force from passing through an engagement area. (FM 3-90)",
-	entity: "Protection Areas",
-	entityType: "Obstacle Effects",
-	entitySubtype: "Block",
-	value: "270501",
-	minCoordinates: 2,
-	geometry: "line",
-	geometryTypes: ["LineString"],
-	drawRule: "Area11"
-};
-const DEFAULT_BLOCK_OPTIONS = {};
-/**
-* Generates a GeoJSON FeatureCollection for a "Block" tactical symbol (T-shape).
-*
-* @param coordinates - An array of GeoJSON Positions (Lon/Lat).
-* Expects exactly 3 points:
-* - PT1 & PT2: Endpoints of the vertical line.
-* - PT3: Defines the endpoint of the horizontal line (stem).
-* @param options - Configuration options.
-* @returns A GeoJSON FeatureCollection containing a LineString.
-*/
-function createBlock(coordinates, _options = {}) {
-	const p1 = project(coordinates[0][0], coordinates[0][1]);
-	const p2 = project(coordinates[1][0], coordinates[1][1]);
-	const frame = createProjectedBaselineFrame(p1, p2, {
-		origin: "midpoint",
-		normal: "right"
-	});
-	if (!frame) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const c3 = coordinates[2];
-	const stemDistance = c3 ? frame.signedNormalDistance(c3) : frame.length * DEFAULT_STEM_RATIO$1;
-	const mid = frame.origin;
-	const pStemEnd = vecAdd(mid, vecScale(frame.normal, stemDistance));
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {},
-			geometry: {
-				type: "LineString",
-				coordinates: [
-					unproject(p1[0], p1[1]),
-					unproject(p2[0], p2[1]),
-					unproject(mid[0], mid[1]),
-					unproject(pStemEnd[0], pStemEnd[1])
-				]
-			}
-		}]
-	};
-}
-const BLOCK = defineControlMeasure({
-	metadata: BLOCK_METADATA,
-	generator: createBlock,
-	defaultOptions: DEFAULT_BLOCK_OPTIONS,
-	rule: blockDrawRule
-});
-//#endregion
-//#region src/internal/angle-utils.ts
-/**
-* Wraps an angle (radians) into the half-open range (-π, π].
-*/
-function normalizeRadians(angle) {
-	let normalized = angle % (Math.PI * 2);
-	if (normalized > Math.PI) normalized -= Math.PI * 2;
-	if (normalized <= -Math.PI) normalized += Math.PI * 2;
-	return normalized;
-}
-/**
-* Flips a text rotation by π when it would otherwise read upside-down, keeping
-* the baseline pointing left-to-right (within ±90° of horizontal).
-*/
-function keepTextLeftToRight(rotation) {
-	const normalized = normalizeRadians(rotation);
-	if (normalized > Math.PI / 2) return normalized - Math.PI;
-	if (normalized < -Math.PI / 2) return normalized + Math.PI;
-	return normalized;
-}
-//#endregion
-//#region src/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 any captured label-size
-* metadata 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",
-			text,
-			rotation,
-			...labelSize.pixels !== void 0 ? { textSizePixels: labelSize.pixels } : {},
-			...labelSize.zoom !== void 0 ? { textSizeZoom: labelSize.zoom } : {},
-			...labelSize.resolution !== void 0 ? { textSizeResolution: labelSize.resolution } : {}
-		},
-		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) {
-	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 gapHalf = frontLength * config.labelGapRatio / 2;
-	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
-	});
-	const mainFeature = {
-		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 rearLineRotation = Math.atan2(dirFront[1], dirFront[0]);
-	const renderedLabelRotation = Math.PI - (rearLineRotation - Math.PI / 2);
-	const labelRotation = normalizeRadians(Math.PI - keepTextLeftToRight(renderedLabelRotation));
-	return {
-		type: "FeatureCollection",
-		features: [mainFeature, createLabelFeature(rearMidpoint, config.labelText, labelRotation, config.labelSize)]
-	};
-}
-//#endregion
-//#region src/generators/cm34-mission-tasks/block.ts
-const DEFAULT_STEM_RATIO = 1.5;
-const DEFAULT_BLOCK_MISSION_TASK_OPTIONS = { labelGapRatio: .2 };
-const BLOCK_MISSION_TASK_METADATA = {
-	id: "block-mission-task",
-	name: "Block",
-	description: "A tactical mission task that denies the enemy access to an area or prevents enemy advance in a direction or along an avenue of approach.",
-	entity: "Mission Tasks",
-	entityType: "Block",
-	value: "340100",
-	minCoordinates: 2,
-	geometry: "line",
-	geometryTypes: ["MultiLineString", "Point"],
-	drawRule: "Area11",
-	capturesLabelSize: true,
-	params: [{
-		key: "labelGapRatio",
-		label: "Label gap",
-		description: "Size of the shaft gap holding the 'B' label, as a ratio of the front length.",
-		type: "number",
-		min: 0,
-		max: 1,
-		step: .01
-	}]
-};
-/**
-* Generates a GeoJSON FeatureCollection for a BLOCK mission task symbol (340100).
-*
-* Uses the same T-shape geometry as the protection-area Block symbol, with a
-* "B" label centered on the shaft.
-*
-* @param coordinates - [PT. 1, PT. 2, optional PT. 3] as Position arrays
-* @param options - Configuration options
-* @returns GeoJSON FeatureCollection containing MultiLineString and Point features
-*/
-function createBlockMissionTaskSymbol(coordinates, options = {}) {
-	const labelGapRatio = options.labelGapRatio ?? DEFAULT_BLOCK_MISSION_TASK_OPTIONS.labelGapRatio;
-	const p1 = project(coordinates[0][0], coordinates[0][1]);
-	const p2 = project(coordinates[1][0], coordinates[1][1]);
-	const frame = createProjectedBaselineFrame(p1, p2, {
-		origin: "midpoint",
-		normal: "right"
-	});
-	if (!frame) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const c3 = coordinates[2];
-	const stemDistance = c3 ? frame.signedNormalDistance(c3) : frame.length * DEFAULT_STEM_RATIO;
-	const mid = frame.origin;
-	const pStemEnd = vecAdd(mid, vecScale(frame.normal, stemDistance));
-	const labelPoint = vecAdd(mid, vecScale(frame.normal, stemDistance / 2));
-	const stemDirection = vecScale(frame.normal, stemDistance < 0 ? -1 : 1);
-	const gapHalf = Math.min(frame.length * labelGapRatio / 2, Math.abs(stemDistance) / 2);
-	const gapStart = vecAdd(labelPoint, vecScale(stemDirection, -gapHalf));
-	const gapEnd = vecAdd(labelPoint, vecScale(stemDirection, gapHalf));
-	const shaftRotation = Math.atan2(frame.normal[1], frame.normal[0]);
-	const renderedLabelRotation = Math.PI - shaftRotation;
-	const labelRotation = normalizeRadians(Math.PI - keepTextLeftToRight(renderedLabelRotation));
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: { part: "block" },
-			geometry: {
-				type: "MultiLineString",
-				coordinates: [
-					[unproject(p1[0], p1[1]), unproject(p2[0], p2[1])],
-					[unproject(mid[0], mid[1]), unproject(gapStart[0], gapStart[1])],
-					[unproject(gapEnd[0], gapEnd[1]), unproject(pStemEnd[0], pStemEnd[1])]
-				]
-			}
-		}, createLabelFeature(labelPoint, "B", labelRotation, {
-			pixels: options.labelSizePixels,
-			zoom: options.labelSizeZoom,
-			resolution: options.labelSizeResolution
-		})]
-	};
-}
-const BLOCK_MISSION_TASK = defineControlMeasure({
-	metadata: BLOCK_MISSION_TASK_METADATA,
-	generator: createBlockMissionTaskSymbol,
-	defaultOptions: DEFAULT_BLOCK_MISSION_TASK_OPTIONS,
-	rule: blockDrawRule
-});
-//#endregion
-//#region src/generators/cm34-mission-tasks/breach.ts
-/**
-* Default options for the BREACH symbol.
-*/
-const DEFAULT_BREACH_OPTIONS = {
-	tickLengthRatio: .15,
-	tickAngle: 45,
-	labelGapRatio: .2
-};
-const BREACH_METADATA = {
-	id: "breach",
-	name: "Breach",
-	description: "A tactical mission task in which a unit breaks through or establishes a passage through an enemy obstacle.",
-	entity: "Mission Tasks",
-	entityType: "Breach",
-	value: "340200",
-	minCoordinates: 3,
-	maxCoordinates: 3,
-	geometry: "line",
-	geometryTypes: ["MultiLineString", "Point"],
-	drawRule: "Point12",
-	capturesLabelSize: true,
-	params: [
-		{
-			key: "tickLengthRatio",
-			label: "Tick length",
-			description: "Length of the outward end ticks, as a ratio of the front opening width.",
-			type: "number",
-			min: .01,
-			max: 1,
-			step: .01
-		},
-		{
-			key: "tickAngle",
-			label: "Tick angle",
-			description: "Outward lean of the end ticks from perpendicular, in degrees.",
-			type: "number",
-			min: 0,
-			max: 90,
-			step: 1
-		},
-		{
-			key: "labelGapRatio",
-			label: "Label gap",
-			description: "Size of the rear-line gap holding the 'B' label, as a ratio of the front length.",
-			type: "number",
-			min: 0,
-			max: 1,
-			step: .01
-		}
-	]
-};
-/**
-* Generates a GeoJSON FeatureCollection for a BREACH mission task symbol (340200).
-*
-* A three-sided bracket (see {@link createBracketSymbol}) whose front opening
-* endpoints terminate in tick marks pointing **outward** (away from the rear
-* "B" line).
-*
-* @param coordinates - [PT. 1, PT. 2, PT. 3] as Position arrays
-* @param options - Configuration options
-* @returns GeoJSON FeatureCollection containing MultiLineString and Point features
-*/
-function createBreachSymbol(coordinates, options = {}) {
-	const tickLengthRatio = options.tickLengthRatio ?? DEFAULT_BREACH_OPTIONS.tickLengthRatio;
-	const tickAngle = options.tickAngle ?? DEFAULT_BREACH_OPTIONS.tickAngle;
-	return createBracketSymbol(coordinates, {
-		part: "breach",
-		labelText: "B",
-		labelGapRatio: options.labelGapRatio ?? DEFAULT_BREACH_OPTIONS.labelGapRatio,
-		labelSize: {
-			pixels: options.labelSizePixels,
-			zoom: options.labelSizeZoom,
-			resolution: options.labelSizeResolution
-		},
-		buildEndCaps: ({ p1, p2, dirFront, perpDir, frontLength }) => {
-			const halfTick = frontLength * tickLengthRatio / 2;
-			const tickAngleRad = tickAngle * Math.PI / 180;
-			const cosTick = Math.cos(tickAngleRad);
-			const sinTick = Math.sin(tickAngleRad);
-			const outwardDir = [-perpDir[0], -perpDir[1]];
-			const tick1Dir = vecAdd(vecScale(outwardDir, cosTick), vecScale(dirFront, -sinTick));
-			const tick1Start = vecAdd(p1, vecScale(tick1Dir, -halfTick));
-			const tick1End = vecAdd(p1, vecScale(tick1Dir, halfTick));
-			const tick2Dir = vecAdd(vecScale(outwardDir, cosTick), vecScale(dirFront, sinTick));
-			const tick2Start = vecAdd(p2, vecScale(tick2Dir, -halfTick));
-			const tick2End = vecAdd(p2, vecScale(tick2Dir, halfTick));
-			return [[unproject(tick1Start[0], tick1Start[1]), unproject(tick1End[0], tick1End[1])], [unproject(tick2Start[0], tick2Start[1]), unproject(tick2End[0], tick2End[1])]];
-		}
-	});
-}
-const BREACH = defineControlMeasure({
-	metadata: BREACH_METADATA,
-	generator: createBreachSymbol,
-	defaultOptions: DEFAULT_BREACH_OPTIONS,
-	rule: point12DrawRule
-});
-//#endregion
-//#region src/generators/cm34-mission-tasks/bypass.ts
-/**
-* Default options for the BYPASS symbol.
-*/
-const DEFAULT_BYPASS_OPTIONS = {
-	arrowHeadLengthRatio: .12,
-	labelGapRatio: .2
-};
-const BYPASS_METADATA = {
-	id: "bypass",
-	name: "Bypass",
-	description: "A tactical mission task in which a unit maneuvers around an obstacle, position, or enemy force to maintain the momentum of the operation.",
-	entity: "Mission Tasks",
-	entityType: "Bypass",
-	value: "340300",
-	minCoordinates: 3,
-	maxCoordinates: 3,
-	geometry: "line",
-	geometryTypes: ["MultiLineString", "Point"],
-	drawRule: "Point12",
-	capturesLabelSize: true,
-	params: [{
-		key: "arrowHeadLengthRatio",
-		label: "Arrowhead length",
-		description: "Length of the outward end chevrons, as a ratio of the front opening width.",
-		type: "number",
-		min: .01,
-		max: 1,
-		step: .01
-	}, {
-		key: "labelGapRatio",
-		label: "Label gap",
-		description: "Size of the rear-line gap holding the 'B' label, as a ratio of the front length.",
-		type: "number",
-		min: 0,
-		max: 1,
-		step: .01
-	}]
-};
-/**
-* Generates a GeoJSON FeatureCollection for a BYPASS mission task symbol (340300).
-*
-* A three-sided bracket (see {@link createBracketSymbol}) with a "B" label on
-* the rear line, whose front opening endpoints terminate in outward-flaring
-* chevron arrowheads instead of tick marks.
-*
-* @param coordinates - [PT. 1, PT. 2, PT. 3] as Position arrays
-* @param options - Configuration options
-* @returns GeoJSON FeatureCollection containing MultiLineString and Point features
-*/
-function createBypassSymbol(coordinates, options = {}) {
-	const arrowHeadLengthRatio = options.arrowHeadLengthRatio ?? DEFAULT_BYPASS_OPTIONS.arrowHeadLengthRatio;
-	return createBracketSymbol(coordinates, {
-		part: "bypass",
-		labelText: "B",
-		labelGapRatio: options.labelGapRatio ?? DEFAULT_BYPASS_OPTIONS.labelGapRatio,
-		labelSize: {
-			pixels: options.labelSizePixels,
-			zoom: options.labelSizeZoom,
-			resolution: options.labelSizeResolution
-		},
-		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)];
-		}
-	});
-}
-const BYPASS = defineControlMeasure({
-	metadata: BYPASS_METADATA,
-	generator: createBypassSymbol,
-	defaultOptions: DEFAULT_BYPASS_OPTIONS,
-	rule: point12DrawRule
-});
-//#endregion
-//#region src/generators/cm34-mission-tasks/canalize.ts
-/**
-* Default options for the CANALIZE symbol.
-*/
-const DEFAULT_CANALIZE_OPTIONS = {
-	tickLengthRatio: .15,
-	tickAngle: 45,
-	labelGapRatio: .2
-};
-const CANALIZE_METADATA = {
-	id: "canalize",
-	name: "Canalize",
-	description: "Canalize is a tactical mission task in which a unit restricts enemy movement to a narrow zone",
-	entity: "Mission Tasks",
-	entityType: "Canalize",
-	value: "340400",
-	minCoordinates: 3,
-	maxCoordinates: 3,
-	geometry: "line",
-	geometryTypes: ["MultiLineString", "Point"],
-	drawRule: "Point12",
-	capturesLabelSize: true,
-	params: [
-		{
-			key: "tickLengthRatio",
-			label: "Tick length",
-			description: "Length of the inward end ticks, as a ratio of the front opening width.",
-			type: "number",
-			min: .01,
-			max: 1,
-			step: .01
-		},
-		{
-			key: "tickAngle",
-			label: "Tick angle",
-			description: "Inward lean of the end ticks from perpendicular, in degrees.",
-			type: "number",
-			min: 0,
-			max: 90,
-			step: 1
-		},
-		{
-			key: "labelGapRatio",
-			label: "Label gap",
-			description: "Size of the rear-line gap holding the 'C' label, as a ratio of the front length.",
-			type: "number",
-			min: 0,
-			max: 1,
-			step: .01
-		}
-	]
-};
-/**
-* Generates a GeoJSON FeatureCollection for a CANALIZE mission task symbol (340400).
-*
-* A three-sided bracket (see {@link createBracketSymbol}) whose front opening
-* endpoints terminate in tick marks pointing **inward** (toward the rear "C"
-* line), opposite BREACH's outward-facing ticks.
-*
-* @param coordinates - [PT. 1, PT. 2, PT. 3] as Position arrays
-* @param options - Configuration options
-* @returns GeoJSON FeatureCollection containing MultiLineString and Point features
-*/
-function createCanalizeSymbol(coordinates, options = {}) {
-	const tickLengthRatio = options.tickLengthRatio ?? DEFAULT_CANALIZE_OPTIONS.tickLengthRatio;
-	const tickAngle = options.tickAngle ?? DEFAULT_CANALIZE_OPTIONS.tickAngle;
-	return createBracketSymbol(coordinates, {
-		part: "canalize",
-		labelText: "C",
-		labelGapRatio: options.labelGapRatio ?? DEFAULT_CANALIZE_OPTIONS.labelGapRatio,
-		labelSize: {
-			pixels: options.labelSizePixels,
-			zoom: options.labelSizeZoom,
-			resolution: options.labelSizeResolution
-		},
-		buildEndCaps: ({ p1, p2, dirFront, perpDir, frontLength }) => {
-			const halfTick = frontLength * tickLengthRatio / 2;
-			const tickAngleRad = tickAngle * Math.PI / 180;
-			const cosTick = Math.cos(tickAngleRad);
-			const sinTick = Math.sin(tickAngleRad);
-			const tick1Dir = vecAdd(vecScale(perpDir, cosTick), vecScale(dirFront, -sinTick));
-			const tick1Start = vecAdd(p1, vecScale(tick1Dir, -halfTick));
-			const tick1End = vecAdd(p1, vecScale(tick1Dir, halfTick));
-			const tick2Dir = vecAdd(vecScale(perpDir, cosTick), vecScale(dirFront, sinTick));
-			const tick2Start = vecAdd(p2, vecScale(tick2Dir, -halfTick));
-			const tick2End = vecAdd(p2, vecScale(tick2Dir, halfTick));
-			return [[unproject(tick1Start[0], tick1Start[1]), unproject(tick1End[0], tick1End[1])], [unproject(tick2Start[0], tick2Start[1]), unproject(tick2End[0], tick2End[1])]];
-		}
-	});
-}
-const CANALIZE = defineControlMeasure({
-	metadata: CANALIZE_METADATA,
-	generator: createCanalizeSymbol,
-	defaultOptions: DEFAULT_CANALIZE_OPTIONS,
-	rule: point12DrawRule
-});
-//#endregion
-//#region src/generators/cm34-mission-tasks/clear.ts
-/**
-* Default options for the CLEAR symbol.
-*/
-const DEFAULT_CLEAR_OPTIONS = {
-	arrowInsetRatio: .15,
-	arrowheadLengthRatio: .15,
-	arrowheadWidthRatio: .2,
-	labelGapRatio: .2
-};
-const CLEAR_METADATA = {
-	id: "clear",
-	name: "Clear",
-	description: "Clear is a tactical mission task that requires a unit to remove all enemy forces and eliminate organized resistance within an assigned area.",
-	entity: "Mission Tasks",
-	entityType: "Clear",
-	value: "340500",
-	minCoordinates: 3,
-	maxCoordinates: 3,
-	geometry: "line",
-	geometryTypes: ["MultiLineString", "Point"],
-	drawRule: "Line23",
-	capturesLabelSize: true,
-	params: [
-		{
-			key: "arrowInsetRatio",
-			label: "Arrow padding",
-			description: "Padding between the line endpoints and the outer arrows, as a ratio of height.",
-			type: "number",
-			min: 0,
-			max: .45,
-			step: .01
-		},
-		{
-			key: "arrowheadLengthRatio",
-			label: "Arrowhead length",
-			description: "Depth of each arrowhead toward the rear, as a ratio of the symbol height.",
-			type: "number",
-			min: .01,
-			max: 1,
-			step: .01
-		},
-		{
-			key: "arrowheadWidthRatio",
-			label: "Arrowhead width",
-			description: "Width of each arrowhead along the vertical line, as a ratio of the height.",
-			type: "number",
-			min: .01,
-			max: 1,
-			step: .01
-		},
-		{
-			key: "labelGapRatio",
-			label: "Label gap",
-			description: "Size of the shaft gap holding the 'C' label, as a ratio of the shaft length.",
-			type: "number",
-			min: 0,
-			max: 1,
-			step: .01
-		}
-	]
-};
-/**
-* Generates a GeoJSON FeatureCollection for a CLEAR mission task symbol (340500).
-*
-* A vertical line (PT. 1 → PT. 2) with three arrows pointing at it,
-* perpendicular to the line. The arrows come from the rear — the side PT. 3
-* sits on — and their tips touch the vertical line; each carries a shaft
-* reaching back to the rear. The arrows are evenly spaced along the line, so
-* the middle arrow's tip sits at the midpoint of the vertical line and its
-* shaft carries the 'C' glyph. The arrows stay perpendicular to the vertical
-* line at any rotation.
-*
-* Input Points:
-* - PT. 1: Top endpoint of the vertical line
-* - PT. 2: Bottom endpoint of the vertical line — defines height with PT. 1
-* - PT. 3: Rear point — defines the shaft length (and which side the arrows
-*   come from)
-*
-* @param coordinates - [PT. 1, PT. 2, PT. 3] as Position arrays
-* @param options - Configuration options
-* @returns GeoJSON FeatureCollection containing MultiLineString and Point features
-*/
-function createClearSymbol(coordinates, options = {}) {
-	const arrowInsetRatio = Math.min(.49, Math.max(0, options.arrowInsetRatio ?? DEFAULT_CLEAR_OPTIONS.arrowInsetRatio));
-	const arrowheadLengthRatio = options.arrowheadLengthRatio ?? DEFAULT_CLEAR_OPTIONS.arrowheadLengthRatio;
-	const arrowheadWidthRatio = options.arrowheadWidthRatio ?? DEFAULT_CLEAR_OPTIONS.arrowheadWidthRatio;
-	const labelGapRatio = options.labelGapRatio ?? DEFAULT_CLEAR_OPTIONS.labelGapRatio;
-	const [c1, c2, c3] = coordinates;
-	const p1 = project(c1[0], c1[1]);
-	const p2 = project(c2[0], c2[1]);
-	const p3 = project(c3[0], c3[1]);
-	const vLine = vecSub(p2, p1);
-	const height = vecMag(vLine);
-	if (height < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const dirLine = vecScale(vLine, 1 / height);
-	const midLine = vecScale(vecAdd(p1, p2), .5);
-	const rawPerp = [-dirLine[1], dirLine[0]];
-	const perpToRear = vecScale(rawPerp, vecDot(vecSub(p3, midLine), rawPerp) < 0 ? -1 : 1);
-	const shaftLength = Math.abs(vecDot(vecSub(p3, midLine), rawPerp));
-	const arrowDir = vecScale(perpToRear, -1);
-	const arrowheadLength = height * arrowheadLengthRatio;
-	const arrowheadWidth = height * arrowheadWidthRatio;
-	const tipAt = (t) => vecAdd(p1, vecScale(dirLine, t * height));
-	const lines = [[unproject(p1[0], p1[1]), unproject(p2[0], p2[1])]];
-	const fullTs = [
-		arrowInsetRatio,
-		.5,
-		1 - arrowInsetRatio
-	];
-	const labelIndex = 1;
-	fullTs.forEach((t, i) => {
-		const tip = tipAt(t);
-		const rearEnd = vecAdd(tip, vecScale(perpToRear, shaftLength));
-		if (i === labelIndex && shaftLength > 1e-6) {
-			const labelCenter = vecAdd(tip, vecScale(perpToRear, shaftLength * .5));
-			const gapHalf = shaftLength * labelGapRatio / 2;
-			const gapRear = vecAdd(labelCenter, vecScale(perpToRear, gapHalf));
-			const gapTip = vecAdd(labelCenter, vecScale(perpToRear, -gapHalf));
-			lines.push([unproject(rearEnd[0], rearEnd[1]), unproject(gapRear[0], gapRear[1])]);
-			lines.push([unproject(gapTip[0], gapTip[1]), unproject(tip[0], tip[1])]);
-		} else if (shaftLength > 1e-6) lines.push([unproject(rearEnd[0], rearEnd[1]), unproject(tip[0], tip[1])]);
-		lines.push(createArrowHead$1(tip, arrowDir, arrowheadLength, arrowheadWidth));
-	});
-	const mainFeature = {
-		type: "Feature",
-		properties: { part: "clear" },
-		geometry: {
-			type: "MultiLineString",
-			coordinates: lines
-		}
-	};
-	const lineRotation = Math.atan2(dirLine[1], dirLine[0]);
-	const renderedLabelRotation = Math.PI - (lineRotation - Math.PI / 2);
-	const labelRotation = normalizeRadians(Math.PI - keepTextLeftToRight(renderedLabelRotation));
-	const labelTip = tipAt(fullTs[labelIndex]);
-	return {
-		type: "FeatureCollection",
-		features: [mainFeature, createLabelFeature(shaftLength > 1e-6 ? vecAdd(labelTip, vecScale(perpToRear, shaftLength * .5)) : labelTip, "C", labelRotation, {
-			pixels: options.labelSizePixels,
-			zoom: options.labelSizeZoom,
-			resolution: options.labelSizeResolution
-		})]
-	};
-}
-const CLEAR = defineControlMeasure({
-	metadata: CLEAR_METADATA,
-	generator: createClearSymbol,
-	defaultOptions: DEFAULT_CLEAR_OPTIONS,
-	rule: line23DrawRule
-});
-//#endregion
-//#region src/generators/cm34-mission-tasks/delay.ts
-const DEFAULT_DELAY_OPTIONS = {
-	arrowheadLengthRatio: .12,
-	arrowheadWidthRatio: .12,
-	labelGapRatio: .18,
-	arcSegments: 32
-};
-const DELAY_METADATA = {
-	id: "delay",
-	name: "Delay",
-	description: "Delay is a tactical mission task in which a force under pressure trades space for time by slowing enemy momentum and inflicting maximum damage without becoming decisively engaged.",
-	entity: "Mission Tasks",
-	entityType: "Delay",
-	value: "340800",
-	minCoordinates: 3,
-	maxCoordinates: 3,
-	geometry: "line",
-	geometryTypes: ["MultiLineString", "Point"],
-	drawRule: "Line24",
-	capturesLabelSize: true,
-	params: [
-		{
-			key: "arrowheadLengthRatio",
-			label: "Arrowhead length",
-			description: "Depth of the arrowhead, as a ratio of the straight-line length.",
-			type: "number",
-			min: .01,
-			max: 1,
-			step: .01
-		},
-		{
-			key: "arrowheadWidthRatio",
-			label: "Arrowhead width",
-			description: "Width of the arrowhead, as a ratio of the straight-line length.",
-			type: "number",
-			min: .01,
-			max: 1,
-			step: .01
-		},
-		{
-			key: "labelGapRatio",
-			label: "Label gap",
-			description: "Size of the shaft gap holding the 'D' label, as a ratio of the shaft length.",
-			type: "number",
-			min: 0,
-			max: 1,
-			step: .01
-		},
-		{
-			key: "arcSegments",
-			label: "Arc segments",
-			description: "Number of straight segments used to approximate the semicircular arc.",
-			type: "number",
-			min: 4,
-			max: 96,
-			step: 1
-		}
-	]
-};
-function createDelaySymbol(coordinates, options = {}) {
-	const [c1, c2, c3] = coordinates;
-	const p1 = project(c1[0], c1[1]);
-	const p2 = project(c2[0], c2[1]);
-	const p3 = project(c3[0], c3[1]);
-	const line = vecSub(p2, p1);
-	const lineLength = vecMag(line);
-	if (lineLength < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const dirLine = vecScale(line, 1 / lineLength);
-	const diameterAxis = [dirLine[1], -dirLine[0]];
-	const signedDiameter = vecDot(vecSub(p3, p2), diameterAxis);
-	const diameterEnd = vecAdd(p2, vecScale(diameterAxis, signedDiameter));
-	const diameter = Math.abs(signedDiameter);
-	const gapHalf = lineLength * Math.min(1, Math.max(0, options.labelGapRatio ?? DEFAULT_DELAY_OPTIONS.labelGapRatio)) / 2;
-	const labelPoint = vecAdd(p1, vecScale(dirLine, lineLength / 2));
-	const gapStart = vecAdd(labelPoint, vecScale(dirLine, -gapHalf));
-	const gapEnd = vecAdd(labelPoint, vecScale(dirLine, gapHalf));
-	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))
-	];
-	if (diameter >= 1e-6) lines.push(createSemicircleArc(p2, diameterEnd, dirLine, options.arcSegments ?? DEFAULT_DELAY_OPTIONS.arcSegments));
-	const lineFeature = {
-		type: "Feature",
-		properties: { part: "delay" },
-		geometry: {
-			type: "MultiLineString",
-			coordinates: lines
-		}
-	};
-	const lineRotation = Math.atan2(dirLine[1], dirLine[0]);
-	return {
-		type: "FeatureCollection",
-		features: [lineFeature, createLabelFeature(labelPoint, "D", normalizeRadians(Math.PI + lineRotation), {
-			pixels: options.labelSizePixels,
-			zoom: options.labelSizeZoom,
-			resolution: options.labelSizeResolution
-		})]
-	};
-}
-function createSemicircleArc(start, end, bulgeDir, requestedSegments) {
-	const diameterVector = vecSub(end, start);
-	const diameter = vecMag(diameterVector);
-	if (diameter < 1e-6) return [unproject(start[0], start[1])];
-	const diameterDir = vecNorm(diameterVector);
-	const center = vecAdd(start, vecScale(diameterVector, .5));
-	const radius = diameter / 2;
-	const segments = Math.max(4, Math.round(requestedSegments));
-	const points = [];
-	for (let i = 0; i <= segments; i += 1) {
-		const theta = i / segments * Math.PI;
-		const point = vecAdd(center, vecAdd(vecScale(diameterDir, -Math.cos(theta) * radius), vecScale(bulgeDir, Math.sin(theta) * radius)));
-		points.push(unproject(point[0], point[1]));
-	}
-	return points;
-}
-const DELAY = defineControlMeasure({
-	metadata: DELAY_METADATA,
-	generator: createDelaySymbol,
-	defaultOptions: DEFAULT_DELAY_OPTIONS,
-	rule: line24DrawRule
-});
-//#endregion
-//#region src/internal/arrowhead.ts
-/**
-* Builds a closed, filled arrowhead triangle ring in unprojected coordinates.
-*
-* `tip` is the point of the arrow, `dir` the unit direction the arrow points,
-* `length` the distance from tip back to the base, and `width` the base width.
-* The returned ring is `[left, tip, right, left]`.
-*/
-function createArrowHeadRing(tip, dir, length, width) {
-	const perp = [-dir[1], dir[0]];
-	const base = vecSub(tip, vecScale(dir, length));
-	const left = vecAdd(base, vecScale(perp, width / 2));
-	const right = vecSub(base, vecScale(perp, width / 2));
-	return [
-		unproject(left[0], left[1]),
-		unproject(tip[0], tip[1]),
-		unproject(right[0], right[1]),
-		unproject(left[0], left[1])
-	];
-}
-//#endregion
-//#region src/generators/cm27-protection-areas/disrupt.ts
-const DEFAULT_DISRUPT_OPTIONS = {
-	middleArrowLengthRatio: .65,
-	bottomArrowLengthRatio: .45,
-	shaftLengthRatio: .65,
-	arrowHeadLengthRatio: .2,
-	arrowHeadWidthRatio: .2
-};
-const DISRUPT_METADATA = {
-	id: "disrupt",
-	name: "Disrupt",
-	description: "Obstacle effect that disrupts enemy tempo, delays movement, forces early breaching, and fragments attacks.",
-	entity: "Protection Areas",
-	entityType: "Obstacle Effects",
-	entitySubtype: "Disrupt",
-	value: "270502",
-	minCoordinates: 2,
-	geometry: "line",
-	geometryTypes: ["MultiLineString", "MultiPolygon"],
-	drawRule: "Area12",
-	params: [
-		{
-			key: "middleArrowLengthRatio",
-			label: "Middle arrow length",
-			description: "Middle arrow length as a ratio of the longest (top) arrow.",
-			type: "number",
-			min: .01,
-			max: 1,
-			step: .01
-		},
-		{
-			key: "bottomArrowLengthRatio",
-			label: "Bottom arrow length",
-			description: "Bottom arrow length as a ratio of the longest (top) arrow.",
-			type: "number",
-			min: .01,
-			max: 1,
-			step: .01
-		},
-		{
-			key: "shaftLengthRatio",
-			label: "Shaft length",
-			description: "Center shaft length as a ratio of the longest arrow, extending opposite.",
-			type: "number",
-			min: .01,
-			max: 1,
-			step: .01
-		},
-		{
-			key: "arrowHeadLengthRatio",
-			label: "Arrowhead length",
-			description: "Arrowhead length as a ratio of the longest arrow.",
-			type: "number",
-			min: .01,
-			max: 1,
-			step: .01
-		},
-		{
-			key: "arrowHeadWidthRatio",
-			label: "Arrowhead width",
-			description: "Arrowhead base width as a ratio of the longest arrow.",
-			type: "number",
-			min: .01,
-			max: 1,
-			step: .01
-		}
-	]
-};
-/**
-* Generates a GeoJSON FeatureCollection for a DISRUPT tactical symbol.
-*
-* Input:
-* - PT1: Top endpoint of the vertical spine
-* - PT2: Bottom endpoint of the vertical spine
-* - PT3: Reference point used to determine the longest-arrow offset
-*
-* Geometry:
-* - Spine: PT1 -> PT2
-* - PT2 -> PT1 defines the baseline orientation; arrow direction is constrained to its perpendicular axis
-* - PT3 is decomposed and projected onto the perpendicular axis through PT1 to derive a valid longest-arrow tip
-* - Three arrows placed at PT1, midpoint(PT1, PT2), and PT2
-* - Center shaft extends opposite arrow direction from midpoint with the same length as the middle arrow
-* - Top arrow is longest
-* - Middle and bottom arrows are proportional to the longest arrow
-* - Arrow heads are returned as filled triangle polygons
-*/
-function createDisrupt(coordinates, options = {}) {
-	const c1 = coordinates[0];
-	const c2 = coordinates[1];
-	const c3 = coordinates[2];
-	const middleArrowLengthRatio = options.middleArrowLengthRatio ?? DEFAULT_DISRUPT_OPTIONS.middleArrowLengthRatio;
-	const bottomArrowLengthRatio = options.bottomArrowLengthRatio ?? DEFAULT_DISRUPT_OPTIONS.bottomArrowLengthRatio;
-	const shaftLengthRatio = options.shaftLengthRatio ?? DEFAULT_DISRUPT_OPTIONS.shaftLengthRatio;
-	const arrowHeadLengthRatio = options.arrowHeadLengthRatio ?? DEFAULT_DISRUPT_OPTIONS.arrowHeadLengthRatio;
-	const arrowHeadWidthRatio = options.arrowHeadWidthRatio ?? DEFAULT_DISRUPT_OPTIONS.arrowHeadWidthRatio;
-	const p1 = project(c1[0], c1[1]);
-	const p2 = project(c2[0], c2[1]);
-	const v12 = vecSub(p2, p1);
-	const spineLength = vecMag(v12);
-	if (spineLength < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const spineDir = vecNorm(v12);
-	const normal = [spineDir[1], -spineDir[0]];
-	const spineMid = vecScale(vecAdd(p1, p2), .5);
-	let topArrowTip;
-	let longestArrowLength;
-	let arrowSideSign;
-	if (c3) {
-		const normalFromP1Raw = vecDot(vecSub(project(c3[0], c3[1]), p1), normal);
-		const hintedSign = normalFromP1Raw >= 0 ? 1 : -1;
-		let normalFromP1 = Number.isFinite(normalFromP1Raw) ? normalFromP1Raw : 0;
-		if (Math.abs(normalFromP1) < 1e-6) normalFromP1 = hintedSign * spineLength * 1.5;
-		topArrowTip = vecAdd(p1, vecScale(normal, normalFromP1));
-		const topVec = vecSub(topArrowTip, p1);
-		longestArrowLength = vecMag(topVec);
-		arrowSideSign = vecDot(topVec, normal) >= 0 ? 1 : -1;
-	} else {
-		longestArrowLength = spineLength * 1.5;
-		arrowSideSign = -1;
-		topArrowTip = vecAdd(p1, vecScale(normal, arrowSideSign * longestArrowLength));
-	}
-	if (longestArrowLength < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const arrowStarts = [
-		p1,
-		spineMid,
-		p2
-	];
-	const arrowLengthRatios = [
-		1,
-		middleArrowLengthRatio,
-		bottomArrowLengthRatio
-	];
-	const lines = [[unproject(p1[0], p1[1]), unproject(p2[0], p2[1])]];
-	const polygons = [];
-	const commonHeadLength = Math.max(longestArrowLength * arrowHeadLengthRatio, EPSILON);
-	const commonHeadWidth = Math.max(longestArrowLength * arrowHeadWidthRatio, EPSILON);
-	for (let i = 0; i < arrowStarts.length; i++) {
-		const start = arrowStarts[i];
-		const ratio = arrowLengthRatios[i];
-		const signedLength = arrowSideSign * longestArrowLength * ratio;
-		if (Math.abs(signedLength) < 1e-6) continue;
-		const tip = i === 0 ? topArrowTip : vecAdd(start, vecScale(normal, signedLength));
-		const dir = vecNorm(vecSub(tip, start));
-		const headBase = vecSub(tip, vecScale(dir, commonHeadLength));
-		lines.push([unproject(start[0], start[1]), unproject(headBase[0], headBase[1])]);
-		polygons.push([createArrowHeadRing(tip, dir, commonHeadLength, commonHeadWidth)]);
-	}
-	const shaftLengthSigned = arrowSideSign * longestArrowLength * shaftLengthRatio;
-	if (Math.abs(shaftLengthSigned) > 1e-6) {
-		const shaftStart = vecSub(spineMid, vecScale(normal, shaftLengthSigned));
-		lines.push([unproject(shaftStart[0], shaftStart[1]), unproject(spineMid[0], spineMid[1])]);
-	}
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {},
-			geometry: {
-				type: "MultiLineString",
-				coordinates: lines
-			}
-		}, {
-			type: "Feature",
-			properties: { fill: true },
-			geometry: {
-				type: "MultiPolygon",
-				coordinates: polygons
-			}
-		}]
-	};
-}
-const DISRUPT = defineControlMeasure({
-	metadata: DISRUPT_METADATA,
-	generator: createDisrupt,
-	defaultOptions: DEFAULT_DISRUPT_OPTIONS,
-	rule: disruptDrawRule
-});
-//#endregion
-//#region src/internal/field-of-fire.ts
-/**
-* Builds the open (stroked) arrowhead at the outward tip of one arm. The two
-* barbs are sized relative to that arm's own length, so each arm's head scales
-* independently (Line3 — arms vary independently). Returns `null` when the arm
-* has collapsed to zero length.
-*/
-function arrowheadAt(vertex, tip, hSize, hWidth) {
-	const v = vecSub(tip, vertex);
-	const armLength = vecMag(v);
-	if (armLength < 1e-6) return null;
-	const dir = vecNorm(v);
-	const perp = [-dir[1], dir[0]];
-	const headLength = armLength * hSize;
-	const halfWidth = headLength * hWidth;
-	const base = vecSub(tip, vecScale(dir, headLength));
-	return [
-		vecAdd(base, vecScale(perp, halfWidth)),
-		tip,
-		vecSub(base, vecScale(perp, halfWidth))
-	];
-}
-/**
-* Projects the vertex (PT 1) and up to two tips and builds the V of arms, each
-* arm ending in an open arrowhead. Renders one arm per tip, so two points
-* (vertex + one tip) draws the single arm being placed — the live feedback
-* after PT 1 — and three points draws the full V. Points beyond the third are
-* ignored (input contract, ADR-0014).
-*
-* Returns `null` if any arm is degenerate (collapsed to zero length), the
-* silent ADR-0014 empty-render signal.
-*/
-function buildFieldOfFireV(coordinates, hSize, hWidth) {
-	const vertexCoord = coordinates[0];
-	const vertex = project(vertexCoord[0], vertexCoord[1]);
-	const tips = coordinates.slice(1, 3).map((c) => project(c[0], c[1]));
-	const lines = [];
-	for (const tip of tips) {
-		const head = arrowheadAt(vertex, tip, hSize, hWidth);
-		if (!head) return null;
-		lines.push([vertex, tip], head);
-	}
-	return {
-		vertex,
-		tips,
-		lines
-	};
-}
-//#endregion
-//#region src/generators/cm14-maneuver-lines/finalProtectiveFire.ts
-const BLADE_LENGTH_FRACTION = .8;
-const DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS = {
-	hSize: .07,
-	hWidth: .67,
-	bladeHeight: .03
-};
-const FPF_SHARED = {
-	entity: "Maneuver Lines",
-	entityType: "Field of Fire",
-	minCoordinates: 2,
-	maxCoordinates: 3,
-	geometry: "line",
-	geometryTypes: ["MultiLineString", "Polygon"],
-	drawRule: "Line3",
-	params: [
-		{
-			key: "hSize",
-			label: "Head size",
-			description: "Arrowhead length as a fraction of each arm's length",
-			type: "number",
-			min: .01,
-			max: .5,
-			step: .01
-		},
-		{
-			key: "hWidth",
-			label: "Head width",
-			description: "Arrowhead wing spread relative to the arrowhead length",
-			type: "number",
-			min: .05,
-			max: 2,
-			step: .01
-		},
-		{
-			key: "bladeHeight",
-			label: "Blade height",
-			description: "Blade's perpendicular reach into the V, as a fraction of its arm's length",
-			type: "number",
-			min: .01,
-			max: .5,
-			step: .01
-		}
-	]
-};
-const FINAL_PROTECTIVE_FIRE_LEFT_METADATA = {
-	...FPF_SHARED,
-	id: "final-protective-fire-left",
-	name: "Final Protective Fire (Left)",
-	description: "An immediately available, prearranged barrier of fire designed to impede enemy movement across defensive lines or areas. The blade marks the left arm (PT 1 to PT 2).",
-	entitySubtype: "Final Protective Fire (Left)",
-	value: "140501"
-};
-const FINAL_PROTECTIVE_FIRE_RIGHT_METADATA = {
-	...FPF_SHARED,
-	id: "final-protective-fire-right",
-	name: "Final Protective Fire (Right)",
-	description: "An immediately available, prearranged barrier of fire designed to impede enemy movement across defensive lines or areas. The blade marks the right arm (PT 1 to PT 3).",
-	entitySubtype: "Final Protective Fire (Right)",
-	value: "140502"
-};
-/**
-* Builds the filled "blade": a uniform-width rectangle hugging the inside of
-* one arm. One long edge lies on the central 80% of the arm line (connected to
-* the line); the strip bulges perpendicularly into the inside of the V by
-* `bladeHeight * armLength`.
-*
-* @param vertex - PT 1, the shared vertex of the V (projected)
-* @param tip - the outward tip of the bladed arm (projected)
-* @param otherTip - the opposite arm's tip, used to find the "inside" side; may
-*   be undefined during live single-arm feedback, in which case a default side
-*   is chosen
-*/
-function bladeRectangle(vertex, tip, otherTip, bladeHeight) {
-	const v = vecSub(tip, vertex);
-	const armLength = vecMag(v);
-	if (armLength < 1e-6) return null;
-	const dir = vecNorm(v);
-	let perp = [-dir[1], dir[0]];
-	if (otherTip) {
-		const toOther = vecSub(otherTip, vertex);
-		if (vecDot(perp, toOther) < 0) perp = vecScale(perp, -1);
-	}
-	const gap = (1 - BLADE_LENGTH_FRACTION) / 2;
-	const onLineNear = vecAdd(vertex, vecScale(dir, armLength * gap));
-	const onLineFar = vecAdd(vertex, vecScale(dir, armLength * (1 - gap)));
-	const height = vecScale(perp, armLength * bladeHeight);
-	return [
-		onLineNear,
-		onLineFar,
-		vecAdd(onLineFar, height),
-		vecAdd(onLineNear, height)
-	];
-}
-/**
-* Generates a GeoJSON FeatureCollection for a FINAL PROTECTIVE FIRE tactical
-* symbol: the Principal-Direction-of-Fire "V" (arms + open arrowheads) plus a
-* filled blade along the inside of one arm.
-*
-* Renders one arm per tip, so two points (vertex + one tip) draws the single
-* arm being placed — the live feedback after PT 1 — and three points draws the
-* full V. Points beyond the third are ignored (input contract, ADR-0014).
-*
-* @param coordinates - [PT 1 (vertex), PT 2 (tip), PT 3 (tip)]
-* @param bladedArm - which arm carries the blade: 0 = PT 2 (left), 1 = PT 3 (right)
-* @param options - Arrowhead and blade sizing parameters
-*/
-function createFinalProtectiveFire(coordinates, bladedArm, options = {}) {
-	const { hSize, hWidth, bladeHeight } = {
-		...DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS,
-		...options
-	};
-	const v = buildFieldOfFireV(coordinates, Math.max(0, hSize), Math.max(0, hWidth));
-	if (!v) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const features = [{
-		type: "Feature",
-		properties: {},
-		geometry: {
-			type: "MultiLineString",
-			coordinates: v.lines.map((line) => line.map((c) => unproject(c[0], c[1])))
-		}
-	}];
-	const bladeTip = v.tips[bladedArm];
-	if (bladeTip) {
-		const otherTip = v.tips[bladedArm === 0 ? 1 : 0];
-		const blade = bladeRectangle(v.vertex, bladeTip, otherTip, Math.max(0, bladeHeight));
-		if (blade) {
-			const ring = [...blade, blade[0]].map((c) => unproject(c[0], c[1]));
-			features.push({
-				type: "Feature",
-				properties: {
-					part: "blade",
-					fill: true
-				},
-				geometry: {
-					type: "Polygon",
-					coordinates: [ring]
-				}
-			});
-		}
-	}
-	return {
-		type: "FeatureCollection",
-		features
-	};
-}
-function createFinalProtectiveFireLeft(coordinates, options = {}) {
-	return createFinalProtectiveFire(coordinates, 0, options);
-}
-function createFinalProtectiveFireRight(coordinates, options = {}) {
-	return createFinalProtectiveFire(coordinates, 1, options);
-}
-const FINAL_PROTECTIVE_FIRE_LEFT = defineControlMeasure({
-	metadata: FINAL_PROTECTIVE_FIRE_LEFT_METADATA,
-	generator: createFinalProtectiveFireLeft,
-	defaultOptions: DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS,
-	rule: line3DrawRule
-});
-const FINAL_PROTECTIVE_FIRE_RIGHT = defineControlMeasure({
-	metadata: FINAL_PROTECTIVE_FIRE_RIGHT_METADATA,
-	generator: createFinalProtectiveFireRight,
-	defaultOptions: DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS,
-	rule: line3DrawRule
-});
-//#endregion
-//#region src/generators/cm27-protection-areas/fix.ts
-const DEFAULT_FIX_OPTIONS = {
-	arrowHeadAngle: 35,
-	arrowHeadSizeRatio: .16,
-	endSegmentRatio: .2
-};
-const FIX_METADATA = {
-	id: "fix",
-	name: "Fix",
-	description: "Fix task symbol with zigzag shaft and open arrowhead.",
-	entity: "Protection Areas",
-	entityType: "Obstacle Effects",
-	entitySubtype: "Fix",
-	value: "270503",
-	minCoordinates: 2,
-	maxCoordinates: 2,
-	geometry: "line",
-	geometryTypes: ["MultiLineString"],
-	drawRule: "Line9",
-	params: [
-		{
-			key: "arrowHeadAngle",
-			label: "Arrowhead angle",
-			description: "Half-angle of the open arrowhead wings, in degrees.",
-			type: "number",
-			min: 0,
-			max: 90,
-			step: 1
-		},
-		{
-			key: "arrowHeadSizeRatio",
-			label: "Arrowhead size",
-			description: "Wing length as a ratio of the overall axis length.",
-			type: "number",
-			min: .01,
-			max: 1,
-			step: .01
-		},
-		{
-			key: "endSegmentRatio",
-			label: "End segment",
-			description: "Flat end segment length as a ratio of the axis (capped at 0.35).",
-			type: "number",
-			min: 0,
-			max: 1,
-			step: .01
-		}
-	]
-};
-/**
-* Generates a GeoJSON FeatureCollection for a FIX tactical symbol.
-*
-* Input:
-* - PT1: Arrow tip end
-* - PT2: Opposite end
-*
-* Notes:
-* - Requires exactly two points.
-* - Produces one MultiLineString feature containing the zigzag body and open arrowhead wings.
-*/
-function createFix(coordinates, options = {}) {
-	const c1 = coordinates[0];
-	const c2 = coordinates[1];
-	const arrowHeadAngle = options.arrowHeadAngle ?? DEFAULT_FIX_OPTIONS.arrowHeadAngle;
-	const arrowHeadSizeRatio = options.arrowHeadSizeRatio ?? DEFAULT_FIX_OPTIONS.arrowHeadSizeRatio;
-	const endSegmentRatio = options.endSegmentRatio ?? DEFAULT_FIX_OPTIONS.endSegmentRatio;
-	const pTip = project(c1[0], c1[1]);
-	const pTail = project(c2[0], c2[1]);
-	const axis = vecSub(pTip, pTail);
-	const axisLength = vecMag(axis);
-	if (axisLength < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const dir = vecNorm(axis);
-	const perp = [-dir[1], dir[0]];
-	const flatLength = Math.min(axisLength * endSegmentRatio, axisLength * .35);
-	const zigStart = vecAdd(pTail, vecScale(dir, flatLength));
-	const zigEnd = vecSub(pTip, vecScale(dir, flatLength));
-	const zigLength = vecMag(vecSub(zigEnd, zigStart));
-	if (zigLength < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const headLength = Math.max(axisLength * arrowHeadSizeRatio, EPSILON);
-	const headAngleRad = arrowHeadAngle * Math.PI / 180;
-	const amplitude = Math.max(Math.abs(headLength * Math.sin(headAngleRad)), EPSILON);
-	const zigP1 = vecAdd(zigStart, vecAdd(vecScale(dir, zigLength * .2), vecScale(perp, -amplitude)));
-	const zigP2 = vecAdd(zigStart, vecAdd(vecScale(dir, zigLength * .5), vecScale(perp, amplitude)));
-	const zigP3 = vecAdd(zigStart, vecAdd(vecScale(dir, zigLength * .8), vecScale(perp, -amplitude)));
-	const mainLine = [
-		unproject(pTail[0], pTail[1]),
-		unproject(zigStart[0], zigStart[1]),
-		unproject(zigP1[0], zigP1[1]),
-		unproject(zigP2[0], zigP2[1]),
-		unproject(zigP3[0], zigP3[1]),
-		unproject(zigEnd[0], zigEnd[1]),
-		unproject(pTip[0], pTip[1])
-	];
-	const backDir = vecScale(dir, -1);
-	const wing1Dir = rotate$1(backDir, headAngleRad);
-	const wing2Dir = rotate$1(backDir, -headAngleRad);
-	const wing1End = vecAdd(pTip, vecScale(wing1Dir, headLength));
-	const wing2End = vecAdd(pTip, vecScale(wing2Dir, headLength));
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {},
-			geometry: {
-				type: "MultiLineString",
-				coordinates: [
-					mainLine,
-					[unproject(pTip[0], pTip[1]), unproject(wing1End[0], wing1End[1])],
-					[unproject(pTip[0], pTip[1]), unproject(wing2End[0], wing2End[1])]
-				]
-			}
-		}]
-	};
-}
-function rotate$1(v, angle) {
-	const cosA = Math.cos(angle);
-	const sinA = Math.sin(angle);
-	return [v[0] * cosA - v[1] * sinA, v[0] * sinA + v[1] * cosA];
-}
-const FIX = defineControlMeasure({
-	metadata: FIX_METADATA,
-	generator: createFix,
-	defaultOptions: DEFAULT_FIX_OPTIONS,
-	rule: line9DrawRule
-});
-//#endregion
-//#region src/generators/cm14-maneuver-lines/flot.ts
-const DEFAULT_RADIUS = 50;
-const DEFAULT_RADIUS_PIXELS = 10;
-const DEFAULT_RESOLUTION = 16;
-/**
-* Default options for the FLOT graphic.
-*/
-const DEFAULT_FLOT_OPTIONS = {
-	radius: DEFAULT_RADIUS,
-	radiusPixels: DEFAULT_RADIUS_PIXELS,
-	resolution: DEFAULT_RESOLUTION
-};
-const FLOT_METADATA = {
-	id: "flot",
-	name: "Forward line of own troops (FLOT)",
-	description: "Indicates the most forward positions of friendly forces at a specific time.",
-	entity: "Maneuver Lines",
-	entityType: "Forward Line of Own Troops",
-	value: "140100",
-	minCoordinates: 2,
-	geometry: "line",
-	geometryTypes: ["LineString"],
-	drawRule: "Line1",
-	params: [
-		{
-			key: "radiusPixels",
-			label: "Radius",
-			description: "Radius of each scallop arc in screen pixels",
-			type: "number",
-			min: 5,
-			max: 50,
-			step: 1,
-			unit: "px"
-		},
-		{
-			key: "radius",
-			label: "Radius",
-			description: "Radius of each scallop arc in meters",
-			type: "number",
-			min: 1,
-			max: 500,
-			step: 1,
-			unit: "m"
-		},
-		{
-			key: "resolution",
-			label: "Resolution",
-			description: "Number of points used to render each semicircle",
-			type: "number",
-			min: 4,
-			max: 32,
-			step: 2
-		}
-	]
-};
-/**
-* Generates points for a true semicircle arc along a segment.
-*
-* The semicircle is centered at the midpoint of the diameter span,
-* with the specified radius. Points are generated by rotating
-* from PI to 0 around this center.
-*
-* @param startPoint - Start point of the arc on the segment
-* @param segmentDir - Direction vector of the segment (normalized)
-* @param perpDir - Perpendicular direction vector (normalized)
-* @param radius - Radius of the semicircle
-* @param resolution - Number of points in the arc
-* @param includeStart - Whether to include the start point
-* @returns Array of arc points forming a true semicircle
-*/
-function generateArcPoints(startPoint, segmentDir, perpDir, radius, resolution, includeStart) {
-	const points = [];
-	const startIndex = includeStart ? 0 : 1;
-	const center = vecAdd(startPoint, vecScale(segmentDir, radius));
-	for (let i = startIndex; i <= resolution; i++) {
-		const t = i / resolution;
-		const angle = Math.PI * (1 - t);
-		const alongSegment = Math.cos(angle) * radius;
-		const perpOffset = Math.sin(angle) * radius;
-		const point = vecAdd(vecAdd(center, vecScale(segmentDir, alongSegment)), vecScale(perpDir, perpOffset));
-		points.push(point);
-	}
-	return points;
-}
-/**
-* Processes a single segment between two positions, generating scalloped arcs.
-*
-* @param p1 - Start position (projected)
-* @param p2 - End position (projected)
-* @param radius - Radius of each semicircle
-* @param resolution - Points per arc
-* @param isFirstSegment - Whether this is the first segment (include start point)
-* @returns Array of points forming the scalloped line for this segment
-*/
-function processSegment(p1, p2, radius, resolution, isFirstSegment) {
-	const segmentVec = vecSub(p2, p1);
-	const segmentLength = vecMag(segmentVec);
-	if (segmentLength < 1e-6) return isFirstSegment ? [p1] : [];
-	const segmentDir = vecNorm(segmentVec);
-	const perpDir = [-segmentDir[1], segmentDir[0]];
-	const points = [];
-	const diameter = 2 * radius;
-	const numFullArcs = Math.floor(segmentLength / diameter);
-	const remainingLength = segmentLength - numFullArcs * diameter;
-	let currentPos = p1;
-	for (let arcIndex = 0; arcIndex < numFullArcs; arcIndex++) {
-		const arcPoints = generateArcPoints(currentPos, segmentDir, perpDir, radius, resolution, arcIndex === 0 && isFirstSegment);
-		points.push(...arcPoints);
-		currentPos = vecAdd(currentPos, vecScale(segmentDir, diameter));
-	}
-	if (remainingLength > diameter * .1) {
-		const partialRadius = remainingLength / 2;
-		const partialResolution = Math.max(3, Math.round(resolution * (partialRadius / radius)));
-		const arcPoints = generateArcPoints(currentPos, segmentDir, perpDir, partialRadius, partialResolution, numFullArcs === 0 && isFirstSegment);
-		points.push(...arcPoints);
-	}
-	return points;
-}
-/**
-* Creates a FLOT (Forward Line of Own Troops) tactical graphic.
-*
-* Generates a scalloped/arc line representing the forward edge of friendly forces.
-* The line consists of semi-circular arcs that bulge perpendicular to the base path,
-* creating a distinctive visual pattern used in military tactical graphics.
-*
-* @param positions - Array of GeoJSON positions defining the base path
-* @param options - Configuration options for the graphic
-* @returns A GeoJSON FeatureCollection containing the scalloped LineString
-*
-* @example
-* ```typescript
-* const flot = createFLOT(
-*   [[-122.4194, 37.7749], [-122.4100, 37.7800], [-122.4000, 37.7750]],
-*   { radius: 100, resolution: 20 }
-* );
-* ```
-*/
-function createFLOT(positions, options = {}) {
-	const { radius = DEFAULT_RADIUS, radiusPixels, metersPerPixel, resolution = DEFAULT_RESOLUTION } = options;
-	let effectiveRadius = radius;
-	if (radiusPixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0) effectiveRadius = radiusPixels * metersPerPixel;
-	const safeRadius = Math.max(EPSILON, effectiveRadius);
-	const safeResolution = Math.max(3, Math.round(resolution));
-	const projectedPoints = positions.map((p) => project(p[0], p[1]));
-	const allPoints = [];
-	for (let i = 0; i < projectedPoints.length - 1; i++) {
-		const p1 = projectedPoints[i];
-		const p2 = projectedPoints[i + 1];
-		const segmentPoints = processSegment(p1, p2, safeRadius, safeResolution, i === 0);
-		allPoints.push(...segmentPoints);
-	}
-	if (allPoints.length > 0 && projectedPoints.length > 1) {
-		const lastOriginal = projectedPoints[projectedPoints.length - 1];
-		const lastGenerated = allPoints[allPoints.length - 1];
-		if (vecMag(vecSub(lastOriginal, lastGenerated)) > 1e-6) allPoints.push(lastOriginal);
-	}
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {},
-			geometry: {
-				type: "LineString",
-				coordinates: allPoints.map((p) => unproject(p[0], p[1]))
-			}
-		}]
-	};
-}
-const FLOT = defineControlMeasure({
-	metadata: FLOT_METADATA,
-	generator: createFLOT,
-	defaultOptions: DEFAULT_FLOT_OPTIONS,
-	rule: line1DrawRule
-});
-//#endregion
-//#region src/generators/cm29-protection-lines/fortifiedLine.ts
-const DEFAULT_SIZE = 50;
-/**
-* Default options for the Fortified Line graphic.
-*/
-const DEFAULT_FORTIFIED_LINE_OPTIONS = {
-	size: DEFAULT_SIZE,
-	sizePixels: 10
-};
-const FORTIFIED_LINE_METADATA = {
-	id: "fortified-line",
-	name: "Fortified Line",
-	description: "Fortified line with castellated square-wave boundary.",
-	entity: "Protection Lines",
-	entityType: "Fortified Line",
-	value: "290900",
-	minCoordinates: 2,
-	geometry: "line",
-	geometryTypes: ["LineString"],
-	drawRule: "Line1",
-	params: FORTIFIED_PARAMS
-};
-/**
-* Generates points for a square wave "tooth" along a segment.
-*
-* A tooth consists of:
-* 1. Move along segment by length/4 (flat)
-* 2. Move out perpendicular by height (rise)
-* 3. Move along segment direction by length/2 (top)
-* 4. Move back perpendicular by height (drop)
-* 5. Move along segment by length/4 (flat)
-*
-* Original 'size' logic (where length=2*size, height=size):
-* - Flat1: size/2 = length/4
-* - Rise: size = height
-* - Top: size = length/2
-* - Drop: size = height
-* - Flat2: size/2 = length/4
-*
-* Total length consumed on segment = length
-*
-* @param startPoint - Start point of the tooth on the segment
-* @param segmentDir - Direction vector of the segment (normalized)
-* @param perpDir - Perpendicular direction vector (normalized)
-* @param length - Length of the tooth along the segment (period)
-* @param height - Height of the tooth (amplitude)
-* @returns Array of points forming a square tooth
-*/
-function generateSquareToothPoints(startPoint, segmentDir, perpDir, length, height) {
-	const points = [];
-	const p1 = vecAdd(startPoint, vecScale(segmentDir, length / 4));
-	points.push(p1);
-	const p2 = vecAdd(p1, vecScale(perpDir, height));
-	points.push(p2);
-	const p3 = vecAdd(p2, vecScale(segmentDir, length / 2));
-	points.push(p3);
-	const p4 = vecAdd(p3, vecScale(perpDir, -height));
-	points.push(p4);
-	return points;
-}
-/**
-* Processes a single segment between two positions, generating square waves.
-*
-* @param p1 - Start position (projected)
-* @param p2 - End position (projected)
-* @param size - Size (height) of the square teeth. Also used for target length (2*size).
-* @param isFirstSegment - Whether this is the first segment (include start point)
-* @returns Array of points forming the castellated line for this segment
-*/
-function processFortifiedSegment(p1, p2, size, isFirstSegment) {
-	const segmentVec = vecSub(p2, p1);
-	const segmentLength = vecMag(segmentVec);
-	if (segmentLength < 1e-6) return isFirstSegment ? [p1] : [];
-	const segmentDir = vecNorm(segmentVec);
-	const perpDir = [-segmentDir[1], segmentDir[0]];
-	const points = [];
-	if (isFirstSegment) points.push(p1);
-	const targetPeriod = 2 * size;
-	let numFullPeriods = Math.round(segmentLength / targetPeriod);
-	if (numFullPeriods < 1) numFullPeriods = 1;
-	const actualPeriod = segmentLength / numFullPeriods;
-	const height = size;
-	let currentPos = p1;
-	for (let i = 0; i < numFullPeriods; i++) {
-		const toothPoints = generateSquareToothPoints(currentPos, segmentDir, perpDir, actualPeriod, height);
-		points.push(...toothPoints);
-		currentPos = vecAdd(currentPos, vecScale(segmentDir, actualPeriod));
-		points.push(currentPos);
-	}
-	return points;
-}
-/**
-* Calculates the effective size based on options and projection.
-*/
-function calculateEffectiveSize(options) {
-	const { size = DEFAULT_SIZE, sizePixels, metersPerPixel } = options;
-	let effectiveSize = size;
-	if (sizePixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0) effectiveSize = sizePixels * metersPerPixel;
-	return Math.max(EPSILON, effectiveSize);
-}
-/**
-* Generates the raw points for a fortified line/area boundary.
-*/
-function generateFortifiedPoints(projectedPoints, effectiveSize) {
-	const allPoints = [];
-	for (let i = 0; i < projectedPoints.length - 1; i++) {
-		const p1 = projectedPoints[i];
-		const p2 = projectedPoints[i + 1];
-		const segmentPoints = processFortifiedSegment(p1, p2, effectiveSize, i === 0);
-		allPoints.push(...segmentPoints);
-	}
-	if (allPoints.length > 0 && projectedPoints.length > 1) {
-		const lastOriginal = projectedPoints[projectedPoints.length - 1];
-		const lastGenerated = allPoints[allPoints.length - 1];
-		if (vecMag(vecSub(lastOriginal, lastGenerated)) > 1e-6) allPoints.push(lastOriginal);
-	}
-	return allPoints;
-}
-/**
-* Creates a Fortified Line tactical graphic.
-*
-* Generates a castellated/square-wave line representing a fortified line.
-* The line consists of square "teeth" that project perpendicular to the base path.
-*
-* @param positions - Array of GeoJSON positions defining the base path
-* @param options - Configuration options for the graphic
-* @returns A GeoJSON FeatureCollection containing the castellated LineString
-*/
-function createFortifiedLine(positions, options = {}) {
-	const safeSize = calculateEffectiveSize(options);
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {},
-			geometry: {
-				type: "LineString",
-				coordinates: generateFortifiedPoints(positions.map((p) => project(p[0], p[1])), safeSize).map((p) => unproject(p[0], p[1]))
-			}
-		}]
-	};
-}
-const FORTIFIED_LINE = defineControlMeasure({
-	metadata: FORTIFIED_LINE_METADATA,
-	generator: createFortifiedLine,
-	defaultOptions: DEFAULT_FORTIFIED_LINE_OPTIONS,
-	rule: line1DrawRule
-});
-//#endregion
-//#region src/generators/cm15-maneuver-areas/fortifiedArea.ts
-const DEFAULT_FORTIFIED_AREA_OPTIONS = DEFAULT_FORTIFIED_LINE_OPTIONS;
-const FORTIFIED_AREA_METADATA = {
-	id: "fortified-area",
-	name: "Fortified Area",
-	description: "A specified geographical locality with constructed defensive works as protection against attack.",
-	entity: "Maneuver Areas",
-	entityType: "Fortified Area",
-	value: "151000",
-	minCoordinates: 3,
-	geometry: "area",
-	geometryTypes: ["Polygon"],
-	drawRule: "Area1",
-	params: FORTIFIED_PARAMS$1
-};
-/**
-* Creates a Fortified Area tactical graphic.
-*
-* Generates a polygon with a castellated/square-wave boundary representing a fortified area.
-* The boundary consists of square "teeth" that project perpendicular to the path.
-*
-* @param positions - Array of GeoJSON positions defining the area boundary.
-*                    The first and last positions should match to close the polygon,
-*                    or it will be closed automatically.
-* @param options - Configuration options for the graphic
-* @returns A GeoJSON FeatureCollection containing the castellated Polygon
-*/
-function createFortifiedArea(positions, options = {}) {
-	const safeSize = calculateEffectiveSize(options);
-	const validPositions = positions;
-	const first = validPositions[0];
-	const last = validPositions[validPositions.length - 1];
-	const boundaryPoints = generateFortifiedPoints((Math.abs(first[0] - last[0]) < Number.EPSILON && Math.abs(first[1] - last[1]) < Number.EPSILON ? validPositions : [...validPositions, first]).map((p) => project(p[0], p[1])), safeSize);
-	if (boundaryPoints.length > 0) {
-		const firstPt = boundaryPoints[0];
-		const lastPt = boundaryPoints[boundaryPoints.length - 1];
-		if (vecMag(vecSub(firstPt, lastPt)) > 1e-6) boundaryPoints.push(firstPt);
-		else boundaryPoints[boundaryPoints.length - 1] = firstPt;
-	}
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {},
-			geometry: {
-				type: "Polygon",
-				coordinates: [boundaryPoints.map((p) => unproject(p[0], p[1]))]
-			}
-		}]
-	};
-}
-const FORTIFIED_AREA = defineControlMeasure({
-	metadata: FORTIFIED_AREA_METADATA,
-	generator: createFortifiedArea,
-	defaultOptions: DEFAULT_FORTIFIED_AREA_OPTIONS
-});
-//#endregion
-//#region src/generators/cm34-mission-tasks/isolate.ts
-/**
-* Default options for the ISOLATE symbol.
-*/
-const DEFAULT_ISOLATE_OPTIONS = {
-	openingDegrees: 30,
-	barbCount: 9,
-	barbLengthRatio: .18
-};
-const ISOLATE_METADATA = {
-	id: "isolate",
-	name: "Isolate",
-	description: "Isolate is a tactical mission task in which a unit seals off an enemy, physically and psychologically, from sources of support and denies it freedom of movement.",
-	entity: "Mission Tasks",
-	entityType: "Isolate",
-	value: "341500",
-	minCoordinates: 2,
-	maxCoordinates: 2,
-	geometry: "line",
-	geometryTypes: ["MultiLineString"],
-	drawRule: "Area15",
-	params: [
-		{
-			key: "openingDegrees",
-			label: "Opening",
-			description: "Angular width of the gap on the friendly side, in degrees.",
-			type: "number",
-			min: 0,
-			max: 180,
-			step: 1
-		},
-		{
-			key: "barbCount",
-			label: "Barbs",
-			description: "Number of inward-pointing barbs spaced along the closed arc.",
-			type: "number",
-			min: 1,
-			max: 24,
-			step: 1
-		},
-		{
-			key: "barbLengthRatio",
-			label: "Barb length",
-			description: "Length of each inward barb, as a ratio of the symbol radius.",
-			type: "number",
-			min: .01,
-			max: 1,
-			step: .01
-		}
-	]
-};
-/**
-* Generates a GeoJSON FeatureCollection for an ISOLATE mission task symbol (341500).
-*
-* A near-complete circle centered on PT. 1 whose radius reaches PT. 2. The arc
-* starts (bare) at PT. 2's bearing and sweeps clockwise around the closed
-* portion to a single arrow tip at the far end; the wedge-shaped gap (default
-* 30°) between that arrow tip and PT. 2 is the opening — the "friendly side".
-* Inward-pointing arrowhead barbs are spaced along the closed arc, set in from
-* both ends so they never touch PT. 2 or the arrow tip, conveying the
-* sealing-off of the enclosed force. Unlike the bracket mission tasks, isolate
-* carries no glyph label.
-*
-* Input Points:
-* - PT. 1: Center point
-* - PT. 2: Start point — fixes the radius and the bearing of the opening
-*
-* @param coordinates - [PT. 1, PT. 2] as Position arrays
-* @param options - Configuration options
-* @returns GeoJSON FeatureCollection containing a single MultiLineString feature
-*/
-function createIsolateSymbol(coordinates, options = {}) {
-	const openingDegrees = options.openingDegrees ?? DEFAULT_ISOLATE_OPTIONS.openingDegrees;
-	const barbCount = options.barbCount ?? DEFAULT_ISOLATE_OPTIONS.barbCount;
-	const barbLengthRatio = options.barbLengthRatio ?? DEFAULT_ISOLATE_OPTIONS.barbLengthRatio;
-	const center = project(coordinates[0][0], coordinates[0][1]);
-	const vRadius = vecSub(project(coordinates[1][0], coordinates[1][1]), center);
-	const radius = vecMag(vRadius);
-	if (radius < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const startAngle = Math.atan2(vRadius[1], vRadius[0]);
-	const openingRad = Math.min(Math.max(openingDegrees, 0), 359) * Math.PI / 180;
-	const arcSpan = 2 * Math.PI - openingRad;
-	const endAngle = startAngle - arcSpan;
-	const pointOnCircle = (angle, r = radius) => vecAdd(center, [r * Math.cos(angle), r * Math.sin(angle)]);
-	const segments = Math.max(8, Math.round(64 * arcSpan / (2 * Math.PI)));
-	const arc = [];
-	for (let i = 0; i <= segments; i++) {
-		const p = pointOnCircle(startAngle - arcSpan * i / segments);
-		arc.push(unproject(p[0], p[1]));
-	}
-	const barbLength = radius * barbLengthRatio;
-	const lines = [arc];
-	const tipDir = [Math.sin(endAngle), -Math.cos(endAngle)];
-	lines.push(createArrowHead$1(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);
-	for (let k = 1; k <= steps; k++) {
-		const angle = startAngle - arcSpan * k / (steps + 1);
-		const left = pointOnCircle(angle - halfWidth);
-		const right = pointOnCircle(angle + halfWidth);
-		const tip = pointOnCircle(angle, tipRadius);
-		lines.push([
-			unproject(left[0], left[1]),
-			unproject(tip[0], tip[1]),
-			unproject(right[0], right[1])
-		]);
-	}
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: { part: "isolate" },
-			geometry: {
-				type: "MultiLineString",
-				coordinates: lines
-			}
-		}]
-	};
-}
-const ISOLATE = defineControlMeasure({
-	metadata: ISOLATE_METADATA,
-	generator: createIsolateSymbol,
-	defaultOptions: DEFAULT_ISOLATE_OPTIONS,
-	rule: isolateDrawRule
-});
-//#endregion
-//#region src/generators/cm15-maneuver-areas/mainAttack.ts
-const DEFAULT_MAIN_ATTACK_OPTIONS = {
-	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO,
-	roundedBends: false,
-	bendSegments: 5
-};
-const MAIN_ATTACK_METADATA = {
-	id: "main-attack",
-	name: "Main Attack",
-	description: "Primary offensive attack graphic.",
-	entity: "Maneuver Areas",
-	entityType: "Axis of Advance",
-	entitySubtype: "Main Attack",
-	value: "151403",
-	minCoordinates: 3,
-	geometry: "line",
-	geometryTypes: ["MultiLineString"],
-	drawRule: "Axis1",
-	params: ATTACK_SHAFT_PARAMS
-};
-/**
-* Generates a GeoJSON FeatureCollection for a Main Attack tactical symbol.
-*
-* The symbol consists of a single MultiLineString feature containing:
-* 1. **Arrowhead**: A line forming a "chevron" or "roof" shape.
-* 2. **Shaft**: Two parallel lines behind the arrow.
-*
-* The shaft is calculated to terminate exactly where it touches the inner walls
-* of the arrowhead, creating a seamless connection.
-*
-* @param coordinates - An array of GeoJSON Positions (Lon/Lat).
-* Minimum 3 points required.
-* **Order matters:** * - Index 0: **Tip** (The sharp point of the arrow)
-* - Index 1 to N-2: **Spine** (The path the shaft follows)
-* - Index N-1: **Width Control** (Determines the width of the arrowhead)
-* @param options - Configuration for ratios and properties.
-* @returns A GeoJSON FeatureCollection containing a single MultiLineString.
-*/
-function createMainAttack(coordinates, options = {}) {
-	const { geometry } = processAttackGeometry(coordinates, options);
-	if (!geometry) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {},
-			geometry: {
-				type: "MultiLineString",
-				coordinates: [
-					geometry.shaftLeft.map((p) => unproject(p[0], p[1])),
-					geometry.shaftRight.map((p) => unproject(p[0], p[1])),
-					geometry.headRing.map((p) => unproject(p[0], p[1]))
-				]
-			}
-		}]
-	};
-}
-const MAIN_ATTACK = defineControlMeasure({
-	metadata: MAIN_ATTACK_METADATA,
-	generator: createMainAttack,
-	defaultOptions: DEFAULT_MAIN_ATTACK_OPTIONS,
-	rule: axis1DrawRule
-});
-//#endregion
-//#region src/generators/cm27-protection-areas/params.ts
-const OBSTACLE_BYPASS_PARAMS = [
-	{
-		key: "arrowHeadLengthRatio",
-		label: "Arrowhead length",
-		description: "Arrowhead length as a ratio of the opening width.",
-		type: "number",
-		min: .05,
-		max: 1,
-		step: .01
-	},
-	{
-		key: "arrowHeadWidthRatio",
-		label: "Arrowhead width",
-		description: "Arrowhead base width as a ratio of the opening width.",
-		type: "number",
-		min: .05,
-		max: 1,
-		step: .01
-	},
-	{
-		key: "defaultLengthRatio",
-		label: "Default length",
-		description: "Symbol depth as a ratio of opening width when no hint point is given.",
-		type: "number",
-		min: .1,
-		max: 4,
-		step: .05
-	}
-];
-//#endregion
-//#region src/generators/cm27-protection-areas/obstacleBypassDifficult.ts
-const DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS = {
-	arrowHeadLengthRatio: .2,
-	arrowHeadWidthRatio: .2,
-	defaultLengthRatio: 1.5,
-	zigzagAmplitudeRatio: .12,
-	zigzagSpacingRatio: .18
-};
-const OBSTACLE_BYPASS_DIFFICULT_METADATA = {
-	id: "obstacle-bypass-difficult",
-	name: "Obstacle Bypass Difficult",
-	description: "Obstacle bypass (difficult) with zigzag rear line and arrowheads.",
-	entity: "Protection Areas",
-	entityType: "Obstacle Bypass",
-	entitySubtype: "Difficult",
-	value: "270602",
-	minCoordinates: 2,
-	geometry: "line",
-	geometryTypes: ["MultiLineString", "MultiPolygon"],
-	drawRule: "Point12",
-	params: [
-		...OBSTACLE_BYPASS_PARAMS,
-		{
-			key: "zigzagAmplitudeRatio",
-			label: "Zigzag amplitude",
-			description: "Zigzag tooth depth as a ratio of the opening width.",
-			type: "number",
-			min: .01,
-			max: 1,
-			step: .01
-		},
-		{
-			key: "zigzagSpacingRatio",
-			label: "Zigzag spacing",
-			description: "Spacing between zigzag teeth as a ratio of the opening width.",
-			type: "number",
-			min: .01,
-			max: 1,
-			step: .01
-		}
-	]
-};
-function createObstacleBypassDifficult(coordinates, options = {}) {
-	const c1 = coordinates[0];
-	const c2 = coordinates[1];
-	const c3 = coordinates[2];
-	const arrowHeadLengthRatio = options.arrowHeadLengthRatio ?? DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS.arrowHeadLengthRatio;
-	const arrowHeadWidthRatio = options.arrowHeadWidthRatio ?? DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS.arrowHeadWidthRatio;
-	const defaultLengthRatio = options.defaultLengthRatio ?? DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS.defaultLengthRatio;
-	const zigzagAmplitudeRatio = options.zigzagAmplitudeRatio ?? DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS.zigzagAmplitudeRatio;
-	const zigzagSpacingRatio = options.zigzagSpacingRatio ?? DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS.zigzagSpacingRatio;
-	const p1 = project(c1[0], c1[1]);
-	const p2 = project(c2[0], c2[1]);
-	const openingVec = vecSub(p2, p1);
-	const openingLength = vecMag(openingVec);
-	if (openingLength < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const openingDir = vecNorm(openingVec);
-	const railDir = [openingDir[1], -openingDir[0]];
-	const openingMid = vecScale(vecAdd(p1, p2), .5);
-	let signedLength;
-	if (c3) {
-		const rawSignedLength = vecDot(vecSub(project(c3[0], c3[1]), openingMid), railDir);
-		if (Math.abs(rawSignedLength) < 1e-6) signedLength = (rawSignedLength >= 0 ? 1 : -1) * openingLength * defaultLengthRatio;
-		else signedLength = rawSignedLength;
-	} else signedLength = openingLength * defaultLengthRatio;
-	if (Math.abs(signedLength) < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const rearMid = vecAdd(openingMid, vecScale(railDir, signedLength));
-	const halfOpening = vecScale(openingDir, openingLength / 2);
-	const rearTop = vecSub(rearMid, halfOpening);
-	const rearBottom = vecAdd(rearMid, halfOpening);
-	const arrowHeadLength = Math.max(openingLength * arrowHeadLengthRatio, EPSILON);
-	const arrowHeadWidth = Math.max(openingLength * arrowHeadWidthRatio, EPSILON);
-	const topDir = vecNorm(vecSub(p1, rearTop));
-	const topHeadBase = vecSub(p1, vecScale(topDir, arrowHeadLength));
-	const bottomDir = vecNorm(vecSub(p2, rearBottom));
-	const bottomHeadBase = vecSub(p2, vecScale(bottomDir, arrowHeadLength));
-	const lineSegments = [
-		createZigzagRear(rearTop, rearBottom, vecScale(railDir, signedLength >= 0 ? -1 : 1), openingLength, zigzagAmplitudeRatio, zigzagSpacingRatio).map((point) => unproject(point[0], point[1])),
-		[unproject(rearTop[0], rearTop[1]), unproject(topHeadBase[0], topHeadBase[1])],
-		[unproject(rearBottom[0], rearBottom[1]), unproject(bottomHeadBase[0], bottomHeadBase[1])]
-	];
-	const polygonRings = [[createArrowHeadRing(p1, topDir, arrowHeadLength, arrowHeadWidth)], [createArrowHeadRing(p2, bottomDir, arrowHeadLength, arrowHeadWidth)]];
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {},
-			geometry: {
-				type: "MultiLineString",
-				coordinates: lineSegments
-			}
-		}, {
-			type: "Feature",
-			properties: { fill: true },
-			geometry: {
-				type: "MultiPolygon",
-				coordinates: polygonRings
-			}
-		}]
-	};
-}
-function createZigzagRear(rearTop, rearBottom, inwardDir, openingLength, amplitudeRatio, spacingRatio) {
-	const axis = vecSub(rearBottom, rearTop);
-	const axisLength = vecMag(axis);
-	if (axisLength < 1e-6) return [rearTop, rearBottom];
-	const axisDir = vecNorm(axis);
-	const amplitude = Math.max(openingLength * amplitudeRatio, EPSILON);
-	const spacing = Math.max(openingLength * spacingRatio, EPSILON * 10);
-	const teeth = Math.max(2, Math.round(axisLength / spacing));
-	const step = axisLength / teeth;
-	const points = [rearTop];
-	for (let i = 0; i < teeth; i += 1) {
-		const mid = vecAdd(rearTop, vecAdd(vecScale(axisDir, step * (i + .5)), vecScale(inwardDir, amplitude)));
-		const base = vecAdd(rearTop, vecScale(axisDir, step * (i + 1)));
-		points.push(mid, base);
-	}
-	return points;
-}
-const OBSTACLE_BYPASS_DIFFICULT = defineControlMeasure({
-	metadata: OBSTACLE_BYPASS_DIFFICULT_METADATA,
-	generator: createObstacleBypassDifficult,
-	defaultOptions: DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS,
-	rule: point12DrawRule
-});
-//#endregion
-//#region src/generators/cm27-protection-areas/obstacleBypassEasy.ts
-const DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS = {
-	arrowHeadLengthRatio: .2,
-	arrowHeadWidthRatio: .2,
-	defaultLengthRatio: 1.5
-};
-const OBSTACLE_BYPASS_EASY_METADATA = {
-	id: "obstacle-bypass-easy",
-	name: "Obstacle Bypass Easy",
-	description: "Obstacle bypass (easy) with parallel rails and two arrowheads.",
-	entity: "Protection Areas",
-	entityType: "Obstacle Bypass",
-	entitySubtype: "Easy",
-	value: "270601",
-	minCoordinates: 2,
-	geometry: "line",
-	geometryTypes: ["MultiLineString", "MultiPolygon"],
-	drawRule: "Point12",
-	params: OBSTACLE_BYPASS_PARAMS
-};
-/**
-* Generates a GeoJSON FeatureCollection for an "Obstacle Bypass Easy" symbol.
-*
-* Input:
-* - PT1 and PT2 define the tips of the two arrowheads (opening and symbol height)
-* - PT3 defines signed symbol length along the perpendicular axis through midpoint(PT1, PT2)
-*
-* Geometry:
-* - Rear line is parallel to opening(PT1-PT2) and has equal length
-* - Two side rails run from rear endpoints to the arrowheads and are parallel to each other
-* - Rear line is perpendicular to both side rails
-* - Arrow heads are filled triangle polygons at PT1 and PT2
-*/
-function createObstacleBypassEasy(coordinates, options = {}) {
-	const c1 = coordinates[0];
-	const c2 = coordinates[1];
-	const c3 = coordinates[2];
-	const arrowHeadLengthRatio = options.arrowHeadLengthRatio ?? DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS.arrowHeadLengthRatio;
-	const arrowHeadWidthRatio = options.arrowHeadWidthRatio ?? DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS.arrowHeadWidthRatio;
-	const defaultLengthRatio = options.defaultLengthRatio ?? DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS.defaultLengthRatio;
-	const p1 = project(c1[0], c1[1]);
-	const p2 = project(c2[0], c2[1]);
-	const openingVec = vecSub(p2, p1);
-	const openingLength = vecMag(openingVec);
-	if (openingLength < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const openingDir = vecNorm(openingVec);
-	const railDir = [openingDir[1], -openingDir[0]];
-	const openingMid = vecScale(vecAdd(p1, p2), .5);
-	let signedLength;
-	if (c3) {
-		const rawSignedLength = vecDot(vecSub(project(c3[0], c3[1]), openingMid), railDir);
-		if (Math.abs(rawSignedLength) < 1e-6) signedLength = (rawSignedLength >= 0 ? 1 : -1) * openingLength * defaultLengthRatio;
-		else signedLength = rawSignedLength;
-	} else signedLength = openingLength * defaultLengthRatio;
-	if (Math.abs(signedLength) < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const rearMid = vecAdd(openingMid, vecScale(railDir, signedLength));
-	const halfOpening = vecScale(openingDir, openingLength / 2);
-	const rearTop = vecSub(rearMid, halfOpening);
-	const rearBottom = vecAdd(rearMid, halfOpening);
-	const arrowHeadLength = Math.max(openingLength * arrowHeadLengthRatio, EPSILON);
-	const arrowHeadWidth = Math.max(openingLength * arrowHeadWidthRatio, EPSILON);
-	const topDir = vecNorm(vecSub(p1, rearTop));
-	const topHeadBase = vecSub(p1, vecScale(topDir, arrowHeadLength));
-	const bottomDir = vecNorm(vecSub(p2, rearBottom));
-	const bottomHeadBase = vecSub(p2, vecScale(bottomDir, arrowHeadLength));
-	const lineSegments = [
-		[unproject(rearTop[0], rearTop[1]), unproject(rearBottom[0], rearBottom[1])],
-		[unproject(rearTop[0], rearTop[1]), unproject(topHeadBase[0], topHeadBase[1])],
-		[unproject(rearBottom[0], rearBottom[1]), unproject(bottomHeadBase[0], bottomHeadBase[1])]
-	];
-	const polygonRings = [[createArrowHeadRing(p1, topDir, arrowHeadLength, arrowHeadWidth)], [createArrowHeadRing(p2, bottomDir, arrowHeadLength, arrowHeadWidth)]];
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {},
-			geometry: {
-				type: "MultiLineString",
-				coordinates: lineSegments
-			}
-		}, {
-			type: "Feature",
-			properties: { fill: true },
-			geometry: {
-				type: "MultiPolygon",
-				coordinates: polygonRings
-			}
-		}]
-	};
-}
-const OBSTACLE_BYPASS_EASY = defineControlMeasure({
-	metadata: OBSTACLE_BYPASS_EASY_METADATA,
-	generator: createObstacleBypassEasy,
-	defaultOptions: DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS,
-	rule: point12DrawRule
-});
-//#endregion
-//#region src/generators/cm27-protection-areas/obstacleBypassImpossible.ts
-const DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS = {
-	arrowHeadLengthRatio: .2,
-	arrowHeadWidthRatio: .2,
-	defaultLengthRatio: 1.5,
-	rearBarLengthRatio: .12,
-	rearGapRatio: .08
-};
-const OBSTACLE_BYPASS_IMPOSSIBLE_METADATA = {
-	id: "obstacle-bypass-impossible",
-	name: "Obstacle Bypass Impossible",
-	description: "Obstacle bypass (impossible) with rear barrier marks and arrowheads.",
-	entity: "Protection Areas",
-	entityType: "Obstacle Bypass",
-	entitySubtype: "Impossible",
-	value: "270603",
-	minCoordinates: 2,
-	geometry: "line",
-	geometryTypes: ["MultiLineString", "MultiPolygon"],
-	drawRule: "Point12",
-	params: [
-		...OBSTACLE_BYPASS_PARAMS,
-		{
-			key: "rearBarLengthRatio",
-			label: "Rear bar length",
-			description: "Length of each rear barrier bar as a ratio of the opening width.",
-			type: "number",
-			min: .01,
-			max: 1,
-			step: .01
-		},
-		{
-			key: "rearGapRatio",
-			label: "Rear gap",
-			description: "Gap between the two rear bars as a ratio of the opening width.",
-			type: "number",
-			min: 0,
-			max: 1,
-			step: .01
-		}
-	]
-};
-/**
-* Generates a GeoJSON FeatureCollection for an "Obstacle Bypass Impossible" symbol.
-*
-* Input:
-* - PT1 and PT2 define the tips of the two arrowheads (opening and symbol height)
-* - PT3 defines signed symbol length along the perpendicular axis through midpoint(PT1, PT2)
-*
-* Geometry:
-* - Same base as obstacle bypass easy
-* - Rear line has two short perpendicular bars on the rear side
-*/
-function createObstacleBypassImpossible(coordinates, options = {}) {
-	const c1 = coordinates[0];
-	const c2 = coordinates[1];
-	const c3 = coordinates[2];
-	const arrowHeadLengthRatio = options.arrowHeadLengthRatio ?? DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS.arrowHeadLengthRatio;
-	const arrowHeadWidthRatio = options.arrowHeadWidthRatio ?? DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS.arrowHeadWidthRatio;
-	const defaultLengthRatio = options.defaultLengthRatio ?? DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS.defaultLengthRatio;
-	const rearBarLengthRatio = options.rearBarLengthRatio ?? DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS.rearBarLengthRatio;
-	const rearGapRatio = options.rearGapRatio ?? DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS.rearGapRatio;
-	const p1 = project(c1[0], c1[1]);
-	const p2 = project(c2[0], c2[1]);
-	const openingVec = vecSub(p2, p1);
-	const openingLength = vecMag(openingVec);
-	if (openingLength < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const openingDir = vecNorm(openingVec);
-	const railDir = [openingDir[1], -openingDir[0]];
-	const openingMid = vecScale(vecAdd(p1, p2), .5);
-	let signedLength;
-	if (c3) {
-		const rawSignedLength = vecDot(vecSub(project(c3[0], c3[1]), openingMid), railDir);
-		if (Math.abs(rawSignedLength) < 1e-6) signedLength = (rawSignedLength >= 0 ? 1 : -1) * openingLength * defaultLengthRatio;
-		else signedLength = rawSignedLength;
-	} else signedLength = openingLength * defaultLengthRatio;
-	if (Math.abs(signedLength) < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const rearMid = vecAdd(openingMid, vecScale(railDir, signedLength));
-	const halfOpening = vecScale(openingDir, openingLength / 2);
-	const rearTop = vecSub(rearMid, halfOpening);
-	const rearBottom = vecAdd(rearMid, halfOpening);
-	const arrowHeadLength = Math.max(openingLength * arrowHeadLengthRatio, EPSILON);
-	const arrowHeadWidth = Math.max(openingLength * arrowHeadWidthRatio, EPSILON);
-	const topDir = vecNorm(vecSub(p1, rearTop));
-	const topHeadBase = vecSub(p1, vecScale(topDir, arrowHeadLength));
-	const bottomDir = vecNorm(vecSub(p2, rearBottom));
-	const bottomHeadBase = vecSub(p2, vecScale(bottomDir, arrowHeadLength));
-	const barLength = Math.max(openingLength * rearBarLengthRatio, EPSILON);
-	const gapHalf = Math.max(openingLength * rearGapRatio * .5, EPSILON * 5);
-	const barHalf = barLength * .5;
-	const upperBarAnchor = vecAdd(rearMid, vecScale(openingDir, -gapHalf));
-	const lowerBarAnchor = vecAdd(rearMid, vecScale(openingDir, gapHalf));
-	const upperGapEnd = upperBarAnchor;
-	const lowerGapEnd = lowerBarAnchor;
-	const lineSegments = [
-		[unproject(rearTop[0], rearTop[1]), unproject(upperGapEnd[0], upperGapEnd[1])],
-		[unproject(lowerGapEnd[0], lowerGapEnd[1]), unproject(rearBottom[0], rearBottom[1])],
-		[unproject(rearTop[0], rearTop[1]), unproject(topHeadBase[0], topHeadBase[1])],
-		[unproject(rearBottom[0], rearBottom[1]), unproject(bottomHeadBase[0], bottomHeadBase[1])],
-		[unproject(upperBarAnchor[0] - railDir[0] * barHalf, upperBarAnchor[1] - railDir[1] * barHalf), unproject(upperBarAnchor[0] + railDir[0] * barHalf, upperBarAnchor[1] + railDir[1] * barHalf)],
-		[unproject(lowerBarAnchor[0] - railDir[0] * barHalf, lowerBarAnchor[1] - railDir[1] * barHalf), unproject(lowerBarAnchor[0] + railDir[0] * barHalf, lowerBarAnchor[1] + railDir[1] * barHalf)]
-	];
-	const polygonRings = [[createArrowHeadRing(p1, topDir, arrowHeadLength, arrowHeadWidth)], [createArrowHeadRing(p2, bottomDir, arrowHeadLength, arrowHeadWidth)]];
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {},
-			geometry: {
-				type: "MultiLineString",
-				coordinates: lineSegments
-			}
-		}, {
-			type: "Feature",
-			properties: { fill: true },
-			geometry: {
-				type: "MultiPolygon",
-				coordinates: polygonRings
-			}
-		}]
-	};
-}
-const OBSTACLE_BYPASS_IMPOSSIBLE = defineControlMeasure({
-	metadata: OBSTACLE_BYPASS_IMPOSSIBLE_METADATA,
-	generator: createObstacleBypassImpossible,
-	defaultOptions: DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS,
-	rule: point12DrawRule
-});
-//#endregion
-//#region src/generators/cm14-maneuver-lines/principalDirectionOfFire.ts
-const DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS = {
-	hSize: .07,
-	hWidth: .67
-};
-const PRINCIPAL_DIRECTION_OF_FIRE_METADATA = {
-	id: "principal-direction-of-fire",
-	name: "Principal Direction of Fire",
-	description: "A specific direction or sector toward which a weapon or unit directs fire for a tactical purpose.",
-	entity: "Maneuver Lines",
-	entityType: "Field of Fire",
-	entitySubtype: "Principal Direction of Fire",
-	value: "140503",
-	minCoordinates: 2,
-	maxCoordinates: 3,
-	geometry: "line",
-	geometryTypes: ["MultiLineString"],
-	drawRule: "Line3",
-	params: [{
-		key: "hSize",
-		label: "Head size",
-		description: "Arrowhead length as a fraction of each arm's length",
-		type: "number",
-		min: .01,
-		max: .5,
-		step: .01
-	}, {
-		key: "hWidth",
-		label: "Head width",
-		description: "Arrowhead wing spread relative to the arrowhead length",
-		type: "number",
-		min: .05,
-		max: 2,
-		step: .01
-	}]
-};
-/**
-* Generates a GeoJSON FeatureCollection for a PRINCIPAL DIRECTION OF FIRE
-* tactical symbol: a "V" of arms from the vertex out to the (independent) tips,
-* each ending in an open arrowhead.
-*
-* Renders one arm per tip, so two points (vertex + one tip) draws the single
-* arm being placed — the live feedback after PT 1 — and three points draws the
-* full V. Points beyond the third are ignored (input contract, ADR-0014).
-*
-* @param coordinates - [PT 1 (vertex), PT 2 (tip), PT 3 (tip)]
-* @param options - Arrowhead sizing parameters
-*/
-function createPrincipalDirectionOfFire(coordinates, options = {}) {
-	const { hSize, hWidth } = {
-		...DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS,
-		...options
-	};
-	const v = buildFieldOfFireV(coordinates, Math.max(0, hSize), Math.max(0, hWidth));
-	if (!v) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {},
-			geometry: {
-				type: "MultiLineString",
-				coordinates: v.lines.map((line) => line.map((c) => unproject(c[0], c[1])))
-			}
-		}]
-	};
-}
-const PRINCIPAL_DIRECTION_OF_FIRE = defineControlMeasure({
-	metadata: PRINCIPAL_DIRECTION_OF_FIRE_METADATA,
-	generator: createPrincipalDirectionOfFire,
-	defaultOptions: DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS,
-	rule: line3DrawRule
-});
-//#endregion
-//#region src/generators/cm15-maneuver-areas/searchArea.ts
-const DEFAULT_HEAD_SIZE_RATIO = .12;
-const DEFAULT_HEAD_WIDTH_MULTIPLIER = .5;
-const DEFAULT_ZIGZAG_START = .55;
-const DEFAULT_ZIGZAG_END = .45;
-const DEFAULT_ZIGZAG_WIDTH = .07;
-/**
-* Default options for the tactical arrow.
-*/
-const DEFAULT_TACTICAL_ARROW_OPTIONS = {
-	headSizeRatio: DEFAULT_HEAD_SIZE_RATIO,
-	headWidthMultiplier: DEFAULT_HEAD_WIDTH_MULTIPLIER,
-	zigzagStart: DEFAULT_ZIGZAG_START,
-	zigzagEnd: DEFAULT_ZIGZAG_END,
-	zigzagWidth: DEFAULT_ZIGZAG_WIDTH
-};
-const SEARCH_AREA_METADATA = {
-	id: "search-area",
-	name: "Search Area",
-	description: "Search area graphic with paired lightning-style arrows.",
-	entity: "Maneuver Areas",
-	entityType: "Search Area",
-	value: "152200",
-	minCoordinates: 3,
-	maxCoordinates: 3,
-	geometry: "area",
-	geometryTypes: ["MultiLineString", "MultiPolygon"],
-	drawRule: "Area21",
-	params: [
-		{
-			key: "headSizeRatio",
-			label: "Head size",
-			description: "Arrowhead length as a ratio of the total leg length.",
-			type: "number",
-			min: 0,
-			max: .5,
-			step: .01
-		},
-		{
-			key: "headWidthMultiplier",
-			label: "Head width",
-			description: "Arrowhead wing width as a multiple of the head length.",
-			type: "number",
-			min: .05,
-			max: 2,
-			step: .1
-		},
-		{
-			key: "zigzagStart",
-			label: "Zigzag start",
-			description: "Point along the leg where the zigzag begins (0-1).",
-			type: "number",
-			min: 0,
-			max: 1,
-			step: .05
-		},
-		{
-			key: "zigzagEnd",
-			label: "Zigzag end",
-			description: "Point along the leg where the zigzag returns (0-1).",
-			type: "number",
-			min: 0,
-			max: 1,
-			step: .05
-		},
-		{
-			key: "zigzagWidth",
-			label: "Zigzag width",
-			description: "Perpendicular kink offset as a ratio of leg length.",
-			type: "number",
-			min: 0,
-			max: .3,
-			step: .01
-		}
-	]
-};
-/**
-* Generates a GeoJSON FeatureCollection of a tactical "lightning" arrow.
-* Handles internal projection to maintain correct perpendicularity.
-*
-* @param coordinates - [Apex Point (PT1), Top Tail (PT2), Bottom Tail (PT3)]
-* @param options - Geometric configuration parameters
-* @returns A FeatureCollection containing a MultiLineString for bolts and a MultiPolygon for heads
-*/
-function createSearchArea(coordinates, options = {}) {
-	const { headSizeRatio = DEFAULT_HEAD_SIZE_RATIO, headWidthMultiplier = DEFAULT_HEAD_WIDTH_MULTIPLIER, zigzagStart = DEFAULT_ZIGZAG_START, zigzagEnd = DEFAULT_ZIGZAG_END, zigzagWidth = DEFAULT_ZIGZAG_WIDTH } = options;
-	const safeHeadSizeRatio = Math.max(0, headSizeRatio);
-	const safeHeadWidthMultiplier = Math.max(0, headWidthMultiplier);
-	const safeZigzagStart = clamp01(zigzagStart);
-	const safeZigzagEnd = clamp01(zigzagEnd);
-	const safeZigzagWidth = Math.max(0, zigzagWidth);
-	const [c0, c1, c2] = coordinates;
-	const [p1, p2, p3] = [
-		project(c0[0], c0[1]),
-		project(c1[0], c1[1]),
-		project(c2[0], c2[1])
-	];
-	const shaftSegments = [];
-	const headPolygons = [];
-	const addLeg = (origin, tip, opposite) => {
-		const v = vecSub(tip, origin);
-		const totalLen = vecMag(v);
-		if (totalLen < 1e-6) return;
-		const u = vecNorm(v);
-		let n = [-u[1], u[0]];
-		const toOpp = vecSub(opposite, origin);
-		if (vecDot(n, toOpp) > 0) n = vecScale(n, -1);
-		const offset = totalLen * safeZigzagWidth;
-		const ptA = vecAdd(vecAdd(origin, vecScale(v, safeZigzagStart)), vecScale(n, offset));
-		const ptB = vecAdd(vecAdd(origin, vecScale(v, safeZigzagEnd)), vecScale(n, -offset));
-		const fv = vecSub(tip, ptB);
-		const fLen = vecMag(fv);
-		let fu = vecNorm(fv);
-		if (fLen < 1e-6) fu = u;
-		const headLen = totalLen * safeHeadSizeRatio;
-		const pBase = vecSub(tip, vecScale(fu, headLen));
-		const wingWidth = headLen * safeHeadWidthMultiplier;
-		const perp = [-fu[1], fu[0]];
-		const pWing1 = vecAdd(pBase, vecScale(perp, wingWidth));
-		const pWing2 = vecSub(pBase, vecScale(perp, wingWidth));
-		shaftSegments.push([
-			origin,
-			ptA,
-			ptB,
-			pBase
-		].map((p) => unproject(p[0], p[1])));
-		headPolygons.push([[
-			tip,
-			pWing1,
-			pWing2,
-			tip
-		].map((p) => unproject(p[0], p[1]))]);
-	};
-	addLeg(p1, p2, p3);
-	addLeg(p1, p3, p2);
-	const features = [];
-	if (shaftSegments.length > 0) features.push({
-		type: "Feature",
-		properties: { part: "shaft" },
-		geometry: {
-			type: "MultiLineString",
-			coordinates: shaftSegments
-		}
-	});
-	if (headPolygons.length > 0) features.push({
-		type: "Feature",
-		properties: {
-			part: "head",
-			fill: true
-		},
-		geometry: {
-			type: "MultiPolygon",
-			coordinates: headPolygons
-		}
-	});
-	return {
-		type: "FeatureCollection",
-		features
-	};
-}
-const SEARCH_AREA = defineControlMeasure({
-	metadata: SEARCH_AREA_METADATA,
-	generator: (controlPoints, options) => createSearchArea(asThreePoints(controlPoints), options),
-	defaultOptions: DEFAULT_TACTICAL_ARROW_OPTIONS,
-	rule: searchAreaDrawRule
-});
-//#endregion
-//#region src/generators/cm15-maneuver-areas/supportByFire.ts
-const DEFAULT_SUPPORT_BY_FIRE_OPTIONS = {
-	arrowTipWidthRatio: .3,
-	backLineLengthRatio: .3,
-	backLineAngle: 45
-};
-const SUPPORT_BY_FIRE_METADATA = {
-	id: "support-by-fire",
-	name: "Support By Fire",
-	description: "Support by fire graphic with paired arrows.",
-	entity: "Maneuver Areas",
-	entityType: "Support by Fire",
-	value: "152100",
-	minCoordinates: 4,
-	geometry: "line",
-	geometryTypes: ["LineString"],
-	drawRule: "Area8",
-	params: FIRE_ARROW_PARAMS
-};
-/**
-* Generates a GeoJSON FeatureCollection for a Support By Fire tactical graphic.
-*
-* Input:
-* - PT1: Left Base
-* - PT2: Right Base
-* - PT3: Left Tip
-* - PT4: Right Tip
-*/
-function createSupportByFire(coordinates, options = {}) {
-	const featureProps = {};
-	const arrowTipWidthRatio = options.arrowTipWidthRatio ?? DEFAULT_SUPPORT_BY_FIRE_OPTIONS.arrowTipWidthRatio;
-	const backLineLengthRatio = options.backLineLengthRatio ?? DEFAULT_SUPPORT_BY_FIRE_OPTIONS.backLineLengthRatio;
-	const backLineAngle = options.backLineAngle ?? DEFAULT_SUPPORT_BY_FIRE_OPTIONS.backLineAngle;
-	const c1 = coordinates[0];
-	const c2 = coordinates[1];
-	const c3 = coordinates[2];
-	const c4 = coordinates[3];
-	const p1 = project(c1[0], c1[1]);
-	const p2 = project(c2[0], c2[1]);
-	const p3 = project(c3[0], c3[1]);
-	const p4 = project(c4[0], c4[1]);
-	const vBase = vecSub(p2, p1);
-	const lenBase = vecMag(vBase);
-	const dirBase = vecNorm(vBase);
-	if (lenBase < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const angleRad = backLineAngle * Math.PI / 180;
-	const baseAngle = -Math.PI / 2;
-	const angleLeft = baseAngle - angleRad;
-	const dirBackLeft = [dirBase[0] * Math.cos(angleLeft) - dirBase[1] * Math.sin(angleLeft), dirBase[0] * Math.sin(angleLeft) + dirBase[1] * Math.cos(angleLeft)];
-	const angleRight = baseAngle + angleRad;
-	const dirBackRight = [dirBase[0] * Math.cos(angleRight) - dirBase[1] * Math.sin(angleRight), dirBase[0] * Math.sin(angleRight) + dirBase[1] * Math.cos(angleRight)];
-	const backLen = lenBase * backLineLengthRatio;
-	const p1Back = vecAdd(p1, vecScale(dirBackLeft, backLen));
-	const p2Back = vecAdd(p2, vecScale(dirBackRight, backLen));
-	const vLeft = vecSub(p3, p1);
-	const lenLeft = vecMag(vLeft);
-	const dirLeft = vecNorm(vLeft);
-	const vRight = vecSub(p4, p2);
-	const lenRight = vecMag(vRight);
-	const dirRight = vecNorm(vRight);
-	const commonHeadWidth = (lenLeft + lenRight) / 2 * arrowTipWidthRatio;
-	const commonHeadLen = commonHeadWidth;
-	const leftHeadFeatures = createArrowHead(p3, dirLeft, commonHeadLen, commonHeadWidth);
-	const rightHeadFeatures = createArrowHead(p4, dirRight, commonHeadLen, commonHeadWidth);
-	return {
-		type: "FeatureCollection",
-		features: [
-			{
-				type: "Feature",
-				properties: featureProps,
-				geometry: {
-					type: "LineString",
-					coordinates: [unproject(p1[0], p1[1]), unproject(p1Back[0], p1Back[1])]
-				}
-			},
-			{
-				type: "Feature",
-				properties: featureProps,
-				geometry: {
-					type: "LineString",
-					coordinates: [unproject(p2[0], p2[1]), unproject(p2Back[0], p2Back[1])]
-				}
-			},
-			{
-				type: "Feature",
-				properties: featureProps,
-				geometry: {
-					type: "LineString",
-					coordinates: [unproject(p1[0], p1[1]), unproject(p3[0], p3[1])]
-				}
-			},
-			{
-				type: "Feature",
-				properties: featureProps,
-				geometry: {
-					type: "LineString",
-					coordinates: [unproject(p2[0], p2[1]), unproject(p4[0], p4[1])]
-				}
-			},
-			{
-				type: "Feature",
-				properties: featureProps,
-				geometry: {
-					type: "LineString",
-					coordinates: [unproject(p1[0], p1[1]), unproject(p2[0], p2[1])]
-				}
-			},
-			...leftHeadFeatures.map((f) => ({
-				...f,
-				properties: featureProps
-			})),
-			...rightHeadFeatures.map((f) => ({
-				...f,
-				properties: featureProps
-			}))
-		]
-	};
-}
-function createArrowHead(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 [{
-		type: "Feature",
-		geometry: {
-			type: "LineString",
-			coordinates: [
-				unproject(left[0], left[1]),
-				unproject(tip[0], tip[1]),
-				unproject(right[0], right[1])
-			]
-		},
-		properties: {}
-	}];
-}
-const SUPPORT_BY_FIRE = defineControlMeasure({
-	metadata: SUPPORT_BY_FIRE_METADATA,
-	generator: createSupportByFire,
-	defaultOptions: DEFAULT_SUPPORT_BY_FIRE_OPTIONS,
-	rule: supportByFireDrawRule
-});
-//#endregion
-//#region src/generators/cm15-maneuver-areas/supportingAttack.ts
-const DEFAULT_SUPPORTING_ATTACK_OPTIONS = {
-	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO,
-	roundedBends: false,
-	bendSegments: 5
-};
-const SUPPORTING_ATTACK_METADATA = {
-	id: "supporting-attack",
-	name: "Supporting Attack",
-	description: "Secondary attack that supports the main effort.",
-	entity: "Maneuver Areas",
-	entityType: "Axis of Advance",
-	entitySubtype: "Supporting Attack",
-	value: "151404",
-	minCoordinates: 3,
-	geometry: "line",
-	geometryTypes: ["LineString"],
-	drawRule: "Axis1",
-	params: ATTACK_SHAFT_PARAMS
-};
-/**
-* Generates a GeoJSON FeatureCollection for a Supporting Attack tactical symbol.
-*
-* The symbol differs from Main Attack in that it is a single LineString
-* outlining the arrow shape, rather than a filled Polygon header + Shaft lines.
-*
-* @param coordinates - An array of GeoJSON Positions.
-* @param options - Configuration options.
-* @returns A GeoJSON FeatureCollection<LineString>.
-*/
-function createSupportingAttack(coordinates, options = {}) {
-	const { geometry } = processAttackGeometry(coordinates, options);
-	if (!geometry) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {},
-			geometry: {
-				type: "LineString",
-				coordinates: [
-					...geometry.shaftLeft,
-					geometry.headRing[0],
-					geometry.headRing[1],
-					geometry.headRing[2],
-					...[...geometry.shaftRight].reverse()
-				].map((p) => unproject(p[0], p[1]))
-			}
-		}]
-	};
-}
-const SUPPORTING_ATTACK = defineControlMeasure({
-	metadata: SUPPORTING_ATTACK_METADATA,
-	generator: createSupportingAttack,
-	defaultOptions: DEFAULT_SUPPORTING_ATTACK_OPTIONS,
-	rule: axis1DrawRule
-});
-//#endregion
-//#region src/generators/cm27-protection-areas/turn.ts
-const DEFAULT_TURN_OPTIONS = {
-	arrowHeadLengthRatio: .16,
-	arrowHeadWidthRatio: .16,
-	arcSegments: 64
-};
-const TURN_METADATA = {
-	id: "turn",
-	name: "Turn",
-	description: "An obstacle effect that integrates fire planning and obstacle effort to drive an enemy formation from one avenue of approach to an adjacent avenue of approach or into an engagement area. The rear of the symbol identifies the enemy's location and the arrow points in the direction the obstacle should force the enemy to turn.",
-	entity: "Protection Areas",
-	entityType: "Obstacle Effects",
-	entitySubtype: "Turn",
-	value: "270504",
-	minCoordinates: 2,
-	geometry: "line",
-	geometryTypes: ["MultiLineString", "MultiPolygon"],
-	drawRule: "Line10",
-	params: [
-		{
-			key: "arrowHeadLengthRatio",
-			label: "Arrowhead length",
-			description: "Arrowhead length as a ratio of the rear-to-tip distance.",
-			type: "number",
-			min: .01,
-			max: .5,
-			step: .01
-		},
-		{
-			key: "arrowHeadWidthRatio",
-			label: "Arrowhead width",
-			description: "Arrowhead base width as a ratio of the rear-to-tip distance.",
-			type: "number",
-			min: .01,
-			max: .5,
-			step: .01
-		},
-		{
-			key: "arcSegments",
-			label: "Arc segments",
-			description: "Number of line segments approximating the quarter-circle shaft.",
-			type: "number",
-			min: 4,
-			max: 128,
-			step: 1
-		}
-	]
-};
-/**
-* Generates a quarter-circle shaft from PT2 (rear) to the arrowhead base.
-* The arrowhead continues tangent to the arc and places its tip at PT1.
-* PT3 selects which side of the PT2 -> PT1 chord contains the arc.
-*/
-function createTurn(coordinates, options = {}) {
-	const tip = project(coordinates[0][0], coordinates[0][1]);
-	const rear = project(coordinates[1][0], coordinates[1][1]);
-	const side = quarterArcSide(rear, tip, coordinates[2] ? project(coordinates[2][0], coordinates[2][1]) : void 0);
-	const rearToTip = vecSub(tip, rear);
-	const totalLength = vecMag(rearToTip);
-	if (totalLength < 1e-6) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const requestedHeadLength = totalLength * (options.arrowHeadLengthRatio ?? DEFAULT_TURN_OPTIONS.arrowHeadLengthRatio);
-	const tangentComponent = Math.min(Math.max(requestedHeadLength, EPSILON), totalLength * .95) / Math.SQRT2;
-	const arcChordLength = Math.sqrt(totalLength * totalLength - tangentComponent * tangentComponent) - tangentComponent;
-	const chordOffset = Math.atan2(tangentComponent, arcChordLength + tangentComponent);
-	const headBase = vecAdd(rear, vecScale(rotate(vecNorm(rearToTip), side * chordOffset), arcChordLength));
-	const arc = createQuarterArc(rear, headBase, side);
-	if (!arc) return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const segmentCount = Math.round(Math.min(128, Math.max(4, options.arcSegments ?? DEFAULT_TURN_OPTIONS.arcSegments)));
-	const arcCoordinates = [];
-	for (let i = 0; i <= segmentCount; i++) {
-		const angle = arc.startAngle + arc.sweepAngle * i / segmentCount;
-		arcCoordinates.push(unproject(arc.center[0] + arc.radius * Math.cos(angle), arc.center[1] + arc.radius * Math.sin(angle)));
-	}
-	const headWidth = totalLength * (options.arrowHeadWidthRatio ?? DEFAULT_TURN_OPTIONS.arrowHeadWidthRatio);
-	const arrowHead = createArrowHeadRing(tip, vecNorm(vecSub(tip, headBase)), vecMag(vecSub(tip, headBase)), headWidth);
-	return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: { part: "arc" },
-			geometry: {
-				type: "MultiLineString",
-				coordinates: [arcCoordinates]
-			}
-		}, {
-			type: "Feature",
-			properties: {
-				part: "arrowhead",
-				fill: true
-			},
-			geometry: {
-				type: "MultiPolygon",
-				coordinates: [[[...arrowHead]]]
-			}
-		}]
-	};
-}
-function rotate(vector, angle) {
-	const cos = Math.cos(angle);
-	const sin = Math.sin(angle);
-	return [vector[0] * cos - vector[1] * sin, vector[0] * sin + vector[1] * cos];
-}
-//#endregion
-//#region src/registry.ts
-/**
-* The single source of truth for the catalog: one **control measure
-* definition** record per measure, co-located with its generator and collected
-* here. The `ControlMeasureId` union, `OptionsByKind`, the generator dispatch,
-* the default options, and rule resolution are all *derived* from this map
-* rather than maintained as parallel tables. Adding a measure is a one-file
-* change plus one line here. See ADR-0013.
-*/
-const DEFINITIONS = {
-	ambush: AMBUSH,
-	"principal-direction-of-fire": PRINCIPAL_DIRECTION_OF_FIRE,
-	"final-protective-fire-left": FINAL_PROTECTIVE_FIRE_LEFT,
-	"final-protective-fire-right": FINAL_PROTECTIVE_FIRE_RIGHT,
-	"search-area": SEARCH_AREA,
-	"main-attack": MAIN_ATTACK,
-	"supporting-attack": SUPPORTING_ATTACK,
-	"airborne-attack": AIRBORNE_ATTACK,
-	"attack-helicopter": ATTACK_HELICOPTER,
-	"support-by-fire": SUPPORT_BY_FIRE,
-	"attack-by-fire": ATTACK_BY_FIRE,
-	flot: FLOT,
-	"block-mission-task": BLOCK_MISSION_TASK,
-	breach: BREACH,
-	bypass: BYPASS,
-	canalize: CANALIZE,
-	clear: CLEAR,
-	delay: DELAY,
-	isolate: ISOLATE,
-	"antitank-ditch-under-construction": ANTITANK_DITCH_UNDER_CONSTRUCTION,
-	"antitank-ditch-completed": ANTITANK_DITCH_COMPLETED,
-	"antitank-wall": ANTITANK_WALL,
-	"fortified-line": FORTIFIED_LINE,
-	"fortified-area": FORTIFIED_AREA,
-	block: BLOCK,
-	disrupt: DISRUPT,
-	fix: FIX,
-	turn: defineControlMeasure({
-		metadata: TURN_METADATA,
-		generator: createTurn,
-		defaultOptions: DEFAULT_TURN_OPTIONS,
-		rule: turnDrawRule
-	}),
-	"obstacle-bypass-easy": OBSTACLE_BYPASS_EASY,
-	"obstacle-bypass-difficult": OBSTACLE_BYPASS_DIFFICULT,
-	"obstacle-bypass-impossible": OBSTACLE_BYPASS_IMPOSSIBLE
-};
-/** Insertion-ordered list of every control-measure id. */
-const CONTROL_MEASURE_IDS = Object.keys(DEFINITIONS);
-/**
-* Merges a definition's resolved `rule` object back onto its metadata,
-* preserving ADR-0005's `getControlMeasureMetadata` shape. Definitions whose
-* `drawRule` id has no implementation leave `rule` undefined.
-*/
-function withRule(definition) {
-	return definition.rule ? {
-		...definition.metadata,
-		rule: definition.rule
-	} : definition.metadata;
-}
-const CONTROL_MEASURE_METADATA = Object.fromEntries(Object.entries(DEFINITIONS).map(([id, definition]) => [id, withRule(definition)]));
-const CONTROL_MEASURE_METADATA_LIST = Object.values(CONTROL_MEASURE_METADATA);
-const CONTROL_MEASURE_METADATA_BY_VALUE = CONTROL_MEASURE_METADATA_LIST.reduce((acc, metadata) => {
-	acc[metadata.value] = metadata;
-	return acc;
-}, {});
-function listControlMeasureMetadata() {
-	return CONTROL_MEASURE_METADATA_LIST;
-}
-function getControlMeasureMetadata(id) {
-	return CONTROL_MEASURE_METADATA[id];
-}
-function getControlMeasureMetadataByValue(value) {
-	return CONTROL_MEASURE_METADATA_BY_VALUE[value];
-}
-function getDefaultOptions(kind) {
-	return structuredClone(DEFINITIONS[kind].defaultOptions);
-}
-//#endregion
-//#region src/style.ts
-/**
-* 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/styleResolver.ts
-/**
-* Three-layer style precedence for `renderControlMeasure`.
-*
-* Lower-priority → higher-priority: `graphicsStyle` (façade default) →
-* `measureStyle` (`cm.style`) → `generatorStyle` (per-feature hint emitted
-* by a generator). Merge is shallow and per-property; higher-priority layers
-* win key by key. Explicit `null` / `undefined` in a higher-priority layer
-* is treated as "no opinion" and does not clear a lower-priority key.
-*
-* Returns `undefined` when all three layers are absent so the renderer can
-* omit `properties.style` entirely — keeps the no-style case byte-identical
-* to a property-less feature.
-*
-* Pure function: inputs are never mutated; the returned object is always a
-* fresh allocation when defined.
-*/
-function resolveStyleHints(graphicsStyle, measureStyle, generatorStyle) {
-	if (!graphicsStyle && !measureStyle && !generatorStyle) return;
-	const merged = {};
-	applyLayer(merged, graphicsStyle);
-	applyLayer(merged, measureStyle);
-	applyLayer(merged, generatorStyle);
-	return merged;
-}
-/**
-* Expand cascaded style hints into concrete per-feature paint, per the
-* monocolor model (ADR-0011).
-*
-* A control measure is monocolor: the single `color` paints both stroke and
-* fill. `strokeColor` / `fillColor` are optional per-channel overrides, and
-* `DEFAULT_SYMBOL_COLOR` is the ultimate fallback so a zero-config render is
-* still black and filled parts still render filled.
-*
-* `filled` is the generator's intrinsic, color-free marker that a part is a
-* solid shape. Non-filled parts never carry a `fillColor` — filledness is
-* intrinsic to the symbol and cannot be conjured by host styling. `color` is
-* input-only and is stripped from the result.
-*
-* Pure: the input is not mutated; a fresh object is always returned.
-*/
-function resolveSymbolColor(merged, filled) {
-	const { color, strokeColor, fillColor, ...rest } = merged ?? {};
-	const resolved = {
-		...rest,
-		strokeColor: firstColor(strokeColor, color)
-	};
-	if (filled) resolved.fillColor = firstColor(fillColor, color);
-	return resolved;
-}
-/**
-* First usable color among the candidates, else `DEFAULT_SYMBOL_COLOR`. An
-* empty string is treated as "not set" (e.g. a cleared color input) rather
-* than kept as an invalid paint, so the fallback chain still reaches black.
-*/
-function firstColor(...candidates) {
-	for (const candidate of candidates) if (candidate !== void 0 && candidate !== "") return candidate;
-	return DEFAULT_SYMBOL_COLOR;
-}
-function applyLayer(target, layer) {
-	if (!layer) return;
-	for (const key of Object.keys(layer)) {
-		const value = layer[key];
-		if (value !== void 0 && value !== null) target[key] = value;
-	}
-}
-//#endregion
-//#region src/renderControlMeasure.ts
-/**
-* Pure render: `ControlMeasure` → `ControlMeasureRender` (a
-* `FeatureCollection` of `FeaturePartProps`-typed features). Per-feature
-* stable ids follow `${cm.id}:${part}:${index}`. Style is resolved from the
-* three layers (graphicsStyle, cm.style, generator hint) and stamped on
-* `properties.style` when non-empty.
-*/
-function renderControlMeasure(cm, opts) {
-	const features = dispatchControlMeasure(cm, opts).features.map((feature, index) => normalizeFeature(cm.id, feature, index, cm.style, opts?.graphicsStyle));
-	const bbox = computeBBox(features);
-	return {
-		type: "FeatureCollection",
-		...bbox ? { bbox } : {},
-		features
-	};
-}
-const EMPTY_COLLECTION = {
-	type: "FeatureCollection",
-	features: []
-};
-function dispatchControlMeasure(cm, opts) {
-	const definition = DEFINITIONS[cm.kind];
-	if (!validateInputContract(cm.controlPoints, definition.metadata, opts?.validationMode)) return EMPTY_COLLECTION;
-	const generator = definition.generator;
-	return generator(cm.controlPoints, cm.options ?? {});
-}
-/**
-* The control-point *input contract*: at least `metadata.minCoordinates` points,
-* each a finite `[lon, lat]` position. Reports per `validationMode` on
-* violation (`silent` → empty render, `warn` → log, `throw` → raise) and
-* returns whether the points may be passed to the generator. Extra points
-* beyond `maxCoordinates` are ignored, not rejected (ADR-0014).
-*/
-function validateInputContract(points, metadata, mode) {
-	const minimum = metadata.minCoordinates ?? 0;
-	if (points.length < minimum) return reportValidationIssue(mode, `"${metadata.id}" requires at least ${minimum} control points; received ${points.length}.`);
-	if (points.some((point) => !isValidPosition(point))) return reportValidationIssue(mode, `"${metadata.id}" control points must contain finite [lon, lat] values.`);
-	return true;
-}
-function normalizeFeature(id, feature, index, measureStyle, graphicsStyle) {
-	const sourceProps = feature.properties ?? {};
-	const part = typeof sourceProps.part === "string" && sourceProps.part.length > 0 ? sourceProps.part : "main";
-	const generatorStyle = typeof sourceProps.style === "object" && sourceProps.style !== null ? sourceProps.style : void 0;
-	const filled = sourceProps.fill === true;
-	const style = resolveSymbolColor(resolveStyleHints(graphicsStyle, measureStyle, generatorStyle), filled);
-	const text = typeof sourceProps.text === "string" ? sourceProps.text : void 0;
-	const rotation = typeof sourceProps.rotation === "number" ? sourceProps.rotation : void 0;
-	const textSizePixels = typeof sourceProps.textSizePixels === "number" ? sourceProps.textSizePixels : void 0;
-	const textSizeZoom = typeof sourceProps.textSizeZoom === "number" ? sourceProps.textSizeZoom : void 0;
-	const textSizeResolution = typeof sourceProps.textSizeResolution === "number" ? sourceProps.textSizeResolution : void 0;
-	return {
-		type: "Feature",
-		id: `${id}:${part}:${index}`,
-		properties: {
-			part,
-			index,
-			style,
-			...text !== void 0 ? { text } : {},
-			...rotation !== void 0 ? { rotation } : {},
-			...textSizePixels !== void 0 ? { textSizePixels } : {},
-			...textSizeZoom !== void 0 ? { textSizeZoom } : {},
-			...textSizeResolution !== void 0 ? { textSizeResolution } : {}
-		},
-		geometry: feature.geometry
-	};
-}
-function computeBBox(features) {
-	let bbox;
-	for (const feature of features) visitGeometryPositions(feature.geometry, ([x, y]) => {
-		if (bbox) bbox = [
-			Math.min(bbox[0], x),
-			Math.min(bbox[1], y),
-			Math.max(bbox[2], x),
-			Math.max(bbox[3], y)
-		];
-		else bbox = [
-			x,
-			y,
-			x,
-			y
-		];
-	});
-	return bbox;
-}
-function visitGeometryPositions(geometry, visit) {
-	switch (geometry.type) {
-		case "Point":
-			visit(geometry.coordinates);
-			break;
-		case "MultiPoint":
-		case "LineString":
-			geometry.coordinates.forEach(visit);
-			break;
-		case "MultiLineString":
-		case "Polygon":
-			geometry.coordinates.forEach((line) => line.forEach(visit));
-			break;
-		case "MultiPolygon":
-			geometry.coordinates.forEach((polygon) => {
-				polygon.forEach((line) => line.forEach(visit));
-			});
-			break;
-		case "GeometryCollection":
-			geometry.geometries.forEach((item) => visitGeometryPositions(item, visit));
-			break;
-		default: assertNever(geometry);
-	}
-}
-function assertNever(value) {
-	throw new Error(`Unhandled control measure kind: ${String(value)}`);
-}
-//#endregion
+import { $ as snapToMidpointPerpendicular, A as DEFAULT_BLOCK_MISSION_TASK_OPTIONS, B as line24DrawRule, C as DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, D as DEFAULT_CANALIZE_OPTIONS, E as DEFAULT_CLEAR_OPTIONS, F as DEFAULT_ANTITANK_DITCH_OPTIONS, G as attackByFireDrawRule, H as turnDrawRule, I as DEFAULT_AMBUSH_OPTIONS, J as blockDrawRule, K as point12DrawRule, L as DEFAULT_AIRBORNE_ATTACK_OPTIONS, M as DEFAULT_ATTACK_HELICOPTER_OPTIONS, N as DEFAULT_ATTACK_BY_FIRE_OPTIONS, O as DEFAULT_BYPASS_OPTIONS, P as DEFAULT_ANTITANK_WALL_OPTIONS, Q as pointOnMidpointPerpendicularAxis, R as axis1DrawRule, S as DEFAULT_FIX_OPTIONS, T as DEFAULT_DELAY_OPTIONS, U as line1DrawRule, V as line23DrawRule, W as ambushDrawRule, X as createMidpointPerpendicularDrawRule, Y as computeDefaultMidpointPerpendicularPoint, Z as getMidpointPerpendicularSignedDistance, _ as DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, at as EPSILON, b as DEFAULT_FORTIFIED_LINE_OPTIONS, c as getDefaultOptions, d as DEFAULT_SUPPORTING_ATTACK_OPTIONS, et as createBaselineFrame, f as DEFAULT_SUPPORT_BY_FIRE_OPTIONS, g as DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, h as DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, i as CONTROL_MEASURE_METADATA, it as unproject, j as DEFAULT_BLOCK_OPTIONS, k as DEFAULT_BREACH_OPTIONS, l as listControlMeasureMetadata, m as DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, n as resolveStyleHints, nt as computeInitialWidthPoint, o as getControlMeasureMetadata, ot as getMetersPerPixel, p as DEFAULT_TACTICAL_ARROW_OPTIONS, q as disruptDrawRule, r as CONTROL_MEASURE_IDS, rt as project, s as getControlMeasureMetadataByValue, st as roundToFixed, t as renderControlMeasure, tt as calculateMetrics, u as DEFAULT_TURN_OPTIONS, v as DEFAULT_MAIN_ATTACK_OPTIONS, w as DEFAULT_DISRUPT_OPTIONS, x as DEFAULT_FLOT_OPTIONS, y as DEFAULT_FORTIFIED_AREA_OPTIONS, z as supportByFireDrawRule } from "./renderControlMeasure-C7pY-TcL.mjs";
 //#region src/instance.ts
 function isKind(cm, kind) {
 	return cm.kind === kind;