@orbat-mapper/control-measures 0.6.0 → 0.8.0

package/dist/{renderControlMeasure-D6VScGE0.mjs → renderControlMeasure-BHIGHuop.mjs}

@@ -586,20 +586,16 @@ const area1DrawRule = {
 	}
 };
 //#endregion
-//#region src/draw-rules/area11.ts
-const blockDrawRule = createMidpointPerpendicularDrawRule({ id: "area11:block" });
-//#endregion
-//#region src/draw-rules/area12.ts
+//#region src/draw-rules/area5.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).
+* Area5 — PT. 1/PT. 2 define the open diameter and PT. 3 defines the arrow end.
+* The arrow stays on the perpendicular bisector of the diameter.
 */
-const disruptDrawRule = createMidpointPerpendicularDrawRule({
-	id: "area12:disrupt",
-	origin: "p1",
-	normal: "left"
+const containDrawRule = createMidpointPerpendicularDrawRule({
+	id: "area5:contain",
+	minimumUserPoints: 3,
+	defaultDistanceRatio: -1.5,
+	minimumPreviewPoints: 2
 });
 //#endregion
 //#region src/draw-rules/area15.ts
@@ -630,6 +626,34 @@ const centerRadiusDrawRule = {
 /** Backward-compatible doctrinal name for Area15's shared center-radius rule. */
 const isolateDrawRule = centerRadiusDrawRule;
 //#endregion
+//#region src/draw-rules/area6.ts
+/**
+* Area6 — center + start point, mechanically identical to Area15. It re-labels
+* the shared behaviour rather than aliasing it because a definition's `rule.id`
+* must carry its `metadata.drawRule` as a prefix (see the registry invariant in
+* `__tests__/metadata-registry.spec.ts`, ADR-0013).
+*/
+const retainDrawRule = {
+	...centerRadiusDrawRule,
+	id: "area6:center-radius"
+};
+//#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/area17.ts
 /**
 * Area17 anchor draw rule for Penetrate.
@@ -689,6 +713,81 @@ const staticPointDrawRule = {
 	id: "point2:static-anchor"
 };
 //#endregion
+//#region src/draw-rules/sector.ts
+const SECTOR_ANGLE_SNAP_RADIANS = Math.PI / 36;
+/**
+* Sector — anchor + inner-left edge + outer-right edge. The two radial points
+* independently control a radius and a true-north azimuth. Dragging the anchor
+* translates both edge points so the sector retains its size and orientation.
+*/
+function derive$9(points) {
+	return clonePositions(points.slice(0, 3));
+}
+function guidePoints$1(points) {
+	return points.length < 3 ? clonePositions(points) : [];
+}
+/** Snap one radial Sector handle to a true-north angular increment. */
+function snapSectorAngle(points, activePointIndex, incrementRadians) {
+	const next = clonePositions(points);
+	if (activePointIndex !== 1 && activePointIndex !== 2) return next;
+	const anchor = next[0];
+	const point = next[activePointIndex];
+	if (!anchor || !point) return next;
+	const range = haversineDistance(anchor, point);
+	const bearing = sphericalBearing(anchor, point);
+	next[activePointIndex] = [...destinationPoint(anchor, range, Math.round(bearing / incrementRadians) * incrementRadians), ...point.slice(2)];
+	return next;
+}
+function constrainAngles(points, activePointIndex) {
+	return snapSectorAngle(points, activePointIndex, SECTOR_ANGLE_SNAP_RADIANS);
+}
+const sectorDrawRule = {
+	id: "sector:anchor-radii",
+	minimumUserPoints: 3,
+	canonicalPointCount: 3,
+	showGuide: true,
+	guidePoints: guidePoints$1,
+	constrainAngles,
+	derive: derive$9,
+	transform(event) {
+		const { previous, next, activePointIndex } = event;
+		if (activePointIndex === 0 && previous.length >= 3 && next.length >= 3) {
+			const dx = next[0][0] - previous[0][0];
+			const dy = next[0][1] - previous[0][1];
+			return [
+				clonePosition(next[0]),
+				[previous[1][0] + dx, previous[1][1] + dy],
+				[previous[2][0] + dx, previous[2][1] + dy]
+			];
+		}
+		return derive$9(next);
+	}
+};
+//#endregion
+//#region src/draw-rules/point18.ts
+const WHOLE_DEGREE_RADIANS = Math.PI / 180;
+function snapToWholeDegrees(points) {
+	let snapped = snapSectorAngle(points, 1, WHOLE_DEGREE_RADIANS);
+	if (snapped.length >= 3) snapped = snapSectorAngle(snapped, 2, WHOLE_DEGREE_RADIANS);
+	return snapped;
+}
+/**
+* Point18 — doctrinally a numeric, single-anchor symbol. The interactive
+* authoring model exposes those dimensions as Sector-style radial handles:
+* P1 is the anchor, P2 fixes the start range/left bearing, and P3 fixes the
+* stop range/right bearing.
+*/
+const dynamicPointDrawRule = {
+	...sectorDrawRule,
+	id: "point18:anchor-radii",
+	derive(points) {
+		return snapToWholeDegrees(sectorDrawRule.derive(points));
+	},
+	transform(event) {
+		return snapSectorAngle(sectorDrawRule.transform(event), event.activePointIndex, WHOLE_DEGREE_RADIANS);
+	}
+};
+//#endregion
 //#region src/draw-rules/area7.ts
 /**
 * Area7 anchor draw rule for Attack By Fire.
@@ -716,20 +815,20 @@ const ambushDrawRule = createMidpointPerpendicularDrawRule({
 });
 //#endregion
 //#region src/draw-rules/line1.ts
-function derive$9(points) {
+function derive$8(points) {
 	return clonePositions(points);
 }
 const line1DrawRule = {
 	id: "line1",
 	minimumUserPoints: 2,
-	derive: derive$9,
+	derive: derive$8,
 	transform(event) {
-		return derive$9(event.next);
+		return derive$8(event.next);
 	}
 };
 //#endregion
 //#region src/draw-rules/line3.ts
-function derive$8(points) {
+function derive$7(points) {
 	return clonePositions(points);
 }
 /**
@@ -744,23 +843,23 @@ const line3DrawRule = {
 	id: "line3",
 	minimumUserPoints: 3,
 	canonicalPointCount: 3,
-	derive: derive$8,
+	derive: derive$7,
 	transform(event) {
-		return derive$8(event.next);
+		return derive$7(event.next);
 	}
 };
 //#endregion
 //#region src/draw-rules/line9.ts
-function derive$7(points) {
+function derive$6(points) {
 	return clonePositions(points);
 }
 const line9DrawRule = {
 	id: "line9",
 	minimumUserPoints: 2,
 	canonicalPointCount: 2,
-	derive: derive$7,
+	derive: derive$6,
 	transform(event) {
-		return derive$7(event.next);
+		return derive$6(event.next);
 	}
 };
 //#endregion
@@ -867,7 +966,7 @@ const line24DrawRule = createMidpointPerpendicularDrawRule({
 });
 //#endregion
 //#region src/draw-rules/line26.ts
-function derive$6(points) {
+function derive$5(points) {
 	if (points.length === 2) {
 		const [p1, p2] = points;
 		const dx = p2[0] - p1[0];
@@ -906,9 +1005,9 @@ const line26DrawRule = {
 	minimumUserPoints: 4,
 	minimumPreviewPoints: 2,
 	canonicalPointCount: 4,
-	derive: derive$6,
+	derive: derive$5,
 	transform(event) {
-		return derive$6(event.next);
+		return derive$5(event.next);
 	}
 };
 //#endregion
@@ -921,7 +1020,7 @@ function deriveArcPoint(p1, p2, p4) {
 	if (!arc) return [(p2[0] + p4[0]) / 2, (p2[1] + p4[1]) / 2];
 	return unproject(arc.midpoint[0], arc.midpoint[1]);
 }
-function derive$5(points) {
+function derive$4(points) {
 	if (points.length < 2) return clonePositions(points);
 	const [p1, p2] = points;
 	if (points.length === 2) {
@@ -960,7 +1059,7 @@ const line27DrawRule = {
 	minimumUserPoints: 3,
 	minimumPreviewPoints: 2,
 	canonicalPointCount: 4,
-	derive: derive$5,
+	derive: derive$4,
 	transform(event) {
 		const { previous, next, activePointIndex } = event;
 		if (activePointIndex === 0 && previous.length >= 4 && next.length >= 4) {
@@ -993,7 +1092,7 @@ const line27DrawRule = {
 };
 //#endregion
 //#region src/draw-rules/area8.ts
-function derive$4(points) {
+function derive$3(points) {
 	if (points.length < 2) return clonePositions(points);
 	if (points.length !== 2) return clonePositions(points.slice(0, 4));
 	const p1 = clonePosition(points[0]);
@@ -1017,16 +1116,16 @@ const supportByFireDrawRule = {
 	id: "area8:support-by-fire",
 	minimumUserPoints: 2,
 	canonicalPointCount: 4,
-	derive: derive$4,
+	derive: derive$3,
 	transform(event) {
 		const { next } = event;
 		if (next.length === 4) return clonePositions(next);
-		return derive$4(next);
+		return derive$3(next);
 	}
 };
 //#endregion
 //#region src/draw-rules/axis1.ts
-function derive$3(points) {
+function derive$2(points) {
 	if (points.length < 2) return clonePositions(points);
 	if (points.length === 2) {
 		const tip = clonePosition(points[0]);
@@ -1064,10 +1163,10 @@ const axis1DrawRule = {
 	id: "axis1",
 	minimumUserPoints: 2,
 	trailingFixedSlots: 1,
-	derive: derive$3,
+	derive: derive$2,
 	transform(event) {
 		const { previous, next, activePointIndex } = event;
-		if (next.length < 3 || previous.length < 3) return derive$3(next);
+		if (next.length < 3 || previous.length < 3) return derive$2(next);
 		if (!(activePointIndex === 0 || activePointIndex === 1)) return clonePositions(next);
 		const metrics = calculateMetrics(previous);
 		if (!metrics) return clonePositions(next);
@@ -1120,7 +1219,7 @@ const counterattackByFireDrawRule = {
 };
 //#endregion
 //#region src/draw-rules/area21.ts
-function derive$2(points) {
+function derive$1(points) {
 	if (points.length === 2) return clonePositions([
 		points[0],
 		points[1],
@@ -1133,9 +1232,9 @@ const searchAreaDrawRule = {
 	minimumUserPoints: 3,
 	minimumPreviewPoints: 2,
 	canonicalPointCount: 3,
-	derive: derive$2,
+	derive: derive$1,
 	transform(event) {
-		return derive$2(event.next);
+		return derive$1(event.next);
 	}
 };
 //#endregion
@@ -1145,7 +1244,7 @@ const searchAreaDrawRule = {
 * edge. P3 is the next corner, constrained to the perpendicular through P2.
 * The generator derives the fourth corner.
 */
-function derive$1(points) {
+function derive(points) {
 	if (points.length < 2) return clonePositions(points);
 	const p1 = clonePosition(points[0]);
 	const p2 = clonePosition(points[1]);
@@ -1164,8 +1263,8 @@ function derive$1(points) {
 		frame?.pointAtNormalDistance(frame.signedNormalDistance(points[2])) ?? clonePosition(points[2])
 	];
 }
-function guidePoints$1(points) {
-	const canonical = derive$1(points);
+function guidePoints(points) {
+	const canonical = derive(points);
 	if (canonical.length < 3) return canonical;
 	const [c1, c2, c3] = canonical;
 	if (!c1 || !c2 || !c3) return canonical;
@@ -1191,16 +1290,16 @@ const rectangleDrawRule = {
 	minimumPreviewPoints: 2,
 	canonicalPointCount: 3,
 	showGuide: true,
-	guidePoints: guidePoints$1,
-	derive: derive$1,
+	guidePoints,
+	derive,
 	transform(event) {
 		const { previous, next, activePointIndex } = event;
-		if (previous.length < 3 || next.length < 3) return derive$1(next);
+		if (previous.length < 3 || next.length < 3) return derive(next);
 		const frame = createBaselineFrame(previous[0], previous[1], {
 			origin: "p2",
 			normal: "right"
 		});
-		if (!frame) return derive$1(next);
+		if (!frame) return derive(next);
 		if (activePointIndex === 0) return [
 			snapToAxis(next[0], frame.p2, frame.direction),
 			clonePosition(previous[1]),
@@ -1225,53 +1324,6 @@ const rectangleDrawRule = {
 				p3
 			];
 		}
-		return derive$1(next);
-	}
-};
-//#endregion
-//#region src/draw-rules/sector.ts
-const SECTOR_ANGLE_SNAP_RADIANS = Math.PI / 36;
-/**
-* Sector — anchor + inner-left edge + outer-right edge. The two radial points
-* independently control a radius and a true-north azimuth. Dragging the anchor
-* translates both edge points so the sector retains its size and orientation.
-*/
-function derive(points) {
-	return clonePositions(points.slice(0, 3));
-}
-function guidePoints(points) {
-	return points.length < 3 ? clonePositions(points) : [];
-}
-function constrainAngles(points, activePointIndex) {
-	const next = clonePositions(points);
-	if (activePointIndex !== 1 && activePointIndex !== 2) return next;
-	const anchor = next[0];
-	const point = next[activePointIndex];
-	if (!anchor || !point) return next;
-	const range = haversineDistance(anchor, point);
-	const bearing = sphericalBearing(anchor, point);
-	next[activePointIndex] = [...destinationPoint(anchor, range, Math.round(bearing / SECTOR_ANGLE_SNAP_RADIANS) * SECTOR_ANGLE_SNAP_RADIANS), ...point.slice(2)];
-	return next;
-}
-const sectorDrawRule = {
-	id: "sector:anchor-radii",
-	minimumUserPoints: 3,
-	canonicalPointCount: 3,
-	showGuide: true,
-	guidePoints,
-	constrainAngles,
-	derive,
-	transform(event) {
-		const { previous, next, activePointIndex } = event;
-		if (activePointIndex === 0 && previous.length >= 3 && next.length >= 3) {
-			const dx = next[0][0] - previous[0][0];
-			const dy = next[0][1] - previous[0][1];
-			return [
-				clonePosition(next[0]),
-				[previous[1][0] + dx, previous[1][1] + dy],
-				[previous[2][0] + dx, previous[2][1] + dy]
-			];
-		}
 		return derive(next);
 	}
 };
@@ -2103,6 +2155,43 @@ function buildGappedLine(verts, gaps) {
 	return parts;
 }
 //#endregion
+//#region src/style.ts
+/**
+* Per-feature style hint pinning a filled part to a solid interior. Attach to
+* a generator's intrinsic doctrinal accents — arrowheads, teeth, echelon
+* glyphs, barbs, blades — so a patterned (`hatch`, `dots`, …) fill set at the graphicsStyle
+* or measure layer never bleeds into a small silhouette and ruins its
+* legibility. The renderer only reads style hints, so one shared instance is
+* safe to reuse across every accent feature.
+*/
+const SOLID_ACCENT_FILL = { fillPattern: "solid" };
+/**
+* Ultimate fallback for the symbol color when no `color` or per-channel
+* override is supplied at any layer. Keeps a zero-config render monocolor
+* black and guarantees filled parts still render filled. See ADR-0011.
+*/
+const DEFAULT_SYMBOL_COLOR = "#000000";
+//#endregion
+//#region src/portrayal.ts
+const DEFAULT_STROKE_WIDTH_CSS_PIXELS = 2;
+const DEFAULT_STROKE_DASH_CSS_PIXELS = Object.freeze([]);
+const DEFAULT_LINE_CAP = "round";
+const DEFAULT_LINE_JOIN = "round";
+const DEFAULT_LABEL_HEIGHT_CSS_PIXELS = 14;
+const DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS = {
+	min: 8,
+	max: 24
+};
+/** Shared absent-value portrayal defaults; render output remains sparse. */
+const DEFAULT_PORTRAYAL = Object.freeze({
+	symbolColor: DEFAULT_SYMBOL_COLOR,
+	strokeWidthCssPixels: 2,
+	strokeDashCssPixels: DEFAULT_STROKE_DASH_CSS_PIXELS,
+	lineCap: DEFAULT_LINE_CAP,
+	lineJoin: DEFAULT_LINE_JOIN,
+	labelHeightCssPixels: 14
+});
+//#endregion
 //#region src/internal/angle-utils.ts
 /**
 * Wraps an angle (radians) into the half-open range (-π, π].
@@ -2609,10 +2698,50 @@ function pushEndLabels(out, verts, textForEnd, options = {}) {
 * measurement is available at generator time.
 */
 const LABEL_CHAR_ASPECT_RATIO = .6;
+/**
+* Half a single glyph's width, as a ratio of its height — the base boundary
+* gap a measure reserves for one intrinsic capital letter (Retain's R,
+* Contain's C). Wider than half `LABEL_CHAR_ASPECT_RATIO` because these
+* glyphs are stamped alone rather than averaged over a word.
+*/
+const LABEL_HALF_GLYPH_RATIO = .45;
 /** Estimated rendered width of `text` given its resolved label height in meters. */
 function estimatedTextWidth(text, textHeightMeters) {
 	return text.length * LABEL_CHAR_ASPECT_RATIO * textHeightMeters;
 }
+/** Resolve the label's final display size, then measure and convert it to construction metres. */
+function resolveTextMetrics(text, options, context, style = "regular") {
+	const legacyHeight = resolveLabelOffsetMeters(options, 1);
+	const constructionScale = context?.constructionMetersPerCssPixel;
+	if (!(constructionScale !== void 0 && constructionScale > 0)) return {
+		width: estimatedTextWidth(text, legacyHeight),
+		height: legacyHeight
+	};
+	let sizeCssPixels;
+	if (options.labelSizePixels !== void 0) sizeCssPixels = options.labelSizePixels;
+	else if (options.labelSize !== void 0) {
+		const requested = options.labelSize / constructionScale;
+		const requestedBand = context?.labelSizeClampCssPixels;
+		const band = requestedBand && Number.isFinite(requestedBand.min) && requestedBand.min >= 0 && Number.isFinite(requestedBand.max) && requestedBand.max >= 0 ? requestedBand : DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS;
+		const min = Math.min(band.min, band.max);
+		const max = Math.max(band.min, band.max);
+		sizeCssPixels = Math.min(max, Math.max(min, requested));
+	} else sizeCssPixels = 14;
+	const fallbackHeight = sizeCssPixels * constructionScale;
+	const measured = context?.measureText?.({
+		text,
+		style,
+		sizeCssPixels
+	});
+	if (!measured || !Number.isFinite(measured.widthCssPixels) || measured.widthCssPixels < 0 || !Number.isFinite(measured.heightCssPixels) || measured.heightCssPixels < 0) return {
+		width: estimatedTextWidth(text, fallbackHeight),
+		height: fallbackHeight
+	};
+	return {
+		width: measured.widthCssPixels * constructionScale,
+		height: measured.heightCssPixels * constructionScale
+	};
+}
 /** The end-label text for a phase-line naming, or `""` when unnamed. */
 function phaseLineLabelText(name, includePrefix) {
 	if (!name) return "";
@@ -2624,17 +2753,17 @@ function phaseLineLabelText(name, includePrefix) {
 * {@link pushEndLabels}. When another beyond-tip label is present, its
 * estimated width is added so the hostile marker remains outermost.
 */
-function pushHostileEndLabels(out, verts, hostileText, options = {}, occupiedTextForEnd = "") {
+function pushHostileEndLabels(out, verts, hostileText, options = {}, occupiedTextForEnd = "", context) {
 	if (!hostileText) return;
 	const frames = endFrames(verts);
 	const sizeProps = labelSizeProps(options);
-	const textHeight = resolveLabelOffsetMeters(options, 1);
-	const clearance = resolveLabelOffsetMeters(options, END_LABEL_CLEARANCE_RATIO + Math.max(0, options.labelPadding ?? 0));
 	for (const end of ["start", "end"]) {
 		const frame = frames[end];
 		if (!frame) continue;
 		const occupiedText = typeof occupiedTextForEnd === "string" ? occupiedTextForEnd : occupiedTextForEnd(end);
-		const distance = clearance + (occupiedText ? estimatedTextWidth(occupiedText, textHeight) + clearance : 0);
+		const metrics = resolveTextMetrics(occupiedText || hostileText, options, context);
+		const clearance = (END_LABEL_CLEARANCE_RATIO + Math.max(0, options.labelPadding ?? 0)) * metrics.height;
+		const distance = clearance + (occupiedText ? metrics.width + clearance : 0);
 		pushLabel(out, vecAdd(frame.point, vecScale(frame.along, distance)), hostileText, labelRotationAlong(frame.along), sizeProps, frame.along[0] >= 0 ? "start" : "end", "N", `label:N:${end}`);
 	}
 }
@@ -2693,7 +2822,7 @@ function pushEndLabelsAbove(out, verts, textForEnd, options = {}) {
 * (via {@link pushEndLabels} or {@link pushEndLabelsAbove}, per `placement`)
 * as a complete FeatureCollection.
 */
-function fixedLabelLineFeatures(positions, options, textForEnd, hostileText) {
+function fixedLabelLineFeatures(positions, options, textForEnd, hostileText, context) {
 	const { part, placement = "beyond", phaseLineName, includePrefix = true, smooth, smoothResolution, ...sizeOptions } = options;
 	const verts = smoothLineVerts(positions.map((p) => project(p[0], p[1])), {
 		smooth,
@@ -2713,7 +2842,7 @@ function fixedLabelLineFeatures(positions, options, textForEnd, hostileText) {
 	else pushEndLabels(labelFeatures, verts, textForEnd, sizeOptions);
 	const nameText = phaseLineLabelText(phaseLineName?.trim(), includePrefix);
 	if (nameText) pushEndLabels(labelFeatures, verts, nameText, sizeOptions);
-	pushHostileEndLabels(labelFeatures, verts, hostileText, sizeOptions, nameText || (placement === "beyond" ? textForEnd : ""));
+	pushHostileEndLabels(labelFeatures, verts, hostileText, sizeOptions, nameText || (placement === "beyond" ? textForEnd : ""), context);
 	features.push(...labelFeatures);
 	return {
 		type: "FeatureCollection",
@@ -2879,10 +3008,9 @@ function nonNegative$1(value, fallback) {
 * later `buildGappedLine` walk); `segments`/`totalLength` describe the full
 * route that anchors the default label placement.
 */
-function directionLabelGap(verts, segments, totalLength, fraction, text, options, placement = {}) {
+function directionLabelGap(verts, segments, totalLength, fraction, text, options, placement = {}, context) {
 	if (!text) return void 0;
-	const textHeight = resolveLabelOffsetMeters(options, 1);
-	const textWidth = estimatedTextWidth(text, textHeight);
+	const { width: textWidth, height: textHeight } = resolveTextMetrics(text, options, context);
 	const clearance = (LABEL_GAP_CLEARANCE_RATIO + Math.max(0, options.labelPadding ?? 0)) * textHeight;
 	const frame = pointAlongPolyline(segments, totalLength, fraction);
 	const rotation = placement.rotation ?? (frame ? labelRotationAlong(frame.along) : 0);
@@ -2943,7 +3071,7 @@ function createDirectionOfAttackLine(coordinates, options, textAmplifiers, confi
 		shaftVerts.push(innerTip);
 	}
 	const labelPosition = clampLinePosition(options.labelPosition, DEFAULT_DIRECTION_LABEL_POSITION);
-	const labelGap = directionLabelGap(shaftVerts, segments, totalLength, labelPosition, textAmplifiers.T, options, resolveAmplifierPlacement(context.amplifierPlacements?.T));
+	const labelGap = directionLabelGap(shaftVerts, segments, totalLength, labelPosition, textAmplifiers.T, options, resolveAmplifierPlacement(context.amplifierPlacements?.T), context);
 	const lines = [...buildGappedLine(shaftVerts, labelGap ? [labelGap] : []), arrowhead.map((point) => unproject(point[0], point[1]))];
 	const features = [{
 		type: "Feature",
@@ -3227,7 +3355,7 @@ function createDirectionOfAttackAviation(coordinates, options = {}, textAmplifie
 	const bowTieB = vecSub(bowTieStart, vecScale(bowTiePerp, bowTieHalfWidth));
 	const bowTieC = vecAdd(bowTieEnd, vecScale(bowTiePerp, bowTieHalfWidth));
 	const bowTieD = vecSub(bowTieEnd, vecScale(bowTiePerp, bowTieHalfWidth));
-	const labelGap = directionLabelGap(verts, segments, totalLength, labelPosition, textAmplifiers.T, resolved, resolveAmplifierPlacement(context.amplifierPlacements?.T));
+	const labelGap = directionLabelGap(verts, segments, totalLength, labelPosition, textAmplifiers.T, resolved, resolveAmplifierPlacement(context.amplifierPlacements?.T), context);
 	const features = [{
 		type: "Feature",
 		properties: { part: "direction-of-attack-aviation" },
@@ -3807,9 +3935,12 @@ function ringLabelAnchor(verts) {
 * overlaps the finite contacted edge; intrinsic markers always mask. Callers
 * own marker names, anchors, rotation, clearance, placement keys, and fields.
 */
-function pushBoundaryMarkers(out, maskVerts, text, anchors, options, amplifierPlacements) {
+function pushBoundaryMarkers(out, maskVerts, text, anchors, options, amplifierPlacements, context, labelOptions) {
 	const { rotation, textHeight, clearance, sizeProps } = options;
-	const textWidth = estimatedTextWidth(text, textHeight);
+	const metrics = resolveTextMetrics(text, labelOptions ?? { labelSize: textHeight }, context);
+	const textWidth = metrics.width;
+	const resolvedTextHeight = metrics.height;
+	const resolvedClearance = textHeight > 0 ? clearance * (resolvedTextHeight / textHeight) : clearance;
 	const gaps = [];
 	for (const anchor of anchors) {
 		const labelPlacementKey = options.placementKeyPrefix ? `${options.placementKeyPrefix}:${anchor.side}` : void 0;
@@ -3819,21 +3950,21 @@ function pushBoundaryMarkers(out, maskVerts, text, anchors, options, amplifierPl
 		pushLabel(out, labelPoint, text, options.followPlacementRotation ? boxRotation : rotation, sizeProps, void 0, options.amplifierField, labelPlacementKey);
 		const contact = placement.position !== void 0 || options.rescanDefaultAnchors === true || anchor.contact === void 0 ? nearestPointOnPolyline(maskVerts, labelPoint) : anchor.contact;
 		if (!contact) continue;
-		if (placement.position && !labelBoxIntersectsSegment(labelPoint, ...contact.edge, textWidth, textHeight, boxRotation)) continue;
-		const tangentExtent = labelHalfExtent(contact.along, textWidth, textHeight, boxRotation) + clearance;
+		if (placement.position && !labelBoxIntersectsSegment(labelPoint, ...contact.edge, textWidth, resolvedTextHeight, boxRotation)) continue;
+		const tangentExtent = labelHalfExtent(contact.along, textWidth, resolvedTextHeight, boxRotation) + resolvedClearance;
 		pushWrappedGap(gaps, contact.arc - tangentExtent, contact.arc + tangentExtent, contact.totalArc);
 	}
 	return gaps;
 }
 /** Emits movable Field N markers using the generic boundary-marker knockout path. */
-function pushHostileMarkers(out, maskVerts, text, anchors, options, amplifierPlacements) {
+function pushHostileMarkers(out, maskVerts, text, anchors, options, amplifierPlacements, context, labelOptions) {
 	return pushBoundaryMarkers(out, maskVerts, text, anchors, {
 		...options,
 		placementKeyPrefix: "label:N",
 		amplifierField: "N"
-	}, amplifierPlacements);
+	}, amplifierPlacements, context, labelOptions);
 }
-function pushAreaLabels(out, ringVerts, texts, options = {}, amplifierPlacements, maskBoundary) {
+function pushAreaLabels(out, ringVerts, texts, options = {}, amplifierPlacements, maskBoundary, context) {
 	if (ringVerts.length < 2) return [];
 	const sizeProps = labelSizeProps(options);
 	const padding = Math.max(0, options.labelPadding ?? 0);
@@ -3876,7 +4007,7 @@ function pushAreaLabels(out, ringVerts, texts, options = {}, amplifierPlacements
 		clearance: (ENY_CLEARANCE_RATIO + padding) * textHeight + Math.max(0, maskBoundary?.extraClearanceMeters ?? 0),
 		sizeProps,
 		rescanDefaultAnchors: maskRingVerts !== ringVerts
-	}, amplifierPlacements);
+	}, amplifierPlacements, context, options);
 }
 /**
 * Boundary + fill features for a pattern-filled area (e.g. Limited Access Area,
@@ -3955,11 +4086,11 @@ function boundaryFeature(verts, gaps) {
 * echelon-masked boundary, ADR-0023) instead of a closed `Polygon` — the
 * common (no `N`) case is unaffected.
 */
-function labeledAreaFeatures(positions, options, texts, amplifierPlacements) {
+function labeledAreaFeatures(positions, options, texts, amplifierPlacements, context) {
 	const { smooth = false, smoothResolution = DEFAULT_SMOOTH_RESOLUTION$9, ...labelOptions } = options;
 	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION$9);
 	const labelFeatures = [];
-	const features = [boundaryFeature(verts, pushAreaLabels(labelFeatures, verts, texts, labelOptions, amplifierPlacements))];
+	const features = [boundaryFeature(verts, pushAreaLabels(labelFeatures, verts, texts, labelOptions, amplifierPlacements, void 0, context))];
 	features.push(...labelFeatures);
 	return {
 		type: "FeatureCollection",
@@ -4003,7 +4134,7 @@ const AREA_METADATA = {
 * marker, per {@link labeledAreaFeatures}.
 */
 function createArea(positions, options = {}, textAmplifiers = {}, context = {}) {
-	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, ""), context.amplifierPlacements);
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, ""), context.amplifierPlacements, context);
 }
 const AREA = defineControlMeasure({
 	metadata: AREA_METADATA,
@@ -4022,23 +4153,6 @@ const AREA = defineControlMeasure({
 	}
 });
 //#endregion
-//#region src/style.ts
-/**
-* Per-feature style hint pinning a filled part to a solid interior. Attach to
-* a generator's intrinsic doctrinal accents — arrowheads, teeth, echelon
-* glyphs, barbs, blades — so a patterned (`hatch`, `dots`, …) fill set at the graphicsStyle
-* or measure layer never bleeds into a small silhouette and ruins its
-* legibility. The renderer only reads style hints, so one shared instance is
-* safe to reuse across every accent feature.
-*/
-const SOLID_ACCENT_FILL = { fillPattern: "solid" };
-/**
-* Ultimate fallback for the symbol color when no `color` or per-channel
-* override is supplied at any layer. Keeps a zero-config render monocolor
-* black and guarantees filled parts still render filled. See ADR-0011.
-*/
-const DEFAULT_SYMBOL_COLOR = "#000000";
-//#endregion
 //#region src/generators/cm15-maneuver-areas/area-defense.ts
 const DEFAULT_AREA_DEFENSE_OPTIONS = {
 	arrowOpeningAngle: 30,
@@ -4122,13 +4236,13 @@ const AREA_DEFENSE_METADATA = {
 		}
 	]
 };
-function pointOnCircle(center, radius, angle) {
+function pointOnCircle$1(center, radius, angle) {
 	return vecAdd(center, [radius * Math.cos(angle), radius * Math.sin(angle)]);
 }
-function sampleArc$1(center, radius, start, end) {
+function sampleArc$2(center, radius, start, end) {
 	const span = end - start;
 	const segments = Math.max(8, Math.round(48 * Math.abs(span) / Math.PI));
-	return Array.from({ length: segments + 1 }, (_, index) => pointOnCircle(center, radius, start + span * index / segments));
+	return Array.from({ length: segments + 1 }, (_, index) => pointOnCircle$1(center, radius, start + span * index / segments));
 }
 function openArrowhead(tip, direction, length) {
 	const base = vecSub(tip, [direction[0] * length, direction[1] * length]);
@@ -4159,8 +4273,8 @@ function createAreaDefense(coordinates, options = {}) {
 	const upperEnd = upperTipAngle;
 	const lowerStart = labelCenter - labelHalf;
 	const lowerEnd = upperTipAngle + arrowHalf * 2 - Math.PI * 2;
-	const upperArc = sampleArc$1(center, radius, upperStart, upperEnd);
-	const lowerArc = sampleArc$1(center, radius, lowerStart, lowerEnd);
+	const upperArc = sampleArc$2(center, radius, upperStart, upperEnd);
+	const lowerArc = sampleArc$2(center, radius, lowerStart, lowerEnd);
 	const arrowLength = radius * Math.max(0, resolved.arrowheadLengthRatio);
 	const upperDirection = [-Math.sin(upperEnd), Math.cos(upperEnd)];
 	const lowerDirection = [Math.sin(lowerEnd), -Math.cos(lowerEnd)];
@@ -4185,17 +4299,17 @@ function createAreaDefense(coordinates, options = {}) {
 	const barbPolygons = [];
 	for (const arc of barbArcs) for (let ordinal = 1; ordinal <= arc.count; ordinal++) {
 		const angle = arc.start + (arc.end - arc.start) * ordinal / (arc.count + 1);
-		const left = pointOnCircle(center, radius, angle - barbHalfAngle);
-		const right = pointOnCircle(center, radius, angle + barbHalfAngle);
+		const left = pointOnCircle$1(center, radius, angle - barbHalfAngle);
+		const right = pointOnCircle$1(center, radius, angle + barbHalfAngle);
 		const ring = [
 			left,
-			pointOnCircle(center, radius + barbLength, angle),
+			pointOnCircle$1(center, radius + barbLength, angle),
 			right,
 			left
 		].map((point) => unproject(point[0], point[1]));
 		barbPolygons.push([ring]);
 	}
-	const labelPoint = pointOnCircle(center, radius, labelCenter);
+	const labelPoint = pointOnCircle$1(center, radius, labelCenter);
 	return {
 		type: "FeatureCollection",
 		features: [
@@ -4283,7 +4397,7 @@ const AREA_OF_OPERATIONS_METADATA = {
 * `H`/`W`/`W1`/`N` amplifier rows, per {@link labeledAreaFeatures}.
 */
 function createAreaOfOperations(positions, options = {}, textAmplifiers = {}, context = {}) {
-	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "AO"), context.amplifierPlacements);
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "AO"), context.amplifierPlacements, context);
 }
 const AREA_OF_OPERATIONS = defineControlMeasure({
 	metadata: AREA_OF_OPERATIONS_METADATA,
@@ -4342,7 +4456,7 @@ const NAMED_AREA_OF_INTEREST_METADATA = {
 * an `N` (Field N) ENY marker, per {@link labeledAreaFeatures}.
 */
 function createNamedAreaOfInterest(positions, options = {}, textAmplifiers = {}, context = {}) {
-	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "NAI"), context.amplifierPlacements);
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "NAI"), context.amplifierPlacements, context);
 }
 const NAMED_AREA_OF_INTEREST = defineControlMeasure({
 	metadata: NAMED_AREA_OF_INTEREST_METADATA,
@@ -4401,7 +4515,7 @@ const TARGET_AREA_OF_INTEREST_METADATA = {
 * an `N` (Field N) ENY marker, per {@link labeledAreaFeatures}.
 */
 function createTargetAreaOfInterest(positions, options = {}, textAmplifiers = {}, context = {}) {
-	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "TAI"), context.amplifierPlacements);
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "TAI"), context.amplifierPlacements, context);
 }
 const TARGET_AREA_OF_INTEREST = defineControlMeasure({
 	metadata: TARGET_AREA_OF_INTEREST_METADATA,
@@ -4496,7 +4610,7 @@ function createAirfieldZone(positions, options = {}, textAmplifiers = {}, contex
 	const { smooth = DEFAULT_AIRFIELD_ZONE_OPTIONS.smooth, smoothResolution = DEFAULT_AIRFIELD_ZONE_OPTIONS.smoothResolution, glyphSizeRatio = DEFAULT_AIRFIELD_ZONE_OPTIONS.glyphSizeRatio, ...labelOptions } = options;
 	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION$8);
 	const enyLabels = [];
-	const features = [boundaryFeature(verts, textAmplifiers.N ? pushAreaLabels(enyLabels, verts, { hostile: textAmplifiers.N }, labelOptions, context.amplifierPlacements) : [])];
+	const features = [boundaryFeature(verts, textAmplifiers.N ? pushAreaLabels(enyLabels, verts, { hostile: textAmplifiers.N }, labelOptions, context.amplifierPlacements, void 0, context) : [])];
 	let minX = Infinity;
 	let maxX = -Infinity;
 	for (const [x] of verts) {
@@ -4572,13 +4686,13 @@ const DEFAULT_ECHELON_LABELED_AREA_OPTIONS = {
 * before carving the boundary, so either (or both) opens it into a gapped
 * `MultiLineString`; with neither, the boundary is a closed `Polygon`.
 */
-function echelonLabeledAreaFeatures(positions, options, texts, amplifierPlacements) {
+function echelonLabeledAreaFeatures(positions, options, texts, amplifierPlacements, context) {
 	const { echelon = DEFAULT_ECHELON_LABELED_AREA_OPTIONS.echelon, echelonSize = DEFAULT_ECHELON_LABELED_AREA_OPTIONS.echelonSize, echelonSizePixels, echelonPadding = DEFAULT_ECHELON_LABELED_AREA_OPTIONS.echelonPadding, echelonPosition = DEFAULT_ECHELON_LABELED_AREA_OPTIONS.echelonPosition, echelonAnchor, metersPerPixel, smooth = DEFAULT_ECHELON_LABELED_AREA_OPTIONS.smooth, smoothResolution = DEFAULT_ECHELON_LABELED_AREA_OPTIONS.smoothResolution, ...labelOptions } = options;
 	const h = resolveEchelonHeight(echelonSize, echelonSizePixels, metersPerPixel);
 	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION$7);
 	const { strokes, fills, gaps: echelonGaps } = placeEchelon(buildAreaPerimeter(verts), h, echelon, echelonPadding, echelonPosition, echelonAnchor);
 	const labelFeatures = [];
-	const enyGaps = pushAreaLabels(labelFeatures, verts, texts, labelOptions, amplifierPlacements);
+	const enyGaps = pushAreaLabels(labelFeatures, verts, texts, labelOptions, amplifierPlacements, void 0, context);
 	const features = [boundaryFeature(verts, [...echelonGaps, ...enyGaps])];
 	if (strokes.length > 0) features.push({
 		type: "Feature",
@@ -4654,7 +4768,7 @@ const BASE_CAMP_METADATA = {
 * boundary, per {@link echelonLabeledAreaFeatures}.
 */
 function createBaseCamp(positions, options = {}, textAmplifiers = {}, context = {}) {
-	return echelonLabeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "BC"), context.amplifierPlacements);
+	return echelonLabeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "BC"), context.amplifierPlacements, context);
 }
 const BASE_CAMP = defineControlMeasure({
 	metadata: BASE_CAMP_METADATA,
@@ -4712,7 +4826,7 @@ const GUERRILLA_BASE_METADATA = {
 * straddling the boundary, per {@link echelonLabeledAreaFeatures}.
 */
 function createGuerrillaBase(positions, options = {}, textAmplifiers = {}, context = {}) {
-	return echelonLabeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "GB"), context.amplifierPlacements);
+	return echelonLabeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "GB"), context.amplifierPlacements, context);
 }
 const GUERRILLA_BASE = defineControlMeasure({
 	metadata: GUERRILLA_BASE_METADATA,
@@ -4774,7 +4888,7 @@ const GENERIC_C2_AREA_METADATA = {
 * `H`/`W`/`W1`/`N` amplifier rows — no prefix, per {@link labeledAreaFeatures}.
 */
 function createGenericC2Area(positions, options = {}, textAmplifiers = {}, context = {}) {
-	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers), context.amplifierPlacements);
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers), context.amplifierPlacements, context);
 }
 const GENERIC_C2_AREA = defineControlMeasure({
 	metadata: GENERIC_C2_AREA_METADATA,
@@ -4829,7 +4943,7 @@ const ASSEMBLY_AREA_METADATA = {
 * `H`/`W`/`W1`/`N` amplifier rows, per {@link labeledAreaFeatures}.
 */
 function createAssemblyArea(positions, options = {}, textAmplifiers = {}, context = {}) {
-	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "AA"), context.amplifierPlacements);
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "AA"), context.amplifierPlacements, context);
 }
 const ASSEMBLY_AREA = defineControlMeasure({
 	metadata: ASSEMBLY_AREA_METADATA,
@@ -5021,13 +5135,13 @@ function ditchPaths(projectedPoints, options) {
 function buildAntitankDitchTriangles(basePath, options) {
 	return generateAntitankDitchTriangles(basePath, calculateAntitankDitchHeight(options), options.toothWidthRatio ?? DEFAULT_TOOTH_WIDTH_RATIO$1);
 }
-function createAntitankDitchUnderConstruction(positions, options = {}, textAmplifiers = {}) {
+function createAntitankDitchUnderConstruction(positions, options = {}, textAmplifiers = {}, context = {}) {
 	const { smoothedPath, basePath } = ditchPaths(positions.map((position) => project(position[0], position[1])), options);
 	const triangles = buildAntitankDitchTriangles(basePath, options);
 	const baseLine = options.smooth ? basePath.map((point) => unproject(point[0], point[1])) : positions.map((position) => [position[0], position[1]]);
 	const triangleLines = triangles.map((triangle) => triangle.map((point) => unproject(point[0], point[1])));
 	const labels = [];
-	pushHostileEndLabels(labels, smoothedPath, textAmplifiers.N, options);
+	pushHostileEndLabels(labels, smoothedPath, textAmplifiers.N, options, "", context);
 	return {
 		type: "FeatureCollection",
 		features: [{
@@ -5040,13 +5154,13 @@ function createAntitankDitchUnderConstruction(positions, options = {}, textAmpli
 		}, ...labels]
 	};
 }
-function createAntitankDitchCompleted(positions, options = {}, textAmplifiers = {}) {
+function createAntitankDitchCompleted(positions, options = {}, textAmplifiers = {}, context = {}) {
 	const { smoothedPath, basePath } = ditchPaths(positions.map((position) => project(position[0], position[1])), options);
 	const polygons = buildAntitankDitchTriangles(basePath, options).map((triangle) => {
 		return [[...triangle, triangle[0]].map((point) => unproject(point[0], point[1]))];
 	});
 	const labels = [];
-	pushHostileEndLabels(labels, smoothedPath, textAmplifiers.N, options);
+	pushHostileEndLabels(labels, smoothedPath, textAmplifiers.N, options, "", context);
 	return {
 		type: "FeatureCollection",
 		features: [{
@@ -5136,7 +5250,7 @@ function generateAntitankWallPoints(projectedPoints, toothHeight, toothWidthRati
 	}
 	return wallPoints;
 }
-function createAntitankWall(positions, options = {}, textAmplifiers = {}) {
+function createAntitankWall(positions, options = {}, textAmplifiers = {}, context = {}) {
 	const toothHeight = calculateAntitankDitchHeight(options);
 	const toothWidthRatio = options.toothWidthRatio ?? DEFAULT_TOOTH_WIDTH_RATIO;
 	const toothSpacingRatio = options.toothSpacingRatio ?? DEFAULT_TOOTH_SPACING_RATIO;
@@ -5144,7 +5258,7 @@ function createAntitankWall(positions, options = {}, textAmplifiers = {}) {
 	const smoothedPath = smoothLineVerts(projectedPoints, options, 16);
 	const wallLine = generateAntitankWallPoints(options.smooth && projectedPoints.length >= 3 ? evenlySpacePath(smoothedPath, Math.max(EPSILON, toothWidthRatio) * toothHeight) : smoothedPath, toothHeight, toothWidthRatio, toothSpacingRatio).map((point) => unproject(point[0], point[1]));
 	const labels = [];
-	pushHostileEndLabels(labels, smoothedPath, textAmplifiers.N, options);
+	pushHostileEndLabels(labels, smoothedPath, textAmplifiers.N, options, "", context);
 	return {
 		type: "FeatureCollection",
 		features: [{
@@ -5591,7 +5705,7 @@ function createBattlePosition(positions, options = {}, textAmplifiers = {}, cont
 	const enyGaps = pushAreaLabels(labelFeatures, verts, {
 		name: textAmplifiers.T,
 		hostile: textAmplifiers.N
-	}, options, context.amplifierPlacements);
+	}, options, context.amplifierPlacements, void 0, context);
 	const boundaryCoords = buildGappedLine(verts, [...gaps, ...enyGaps]);
 	const features = [];
 	if (boundaryCoords.length > 0) features.push({
@@ -5628,41 +5742,253 @@ function createBattlePosition(positions, options = {}, textAmplifiers = {}, cont
 		features
 	};
 }
-/**
-* `freezeOrientation` hook (ADR-0023) shared by Battle Position and Strong
-* Point: pins the echelon anchor to its current bottom-edge fraction so a
-* subsequent rigid rotation of `controlPoints` (e.g. the transform box's
-* rotate grip) does not re-derive a different "bottom edge" against the
-* rotated geometry. Delegates to {@link makeFreezeEchelonAnchor}, the shared
-* factory every echelon-carrying area measure (Battle Position, Strong
-* Point, Base Camp, Guerrilla Base) builds its own instance from — this
-* export just binds Battle Position's own defaults, keeping strongPoint.ts's
-* existing import (and any other importer) unchanged.
-*/
-const freezeEchelonAnchor = makeFreezeEchelonAnchor({
-	echelon: DEFAULT_BATTLE_POSITION_OPTIONS.echelon,
-	smooth: DEFAULT_BATTLE_POSITION_OPTIONS.smooth,
-	smoothResolution: DEFAULT_BATTLE_POSITION_OPTIONS.smoothResolution
-});
-const BATTLE_POSITION = defineControlMeasure({
-	metadata: BATTLE_POSITION_METADATA,
-	generator: createBattlePosition,
-	defaultOptions: DEFAULT_BATTLE_POSITION_OPTIONS,
-	rule: area1DrawRule,
-	freezeOrientation: freezeEchelonAnchor,
+/**
+* `freezeOrientation` hook (ADR-0023) shared by Battle Position and Strong
+* Point: pins the echelon anchor to its current bottom-edge fraction so a
+* subsequent rigid rotation of `controlPoints` (e.g. the transform box's
+* rotate grip) does not re-derive a different "bottom edge" against the
+* rotated geometry. Delegates to {@link makeFreezeEchelonAnchor}, the shared
+* factory every echelon-carrying area measure (Battle Position, Strong
+* Point, Base Camp, Guerrilla Base) builds its own instance from — this
+* export just binds Battle Position's own defaults, keeping strongPoint.ts's
+* existing import (and any other importer) unchanged.
+*/
+const freezeEchelonAnchor = makeFreezeEchelonAnchor({
+	echelon: DEFAULT_BATTLE_POSITION_OPTIONS.echelon,
+	smooth: DEFAULT_BATTLE_POSITION_OPTIONS.smooth,
+	smoothResolution: DEFAULT_BATTLE_POSITION_OPTIONS.smoothResolution
+});
+const BATTLE_POSITION = defineControlMeasure({
+	metadata: BATTLE_POSITION_METADATA,
+	generator: createBattlePosition,
+	defaultOptions: DEFAULT_BATTLE_POSITION_OPTIONS,
+	rule: area1DrawRule,
+	freezeOrientation: freezeEchelonAnchor,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: { T: "ALFA" },
+		options: {
+			echelonSize: 200,
+			smooth: true,
+			labelSize: 96
+		}
+	}
+});
+//#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/internal/projected-arc.ts
+/** The arc point at `angle`, in projected meters. */
+function arcPointAt(center, startRadius, bulgeRadius, angle) {
+	return vecAdd(center, vecAdd(vecScale(startRadius, Math.cos(angle)), vecScale(bulgeRadius, Math.sin(angle))));
+}
+/**
+* Samples the arc from `start` to `end` radians as unprojected positions.
+* `resolution` is the segment count a full half-turn would use, so the density
+* of a partial arc stays proportional to how much of the circle it covers.
+*/
+function sampleProjectedArc(center, startRadius, bulgeRadius, start, end, resolution) {
+	const segments = Math.max(2, Math.ceil(resolution * Math.abs(end - start) / Math.PI));
+	return Array.from({ length: segments + 1 }, (_, index) => {
+		const point = arcPointAt(center, startRadius, bulgeRadius, start + (end - start) * index / segments);
+		return unproject(point[0], point[1]);
+	});
+}
+//#endregion
+//#region src/generators/cm15-maneuver-areas/contain.ts
+const DEFAULT_CONTAIN_OPTIONS = {
+	labelPadding: .2,
+	resolution: 32
+};
+const CONTAIN_METADATA = {
+	id: "contain",
+	name: "Contain",
+	description: "Stops, holds, or surrounds enemy forces and prevents them from withdrawing or using them elsewhere.",
+	entity: "Maneuver Areas",
+	entityType: "Battle Position",
+	entitySubtype: "Contain",
+	value: "151204",
+	minCoordinates: 3,
+	maxCoordinates: 3,
+	geometry: "area",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Area5",
+	capturesLabelSize: true,
+	textAmplifiers: [AREA_HOSTILE_AMPLIFIER],
+	params: [{
+		key: "labelPadding",
+		presentationTier: "advanced",
+		label: "Label padding",
+		description: "Extra clearance around C and ENY, as a ratio of label height",
+		type: "number",
+		min: 0,
+		max: 2,
+		step: .05
+	}, {
+		key: "resolution",
+		presentationTier: "advanced",
+		label: "Resolution",
+		description: "Number of segments used to approximate the semicircle",
+		type: "number",
+		min: 8,
+		max: 128,
+		step: 1
+	}]
+};
+/** Where the ENY label sits along the arrow, as a ratio of its full length. */
+const HOSTILE_LABEL_POSITION_RATIO = .55;
+/** Creates the Contain semicircle, inward tics, center-pointing arrow, and C label. */
+function createContain(coordinates, options = {}, textAmplifiers = {}, context = {}) {
+	const p1 = project(coordinates[0][0], coordinates[0][1]);
+	const p2 = project(coordinates[1][0], coordinates[1][1]);
+	const p3 = project(coordinates[2][0], coordinates[2][1]);
+	const diameterLength = vecMag(vecSub(p2, p1));
+	if (diameterLength < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const center = [(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2];
+	const arrowVector = vecSub(p3, center);
+	const arrowLength = vecMag(arrowVector);
+	if (arrowLength < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const radius = diameterLength / 2;
+	const openingDirection = vecNorm(arrowVector);
+	const labelRotation = labelRotationAlong(openingDirection);
+	const startRadius = vecSub(p1, center);
+	const bulgeRadius = vecScale(openingDirection, -radius);
+	const h = Math.min(radius * .45, Math.max(EPSILON, resolveLabelOffsetMeters(options, 1, radius * .12)));
+	const labelPadding = Math.max(0, options.labelPadding ?? DEFAULT_CONTAIN_OPTIONS.labelPadding);
+	const resolution = Math.round(Math.min(128, Math.max(8, options.resolution ?? DEFAULT_CONTAIN_OPTIONS.resolution)));
+	const hostileText = textAmplifiers.N ?? "ENY";
+	const labelHalfAngle = Math.min(Math.PI / 3, h * (LABEL_HALF_GLYPH_RATIO + labelPadding) / radius);
+	const labelAngle = Math.PI / 2;
+	const boundary = [sampleProjectedArc(center, startRadius, bulgeRadius, 0, labelAngle - labelHalfAngle, resolution), sampleProjectedArc(center, startRadius, bulgeRadius, labelAngle + labelHalfAngle, Math.PI, resolution)];
+	const tics = [];
+	const spacingAngle = h / radius;
+	for (let angle = spacingAngle / 2; angle < Math.PI; angle += spacingAngle) {
+		if (Math.abs(angle - labelAngle) <= labelHalfAngle) continue;
+		const outer = arcPointAt(center, startRadius, bulgeRadius, angle);
+		const inner = vecAdd(outer, vecScale(vecNorm(vecSub(center, outer)), h));
+		tics.push([unproject(outer[0], outer[1]), unproject(inner[0], inner[1])]);
+	}
+	const arrowhead = createArrowHeadRing(center, vecScale(openingDirection, -1), h, h).slice(0, 3);
+	const arrow = [];
+	const hostilePoint = vecAdd(center, vecScale(arrowVector, HOSTILE_LABEL_POSITION_RATIO));
+	if (hostileText) {
+		const metrics = resolveTextMetrics(hostileText, options, context);
+		const maximumHalfGap = arrowLength * Math.min(HOSTILE_LABEL_POSITION_RATIO, 1 - HOSTILE_LABEL_POSITION_RATIO);
+		const halfGap = Math.min(maximumHalfGap, metrics.width / 2 + labelPadding * metrics.height);
+		const farGapEdge = vecAdd(hostilePoint, vecScale(openingDirection, halfGap));
+		const nearGapEdge = vecAdd(hostilePoint, vecScale(openingDirection, -halfGap));
+		arrow.push([unproject(p3[0], p3[1]), unproject(farGapEdge[0], farGapEdge[1])], [unproject(nearGapEdge[0], nearGapEdge[1]), unproject(center[0], center[1])]);
+	} else arrow.push([unproject(p3[0], p3[1]), unproject(center[0], center[1])]);
+	arrow.push(arrowhead);
+	const labelPoint = arcPointAt(center, startRadius, bulgeRadius, labelAngle);
+	const sizeProps = labelSizeProps(options);
+	const features = [
+		{
+			type: "Feature",
+			properties: { part: "boundary" },
+			geometry: {
+				type: "MultiLineString",
+				coordinates: boundary
+			}
+		},
+		{
+			type: "Feature",
+			properties: { part: "tics" },
+			geometry: {
+				type: "MultiLineString",
+				coordinates: tics
+			}
+		},
+		{
+			type: "Feature",
+			properties: { part: "arrow" },
+			geometry: {
+				type: "MultiLineString",
+				coordinates: arrow
+			}
+		},
+		{
+			type: "Feature",
+			properties: {
+				part: "label",
+				labelPlacement: false,
+				text: "C",
+				rotation: labelRotation,
+				...sizeProps
+			},
+			geometry: {
+				type: "Point",
+				coordinates: unproject(labelPoint[0], labelPoint[1])
+			}
+		}
+	];
+	if (hostileText) features.push({
+		type: "Feature",
+		properties: {
+			part: "label",
+			labelPlacement: false,
+			amplifierField: "N",
+			text: hostileText,
+			rotation: labelRotation,
+			...sizeProps
+		},
+		geometry: {
+			type: "Point",
+			coordinates: unproject(hostilePoint[0], hostilePoint[1])
+		}
+	});
+	return {
+		type: "FeatureCollection",
+		features
+	};
+}
+const CONTAIN = defineControlMeasure({
+	metadata: CONTAIN_METADATA,
+	generator: createContain,
+	defaultOptions: DEFAULT_CONTAIN_OPTIONS,
+	rule: containDrawRule,
 	previewSample: {
 		controlPoints: [
-			[-1, -.5],
-			[1, -.5],
-			[1, .5],
-			[-1, .5]
+			[0, .7],
+			[0, -.7],
+			[1.5, 0]
 		],
-		textAmplifiers: { T: "ALFA" },
-		options: {
-			echelonSize: 200,
-			smooth: true,
-			labelSize: 96
-		}
+		options: { labelSize: 90 }
 	}
 });
 //#endregion
@@ -6189,7 +6515,7 @@ const BOUNDARY_METADATA = {
 * @param textAmplifiers - Normalized text amplifiers (ADR-0027): `T`/`AS` label
 *   unit 1 (left-of-travel side), `T1`/`AS1` label unit 2 (right-of-travel side).
 */
-function createBoundary(positions, options = {}, textAmplifiers = {}) {
+function createBoundary(positions, options = {}, textAmplifiers = {}, context = {}) {
 	const { echelon = DEFAULT_BOUNDARY_OPTIONS.echelon, echelonSize = DEFAULT_BOUNDARY_OPTIONS.echelonSize, echelonSizePixels, echelonPadding = DEFAULT_BOUNDARY_OPTIONS.echelonPadding, metersPerPixel, labelRepetitions = DEFAULT_BOUNDARY_OPTIONS.labelRepetitions, labelSpacing = DEFAULT_BOUNDARY_OPTIONS.labelSpacing, labelPosition = DEFAULT_BOUNDARY_OPTIONS.labelPosition, labelPadding = DEFAULT_BOUNDARY_OPTIONS.labelPadding, labelOrientation = DEFAULT_BOUNDARY_OPTIONS.labelOrientation, smooth = DEFAULT_BOUNDARY_OPTIONS.smooth, smoothResolution = DEFAULT_BOUNDARY_OPTIONS.smoothResolution } = options;
 	const unit1Designator = textAmplifiers.T ?? "";
 	const unit1Country = textAmplifiers.AS ?? "";
@@ -6273,7 +6599,7 @@ function createBoundary(positions, options = {}, textAmplifiers = {}) {
 		labelSize: h,
 		labelPadding
 	};
-	pushHostileEndLabels(labelFeatures, verts, textAmplifiers.N, hostileLabelOptions);
+	pushHostileEndLabels(labelFeatures, verts, textAmplifiers.N, hostileLabelOptions, "", context);
 	const boundaryCoords = buildGappedLine(verts, gaps);
 	const features = [];
 	if (boundaryCoords.length > 0) features.push({
@@ -6389,12 +6715,12 @@ const LIGHT_LINE_METADATA = {
 * Creates a Light line control measure: a polyline through `positions`
 * labeled "LL" above the line near each end.
 */
-function createLightLine(positions, options = {}, textAmplifiers = {}) {
+function createLightLine(positions, options = {}, textAmplifiers = {}, context = {}) {
 	return fixedLabelLineFeatures(positions, {
 		part: "light-line",
 		placement: "above",
 		...options
-	}, "LL", textAmplifiers.N);
+	}, "LL", textAmplifiers.N, context);
 }
 const LIGHT_LINE = defineControlMeasure({
 	metadata: LIGHT_LINE_METADATA,
@@ -6500,12 +6826,12 @@ const CENTER_LABEL_OFFSET_RATIO = .7;
 * above the line, T1/AS1 below). No center group is emitted when all four
 * amplifiers are empty.
 */
-function createEngineerWorkLine(positions, options = {}, textAmplifiers = {}) {
+function createEngineerWorkLine(positions, options = {}, textAmplifiers = {}, context = {}) {
 	const features = [...fixedLabelLineFeatures(positions, {
 		part: "engineer-work-line",
 		placement: "above",
 		...options
-	}, "EWL", textAmplifiers.N).features];
+	}, "EWL", textAmplifiers.N, context).features];
 	const { segments, totalLength } = polylineSegments(smoothLineVerts(positions.map((p) => project(p[0], p[1])), options, 12));
 	const frame = pointAlongPolyline(segments, totalLength, .5);
 	if (frame) {
@@ -6642,7 +6968,7 @@ const GENERIC_C2_LINE_METADATA = {
 * (inset from the tip, anchored toward the line's interior), one at
 * `base + perp·offset` and the other at `base − perp·offset`.
 */
-function createGenericC2Line(positions, options = {}, textAmplifiers = {}) {
+function createGenericC2Line(positions, options = {}, textAmplifiers = {}, context = {}) {
 	const { phaseLineName, includePrefix = true, smooth, smoothResolution, ...sizeOptions } = options;
 	const verts = smoothLineVerts(positions.map((p) => project(p[0], p[1])), {
 		smooth,
@@ -6674,7 +7000,7 @@ function createGenericC2Line(positions, options = {}, textAmplifiers = {}) {
 		}
 		const nameText = phaseLineLabelText(trimmedPhaseLineName, includePrefix);
 		if (nameText) pushEndLabels(labelFeatures, verts, nameText, sizeOptions);
-		pushHostileEndLabels(labelFeatures, verts, textAmplifiers.N, sizeOptions, nameText);
+		pushHostileEndLabels(labelFeatures, verts, textAmplifiers.N, sizeOptions, nameText, context);
 		features.push(...labelFeatures);
 	}
 	return {
@@ -7526,6 +7852,8 @@ const ARC_RESOLUTION_PARAMS = [{
 	max: 360,
 	step: 1
 }];
+//#endregion
+//#region src/generators/cm99-generic-graphics/params.ts
 const SMOOTH_PATH_PARAMS = [{
 	key: "smooth",
 	label: "Smooth",
@@ -7862,6 +8190,41 @@ const GENERIC_RECTANGLE = defineControlMeasure({
 	] }
 });
 //#endregion
+//#region src/internal/annular-sector.ts
+/**
+* Clockwise sweep in degrees from `leftAzimuth` to `rightAzimuth`. A non-zero
+* raw difference that normalizes to 0 means a full 360° fan.
+*
+* `collapseToleranceDegrees` (default 0, i.e. off) treats a near-zero or
+* near-360 sweep as a collapsed sector. Callers whose handle coordinates are
+* rounded need this: two handles placed on the same ray can recover bearings a
+* few thousandths of a degree apart, which would otherwise read as an
+* almost-360° fan.
+*/
+function clockwiseSweepDegrees(leftAzimuth, rightAzimuth, collapseToleranceDegrees = 0) {
+	const rawSweep = rightAzimuth - leftAzimuth;
+	const sweep = normalizeDegrees(rawSweep);
+	if (collapseToleranceDegrees > 0 && Math.min(sweep, 360 - sweep) < collapseToleranceDegrees) return 0;
+	return sweep === 0 && rawSweep !== 0 ? 360 : sweep;
+}
+/** Samples an arc of `sweepDegrees` at `radius`, starting from `leftAzimuth`. */
+function sampleArc$1(anchor, radius, leftAzimuth, sweepDegrees, resolution) {
+	const segmentCount = Math.max(1, Math.ceil(sweepDegrees / 360 * resolution));
+	return Array.from({ length: segmentCount + 1 }, (_, index) => {
+		return destinationPoint(anchor, radius, (leftAzimuth + index / segmentCount * sweepDegrees) * Math.PI / 180);
+	});
+}
+/** Closed ring tracing the outer arc, back along the inner arc, and closed. */
+function annularSectorRing(anchor, innerRadius, outerRadius, leftAzimuth, sweepDegrees, resolution) {
+	const outerArc = sampleArc$1(anchor, outerRadius, leftAzimuth, sweepDegrees, resolution);
+	const innerArc = sampleArc$1(anchor, innerRadius, leftAzimuth, sweepDegrees, resolution).reverse();
+	return [
+		...outerArc,
+		...innerArc,
+		outerArc[0]
+	];
+}
+//#endregion
 //#region src/generators/cm99-generic-graphics/sector.ts
 const DEFAULT_GENERIC_SECTOR_OPTIONS = {
 	filled: false,
@@ -7887,17 +8250,6 @@ const GENERIC_SECTOR_METADATA = {
 	drawRule: "Sector",
 	params: [...FILLED_AREA_PARAMS, ...ARC_RESOLUTION_PARAMS]
 };
-function clockwiseSweepDegrees(leftAzimuth, rightAzimuth) {
-	const rawSweep = rightAzimuth - leftAzimuth;
-	const sweep = normalizeDegrees(rawSweep);
-	return sweep === 0 && rawSweep !== 0 ? 360 : sweep;
-}
-function sampleArc(anchor, radius, leftAzimuth, sweepDegrees, resolution) {
-	const segmentCount = Math.max(1, Math.ceil(sweepDegrees / 360 * resolution));
-	return Array.from({ length: segmentCount + 1 }, (_, index) => {
-		return destinationPoint(anchor, radius, (leftAzimuth + index / segmentCount * sweepDegrees) * Math.PI / 180);
-	});
-}
 function createGenericSector(coordinates, options = {}) {
 	const anchor = coordinates[0];
 	const innerLeftPoint = coordinates[1];
@@ -7906,11 +8258,13 @@ function createGenericSector(coordinates, options = {}) {
 		type: "FeatureCollection",
 		features: []
 	};
-	const innerRadius = haversineDistance(anchor, innerLeftPoint);
-	const outerRadius = haversineDistance(anchor, outerRightPoint);
+	const firstRadius = haversineDistance(anchor, innerLeftPoint);
+	const secondRadius = haversineDistance(anchor, outerRightPoint);
+	const innerRadius = Math.min(firstRadius, secondRadius);
+	const outerRadius = Math.max(firstRadius, secondRadius);
 	const leftAzimuth = normalizeDegrees(sphericalBearing(anchor, innerLeftPoint) * 180 / Math.PI);
 	const rightAzimuth = normalizeDegrees(sphericalBearing(anchor, outerRightPoint) * 180 / Math.PI);
-	if (outerRadius <= innerRadius || innerRadius < 1e-6 || outerRadius < 1e-6) return {
+	if (outerRadius - innerRadius < 1e-6 || innerRadius < 1e-6) return {
 		type: "FeatureCollection",
 		features: []
 	};
@@ -7919,13 +8273,7 @@ function createGenericSector(coordinates, options = {}) {
 		type: "FeatureCollection",
 		features: []
 	};
-	const resolution = normalizeArcResolution(options.resolution);
-	const outerArc = sampleArc(anchor, outerRadius, leftAzimuth, sweepDegrees, resolution);
-	const ring = [
-		...outerArc,
-		...sampleArc(anchor, innerRadius, leftAzimuth, sweepDegrees, resolution).reverse(),
-		outerArc[0]
-	];
+	const ring = annularSectorRing(anchor, innerRadius, outerRadius, leftAzimuth, sweepDegrees, normalizeArcResolution(options.resolution));
 	return {
 		type: "FeatureCollection",
 		features: [{
@@ -8128,6 +8476,114 @@ const GENERIC_TEXT = defineControlMeasure({
 	}
 });
 //#endregion
+//#region src/generators/cm20-maritime-control-areas/radar-search-doctrine.ts
+const DEFAULT_RADAR_SEARCH_DOCTRINE_OPTIONS = { resolution: 64 };
+/** Doctrinal RSD colors from the symbol specification. */
+const RADAR_SEARCH_DOCTRINE_STROKE_COLOR = "rgb(51, 136, 136)";
+const RADAR_SEARCH_DOCTRINE_FILL_COLOR = "rgba(51, 136, 136, 0.25)";
+const RADAR_SEARCH_DOCTRINE_METADATA = {
+	id: "radar-search-doctrine",
+	name: "Radar Search Doctrine",
+	description: "A maritime radar search area defined by an axis and annular-sector limits.",
+	entity: "Maritime Control Areas",
+	entityType: "Radar Search Doctrine",
+	value: "200700",
+	minCoordinates: 3,
+	maxCoordinates: 3,
+	geometry: "area",
+	geometryTypes: ["Polygon", "Point"],
+	paints: {
+		stroke: true,
+		fill: "fixed",
+		text: true
+	},
+	drawRule: "Point18",
+	capturesLabelSize: true,
+	params: ARC_RESOLUTION_PARAMS,
+	textAmplifiers: [{
+		key: "T",
+		label: "Unique designation",
+		description: "Field T — designation centered in the search area along its axis.",
+		placeholder: "FF",
+		maxLength: 20
+	}]
+};
+/**
+* GeoJSON positions are rounded by `destinationPoint`, so two handles placed on
+* the same ray can recover bearings a few thousandths of a degree apart. Treat
+* that numerical noise as a collapsed sector, not an almost-360° fan.
+*/
+const SWEEP_COLLAPSE_TOLERANCE_DEGREES = .01;
+function createRadarSearchDoctrine(coordinates, options = {}, textAmplifiers = {}) {
+	const anchor = coordinates[0];
+	const startLimit = coordinates[1];
+	const stopLimit = coordinates[2];
+	const firstRange = haversineDistance(anchor, startLimit);
+	const secondRange = haversineDistance(anchor, stopLimit);
+	const startRange = Math.min(firstRange, secondRange);
+	const stopRange = Math.max(firstRange, secondRange);
+	const leftAzimuth = normalizeDegrees(sphericalBearing(anchor, startLimit) * 180 / Math.PI);
+	const sweepDegrees = clockwiseSweepDegrees(leftAzimuth, normalizeDegrees(sphericalBearing(anchor, stopLimit) * 180 / Math.PI), SWEEP_COLLAPSE_TOLERANCE_DEGREES);
+	if (stopRange - startRange < 1e-6 || sweepDegrees < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const axis = normalizeDegrees(leftAzimuth + sweepDegrees / 2) * Math.PI / 180;
+	const ring = annularSectorRing(anchor, startRange, stopRange, leftAzimuth, sweepDegrees, normalizeArcResolution(options.resolution));
+	const features = [{
+		type: "Feature",
+		properties: {
+			part: "search-area",
+			fill: true,
+			style: {
+				strokeColor: RADAR_SEARCH_DOCTRINE_STROKE_COLOR,
+				fillColor: RADAR_SEARCH_DOCTRINE_FILL_COLOR,
+				fillPattern: "solid"
+			}
+		},
+		geometry: {
+			type: "Polygon",
+			coordinates: [ring]
+		}
+	}];
+	if (textAmplifiers.T) {
+		const labelAnchor = destinationPoint(anchor, (startRange + stopRange) / 2, axis);
+		features.push({
+			type: "Feature",
+			properties: {
+				part: "label",
+				text: textAmplifiers.T,
+				amplifierField: "T",
+				labelPlacementKey: "T",
+				...labelSizeProps(options),
+				rotation: labelRotationAlong([Math.cos(axis), -Math.sin(axis)])
+			},
+			geometry: {
+				type: "Point",
+				coordinates: labelAnchor
+			}
+		});
+	}
+	return {
+		type: "FeatureCollection",
+		features
+	};
+}
+const RADAR_SEARCH_DOCTRINE = defineControlMeasure({
+	metadata: RADAR_SEARCH_DOCTRINE_METADATA,
+	generator: createRadarSearchDoctrine,
+	defaultOptions: DEFAULT_RADAR_SEARCH_DOCTRINE_OPTIONS,
+	rule: dynamicPointDrawRule,
+	previewSample: {
+		controlPoints: [
+			[0, -1],
+			[-.55, -.15],
+			[1, .45]
+		],
+		textAmplifiers: { T: "FF" }
+	}
+});
+//#endregion
 //#region src/generators/cm34-mission-tasks/clear.ts
 /**
 * Default options for the CLEAR symbol.
@@ -8467,27 +8923,6 @@ const COUNTERATTACK = defineControlMeasure({
 	}
 });
 //#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/cm34-mission-tasks/counterattack-by-fire.ts
 const DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS = { ...DEFAULT_COUNTERATTACK_OPTIONS };
 /** Length of the solid fire arrowhead relative to the recessed P1 extension. */
@@ -9699,7 +10134,7 @@ const DROP_ZONE_METADATA = {
 * (Field N) ENY marker, per {@link labeledAreaFeatures}.
 */
 function createDropZone(positions, options = {}, textAmplifiers = {}, context = {}) {
-	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "DZ"), context.amplifierPlacements);
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "DZ"), context.amplifierPlacements, context);
 }
 const DROP_ZONE = defineControlMeasure({
 	metadata: DROP_ZONE_METADATA,
@@ -9835,7 +10270,7 @@ function createEncirclement(positions, options = {}, textAmplifiers = {}, contex
 	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION$2);
 	const perimeter = buildAreaPerimeter(verts);
 	const labelFeatures = [];
-	const gaps = pushAreaLabels(labelFeatures, verts, { hostile: textAmplifiers.N }, options, context.amplifierPlacements);
+	const gaps = pushAreaLabels(labelFeatures, verts, { hostile: textAmplifiers.N }, options, context.amplifierPlacements, void 0, context);
 	const radius = meanRadius(verts);
 	const barbLength = radius * Math.max(0, barbLengthRatio);
 	const barbs = buildBarbs(perimeter, radius * Math.max(0, barbSpacingRatio), barbLength, gaps);
@@ -9916,7 +10351,7 @@ const EXTRACTION_ZONE_METADATA = {
 * an `N` (Field N) ENY marker, per {@link labeledAreaFeatures}.
 */
 function createExtractionZone(positions, options = {}, textAmplifiers = {}, context = {}) {
-	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "EZ"), context.amplifierPlacements);
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "EZ"), context.amplifierPlacements, context);
 }
 const EXTRACTION_ZONE = defineControlMeasure({
 	metadata: EXTRACTION_ZONE_METADATA,
@@ -10588,7 +11023,7 @@ function processSegment(p1, p2, radius, arcSegments, isFirstSegment) {
 * );
 * ```
 */
-function createFLOT(positions, options = {}, textAmplifiers = {}) {
+function createFLOT(positions, options = {}, textAmplifiers = {}, context = {}) {
 	const { radius = DEFAULT_RADIUS, radiusPixels, metersPerPixel, arcSegments = DEFAULT_ARC_SEGMENTS, smooth = DEFAULT_FLOT_OPTIONS.smooth, smoothResolution = DEFAULT_FLOT_OPTIONS.smoothResolution } = options;
 	let effectiveRadius = radius;
 	if (radiusPixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0) effectiveRadius = radiusPixels * metersPerPixel;
@@ -10626,7 +11061,7 @@ function createFLOT(positions, options = {}, textAmplifiers = {}) {
 		}
 	};
 	const labels = [];
-	pushHostileEndLabels(labels, smoothedPath, textAmplifiers.N, options);
+	pushHostileEndLabels(labels, smoothedPath, textAmplifiers.N, options, "", context);
 	return {
 		type: "FeatureCollection",
 		features: [feature, ...labels]
@@ -10695,14 +11130,14 @@ const PHASE_LINE_METADATA = {
 * Creates a Phase line control measure: a polyline through `positions`
 * labeled at each end with `T` (optionally "PL"-prefixed).
 */
-function createPhaseLine(positions, options = {}, textAmplifiers = {}) {
+function createPhaseLine(positions, options = {}, textAmplifiers = {}, context = {}) {
 	const { includePrefix = true, ...sizeOptions } = options;
 	const designation = textAmplifiers.T ?? "";
 	const text = includePrefix ? designation.length > 0 ? `PL ${designation}` : "PL" : designation;
 	return fixedLabelLineFeatures(positions, {
 		part: "phase-line",
 		...sizeOptions
-	}, text, textAmplifiers.N);
+	}, text, textAmplifiers.N, context);
 }
 const PHASE_LINE = defineControlMeasure({
 	metadata: PHASE_LINE_METADATA,
@@ -10774,12 +11209,12 @@ const BRIDGEHEAD_LINE_METADATA = {
 	textAmplifiers: [HOSTILE_LINE_AMPLIFIER]
 };
 /** Creates a Bridgehead line labeled "BL" above both ends. */
-function createBridgeheadLine(positions, options = {}, textAmplifiers = {}) {
+function createBridgeheadLine(positions, options = {}, textAmplifiers = {}, context = {}) {
 	return fixedLabelLineFeatures(positions, {
 		part: "bridgehead-line",
 		placement: "above",
 		...options
-	}, "BL", textAmplifiers.N);
+	}, "BL", textAmplifiers.N, context);
 }
 const BRIDGEHEAD_LINE = defineControlMeasure({
 	metadata: BRIDGEHEAD_LINE_METADATA,
@@ -10850,12 +11285,12 @@ const HOLDING_LINE_METADATA = {
 	textAmplifiers: [HOSTILE_LINE_AMPLIFIER]
 };
 /** Creates a Holding line labeled "HL" above both ends. */
-function createHoldingLine(positions, options = {}, textAmplifiers = {}) {
+function createHoldingLine(positions, options = {}, textAmplifiers = {}, context = {}) {
 	return fixedLabelLineFeatures(positions, {
 		part: "holding-line",
 		placement: "above",
 		...options
-	}, "HL", textAmplifiers.N);
+	}, "HL", textAmplifiers.N, context);
 }
 const HOLDING_LINE = defineControlMeasure({
 	metadata: HOLDING_LINE_METADATA,
@@ -10926,12 +11361,12 @@ const RELEASE_LINE_METADATA = {
 	textAmplifiers: [HOSTILE_LINE_AMPLIFIER]
 };
 /** Creates a Release line labeled "RL" above both ends. */
-function createReleaseLine(positions, options = {}, textAmplifiers = {}) {
+function createReleaseLine(positions, options = {}, textAmplifiers = {}, context = {}) {
 	return fixedLabelLineFeatures(positions, {
 		part: "release-line",
 		placement: "above",
 		...options
-	}, "RL", textAmplifiers.N);
+	}, "RL", textAmplifiers.N, context);
 }
 const RELEASE_LINE = defineControlMeasure({
 	metadata: RELEASE_LINE_METADATA,
@@ -11005,12 +11440,12 @@ const FORWARD_EDGE_OF_BATTLE_AREA_METADATA = {
 * Creates a Forward edge of the battle area control measure: a polyline
 * through `positions` labeled "FEBA" above the line near each end.
 */
-function createForwardEdgeOfBattleArea(positions, options = {}, textAmplifiers = {}) {
+function createForwardEdgeOfBattleArea(positions, options = {}, textAmplifiers = {}, context = {}) {
 	return fixedLabelLineFeatures(positions, {
 		part: "forward-edge-of-battle-area",
 		placement: "above",
 		...options
-	}, "FEBA", textAmplifiers.N);
+	}, "FEBA", textAmplifiers.N, context);
 }
 const FORWARD_EDGE_OF_BATTLE_AREA = defineControlMeasure({
 	metadata: FORWARD_EDGE_OF_BATTLE_AREA_METADATA,
@@ -11084,12 +11519,12 @@ const HANDOVER_LINE_METADATA = {
 * Creates a Handover line control measure: a polyline through `positions`
 * labeled "HOL" above the line near each end.
 */
-function createHandoverLine(positions, options = {}, textAmplifiers = {}) {
+function createHandoverLine(positions, options = {}, textAmplifiers = {}, context = {}) {
 	return fixedLabelLineFeatures(positions, {
 		part: "handover-line",
 		placement: "above",
 		...options
-	}, "HOL", textAmplifiers.N);
+	}, "HOL", textAmplifiers.N, context);
 }
 const HANDOVER_LINE = defineControlMeasure({
 	metadata: HANDOVER_LINE_METADATA,
@@ -11163,12 +11598,12 @@ const BATTLE_HANDOVER_LINE_METADATA = {
 * Creates a Battle handover line control measure: a polyline through
 * `positions` labeled "BHL" above the line near each end.
 */
-function createBattleHandoverLine(positions, options = {}, textAmplifiers = {}) {
+function createBattleHandoverLine(positions, options = {}, textAmplifiers = {}, context = {}) {
 	return fixedLabelLineFeatures(positions, {
 		part: "battle-handover-line",
 		placement: "above",
 		...options
-	}, "BHL", textAmplifiers.N);
+	}, "BHL", textAmplifiers.N, context);
 }
 const BATTLE_HANDOVER_LINE = defineControlMeasure({
 	metadata: BATTLE_HANDOVER_LINE_METADATA,
@@ -11320,7 +11755,7 @@ function generateFortifiedPoints(projectedPoints, effectiveSize) {
 * @param options - Configuration options for the graphic
 * @returns A GeoJSON FeatureCollection containing the castellated LineString
 */
-function createFortifiedLine(positions, options = {}, textAmplifiers = {}) {
+function createFortifiedLine(positions, options = {}, textAmplifiers = {}, context = {}) {
 	const { smooth = DEFAULT_FORTIFIED_LINE_OPTIONS.smooth, smoothResolution = DEFAULT_FORTIFIED_LINE_OPTIONS.smoothResolution } = options;
 	const safeSize = calculateEffectiveSize(options);
 	const projectedPoints = positions.map((p) => project(p[0], p[1]));
@@ -11334,7 +11769,7 @@ function createFortifiedLine(positions, options = {}, textAmplifiers = {}) {
 		}
 	};
 	const labels = [];
-	pushHostileEndLabels(labels, smoothedPath, textAmplifiers.N, options);
+	pushHostileEndLabels(labels, smoothedPath, textAmplifiers.N, options, "", context);
 	return {
 		type: "FeatureCollection",
 		features: [feature, ...labels]
@@ -11418,7 +11853,7 @@ function createFortifiedArea(positions, options = {}, textAmplifiers = {}, conte
 		}, options, context.amplifierPlacements, {
 			ringVerts: boundaryPoints,
 			extraClearanceMeters: 3 * safeSize
-		})),
+		}, context)),
 		properties: {}
 	}];
 	features.push(...labelFeatures);
@@ -12343,7 +12778,7 @@ const JOINT_TACTICAL_ACTION_AREA_METADATA = {
 * {@link labeledAreaFeatures}.
 */
 function createJointTacticalActionArea(positions, options = {}, textAmplifiers = {}, context = {}) {
-	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "JTAA -", ""), context.amplifierPlacements);
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "JTAA -", ""), context.amplifierPlacements, context);
 }
 const JOINT_TACTICAL_ACTION_AREA = defineControlMeasure({
 	metadata: JOINT_TACTICAL_ACTION_AREA_METADATA,
@@ -12402,7 +12837,7 @@ const LANDING_ZONE_METADATA = {
 * amplifier rows, per {@link labeledAreaFeatures}.
 */
 function createLandingZone(positions, options = {}, textAmplifiers = {}, context = {}) {
-	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "LZ"), context.amplifierPlacements);
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "LZ"), context.amplifierPlacements, context);
 }
 const LANDING_ZONE = defineControlMeasure({
 	metadata: LANDING_ZONE_METADATA,
@@ -12473,7 +12908,7 @@ function createLimitedAccessArea(positions, options = {}, textAmplifiers = {}, c
 	}];
 	return {
 		type: "FeatureCollection",
-		features: [...patternedAreaFeatures(verts, pushAreaLabels(labelFeatures, verts, { hostile: textAmplifiers.N }, options, context.amplifierPlacements), "reverse-hatch"), ...labelFeatures]
+		features: [...patternedAreaFeatures(verts, pushAreaLabels(labelFeatures, verts, { hostile: textAmplifiers.N }, options, context.amplifierPlacements, void 0, context), "reverse-hatch"), ...labelFeatures]
 	};
 }
 const LIMITED_ACCESS_AREA = defineControlMeasure({
@@ -12584,7 +13019,7 @@ function createNoFireAreaIrregular(positions, options = {}, textAmplifiers = {},
 	}
 	return {
 		type: "FeatureCollection",
-		features: [...patternedAreaFeatures(verts, pushAreaLabels(labels, verts, { hostile: textAmplifiers.N }, options, context.amplifierPlacements), "reverse-hatch"), ...labels]
+		features: [...patternedAreaFeatures(verts, pushAreaLabels(labels, verts, { hostile: textAmplifiers.N }, options, context.amplifierPlacements, void 0, context), "reverse-hatch"), ...labels]
 	};
 }
 const NO_FIRE_AREA_IRREGULAR = defineControlMeasure({
@@ -12929,7 +13364,7 @@ function createMinefield(coordinates, options = {}, textAmplifiers = {}, context
 		clearance: ENY_CLEARANCE_RATIO * labelSize,
 		sizeProps,
 		followPlacementRotation: true
-	}, context.amplifierPlacements);
+	}, context.amplifierPlacements, context, { labelSize });
 	if (textAmplifiers.W) pushLabel(labelFeatures, offset(center, 0, -halfHeight - width * LABEL_CLEARANCE_RATIO), textAmplifiers.W, labelRotation, sizeProps, void 0, "W");
 	const features = [{
 		type: "Feature",
@@ -13146,7 +13581,7 @@ function createMineArea(positions, options, minedArea, textAmplifiers, context)
 			textHeight: resolveLabelOffsetMeters(options, 1),
 			clearance: resolveLabelOffsetMeters(options, .12 + labelPadding),
 			sizeProps: labelSizeProps(options)
-		}) : [], ...pushAreaLabels(labelFeatures, ring, { hostile: textAmplifiers.N }, options, context.amplifierPlacements)], mineFillPattern(mineType)), ...labelFeatures]
+		}, void 0, context, options) : [], ...pushAreaLabels(labelFeatures, ring, { hostile: textAmplifiers.N }, options, context.amplifierPlacements, void 0, context)], mineFillPattern(mineType)), ...labelFeatures]
 	};
 }
 function createDynamicMinefield(positions, options = {}, textAmplifiers = {}, context = {}) {
@@ -13649,7 +14084,7 @@ const PICKUP_ZONE_METADATA = {
 * amplifier rows, per {@link labeledAreaFeatures}.
 */
 function createPickupZone(positions, options = {}, textAmplifiers = {}, context = {}) {
-	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "PZ"), context.amplifierPlacements);
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "PZ"), context.amplifierPlacements, context);
 }
 const PICKUP_ZONE = defineControlMeasure({
 	metadata: PICKUP_ZONE_METADATA,
@@ -13704,7 +14139,7 @@ const ASSAULT_POSITION_METADATA = {
 * an `N` (Field N) ENY marker, per {@link labeledAreaFeatures}.
 */
 function createAssaultPosition(positions, options = {}, textAmplifiers = {}, context = {}) {
-	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "ASLT"), context.amplifierPlacements);
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "ASLT"), context.amplifierPlacements, context);
 }
 const ASSAULT_POSITION = defineControlMeasure({
 	metadata: ASSAULT_POSITION_METADATA,
@@ -13759,7 +14194,7 @@ const ATTACK_POSITION_METADATA = {
 * an `N` (Field N) ENY marker, per {@link labeledAreaFeatures}.
 */
 function createAttackPosition(positions, options = {}, textAmplifiers = {}, context = {}) {
-	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "ATK"), context.amplifierPlacements);
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "ATK"), context.amplifierPlacements, context);
 }
 const ATTACK_POSITION = defineControlMeasure({
 	metadata: ATTACK_POSITION_METADATA,
@@ -13814,7 +14249,7 @@ const OBJECTIVE_AREA_METADATA = {
 * an `N` (Field N) ENY marker, per {@link labeledAreaFeatures}.
 */
 function createObjectiveArea(positions, options = {}, textAmplifiers = {}, context = {}) {
-	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "OBJ"), context.amplifierPlacements);
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "OBJ"), context.amplifierPlacements, context);
 }
 const OBJECTIVE_AREA = defineControlMeasure({
 	metadata: OBJECTIVE_AREA_METADATA,
@@ -14097,7 +14532,7 @@ function createStrongPoint(positions, options = {}, textAmplifiers = {}, context
 	const enyGaps = pushAreaLabels(labelFeatures, verts, {
 		name: textAmplifiers.T,
 		hostile: textAmplifiers.N
-	}, options, context.amplifierPlacements);
+	}, options, context.amplifierPlacements, void 0, context);
 	const allGaps = [...gaps, ...enyGaps];
 	const boundaryCoords = buildGappedLine(verts, allGaps);
 	const tics = buildStrongPointTics(perimeter, allGaps, h);
@@ -14166,6 +14601,180 @@ const STRONG_POINT = defineControlMeasure({
 	}
 });
 //#endregion
+//#region src/generators/cm15-maneuver-areas/retain.ts
+const DEFAULT_RETAIN_OPTIONS = {
+	openingAngle: 30,
+	arrowheadLengthRatio: .1,
+	arrowheadWidthRatio: .12,
+	labelPadding: 0
+};
+const RETAIN_METADATA = {
+	id: "retain",
+	name: "Retain",
+	description: "Ensures that a terrain feature controlled by a friendly force remains secure.",
+	entity: "Maneuver Areas",
+	entityType: "Battle Position",
+	entitySubtype: "Retain",
+	value: "151205",
+	minCoordinates: 2,
+	maxCoordinates: 2,
+	geometry: "area",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Area6",
+	capturesLabelSize: true,
+	params: [
+		{
+			key: "openingAngle",
+			presentationTier: "advanced",
+			label: "Opening",
+			description: "Angular opening on the friendly side, in degrees",
+			type: "number",
+			min: 5,
+			max: 120,
+			step: 1
+		},
+		{
+			key: "arrowheadLengthRatio",
+			presentationTier: "advanced",
+			label: "Arrowhead length",
+			description: "Open-arrowhead length as a ratio of the symbol radius",
+			type: "number",
+			min: .02,
+			max: .5,
+			step: .01
+		},
+		{
+			key: "arrowheadWidthRatio",
+			presentationTier: "advanced",
+			label: "Arrowhead width",
+			description: "Open-arrowhead base width as a ratio of the symbol radius",
+			type: "number",
+			min: .02,
+			max: .5,
+			step: .01
+		},
+		{
+			key: "labelPadding",
+			presentationTier: "advanced",
+			label: "R padding",
+			description: "Extra boundary clearance on each side of R, as a ratio of its height",
+			type: "number",
+			min: 0,
+			max: 2,
+			step: .05
+		}
+	]
+};
+const TAU = Math.PI * 2;
+/** Smallest visible boundary gap, in projected meters, for tiny label heights. */
+const MIN_LABEL_GAP_METERS = 1;
+function pointOnCircle(center, radius, angle) {
+	return vecAdd(center, [radius * Math.cos(angle), radius * Math.sin(angle)]);
+}
+function sampleArc(center, radius, start, end) {
+	const segments = Math.max(8, Math.ceil(48 * Math.abs(end - start) / Math.PI));
+	return Array.from({ length: segments + 1 }, (_, index) => {
+		const point = pointOnCircle(center, radius, start + (end - start) * index / segments);
+		return unproject(point[0], point[1]);
+	});
+}
+/** Creates the Retain boundary, outward tics, and intrinsic R label. */
+function createRetain(coordinates, options = {}) {
+	const center = project(coordinates[0][0], coordinates[0][1]);
+	const radiusVector = vecSub(project(coordinates[1][0], coordinates[1][1]), center);
+	const radius = vecMag(radiusVector);
+	if (radius < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const resolved = {
+		...DEFAULT_RETAIN_OPTIONS,
+		...options
+	};
+	const startAngle = Math.atan2(radiusVector[1], radiusVector[0]);
+	const opening = Math.min(120, Math.max(5, resolved.openingAngle)) * Math.PI / 180;
+	const h = resolveLabelOffsetMeters(options, 1, radius * .1);
+	const labelPadding = Math.max(0, resolved.labelPadding);
+	const boundarySpan = TAU - opening;
+	const labelDistance = Math.PI - opening / 2;
+	const labelCenter = startAngle - labelDistance;
+	const labelHalfGap = Math.min(Math.PI / 2, Math.max(h * (LABEL_HALF_GLYPH_RATIO + labelPadding), MIN_LABEL_GAP_METERS) / radius);
+	const labelStart = startAngle - labelDistance + labelHalfGap;
+	const labelEnd = startAngle - labelDistance - labelHalfGap;
+	const boundaryEnd = startAngle - boundarySpan;
+	const arrowTip = pointOnCircle(center, radius, boundaryEnd);
+	const arrowheadLength = radius * Math.max(0, resolved.arrowheadLengthRatio);
+	const arrowheadWidth = radius * Math.max(0, resolved.arrowheadWidthRatio);
+	const boundary = [
+		sampleArc(center, radius, startAngle, labelStart),
+		sampleArc(center, radius, labelEnd, boundaryEnd),
+		createArrowHeadRing(arrowTip, [Math.sin(boundaryEnd), -Math.cos(boundaryEnd)], arrowheadLength, arrowheadWidth).slice(0, 3)
+	];
+	const tics = [];
+	const spacingAngle = Math.max(h / radius, Math.PI / 180);
+	const arrowClearanceAngle = (arrowheadLength + arrowheadWidth / 2 + h / 2) / radius;
+	for (let distance = spacingAngle / 2; distance < boundarySpan - arrowClearanceAngle; distance += spacingAngle) {
+		if (distance > labelDistance - labelHalfGap && distance < labelDistance + labelHalfGap) continue;
+		const angle = startAngle - distance;
+		const cos = Math.cos(angle);
+		const sin = Math.sin(angle);
+		const innerX = center[0] + radius * cos;
+		const innerY = center[1] + radius * sin;
+		tics.push([unproject(innerX, innerY), unproject(innerX + h * cos, innerY + h * sin)]);
+	}
+	const labelPoint = pointOnCircle(center, radius, labelCenter);
+	return {
+		type: "FeatureCollection",
+		features: [
+			{
+				type: "Feature",
+				properties: { part: "boundary" },
+				geometry: {
+					type: "MultiLineString",
+					coordinates: boundary
+				}
+			},
+			{
+				type: "Feature",
+				properties: { part: "tics" },
+				geometry: {
+					type: "MultiLineString",
+					coordinates: tics
+				}
+			},
+			{
+				type: "Feature",
+				properties: {
+					part: "label",
+					labelPlacement: false,
+					text: "R",
+					rotation: Math.PI,
+					...labelSizeProps(options)
+				},
+				geometry: {
+					type: "Point",
+					coordinates: unproject(labelPoint[0], labelPoint[1])
+				}
+			}
+		]
+	};
+}
+const RETAIN = defineControlMeasure({
+	metadata: RETAIN_METADATA,
+	generator: createRetain,
+	defaultOptions: DEFAULT_RETAIN_OPTIONS,
+	rule: retainDrawRule,
+	previewSample: {
+		controlPoints: [[0, 0], [-.8, .2]],
+		options: { labelSize: 90 }
+	}
+});
+//#endregion
 //#region src/generators/cm15-maneuver-areas/submarineActionArea.ts
 /** Default options for the Submarine action area control measure. */
 const DEFAULT_SUBMARINE_ACTION_AREA_OPTIONS = {
@@ -14203,7 +14812,7 @@ const SUBMARINE_ACTION_AREA_METADATA = {
 * `W`/`W1`/`N` amplifier rows, per {@link labeledAreaFeatures}.
 */
 function createSubmarineActionArea(positions, options = {}, textAmplifiers = {}, context = {}) {
-	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "SAA -", ""), context.amplifierPlacements);
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "SAA -", ""), context.amplifierPlacements, context);
 }
 const SUBMARINE_ACTION_AREA = defineControlMeasure({
 	metadata: SUBMARINE_ACTION_AREA_METADATA,
@@ -14263,7 +14872,7 @@ const SUBMARINE_GENERATED_ACTION_AREA_METADATA = {
 * (Field T) plus `W`/`W1`/`N` amplifier rows, per {@link labeledAreaFeatures}.
 */
 function createSubmarineGeneratedActionArea(positions, options = {}, textAmplifiers = {}, context = {}) {
-	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "SGSA -", ""), context.amplifierPlacements);
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "SGSA -", ""), context.amplifierPlacements, context);
 }
 const SUBMARINE_GENERATED_ACTION_AREA = defineControlMeasure({
 	metadata: SUBMARINE_GENERATED_ACTION_AREA_METADATA,
@@ -14624,7 +15233,9 @@ const DEFINITIONS = {
 	"engineer-work-line": ENGINEER_WORK_LINE,
 	"generic-c2-line": GENERIC_C2_LINE,
 	"battle-position": BATTLE_POSITION,
+	contain: CONTAIN,
 	"strong-point": STRONG_POINT,
+	retain: RETAIN,
 	ambush: AMBUSH,
 	"direction-of-attack-aviation": DIRECTION_OF_ATTACK_AVIATION,
 	"direction-of-main-attack": DIRECTION_OF_MAIN_ATTACK,
@@ -14669,6 +15280,7 @@ const DEFINITIONS = {
 	circle: GENERIC_CIRCLE,
 	sector: GENERIC_SECTOR,
 	text: GENERIC_TEXT,
+	"radar-search-doctrine": RADAR_SEARCH_DOCTRINE,
 	"airborne-attack": AIRBORNE_ATTACK,
 	"attack-helicopter": ATTACK_HELICOPTER,
 	"support-by-fire": SUPPORT_BY_FIRE,
@@ -14960,7 +15572,31 @@ function dispatchControlMeasure(cm, opts) {
 	if (!validateInputContract(cm.controlPoints, definition.metadata, opts?.validationMode)) return EMPTY_COLLECTION;
 	const generator = definition.generator;
 	const textAmplifiers = normalizeTextAmplifiers(cm.textAmplifiers);
-	return generator(cm.controlPoints, cm.options ?? {}, textAmplifiers, { amplifierPlacements: cm.amplifierPlacements });
+	const constructionMetersPerCssPixel = resolveConstructionScale(cm.controlPoints, opts?.context?.groundMetersPerCssPixel);
+	const authoredOptions = cm.options ?? {};
+	const generatorOptions = constructionMetersPerCssPixel === void 0 ? authoredOptions : {
+		...authoredOptions,
+		metersPerPixel: constructionMetersPerCssPixel
+	};
+	return generator(cm.controlPoints, generatorOptions, textAmplifiers, {
+		amplifierPlacements: cm.amplifierPlacements,
+		constructionMetersPerCssPixel,
+		labelSizeClampCssPixels: opts?.context?.labelSizeClampCssPixels,
+		measureText: opts?.context?.measureText
+	});
+}
+/** Convert true-ground scale to the Web Mercator metres legacy generators construct in. */
+function resolveConstructionScale(points, groundMetersPerCssPixel) {
+	if (!(groundMetersPerCssPixel !== void 0 && groundMetersPerCssPixel > 0)) return void 0;
+	let minLatitude = Infinity;
+	let maxLatitude = -Infinity;
+	for (const point of points) {
+		minLatitude = Math.min(minLatitude, point[1]);
+		maxLatitude = Math.max(maxLatitude, point[1]);
+	}
+	const midpointLatitude = (minLatitude + maxLatitude) / 2;
+	const mercatorScale = Math.cos(midpointLatitude * Math.PI / 180);
+	return groundMetersPerCssPixel / Math.max(mercatorScale, Number.EPSILON);
 }
 /**
 * The control-point *input contract*: `controlPoints` must be present and an
@@ -15099,4 +15735,4 @@ function assertNever(value) {
 	throw new Error(`Unhandled control measure kind: ${String(value)}`);
 }
 //#endregion
-export { DEFAULT_TACTICAL_ARROW_OPTIONS as $, centerRadiusDrawRule as $t, DEFAULT_REARWARD_PASSAGE_OF_LINES_OPTIONS as A, DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS as At, DEFAULT_BRIDGEHEAD_LINE_OPTIONS as B, axis1DrawRule as Bt, DEFAULT_LANDING_ZONE_OPTIONS as C, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Ct, DEFAULT_SEIZE_OPTIONS as D, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as Dt, DEFAULT_WITHDRAW_OPTIONS as E, DEFAULT_ASSEMBLY_AREA_OPTIONS as Et, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as F, resolveAmplifierPlacement as Ft, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as G, line23DrawRule as Gt, DEFAULT_FLOT_OPTIONS as H, line27DrawRule as Ht, DEFAULT_HANDOVER_LINE_OPTIONS as I, DEFAULT_AMBUSH_OPTIONS as It, DEFAULT_GUARD_OPTIONS as J, ambushDrawRule as Jt, DEFAULT_ENCIRCLEMENT_OPTIONS as K, turnDrawRule as Kt, DEFAULT_FORWARD_EDGE_OF_BATTLE_AREA_OPTIONS as L, DEFAULT_AIRBORNE_ATTACK_OPTIONS as Lt, DEFAULT_FRONTAL_ATTACK_OPTIONS as M, TEXT_AMPLIFIER_FIELDS as Mt, DEFAULT_FORTIFIED_AREA_OPTIONS as N, canonicalTextAmplifierKey as Nt, DEFAULT_SCREEN_OPTIONS as O, DEFAULT_AREA_DEFENSE_OPTIONS as Ot, DEFAULT_FORTIFIED_LINE_OPTIONS as P, normalizeTextAmplifiers as Pt, DEFAULT_COVER_OPTIONS as Q, penetrateDrawRule as Qt, DEFAULT_RELEASE_LINE_OPTIONS as R, sectorDrawRule as Rt, DEFAULT_MAIN_ATTACK_OPTIONS as S, DEFAULT_ATTACK_HELICOPTER_OPTIONS as St, DEFAULT_WITHDRAW_UNDER_PRESSURE_OPTIONS as T, DEFAULT_ANTITANK_DITCH_OPTIONS as Tt, DEFAULT_FIX_MISSION_TASK_OPTIONS as U, line26DrawRule as Ut, DEFAULT_PHASE_LINE_OPTIONS as V, supportByFireDrawRule as Vt, DEFAULT_FIX_OPTIONS as W, line24DrawRule as Wt, DEFAULT_DISENGAGE_OPTIONS as X, staticPointDrawRule as Xt, DEFAULT_DISRUPT_MISSION_TASK_OPTIONS as Y, attackByFireDrawRule as Yt, DEFAULT_DELAY_OPTIONS as Z, point12DrawRule as Zt, DEFAULT_PICKUP_ZONE_OPTIONS as _, DEFAULT_LIGHT_LINE_OPTIONS as _t, DEFINITIONS as a, pointOnMidpointPerpendicularAxis as an, DEFAULT_GENERIC_SECTOR_OPTIONS as at, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as b, DEFAULT_BLOCK_OPTIONS as bt, getDefaultOptions as c, calculateMetrics as cn, DEFAULT_GENERIC_LINE_OPTIONS as ct, DEFAULT_TURN_OPTIONS as d, project as dn, DEFAULT_CANALIZE_OPTIONS as dt, disruptDrawRule as en, DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS as et, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as f, sphericalBearing as fn, DEFAULT_BYPASS_OPTIONS as ft, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as g, roundToFixed as gn, DEFAULT_ENGINEER_WORK_LINE_OPTIONS as gt, SECONDARY_DIRECTION_OF_FIRE_DASH as h, getMetersPerPixel as hn, DEFAULT_GENERIC_C2_LINE_OPTIONS as ht, CONTROL_MEASURE_METADATA as i, getMidpointPerpendicularSignedDistance as in, DEFAULT_GENERIC_TEXT_OPTIONS as it, DEFAULT_PENETRATE_OPTIONS as j, DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS as jt, DEFAULT_RETIRE_OPTIONS as k, DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS as kt, listControlMeasureMetadata as l, computeInitialWidthPoint as ln, DEFAULT_GENERIC_CIRCLE_OPTIONS as lt, DEFAULT_SECONDARY_DIRECTION_OF_FIRE_OPTIONS as m, EPSILON as mn, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as mt, resolveStyleHints as n, computeDefaultMidpointPerpendicularPoint as nn, DEFAULT_SUPPORTING_ATTACK_OPTIONS as nt, getControlMeasureMetadata as o, snapToMidpointPerpendicular as on, DEFAULT_GENERIC_RECTANGLE_OPTIONS as ot, DEFAULT_STRONG_POINT_OPTIONS as p, unproject as pn, DEFAULT_BREACH_OPTIONS as pt, DEFAULT_DISRUPT_OPTIONS as q, line1DrawRule as qt, CONTROL_MEASURE_IDS as r, createMidpointPerpendicularDrawRule as rn, DEFAULT_CLEAR_OPTIONS as rt, getControlMeasureMetadataByValue as s, createBaselineFrame as sn, DEFAULT_GENERIC_POLYGON_OPTIONS as st, renderControlMeasure as t, blockDrawRule as tn, DEFAULT_COUNTERATTACK_OPTIONS as tt, DEFAULT_TURNING_MOVEMENT_OPTIONS as u, haversineDistance as un, DEFAULT_CLASSIC_ARROW_OPTIONS as ut, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as v, DEFAULT_BOUNDARY_OPTIONS as vt, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as w, DEFAULT_ANTITANK_WALL_OPTIONS as wt, DEFAULT_MINEFIELD_OPTIONS as x, DEFAULT_BATTLE_POSITION_OPTIONS as xt, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as y, DEFAULT_BLOCK_ARROW_OPTIONS as yt, DEFAULT_HOLDING_LINE_OPTIONS as z, rectangleDrawRule as zt };
+export { DEFAULT_COVER_OPTIONS as $, supportByFireDrawRule as $t, DEFAULT_RETIRE_OPTIONS as A, getMetersPerPixel as An, DEFAULT_ANTITANK_DITCH_OPTIONS as At, DEFAULT_HOLDING_LINE_OPTIONS as B, resolveAmplifierPlacement as Bt, DEFAULT_MAIN_ATTACK_OPTIONS as C, calculateMetrics as Cn, DEFAULT_BLOCK_ARROW_OPTIONS as Ct, DEFAULT_WITHDRAW_OPTIONS as D, sphericalBearing as Dn, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Dt, DEFAULT_WITHDRAW_UNDER_PRESSURE_OPTIONS as E, project as En, DEFAULT_BATTLE_POSITION_OPTIONS as Et, DEFAULT_FORTIFIED_LINE_OPTIONS as F, DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS as Ft, DEFAULT_FIX_OPTIONS as G, DEFAULT_PORTRAYAL as Gt, DEFAULT_PHASE_LINE_OPTIONS as H, DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS as Ht, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as I, DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS as It, DEFAULT_DISRUPT_OPTIONS as J, DEFAULT_SYMBOL_COLOR as Jt, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as K, DEFAULT_STROKE_DASH_CSS_PIXELS as Kt, DEFAULT_HANDOVER_LINE_OPTIONS as L, TEXT_AMPLIFIER_FIELDS as Lt, DEFAULT_PENETRATE_OPTIONS as M, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as Mt, DEFAULT_FRONTAL_ATTACK_OPTIONS as N, DEFAULT_AREA_DEFENSE_OPTIONS as Nt, DEFAULT_SEIZE_OPTIONS as O, unproject as On, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Ot, DEFAULT_FORTIFIED_AREA_OPTIONS as P, DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS as Pt, DEFAULT_DELAY_OPTIONS as Q, axis1DrawRule as Qt, DEFAULT_FORWARD_EDGE_OF_BATTLE_AREA_OPTIONS as R, canonicalTextAmplifierKey as Rt, DEFAULT_MINEFIELD_OPTIONS as S, createBaselineFrame as Sn, DEFAULT_BOUNDARY_OPTIONS as St, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as T, haversineDistance as Tn, DEFAULT_CONTAIN_OPTIONS as Tt, DEFAULT_FLOT_OPTIONS as U, DEFAULT_LINE_CAP as Ut, DEFAULT_BRIDGEHEAD_LINE_OPTIONS as V, DEFAULT_LABEL_HEIGHT_CSS_PIXELS as Vt, DEFAULT_FIX_MISSION_TASK_OPTIONS as W, DEFAULT_LINE_JOIN as Wt, DEFAULT_DISRUPT_MISSION_TASK_OPTIONS as X, DEFAULT_AIRBORNE_ATTACK_OPTIONS as Xt, DEFAULT_GUARD_OPTIONS as Y, DEFAULT_AMBUSH_OPTIONS as Yt, DEFAULT_DISENGAGE_OPTIONS as Z, rectangleDrawRule as Zt, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as _, computeDefaultMidpointPerpendicularPoint as _n, DEFAULT_BREACH_OPTIONS as _t, DEFINITIONS as a, line1DrawRule as an, DEFAULT_RADAR_SEARCH_DOCTRINE_OPTIONS as at, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as b, pointOnMidpointPerpendicularAxis as bn, DEFAULT_ENGINEER_WORK_LINE_OPTIONS as bt, getDefaultOptions as c, dynamicPointDrawRule as cn, DEFAULT_GENERIC_TEXT_OPTIONS as ct, DEFAULT_TURN_OPTIONS as d, point12DrawRule as dn, DEFAULT_GENERIC_POLYGON_OPTIONS as dt, line27DrawRule as en, DEFAULT_TACTICAL_ARROW_OPTIONS as et, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as f, penetrateDrawRule as fn, DEFAULT_GENERIC_LINE_OPTIONS as ft, SECONDARY_DIRECTION_OF_FIRE_DASH as g, containDrawRule as gn, DEFAULT_BYPASS_OPTIONS as gt, DEFAULT_SECONDARY_DIRECTION_OF_FIRE_OPTIONS as h, centerRadiusDrawRule as hn, DEFAULT_CANALIZE_OPTIONS as ht, CONTROL_MEASURE_METADATA as i, turnDrawRule as in, DEFAULT_CLEAR_OPTIONS as it, DEFAULT_REARWARD_PASSAGE_OF_LINES_OPTIONS as j, roundToFixed as jn, DEFAULT_ASSEMBLY_AREA_OPTIONS as jt, DEFAULT_SCREEN_OPTIONS as k, EPSILON as kn, DEFAULT_ANTITANK_WALL_OPTIONS as kt, listControlMeasureMetadata as l, sectorDrawRule as ln, DEFAULT_GENERIC_SECTOR_OPTIONS as lt, DEFAULT_STRONG_POINT_OPTIONS as m, blockDrawRule as mn, DEFAULT_CLASSIC_ARROW_OPTIONS as mt, resolveStyleHints as n, line24DrawRule as nn, DEFAULT_COUNTERATTACK_OPTIONS as nt, getControlMeasureMetadata as o, ambushDrawRule as on, RADAR_SEARCH_DOCTRINE_FILL_COLOR as ot, DEFAULT_RETAIN_OPTIONS as p, disruptDrawRule as pn, DEFAULT_GENERIC_CIRCLE_OPTIONS as pt, DEFAULT_ENCIRCLEMENT_OPTIONS as q, DEFAULT_STROKE_WIDTH_CSS_PIXELS as qt, CONTROL_MEASURE_IDS as r, line23DrawRule as rn, DEFAULT_SUPPORTING_ATTACK_OPTIONS as rt, getControlMeasureMetadataByValue as s, attackByFireDrawRule as sn, RADAR_SEARCH_DOCTRINE_STROKE_COLOR as st, renderControlMeasure as t, line26DrawRule as tn, DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS as tt, DEFAULT_TURNING_MOVEMENT_OPTIONS as u, staticPointDrawRule as un, DEFAULT_GENERIC_RECTANGLE_OPTIONS as ut, DEFAULT_PICKUP_ZONE_OPTIONS as v, createMidpointPerpendicularDrawRule as vn, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as vt, DEFAULT_LANDING_ZONE_OPTIONS as w, computeInitialWidthPoint as wn, DEFAULT_BLOCK_OPTIONS as wt, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as x, snapToMidpointPerpendicular as xn, DEFAULT_LIGHT_LINE_OPTIONS as xt, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as y, getMidpointPerpendicularSignedDistance as yn, DEFAULT_GENERIC_C2_LINE_OPTIONS as yt, DEFAULT_RELEASE_LINE_OPTIONS as z, normalizeTextAmplifiers as zt };