@orbat-mapper/control-measures 0.27.0 → 0.29.0

package/dist/{renderControlMeasure-Cil8mQzg.mjs → renderControlMeasure-ZpYrUlKM.mjs}

@@ -144,40 +144,45 @@ const destinationPoint = (origin, distance, bearing) => {
 * Offsets a polyline to both sides at once, using Miter Joins or Round Joins.
 * `offsets` carries one half-width per vertex, so the outline may taper along
 * its centerline; both sides read the same array rather than materialising a
-* negated copy per geometry pass.
+* negated copy per geometry pass. Pass `rightOffsets` to give the right side
+* its own half-widths (an asymmetric outline).
+*
+* `leftStarts` / `rightStarts` give, per centerline vertex, the index of its
+* first point in that edge (rounded joins emit several), after any loop was
+* trimmed out: `edge.slice(0, starts[i])` is the edge before vertex `i`.
 */
-function offsetPolylineSides(points, offsets, rounded = false, segments = 5) {
+function offsetPolylineSides(points, offsets, rounded = false, segments = 5, rightOffsets = offsets) {
+	const left = offsetPolylineWithOffsets(points, offsets, rounded, segments, 1);
+	const right = offsetPolylineWithOffsets(points, rightOffsets, rounded, segments, -1);
 	return {
-		left: offsetPolylineWithOffsets(points, offsets, rounded, segments, 1),
-		right: offsetPolylineWithOffsets(points, offsets, rounded, segments, -1)
+		left: left.edge,
+		right: right.edge,
+		leftStarts: left.starts,
+		rightStarts: right.starts
 	};
 }
 /** One side of {@link offsetPolylineSides}; `sign` picks which. */
 function offsetPolylineWithOffsets(points, offsets, rounded, segments, sign) {
-	if (points.length < 2) return points;
-	if (offsets.length !== points.length) return points;
+	if (points.length < 2 || offsets.length !== points.length) return {
+		edge: points,
+		starts: points.map((_, i) => i)
+	};
 	const result = [];
 	const N = points.length;
+	const vertexStarts = new Array(N);
 	for (let i = 0; i < N; i++) {
+		vertexStarts[i] = result.length;
 		const p = points[i];
 		if (!p) continue;
 		const offset = offsets[i] * sign;
 		if (i === 0) {
 			const next = points[i + 1];
-			if (next) {
-				const dir = vecNorm(vecSub(next, p));
-				const normal = [-dir[1], dir[0]];
-				result.push(vecAdd(p, vecScale(normal, offset)));
-			}
+			if (next) result.push(vecAdd(p, vecScale(segmentNormal(p, next), offset)));
 			continue;
 		}
 		if (i === N - 1) {
 			const prev = points[i - 1];
-			if (prev) {
-				const dir = vecNorm(vecSub(p, prev));
-				const normal = [-dir[1], dir[0]];
-				result.push(vecAdd(p, vecScale(normal, offset)));
-			}
+			if (prev) result.push(vecAdd(p, vecScale(segmentNormal(prev, p), offset)));
 			continue;
 		}
 		const prev = points[i - 1];
@@ -185,10 +190,9 @@ function offsetPolylineWithOffsets(points, offsets, rounded, segments, sign) {
 		if (!prev || !next) continue;
 		const v1 = vecNorm(vecSub(p, prev));
 		const v2 = vecNorm(vecSub(next, p));
-		const n1 = [-v1[1], v1[0]];
-		const n2 = [-v2[1], v2[0]];
-		const cross = v1[0] * v2[1] - v1[1] * v2[0];
-		if (rounded && (offset > 0 && cross < -1e-6 || offset < 0 && cross > 1e-6)) {
+		if (rounded && isOuterJoin(v1, v2, offset)) {
+			const n1 = [-v1[1], v1[0]];
+			const n2 = [-v2[1], v2[0]];
 			const angle1 = Math.atan2(n1[1], n1[0]);
 			let diff = Math.atan2(n2[1], n2[0]) - angle1;
 			if (offset > 0) {
@@ -207,27 +211,154 @@ function offsetPolylineWithOffsets(points, offsets, rounded, segments, sign) {
 				result.push([p[0] + nx * offset, p[1] + ny * offset]);
 			}
 		} else {
-			const tangent = vecNorm(vecAdd(v1, v2));
-			const miter = [-tangent[1], tangent[0]];
-			const dot = vecDot(miter, n1);
-			const miterLimit = 3;
-			const scaleFactor = Math.abs(dot) < 1e-6 ? 1 : 1 / dot;
-			const normal = vecScale(miter, Math.min(scaleFactor, miterLimit));
+			const { miter, scale } = miterJoin(v1, v2);
+			const normal = vecScale(miter, scale);
 			result.push(vecAdd(p, vecScale(normal, offset)));
 		}
 	}
+	const folded = foldedSegments(points, result, vertexStarts);
+	if (folded.length === 0) return {
+		edge: result,
+		starts: vertexStarts
+	};
+	let maxOffset = 0;
+	for (const offset of offsets) maxOffset = Math.max(maxOffset, Math.abs(offset));
+	return {
+		edge: trimFolds(result, folded, vertexStarts, FOLD_REACH_OFFSETS * MITER_LIMIT * maxOffset),
+		starts: vertexStarts
+	};
+}
+/**
+* Edge segments that run against the centerline. The segment from vertex
+* `i - 1`'s last edge point to vertex `i`'s first offsets centerline segment
+* `i - 1 → i`; where the bend is tighter than the offset it points backwards
+* and the edge folds over itself.
+*/
+function foldedSegments(points, edge, vertexStarts) {
+	const folded = [];
+	for (let i = 1; i < points.length; i++) {
+		const k = vertexStarts[i] - 1;
+		const from = edge[k];
+		const to = edge[k + 1];
+		if (!from || !to) continue;
+		if (vecDot(vecSub(to, from), vecSub(points[i], points[i - 1])) < 0) folded.push(k);
+	}
+	return folded;
+}
+/**
+* Cuts the loop each fold makes: the edge runs back across itself, so the
+* nearest pair of segments around a folded run that cross are joined at their
+* crossing and everything between them dropped. The inner edge then comes to
+* a point in a tight bend instead of looping. Edges without folds, and
+* folds that never cross back, are returned unchanged; the two end points are
+* always kept. `starts` (edge indices, as in {@link offsetPolylineSides}) is
+* updated in place to follow the cuts; a start whose point was cut moves to
+* just past the crossing, which replaces it.
+*/
+function trimFolds(edge, folded, starts, reach) {
+	let result = edge;
+	let limit = edge.length - 1;
+	for (let r = folded.length - 1; r >= 0; r--) {
+		const last = folded[r];
+		let first = last;
+		while (r > 0 && folded[r - 1] === first - 1) first = folded[--r];
+		if (last >= limit) continue;
+		const cut = foldCrossing(result, first, last, limit, reach);
+		if (!cut) continue;
+		result = [
+			...result.slice(0, cut.from + 1),
+			cut.point,
+			...result.slice(cut.to + 1)
+		];
+		for (let i = 0; i < starts.length; i++) {
+			const start = starts[i];
+			if (start > cut.to) starts[i] = start - (cut.to - cut.from) + 1;
+			else if (start > cut.from) starts[i] = cut.from + 2;
+		}
+		limit = cut.from;
+	}
 	return result;
 }
-/** Linearly interpolates values by distance along a polyline, not vertex count. */
-function interpolatePolylineValues(points, startValue, endValue) {
-	const distances = [0];
+/** Edge length, in offsets, within which {@link foldCrossing} looks for a fold's loop. */
+const FOLD_REACH_OFFSETS = 4;
+/**
+* The crossing that closes the loop around folded segments `first … last`:
+* segment `from` at or before the run crossing segment `to` at or after it,
+* picking the tightest such pair. Only segments within `reach` of edge length
+* of the run are tried, which keeps the search local on densely sampled
+* curves.
+*/
+function foldCrossing(edge, first, last, limit, reach) {
+	let best = null;
+	let back = 0;
+	for (let from = first; from >= 0; from--) {
+		if (from < first - 1) back += vecMag(vecSub(edge[from + 2], edge[from + 1]));
+		if (back > reach) break;
+		let ahead = 0;
+		for (let to = Math.max(last, from + 2); to < limit; to++) {
+			if (to > last + 1) ahead += vecMag(vecSub(edge[to], edge[to - 1]));
+			if (ahead > reach) break;
+			if (best && to - from >= best.to - best.from) break;
+			const point = lineIntersection(edge[from], edge[from + 1], edge[to], edge[to + 1]);
+			if (point) best = {
+				from,
+				to,
+				point
+			};
+		}
+		if (best && last - from >= best.to - best.from) break;
+	}
+	return best;
+}
+const MITER_LIMIT = 3;
+/** Unit left normal of the segment `a → b`. */
+function segmentNormal(a, b) {
+	const dir = vecNorm(vecSub(b, a));
+	return [-dir[1], dir[0]];
+}
+/**
+* The unit bisector normal at a join of unit directions `v1` → `v2`, and the
+* miter-limited factor that scales it to one unit of perpendicular offset.
+*/
+function miterJoin(v1, v2) {
+	const tangent = vecNorm(vecAdd(v1, v2));
+	const miter = [-tangent[1], tangent[0]];
+	const dot = vecDot(miter, [-v1[1], v1[0]]);
+	const scaleFactor = Math.abs(dot) < 1e-6 ? 1 : 1 / dot;
+	return {
+		miter,
+		scale: Math.min(scaleFactor, MITER_LIMIT)
+	};
+}
+/** Whether an offset of sign `side` lies on the outside of the `v1` → `v2` turn. */
+function isOuterJoin(v1, v2, side) {
+	const cross = v1[0] * v2[1] - v1[1] * v2[0];
+	return side > 0 && cross < -1e-6 || side < 0 && cross > 1e-6;
+}
+/**
+* The offset vector that {@link offsetPolylineSides} applies per unit half-width
+* at vertex `index` on side `sign` (`1` left, `-1` right): the end-segment
+* normal at the ends, the capped miter at interior vertices, and the unit
+* bisector on the outer side of a rounded join (the midpoint of its arc). So
+* `vertex + direction * halfWidth` lies on the drawn edge.
+*/
+function offsetDirectionAt(points, index, sign, rounded) {
+	const p = points[index];
+	if (!p || points.length < 2) return null;
+	const prev = points[index - 1];
+	const next = points[index + 1];
+	if (!prev) return vecScale(segmentNormal(p, next), sign);
+	if (!next) return vecScale(segmentNormal(prev, p), sign);
+	const v1 = vecNorm(vecSub(p, prev));
+	const v2 = vecNorm(vecSub(next, p));
+	const { miter, scale } = miterJoin(v1, v2);
+	return vecScale(miter, rounded && isOuterJoin(v1, v2, sign) ? sign : scale * sign);
+}
+/** Cumulative arc length at each polyline vertex (`0` at the first). */
+function cumulativeDistances(points) {
+	const distances = points.length > 0 ? [0] : [];
 	for (let i = 1; i < points.length; i++) distances.push(distances[i - 1] + vecMag(vecSub(points[i], points[i - 1])));
-	const totalLength = distances.at(-1) ?? 0;
-	if (totalLength < 1e-6) return points.map(() => endValue);
-	return distances.map((distance) => {
-		const progress = distance / totalLength;
-		return startValue + (endValue - startValue) * progress;
-	});
+	return distances;
 }
 function vecAdd(a, b) {
 	return [a[0] + b[0], a[1] + b[1]];
@@ -992,6 +1123,24 @@ const bridgeOrGapDrawRule = {
 	}
 };
 //#endregion
+//#region src/draw-rules/line12.ts
+/**
+* Line12 anchor draw rule for Roadblocks, Craters and Blown Bridges.
+*
+* PT. 1 and PT. 2 are the endpoints of the symbol's centerline. PT. 3 is
+* constrained to the perpendicular axis through `midpoint(PT. 1, PT. 2)` and
+* locates one side of the symbol; its distance from the centerline is the
+* half-width. All three points are placed explicitly, with a two-point live
+* preview before commit.
+*/
+const line12DrawRule = createMidpointPerpendicularDrawRule({
+	id: "line12:roadblock",
+	defaultDistanceRatio: .1,
+	minimumUserPoints: 3,
+	minimumPreviewPoints: 2,
+	finishOnLastPointRepeat: true
+});
+//#endregion
 //#region src/draw-rules/line23.ts
 /**
 * Line23 anchor draw rule for the Clear mission task.
@@ -1335,11 +1484,464 @@ const supportByFireDrawRule = {
 	}
 };
 //#endregion
+//#region src/internal/sketch.ts
+/**
+* Projects `coordinates` and derives the arrow's tip, heading and total length.
+* Returns `null` for degenerate input (fewer than two points, a zero-length
+* path, or a zero-length final segment) so the caller can decide what to emit.
+*/
+function arrowAxis(coordinates) {
+	if (coordinates.length < 2) return null;
+	const pts = coordinates.map((c) => project(c[0], c[1]));
+	let pathLength = 0;
+	for (let i = 0; i < pts.length - 1; i++) pathLength += Math.hypot(pts[i + 1][0] - pts[i][0], pts[i + 1][1] - pts[i][1]);
+	const tip = pts[pts.length - 1];
+	const prev = pts[pts.length - 2];
+	const hx = tip[0] - prev[0];
+	const hy = tip[1] - prev[1];
+	const segLength = Math.hypot(hx, hy);
+	if (segLength === 0 || pathLength === 0) return null;
+	const dir = [hx / segLength, hy / segLength];
+	const perp = [-dir[1], dir[0]];
+	return {
+		pts,
+		pathLength,
+		tip,
+		dir,
+		perp,
+		segLength
+	};
+}
+/**
+* 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$1(value, fallback) {
+	if (!Number.isFinite(value)) return fallback;
+	return Math.min(64, Math.max(2, Math.round(value)));
+}
+/**
+* Shared param descriptors for {@link SmoothLineOptions}, modeled on
+* `SMOOTH_PATH_PARAMS` (cm99-generic-graphics/params.ts). Measures that add
+* their own params should spread these at the top of the array.
+*/
+const SMOOTH_LINE_PARAMS = [{
+	key: "smooth",
+	label: "Smooth",
+	description: "Round the line's corners by curving the path through the control points.",
+	type: "boolean"
+}, {
+	key: "smoothResolution",
+	presentationTier: "advanced",
+	label: "Smooth resolution",
+	description: "Number of samples per segment when smooth mode is enabled.",
+	type: "number",
+	min: 2,
+	max: 64,
+	step: 1,
+	visibleWhen: (opts) => Boolean(opts.smooth)
+}];
+/**
+* Applies {@link SmoothLineOptions} to projected vertices `verts`: runs
+* {@link catmullRom} at the resolved (clamped) sample resolution when `smooth`
+* is set, else returns `verts` unchanged.
+*/
+function smoothLineVerts(verts, options, defaultResolution) {
+	return options.smooth ? catmullRom(verts, normalizeSmoothResolution$1(options.smoothResolution ?? defaultResolution, defaultResolution)) : verts;
+}
+/**
+* Resamples a path into equal arc-length segments.
+*
+* This is useful for a repeated motif (such as a fortified tooth or FLOT
+* scallop) after smoothing. Catmull-Rom samples are evenly spaced in spline
+* parameter, not distance, so using them directly as motif boundaries causes
+* the motifs to bunch up where the curve's samples are closer together.
+*/
+function evenlySpacePath(points, targetSegmentLength) {
+	if (points.length < 2) return points;
+	const segmentLengths = [];
+	let totalLength = 0;
+	for (let i = 0; i < points.length - 1; i++) {
+		const length = vecMag(vecSub(points[i + 1], points[i]));
+		segmentLengths.push(length);
+		totalLength += length;
+	}
+	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) {
+	const t2 = t * t;
+	const t3 = t2 * t;
+	return [.5 * (2 * p1[0] + (-p0[0] + p2[0]) * t + (2 * p0[0] - 5 * p1[0] + 4 * p2[0] - p3[0]) * t2 + (-p0[0] + 3 * p1[0] - 3 * p2[0] + p3[0]) * t3), .5 * (2 * p1[1] + (-p0[1] + p2[1]) * t + (2 * p0[1] - 5 * p1[1] + 4 * p2[1] - p3[1]) * t2 + (-p0[1] + 3 * p1[1] - 3 * p2[1] + p3[1]) * t3)];
+}
+/**
+* Centripetal Catmull-Rom spline through `points`, sampled `samples` times per
+* segment. Endpoints are duplicated so the curve passes through them, so the
+* first and last points are preserved exactly. With `samples <= 1` (or fewer
+* than 3 points) it returns the input unchanged.
+*/
+function catmullRom(points, samples) {
+	if (points.length < 3 || samples <= 1) return points;
+	const pts = [
+		points[0],
+		...points,
+		points[points.length - 1]
+	];
+	const out = [points[0]];
+	for (let i = 1; i < pts.length - 2; i++) {
+		const p0 = pts[i - 1];
+		const p1 = pts[i];
+		const p2 = pts[i + 1];
+		const p3 = pts[i + 2];
+		for (let s = 1; s <= samples; s++) out.push(catmullRomAt(p0, p1, p2, p3, s / samples));
+	}
+	return out;
+}
+/**
+* Closed centripetal Catmull-Rom: smooths a polygon ring through every vertex,
+* wrapping the control points around the seam. Returns a ring whose first and
+* last positions coincide (explicit closure). With `samples <= 1` (or fewer
+* than 3 points) it returns the input unchanged.
+*/
+function closedCatmullRom(points, samples) {
+	const n = points.length;
+	if (n < 3 || samples <= 1) return points;
+	const out = [];
+	for (let i = 0; i < n; i++) {
+		const p0 = points[(i - 1 + n) % n];
+		const p1 = points[i];
+		const p2 = points[(i + 1) % n];
+		const p3 = points[(i + 2) % n];
+		for (let s = 0; s < samples; s++) out.push(catmullRomAt(p0, p1, p2, p3, s / samples));
+	}
+	out.push([...out[0]]);
+	return out;
+}
+//#endregion
+//#region src/internal/vertex-widths.ts
+/** The option key holding each side's per-vertex widths. */
+const VERTEX_WIDTH_OPTION_KEYS = {
+	left: "vertexLeftWidthRatios",
+	right: "vertexRightWidthRatios"
+};
+/** The `vertexAlignedOptions` every variable-width arrow body declares. */
+const VERTEX_WIDTH_ALIGNED_OPTIONS = [VERTEX_WIDTH_OPTION_KEYS.left, VERTEX_WIDTH_OPTION_KEYS.right];
+/** Maps a body-spine index (rear = 0) to its Axis1 control-point index. */
+function spineIndexToControlPoint(spineIndex, controlPointCount) {
+	return controlPointCount - 2 - spineIndex;
+}
+/**
+* Resolves both sides' per-vertex widths onto the body spine (rear → neck),
+* clamping each set ratio to `[min, max]`. Returns `null` when no shaft vertex
+* carries a usable width on either side, which callers treat as "use the plain
+* rear → shaft taper" so graphics without the options run exactly the code they
+* ran before.
+*/
+function resolveSpineWidthRatios(options, controlPointCount, min, max) {
+	const left = resolveSide(options.vertexLeftWidthRatios, controlPointCount, min, max);
+	const right = resolveSide(options.vertexRightWidthRatios, controlPointCount, min, max);
+	return left || right ? {
+		left,
+		right
+	} : null;
+}
+function resolveSide(ratios, controlPointCount, min, max) {
+	if (!ratios?.length) return null;
+	const spineCount = controlPointCount - 2;
+	if (spineCount < 1) return null;
+	let found = false;
+	const resolved = new Array(spineCount).fill(null);
+	for (let j = 0; j < spineCount; j++) {
+		const value = ratios[spineIndexToControlPoint(j, controlPointCount)];
+		if (!isFiniteNumber(value)) continue;
+		resolved[j] = clamp(value, min, max);
+		found = true;
+	}
+	return found ? resolved : null;
+}
+/**
+* One value per polyline vertex, given each vertex's cumulative arc length
+* (see {@link cumulativeDistances}): pinned to `startValue` / `endValue` at the
+* two ends, taken from `setValues` where set, and interpolated linearly by arc
+* length between set neighbours elsewhere. `setValues` is parallel to the
+* vertices; its first and last entries are ignored and missing entries count
+* as unset.
+*/
+function anchoredPolylineValues(distances, startValue, endValue, setValues) {
+	const n = distances.length;
+	if (n === 0) return [];
+	if (n === 1) return [endValue];
+	const values = new Array(n);
+	values[0] = startValue;
+	let previous = 0;
+	for (let j = 1; j < n; j++) {
+		const set = j === n - 1 ? endValue : setValues[j];
+		if (set === null || set === void 0) continue;
+		values[j] = set;
+		const from = values[previous];
+		const span = distances[j] - distances[previous];
+		for (let k = previous + 1; k < j; k++) {
+			const t = span < 1e-6 ? 1 : (distances[k] - distances[previous]) / span;
+			values[k] = from + (set - from) * t;
+		}
+		previous = j;
+	}
+	return values;
+}
+/**
+* Linearly reads per-vertex `values` at arc-length fraction `t`, given each
+* vertex's cumulative arc length (see {@link cumulativeDistances}).
+*/
+function valueAtFraction(distances, values, t) {
+	const n = Math.min(distances.length, values.length);
+	if (n === 0) return 0;
+	if (n === 1) return values[0];
+	const target = clamp(t, 0, 1) * distances[n - 1];
+	for (let i = 1; i < n; i++) if (target <= distances[i]) {
+		const length = distances[i] - distances[i - 1];
+		const f = length < 1e-6 ? 1 : (target - distances[i - 1]) / length;
+		return values[i - 1] + (values[i] - values[i - 1]) * f;
+	}
+	return values[n - 1];
+}
+/**
+* Resamples an authored shaft centerline onto a Catmull-Rom curve with
+* `samples` drawn points per segment, so authored vertex `j` lands at drawn
+* index `j * stride`. Fewer than three vertices or two samples leave the spine
+* as authored, with a stride of 1.
+*/
+function curveSpine(authored, samples) {
+	if (authored.length < 3 || samples < 2) return {
+		spine: authored,
+		stride: 1
+	};
+	return {
+		spine: catmullRom(authored, samples),
+		stride: samples
+	};
+}
+/**
+* Outlines a shaft whose two sides each run from the rear half-width to the
+* base half-width, following their own set ratios in between. Only the
+* authored vertices before the shaft end may carry a set width (the head may
+* have swallowed the rest; `ratios` is a longer prefix then). A side's own rear
+* entry overrides the shared rear width.
+*
+* With `stride` 1 widths change linearly between the authored vertices; on a
+* resampled curve they ease smoothly between set vertices (see
+* {@link smoothAnchoredValues}). Without ratios both sides share the plain
+* rear → base taper.
+*/
+function variableWidthShaft(input) {
+	const { spine, stride, rearHalfWidth, baseHalfWidth, ratios, ratioToHalfWidth } = input;
+	const distances = cumulativeDistances(spine);
+	const setCount = (spine.length - 1) / stride;
+	const side = (sideRatios) => {
+		const set = [];
+		for (let j = 0; j < setCount; j++) {
+			const ratio = sideRatios?.[j];
+			set.push(ratio === null || ratio === void 0 ? null : ratio * ratioToHalfWidth);
+		}
+		const rear = set[0] ?? rearHalfWidth;
+		return stride === 1 ? anchoredPolylineValues(distances, rear, baseHalfWidth, set) : smoothAnchoredValues(distances, rear, baseHalfWidth, set, stride);
+	};
+	const left = side(ratios?.left);
+	const right = ratios ? side(ratios.right) : left;
+	const edges = offsetPolylineSides(spine, left, input.rounded, input.roundSegments, right);
+	return {
+		leftEdge: edges.left,
+		rightEdge: edges.right,
+		profile: {
+			spine,
+			stride,
+			left,
+			right,
+			ratios,
+			rounded: input.rounded,
+			edgeStarts: {
+				left: edges.leftStarts,
+				right: edges.rightStarts
+			}
+		}
+	};
+}
+const REAR_GRIP_SIDES = ["left"];
+const VERTEX_GRIP_SIDES = ["left", "right"];
+/** Authored vertices behind a profile's drawn spine (rear … shaft end). */
+function authoredCount(profile) {
+	return (profile.spine.length - 1) / profile.stride + 1;
+}
+function vertexWidthGrip(profile, controlPointCount, side, spineIndex) {
+	const index = spineIndex * profile.stride;
+	const vertex = profile.spine[index];
+	const halfWidth = profile[side][index];
+	if (!vertex || halfWidth === void 0) return null;
+	const direction = offsetDirectionAt(profile.spine, index, side === "left" ? 1 : -1, profile.rounded);
+	if (!direction) return null;
+	return {
+		controlPointIndex: spineIndexToControlPoint(spineIndex, controlPointCount),
+		side,
+		vertex,
+		direction,
+		halfWidth,
+		set: isFiniteNumber(profile.ratios?.[side]?.[spineIndex])
+	};
+}
+/**
+* The width grips for a shaft: a left and a right grip per interior vertex that
+* came from a control point, each on its own edge, plus a left grip at the rear
+* (the shared `rear-width` handle already sits on the right rear corner and
+* moves both sides until the left is set). The shaft end belongs to
+* `shaftWidthRatio` and gets none.
+*/
+function buildVertexWidthGrips(profile, controlPointCount) {
+	const grips = [];
+	const count = authoredCount(profile);
+	for (let j = 0; j < count - 1; j++) for (const side of j === 0 ? REAR_GRIP_SIDES : VERTEX_GRIP_SIDES) {
+		const grip = vertexWidthGrip(profile, controlPointCount, side, j);
+		if (grip) grips.push(grip);
+	}
+	return grips;
+}
+/** The one grip of {@link buildVertexWidthGrips} for `side` at control point `index`. */
+function findVertexWidthGrip(profile, controlPointCount, side, controlPointIndex) {
+	const j = spineIndexToControlPoint(controlPointIndex, controlPointCount);
+	if (j < 0 || j >= authoredCount(profile) - 1 || j === 0 && side === "right") return null;
+	return vertexWidthGrip(profile, controlPointCount, side, j);
+}
+const VERTEX_WIDTH_HANDLE_PREFIX = "vertex-width-";
+const VERTEX_WIDTH_HANDLE_PATTERN = new RegExp(`^${VERTEX_WIDTH_HANDLE_PREFIX}(left|right)-(\\d+)$`);
+/** Handle id for the `side` width grip stored under control point `index`. */
+function vertexWidthHandleId(side, controlPointIndex) {
+	return `${VERTEX_WIDTH_HANDLE_PREFIX}${side}-${controlPointIndex}`;
+}
+/** Parses a {@link vertexWidthHandleId}; `null` for any other handle id. */
+function parseVertexWidthHandleId(handleId) {
+	const match = VERTEX_WIDTH_HANDLE_PATTERN.exec(handleId);
+	if (!match) return null;
+	return {
+		side: match[1],
+		controlPointIndex: Number(match[2])
+	};
+}
+/**
+* Returns `ratios` with entry `index` replaced by `value`, padding with `null`
+* as needed. A `null` value trims trailing `null`s, and an all-`null` result
+* collapses to `undefined` so a fully reset option drops out of the options.
+*/
+function withVertexWidth(ratios, index, value) {
+	const next = ratios ? [...ratios] : [];
+	while (next.length <= index) next.push(null);
+	next[index] = value;
+	while (next.length > 0 && !isFiniteNumber(next.at(-1))) next.pop();
+	return next.length > 0 ? next : void 0;
+}
+/**
+* Smooth counterpart of {@link anchoredPolylineValues} for a curved (densely
+* sampled) spine, given each drawn vertex's cumulative arc length. The knots are the two ends and every set authored vertex;
+* values in between follow a monotone cubic in arc length, so the width eases
+* in and out of each set vertex without overshooting (a pinch never dips
+* below its own width). Authored vertex `j` sits at drawn index `j * stride`;
+* `setValues` is parallel to the authored vertices.
+*/
+function smoothAnchoredValues(distances, startValue, endValue, setValues, stride) {
+	const n = distances.length;
+	if (n === 0) return [];
+	if (n === 1) return [endValue];
+	const xs = [0];
+	const ys = [startValue];
+	for (let j = 1; j * stride < n - 1; j++) {
+		const value = setValues[j];
+		if (value === null || value === void 0) continue;
+		const x = distances[j * stride];
+		if (x - xs.at(-1) < 1e-6) continue;
+		xs.push(x);
+		ys.push(value);
+	}
+	const total = distances[n - 1];
+	if (total - xs.at(-1) < 1e-6) ys[ys.length - 1] = endValue;
+	else {
+		xs.push(total);
+		ys.push(endValue);
+	}
+	if (xs.length < 2) return distances.map(() => endValue);
+	const slopes = monotoneTangents(xs, ys);
+	const values = new Array(n);
+	let k = 0;
+	for (let i = 0; i < n; i++) {
+		const x = distances[i];
+		while (k < xs.length - 2 && x > xs[k + 1]) k++;
+		const h = xs[k + 1] - xs[k];
+		const t = clamp((x - xs[k]) / h, 0, 1);
+		const t2 = t * t;
+		const t3 = t2 * t;
+		values[i] = (2 * t3 - 3 * t2 + 1) * ys[k] + (t3 - 2 * t2 + t) * h * slopes[k] + (-2 * t3 + 3 * t2) * ys[k + 1] + (t3 - t2) * h * slopes[k + 1];
+	}
+	return values;
+}
+/**
+* Knot tangents for a monotone piecewise-cubic Hermite interpolant
+* (Fritsch–Butland): zero at local extrema, a weighted harmonic mean of the
+* neighbouring secants elsewhere, and the adjacent secant at the two ends.
+*/
+function monotoneTangents(xs, ys) {
+	const m = xs.length;
+	const secants = [];
+	for (let k = 0; k < m - 1; k++) secants.push((ys[k + 1] - ys[k]) / (xs[k + 1] - xs[k]));
+	const tangents = [secants[0]];
+	for (let k = 1; k < m - 1; k++) {
+		const d0 = secants[k - 1];
+		const d1 = secants[k];
+		if (d0 * d1 <= 0) {
+			tangents.push(0);
+			continue;
+		}
+		const h0 = xs[k] - xs[k - 1];
+		const h1 = xs[k + 1] - xs[k];
+		tangents.push(3 * (h0 + h1) / ((2 * h1 + h0) / d0 + (h1 + 2 * h0) / d1));
+	}
+	tangents.push(secants[m - 2]);
+	return tangents;
+}
+//#endregion
 //#region src/attack-utils.ts
 const DEFAULT_SHAFT_WIDTH_RATIO$1 = .6;
 const DEFAULT_REAR_WIDTH_RATIO = DEFAULT_SHAFT_WIDTH_RATIO$1;
 const SHAFT_MIN_RATIO = .1;
 const SHAFT_MAX_RATIO = .9;
+const DEFAULT_ATTACK_SMOOTH_MODE = "rounded-corners";
+/** Curve samples per shaft segment for each unit of `smoothResolution`. */
+const CURVE_SAMPLES_PER_RESOLUTION = 4;
+/** Shaft defaults shared by every variable-width attack body. */
+const DEFAULT_ATTACK_SHAFT_OPTIONS = {
+	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
+	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
+	smooth: false,
+	smoothMode: DEFAULT_ATTACK_SMOOTH_MODE,
+	smoothResolution: 5
+};
 const REAR_WIDTH_OPTION_HANDLE_ID = "rear-width";
 const SHAFT_WIDTH_OPTION_HANDLE_ID = "shaft-width";
 /**
@@ -1350,30 +1952,72 @@ const SHAFT_WIDTH_OPTION_HANDLE_ID = "shaft-width";
 * matching centerline segment, over the reference half-width) live here once.
 */
 function createWidthOptionHandles(config) {
+	const vertexWidthPatch = (options, side, index, value) => {
+		const key = VERTEX_WIDTH_OPTION_KEYS[side];
+		return { [key]: withVertexWidth(options[key], index, value) };
+	};
+	const rightRearOverride = (controlPoints, options) => {
+		const rearIndex = spineIndexToControlPoint(0, controlPoints.length);
+		return isFiniteNumber(options.vertexRightWidthRatios?.[rearIndex]) ? rearIndex : null;
+	};
 	return {
-		get(controlPoints, options) {
+		get(controlPoints, options, query) {
 			const geometry = config.geometry(controlPoints, options);
 			const rearRight = geometry?.rightEdge[0];
 			const neckRight = geometry?.rightEdge.at(-1);
-			if (!rearRight || !neckRight) return [];
-			return [{
+			if (!geometry || !rearRight || !neckRight) return [];
+			const handles = [{
 				id: REAR_WIDTH_OPTION_HANDLE_ID,
 				position: unproject(rearRight[0], rearRight[1])
 			}, {
 				id: SHAFT_WIDTH_OPTION_HANDLE_ID,
 				position: unproject(neckRight[0], neckRight[1])
 			}];
+			if (!query?.detail) return handles;
+			for (const grip of buildVertexWidthGrips(geometry.profile, geometry.controlPointCount)) {
+				const point = vecAdd(grip.vertex, vecScale(grip.direction, grip.halfWidth));
+				handles.push({
+					id: vertexWidthHandleId(grip.side, grip.controlPointIndex),
+					position: unproject(point[0], point[1]),
+					...grip.set ? {} : { unset: true }
+				});
+			}
+			return handles;
 		},
 		drag({ controlPoints, options, handleId, position }) {
+			const target = parseVertexWidthHandleId(handleId);
+			if (target) {
+				const geometry = config.geometry(controlPoints, options);
+				if (!geometry || geometry.referenceHalfWidth < 1e-6) return void 0;
+				const grip = findVertexWidthGrip(geometry.profile, geometry.controlPointCount, target.side, target.controlPointIndex);
+				if (!grip) return void 0;
+				const lengthSq = vecDot(grip.direction, grip.direction);
+				if (lengthSq < 1e-6) return void 0;
+				const ratio = clamp(vecDot(vecSub(project(position[0], position[1]), grip.vertex), grip.direction) / lengthSq / geometry.referenceHalfWidth, config.minRatio, config.maxRearRatio);
+				return vertexWidthPatch(options, target.side, target.controlPointIndex, ratio);
+			}
 			const rear = handleId === REAR_WIDTH_OPTION_HANDLE_ID;
 			if (!rear && !(handleId === "shaft-width")) return void 0;
 			const geometry = config.geometry(controlPoints, options);
 			if (!geometry || geometry.referenceHalfWidth < 1e-6) return void 0;
-			const from = rear ? geometry.spine[0] : geometry.spine.at(-2);
-			const to = rear ? geometry.spine[1] : geometry.spine.at(-1);
+			const { spine } = geometry.profile;
+			const from = rear ? spine[0] : spine.at(-2);
+			const to = rear ? spine[1] : spine.at(-1);
 			if (!from || !to) return void 0;
 			const ratio = clamp(pointToInfiniteLineDistance(project(position[0], position[1]), from, to) / geometry.referenceHalfWidth, config.minRatio, rear ? config.maxRearRatio : config.maxShaftRatio);
-			return rear ? { rearWidthRatio: ratio } : { shaftWidthRatio: ratio };
+			if (!rear) return { shaftWidthRatio: ratio };
+			const rearIndex = rightRearOverride(controlPoints, options);
+			if (rearIndex !== null) return vertexWidthPatch(options, "right", rearIndex, ratio);
+			return { rearWidthRatio: ratio };
+		},
+		reset({ controlPoints, options, handleId }) {
+			if (handleId === "rear-width") {
+				const rearIndex = rightRearOverride(controlPoints, options);
+				return rearIndex === null ? void 0 : vertexWidthPatch(options, "right", rearIndex, null);
+			}
+			const target = parseVertexWidthHandleId(handleId);
+			if (!target || !options[VERTEX_WIDTH_OPTION_KEYS[target.side]]) return void 0;
+			return vertexWidthPatch(options, target.side, target.controlPointIndex, null);
 		}
 	};
 }
@@ -1392,9 +2036,10 @@ function createVariableWidthAttackOptionHandles(resolveCoordinates = (points) =>
 			const outerLeft = geometry?.headRing[0];
 			if (!geometry || !outerLeft) return null;
 			return {
-				spine: geometry.shaftCenterline,
+				profile: geometry.shaftProfile,
 				rightEdge: geometry.shaftRight,
-				referenceHalfWidth: vecMag(vecSub(outerLeft, geometry.ptBase))
+				referenceHalfWidth: vecMag(vecSub(outerLeft, geometry.ptBase)),
+				controlPointCount: coordinates.length
 			};
 		},
 		minRatio: SHAFT_MIN_RATIO,
@@ -1411,11 +2056,48 @@ const variableWidthAttackOptionHandles = createVariableWidthAttackOptionHandles(
 function resolveRearWidthRatio(options, shaftRatio) {
 	return options.rearWidthRatio ?? shaftRatio;
 }
+/** The options {@link processAttackGeometry} reads; the cache compares only these. */
+const ATTACK_GEOMETRY_OPTION_KEYS = [
+	"shaftWidthRatio",
+	"rearWidthRatio",
+	"smooth",
+	"smoothResolution",
+	"smoothMode",
+	"vertexLeftWidthRatios",
+	"vertexRightWidthRatios"
+];
+/**
+* The last body built, by value. A width-grip drag builds the same body up to
+* three times per pointer move (the drag, the render, the next handle
+* placement), so one entry is enough. The result is shared, never mutated.
+*/
+let lastAttackGeometry = null;
+function sameOptionValue(a, b) {
+	if (Object.is(a, b)) return true;
+	if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+	return a.every((value, i) => Object.is(value, b[i]));
+}
 /**
 * Processes input coordinates and options to generate the core symbol geometry.
 * This handles validation, default values, projection, and geometry calculation.
 */
 function processAttackGeometry(coordinates, options = {}) {
+	const last = lastAttackGeometry;
+	if (last && last.coordinates.length === coordinates.length * 2 && coordinates.every((c, i) => c[0] === last.coordinates[2 * i] && c[1] === last.coordinates[2 * i + 1]) && ATTACK_GEOMETRY_OPTION_KEYS.every((key) => sameOptionValue(options[key], last.options[key]))) return last.result;
+	const result = buildAttackGeometry(coordinates, options);
+	const snapshot = {};
+	for (const key of ATTACK_GEOMETRY_OPTION_KEYS) {
+		const value = options[key];
+		snapshot[key] = Array.isArray(value) ? [...value] : value;
+	}
+	lastAttackGeometry = {
+		coordinates: coordinates.flatMap((c) => [c[0], c[1]]),
+		options: snapshot,
+		result
+	};
+	return result;
+}
+function buildAttackGeometry(coordinates, options) {
 	const shaftRatio = clamp(options.shaftWidthRatio ?? .6, SHAFT_MIN_RATIO, SHAFT_MAX_RATIO);
 	const smooth = options.smooth ?? false;
 	const smoothResolution = options.smoothResolution ?? 5;
@@ -1429,9 +2111,9 @@ function processAttackGeometry(coordinates, options = {}) {
 		const p = points[i];
 		if (p) spinePoints.push(p);
 	}
-	return { geometry: calculateSymbolGeometry(ptTip, ptWidth, spinePoints, shaftRatio, rearRatio, smooth, smoothResolution) };
+	return { geometry: calculateSymbolGeometry(ptTip, ptWidth, spinePoints, shaftRatio, rearRatio, smooth ? options.smoothMode ?? "rounded-corners" : null, smoothResolution, resolveSpineWidthRatios(options, numPoints, SHAFT_MIN_RATIO, 3)) };
 }
-function calculateSymbolGeometry(ptTip, ptWidth, spine, shaftRatio, rearWidthRatio, smooth, smoothResolution) {
+function calculateSymbolGeometry(ptTip, ptWidth, spine, shaftRatio, rearWidthRatio, smoothing, smoothResolution, spineWidthRatios = null) {
 	const initialNeck = spine[spine.length - 1];
 	if (!initialNeck) return null;
 	const initialTipDir = vecNorm(vecSub(ptTip, initialNeck));
@@ -1484,15 +2166,46 @@ function calculateSymbolGeometry(ptTip, ptWidth, spine, shaftRatio, rearWidthRat
 		outerLeft
 	];
 	const fullSpine = [...remainingSpine, shaftEndCenter];
-	const { left: shaftLeft, right: shaftRight } = offsetPolylineSides(fullSpine, interpolatePolylineValues(fullSpine, headHalfWidth * rearWidthRatio, shaftHalfWidth), smooth, smoothResolution);
+	const rearHalfWidth = headHalfWidth * rearWidthRatio;
+	const { spine: drawnSpine, stride } = smoothing === "curve" ? curveSpine(fullSpine, normalizeSmoothResolution$1(smoothResolution * CURVE_SAMPLES_PER_RESOLUTION, 5 * CURVE_SAMPLES_PER_RESOLUTION)) : {
+		spine: fullSpine,
+		stride: 1
+	};
+	const { leftEdge: shaftLeft, rightEdge: shaftRight, profile: shaftProfile } = variableWidthShaft({
+		spine: drawnSpine,
+		stride,
+		rearHalfWidth,
+		baseHalfWidth: shaftHalfWidth,
+		ratios: spineWidthRatios,
+		ratioToHalfWidth: headHalfWidth,
+		rounded: smoothing !== null && !(stride > 1),
+		roundSegments: smoothResolution
+	});
 	return {
-		shaftCenterline: fullSpine,
+		shaftCenterline: drawnSpine,
 		shaftLeft,
 		shaftRight,
 		headRing,
 		ptTip,
 		ptNeck,
-		ptBase
+		ptBase,
+		shaftProfile
+	};
+}
+/**
+* The two shaft edges cut at the neck, for bodies whose outline crosses over
+* from the neck to the far side of the head (Airborne Attack, Attack
+* Helicopter). The edges run on to the head base; this keeps each edge up to
+* the neck, the last authored vertex before the base, which sits one `stride`
+* of drawn vertices back.
+*/
+function shaftEdgesToNeck(geometry) {
+	const { spine, stride, edgeStarts } = geometry.shaftProfile;
+	const afterNeck = spine.length - stride;
+	const toNeck = (edge, starts) => edge.slice(0, Math.max(1, starts[afterNeck] ?? edge.length));
+	return {
+		left: toNeck(geometry.shaftLeft, edgeStarts.left),
+		right: toNeck(geometry.shaftRight, edgeStarts.right)
 	};
 }
 /**
@@ -1777,242 +2490,86 @@ const line25DrawRule = {
 /**
 * Per-feature style hint pinning a filled part to a solid interior. Attach to
 * a generator's intrinsic doctrinal accents — arrowheads, teeth, echelon
-* glyphs, barbs, blades — so a patterned (`hatch`, `dots`, …) fill set at the graphicsStyle
-* or measure layer never bleeds into a small silhouette and ruins its
-* legibility. The renderer only reads style hints, so one shared instance is
-* safe to reuse across every accent feature.
-*/
-const SOLID_ACCENT_FILL = { fillPattern: "solid" };
-/**
-* Ultimate fallback for the symbol color when no `color` or per-channel
-* override or doctrinal metadata default is supplied. Keeps other measures
-* monocolor black and guarantees filled parts still render filled. See ADR-0011.
-*/
-const DEFAULT_SYMBOL_COLOR = "#000000";
-/** MIL-STD-2525D Tables XV–XVI. Fill shades are neutral identity palette samples. */
-const MIL_STD_GREEN = {
-	neon: "#00ff00",
-	dark: "#00a000",
-	medium: "#00e200",
-	light: "#aaffaa"
-};
-//#endregion
-//#region src/portrayal.ts
-/**
-* Convert true-ground portrayal scale to the Web Mercator metres used by legacy
-* geometry and authored text sizes. Use the graphic's control-point bounding-box
-* midpoint for both label layout and painting, including moved labels.
-*/
-function resolveConstructionMetersPerCssPixel(points, groundMetersPerCssPixel) {
-	if (!(groundMetersPerCssPixel !== void 0 && groundMetersPerCssPixel > 0)) return void 0;
-	let minLatitude = Infinity;
-	let maxLatitude = -Infinity;
-	for (const point of points) {
-		minLatitude = Math.min(minLatitude, point[1]);
-		maxLatitude = Math.max(maxLatitude, point[1]);
-	}
-	const midpointLatitude = (minLatitude + maxLatitude) / 2;
-	const mercatorScale = Math.cos(midpointLatitude * Math.PI / 180);
-	return groundMetersPerCssPixel / Math.max(mercatorScale, Number.EPSILON);
-}
-const DEFAULT_STROKE_WIDTH_CSS_PIXELS = 2;
-const DEFAULT_STROKE_DASH_CSS_PIXELS = Object.freeze([]);
-const DEFAULT_LINE_CAP = "round";
-const DEFAULT_LINE_JOIN = "round";
-const DEFAULT_LABEL_HEIGHT_CSS_PIXELS = 14;
-const DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS = {
-	min: 8,
-	max: 24
-};
-/** Shared absent-value portrayal defaults; render output remains sparse. */
-const DEFAULT_PORTRAYAL = Object.freeze({
-	symbolColor: DEFAULT_SYMBOL_COLOR,
-	strokeWidthCssPixels: 2,
-	strokeDashCssPixels: DEFAULT_STROKE_DASH_CSS_PIXELS,
-	lineCap: DEFAULT_LINE_CAP,
-	lineJoin: DEFAULT_LINE_JOIN,
-	labelHeightCssPixels: 14
-});
-//#endregion
-//#region src/internal/angle-utils.ts
-/**
-* Wraps an angle (radians) into the half-open range (-π, π].
-*/
-function normalizeRadians(angle) {
-	let normalized = angle % (Math.PI * 2);
-	if (normalized > Math.PI) normalized -= Math.PI * 2;
-	if (normalized <= -Math.PI) normalized += Math.PI * 2;
-	return normalized;
-}
-/** Wraps a degree value into the canonical clockwise `[0, 360)` range. */
-function normalizeDegrees(degrees) {
-	return (degrees % 360 + 360) % 360;
-}
-/**
-* Flips a text rotation by π when it would otherwise read upside-down, keeping
-* the baseline pointing left-to-right (within ±90° of horizontal).
-*/
-function keepTextLeftToRight(rotation) {
-	const normalized = normalizeRadians(rotation);
-	if (normalized > Math.PI / 2) return normalized - Math.PI;
-	if (normalized < -Math.PI / 2) return normalized + Math.PI;
-	return normalized;
-}
-//#endregion
-//#region src/internal/sketch.ts
-/**
-* Projects `coordinates` and derives the arrow's tip, heading and total length.
-* Returns `null` for degenerate input (fewer than two points, a zero-length
-* path, or a zero-length final segment) so the caller can decide what to emit.
-*/
-function arrowAxis(coordinates) {
-	if (coordinates.length < 2) return null;
-	const pts = coordinates.map((c) => project(c[0], c[1]));
-	let pathLength = 0;
-	for (let i = 0; i < pts.length - 1; i++) pathLength += Math.hypot(pts[i + 1][0] - pts[i][0], pts[i + 1][1] - pts[i][1]);
-	const tip = pts[pts.length - 1];
-	const prev = pts[pts.length - 2];
-	const hx = tip[0] - prev[0];
-	const hy = tip[1] - prev[1];
-	const segLength = Math.hypot(hx, hy);
-	if (segLength === 0 || pathLength === 0) return null;
-	const dir = [hx / segLength, hy / segLength];
-	const perp = [-dir[1], dir[0]];
-	return {
-		pts,
-		pathLength,
-		tip,
-		dir,
-		perp,
-		segLength
-	};
-}
-/**
-* Clamps and rounds a smooth-resolution option (samples per segment) onto
-* `[MIN_SMOOTH_RESOLUTION, MAX_SMOOTH_RESOLUTION]`, falling back to `fallback`
-* for non-finite input. The default varies per measure, so it's passed in.
-*/
-function normalizeSmoothResolution$2(value, fallback) {
-	if (!Number.isFinite(value)) return fallback;
-	return Math.min(64, Math.max(2, Math.round(value)));
-}
-/**
-* Shared param descriptors for {@link SmoothLineOptions}, modeled on
-* `SMOOTH_PATH_PARAMS` (cm99-generic-graphics/params.ts). Measures that add
-* their own params should spread these at the top of the array.
-*/
-const SMOOTH_LINE_PARAMS = [{
-	key: "smooth",
-	label: "Smooth",
-	description: "Round the line's corners by curving the path through the control points.",
-	type: "boolean"
-}, {
-	key: "smoothResolution",
-	presentationTier: "advanced",
-	label: "Smooth resolution",
-	description: "Number of samples per segment when smooth mode is enabled.",
-	type: "number",
-	min: 2,
-	max: 64,
-	step: 1,
-	visibleWhen: (opts) => Boolean(opts.smooth)
-}];
+* glyphs, barbs, blades — so a patterned (`hatch`, `dots`, …) fill set at the graphicsStyle
+* or measure layer never bleeds into a small silhouette and ruins its
+* legibility. The renderer only reads style hints, so one shared instance is
+* safe to reuse across every accent feature.
+*/
+const SOLID_ACCENT_FILL = { fillPattern: "solid" };
 /**
-* Applies {@link SmoothLineOptions} to projected vertices `verts`: runs
-* {@link catmullRom} at the resolved (clamped) sample resolution when `smooth`
-* is set, else returns `verts` unchanged.
+* Ultimate fallback for the symbol color when no `color` or per-channel
+* override or doctrinal metadata default is supplied. Keeps other measures
+* monocolor black and guarantees filled parts still render filled. See ADR-0011.
 */
-function smoothLineVerts(verts, options, defaultResolution) {
-	return options.smooth ? catmullRom(verts, normalizeSmoothResolution$2(options.smoothResolution ?? defaultResolution, defaultResolution)) : verts;
-}
+const DEFAULT_SYMBOL_COLOR = "#000000";
+/** MIL-STD-2525D Tables XV–XVI. Fill shades are neutral identity palette samples. */
+const MIL_STD_GREEN = {
+	neon: "#00ff00",
+	dark: "#00a000",
+	medium: "#00e200",
+	light: "#aaffaa"
+};
+//#endregion
+//#region src/portrayal.ts
 /**
-* 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.
+* Convert true-ground portrayal scale to the Web Mercator metres used by legacy
+* geometry and authored text sizes. Use the graphic's control-point bounding-box
+* midpoint for both label layout and painting, including moved labels.
 */
-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]);
+function resolveConstructionMetersPerCssPixel(points, groundMetersPerCssPixel) {
+	if (!(groundMetersPerCssPixel !== void 0 && groundMetersPerCssPixel > 0)) return void 0;
+	let minLatitude = Infinity;
+	let maxLatitude = -Infinity;
+	for (const point of points) {
+		minLatitude = Math.min(minLatitude, point[1]);
+		maxLatitude = Math.max(maxLatitude, point[1]);
 	}
-	out.push(points[points.length - 1]);
-	return out;
-}
-/** One centripetal Catmull-Rom sample at parameter `t` over control points `p0..p3`. */
-function catmullRomAt(p0, p1, p2, p3, t) {
-	const t2 = t * t;
-	const t3 = t2 * t;
-	return [.5 * (2 * p1[0] + (-p0[0] + p2[0]) * t + (2 * p0[0] - 5 * p1[0] + 4 * p2[0] - p3[0]) * t2 + (-p0[0] + 3 * p1[0] - 3 * p2[0] + p3[0]) * t3), .5 * (2 * p1[1] + (-p0[1] + p2[1]) * t + (2 * p0[1] - 5 * p1[1] + 4 * p2[1] - p3[1]) * t2 + (-p0[1] + 3 * p1[1] - 3 * p2[1] + p3[1]) * t3)];
+	const midpointLatitude = (minLatitude + maxLatitude) / 2;
+	const mercatorScale = Math.cos(midpointLatitude * Math.PI / 180);
+	return groundMetersPerCssPixel / Math.max(mercatorScale, Number.EPSILON);
 }
+const DEFAULT_STROKE_WIDTH_CSS_PIXELS = 2;
+const DEFAULT_STROKE_DASH_CSS_PIXELS = Object.freeze([]);
+const DEFAULT_LINE_CAP = "round";
+const DEFAULT_LINE_JOIN = "round";
+const DEFAULT_LABEL_HEIGHT_CSS_PIXELS = 14;
+const DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS = {
+	min: 8,
+	max: 24
+};
+/** Shared absent-value portrayal defaults; render output remains sparse. */
+const DEFAULT_PORTRAYAL = Object.freeze({
+	symbolColor: DEFAULT_SYMBOL_COLOR,
+	strokeWidthCssPixels: 2,
+	strokeDashCssPixels: DEFAULT_STROKE_DASH_CSS_PIXELS,
+	lineCap: DEFAULT_LINE_CAP,
+	lineJoin: DEFAULT_LINE_JOIN,
+	labelHeightCssPixels: 14
+});
+//#endregion
+//#region src/internal/angle-utils.ts
 /**
-* Centripetal Catmull-Rom spline through `points`, sampled `samples` times per
-* segment. Endpoints are duplicated so the curve passes through them, so the
-* first and last points are preserved exactly. With `samples <= 1` (or fewer
-* than 3 points) it returns the input unchanged.
+* Wraps an angle (radians) into the half-open range (-π, π].
 */
-function catmullRom(points, samples) {
-	if (points.length < 3 || samples <= 1) return points;
-	const pts = [
-		points[0],
-		...points,
-		points[points.length - 1]
-	];
-	const out = [points[0]];
-	for (let i = 1; i < pts.length - 2; i++) {
-		const p0 = pts[i - 1];
-		const p1 = pts[i];
-		const p2 = pts[i + 1];
-		const p3 = pts[i + 2];
-		for (let s = 1; s <= samples; s++) out.push(catmullRomAt(p0, p1, p2, p3, s / samples));
-	}
-	return out;
+function normalizeRadians(angle) {
+	let normalized = angle % (Math.PI * 2);
+	if (normalized > Math.PI) normalized -= Math.PI * 2;
+	if (normalized <= -Math.PI) normalized += Math.PI * 2;
+	return normalized;
+}
+/** Wraps a degree value into the canonical clockwise `[0, 360)` range. */
+function normalizeDegrees(degrees) {
+	return (degrees % 360 + 360) % 360;
 }
 /**
-* Closed centripetal Catmull-Rom: smooths a polygon ring through every vertex,
-* wrapping the control points around the seam. Returns a ring whose first and
-* last positions coincide (explicit closure). With `samples <= 1` (or fewer
-* than 3 points) it returns the input unchanged.
+* Flips a text rotation by π when it would otherwise read upside-down, keeping
+* the baseline pointing left-to-right (within ±90° of horizontal).
 */
-function closedCatmullRom(points, samples) {
-	const n = points.length;
-	if (n < 3 || samples <= 1) return points;
-	const out = [];
-	for (let i = 0; i < n; i++) {
-		const p0 = points[(i - 1 + n) % n];
-		const p1 = points[i];
-		const p2 = points[(i + 1) % n];
-		const p3 = points[(i + 2) % n];
-		for (let s = 0; s < samples; s++) out.push(catmullRomAt(p0, p1, p2, p3, s / samples));
-	}
-	out.push([...out[0]]);
-	return out;
+function keepTextLeftToRight(rotation) {
+	const normalized = normalizeRadians(rotation);
+	if (normalized > Math.PI / 2) return normalized - Math.PI;
+	if (normalized < -Math.PI / 2) return normalized + Math.PI;
+	return normalized;
 }
 //#endregion
 //#region src/internal/line-labels.ts
@@ -2981,7 +3538,7 @@ function createWireObstacle(positions, options, text, context, kind) {
 		features: [...features, ...labels]
 	};
 }
-function definition$1(id, name, kind) {
+function definition$2(id, name, kind) {
 	const spec = WIRE_KINDS[kind];
 	return defineControlMeasure({
 		metadata: {
@@ -3040,15 +3597,15 @@ function definition$1(id, name, kind) {
 		}
 	});
 }
-const WIRE_OBSTACLE_UNSPECIFIED = definition$1("wire-obstacle-unspecified", "Wire Obstacles – Unspecified", "unspecified");
-const SINGLE_FENCE = definition$1("single-fence", "Single Fence", "single");
-const DOUBLE_FENCE = definition$1("double-fence", "Double Fence", "double");
-const DOUBLE_APRON_FENCE = definition$1("double-apron-fence", "Double Apron Fence", "apron");
-const LOW_WIRE_FENCE = definition$1("low-wire-fence", "Low Wire Fence", "low");
-const HIGH_WIRE_FENCE = definition$1("high-wire-fence", "High Wire Fence", "high");
-const SINGLE_CONCERTINA = definition$1("single-concertina", "Single Concertina", "concertina");
-const DOUBLE_STRAND_CONCERTINA = definition$1("double-strand-concertina", "Double Strand Concertina", "double-concertina");
-const TRIPLE_STRAND_CONCERTINA = definition$1("triple-strand-concertina", "Triple Strand Concertina", "triple-concertina");
+const WIRE_OBSTACLE_UNSPECIFIED = definition$2("wire-obstacle-unspecified", "Wire Obstacles – Unspecified", "unspecified");
+const SINGLE_FENCE = definition$2("single-fence", "Single Fence", "single");
+const DOUBLE_FENCE = definition$2("double-fence", "Double Fence", "double");
+const DOUBLE_APRON_FENCE = definition$2("double-apron-fence", "Double Apron Fence", "apron");
+const LOW_WIRE_FENCE = definition$2("low-wire-fence", "Low Wire Fence", "low");
+const HIGH_WIRE_FENCE = definition$2("high-wire-fence", "High Wire Fence", "high");
+const SINGLE_CONCERTINA = definition$2("single-concertina", "Single Concertina", "concertina");
+const DOUBLE_STRAND_CONCERTINA = definition$2("double-strand-concertina", "Double Strand Concertina", "double-concertina");
+const TRIPLE_STRAND_CONCERTINA = definition$2("triple-strand-concertina", "Triple Strand Concertina", "triple-concertina");
 //#endregion
 //#region src/generators/cm34-mission-tasks/shared.ts
 /**
@@ -3861,12 +4418,26 @@ const ATTACK_SHAFT_PARAMS = [
 		key: "smoothResolution",
 		presentationTier: "advanced",
 		label: "Smooth resolution",
-		description: "Number of segments approximating each rounded bend when smooth mode is enabled.",
+		description: "Number of segments approximating each rounded bend when smooth mode is enabled. In curve style, each shaft segment is sampled at four times this resolution.",
 		type: "number",
 		min: 1,
 		max: 20,
 		step: 1,
 		visibleWhen: (opts) => opts.smooth === true
+	},
+	{
+		key: "smoothMode",
+		label: "Smooth style",
+		description: "Round only the corners where the shaft changes direction, or curve the whole shaft through the control points.",
+		type: "enum",
+		options: [{
+			label: "Rounded corners",
+			value: "rounded-corners"
+		}, {
+			label: "Curve",
+			value: "curve"
+		}],
+		visibleWhen: (opts) => opts.smooth === true
 	}
 ];
 const FIRE_ARROW_PARAMS = [
@@ -4104,12 +4675,7 @@ const AREA_TEXT_AMPLIFIERS_NO_ADDITIONAL_INFO = AREA_TEXT_AMPLIFIERS.filter((d)
 const AREA_TEXT_AMPLIFIERS_DESIGNATION_HOSTILE = AREA_TEXT_AMPLIFIERS.filter((d) => d.key === "T" || d.key === "N");
 //#endregion
 //#region src/generators/cm15-maneuver-areas/airborneAttack.ts
-const DEFAULT_AIRBORNE_ATTACK_OPTIONS = {
-	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
-	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
-	smooth: false,
-	smoothResolution: 5
-};
+const DEFAULT_AIRBORNE_ATTACK_OPTIONS = { ...DEFAULT_ATTACK_SHAFT_OPTIONS };
 const AIRBORNE_ATTACK_METADATA = {
 	id: "airborne-attack",
 	name: "Airborne Attack",
@@ -4145,8 +4711,7 @@ function createAirborneAttack(coordinates, options = {}) {
 		type: "FeatureCollection",
 		features: []
 	};
-	const shaftLeftToNeck = geometry.shaftLeft.slice(0, -1);
-	const shaftRightToNeck = geometry.shaftRight.slice(0, -1);
+	const { left: shaftLeftToNeck, right: shaftRightToNeck } = shaftEdgesToNeck(geometry);
 	return {
 		type: "FeatureCollection",
 		features: [{
@@ -4172,7 +4737,8 @@ const AIRBORNE_ATTACK = defineControlMeasure({
 	generator: createAirborneAttack,
 	defaultOptions: DEFAULT_AIRBORNE_ATTACK_OPTIONS,
 	rule: axis1DrawRule,
-	optionHandles: variableWidthAttackOptionHandles
+	optionHandles: variableWidthAttackOptionHandles,
+	vertexAlignedOptions: VERTEX_WIDTH_ALIGNED_OPTIONS
 });
 /**
 * Reacts to an **input-contract** violation according to `mode`: `throw`
@@ -5187,7 +5753,7 @@ function projectRingPoints(positions) {
 */
 function buildClosedRing(positions, smooth, smoothResolution, defaultSmoothResolution) {
 	const ringPts = projectRingPoints(positions);
-	return smooth ? closedCatmullRom(ringPts, normalizeSmoothResolution$2(smoothResolution, defaultSmoothResolution)) : [...ringPts, ringPts[0]];
+	return smooth ? closedCatmullRom(ringPts, normalizeSmoothResolution$1(smoothResolution, defaultSmoothResolution)) : [...ringPts, ringPts[0]];
 }
 /**
 * Walks a closed ring into per-segment metadata (unit direction, outward
@@ -7319,10 +7885,7 @@ const ATTACK_BY_FIRE = defineControlMeasure({
 //#endregion
 //#region src/generators/cm15-maneuver-areas/attackHelicopter.ts
 const DEFAULT_ATTACK_HELICOPTER_OPTIONS = {
-	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
-	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
-	smooth: false,
-	smoothResolution: 5,
+	...DEFAULT_ATTACK_SHAFT_OPTIONS,
 	symbolHeightRatio: .45,
 	triangleSizeRatio: .25,
 	bottomBarWidthRatio: 1.5,
@@ -7405,15 +7968,14 @@ function createAttackHelicopter(coordinates, options = {}) {
 		type: "FeatureCollection",
 		features: []
 	};
-	const shaftLeftToNeck = geometry.shaftLeft.slice(0, -1);
-	const shaftRightToNeck = geometry.shaftRight.slice(0, -1);
 	if (geometry.shaftLeft.length < 2 || geometry.shaftRight.length < 2) return {
 		type: "FeatureCollection",
 		features: []
 	};
-	const pL = geometry.shaftLeft[geometry.shaftLeft.length - 2];
+	const { left: shaftLeftToNeck, right: shaftRightToNeck } = shaftEdgesToNeck(geometry);
+	const pL = shaftLeftToNeck.at(-1);
 	const pIR = geometry.headRing[3];
-	const pR = geometry.shaftRight[geometry.shaftRight.length - 2];
+	const pR = shaftRightToNeck.at(-1);
 	const pIL = geometry.headRing[5];
 	if (!pL || !pIR || !pR || !pIL) return {
 		type: "FeatureCollection",
@@ -7540,7 +8102,8 @@ const ATTACK_HELICOPTER = defineControlMeasure({
 	generator: createAttackHelicopter,
 	defaultOptions: DEFAULT_ATTACK_HELICOPTER_OPTIONS,
 	rule: axis1DrawRule,
-	optionHandles: variableWidthAttackOptionHandles
+	optionHandles: variableWidthAttackOptionHandles,
+	vertexAlignedOptions: VERTEX_WIDTH_ALIGNED_OPTIONS
 });
 //#endregion
 //#region src/generators/cm15-maneuver-areas/battlePosition.ts
@@ -8174,13 +8737,144 @@ const BRIDGE_OR_GAP = defineControlMeasure({
 	}
 });
 //#endregion
+//#region src/generators/cm27-protection-areas/roadblocks.ts
+/**
+* Angle the executed roadblock's crossing pair is rotated from the anchored
+* pair, swinging PT. 1's end toward PT. 3 — measured off the MIL-STD-2525E
+* example.
+*/
+const COMPLETE_CROSSING_ANGLE = 75 * Math.PI / 180;
+/** Intrinsic doctrinal dash pattern for the not-yet-emplaced lines. */
+const ROADBLOCK_DASH = [6, 4];
+const DEFAULT_ROADBLOCK_OPTIONS = {};
+const PREVIEW_POINTS$1 = [
+	[.35, .7],
+	[-.35, -.7],
+	[-.134, .067]
+];
+const ROADBLOCK_KINDS = {
+	planned: {
+		name: "Roadblock - Planned",
+		entitySubtype: "Planned",
+		previewPoints: PREVIEW_POINTS$1,
+		description: "A planned roadblock, crater, or blown bridge not yet emplaced."
+	},
+	safe: {
+		name: "Roadblock - Explosives, State of Readiness 1 (Safe)",
+		entitySubtype: "Explosives, State of Readiness 1 (Safe)",
+		previewPoints: PREVIEW_POINTS$1,
+		description: "A roadblock, crater, or blown bridge with explosives emplaced but not armed."
+	},
+	armed: {
+		name: "Roadblock - Explosives, State of Readiness 2 (Armed but Passable)",
+		entitySubtype: "Explosives, State of Readiness 2 (Armed but Passable)",
+		previewPoints: PREVIEW_POINTS$1,
+		description: "A roadblock, crater, or blown bridge with explosives armed; the route is still passable."
+	},
+	complete: {
+		name: "Roadblock Complete (Executed)",
+		entitySubtype: "Roadblock Complete (Executed)",
+		description: "An executed roadblock, crater, or blown bridge that blocks the route.",
+		previewPoints: [
+			[.45, .6],
+			[-.45, -.6],
+			[-.096, .072]
+		]
+	}
+};
+function linesFeature(part, lines, dashed) {
+	return {
+		type: "Feature",
+		properties: dashed ? {
+			part,
+			style: { strokeDash: [...ROADBLOCK_DASH] }
+		} : { part },
+		geometry: {
+			type: "MultiLineString",
+			coordinates: lines
+		}
+	};
+}
+/**
+* Generates a roadblock of the given subtype from PT. 1 and PT. 2 (centerline
+* endpoints) and PT. 3 (one side). The input contract is enforced at the render
+* seam (ADR-0014).
+*/
+function createRoadblock(coordinates, kind) {
+	const p1 = project(coordinates[0][0], coordinates[0][1]);
+	const p2 = project(coordinates[1][0], coordinates[1][1]);
+	const frame = createProjectedBaselineFrame(p1, p2, {
+		origin: "midpoint",
+		normal: "right"
+	});
+	if (!frame) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const distance = frame.signedNormalDistance(coordinates[2]);
+	const offset = vecScale(frame.normal, distance);
+	const near = [vecAdd(p1, offset), vecAdd(p2, offset)];
+	const far = [vecSub(p1, offset), vecSub(p2, offset)];
+	if (kind === "safe") return {
+		type: "FeatureCollection",
+		features: [linesFeature("dashed-side", [near.map(toPosition)], true), linesFeature("solid-side", [far.map(toPosition)], false)]
+	};
+	const features = [linesFeature("sides", [near.map(toPosition), far.map(toPosition)], kind === "planned")];
+	if (kind === "complete") {
+		const angle = (distance < 0 ? -1 : 1) * COMPLETE_CROSSING_ANGLE;
+		const center = frame.origin;
+		const rotated = (line) => line.map((point) => toPosition(vecAdd(center, vecRotate(vecSub(point, center), angle))));
+		features.push(linesFeature("crossing-sides", [rotated(near), rotated(far)], false));
+	}
+	return {
+		type: "FeatureCollection",
+		features
+	};
+}
+function definition$1(id, value, kind) {
+	const { name, entitySubtype, description, previewPoints } = ROADBLOCK_KINDS[kind];
+	return defineControlMeasure({
+		metadata: {
+			id,
+			name,
+			description,
+			entity: "Protection Areas",
+			colorRole: "obstacle",
+			entityType: "Roadblocks, Craters and Blown Bridges",
+			entitySubtype,
+			value,
+			minCoordinates: 3,
+			maxCoordinates: 3,
+			geometry: "line",
+			geometryTypes: ["MultiLineString"],
+			paints: {
+				stroke: true,
+				fill: "none",
+				text: false
+			},
+			drawRule: "Line12"
+		},
+		generator: (positions, _options = {}) => createRoadblock(positions, kind),
+		defaultOptions: DEFAULT_ROADBLOCK_OPTIONS,
+		rule: line12DrawRule,
+		previewSample: { controlPoints: previewPoints }
+	});
+}
+const ROADBLOCK_PLANNED = definition$1("roadblock-planned", "271201", "planned");
+const ROADBLOCK_EXPLOSIVES_SAFE = definition$1("roadblock-explosives-safe", "271202", "safe");
+const ROADBLOCK_EXPLOSIVES_ARMED = definition$1("roadblock-explosives-armed", "271203", "armed");
+const ROADBLOCK_COMPLETE = definition$1("roadblock-complete", "271204", "complete");
+//#endregion
 //#region src/generators/cm99-generic-arrows/blockArrow.ts
 const DEFAULT_SMOOTH_RESOLUTION$4 = 12;
-const MIN_SMOOTH_RESOLUTION$1 = 2;
-const MAX_SMOOTH_RESOLUTION$1 = 64;
 const DEFAULT_SHAFT_WIDTH_RATIO = .06;
 const MIN_SHAFT_WIDTH_RATIO = .01;
 const MAX_SHAFT_WIDTH_RATIO = .3;
+/**
+* Rear and per-vertex widths may flare well past the arrowhead; only the shaft
+* end, which meets the head, keeps the tighter shaft cap.
+*/
+const MAX_FLARE_WIDTH_RATIO = 1;
 const DEFAULT_BLOCK_ARROW_OPTIONS = {
 	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO,
 	rearWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO,
@@ -8189,6 +8883,7 @@ const DEFAULT_BLOCK_ARROW_OPTIONS = {
 	arrowheadLengthRatio: .22,
 	smooth: false,
 	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$4,
+	smoothMode: "curve",
 	filled: true
 };
 const BLOCK_ARROW_METADATA = {
@@ -8226,7 +8921,7 @@ const BLOCK_ARROW_METADATA = {
 			description: "Width at the rear of the shaft as a fraction of the total path length",
 			type: "number",
 			min: MIN_SHAFT_WIDTH_RATIO,
-			max: MAX_SHAFT_WIDTH_RATIO,
+			max: MAX_FLARE_WIDTH_RATIO,
 			step: .01
 		},
 		{
@@ -8288,20 +8983,34 @@ const BLOCK_ARROW_METADATA = {
 		{
 			key: "smooth",
 			label: "Smooth",
-			description: "Round the shaft's corners by curving it through the control points.",
+			description: "Curve the shaft through the control points, or round its corners.",
 			type: "boolean"
 		},
 		{
 			key: "smoothResolution",
 			presentationTier: "advanced",
 			label: "Smooth resolution",
-			description: "Number of samples per segment when smooth mode is enabled",
+			description: "Number of samples per segment when smooth mode is enabled. In rounded-corners style, the number of segments approximating each rounded corner.",
 			type: "number",
 			min: 2,
 			max: 64,
 			step: 1,
 			visibleWhen: (opts) => Boolean(opts.smooth)
 		},
+		{
+			key: "smoothMode",
+			label: "Smooth style",
+			description: "Curve the whole shaft through the control points, or round only the corners where it changes direction.",
+			type: "enum",
+			options: [{
+				label: "Curve",
+				value: "curve"
+			}, {
+				label: "Rounded corners",
+				value: "rounded-corners"
+			}],
+			visibleWhen: (opts) => Boolean(opts.smooth)
+		},
 		{
 			key: "filled",
 			label: "Filled",
@@ -8409,10 +9118,23 @@ function calculateBlockArrowGeometry(coordinates, options) {
 			];
 			break;
 	}
-	let spine = [...pts.slice(0, -1), onAxis(shaftEndDist)];
-	if (options.smooth) spine = catmullRom(spine, normalizeSmoothResolution$1(options.smoothResolution));
-	const widths = interpolatePolylineValues(spine, halfRear, halfShaft);
-	const { left: leftSide, right: rightSide } = offsetPolylineSides(spine, widths);
+	const authored = [...pts.slice(0, -1), onAxis(shaftEndDist)];
+	const samples = normalizeSmoothResolution$1(options.smoothResolution, DEFAULT_SMOOTH_RESOLUTION$4);
+	const curved = options.smooth && options.smoothMode === "curve";
+	const { spine, stride } = curved ? curveSpine(authored, samples) : {
+		spine: authored,
+		stride: 1
+	};
+	const { leftEdge: leftSide, rightEdge: rightSide, profile } = variableWidthShaft({
+		spine,
+		stride,
+		rearHalfWidth: halfRear,
+		baseHalfWidth: halfShaft,
+		ratios: resolveSpineWidthRatios(options, coordinates.length, MIN_SHAFT_WIDTH_RATIO, MAX_FLARE_WIDTH_RATIO),
+		ratioToHalfWidth: pathLength / 2,
+		rounded: options.smooth && !curved,
+		roundSegments: samples
+	});
 	const ring = [
 		...leftSide,
 		...headPts,
@@ -8421,10 +9143,9 @@ function calculateBlockArrowGeometry(coordinates, options) {
 	ring.push(ring[0]);
 	return {
 		ring,
-		spine,
-		leftSide,
 		rightSide,
-		pathLength
+		pathLength,
+		profile
 	};
 }
 function resolveBlockArrowOptions(options) {
@@ -8447,15 +9168,17 @@ const BLOCK_ARROW = defineControlMeasure({
 			const geometry = calculateBlockArrowGeometry(controlPoints, resolveBlockArrowOptions(options));
 			if (!geometry) return null;
 			return {
-				spine: geometry.spine,
+				profile: geometry.profile,
 				rightEdge: geometry.rightSide,
-				referenceHalfWidth: geometry.pathLength / 2
+				referenceHalfWidth: geometry.pathLength / 2,
+				controlPointCount: controlPoints.length
 			};
 		},
 		minRatio: MIN_SHAFT_WIDTH_RATIO,
-		maxRearRatio: MAX_SHAFT_WIDTH_RATIO,
+		maxRearRatio: MAX_FLARE_WIDTH_RATIO,
 		maxShaftRatio: MAX_SHAFT_WIDTH_RATIO
 	}),
+	vertexAlignedOptions: VERTEX_WIDTH_ALIGNED_OPTIONS,
 	previewSample: {
 		controlPoints: [
 			[1.4, 0],
@@ -8477,10 +9200,6 @@ function axis1Geometry(coordinates) {
 		...metrics && Math.abs(metrics.lateral) > 1e-6 ? { headHalfWidth: Math.abs(metrics.lateral) } : {}
 	};
 }
-function normalizeSmoothResolution$1(value) {
-	if (!Number.isFinite(value)) return DEFAULT_SMOOTH_RESOLUTION$4;
-	return Math.min(MAX_SMOOTH_RESOLUTION$1, Math.max(MIN_SMOOTH_RESOLUTION$1, Math.round(value)));
-}
 //#endregion
 //#region src/internal/line-echelon.ts
 /**
@@ -10119,7 +10838,7 @@ function createGenericLine(coordinates, options = {}) {
 		...DEFAULT_GENERIC_LINE_OPTIONS,
 		...options
 	};
-	const resolution = normalizeSmoothResolution$2(smoothResolution, 12);
+	const resolution = normalizeSmoothResolution$1(smoothResolution, 12);
 	return {
 		type: "FeatureCollection",
 		features: [{
@@ -10180,7 +10899,7 @@ function createGenericPolygon(coordinates, options = {}) {
 		...DEFAULT_GENERIC_POLYGON_OPTIONS,
 		...options
 	};
-	const resolution = normalizeSmoothResolution$2(smoothResolution, 12);
+	const resolution = normalizeSmoothResolution$1(smoothResolution, 12);
 	const ring = smooth ? closedCatmullRom(ringPoints, resolution) : [...ringPoints, ringPoints[0]];
 	return {
 		type: "FeatureCollection",
@@ -11097,10 +11816,7 @@ const DEFAULT_MANEUVER_ARROW_TASK_AMPLIFIER_OPTIONS = {
 	labelPadding: 0
 };
 const DEFAULT_MANEUVER_ARROW_TASK_OPTIONS = {
-	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
-	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
-	smooth: false,
-	smoothResolution: 5,
+	...DEFAULT_ATTACK_SHAFT_OPTIONS,
 	crossbarLengthRatio: 1.1,
 	...DEFAULT_MANEUVER_ARROW_TASK_AMPLIFIER_OPTIONS
 };
@@ -11166,8 +11882,9 @@ function createManeuverArrowTask(coordinates, options, textAmplifiers, config) {
 		const crossbarFrame = pointAlongPolyline(segments, totalLength, shaftPosition);
 		crossbarCenter = crossbarFrame.point;
 		crossbarAlong = crossbarFrame.along;
-		const rearWidth = vecMag(vecSub(geometry.shaftLeft[0], geometry.shaftRight[0]));
-		crossbarBaseWidth = rearWidth + (vecMag(vecSub(geometry.shaftLeft.at(-1), geometry.shaftRight.at(-1))) - rearWidth) * shaftPosition;
+		const { left, right } = geometry.shaftProfile;
+		const distances = cumulativeDistances(centerline);
+		crossbarBaseWidth = 2 * Math.max(valueAtFraction(distances, left, shaftPosition), valueAtFraction(distances, right, shaftPosition));
 	}
 	const crossbarLength = crossbarBaseWidth * Math.max(1, resolved.crossbarLengthRatio);
 	const crossbarPerp = [-crossbarAlong[1], crossbarAlong[0]];
@@ -11268,10 +11985,7 @@ const MANEUVER_ARROW_TASK_TEXT_AMPLIFIERS = [
 //#endregion
 //#region src/generators/cm15-maneuver-areas/supportingAttack.ts
 const DEFAULT_SUPPORTING_ATTACK_OPTIONS = {
-	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
-	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
-	smooth: false,
-	smoothResolution: 5,
+	...DEFAULT_ATTACK_SHAFT_OPTIONS,
 	...DEFAULT_MANEUVER_ARROW_TASK_AMPLIFIER_OPTIONS
 };
 const SUPPORTING_ATTACK_METADATA = {
@@ -11346,6 +12060,7 @@ const SUPPORTING_ATTACK = defineControlMeasure({
 	defaultOptions: DEFAULT_SUPPORTING_ATTACK_OPTIONS,
 	rule: axis1DrawRule,
 	optionHandles: variableWidthAttackOptionHandles,
+	vertexAlignedOptions: VERTEX_WIDTH_ALIGNED_OPTIONS,
 	previewSample: {
 		controlPoints: [
 			[1, 0],
@@ -11364,10 +12079,7 @@ const SUPPORTING_ATTACK = defineControlMeasure({
 //#endregion
 //#region src/generators/cm34-mission-tasks/counterattack.ts
 const DEFAULT_COUNTERATTACK_OPTIONS = {
-	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
-	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
-	smooth: false,
-	smoothResolution: 5,
+	...DEFAULT_ATTACK_SHAFT_OPTIONS,
 	labelPosition: 1
 };
 /** Intrinsic dash and gap lengths for the complete Counterattack outline. */
@@ -11457,6 +12169,7 @@ const COUNTERATTACK = defineControlMeasure({
 	defaultOptions: DEFAULT_COUNTERATTACK_OPTIONS,
 	rule: axis1DrawRule,
 	optionHandles: variableWidthAttackOptionHandles,
+	vertexAlignedOptions: VERTEX_WIDTH_ALIGNED_OPTIONS,
 	previewSample: {
 		controlPoints: [
 			[1, 0],
@@ -11618,6 +12331,7 @@ const COUNTERATTACK_BY_FIRE = defineControlMeasure({
 	defaultOptions: DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS,
 	rule: counterattackByFireDrawRule,
 	optionHandles: createVariableWidthAttackOptionHandles(counterattackByFireBodyCoordinates),
+	vertexAlignedOptions: VERTEX_WIDTH_ALIGNED_OPTIONS,
 	previewSample: {
 		controlPoints: [
 			[1.35, 0],
@@ -15256,7 +15970,7 @@ function createFortifiedLine(positions, options = {}, textAmplifiers = {}, conte
 	const { smooth = DEFAULT_FORTIFIED_LINE_OPTIONS.smooth, smoothResolution = DEFAULT_FORTIFIED_LINE_OPTIONS.smoothResolution } = options;
 	const safeSize = calculateEffectiveSize(options);
 	const projectedPoints = positions.map((p) => project(p[0], p[1]));
-	const smoothedPath = smooth ? catmullRom(projectedPoints, normalizeSmoothResolution$2(smoothResolution, DEFAULT_SMOOTH_RESOLUTION$1)) : projectedPoints;
+	const smoothedPath = smooth ? catmullRom(projectedPoints, normalizeSmoothResolution$1(smoothResolution, DEFAULT_SMOOTH_RESOLUTION$1)) : projectedPoints;
 	const feature = {
 		type: "Feature",
 		properties: {},
@@ -15333,7 +16047,7 @@ function createFortifiedArea(positions, options = {}, textAmplifiers = {}, conte
 	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 ? evenlySpacePath(closedCatmullRom(ringPts, normalizeSmoothResolution$2(smoothResolution, DEFAULT_FORTIFIED_AREA_OPTIONS.smoothResolution)), 2 * safeSize) : [...ringPts, ringPts[0]];
+	const boundaryInput = smooth ? evenlySpacePath(closedCatmullRom(ringPts, normalizeSmoothResolution$1(smoothResolution, DEFAULT_FORTIFIED_AREA_OPTIONS.smoothResolution)), 2 * safeSize) : [...ringPts, ringPts[0]];
 	const boundaryPoints = generateFortifiedPoints(boundaryInput, safeSize);
 	if (boundaryPoints.length > 0) {
 		const firstPt = boundaryPoints[0];
@@ -15413,6 +16127,7 @@ const FRONTAL_ATTACK = defineControlMeasure({
 	defaultOptions: DEFAULT_FRONTAL_ATTACK_OPTIONS,
 	rule: axis1DrawRule,
 	optionHandles: variableWidthAttackOptionHandles,
+	vertexAlignedOptions: VERTEX_WIDTH_ALIGNED_OPTIONS,
 	previewSample: {
 		controlPoints: [
 			[1, 0],
@@ -15478,10 +16193,7 @@ const MOVEMENT_TO_CONTACT_BOLT_HANDLE_ID = "bolt-tip";
 const MOVEMENT_TO_CONTACT_STEM_SETBACK_RATIO = .22;
 const MOVEMENT_TO_CONTACT_STEM_OFFSET_RATIO = .55;
 const DEFAULT_MOVEMENT_TO_CONTACT_OPTIONS = {
-	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
-	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
-	smooth: false,
-	smoothResolution: 5,
+	...DEFAULT_ATTACK_SHAFT_OPTIONS,
 	...DEFAULT_TACTICAL_ARROW_OPTIONS,
 	...DEFAULT_MANEUVER_ARROW_TASK_AMPLIFIER_OPTIONS,
 	boltLengthRatio: MOVEMENT_TO_CONTACT_BOLT_LENGTH_RATIO,
@@ -15625,8 +16337,8 @@ const MOVEMENT_TO_CONTACT = defineControlMeasure({
 	defaultOptions: DEFAULT_MOVEMENT_TO_CONTACT_OPTIONS,
 	rule: axis1DrawRule,
 	optionHandles: {
-		get(controlPoints, options) {
-			const widthHandles = variableWidthAttackOptionHandles.get(controlPoints, options);
+		get(controlPoints, options, query) {
+			const widthHandles = variableWidthAttackOptionHandles.get(controlPoints, options, query);
 			const resolved = resolveMovementToContactGeometry(controlPoints, options);
 			if (!resolved) return widthHandles;
 			return [...widthHandles, {
@@ -15647,8 +16359,12 @@ const MOVEMENT_TO_CONTACT = defineControlMeasure({
 				boltLengthRatio: length / resolved.arrowBaseWidth,
 				boltAngle: clamp(Math.abs(Math.atan2(cross, dot) * 180 / Math.PI), 0, 90)
 			};
+		},
+		reset(event) {
+			return variableWidthAttackOptionHandles.reset?.(event);
 		}
 	},
+	vertexAlignedOptions: VERTEX_WIDTH_ALIGNED_OPTIONS,
 	previewSample: {
 		controlPoints: [
 			[1, 0],
@@ -17244,10 +17960,7 @@ const NO_FIRE_AREA_IRREGULAR = defineControlMeasure({
 //#endregion
 //#region src/generators/cm15-maneuver-areas/mainAttack.ts
 const DEFAULT_MAIN_ATTACK_OPTIONS = {
-	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO$1,
-	rearWidthRatio: DEFAULT_REAR_WIDTH_RATIO,
-	smooth: false,
-	smoothResolution: 5,
+	...DEFAULT_ATTACK_SHAFT_OPTIONS,
 	...DEFAULT_MANEUVER_ARROW_TASK_AMPLIFIER_OPTIONS
 };
 const MAIN_ATTACK_METADATA = {
@@ -17317,6 +18030,7 @@ const MAIN_ATTACK = defineControlMeasure({
 	defaultOptions: DEFAULT_MAIN_ATTACK_OPTIONS,
 	rule: axis1DrawRule,
 	optionHandles: variableWidthAttackOptionHandles,
+	vertexAlignedOptions: VERTEX_WIDTH_ALIGNED_OPTIONS,
 	previewSample: {
 		controlPoints: [
 			[1, 0],
@@ -19789,6 +20503,7 @@ const DEFINITIONS = {
 		defaultOptions: DEFAULT_TURNING_MOVEMENT_OPTIONS,
 		rule: axis1DrawRule,
 		optionHandles: variableWidthAttackOptionHandles,
+		vertexAlignedOptions: VERTEX_WIDTH_ALIGNED_OPTIONS,
 		previewSample: {
 			controlPoints: [
 				[1, 0],
@@ -19806,6 +20521,10 @@ const DEFINITIONS = {
 	}),
 	block: BLOCK,
 	"bridge-or-gap": BRIDGE_OR_GAP,
+	"roadblock-planned": ROADBLOCK_PLANNED,
+	"roadblock-explosives-safe": ROADBLOCK_EXPLOSIVES_SAFE,
+	"roadblock-explosives-armed": ROADBLOCK_EXPLOSIVES_ARMED,
+	"roadblock-complete": ROADBLOCK_COMPLETE,
 	disrupt: DISRUPT,
 	fix: FIX,
 	"fix-mission-task": FIX_MISSION_TASK,