@orbat-mapper/control-measures 0.28.0 → 0.29.1

package/dist/{renderControlMeasure-D1kIdove.mjs → renderControlMeasure-DsTDL15-.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]];
@@ -1353,11 +1484,486 @@ 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;
+}
+/**
+* Samples one centripetal (alpha = 0.5) Catmull-Rom segment from `p1` to `p2`
+* at `t = s / samples` for `s` in `[first, last]`, appending to `out`. Uses the
+* Hermite form (Yuksel et al.); centripetal knots keep the curve from
+* overshooting or looping next to a much shorter neighbouring segment.
+*/
+function sampleCatmullRomSegment(out, [p0, p1, p2, p3], samples, first, last) {
+	const knot = (a, b) => Math.sqrt(vecMag(vecSub(b, a)));
+	const d1 = knot(p1, p2);
+	const d0 = knot(p0, p1) || d1;
+	const d2 = knot(p2, p3) || d1;
+	const tangent = (a, b, c, da, db) => d1 < 1e-12 ? [0, 0] : [((b[0] - a[0]) / da - (c[0] - a[0]) / (da + db) + (c[0] - b[0]) / db) * d1, ((b[1] - a[1]) / da - (c[1] - a[1]) / (da + db) + (c[1] - b[1]) / db) * d1];
+	const m1 = tangent(p0, p1, p2, d0, d1);
+	const m2 = tangent(p1, p2, p3, d1, d2);
+	for (let s = first; s <= last; s++) {
+		const t = s / samples;
+		const t2 = t * t;
+		const t3 = t2 * t;
+		const h00 = 2 * t3 - 3 * t2 + 1;
+		const h10 = t3 - 2 * t2 + t;
+		const h01 = -2 * t3 + 3 * t2;
+		const h11 = t3 - t2;
+		out.push([h00 * p1[0] + h10 * m1[0] + h01 * p2[0] + h11 * m2[0], h00 * p1[1] + h10 * m1[1] + h01 * p2[1] + h11 * m2[1]]);
+	}
+}
+/**
+* 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. An `endDirection` instead makes
+* the curve arrive at the last point heading that way. With `samples <= 1` (or
+* fewer than 3 points) it returns the input unchanged.
+*/
+function catmullRom(points, samples, endDirection) {
+	if (points.length < 3 || samples <= 1) return points;
+	const last = points[points.length - 1];
+	const beforeLast = points[points.length - 2];
+	const reach = vecMag(vecSub(last, beforeLast));
+	const end = endDirection ? [last[0] + endDirection[0] * reach, last[1] + endDirection[1] * reach] : last;
+	const pts = [
+		points[0],
+		...points,
+		end
+	];
+	const out = [points[0]];
+	for (let i = 1; i < pts.length - 2; i++) sampleCatmullRomSegment(out, [
+		pts[i - 1],
+		pts[i],
+		pts[i + 1],
+		pts[i + 2]
+	], samples, 1, 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++) sampleCatmullRomSegment(out, [
+		points[(i - 1 + n) % n],
+		points[i],
+		points[(i + 1) % n],
+		points[(i + 2) % n]
+	], samples, 0, samples - 1);
+	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, endDirection) {
+	if (authored.length < 3 || samples < 2) return {
+		spine: authored,
+		stride: 1
+	};
+	return {
+		spine: catmullRom(authored, samples, endDirection),
+		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";
 /**
@@ -1368,30 +1974,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);
 		}
 	};
 }
@@ -1410,9 +2058,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,
@@ -1429,11 +2078,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;
@@ -1447,9 +2133,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));
@@ -1502,15 +2188,48 @@ 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), tipDir) : {
+		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
+	});
+	shaftLeft[shaftLeft.length - 1] = innerLeft;
+	shaftRight[shaftRight.length - 1] = innerRight;
 	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)
 	};
 }
 /**
@@ -1877,162 +2596,6 @@ function keepTextLeftToRight(rotation) {
 	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)
-}];
-/**
-* Applies {@link SmoothLineOptions} to projected vertices `verts`: runs
-* {@link catmullRom} at the resolved (clamped) sample resolution when `smooth`
-* is set, else returns `verts` unchanged.
-*/
-function smoothLineVerts(verts, options, defaultResolution) {
-	return options.smooth ? catmullRom(verts, normalizeSmoothResolution$2(options.smoothResolution ?? defaultResolution, defaultResolution)) : verts;
-}
-/**
-* Resamples a path into equal arc-length segments.
-*
-* This is useful for a repeated motif (such as a fortified tooth or FLOT
-* scallop) after smoothing. Catmull-Rom samples are evenly spaced in spline
-* parameter, not distance, so using them directly as motif boundaries causes
-* the motifs to bunch up where the curve's samples are closer together.
-*/
-function evenlySpacePath(points, targetSegmentLength) {
-	if (points.length < 2) return points;
-	const segmentLengths = [];
-	let totalLength = 0;
-	for (let i = 0; i < points.length - 1; i++) {
-		const length = vecMag(vecSub(points[i + 1], points[i]));
-		segmentLengths.push(length);
-		totalLength += length;
-	}
-	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/line-labels.ts
 /**
 * Stored label rotation for text running along projected direction `dir`.
@@ -3879,12 +4442,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 = [
@@ -4122,12 +4699,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",
@@ -4163,8 +4735,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: [{
@@ -4190,7 +4761,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`
@@ -5205,7 +5777,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
@@ -7337,10 +7909,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,
@@ -7423,15 +7992,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",
@@ -7558,7 +8126,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
@@ -8322,11 +8891,14 @@ const ROADBLOCK_COMPLETE = definition$1("roadblock-complete", "271204", "complet
 //#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,
@@ -8335,6 +8907,7 @@ const DEFAULT_BLOCK_ARROW_OPTIONS = {
 	arrowheadLengthRatio: .22,
 	smooth: false,
 	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$4,
+	smoothMode: "curve",
 	filled: true
 };
 const BLOCK_ARROW_METADATA = {
@@ -8372,7 +8945,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
 		},
 		{
@@ -8434,20 +9007,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",
@@ -8555,10 +9142,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,
@@ -8567,10 +9167,9 @@ function calculateBlockArrowGeometry(coordinates, options) {
 	ring.push(ring[0]);
 	return {
 		ring,
-		spine,
-		leftSide,
 		rightSide,
-		pathLength
+		pathLength,
+		profile
 	};
 }
 function resolveBlockArrowOptions(options) {
@@ -8593,15 +9192,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],
@@ -8623,10 +9224,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
 /**
@@ -10265,7 +10862,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: [{
@@ -10326,7 +10923,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",
@@ -11243,10 +11840,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
 };
@@ -11312,8 +11906,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]];
@@ -11414,10 +12009,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 = {
@@ -11492,6 +12084,7 @@ const SUPPORTING_ATTACK = defineControlMeasure({
 	defaultOptions: DEFAULT_SUPPORTING_ATTACK_OPTIONS,
 	rule: axis1DrawRule,
 	optionHandles: variableWidthAttackOptionHandles,
+	vertexAlignedOptions: VERTEX_WIDTH_ALIGNED_OPTIONS,
 	previewSample: {
 		controlPoints: [
 			[1, 0],
@@ -11510,10 +12103,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. */
@@ -11603,6 +12193,7 @@ const COUNTERATTACK = defineControlMeasure({
 	defaultOptions: DEFAULT_COUNTERATTACK_OPTIONS,
 	rule: axis1DrawRule,
 	optionHandles: variableWidthAttackOptionHandles,
+	vertexAlignedOptions: VERTEX_WIDTH_ALIGNED_OPTIONS,
 	previewSample: {
 		controlPoints: [
 			[1, 0],
@@ -11764,6 +12355,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],
@@ -15402,7 +15994,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: {},
@@ -15479,7 +16071,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];
@@ -15559,6 +16151,7 @@ const FRONTAL_ATTACK = defineControlMeasure({
 	defaultOptions: DEFAULT_FRONTAL_ATTACK_OPTIONS,
 	rule: axis1DrawRule,
 	optionHandles: variableWidthAttackOptionHandles,
+	vertexAlignedOptions: VERTEX_WIDTH_ALIGNED_OPTIONS,
 	previewSample: {
 		controlPoints: [
 			[1, 0],
@@ -15624,10 +16217,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,
@@ -15771,8 +16361,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, {
@@ -15793,8 +16383,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],
@@ -17390,10 +17984,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 = {
@@ -17463,6 +18054,7 @@ const MAIN_ATTACK = defineControlMeasure({
 	defaultOptions: DEFAULT_MAIN_ATTACK_OPTIONS,
 	rule: axis1DrawRule,
 	optionHandles: variableWidthAttackOptionHandles,
+	vertexAlignedOptions: VERTEX_WIDTH_ALIGNED_OPTIONS,
 	previewSample: {
 		controlPoints: [
 			[1, 0],
@@ -19935,6 +20527,7 @@ const DEFINITIONS = {
 		defaultOptions: DEFAULT_TURNING_MOVEMENT_OPTIONS,
 		rule: axis1DrawRule,
 		optionHandles: variableWidthAttackOptionHandles,
+		vertexAlignedOptions: VERTEX_WIDTH_ALIGNED_OPTIONS,
 		previewSample: {
 			controlPoints: [
 				[1, 0],