@orbat-mapper/control-measures 0.2.0-alpha.10 → 0.2.0-alpha.12

package/dist/{renderControlMeasure-BblcXXLp.mjs → renderControlMeasure-DHQO01PA.mjs}

@@ -963,7 +963,231 @@ const rectangleDrawRule = {
 	}
 };
 //#endregion
+//#region src/internal/echelon.ts
+/**
+* APP-6 echelon (Field B) glyph vocabulary, shared by the control measures that
+* stamp a unit-size amplifier onto their geometry (Boundary, Battle Position).
+*
+* A compact port of the APP-6 echelon designs, modeled on milsymbol but
+* expressed as parametric geometry so it bakes into GeoJSON and strokes
+* monocolor (ADR-0023). Every glyph is built from three primitives — vertical
+* bars, crosses, and dots — plus the team/crew ring and command `++`.
+*/
+const ECHELONS = {
+	team: {
+		kind: "ring",
+		count: 1,
+		label: "Team/Crew"
+	},
+	crew: {
+		kind: "ring",
+		count: 1
+	},
+	squad: {
+		kind: "dots",
+		count: 1,
+		label: "Squad"
+	},
+	section: {
+		kind: "dots",
+		count: 2,
+		label: "Section"
+	},
+	platoon: {
+		kind: "dots",
+		count: 3,
+		label: "Platoon"
+	},
+	company: {
+		kind: "bars",
+		count: 1,
+		label: "Company"
+	},
+	battalion: {
+		kind: "bars",
+		count: 2,
+		label: "Battalion"
+	},
+	regiment: {
+		kind: "bars",
+		count: 3,
+		label: "Regiment"
+	},
+	brigade: {
+		kind: "crosses",
+		count: 1,
+		label: "Brigade"
+	},
+	division: {
+		kind: "crosses",
+		count: 2,
+		label: "Division"
+	},
+	corps: {
+		kind: "crosses",
+		count: 3,
+		label: "Corps"
+	},
+	army: {
+		kind: "crosses",
+		count: 4,
+		label: "Army"
+	},
+	"army-group": {
+		kind: "crosses",
+		count: 5,
+		label: "Army Group"
+	},
+	region: {
+		kind: "crosses",
+		count: 6,
+		label: "Region"
+	},
+	command: {
+		kind: "command",
+		count: 2,
+		label: "Command"
+	}
+};
+/** Symbol-form aliases (`"XX"`, `"II"`, `"•••"`, …) → canonical echelon key. */
+const ECHELON_ALIASES = {
+	ø: "team",
+	"•": "squad",
+	"••": "section",
+	"•••": "platoon",
+	i: "company",
+	ii: "battalion",
+	iii: "regiment",
+	x: "brigade",
+	xx: "division",
+	xxx: "corps",
+	xxxx: "army",
+	xxxxx: "army-group",
+	xxxxxx: "region",
+	"++": "command"
+};
+/** Enum options for the params panel, derived from {@link ECHELONS}. */
+const ECHELON_PARAM_OPTIONS = [{
+	label: "None",
+	value: "none"
+}, ...Object.entries(ECHELONS).filter(([, spec]) => spec.label !== void 0).map(([value, spec]) => ({
+	label: spec.label,
+	value
+}))];
+function resolveEchelon(echelon) {
+	const key = echelon.trim().toLowerCase();
+	if (key.length === 0) return void 0;
+	const alias = ECHELON_ALIASES[key];
+	return ECHELONS[key] ?? (alias ? ECHELONS[alias] : void 0);
+}
+/**
+* Builds the echelon glyph centered at `center`, with its baseline along
+* `along` and `perp` (both unit vectors), `h` meters tall. Returns the glyph's
+* `strokes` (open polylines), `fills` (closed rings drawn as solid shapes —
+* the squad/section/platoon dots), and its intrinsic width along the line; the
+* caller adds the configurable side padding to derive the line gap.
+*/
+function buildEchelonGlyph(center, along, perp, h, spec) {
+	const P = (a, p) => {
+		const q = vecAdd(vecAdd(center, vecScale(along, a)), vecScale(perp, p));
+		return unproject(q[0], q[1]);
+	};
+	const ring = (a, r) => {
+		const pts = [];
+		const steps = 16;
+		for (let i = 0; i <= steps; i++) {
+			const t = 2 * Math.PI * i / steps;
+			pts.push(P(a + r * Math.cos(t), r * Math.sin(t)));
+		}
+		return pts;
+	};
+	const strokes = [];
+	const fills = [];
+	const half = h / 2;
+	switch (spec.kind) {
+		case "bars": {
+			const spacing = h * .8;
+			const total = (spec.count - 1) * spacing;
+			for (let j = 0; j < spec.count; j++) {
+				const a = -total / 2 + j * spacing;
+				strokes.push([P(a, -half), P(a, half)]);
+			}
+			return {
+				strokes,
+				fills,
+				width: total
+			};
+		}
+		case "crosses": {
+			const w = h;
+			const spacing = h * 1.4;
+			const total = (spec.count - 1) * spacing;
+			for (let j = 0; j < spec.count; j++) {
+				const a0 = -total / 2 + j * spacing;
+				strokes.push([P(a0 - w / 2, -half), P(a0 + w / 2, half)]);
+				strokes.push([P(a0 - w / 2, half), P(a0 + w / 2, -half)]);
+			}
+			return {
+				strokes,
+				fills,
+				width: total + w
+			};
+		}
+		case "dots": {
+			const r = h * .3;
+			const spacing = h * 1.2;
+			const total = (spec.count - 1) * spacing;
+			for (let j = 0; j < spec.count; j++) fills.push(ring(-total / 2 + j * spacing, r));
+			return {
+				strokes,
+				fills,
+				width: total + 2 * r
+			};
+		}
+		case "ring": {
+			const r = h * .6;
+			strokes.push(ring(0, r));
+			strokes.push([P(-h * .8, -h * .4), P(h * .8, h * .4)]);
+			return {
+				strokes,
+				fills,
+				width: h * 1.6
+			};
+		}
+		case "command": {
+			const arm = h * .5;
+			const spacing = h * 1.4;
+			const total = (spec.count - 1) * spacing;
+			for (let j = 0; j < spec.count; j++) {
+				const a0 = -total / 2 + j * spacing;
+				strokes.push([P(a0 - arm, 0), P(a0 + arm, 0)]);
+				strokes.push([P(a0, -half), P(a0, half)]);
+			}
+			return {
+				strokes,
+				fills,
+				width: total + 2 * arm
+			};
+		}
+	}
+}
+//#endregion
 //#region src/generators/cm15-maneuver-areas/params.ts
+const AREA_SMOOTH_PARAMS = [{
+	key: "smooth",
+	label: "Smooth",
+	description: "Round the area's corners by curving the boundary through the control points.",
+	type: "boolean"
+}, {
+	key: "smoothResolution",
+	label: "Smooth resolution",
+	description: "Number of samples per segment when smooth mode is enabled.",
+	type: "number",
+	min: 2,
+	max: 64,
+	step: 1,
+	visibleWhen: (opts) => Boolean(opts.smooth)
+}];
 const ATTACK_SHAFT_PARAMS = [
 	{
 		key: "shaftWidthRatio",
@@ -1075,25 +1299,7 @@ const ENCIRCLEMENT_PARAMS = [
 		step: .01
 	}
 ];
-const FORTIFIED_AREA_PARAMS = [
-	{
-		key: "smooth",
-		label: "Smooth",
-		description: "Round the area's corners by curving the boundary through the control points.",
-		type: "boolean"
-	},
-	{
-		key: "smoothResolution",
-		label: "Smooth resolution",
-		description: "Number of samples per segment when smooth mode is enabled.",
-		type: "number",
-		min: 2,
-		max: 64,
-		step: 1,
-		visibleWhen: (opts) => Boolean(opts.smooth)
-	},
-	...FORTIFIED_AREA_SIZE_PARAMS
-];
+const FORTIFIED_AREA_PARAMS = [...AREA_SMOOTH_PARAMS, ...FORTIFIED_AREA_SIZE_PARAMS];
 const AREA_LABEL_PADDING_PARAM = {
 	key: "labelPadding",
 	label: "Label padding",
@@ -1103,22 +1309,53 @@ const AREA_LABEL_PADDING_PARAM = {
 	max: 2,
 	step: .05
 };
-const LABELED_AREA_PARAMS = [
+const LABELED_AREA_PARAMS = [...AREA_SMOOTH_PARAMS, AREA_LABEL_PADDING_PARAM];
+const ECHELON_AREA_PARAMS = [
+	...AREA_SMOOTH_PARAMS,
 	{
-		key: "smooth",
-		label: "Smooth",
-		description: "Round the area's corners by curving the boundary through the control points.",
-		type: "boolean"
+		key: "echelon",
+		label: "Echelon",
+		description: "Field B unit-size amplifier, drawn on the boundary.",
+		type: "enum",
+		options: ECHELON_PARAM_OPTIONS
 	},
 	{
-		key: "smoothResolution",
-		label: "Smooth resolution",
-		description: "Number of samples per segment when smooth mode is enabled.",
+		key: "echelonSizePixels",
+		label: "Echelon size",
+		description: "Echelon glyph height in screen pixels.",
 		type: "number",
-		min: 2,
-		max: 64,
+		min: 8,
+		max: 48,
 		step: 1,
-		visibleWhen: (opts) => Boolean(opts.smooth)
+		unit: "px"
+	},
+	{
+		key: "echelonSize",
+		label: "Echelon size",
+		description: "Echelon glyph height in meters.",
+		type: "number",
+		min: 50,
+		max: 2e4,
+		step: 50,
+		unit: "m"
+	},
+	{
+		key: "echelonPadding",
+		label: "Echelon padding",
+		description: "Gap on each side of the echelon, as a ratio of its height.",
+		type: "number",
+		min: 0,
+		max: 2,
+		step: .05
+	},
+	{
+		key: "echelonPosition",
+		label: "Echelon position",
+		description: "Slide the echelon along the boundary, as a fraction of the perimeter from the bottom edge.",
+		type: "number",
+		min: -.5,
+		max: .5,
+		step: .01
 	},
 	AREA_LABEL_PADDING_PARAM
 ];
@@ -1165,6 +1402,16 @@ const AREA_TEXT_AMPLIFIERS = [
 /** {@link AREA_TEXT_AMPLIFIERS} without the N (hostile) field, for measures
 *  whose template carries no ENY marker (Fortified Area). */
 const AREA_TEXT_AMPLIFIERS_NO_HOSTILE = AREA_TEXT_AMPLIFIERS.filter((d) => d.key !== "N");
+/** {@link AREA_TEXT_AMPLIFIERS} without the H (additional information) field,
+*  for measures whose template omits that row but keeps the W/W1 window and
+*  the N (hostile) marker (Submarine Action Area, Submarine-Generated Action
+*  Area). */
+const AREA_TEXT_AMPLIFIERS_NO_ADDITIONAL_INFO = AREA_TEXT_AMPLIFIERS.filter((d) => d.key !== "H");
+/** {@link AREA_TEXT_AMPLIFIERS} reduced to just the designation (Field T) and
+*  hostile marker (Field N), for measures whose template carries no
+*  additional-information or date-time-group rows (Area, Drop Zone,
+*  Extraction Zone). */
+const AREA_TEXT_AMPLIFIERS_DESIGNATION_HOSTILE = AREA_TEXT_AMPLIFIERS.filter((d) => d.key === "T" || d.key === "N");
 //#endregion
 //#region src/generators/cm15-maneuver-areas/airborneAttack.ts
 const DEFAULT_AIRBORNE_ATTACK_OPTIONS = {
@@ -1415,215 +1662,6 @@ const AMBUSH = defineControlMeasure({
 	rule: ambushDrawRule
 });
 //#endregion
-//#region src/internal/echelon.ts
-/**
-* APP-6 echelon (Field B) glyph vocabulary, shared by the control measures that
-* stamp a unit-size amplifier onto their geometry (Boundary, Battle Position).
-*
-* A compact port of the APP-6 echelon designs, modeled on milsymbol but
-* expressed as parametric geometry so it bakes into GeoJSON and strokes
-* monocolor (ADR-0023). Every glyph is built from three primitives — vertical
-* bars, crosses, and dots — plus the team/crew ring and command `++`.
-*/
-const ECHELONS = {
-	team: {
-		kind: "ring",
-		count: 1,
-		label: "Team/Crew"
-	},
-	crew: {
-		kind: "ring",
-		count: 1
-	},
-	squad: {
-		kind: "dots",
-		count: 1,
-		label: "Squad"
-	},
-	section: {
-		kind: "dots",
-		count: 2,
-		label: "Section"
-	},
-	platoon: {
-		kind: "dots",
-		count: 3,
-		label: "Platoon"
-	},
-	company: {
-		kind: "bars",
-		count: 1,
-		label: "Company"
-	},
-	battalion: {
-		kind: "bars",
-		count: 2,
-		label: "Battalion"
-	},
-	regiment: {
-		kind: "bars",
-		count: 3,
-		label: "Regiment"
-	},
-	brigade: {
-		kind: "crosses",
-		count: 1,
-		label: "Brigade"
-	},
-	division: {
-		kind: "crosses",
-		count: 2,
-		label: "Division"
-	},
-	corps: {
-		kind: "crosses",
-		count: 3,
-		label: "Corps"
-	},
-	army: {
-		kind: "crosses",
-		count: 4,
-		label: "Army"
-	},
-	"army-group": {
-		kind: "crosses",
-		count: 5,
-		label: "Army Group"
-	},
-	region: {
-		kind: "crosses",
-		count: 6,
-		label: "Region"
-	},
-	command: {
-		kind: "command",
-		count: 2,
-		label: "Command"
-	}
-};
-/** Symbol-form aliases (`"XX"`, `"II"`, `"•••"`, …) → canonical echelon key. */
-const ECHELON_ALIASES = {
-	ø: "team",
-	"•": "squad",
-	"••": "section",
-	"•••": "platoon",
-	i: "company",
-	ii: "battalion",
-	iii: "regiment",
-	x: "brigade",
-	xx: "division",
-	xxx: "corps",
-	xxxx: "army",
-	xxxxx: "army-group",
-	xxxxxx: "region",
-	"++": "command"
-};
-/** Enum options for the params panel, derived from {@link ECHELONS}. */
-const ECHELON_PARAM_OPTIONS = [{
-	label: "None",
-	value: "none"
-}, ...Object.entries(ECHELONS).filter(([, spec]) => spec.label !== void 0).map(([value, spec]) => ({
-	label: spec.label,
-	value
-}))];
-function resolveEchelon(echelon) {
-	const key = echelon.trim().toLowerCase();
-	if (key.length === 0) return void 0;
-	const alias = ECHELON_ALIASES[key];
-	return ECHELONS[key] ?? (alias ? ECHELONS[alias] : void 0);
-}
-/**
-* Builds the echelon glyph centered at `center`, with its baseline along
-* `along` and `perp` (both unit vectors), `h` meters tall. Returns the glyph's
-* `strokes` (open polylines), `fills` (closed rings drawn as solid shapes —
-* the squad/section/platoon dots), and its intrinsic width along the line; the
-* caller adds the configurable side padding to derive the line gap.
-*/
-function buildEchelonGlyph(center, along, perp, h, spec) {
-	const P = (a, p) => {
-		const q = vecAdd(vecAdd(center, vecScale(along, a)), vecScale(perp, p));
-		return unproject(q[0], q[1]);
-	};
-	const ring = (a, r) => {
-		const pts = [];
-		const steps = 16;
-		for (let i = 0; i <= steps; i++) {
-			const t = 2 * Math.PI * i / steps;
-			pts.push(P(a + r * Math.cos(t), r * Math.sin(t)));
-		}
-		return pts;
-	};
-	const strokes = [];
-	const fills = [];
-	const half = h / 2;
-	switch (spec.kind) {
-		case "bars": {
-			const spacing = h * .8;
-			const total = (spec.count - 1) * spacing;
-			for (let j = 0; j < spec.count; j++) {
-				const a = -total / 2 + j * spacing;
-				strokes.push([P(a, -half), P(a, half)]);
-			}
-			return {
-				strokes,
-				fills,
-				width: total
-			};
-		}
-		case "crosses": {
-			const w = h;
-			const spacing = h * 1.4;
-			const total = (spec.count - 1) * spacing;
-			for (let j = 0; j < spec.count; j++) {
-				const a0 = -total / 2 + j * spacing;
-				strokes.push([P(a0 - w / 2, -half), P(a0 + w / 2, half)]);
-				strokes.push([P(a0 - w / 2, half), P(a0 + w / 2, -half)]);
-			}
-			return {
-				strokes,
-				fills,
-				width: total + w
-			};
-		}
-		case "dots": {
-			const r = h * .3;
-			const spacing = h * 1.2;
-			const total = (spec.count - 1) * spacing;
-			for (let j = 0; j < spec.count; j++) fills.push(ring(-total / 2 + j * spacing, r));
-			return {
-				strokes,
-				fills,
-				width: total + 2 * r
-			};
-		}
-		case "ring": {
-			const r = h * .6;
-			strokes.push(ring(0, r));
-			strokes.push([P(-h * .8, -h * .4), P(h * .8, h * .4)]);
-			return {
-				strokes,
-				fills,
-				width: h * 1.6
-			};
-		}
-		case "command": {
-			const arm = h * .5;
-			const spacing = h * 1.4;
-			const total = (spec.count - 1) * spacing;
-			for (let j = 0; j < spec.count; j++) {
-				const a0 = -total / 2 + j * spacing;
-				strokes.push([P(a0 - arm, 0), P(a0 + arm, 0)]);
-				strokes.push([P(a0, -half), P(a0, half)]);
-			}
-			return {
-				strokes,
-				fills,
-				width: total + 2 * arm
-			};
-		}
-	}
-}
-//#endregion
 //#region src/internal/gapped-line.ts
 /**
 * Pushes the arc-length gap `[g0, g1]` onto `gaps`, normalizing it onto
@@ -1752,13 +1790,81 @@ function arrowAxis(coordinates) {
 	};
 }
 /**
-* Clamps and rounds a smooth-resolution option (samples per segment) onto
-* `[MIN_SMOOTH_RESOLUTION, MAX_SMOOTH_RESOLUTION]`, falling back to `fallback`
-* for non-finite input. The default varies per measure, so it's passed in.
+* Clamps and rounds a smooth-resolution option (samples per segment) onto
+* `[MIN_SMOOTH_RESOLUTION, MAX_SMOOTH_RESOLUTION]`, falling back to `fallback`
+* for non-finite input. The default varies per measure, so it's passed in.
+*/
+function normalizeSmoothResolution$2(value, fallback) {
+	if (!Number.isFinite(value)) return fallback;
+	return Math.min(64, Math.max(2, Math.round(value)));
+}
+/**
+* Shared param descriptors for {@link SmoothLineOptions}, modeled on
+* `SMOOTH_PATH_PARAMS` (cm99-generic-graphics/params.ts). Measures that add
+* their own params should spread these at the top of the array.
+*/
+const SMOOTH_LINE_PARAMS = [{
+	key: "smooth",
+	label: "Smooth",
+	description: "Round the line's corners by curving the path through the control points.",
+	type: "boolean"
+}, {
+	key: "smoothResolution",
+	label: "Smooth resolution",
+	description: "Number of samples per segment when smooth mode is enabled.",
+	type: "number",
+	min: 2,
+	max: 64,
+	step: 1,
+	visibleWhen: (opts) => Boolean(opts.smooth)
+}];
+/**
+* Applies {@link SmoothLineOptions} to projected vertices `verts`: runs
+* {@link catmullRom} at the resolved (clamped) sample resolution when `smooth`
+* is set, else returns `verts` unchanged.
+*/
+function smoothLineVerts(verts, options, defaultResolution) {
+	return options.smooth ? catmullRom(verts, normalizeSmoothResolution$2(options.smoothResolution ?? defaultResolution, defaultResolution)) : verts;
+}
+/**
+* Resamples a path into equal arc-length segments.
+*
+* This is useful for a repeated motif (such as a fortified tooth or FLOT
+* scallop) after smoothing. Catmull-Rom samples are evenly spaced in spline
+* parameter, not distance, so using them directly as motif boundaries causes
+* the motifs to bunch up where the curve's samples are closer together.
 */
-function normalizeSmoothResolution$2(value, fallback) {
-	if (!Number.isFinite(value)) return fallback;
-	return Math.min(64, Math.max(2, Math.round(value)));
+function evenlySpacePath(points, targetSegmentLength) {
+	if (points.length < 2) return points;
+	const segmentLengths = [];
+	let totalLength = 0;
+	for (let i = 0; i < points.length - 1; i++) {
+		const length = vecMag(vecSub(points[i + 1], points[i]));
+		segmentLengths.push(length);
+		totalLength += length;
+	}
+	if (totalLength < 1e-6) return [points[0]];
+	const segmentCount = Math.max(1, Math.round(totalLength / targetSegmentLength));
+	const segmentLength = totalLength / segmentCount;
+	const out = [points[0]];
+	let sourceIndex = 0;
+	let sourceStart = points[0];
+	let consumed = 0;
+	for (let segment = 1; segment < segmentCount; segment++) {
+		const target = segment * segmentLength;
+		while (sourceIndex < segmentLengths.length - 1 && consumed + segmentLengths[sourceIndex] < target) {
+			consumed += segmentLengths[sourceIndex];
+			sourceIndex++;
+			sourceStart = points[sourceIndex];
+		}
+		const length = segmentLengths[sourceIndex];
+		if (length < 1e-6) continue;
+		const t = (target - consumed) / length;
+		const sourceEnd = points[sourceIndex + 1];
+		out.push([sourceStart[0] + (sourceEnd[0] - sourceStart[0]) * t, sourceStart[1] + (sourceEnd[1] - sourceStart[1]) * t]);
+	}
+	out.push(points[points.length - 1]);
+	return out;
 }
 /** One centripetal Catmull-Rom sample at parameter `t` over control points `p0..p3`. */
 function catmullRomAt(p0, p1, p2, p3, t) {
@@ -1934,6 +2040,31 @@ function placeEchelon(perimeter, h, echelon, echelonPadding, echelonPosition, ec
 		gaps
 	};
 }
+/**
+* Factory for the `freezeOrientation` hook (ADR-0023) shared by every
+* echelon-carrying closed-area measure (Battle Position, Strong Point, Base
+* Camp, Guerrilla Base): pins the echelon anchor to its current bottom-edge
+* fraction so a subsequent rigid rotation of `controlPoints` (e.g. the
+* transform box's rotate grip) does not re-derive a different "bottom edge"
+* against the rotated geometry. `defaults` supplies the measure's own
+* `echelon`/`smooth`/`smoothResolution` defaults, since each measure's
+* `DEFAULT_*_OPTIONS` differ (e.g. Battle Position's `echelon: "battalion"`
+* vs. Base Camp/Guerrilla Base's `echelon: "none"`).
+*
+* The returned hook returns `undefined` — nothing to freeze — when:
+*  - `echelonAnchor` is already set (previously frozen or user-authored), or
+*  - the echelon resolves to none (nothing visible to pin), or
+*  - the ring is degenerate (no segments, or a near-zero perimeter).
+*/
+function makeFreezeEchelonAnchor(defaults) {
+	return function freezeEchelonAnchor(controlPoints, options) {
+		if (options.echelonAnchor !== void 0) return void 0;
+		if (!resolveEchelon(options.echelon ?? defaults.echelon)) return void 0;
+		const perimeter = buildAreaPerimeter(buildClosedRing(controlPoints, options.smooth ?? defaults.smooth, options.smoothResolution ?? defaults.smoothResolution, defaults.smoothResolution));
+		if (perimeter.segs.length === 0 || perimeter.totalLength < 1e-6) return void 0;
+		return { echelonAnchor: perimeter.anchorTarget / perimeter.totalLength };
+	};
+}
 //#endregion
 //#region src/internal/angle-utils.ts
 /**
@@ -1976,13 +2107,13 @@ function labelRotationAlong(dir) {
 */
 function pushUnitLabels(out, frame, units) {
 	const { center, perp, offset, rotation, labelSize } = frame;
-	for (const { side, designator, country, textAnchor } of units) {
+	for (const { side, designator, country, textAnchor, amplifierField } of units) {
 		let text;
 		if (designator.length > 0 && country.length > 0) text = `${designator} (${country})`;
 		else if (designator.length > 0) text = designator;
 		else if (country.length > 0) text = `(${country})`;
 		else continue;
-		pushLabel(out, vecAdd(center, vecScale(perp, side * offset)), text, rotation, labelSize, textAnchor);
+		pushLabel(out, vecAdd(center, vecScale(perp, side * offset)), text, rotation, labelSize, textAnchor, amplifierField);
 	}
 }
 /**
@@ -2095,19 +2226,20 @@ function endTangents(verts) {
 	};
 }
 /**
-* Resolves {@link LabelSizeOptions} into the `textSize*` properties adapters
-* expect on a label feature, omitting any key whose input was not supplied.
+* Resolves {@link LabelSizeOptions} into the single text-size property the
+* label feature carries (ADR-0028): `textSizePixels` when screen-anchored
+* (`labelSizePixels` present — pixels win over a stray `labelSize`),
+* `textSizeMeters` when ground-anchored (`labelSize` alone), or neither, in
+* which case adapters render their engine default, screen-fixed.
 */
 function labelSizeProps(options) {
-	const { labelSizePixels, labelSizeZoom, labelSizeResolution } = options;
-	const props = {};
-	if (labelSizePixels !== void 0) props.textSizePixels = labelSizePixels;
-	if (labelSizeZoom !== void 0) props.textSizeZoom = labelSizeZoom;
-	if (labelSizeResolution !== void 0) props.textSizeResolution = labelSizeResolution;
-	return props;
+	const { labelSize, labelSizePixels } = options;
+	if (labelSizePixels !== void 0) return { textSizePixels: labelSizePixels };
+	if (labelSize !== void 0) return { textSizeMeters: labelSize };
+	return {};
 }
 /** Pushes a `part: "label"` Point feature at projected `point`. */
-function pushLabel(out, point, text, rotation, sizeProps, textAnchor) {
+function pushLabel(out, point, text, rotation, sizeProps, textAnchor, amplifierField) {
 	out.push({
 		type: "Feature",
 		properties: {
@@ -2115,6 +2247,7 @@ function pushLabel(out, point, text, rotation, sizeProps, textAnchor) {
 			text,
 			rotation,
 			...textAnchor ? { textAnchor } : {},
+			...amplifierField ? { amplifierField } : {},
 			...sizeProps
 		},
 		geometry: {
@@ -2123,20 +2256,21 @@ function pushLabel(out, point, text, rotation, sizeProps, textAnchor) {
 		}
 	});
 }
-/** Ratio of resolved label height (`labelSizePixels × labelSizeResolution`) used as end-label clearance. */
+/** Ratio of resolved label height (`labelSize`, or `labelSizePixels × metersPerPixel`) used as end-label clearance. */
 const END_LABEL_CLEARANCE_RATIO = .3;
 /** Ratio of resolved label height used to inset "above" end labels from the tip. */
 const ABOVE_LABEL_INSET_RATIO = .3;
 /** Ratio of resolved label height used as the "above" end labels' perpendicular offset. */
 const ABOVE_LABEL_OFFSET_RATIO = .6;
 function textHeight(options) {
-	const { labelSizePixels, labelSizeResolution } = options;
-	if (labelSizePixels !== void 0 && labelSizeResolution !== void 0) return labelSizePixels * labelSizeResolution;
+	const { labelSize, labelSizePixels, metersPerPixel } = options;
+	if (labelSizePixels !== void 0) return metersPerPixel !== void 0 && metersPerPixel > 0 ? labelSizePixels * metersPerPixel : void 0;
+	return labelSize;
 }
 /**
-* Ground-anchored label offset in meters: `ratio` × the label's resolved height
-* (`labelSizePixels × labelSizeResolution`), or `fallbackMeters` when no live
-* size was captured (e.g. no map resolution yet). The fallback is small
+* Label offset in meters: `ratio` × the label's resolved height (`labelSize`
+* meters, or `labelSizePixels × metersPerPixel` when screen-anchored), or
+* `fallbackMeters` when no size resolves (e.g. no map resolution yet). The fallback is small
 * relative to typical control measure spans — the same order of magnitude as
 * Boundary's own smallest label offsets — so a fixed label still reads as "just
 * clear of the line" rather than crowding it or floating away. Callers supply
@@ -2230,16 +2364,20 @@ function pushEndLabelsAbove(out, verts, textForEnd, options = {}) {
 * as a complete FeatureCollection.
 */
 function fixedLabelLineFeatures(positions, options, textForEnd) {
-	const { part, placement = "beyond", phaseLineName, includePrefix = true, ...sizeOptions } = options;
+	const { part, placement = "beyond", phaseLineName, includePrefix = true, smooth, smoothResolution, ...sizeOptions } = options;
+	const verts = smoothLineVerts(positions.map((p) => project(p[0], p[1])), {
+		smooth,
+		smoothResolution
+	}, 12);
+	const lineCoordinates = smooth ? verts.map((v) => unproject(v[0], v[1])) : positions;
 	const features = [{
 		type: "Feature",
 		properties: { part },
 		geometry: {
 			type: "LineString",
-			coordinates: positions
+			coordinates: lineCoordinates
 		}
 	}];
-	const verts = positions.map((p) => project(p[0], p[1]));
 	const labelFeatures = [];
 	if (placement === "above") pushEndLabelsAbove(labelFeatures, verts, textForEnd, sizeOptions);
 	else pushEndLabels(labelFeatures, verts, textForEnd, sizeOptions);
@@ -2254,7 +2392,9 @@ function fixedLabelLineFeatures(positions, options, textForEnd) {
 //#endregion
 //#region src/internal/area-labels.ts
 /** Stored label rotation for horizontal (screen-upright) area text — adapters
-*  render feature rotation as `π − rotation`, so `π` renders as `0`. */
+*  render feature rotation as `π − rotation`, so `π` renders as `0`. Exported
+*  for reuse by measures that place a horizontal label outside the area's
+*  boundary (e.g. Airfield Zone's Field H). */
 const HORIZONTAL_LABEL_ROTATION = Math.PI;
 /** Row pitch, as a ratio of the resolved label height, between stacked
 *  name/H/W-W1 rows (see {@link pushAreaLabels}). */
@@ -2268,7 +2408,7 @@ const ENY_CLEARANCE_RATIO = .3;
 *  for sizing the boundary knockout gap — no live text-measurement is
 *  available at generator time. */
 const ENY_CHAR_ASPECT_RATIO = .6;
-const DEFAULT_SMOOTH_RESOLUTION$7 = 16;
+const DEFAULT_SMOOTH_RESOLUTION$9 = 16;
 /**
 * Composes an area's main label text from a `prefix` (e.g. `"AO"`) and a
 * `designation` (e.g. `"GREEN"`), mirroring Phase Line's "PL" precedent: a
@@ -2305,7 +2445,8 @@ function composeAreaLabelTexts(textAmplifiers, prefix = "", separator = " ") {
 * divide by zero). For a **concave** ring the area centroid can fall outside
 * the shape; that limitation is accepted here, matching the doctrinal
 * template's plain "center of the area" placement rather than a
-* point-in-polygon-safe visual center.
+* point-in-polygon-safe visual center. Exported for reuse by measures that
+* center a non-label glyph on the area (e.g. Airfield Zone's runway glyph).
 */
 function ringCentroid(verts) {
 	const n = verts.length - 1;
@@ -2331,12 +2472,6 @@ function ringCentroid(verts) {
 	const factor = 1 / (3 * area2);
 	return [cx * factor, cy * factor];
 }
-/** Joins the W/W1 date-time-group pair as `"W - W1"`; a single supplied value
-*  passes through unchanged; neither set yields `""`. */
-function joinDtg(start, end) {
-	if (start && end) return `${start} - ${end}`;
-	return start ?? end ?? "";
-}
 /**
 * Points where the closed ring `verts` crosses the horizontal line
 * `y = target`, one per crossing edge, plus the ring's total arc length —
@@ -2380,7 +2515,7 @@ function ringCrossingsAtY(verts, target) {
 * {@link buildGappedLine} uses) an "ENY" marker knocks out of the boundary —
 * empty unless `texts.hostile` was placed.
 *
-* Rows are `[name, additionalInformation, joinDtg(dtgStart, dtgEnd)]`,
+* Rows are `[name (T), additionalInformation (H), dtgStart (W), dtgEnd (W1)]`,
 * filtered to non-empty text, stacked around the ring's {@link ringCentroid}
 * at `pitch = resolveLabelOffsetMeters(options, 1.2 + labelPadding)` (the 50m
 * no-size fallback applies until a live label size is captured — see
@@ -2414,14 +2549,18 @@ function pushAreaLabels(out, ringVerts, texts, options = {}) {
 	const padding = Math.max(0, options.labelPadding ?? 0);
 	const [cx, cy] = ringCentroid(ringVerts);
 	const rows = [
-		texts.name,
-		texts.additionalInformation,
-		joinDtg(texts.dtgStart, texts.dtgEnd)
-	].filter((s) => Boolean(s && s.length > 0));
+		[texts.name, "T"],
+		[texts.additionalInformation, "H"],
+		[texts.dtgStart, "W"],
+		[texts.dtgEnd, "W1"]
+	].flatMap(([text, field]) => text ? [{
+		text,
+		field
+	}] : []);
 	if (rows.length > 0) {
 		const pitch = resolveLabelOffsetMeters(options, ROW_PITCH_RATIO + padding);
-		rows.forEach((text, i) => {
-			pushLabel(out, [cx, cy + ((rows.length - 1) / 2 - i) * pitch], text, HORIZONTAL_LABEL_ROTATION, sizeProps);
+		rows.forEach(({ text, field }, i) => {
+			pushLabel(out, [cx, cy + ((rows.length - 1) / 2 - i) * pitch], text, HORIZONTAL_LABEL_ROTATION, sizeProps, void 0, field);
 		});
 	}
 	const gaps = [];
@@ -2435,7 +2574,7 @@ function pushAreaLabels(out, ringVerts, texts, options = {}) {
 			const textWidth = texts.hostile.length * ENY_CHAR_ASPECT_RATIO * textHeight;
 			const clearance = (ENY_CLEARANCE_RATIO + padding) * textHeight;
 			for (const crossing of [west, east]) {
-				pushLabel(out, [crossing.x, cy], texts.hostile, HORIZONTAL_LABEL_ROTATION, sizeProps);
+				pushLabel(out, [crossing.x, cy], texts.hostile, HORIZONTAL_LABEL_ROTATION, sizeProps, void 0, "N");
 				const halfExtent = .5 * (textWidth * Math.abs(crossing.along[0]) + textHeight * Math.abs(crossing.along[1])) + clearance;
 				pushWrappedGap(gaps, crossing.arc - halfExtent, crossing.arc + halfExtent, totalArc);
 			}
@@ -2479,8 +2618,8 @@ function boundaryFeature(verts, gaps) {
 * common (no `N`) case is unaffected.
 */
 function labeledAreaFeatures(positions, options, texts) {
-	const { smooth = false, smoothResolution = DEFAULT_SMOOTH_RESOLUTION$7, ...labelOptions } = options;
-	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION$7);
+	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))];
 	features.push(...labelFeatures);
@@ -2490,44 +2629,492 @@ function labeledAreaFeatures(positions, options, texts) {
 	};
 }
 //#endregion
-//#region src/generators/cm12-command-control-areas/area-of-operations.ts
-/** Default options for the Area of operations control measure. */
-const DEFAULT_AREA_OF_OPERATIONS_OPTIONS = {
-	smooth: false,
-	smoothResolution: 16
+//#region src/generators/cm15-maneuver-areas/area.ts
+/** Default options for the Area control measure. */
+const DEFAULT_AREA_OPTIONS = {
+	smooth: false,
+	smoothResolution: 16
+};
+const AREA_METADATA = {
+	id: "area",
+	name: "Area",
+	description: "A generic maneuver area enclosed by a boundary.",
+	entity: "Maneuver Areas",
+	entityType: "Area",
+	value: "150100",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: [
+		"Polygon",
+		"MultiLineString",
+		"Point"
+	],
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: LABELED_AREA_PARAMS,
+	textAmplifiers: AREA_TEXT_AMPLIFIERS_DESIGNATION_HOSTILE
+};
+/**
+* Creates an Area control measure: a closed area through `positions` labeled
+* at its center with an un-prefixed `T` (Field T) plus an `N` (Field N) ENY
+* marker, per {@link labeledAreaFeatures}.
+*/
+function createArea(positions, options = {}, textAmplifiers = {}) {
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, ""));
+}
+const AREA = defineControlMeasure({
+	metadata: AREA_METADATA,
+	generator: createArea,
+	defaultOptions: DEFAULT_AREA_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: {},
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
+//#region src/generators/cm12-command-control-areas/area-of-operations.ts
+/** Default options for the Area of operations control measure. */
+const DEFAULT_AREA_OF_OPERATIONS_OPTIONS = {
+	smooth: false,
+	smoothResolution: 16
+};
+const AREA_OF_OPERATIONS_METADATA = {
+	id: "area-of-operations",
+	name: "Area of operations",
+	description: "An operational area defined by a commander for land and naval forces, within which the assigned force conducts military operations.",
+	entity: "Command and Control Areas",
+	entityType: "Area of Operations",
+	value: "120100",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: [
+		"Polygon",
+		"MultiLineString",
+		"Point"
+	],
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: LABELED_AREA_PARAMS,
+	textAmplifiers: AREA_TEXT_AMPLIFIERS
+};
+/**
+* Creates an Area of operations control measure: a closed area through
+* `positions` labeled at its center with "AO "-prefixed `T` (Field T) plus
+* `H`/`W`/`W1`/`N` amplifier rows, per {@link labeledAreaFeatures}.
+*/
+function createAreaOfOperations(positions, options = {}, textAmplifiers = {}) {
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "AO"));
+}
+const AREA_OF_OPERATIONS = defineControlMeasure({
+	metadata: AREA_OF_OPERATIONS_METADATA,
+	generator: createAreaOfOperations,
+	defaultOptions: DEFAULT_AREA_OF_OPERATIONS_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: { T: "GREEN" },
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
+//#region src/generators/cm12-command-control-areas/params.ts
+const SMOOTH_AREA_PARAMS = AREA_SMOOTH_PARAMS;
+const AREA_DESIGNATION_ONLY_AMPLIFIER = {
+	key: "T",
+	label: "Unique designation",
+	description: "Field T — the area's unique designation.",
+	maxLength: 21
+};
+//#endregion
+//#region src/generators/cm12-command-control-areas/named-area-of-interest.ts
+/**
+* Default options for the Named area of interest control measure. The
+* standard's example renders a straight-sided polygon, so `smooth` defaults
+* off (unlike the rounded L-15 templates) while staying available.
+*/
+const DEFAULT_NAMED_AREA_OF_INTEREST_OPTIONS = {
+	smooth: false,
+	smoothResolution: 16
+};
+const NAMED_AREA_OF_INTEREST_METADATA = {
+	id: "named-area-of-interest",
+	name: "Named area of interest",
+	description: "A geographical area where information is gathered to satisfy specific intelligence requirements.",
+	entity: "Command and Control Areas",
+	entityType: "Named Area of Interest",
+	value: "120200",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: ["Polygon", "Point"],
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: SMOOTH_AREA_PARAMS,
+	textAmplifiers: [AREA_DESIGNATION_ONLY_AMPLIFIER]
+};
+/**
+* Creates a Named area of interest control measure: a closed area through
+* `positions` labeled at its center with "NAI "-prefixed `T` (Field T) —
+* the sole label row, per {@link labeledAreaFeatures}.
+*/
+function createNamedAreaOfInterest(positions, options = {}, textAmplifiers = {}) {
+	return labeledAreaFeatures(positions, options, { name: composeAreaName("NAI", textAmplifiers.T) });
+}
+const NAMED_AREA_OF_INTEREST = defineControlMeasure({
+	metadata: NAMED_AREA_OF_INTEREST_METADATA,
+	generator: createNamedAreaOfInterest,
+	defaultOptions: DEFAULT_NAMED_AREA_OF_INTEREST_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: { T: "1" },
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
+//#region src/generators/cm12-command-control-areas/target-area-of-interest.ts
+/**
+* Default options for the Target area of interest control measure. The
+* standard's example renders a straight-sided polygon, so `smooth` defaults
+* off (unlike the rounded L-15 templates) while staying available.
+*/
+const DEFAULT_TARGET_AREA_OF_INTEREST_OPTIONS = {
+	smooth: false,
+	smoothResolution: 16
+};
+const TARGET_AREA_OF_INTEREST_METADATA = {
+	id: "target-area-of-interest",
+	name: "Target area of interest",
+	description: "The geographical area where high-value targets can be acquired and engaged by friendly forces.",
+	entity: "Command and Control Areas",
+	entityType: "Target Area of Interest",
+	value: "120300",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: ["Polygon", "Point"],
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: SMOOTH_AREA_PARAMS,
+	textAmplifiers: [AREA_DESIGNATION_ONLY_AMPLIFIER]
+};
+/**
+* Creates a Target area of interest control measure: a closed area through
+* `positions` labeled at its center with "TAI "-prefixed `T` (Field T) —
+* the sole label row, per {@link labeledAreaFeatures}.
+*/
+function createTargetAreaOfInterest(positions, options = {}, textAmplifiers = {}) {
+	return labeledAreaFeatures(positions, options, { name: composeAreaName("TAI", textAmplifiers.T) });
+}
+const TARGET_AREA_OF_INTEREST = defineControlMeasure({
+	metadata: TARGET_AREA_OF_INTEREST_METADATA,
+	generator: createTargetAreaOfInterest,
+	defaultOptions: DEFAULT_TARGET_AREA_OF_INTEREST_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: { T: "YUKON" },
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
+//#region src/generators/cm12-command-control-areas/airfield-zone.ts
+const DEFAULT_SMOOTH_RESOLUTION$8 = 16;
+/** Long runway line's tilt off the horizontal, in radians (+15°). */
+const LONG_LINE_ANGLE = 15 * Math.PI / 180;
+/** Short runway line's tilt off the horizontal, in radians (+50°). */
+const SHORT_LINE_ANGLE = 50 * Math.PI / 180;
+/** Short line's half-length as a ratio of the long line's half-length. */
+const SHORT_LINE_RATIO = .55;
+/** Field H's offset east of the area's max-x edge, as a ratio of the resolved label offset. */
+const H_LABEL_OFFSET_RATIO = .75;
+/**
+* Default options for the Airfield zone control measure. The standard's
+* example is a rounded blob, so `smooth` defaults on.
+*/
+const DEFAULT_AIRFIELD_ZONE_OPTIONS = {
+	smooth: true,
+	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$8,
+	glyphSizeRatio: .55
+};
+const AIRFIELD_ZONE_METADATA = {
+	id: "airfield-zone",
+	name: "Airfield zone",
+	description: "A zone enclosing an airfield, marked with a runway glyph; Field H carries the airfield type, runway length and other pertinent information.",
+	entity: "Command and Control Areas",
+	entityType: "Airfield Zone",
+	value: "120400",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: [
+		"Polygon",
+		"MultiLineString",
+		"Point"
+	],
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: [...SMOOTH_AREA_PARAMS, {
+		key: "glyphSizeRatio",
+		label: "Runway size",
+		description: "Size of the runway glyph as a ratio of the area's width.",
+		type: "number",
+		min: .2,
+		max: .9,
+		step: .05
+	}],
+	textAmplifiers: [{
+		key: "H",
+		label: "Additional information",
+		description: "Field H — airfield type, runway length and other information, placed outside the area's east edge.",
+		maxLength: 20
+	}]
+};
+/**
+* Creates an Airfield zone control measure: a closed area through
+* `positions` with a runway glyph (two crossed lines forming a shallow
+* asymmetric X) centered on the ring, and Field H placed outside the area to
+* the east when set.
+*
+* @param positions - Area anchor points (≥3); the input contract is enforced
+*   at the render seam (ADR-0014).
+* @param options - {@link AirfieldZoneOptions}.
+* @param textAmplifiers - Field H only.
+*/
+function createAirfieldZone(positions, options = {}, textAmplifiers = {}) {
+	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 features = [boundaryFeature(verts, [])];
+	let minX = Infinity;
+	let maxX = -Infinity;
+	for (const [x] of verts) {
+		if (x < minX) minX = x;
+		if (x > maxX) maxX = x;
+	}
+	const bboxWidth = maxX - minX;
+	const [cx, cy] = ringCentroid(verts);
+	if (bboxWidth >= 1e-6) {
+		const longHalf = .5 * glyphSizeRatio * bboxWidth;
+		const shortHalf = longHalf * SHORT_LINE_RATIO;
+		const center = [cx, cy];
+		const longDir = [Math.cos(LONG_LINE_ANGLE), Math.sin(LONG_LINE_ANGLE)];
+		const shortDir = [Math.cos(SHORT_LINE_ANGLE), Math.sin(SHORT_LINE_ANGLE)];
+		const along = (dir, half) => [[center[0] - dir[0] * half, center[1] - dir[1] * half], [center[0] + dir[0] * half, center[1] + dir[1] * half]];
+		const [longA, longB] = along(longDir, longHalf);
+		const [shortA, shortB] = along(shortDir, shortHalf);
+		features.push({
+			type: "Feature",
+			properties: {},
+			geometry: {
+				type: "MultiLineString",
+				coordinates: [[unproject(longA[0], longA[1]), unproject(longB[0], longB[1])], [unproject(shortA[0], shortA[1]), unproject(shortB[0], shortB[1])]]
+			}
+		});
+	}
+	if (textAmplifiers.H) {
+		const labelFeatures = [];
+		pushLabel(labelFeatures, [maxX + H_LABEL_OFFSET_RATIO * resolveLabelOffsetMeters(labelOptions, 1), cy], textAmplifiers.H, HORIZONTAL_LABEL_ROTATION, labelSizeProps(labelOptions), "start", "H");
+		features.push(...labelFeatures);
+	}
+	return {
+		type: "FeatureCollection",
+		features
+	};
+}
+const AIRFIELD_ZONE = defineControlMeasure({
+	metadata: AIRFIELD_ZONE_METADATA,
+	generator: createAirfieldZone,
+	defaultOptions: DEFAULT_AIRFIELD_ZONE_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: { H: "570M" },
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
+//#region src/generators/cm12-command-control-areas/echelon-labeled-area.ts
+const DEFAULT_SMOOTH_RESOLUTION$7 = 16;
+/** Default options shared by Base Camp and Guerrilla Base — echelon off, boundary rounded. */
+const DEFAULT_ECHELON_LABELED_AREA_OPTIONS = {
+	echelon: "none",
+	echelonSize: 750,
+	echelonSizePixels: 16,
+	echelonPadding: .3,
+	echelonPosition: 0,
+	smooth: true,
+	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$7
+};
+/**
+* Builds the shared Base Camp / Guerrilla Base geometry: a closed area
+* through `positions` carrying the full L-15 text amplifier template
+* ({@link pushAreaLabels}) plus an optional Field B echelon glyph straddling
+* the boundary ({@link placeEchelon}, mirroring Battle Position). The
+* echelon's masking gap and any Field N "ENY" masking gap are concatenated
+* 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) {
+	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);
+	const features = [boundaryFeature(verts, [...echelonGaps, ...enyGaps])];
+	if (strokes.length > 0) features.push({
+		type: "Feature",
+		properties: { part: "echelon" },
+		geometry: {
+			type: "MultiLineString",
+			coordinates: strokes
+		}
+	});
+	if (fills.length > 0) features.push({
+		type: "Feature",
+		properties: {
+			part: "echelon",
+			fill: true
+		},
+		geometry: {
+			type: "MultiPolygon",
+			coordinates: fills.map((ring) => [ring])
+		}
+	});
+	features.push(...labelFeatures);
+	return {
+		type: "FeatureCollection",
+		features
+	};
+}
+/**
+* `freezeOrientation` hook factory instance shared by Base Camp and
+* Guerrilla Base — see {@link makeFreezeEchelonAnchor} (ADR-0023) for the
+* mechanism; both measures default to `echelon: "none"`, so unlike Battle
+* Position's own instance (battlePosition.ts) freezing is a no-op until a
+* user explicitly picks an echelon.
+*/
+const freezeEchelonLabeledAreaAnchor = makeFreezeEchelonAnchor({
+	echelon: DEFAULT_ECHELON_LABELED_AREA_OPTIONS.echelon,
+	smooth: DEFAULT_ECHELON_LABELED_AREA_OPTIONS.smooth,
+	smoothResolution: DEFAULT_ECHELON_LABELED_AREA_OPTIONS.smoothResolution
+});
+//#endregion
+//#region src/generators/cm12-command-control-areas/base-camp.ts
+/** Default options for the Base camp control measure. */
+const DEFAULT_BASE_CAMP_OPTIONS = DEFAULT_ECHELON_LABELED_AREA_OPTIONS;
+const BASE_CAMP_METADATA = {
+	id: "base-camp",
+	name: "Base camp",
+	description: "An evolving military facility that supports military operations of a deployed unit and provides the necessary support and services for sustained operations.",
+	entity: "Command and Control Areas",
+	entityType: "Base Camp",
+	value: "120500",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: [
+		"Polygon",
+		"MultiLineString",
+		"MultiPolygon",
+		"Point"
+	],
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: ECHELON_AREA_PARAMS,
+	textAmplifiers: AREA_TEXT_AMPLIFIERS
 };
-const AREA_OF_OPERATIONS_METADATA = {
-	id: "area-of-operations",
-	name: "Area of operations",
-	description: "An operational area defined by a commander for land and naval forces, within which the assigned force conducts military operations.",
+/**
+* Creates a Base camp control measure: a closed area through `positions`
+* labeled at its center with "BC "-prefixed `T` (Field T) plus `H`/`W`/`W1`/`N`
+* amplifier rows, and an optional Field B echelon glyph straddling the
+* boundary, per {@link echelonLabeledAreaFeatures}.
+*/
+function createBaseCamp(positions, options = {}, textAmplifiers = {}) {
+	return echelonLabeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "BC"));
+}
+const BASE_CAMP = defineControlMeasure({
+	metadata: BASE_CAMP_METADATA,
+	generator: createBaseCamp,
+	defaultOptions: DEFAULT_BASE_CAMP_OPTIONS,
+	rule: area1DrawRule,
+	freezeOrientation: freezeEchelonLabeledAreaAnchor,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: { T: "LEATHERNECK" },
+		options: {
+			smooth: true,
+			labelSize: 96
+		}
+	}
+});
+//#endregion
+//#region src/generators/cm12-command-control-areas/guerrilla-base.ts
+/** Default options for the Guerrilla base control measure. */
+const DEFAULT_GUERRILLA_BASE_OPTIONS = DEFAULT_ECHELON_LABELED_AREA_OPTIONS;
+const GUERRILLA_BASE_METADATA = {
+	id: "guerrilla-base",
+	name: "Guerrilla base",
+	description: "A temporary site where guerrilla installations, headquarters, and units are located.",
 	entity: "Command and Control Areas",
-	entityType: "Area of Operations",
-	value: "120100",
+	entityType: "Guerrilla Base",
+	value: "120600",
 	minCoordinates: 3,
 	geometry: "area",
 	geometryTypes: [
 		"Polygon",
 		"MultiLineString",
+		"MultiPolygon",
 		"Point"
 	],
 	drawRule: "Area1",
 	capturesLabelSize: true,
-	params: LABELED_AREA_PARAMS,
+	params: ECHELON_AREA_PARAMS,
 	textAmplifiers: AREA_TEXT_AMPLIFIERS
 };
 /**
-* Creates an Area of operations control measure: a closed area through
-* `positions` labeled at its center with "AO "-prefixed `T` (Field T) plus
-* `H`/`W`/`W1`/`N` amplifier rows, per {@link labeledAreaFeatures}.
+* Creates a Guerrilla base control measure: a closed area through
+* `positions` labeled at its center with "GB "-prefixed `T` (Field T) plus
+* `H`/`W`/`W1`/`N` amplifier rows, and an optional Field B echelon glyph
+* straddling the boundary, per {@link echelonLabeledAreaFeatures}.
 */
-function createAreaOfOperations(positions, options = {}, textAmplifiers = {}) {
-	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "AO"));
+function createGuerrillaBase(positions, options = {}, textAmplifiers = {}) {
+	return echelonLabeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "GB"));
 }
-const AREA_OF_OPERATIONS = defineControlMeasure({
-	metadata: AREA_OF_OPERATIONS_METADATA,
-	generator: createAreaOfOperations,
-	defaultOptions: DEFAULT_AREA_OF_OPERATIONS_OPTIONS,
+const GUERRILLA_BASE = defineControlMeasure({
+	metadata: GUERRILLA_BASE_METADATA,
+	generator: createGuerrillaBase,
+	defaultOptions: DEFAULT_GUERRILLA_BASE_OPTIONS,
 	rule: area1DrawRule,
+	freezeOrientation: freezeEchelonLabeledAreaAnchor,
 	previewSample: {
 		controlPoints: [
 			[-1, -.5],
@@ -2535,14 +3122,67 @@ const AREA_OF_OPERATIONS = defineControlMeasure({
 			[1, .5],
 			[-1, .5]
 		],
-		textAmplifiers: { T: "GREEN" },
+		textAmplifiers: { T: "GUEVARA" },
 		options: {
-			labelSizePixels: 12,
-			labelSizeResolution: 8
+			smooth: true,
+			labelSize: 96
 		}
 	}
 });
 //#endregion
+//#region src/generators/cm12-command-control-areas/generic-c2-area.ts
+/**
+* Default options for the Generic command and control area control measure.
+* The standard's example is a rounded blob, so `smooth` defaults on.
+*/
+const DEFAULT_GENERIC_C2_AREA_OPTIONS = {
+	smooth: true,
+	smoothResolution: 16
+};
+const GENERIC_C2_AREA_METADATA = {
+	id: "generic-c2-area",
+	name: "Generic command and control area",
+	description: "A general-purpose command and control area carrying a designation, additional information and an effective date-time-group window.",
+	entity: "Command and Control Areas",
+	entityType: "Generic",
+	value: "120700",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: [
+		"Polygon",
+		"MultiLineString",
+		"Point"
+	],
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: LABELED_AREA_PARAMS,
+	textAmplifiers: AREA_TEXT_AMPLIFIERS
+};
+/**
+* Creates a Generic command and control area control measure: a closed area
+* through `positions` labeled at its center with the bare `T` (Field T) plus
+* `H`/`W`/`W1`/`N` amplifier rows — no prefix, per {@link labeledAreaFeatures}.
+*/
+function createGenericC2Area(positions, options = {}, textAmplifiers = {}) {
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers));
+}
+const GENERIC_C2_AREA = defineControlMeasure({
+	metadata: GENERIC_C2_AREA_METADATA,
+	generator: createGenericC2Area,
+	defaultOptions: DEFAULT_GENERIC_C2_AREA_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: { T: "RIOT FOODS" },
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
 //#region src/generators/cm15-maneuver-areas/assemblyArea.ts
 /** Default options for the Assembly area control measure. */
 const DEFAULT_ASSEMBLY_AREA_OPTIONS = {
@@ -2589,31 +3229,13 @@ const ASSEMBLY_AREA = defineControlMeasure({
 			[-1, .5]
 		],
 		textAmplifiers: { T: "BLUE" },
-		options: {
-			labelSizePixels: 12,
-			labelSizeResolution: 8
-		}
+		options: { labelSize: 96 }
 	}
 });
 //#endregion
 //#region src/generators/cm29-protection-lines/params.ts
 const FORTIFIED_PARAMS = [
-	{
-		key: "smooth",
-		label: "Smooth",
-		description: "Round the line's corners by curving the path through the control points.",
-		type: "boolean"
-	},
-	{
-		key: "smoothResolution",
-		label: "Smooth resolution",
-		description: "Number of samples per segment when smooth mode is enabled.",
-		type: "number",
-		min: 2,
-		max: 64,
-		step: 1,
-		visibleWhen: (opts) => Boolean(opts.smooth)
-	},
+	...SMOOTH_LINE_PARAMS,
 	{
 		key: "toothSizePixels",
 		label: "Tooth size",
@@ -2636,6 +3258,7 @@ const FORTIFIED_PARAMS = [
 	}
 ];
 const ANTITANK_DITCH_PARAMS = [
+	...SMOOTH_LINE_PARAMS,
 	{
 		key: "toothHeightPixels",
 		label: "Tooth height",
@@ -2685,7 +3308,9 @@ const DEFAULT_TOOTH_WIDTH_RATIO$1 = 1.15;
 const DEFAULT_ANTITANK_DITCH_OPTIONS = {
 	toothHeight: DEFAULT_TOOTH_HEIGHT,
 	toothHeightPixels: DEFAULT_TOOTH_HEIGHT_PIXELS,
-	toothWidthRatio: DEFAULT_TOOTH_WIDTH_RATIO$1
+	toothWidthRatio: DEFAULT_TOOTH_WIDTH_RATIO$1,
+	smooth: false,
+	smoothResolution: 16
 };
 const ANTITANK_DITCH_UNDER_CONSTRUCTION_METADATA = {
 	id: "antitank-ditch-under-construction",
@@ -2746,13 +3371,25 @@ function generateAntitankDitchTriangles(projectedPoints, toothHeight, toothWidth
 	}
 	return triangles;
 }
-function buildAntitankDitchTriangles(positions, options) {
+/**
+* Projects `positions` and, when `options.smooth` is set, curves the result
+* through the control points (centripetal Catmull-Rom) before the teeth are
+* traced — matching Fortified Line's base-path smoothing. Returns the input
+* unchanged (no project/unproject round trip) when smoothing is off.
+*/
+function smoothedDitchBasePath(positions, options) {
+	const projectedPoints = positions.map((position) => project(position[0], position[1]));
+	const smoothedPath = smoothLineVerts(projectedPoints, options, 16);
 	const toothHeight = calculateAntitankDitchHeight(options);
-	const toothWidthRatio = options.toothWidthRatio ?? DEFAULT_TOOTH_WIDTH_RATIO$1;
-	return generateAntitankDitchTriangles(positions.map((position) => project(position[0], position[1])), toothHeight, toothWidthRatio);
+	const toothWidthRatio = Math.max(EPSILON, options.toothWidthRatio ?? DEFAULT_TOOTH_WIDTH_RATIO$1);
+	return options.smooth && projectedPoints.length >= 3 ? evenlySpacePath(smoothedPath, toothWidthRatio * toothHeight) : smoothedPath;
+}
+function buildAntitankDitchTriangles(basePath, options) {
+	return generateAntitankDitchTriangles(basePath, calculateAntitankDitchHeight(options), options.toothWidthRatio ?? DEFAULT_TOOTH_WIDTH_RATIO$1);
 }
 function createAntitankDitchUnderConstruction(positions, options = {}) {
-	const triangles = buildAntitankDitchTriangles(positions, options);
+	const basePath = smoothedDitchBasePath(positions, options);
+	const triangles = buildAntitankDitchTriangles(basePath, options);
 	return {
 		type: "FeatureCollection",
 		features: [{
@@ -2760,7 +3397,7 @@ function createAntitankDitchUnderConstruction(positions, options = {}) {
 			properties: { part: "ditch" },
 			geometry: {
 				type: "MultiLineString",
-				coordinates: [positions.map((position) => [position[0], position[1]]), ...triangles.map((triangle) => triangle.map((point) => unproject(point[0], point[1])))]
+				coordinates: [options.smooth ? basePath.map((point) => unproject(point[0], point[1])) : positions.map((position) => [position[0], position[1]]), ...triangles.map((triangle) => triangle.map((point) => unproject(point[0], point[1])))]
 			}
 		}]
 	};
@@ -2776,7 +3413,7 @@ function createAntitankDitchCompleted(positions, options = {}) {
 			},
 			geometry: {
 				type: "MultiPolygon",
-				coordinates: buildAntitankDitchTriangles(positions, options).map((triangle) => {
+				coordinates: buildAntitankDitchTriangles(smoothedDitchBasePath(positions, options), options).map((triangle) => {
 					return [[...triangle, triangle[0]].map((point) => unproject(point[0], point[1]))];
 				})
 			}
@@ -2853,6 +3490,8 @@ function createAntitankWall(positions, options = {}) {
 	const toothHeight = calculateAntitankDitchHeight(options);
 	const toothWidthRatio = options.toothWidthRatio ?? DEFAULT_TOOTH_WIDTH_RATIO;
 	const toothSpacingRatio = options.toothSpacingRatio ?? DEFAULT_TOOTH_SPACING_RATIO;
+	const projectedPoints = positions.map((position) => project(position[0], position[1]));
+	const smoothedPath = smoothLineVerts(projectedPoints, options, 16);
 	return {
 		type: "FeatureCollection",
 		features: [{
@@ -2860,7 +3499,7 @@ function createAntitankWall(positions, options = {}) {
 			properties: { part: "wall" },
 			geometry: {
 				type: "MultiLineString",
-				coordinates: [generateAntitankWallPoints(positions.map((position) => project(position[0], position[1])), toothHeight, toothWidthRatio, toothSpacingRatio).map((point) => unproject(point[0], point[1]))]
+				coordinates: [generateAntitankWallPoints(options.smooth && projectedPoints.length >= 3 ? evenlySpacePath(smoothedPath, Math.max(EPSILON, toothWidthRatio) * toothHeight) : smoothedPath, toothHeight, toothWidthRatio, toothSpacingRatio).map((point) => unproject(point[0], point[1]))]
 			}
 		}]
 	};
@@ -3255,70 +3894,7 @@ const BATTLE_POSITION_METADATA = {
 	],
 	drawRule: "Area1",
 	capturesLabelSize: true,
-	params: [
-		{
-			key: "smooth",
-			label: "Smooth",
-			description: "Round the area's corners by curving the boundary through the control points.",
-			type: "boolean"
-		},
-		{
-			key: "smoothResolution",
-			label: "Smooth resolution",
-			description: "Number of samples per segment when smooth mode is enabled.",
-			type: "number",
-			min: 2,
-			max: 64,
-			step: 1,
-			visibleWhen: (opts) => Boolean(opts.smooth)
-		},
-		{
-			key: "echelon",
-			label: "Echelon",
-			description: "Field B unit-size amplifier, drawn on the boundary.",
-			type: "enum",
-			options: ECHELON_PARAM_OPTIONS
-		},
-		{
-			key: "echelonSizePixels",
-			label: "Echelon size",
-			description: "Echelon glyph height in screen pixels.",
-			type: "number",
-			min: 8,
-			max: 48,
-			step: 1,
-			unit: "px"
-		},
-		{
-			key: "echelonSize",
-			label: "Echelon size",
-			description: "Echelon glyph height in meters.",
-			type: "number",
-			min: 50,
-			max: 2e4,
-			step: 50,
-			unit: "m"
-		},
-		{
-			key: "echelonPadding",
-			label: "Echelon padding",
-			description: "Gap on each side of the echelon, as a ratio of its height.",
-			type: "number",
-			min: 0,
-			max: 2,
-			step: .05
-		},
-		{
-			key: "echelonPosition",
-			label: "Echelon position",
-			description: "Slide the echelon along the boundary, as a fraction of the perimeter from the bottom edge.",
-			type: "number",
-			min: -.5,
-			max: .5,
-			step: .01
-		},
-		AREA_LABEL_PADDING_PARAM
-	],
+	params: ECHELON_AREA_PARAMS,
 	textAmplifiers: [AREA_DESIGNATION_AMPLIFIER]
 };
 /**
@@ -3380,18 +3956,17 @@ function createBattlePosition(positions, options = {}, textAmplifiers = {}) {
 * 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. Returns `undefined` — nothing to freeze — when:
-*  - `echelonAnchor` is already set (previously frozen or user-authored), or
-*  - the echelon resolves to none (nothing visible to pin), or
-*  - the ring is degenerate (no segments, or a near-zero perimeter).
-*/
-function freezeEchelonAnchor(controlPoints, options) {
-	if (options.echelonAnchor !== void 0) return void 0;
-	if (!resolveEchelon(options.echelon ?? DEFAULT_BATTLE_POSITION_OPTIONS.echelon)) return void 0;
-	const perimeter = buildAreaPerimeter(buildClosedRing(controlPoints, options.smooth ?? DEFAULT_BATTLE_POSITION_OPTIONS.smooth, options.smoothResolution ?? DEFAULT_BATTLE_POSITION_OPTIONS.smoothResolution, DEFAULT_SMOOTH_RESOLUTION$6));
-	if (perimeter.segs.length === 0 || perimeter.totalLength < 1e-6) return void 0;
-	return { echelonAnchor: perimeter.anchorTarget / perimeter.totalLength };
-}
+* 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,
@@ -3409,8 +3984,7 @@ const BATTLE_POSITION = defineControlMeasure({
 		options: {
 			echelonSize: 200,
 			smooth: true,
-			labelSizePixels: 12,
-			labelSizeResolution: 8
+			labelSize: 96
 		}
 	}
 });
@@ -3762,7 +4336,6 @@ const BOUNDARY_METADATA = {
 		"Point"
 	],
 	drawRule: "Line1",
-	capturesLabelSize: true,
 	params: [
 		{
 			key: "smooth",
@@ -3896,7 +4469,7 @@ const BOUNDARY_METADATA = {
 *   unit 1 (left-of-travel side), `T1`/`AS1` label unit 2 (right-of-travel side).
 */
 function createBoundary(positions, options = {}, textAmplifiers = {}) {
-	const { echelon = DEFAULT_BOUNDARY_OPTIONS.echelon, echelonSize = DEFAULT_BOUNDARY_OPTIONS.echelonSize, echelonSizePixels, echelonPadding = DEFAULT_BOUNDARY_OPTIONS.echelonPadding, metersPerPixel, labelSizeZoom, labelSizeResolution, labelRepetitions = DEFAULT_BOUNDARY_OPTIONS.labelRepetitions, labelSpacing = DEFAULT_BOUNDARY_OPTIONS.labelSpacing, labelPadding = DEFAULT_BOUNDARY_OPTIONS.labelPadding, labelOrientation = DEFAULT_BOUNDARY_OPTIONS.labelOrientation, smooth = DEFAULT_BOUNDARY_OPTIONS.smooth, smoothResolution = DEFAULT_BOUNDARY_OPTIONS.smoothResolution } = options;
+	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, 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 ?? "";
 	const unit2Designator = textAmplifiers.T1 ?? "";
@@ -3906,14 +4479,7 @@ function createBoundary(positions, options = {}, textAmplifiers = {}) {
 	h = Math.max(EPSILON, h);
 	const reps = Math.max(1, Math.round(labelRepetitions));
 	const spec = resolveEchelon(echelon);
-	const screenAnchored = echelonSizePixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0;
-	const refResolution = screenAnchored ? metersPerPixel : labelSizeResolution;
-	const labelSize = {};
-	if (refResolution !== void 0 && refResolution > 0) labelSize.textSizePixels = Math.round(h / refResolution);
-	if (!screenAnchored) {
-		if (labelSizeResolution !== void 0) labelSize.textSizeResolution = labelSizeResolution;
-		if (labelSizeZoom !== void 0) labelSize.textSizeZoom = labelSizeZoom;
-	}
+	const labelSize = echelonSizePixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0 ? { textSizePixels: echelonSizePixels } : { textSizeMeters: h };
 	const rawVerts = positions.map((p) => project(p[0], p[1]));
 	const verts = smooth ? catmullRom(rawVerts, normalizeSmoothResolution$2(smoothResolution, DEFAULT_SMOOTH_RESOLUTION$4)) : rawVerts;
 	const glyphStrokes = [];
@@ -4018,13 +4584,24 @@ const BOUNDARY = defineControlMeasure({
 	rule: line1DrawRule,
 	previewSample: {
 		controlPoints: [[-2.5, 0], [2.5, 0]],
-		options: { echelonSize: 375 }
+		options: {
+			echelonSize: 375,
+			labelPadding: .5
+		},
+		textAmplifiers: {
+			T: "2INF",
+			T1: "3INF"
+		}
 	}
 });
 //#endregion
 //#region src/generators/cm11-command-control-lines/light-line.ts
 /** Default options for the Light line control measure. */
-const DEFAULT_LIGHT_LINE_OPTIONS = { includePrefix: true };
+const DEFAULT_LIGHT_LINE_OPTIONS = {
+	includePrefix: true,
+	smooth: false,
+	smoothResolution: 12
+};
 const LIGHT_LINE_METADATA = {
 	id: "light-line",
 	name: "Light line",
@@ -4038,13 +4615,15 @@ const LIGHT_LINE_METADATA = {
 	drawRule: "Line1",
 	capturesLabelSize: true,
 	params: [
+		...SMOOTH_LINE_PARAMS,
 		{
 			key: "phaseLineName",
 			label: "Phase line name",
 			description: "Name the line as a phase line — rendered \"PL <name>\" beyond each end of the line.",
 			type: "text",
 			placeholder: "DAVID",
-			maxLength: 21
+			maxLength: 21,
+			field: "T"
 		},
 		{
 			key: "includePrefix",
@@ -4082,16 +4661,17 @@ const LIGHT_LINE = defineControlMeasure({
 	rule: line1DrawRule,
 	previewSample: {
 		controlPoints: [[-1, 0], [1, 0]],
-		options: {
-			labelSizePixels: 12,
-			labelSizeResolution: 8
-		}
+		options: { labelSize: 96 }
 	}
 });
 //#endregion
 //#region src/generators/cm11-command-control-lines/engineer-work-line.ts
 /** Default options for the Engineer work line control measure. */
-const DEFAULT_ENGINEER_WORK_LINE_OPTIONS = { includePrefix: true };
+const DEFAULT_ENGINEER_WORK_LINE_OPTIONS = {
+	includePrefix: true,
+	smooth: false,
+	smoothResolution: 12
+};
 const ENGINEER_WORK_LINE_METADATA = {
 	id: "engineer-work-line",
 	name: "Engineer work line",
@@ -4105,13 +4685,15 @@ const ENGINEER_WORK_LINE_METADATA = {
 	drawRule: "Line1",
 	capturesLabelSize: true,
 	params: [
+		...SMOOTH_LINE_PARAMS,
 		{
 			key: "phaseLineName",
 			label: "Phase line name",
 			description: "Name the line as a phase line — rendered \"PL <name>\" beyond each end of the line.",
 			type: "text",
 			placeholder: "DAVID",
-			maxLength: 21
+			maxLength: 21,
+			field: "T"
 		},
 		{
 			key: "includePrefix",
@@ -4173,17 +4755,19 @@ function createEngineerWorkLine(positions, options = {}, textAmplifiers = {}) {
 		placement: "above",
 		...options
 	}, "EWL").features];
-	const { segments, totalLength } = polylineSegments(positions.map((p) => project(p[0], p[1])));
+	const { segments, totalLength } = polylineSegments(smoothLineVerts(positions.map((p) => project(p[0], p[1])), options, 12));
 	const frame = pointAlongPolyline(segments, totalLength, .5);
 	if (frame) {
 		const units = [{
 			side: 1,
 			designator: textAmplifiers.T ?? "",
-			country: textAmplifiers.AS ?? ""
+			country: textAmplifiers.AS ?? "",
+			amplifierField: "T"
 		}, {
 			side: -1,
 			designator: textAmplifiers.T1 ?? "",
-			country: textAmplifiers.AS1 ?? ""
+			country: textAmplifiers.AS1 ?? "",
+			amplifierField: "T1"
 		}];
 		const labelFeatures = [];
 		pushUnitLabels(labelFeatures, {
@@ -4208,21 +4792,20 @@ const ENGINEER_WORK_LINE = defineControlMeasure({
 	previewSample: {
 		controlPoints: [[-2.5, 0], [2.5, 0]],
 		textAmplifiers: {
-			T: "326EN BN",
-			AS: "USA",
-			T1: "127EN BN",
-			AS1: "USA"
+			T: "2BN",
+			T1: "3BN"
 		},
-		options: {
-			labelSizePixels: 12,
-			labelSizeResolution: 20
-		}
+		options: { labelSize: 240 }
 	}
 });
 //#endregion
 //#region src/generators/cm11-command-control-lines/generic-c2-line.ts
 /** Default options for the Generic command and control line. */
-const DEFAULT_GENERIC_C2_LINE_OPTIONS = { includePrefix: true };
+const DEFAULT_GENERIC_C2_LINE_OPTIONS = {
+	includePrefix: true,
+	smooth: false,
+	smoothResolution: 12
+};
 const GENERIC_C2_LINE_METADATA = {
 	id: "generic-c2-line",
 	name: "Generic command and control line",
@@ -4236,13 +4819,15 @@ const GENERIC_C2_LINE_METADATA = {
 	drawRule: "Line1",
 	capturesLabelSize: true,
 	params: [
+		...SMOOTH_LINE_PARAMS,
 		{
 			key: "phaseLineName",
 			label: "Phase line name",
 			description: "Name the line as a phase line — rendered \"PL <name>\" beyond each end of the line.",
 			type: "text",
 			placeholder: "DAVID",
-			maxLength: 21
+			maxLength: 21,
+			field: "T"
 		},
 		{
 			key: "includePrefix",
@@ -4298,20 +4883,23 @@ const GENERIC_C2_LINE_METADATA = {
 * `base + perp·offset` and the other at `base − perp·offset`.
 */
 function createGenericC2Line(positions, options = {}, textAmplifiers = {}) {
-	const { phaseLineName, includePrefix = true, ...sizeOptions } = options;
+	const { phaseLineName, includePrefix = true, smooth, smoothResolution, ...sizeOptions } = options;
+	const verts = smoothLineVerts(positions.map((p) => project(p[0], p[1])), {
+		smooth,
+		smoothResolution
+	}, 12);
 	const features = [{
 		type: "Feature",
 		properties: { part: "generic-c2-line" },
 		geometry: {
 			type: "LineString",
-			coordinates: positions
+			coordinates: smooth ? verts.map((v) => unproject(v[0], v[1])) : positions
 		}
 	}];
 	const above = [textAmplifiers.H, textAmplifiers.T].filter((v) => Boolean(v)).join(" ");
 	const below = [textAmplifiers.W, textAmplifiers.W1].filter((v) => Boolean(v)).join(" - ");
 	const trimmedPhaseLineName = phaseLineName?.trim();
 	if (above.length > 0 || below.length > 0 || trimmedPhaseLineName) {
-		const verts = positions.map((p) => project(p[0], p[1]));
 		const labelFeatures = [];
 		if (above.length > 0 || below.length > 0) {
 			const frames = aboveEndFrames(verts, sizeOptions);
@@ -4340,15 +4928,12 @@ const GENERIC_C2_LINE = defineControlMeasure({
 	previewSample: {
 		controlPoints: [[-2.5, 0], [2.5, 0]],
 		textAmplifiers: {
-			H: "IDR",
-			T: "METH",
-			W: "221735ZAUG2018",
-			W1: "312359ZDEC2099"
+			H: "<H>",
+			T: "<T>",
+			W: "<W>",
+			W1: "<W1>"
 		},
-		options: {
-			labelSizePixels: 12,
-			labelSizeResolution: 20
-		}
+		options: { labelSize: 240 }
 	}
 });
 //#endregion
@@ -4371,21 +4956,21 @@ function createArrowHead$1(tip, dir, length, width) {
 	];
 }
 /**
-* Builds the glyph label as a Point feature, forwarding any captured label-size
-* metadata to adapters for styling. `point` is in projected meters; the rotation
-* must already be in the generator's feature-rotation convention. Shared by every
-* mission-task measure that centers a glyph on its symbol.
+* Builds the glyph label as a Point feature, forwarding the resolved size
+* anchor (`textSizeMeters`/`textSizePixels`, ADR-0028) to adapters for
+* styling. `point` is in projected meters; the rotation must already be in
+* the generator's feature-rotation convention. Shared by every mission-task
+* measure that centers a glyph on its symbol.
 */
 function createLabelFeature(point, text, rotation, labelSize = {}) {
 	return {
 		type: "Feature",
 		properties: {
 			part: "label",
+			labelPlacement: false,
 			text,
 			rotation,
-			...labelSize.pixels !== void 0 ? { textSizePixels: labelSize.pixels } : {},
-			...labelSize.zoom !== void 0 ? { textSizeZoom: labelSize.zoom } : {},
-			...labelSize.resolution !== void 0 ? { textSizeResolution: labelSize.resolution } : {}
+			...labelSizeProps(labelSize)
 		},
 		geometry: {
 			type: "Point",
@@ -4550,9 +5135,8 @@ function createBlockMissionTaskSymbol(coordinates, options = {}) {
 				]
 			}
 		}, createLabelFeature(labelPoint, "B", labelRotation, {
-			pixels: options.labelSizePixels,
-			zoom: options.labelSizeZoom,
-			resolution: options.labelSizeResolution
+			labelSize: options.labelSize,
+			labelSizePixels: options.labelSizePixels
 		})]
 	};
 }
@@ -4635,9 +5219,8 @@ function createBreachSymbol(coordinates, options = {}) {
 		labelText: "B",
 		labelGapRatio: options.labelGapRatio ?? DEFAULT_BREACH_OPTIONS.labelGapRatio,
 		labelSize: {
-			pixels: options.labelSizePixels,
-			zoom: options.labelSizeZoom,
-			resolution: options.labelSizeResolution
+			labelSize: options.labelSize,
+			labelSizePixels: options.labelSizePixels
 		},
 		buildEndCaps: ({ p1, p2, dirFront, perpDir, frontLength }) => {
 			const halfTick = frontLength * tickLengthRatio / 2;
@@ -4719,9 +5302,8 @@ function createBypassSymbol(coordinates, options = {}) {
 		labelText: "B",
 		labelGapRatio: options.labelGapRatio ?? DEFAULT_BYPASS_OPTIONS.labelGapRatio,
 		labelSize: {
-			pixels: options.labelSizePixels,
-			zoom: options.labelSizeZoom,
-			resolution: options.labelSizeResolution
+			labelSize: options.labelSize,
+			labelSizePixels: options.labelSizePixels
 		},
 		buildEndCaps: ({ p1, p2, frontLength, rearTop }) => {
 			const arrowheadLength = frontLength * arrowheadLengthRatio;
@@ -4808,9 +5390,8 @@ function createCanalizeSymbol(coordinates, options = {}) {
 		labelText: "C",
 		labelGapRatio: options.labelGapRatio ?? DEFAULT_CANALIZE_OPTIONS.labelGapRatio,
 		labelSize: {
-			pixels: options.labelSizePixels,
-			zoom: options.labelSizeZoom,
-			resolution: options.labelSizeResolution
+			labelSize: options.labelSize,
+			labelSizePixels: options.labelSizePixels
 		},
 		buildEndCaps: ({ p1, p2, dirFront, perpDir, frontLength }) => {
 			const halfTick = frontLength * tickLengthRatio / 2;
@@ -5539,9 +6120,8 @@ function createClearSymbol(coordinates, options = {}) {
 	return {
 		type: "FeatureCollection",
 		features: [mainFeature, createLabelFeature(shaftLength > 1e-6 ? vecAdd(labelTip, vecScale(perpToRear, shaftLength * .5)) : labelTip, "C", labelRotation, {
-			pixels: options.labelSizePixels,
-			zoom: options.labelSizeZoom,
-			resolution: options.labelSizeResolution
+			labelSize: options.labelSize,
+			labelSizePixels: options.labelSizePixels
 		})]
 	};
 }
@@ -5649,9 +6229,8 @@ function createDelaySymbol(coordinates, options = {}) {
 	return {
 		type: "FeatureCollection",
 		features: [lineFeature, createLabelFeature(labelPoint, "D", normalizeRadians(Math.PI + lineRotation), {
-			pixels: options.labelSizePixels,
-			zoom: options.labelSizeZoom,
-			resolution: options.labelSizeResolution
+			labelSize: options.labelSize,
+			labelSizePixels: options.labelSizePixels
 		})]
 	};
 }
@@ -5883,6 +6462,56 @@ const DISRUPT = defineControlMeasure({
 	previewSample: { controlPoints: [[0, .4], [0, -.4]] }
 });
 //#endregion
+//#region src/generators/cm15-maneuver-areas/dropZone.ts
+/** Default options for the Drop zone control measure. */
+const DEFAULT_DROP_ZONE_OPTIONS = {
+	smooth: false,
+	smoothResolution: 16
+};
+const DROP_ZONE_METADATA = {
+	id: "drop-zone",
+	name: "Drop zone",
+	description: "A specified area upon which airborne troops, equipment, or supplies are airdropped.",
+	entity: "Maneuver Areas",
+	entityType: "Drop Zone",
+	value: "150600",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: [
+		"Polygon",
+		"MultiLineString",
+		"Point"
+	],
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: LABELED_AREA_PARAMS,
+	textAmplifiers: AREA_TEXT_AMPLIFIERS_DESIGNATION_HOSTILE
+};
+/**
+* Creates a Drop zone control measure: a closed area through `positions`
+* labeled at its center with "DZ "-prefixed `T` (Field T) plus an `N`
+* (Field N) ENY marker, per {@link labeledAreaFeatures}.
+*/
+function createDropZone(positions, options = {}, textAmplifiers = {}) {
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "DZ"));
+}
+const DROP_ZONE = defineControlMeasure({
+	metadata: DROP_ZONE_METADATA,
+	generator: createDropZone,
+	defaultOptions: DEFAULT_DROP_ZONE_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: { T: "HAWK" },
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
 //#region src/generators/cm15-maneuver-areas/encirclement.ts
 const DEFAULT_BARB_SPACING_RATIO = .4;
 const DEFAULT_BARB_LENGTH_RATIO = .16;
@@ -6030,17 +6659,66 @@ const ENCIRCLEMENT = defineControlMeasure({
 			[-.4, .85],
 			[-1, .5]
 		],
-		textAmplifiers: { N: "ENY" },
+		textAmplifiers: {},
 		options: {
 			barbSpacingRatio: .4,
 			barbLengthRatio: .18,
 			smooth: true,
-			labelSizePixels: 12,
-			labelSizeResolution: 8
+			labelSize: 96
 		}
 	}
 });
 //#endregion
+//#region src/generators/cm15-maneuver-areas/extractionZone.ts
+/** Default options for the Extraction zone control measure. */
+const DEFAULT_EXTRACTION_ZONE_OPTIONS = {
+	smooth: false,
+	smoothResolution: 16
+};
+const EXTRACTION_ZONE_METADATA = {
+	id: "extraction-zone",
+	name: "Extraction zone",
+	description: "A specified drop zone used for the delivery of supplies and/or equipment by means of an extraction technique from an aircraft flying very close to the ground.",
+	entity: "Maneuver Areas",
+	entityType: "Extraction Zone",
+	value: "150700",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: [
+		"Polygon",
+		"MultiLineString",
+		"Point"
+	],
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: LABELED_AREA_PARAMS,
+	textAmplifiers: AREA_TEXT_AMPLIFIERS_DESIGNATION_HOSTILE
+};
+/**
+* Creates an Extraction zone control measure: a closed area through
+* `positions` labeled at its center with "EZ "-prefixed `T` (Field T) plus
+* an `N` (Field N) ENY marker, per {@link labeledAreaFeatures}.
+*/
+function createExtractionZone(positions, options = {}, textAmplifiers = {}) {
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "EZ"));
+}
+const EXTRACTION_ZONE = defineControlMeasure({
+	metadata: EXTRACTION_ZONE_METADATA,
+	generator: createExtractionZone,
+	defaultOptions: DEFAULT_EXTRACTION_ZONE_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: { T: "ROCK" },
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
 //#region src/internal/field-of-fire.ts
 /**
 * Builds the open (stroked) arrowhead at the outward tip of one arm. The two
@@ -6411,7 +7089,9 @@ const DEFAULT_ARC_SEGMENTS = 16;
 const DEFAULT_FLOT_OPTIONS = {
 	radius: DEFAULT_RADIUS,
 	radiusPixels: DEFAULT_RADIUS_PIXELS,
-	arcSegments: DEFAULT_ARC_SEGMENTS
+	arcSegments: DEFAULT_ARC_SEGMENTS,
+	smooth: false,
+	smoothResolution: 16
 };
 const FLOT_METADATA = {
 	id: "flot",
@@ -6425,6 +7105,7 @@ const FLOT_METADATA = {
 	geometryTypes: ["LineString"],
 	drawRule: "Line1",
 	params: [
+		...SMOOTH_LINE_PARAMS,
 		{
 			key: "radiusPixels",
 			label: "Radius",
@@ -6539,21 +7220,31 @@ function processSegment(p1, p2, radius, arcSegments, isFirstSegment) {
 * ```
 */
 function createFLOT(positions, options = {}) {
-	const { radius = DEFAULT_RADIUS, radiusPixels, metersPerPixel, arcSegments = DEFAULT_ARC_SEGMENTS } = options;
+	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;
 	const safeRadius = Math.max(EPSILON, effectiveRadius);
 	const safeArcSegments = Math.max(3, Math.round(arcSegments));
 	const projectedPoints = positions.map((p) => project(p[0], p[1]));
+	const smoothedPath = smoothLineVerts(projectedPoints, {
+		smooth,
+		smoothResolution
+	}, 16);
+	const basePath = smooth && projectedPoints.length >= 3 ? evenlySpacePath(smoothedPath, 2 * safeRadius) : smoothedPath;
 	const allPoints = [];
-	for (let i = 0; i < projectedPoints.length - 1; i++) {
-		const p1 = projectedPoints[i];
-		const p2 = projectedPoints[i + 1];
+	for (let i = 0; i < basePath.length - 1; i++) {
+		const p1 = basePath[i];
+		const p2 = basePath[i + 1];
 		const segmentPoints = processSegment(p1, p2, safeRadius, safeArcSegments, i === 0);
 		allPoints.push(...segmentPoints);
 	}
-	if (allPoints.length > 0 && projectedPoints.length > 1) {
-		const lastOriginal = projectedPoints[projectedPoints.length - 1];
+	if (allPoints.length > 0 && basePath.length > 1) {
+		const firstOriginal = basePath[0];
+		const firstGenerated = allPoints[0];
+		if (vecMag(vecSub(firstOriginal, firstGenerated)) > 1e-6) allPoints.unshift(firstOriginal);
+	}
+	if (allPoints.length > 0 && basePath.length > 1) {
+		const lastOriginal = basePath[basePath.length - 1];
 		const lastGenerated = allPoints[allPoints.length - 1];
 		if (vecMag(vecSub(lastOriginal, lastGenerated)) > 1e-6) allPoints.push(lastOriginal);
 	}
@@ -6579,7 +7270,11 @@ const FLOT = defineControlMeasure({
 //#endregion
 //#region src/generators/cm14-maneuver-lines/phase-line.ts
 /** Default options for the Phase line control measure. */
-const DEFAULT_PHASE_LINE_OPTIONS = { includePrefix: true };
+const DEFAULT_PHASE_LINE_OPTIONS = {
+	includePrefix: true,
+	smooth: false,
+	smoothResolution: 12
+};
 const PHASE_LINE_METADATA = {
 	id: "phase-line",
 	name: "Phase line",
@@ -6592,20 +7287,24 @@ const PHASE_LINE_METADATA = {
 	geometryTypes: ["LineString", "Point"],
 	drawRule: "Line1",
 	capturesLabelSize: true,
-	params: [{
-		key: "includePrefix",
-		label: "Show PL prefix",
-		description: "Prefix the end labels with \"PL\" (or show a bare \"PL\" with no designation).",
-		type: "boolean"
-	}, {
-		key: "labelPadding",
-		label: "Label padding",
-		description: "Extra clearance between the line and its labels, as a ratio of the label height",
-		type: "number",
-		min: 0,
-		max: 2,
-		step: .05
-	}],
+	params: [
+		...SMOOTH_LINE_PARAMS,
+		{
+			key: "includePrefix",
+			label: "Show PL prefix",
+			description: "Prefix the end labels with \"PL\" (or show a bare \"PL\" with no designation).",
+			type: "boolean"
+		},
+		{
+			key: "labelPadding",
+			label: "Label padding",
+			description: "Extra clearance between the line and its labels, as a ratio of the label height",
+			type: "number",
+			min: 0,
+			max: 2,
+			step: .05
+		}
+	],
 	textAmplifiers: [{
 		key: "T",
 		label: "Unique designation",
@@ -6635,16 +7334,17 @@ const PHASE_LINE = defineControlMeasure({
 	previewSample: {
 		controlPoints: [[-1, 0], [1, 0]],
 		textAmplifiers: { T: "ECHO" },
-		options: {
-			labelSizePixels: 12,
-			labelSizeResolution: 8
-		}
+		options: { labelSize: 96 }
 	}
 });
 //#endregion
 //#region src/generators/cm14-maneuver-lines/handover-line.ts
 /** Default options for the Handover line control measure. */
-const DEFAULT_HANDOVER_LINE_OPTIONS = { includePrefix: true };
+const DEFAULT_HANDOVER_LINE_OPTIONS = {
+	includePrefix: true,
+	smooth: false,
+	smoothResolution: 12
+};
 const HANDOVER_LINE_METADATA = {
 	id: "handover-line",
 	name: "Handover line",
@@ -6658,13 +7358,15 @@ const HANDOVER_LINE_METADATA = {
 	drawRule: "Line1",
 	capturesLabelSize: true,
 	params: [
+		...SMOOTH_LINE_PARAMS,
 		{
 			key: "phaseLineName",
 			label: "Phase line name",
 			description: "Name the line as a phase line — rendered \"PL <name>\" beyond each end of the line.",
 			type: "text",
 			placeholder: "DAVID",
-			maxLength: 21
+			maxLength: 21,
+			field: "T"
 		},
 		{
 			key: "includePrefix",
@@ -6702,16 +7404,17 @@ const HANDOVER_LINE = defineControlMeasure({
 	rule: line1DrawRule,
 	previewSample: {
 		controlPoints: [[-1, 0], [1, 0]],
-		options: {
-			labelSizePixels: 12,
-			labelSizeResolution: 8
-		}
+		options: { labelSize: 96 }
 	}
 });
 //#endregion
 //#region src/generators/cm14-maneuver-lines/battle-handover-line.ts
 /** Default options for the Battle handover line control measure. */
-const DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS = { includePrefix: true };
+const DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS = {
+	includePrefix: true,
+	smooth: false,
+	smoothResolution: 12
+};
 const BATTLE_HANDOVER_LINE_METADATA = {
 	id: "battle-handover-line",
 	name: "Battle handover line",
@@ -6725,13 +7428,15 @@ const BATTLE_HANDOVER_LINE_METADATA = {
 	drawRule: "Line1",
 	capturesLabelSize: true,
 	params: [
+		...SMOOTH_LINE_PARAMS,
 		{
 			key: "phaseLineName",
 			label: "Phase line name",
 			description: "Name the line as a phase line — rendered \"PL <name>\" beyond each end of the line.",
 			type: "text",
 			placeholder: "DAVID",
-			maxLength: 21
+			maxLength: 21,
+			field: "T"
 		},
 		{
 			key: "includePrefix",
@@ -6769,10 +7474,7 @@ const BATTLE_HANDOVER_LINE = defineControlMeasure({
 	rule: line1DrawRule,
 	previewSample: {
 		controlPoints: [[-1, 0], [1, 0]],
-		options: {
-			labelSizePixels: 12,
-			labelSizeResolution: 8
-		}
+		options: { labelSize: 96 }
 	}
 });
 //#endregion
@@ -6919,7 +7621,7 @@ function createFortifiedLine(positions, options = {}) {
 			properties: {},
 			geometry: {
 				type: "LineString",
-				coordinates: generateFortifiedPoints(smooth ? catmullRom(projectedPoints, normalizeSmoothResolution$2(smoothResolution, DEFAULT_SMOOTH_RESOLUTION$1)) : projectedPoints, safeSize).map((p) => unproject(p[0], p[1]))
+				coordinates: generateFortifiedPoints(smooth ? evenlySpacePath(catmullRom(projectedPoints, normalizeSmoothResolution$2(smoothResolution, DEFAULT_SMOOTH_RESOLUTION$1)), 2 * safeSize) : projectedPoints, safeSize).map((p) => unproject(p[0], p[1]))
 			}
 		}]
 	};
@@ -6971,7 +7673,7 @@ function createFortifiedArea(positions, options = {}, textAmplifiers = {}) {
 	const safeSize = calculateEffectiveSize(options);
 	const projected = positions.map((p) => project(p[0], p[1]));
 	const ringPts = projected.length > 1 && vecMag(vecSub(projected[0], projected[projected.length - 1])) < 1e-6 ? projected.slice(0, -1) : projected;
-	const boundaryInput = smooth ? closedCatmullRom(ringPts, normalizeSmoothResolution$2(smoothResolution, DEFAULT_FORTIFIED_AREA_OPTIONS.smoothResolution)) : [...ringPts, ringPts[0]];
+	const boundaryInput = smooth ? evenlySpacePath(closedCatmullRom(ringPts, normalizeSmoothResolution$2(smoothResolution, DEFAULT_FORTIFIED_AREA_OPTIONS.smoothResolution)), 2 * safeSize) : [...ringPts, ringPts[0]];
 	const boundaryPoints = generateFortifiedPoints(boundaryInput, safeSize);
 	if (boundaryPoints.length > 0) {
 		const firstPt = boundaryPoints[0];
@@ -7013,10 +7715,7 @@ const FORTIFIED_AREA = defineControlMeasure({
 			[-1, .5]
 		],
 		textAmplifiers: { T: "TANGO" },
-		options: {
-			labelSizePixels: 12,
-			labelSizeResolution: 8
-		}
+		options: { labelSize: 96 }
 	}
 });
 //#endregion
@@ -7199,14 +7898,10 @@ const JOINT_TACTICAL_ACTION_AREA = defineControlMeasure({
 		],
 		textAmplifiers: {
 			T: "02",
-			N: "ENY",
 			W: "051030Z",
 			W1: "051600Z"
 		},
-		options: {
-			labelSizePixels: 12,
-			labelSizeResolution: 8
-		}
+		options: { labelSize: 96 }
 	}
 });
 //#endregion
@@ -7256,10 +7951,7 @@ const LANDING_ZONE = defineControlMeasure({
 			[-1, .5]
 		],
 		textAmplifiers: { T: "SILVER" },
-		options: {
-			labelSizePixels: 12,
-			labelSizeResolution: 8
-		}
+		options: { labelSize: 96 }
 	}
 });
 //#endregion
@@ -7779,10 +8471,145 @@ const PICKUP_ZONE = defineControlMeasure({
 			[-1, .5]
 		],
 		textAmplifiers: { T: "WOLF" },
-		options: {
-			labelSizePixels: 12,
-			labelSizeResolution: 8
-		}
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
+//#region src/generators/cm15-maneuver-areas/assaultPosition.ts
+/** Default options for the Assault position control measure. */
+const DEFAULT_ASSAULT_POSITION_OPTIONS = {
+	smooth: false,
+	smoothResolution: 16
+};
+const ASSAULT_POSITION_METADATA = {
+	id: "assault-position",
+	name: "Assault position",
+	description: "That position between the line of departure and the objective in an attack from which forces assault the objective. Ideally, it is the last covered and concealed position before reaching the objective.",
+	entity: "Maneuver Areas",
+	entityType: "Assault Position",
+	value: "151500",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: ["Polygon", "Point"],
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: SMOOTH_AREA_PARAMS,
+	textAmplifiers: [AREA_DESIGNATION_ONLY_AMPLIFIER]
+};
+/**
+* Creates an Assault position control measure: a closed area through
+* `positions` labeled at its center with "ASLT "-prefixed `T` (Field T) —
+* the sole label row, per {@link labeledAreaFeatures}.
+*/
+function createAssaultPosition(positions, options = {}, textAmplifiers = {}) {
+	return labeledAreaFeatures(positions, options, { name: composeAreaName("ASLT", textAmplifiers.T) });
+}
+const ASSAULT_POSITION = defineControlMeasure({
+	metadata: ASSAULT_POSITION_METADATA,
+	generator: createAssaultPosition,
+	defaultOptions: DEFAULT_ASSAULT_POSITION_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: { T: "DANUBE" },
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
+//#region src/generators/cm15-maneuver-areas/attackPosition.ts
+/** Default options for the Attack position control measure. */
+const DEFAULT_ATTACK_POSITION_OPTIONS = {
+	smooth: false,
+	smoothResolution: 16
+};
+const ATTACK_POSITION_METADATA = {
+	id: "attack-position",
+	name: "Attack position",
+	description: "The last position occupied by the assault echelon before crossing the start line/line of departure.",
+	entity: "Maneuver Areas",
+	entityType: "Attack Position",
+	value: "151600",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: ["Polygon", "Point"],
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: SMOOTH_AREA_PARAMS,
+	textAmplifiers: [AREA_DESIGNATION_ONLY_AMPLIFIER]
+};
+/**
+* Creates an Attack position control measure: a closed area through
+* `positions` labeled at its center with "ATK "-prefixed `T` (Field T) —
+* the sole label row, per {@link labeledAreaFeatures}.
+*/
+function createAttackPosition(positions, options = {}, textAmplifiers = {}) {
+	return labeledAreaFeatures(positions, options, { name: composeAreaName("ATK", textAmplifiers.T) });
+}
+const ATTACK_POSITION = defineControlMeasure({
+	metadata: ATTACK_POSITION_METADATA,
+	generator: createAttackPosition,
+	defaultOptions: DEFAULT_ATTACK_POSITION_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: { T: "NILE" },
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
+//#region src/generators/cm15-maneuver-areas/objectiveArea.ts
+/** Default options for the Objective area control measure. */
+const DEFAULT_OBJECTIVE_AREA_OPTIONS = {
+	smooth: false,
+	smoothResolution: 16
+};
+const OBJECTIVE_AREA_METADATA = {
+	id: "objective-area",
+	name: "Objective area",
+	description: "A defined geographical area within which is located an objective to be captured or reached by the military forces. This area is defined by competent authority for purposes of command and control.",
+	entity: "Maneuver Areas",
+	entityType: "Objective Area",
+	value: "151700",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: ["Polygon", "Point"],
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: SMOOTH_AREA_PARAMS,
+	textAmplifiers: [AREA_DESIGNATION_ONLY_AMPLIFIER]
+};
+/**
+* Creates an Objective area control measure: a closed area through
+* `positions` labeled at its center with "OBJ "-prefixed `T` (Field T) —
+* the sole label row, per {@link labeledAreaFeatures}.
+*/
+function createObjectiveArea(positions, options = {}, textAmplifiers = {}) {
+	return labeledAreaFeatures(positions, options, { name: composeAreaName("OBJ", textAmplifiers.T) });
+}
+const OBJECTIVE_AREA = defineControlMeasure({
+	metadata: OBJECTIVE_AREA_METADATA,
+	generator: createObjectiveArea,
+	defaultOptions: DEFAULT_OBJECTIVE_AREA_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: { T: "FIVE" },
+		options: { labelSize: 96 }
 	}
 });
 //#endregion
@@ -8056,70 +8883,7 @@ const STRONG_POINT_METADATA = {
 	],
 	drawRule: "Area1",
 	capturesLabelSize: true,
-	params: [
-		{
-			key: "smooth",
-			label: "Smooth",
-			description: "Round the area's corners by curving the boundary through the control points.",
-			type: "boolean"
-		},
-		{
-			key: "smoothResolution",
-			label: "Smooth resolution",
-			description: "Number of samples per segment when smooth mode is enabled.",
-			type: "number",
-			min: 2,
-			max: 64,
-			step: 1,
-			visibleWhen: (opts) => Boolean(opts.smooth)
-		},
-		{
-			key: "echelon",
-			label: "Echelon",
-			description: "Field B unit-size amplifier, drawn on the boundary.",
-			type: "enum",
-			options: ECHELON_PARAM_OPTIONS
-		},
-		{
-			key: "echelonSizePixels",
-			label: "Echelon size",
-			description: "Echelon glyph height in screen pixels.",
-			type: "number",
-			min: 8,
-			max: 48,
-			step: 1,
-			unit: "px"
-		},
-		{
-			key: "echelonSize",
-			label: "Echelon size",
-			description: "Echelon glyph height in meters.",
-			type: "number",
-			min: 50,
-			max: 2e4,
-			step: 50,
-			unit: "m"
-		},
-		{
-			key: "echelonPadding",
-			label: "Echelon padding",
-			description: "Gap on each side of the echelon, as a ratio of its height.",
-			type: "number",
-			min: 0,
-			max: 2,
-			step: .05
-		},
-		{
-			key: "echelonPosition",
-			label: "Echelon position",
-			description: "Slide the echelon along the boundary, as a fraction of the perimeter from the bottom edge.",
-			type: "number",
-			min: -.5,
-			max: .5,
-			step: .01
-		},
-		AREA_LABEL_PADDING_PARAM
-	],
+	params: ECHELON_AREA_PARAMS,
 	textAmplifiers: [AREA_DESIGNATION_AMPLIFIER]
 };
 /**
@@ -8227,12 +8991,121 @@ const STRONG_POINT = defineControlMeasure({
 		options: {
 			echelonSize: 200,
 			smooth: true,
-			labelSizePixels: 12,
-			labelSizeResolution: 8
+			labelSize: 96
 		}
 	}
 });
 //#endregion
+//#region src/generators/cm15-maneuver-areas/submarineActionArea.ts
+/** Default options for the Submarine action area control measure. */
+const DEFAULT_SUBMARINE_ACTION_AREA_OPTIONS = {
+	smooth: false,
+	smoothResolution: 16
+};
+const SUBMARINE_ACTION_AREA_METADATA = {
+	id: "submarine-action-area",
+	name: "Submarine action area",
+	description: "An area, including the water space and airspace above it, reserved for submarine operations.",
+	entity: "Maneuver Areas",
+	entityType: "Action Area",
+	entitySubtype: "Submarine Action Area",
+	value: "150502",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: [
+		"Polygon",
+		"MultiLineString",
+		"Point"
+	],
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: LABELED_AREA_PARAMS,
+	textAmplifiers: AREA_TEXT_AMPLIFIERS_NO_ADDITIONAL_INFO
+};
+/**
+* Creates a Submarine action area control measure: a closed area through
+* `positions` labeled at its center with "SAA -"-prefixed `T` (Field T) plus
+* `W`/`W1`/`N` amplifier rows, per {@link labeledAreaFeatures}.
+*/
+function createSubmarineActionArea(positions, options = {}, textAmplifiers = {}) {
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "SAA -", ""));
+}
+const SUBMARINE_ACTION_AREA = defineControlMeasure({
+	metadata: SUBMARINE_ACTION_AREA_METADATA,
+	generator: createSubmarineActionArea,
+	defaultOptions: DEFAULT_SUBMARINE_ACTION_AREA_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: {
+			T: "02",
+			W: "051030Z",
+			W1: "051600Z"
+		},
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
+//#region src/generators/cm15-maneuver-areas/submarineGeneratedActionArea.ts
+/** Default options for the Submarine-generated action area control measure. */
+const DEFAULT_SUBMARINE_GENERATED_ACTION_AREA_OPTIONS = {
+	smooth: false,
+	smoothResolution: 16
+};
+const SUBMARINE_GENERATED_ACTION_AREA_METADATA = {
+	id: "submarine-generated-action-area",
+	name: "Submarine-generated action area",
+	description: "An action area generated around a submarine's reported position, reserved for its operations.",
+	entity: "Maneuver Areas",
+	entityType: "Action Area",
+	entitySubtype: "Submarine-Generated Action Area",
+	value: "150503",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: [
+		"Polygon",
+		"MultiLineString",
+		"Point"
+	],
+	drawRule: "Area1",
+	capturesLabelSize: true,
+	params: LABELED_AREA_PARAMS,
+	textAmplifiers: AREA_TEXT_AMPLIFIERS_NO_ADDITIONAL_INFO
+};
+/**
+* Creates a Submarine-generated action area control measure: a closed area
+* through `positions` labeled at its center with "SGSA -"-prefixed `T`
+* (Field T) plus `W`/`W1`/`N` amplifier rows, per {@link labeledAreaFeatures}.
+*/
+function createSubmarineGeneratedActionArea(positions, options = {}, textAmplifiers = {}) {
+	return labeledAreaFeatures(positions, options, composeAreaLabelTexts(textAmplifiers, "SGSA -", ""));
+}
+const SUBMARINE_GENERATED_ACTION_AREA = defineControlMeasure({
+	metadata: SUBMARINE_GENERATED_ACTION_AREA_METADATA,
+	generator: createSubmarineGeneratedActionArea,
+	defaultOptions: DEFAULT_SUBMARINE_GENERATED_ACTION_AREA_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		textAmplifiers: {
+			T: "02",
+			W: "051030Z",
+			W1: "051600Z"
+		},
+		options: { labelSize: 96 }
+	}
+});
+//#endregion
 //#region src/generators/cm15-maneuver-areas/supportByFire.ts
 const DEFAULT_SUPPORT_BY_FIRE_OPTIONS = {
 	arrowheadWidthRatio: .3,
@@ -8571,11 +9444,25 @@ const DEFINITIONS = {
 	"final-protective-fire-right": FINAL_PROTECTIVE_FIRE_RIGHT,
 	"search-area": SEARCH_AREA,
 	encirclement: ENCIRCLEMENT,
+	area: AREA,
 	"assembly-area": ASSEMBLY_AREA,
 	"joint-tactical-action-area": JOINT_TACTICAL_ACTION_AREA,
+	"submarine-action-area": SUBMARINE_ACTION_AREA,
+	"submarine-generated-action-area": SUBMARINE_GENERATED_ACTION_AREA,
+	"drop-zone": DROP_ZONE,
+	"extraction-zone": EXTRACTION_ZONE,
 	"landing-zone": LANDING_ZONE,
 	"pickup-zone": PICKUP_ZONE,
+	"assault-position": ASSAULT_POSITION,
+	"attack-position": ATTACK_POSITION,
+	"objective-area": OBJECTIVE_AREA,
 	"area-of-operations": AREA_OF_OPERATIONS,
+	"named-area-of-interest": NAMED_AREA_OF_INTEREST,
+	"target-area-of-interest": TARGET_AREA_OF_INTEREST,
+	"airfield-zone": AIRFIELD_ZONE,
+	"base-camp": BASE_CAMP,
+	"guerrilla-base": GUERRILLA_BASE,
+	"generic-c2-area": GENERIC_C2_AREA,
 	"main-attack": MAIN_ATTACK,
 	"supporting-attack": SUPPORTING_ATTACK,
 	"classic-arrow": CLASSIC_ARROW,
@@ -8854,7 +9741,16 @@ function normalizeTextAmplifiers(input) {
 * `properties.style` when non-empty.
 */
 function renderControlMeasure(cm, opts) {
-	const features = dispatchControlMeasure(cm, opts).features.map((feature, index) => normalizeFeature(cm.id, feature, index, cm.style, opts?.graphicsStyle));
+	const raw = dispatchControlMeasure(cm, opts);
+	const generatedLabelOrdinals = /* @__PURE__ */ new Map();
+	const features = raw.features.map((feature, index) => {
+		const sourceProps = feature.properties ?? {};
+		const part = typeof sourceProps.part === "string" && sourceProps.part.length > 0 ? sourceProps.part : "main";
+		const isGeneratedLabel = sourceProps.labelPlacement !== false && !(typeof sourceProps.amplifierField === "string" && canonicalTextAmplifierKey(sourceProps.amplifierField)) && !(typeof sourceProps.labelPlacementKey === "string" && sourceProps.labelPlacementKey.length > 0) && typeof sourceProps.text === "string" && feature.geometry.type === "Point";
+		const generatedLabelOrdinal = isGeneratedLabel ? generatedLabelOrdinals.get(part) ?? 0 : index;
+		if (isGeneratedLabel) generatedLabelOrdinals.set(part, generatedLabelOrdinal + 1);
+		return normalizeFeature(cm.id, feature, index, generatedLabelOrdinal, cm.style, opts?.graphicsStyle, cm.amplifierPlacements);
+	});
 	const bbox = computeBBox(features);
 	return {
 		type: "FeatureCollection",
@@ -8886,7 +9782,20 @@ function validateInputContract(points, metadata, mode) {
 	if (points.some((point) => !isValidPosition(point))) return reportValidationIssue(mode, `"${metadata.id}" control points must contain finite [lon, lat] values.`);
 	return true;
 }
-function normalizeFeature(id, feature, index, measureStyle, graphicsStyle) {
+/**
+* The `amplifierPlacements` key that repositions this feature, if any: the
+* canonical amplifier field when the generator declared one, an explicit
+* `labelPlacementKey`, or a synthesized `label:<part>:<ordinal>` key for any
+* other point label — unless the generator opted out via
+* `labelPlacement: false`.
+*/
+function resolveLabelPlacementKey(sourceProps, amplifierField, text, geometryType, part, generatedLabelOrdinal) {
+	if (sourceProps.labelPlacement === false) return void 0;
+	if (amplifierField) return amplifierField;
+	if (typeof sourceProps.labelPlacementKey === "string" && sourceProps.labelPlacementKey.length > 0) return sourceProps.labelPlacementKey;
+	if (text !== void 0 && geometryType === "Point") return `label:${part}:${generatedLabelOrdinal}`;
+}
+function normalizeFeature(id, feature, index, generatedLabelOrdinal, measureStyle, graphicsStyle, amplifierPlacements) {
 	const sourceProps = feature.properties ?? {};
 	const part = typeof sourceProps.part === "string" && sourceProps.part.length > 0 ? sourceProps.part : "main";
 	const generatorStyle = typeof sourceProps.style === "object" && sourceProps.style !== null ? sourceProps.style : void 0;
@@ -8895,9 +9804,15 @@ function normalizeFeature(id, feature, index, measureStyle, graphicsStyle) {
 	const text = typeof sourceProps.text === "string" ? sourceProps.text : void 0;
 	const rotation = typeof sourceProps.rotation === "number" ? sourceProps.rotation : void 0;
 	const textSizePixels = typeof sourceProps.textSizePixels === "number" ? sourceProps.textSizePixels : void 0;
-	const textSizeZoom = typeof sourceProps.textSizeZoom === "number" ? sourceProps.textSizeZoom : void 0;
-	const textSizeResolution = typeof sourceProps.textSizeResolution === "number" ? sourceProps.textSizeResolution : void 0;
+	const textSizeMeters = typeof sourceProps.textSizeMeters === "number" ? sourceProps.textSizeMeters : void 0;
 	const textAnchor = sourceProps.textAnchor === "start" || sourceProps.textAnchor === "end" ? sourceProps.textAnchor : void 0;
+	const amplifierField = typeof sourceProps.amplifierField === "string" ? canonicalTextAmplifierKey(sourceProps.amplifierField) : void 0;
+	const labelPlacementKey = resolveLabelPlacementKey(sourceProps, amplifierField, text, feature.geometry.type, part, generatedLabelOrdinal);
+	const placement = labelPlacementKey ? amplifierPlacements?.[labelPlacementKey] : void 0;
+	const geometry = placement && isValidPosition(placement) && feature.geometry.type === "Point" ? {
+		...feature.geometry,
+		coordinates: [...placement]
+	} : feature.geometry;
 	return {
 		type: "Feature",
 		id: `${id}:${part}:${index}`,
@@ -8908,11 +9823,12 @@ function normalizeFeature(id, feature, index, measureStyle, graphicsStyle) {
 			...text !== void 0 ? { text } : {},
 			...rotation !== void 0 ? { rotation } : {},
 			...textAnchor !== void 0 ? { textAnchor } : {},
+			...amplifierField !== void 0 ? { amplifierField } : {},
+			...labelPlacementKey !== void 0 ? { labelPlacementKey } : {},
 			...textSizePixels !== void 0 ? { textSizePixels } : {},
-			...textSizeZoom !== void 0 ? { textSizeZoom } : {},
-			...textSizeResolution !== void 0 ? { textSizeResolution } : {}
+			...textSizeMeters !== void 0 ? { textSizeMeters } : {}
 		},
-		geometry: feature.geometry
+		geometry
 	};
 }
 function computeBBox(features) {