@orbat-mapper/tactical-draw 0.2.0-alpha.4 → 0.2.0-alpha.5

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { cloneControlMeasure, controlMeasureIdFromFeature, getControlMeasureMetadata, renderControlMeasure, resolveStyleHints, roundToFixed } from "@orbat-mapper/control-measures";
+import { cloneControlMeasure, controlMeasureIdFromFeature, freezeOrientationOptions, getControlMeasureMetadata, renderControlMeasure, resolveStyleHints, roundToFixed } from "@orbat-mapper/control-measures";
 //#region src/base-map-adapter.ts
 /**
 * Abstract base class shared by all `MapAdapter` implementations.
@@ -773,6 +773,82 @@ function roundControlPoints(points) {
 	return points.map(roundControlPoint);
 }
 //#endregion
+//#region src/tactical-draw/guide.ts
+/**
+* Stable preview-layer ids and emission rules for the rubber-band guide
+* (ADR-0004). Shared between `td.draw` and `td.edit` so hosts can apply a
+* single styling rule across both interactions.
+*/
+const PREVIEW_GUIDE_FEATURE_PREFIX = "__td_preview__";
+const PREVIEW_GUIDE_OPEN_ID = `${PREVIEW_GUIDE_FEATURE_PREFIX}:guide:open`;
+const PREVIEW_GUIDE_CLOSING_ID = `${PREVIEW_GUIDE_FEATURE_PREFIX}:guide:closing`;
+/**
+* A kind is fixed-length when its draw rule pins the slot count
+* (`canonicalPointCount`) or its metadata declares `min === max`. The
+* generator preview is already authoritative for these, so the rubber-band
+* guide adds no information.
+*/
+function isFixedLength(metadata) {
+	if (metadata.rule?.canonicalPointCount !== void 0) return true;
+	const min = metadata.minCoordinates;
+	const max = metadata.maxCoordinates;
+	return typeof min === "number" && typeof max === "number" && min === max;
+}
+/**
+* Guide is mechanically suppressed for kinds where it carries no information:
+* point kinds and fixed-length kinds. Independent of the host's `guide`
+* opt-out.
+*/
+function shouldSuppressGuide(metadata) {
+	if (metadata.geometry === "point") return true;
+	if (metadata.rule?.showGuide === true) return false;
+	return isFixedLength(metadata);
+}
+/**
+* Build the guide LineString features for a point list.
+*  - Open polyline through `points` once `points.length >= 2`.
+*  - Closing segment `[last, first]` for area kinds once `points.length >= 3`.
+*
+* Callers are responsible for the opt-out (`guide: false`) and the suppression
+* check via [[shouldSuppressGuide]] — this function only emits geometry.
+*/
+function buildGuideFeatures(points, isAreaKind, trailingFixedSlots = 0) {
+	const features = [];
+	const spine = trailingFixedSlots > 0 ? points.slice(0, points.length - trailingFixedSlots) : points;
+	if (spine.length >= 2) {
+		const open = {
+			type: "Feature",
+			id: PREVIEW_GUIDE_OPEN_ID,
+			geometry: {
+				type: "LineString",
+				coordinates: spine.slice()
+			},
+			properties: {
+				part: "guide",
+				segment: "open"
+			}
+		};
+		features.push(open);
+	}
+	const alreadyClosed = spine.length >= 2 && spine[0][0] === spine[spine.length - 1][0] && spine[0][1] === spine[spine.length - 1][1];
+	if (isAreaKind && spine.length >= 3 && !alreadyClosed) {
+		const closing = {
+			type: "Feature",
+			id: PREVIEW_GUIDE_CLOSING_ID,
+			geometry: {
+				type: "LineString",
+				coordinates: [spine[spine.length - 1], spine[0]]
+			},
+			properties: {
+				part: "guide",
+				segment: "closing"
+			}
+		};
+		features.push(closing);
+	}
+	return features;
+}
+//#endregion
 //#region src/tactical-draw/draw-controller.ts
 const PREVIEW_CM_ID$1 = "__td_preview__";
 const PREVIEW_CURSOR$1 = "crosshair";
@@ -790,7 +866,7 @@ const PREVIEW_CURSOR$1 = "crosshair";
 * kinds need no host UI.
 */
 function runFixedLengthDraw(options) {
-	const { adapter, kind, previewLayer, graphicsStyle, generateId, signal, measureOptions, measureStyle, measureProperties, sizeAnchor, onSettled } = options;
+	const { adapter, kind, previewLayer, guideLayer, graphicsStyle, generateId, signal, measureOptions, measureStyle, measureProperties, guide: guideOpt, sizeAnchor, onSettled } = options;
 	const metadata = getControlMeasureMetadata(kind);
 	const rule = metadata.rule;
 	const min = metadata.minCoordinates;
@@ -800,6 +876,8 @@ function runFixedLengthDraw(options) {
 	else if (typeof min === "number" && typeof max === "number" && min === max) required = min;
 	else throw new Error(`runFixedLengthDraw: kind "${kind}" is not fixed-length (min=${min}, max=${max})`);
 	const renderOpts = graphicsStyle ? { graphicsStyle } : void 0;
+	const guideEnabled = (guideOpt ?? true) && !shouldSuppressGuide(metadata);
+	const isAreaKind = metadata.geometry === "area";
 	const committed = [];
 	let rubberBand;
 	let ctx;
@@ -824,11 +902,15 @@ function runFixedLengthDraw(options) {
 		const raw = rubberBand !== void 0 ? [...committed, rubberBand] : [...committed];
 		if (raw.length === 0) {
 			ctx.writeLayer(previewLayer, []);
+			ctx.writeLayer(guideLayer, []);
 			return;
 		}
 		const previewThreshold = rule?.minimumPreviewPoints ?? required;
 		const features = buildPreviewFeatures$1(adapter, kind, rule && raw.length >= previewThreshold ? rule.derive(raw) : raw, measureOptions, measureStyle, renderOpts);
 		ctx.writeLayer(previewLayer, features);
+		const guidePoints = rule?.guidePoints ? rule.guidePoints(raw) : raw;
+		const guideFeatures = guideEnabled ? buildGuideFeatures(guidePoints, isAreaKind) : [];
+		ctx.writeLayer(guideLayer, guideFeatures);
 	}
 	function rescaleOnViewChange() {
 		if (!measureUsesAdapterResolution({
@@ -856,7 +938,7 @@ function runFixedLengthDraw(options) {
 	return runInteraction({
 		adapter,
 		signal,
-		layers: [previewLayer],
+		layers: [previewLayer, guideLayer],
 		onViewChange: rescaleOnViewChange,
 		onSettled,
 		attach(c) {
@@ -915,79 +997,6 @@ function outlinePreview$1(points) {
 	return features;
 }
 //#endregion
-//#region src/tactical-draw/guide.ts
-/**
-* Stable preview-layer ids and emission rules for the rubber-band guide
-* (ADR-0004). Shared between `td.draw` and `td.edit` so hosts can apply a
-* single styling rule across both interactions.
-*/
-const PREVIEW_GUIDE_FEATURE_PREFIX = "__td_preview__";
-const PREVIEW_GUIDE_OPEN_ID = `${PREVIEW_GUIDE_FEATURE_PREFIX}:guide:open`;
-const PREVIEW_GUIDE_CLOSING_ID = `${PREVIEW_GUIDE_FEATURE_PREFIX}:guide:closing`;
-/**
-* A kind is fixed-length when its draw rule pins the slot count
-* (`canonicalPointCount`) or its metadata declares `min === max`. The
-* generator preview is already authoritative for these, so the rubber-band
-* guide adds no information.
-*/
-function isFixedLength(metadata) {
-	if (metadata.rule?.canonicalPointCount !== void 0) return true;
-	const min = metadata.minCoordinates;
-	const max = metadata.maxCoordinates;
-	return typeof min === "number" && typeof max === "number" && min === max;
-}
-/**
-* Guide is mechanically suppressed for kinds where it carries no information:
-* point kinds and fixed-length kinds. Independent of the host's `guide`
-* opt-out.
-*/
-function shouldSuppressGuide(metadata) {
-	return metadata.geometry === "point" || isFixedLength(metadata);
-}
-/**
-* Build the guide LineString features for a point list.
-*  - Open polyline through `points` once `points.length >= 2`.
-*  - Closing segment `[last, first]` for area kinds once `points.length >= 3`.
-*
-* Callers are responsible for the opt-out (`guide: false`) and the suppression
-* check via [[shouldSuppressGuide]] — this function only emits geometry.
-*/
-function buildGuideFeatures(points, isAreaKind, trailingFixedSlots = 0) {
-	const features = [];
-	const spine = trailingFixedSlots > 0 ? points.slice(0, points.length - trailingFixedSlots) : points;
-	if (spine.length >= 2) {
-		const open = {
-			type: "Feature",
-			id: PREVIEW_GUIDE_OPEN_ID,
-			geometry: {
-				type: "LineString",
-				coordinates: spine.slice()
-			},
-			properties: {
-				part: "guide",
-				segment: "open"
-			}
-		};
-		features.push(open);
-	}
-	if (isAreaKind && spine.length >= 3) {
-		const closing = {
-			type: "Feature",
-			id: PREVIEW_GUIDE_CLOSING_ID,
-			geometry: {
-				type: "LineString",
-				coordinates: [spine[spine.length - 1], spine[0]]
-			},
-			properties: {
-				part: "guide",
-				segment: "closing"
-			}
-		};
-		features.push(closing);
-	}
-	return features;
-}
-//#endregion
 //#region src/tactical-draw/draw-controller-variable.ts
 const PREVIEW_CM_ID = "__td_preview__";
 const PREVIEW_CURSOR = "crosshair";
@@ -1251,63 +1260,14 @@ function outlinePreview(points) {
 //#endregion
 //#region src/tactical-draw/handles.ts
 /**
-* Compute the anchor used by translate and rotate handles. The anchor is the
-* centroid (arithmetic mean) of the control-point list — stable, kind
-* agnostic, and well-defined for any non-empty point set.
-*/
-function computeHandleAnchor(controlPoints) {
-	if (controlPoints.length === 0) return null;
-	let sx = 0;
-	let sy = 0;
-	for (const p of controlPoints) {
-		sx += p[0];
-		sy += p[1];
-	}
-	return [sx / controlPoints.length, sy / controlPoints.length];
-}
-/**
-* How far past the outermost control point the rotate grip sits. `1.3` places
-* it 30% beyond the farthest vertex, clearing the geometry while staying
-* proportional to the shape's size.
-*/
-const ROTATE_HANDLE_REACH_FACTOR = 1.3;
-/**
-* Position of the rotate grip. Unlike the translate handle — which sits on the
-* centroid pivot — the rotate handle needs a lever arm, so it is offset from
-* the centroid along the ray toward the control point farthest from it, just
-* outside the shape. Anchoring to a *material* point (rather than the
-* axis-aligned bbox top) keeps this stateless yet glued to the geometry: the
-* grip orbits with the shape as it rotates, since the farthest vertex rotates
-* with it. Falls back to the centroid when every point coincides (no
-* well-defined direction) or the list is empty.
-*/
-function computeRotateHandlePosition(controlPoints) {
-	const anchor = computeHandleAnchor(controlPoints);
-	if (!anchor) return null;
-	let farthest = null;
-	let maxDistSq = 0;
-	for (const p of controlPoints) {
-		const dx = p[0] - anchor[0];
-		const dy = p[1] - anchor[1];
-		const distSq = dx * dx + dy * dy;
-		if (distSq > maxDistSq) {
-			maxDistSq = distSq;
-			farthest = p;
-		}
-	}
-	if (!farthest) return anchor;
-	return [anchor[0] + (farthest[0] - anchor[0]) * ROTATE_HANDLE_REACH_FACTOR, anchor[1] + (farthest[1] - anchor[1]) * ROTATE_HANDLE_REACH_FACTOR];
-}
-/**
 * Axis-aligned bounding-box center of the control points — the midpoint of
-* `[minX, maxX] × [minY, maxY]`. Used as the rotation pivot so a shape turns
-* about its visual middle (matching mainstream drawing tools) rather than the
-* vertex mean (`computeHandleAnchor`), which is pulled off-center on asymmetric
-* measures. Returns `null` for an empty list.
+* `[minX, maxX] × [minY, maxY]`. Used as the fallback rotation pivot for the
+* `COMMIT_ROTATE_FOR_TEST` seam when no transform box exists yet (e.g. before
+* the first paint), matching mainstream drawing tools' "turn about the visual
+* middle" convention. Returns `null` for an empty list.
 *
-* Exported because the rotation pivot is *not* a handle: it is the rotation
-* center, distinct from the rotate grip's lever-arm position. The edit
-* controller computes it directly at drag-start. See ADR-0016.
+* Exported because the rotation pivot is *not* a handle — the edit controller
+* consults it directly. See ADR-0016/ADR-0017.
 */
 function computeBoundingBoxCenter(controlPoints) {
 	if (controlPoints.length === 0) return null;
@@ -1333,23 +1293,23 @@ function segmentMidpoint(a, b) {
 	return [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
 }
 /**
-* The single source of truth for edit-handle placement and the
-* `EditMode → which handles` gating (ADR-0016). Pure and projection-free:
-* positions are lonLat. Handles are emitted in **pick priority order** —
-* `[vertices…, midpoints…, translate, rotate]` — so `pickHandle` can return the
-* first within tolerance and preserve "vertex wins over a pixel-closer
+* The single source of truth for reshape-handle placement and the
+* `EditMode → which handles` gating (ADR-0016, narrowed by ADR-0017). Pure and
+* projection-free: positions are lonLat. Handles are emitted in **pick
+* priority order** — `[vertices…, midpoints…]` — so `pickHandle` can return
+* the first within tolerance and preserve "vertex wins over a pixel-closer
 * midpoint." Rendering (`toFeatures`) and picking (`pickHandle`) are thin
 * projections of this set; the drag controller seeds gestures from it too.
 *
 * Emits handles only for modes present in `modes`:
 *  - `reshape`: vertex handle at every control point + midpoint handle on
 *    every adjacent pair (subject to `includeMidpoints` / `trailingFixedSlots`);
-*  - `delete`: vertex handles only (tapped to remove), no midpoint/grips;
-*  - `translate`: a single translate handle at the centroid anchor;
-*  - `rotate`: a single rotate grip offset outside the shape.
+*  - `delete`: vertex handles only (tapped to remove), no midpoints.
 *
-* `scale` is a reserved enum value rejected at the façade boundary — no handles
-* are emitted for it here. Returns `[]` for an empty control-point list.
+* `transform` mode never contributes handles here — the box's corner/rotate
+* grips are pixel-space and placed by `transform-box.ts`, then rendered as
+* `Handle`s of kind `scale`/`rotate` by the edit controller. Returns `[]` for
+* an empty control-point list.
 */
 function buildHandleSet(controlPoints, modes, options = {}) {
 	const { includeMidpoints = true, trailingFixedSlots = 0, closedRing = false } = options;
@@ -1373,29 +1333,13 @@ function buildHandleSet(controlPoints, modes, options = {}) {
 			}
 		}
 	}
-	if (modes.includes("translate")) {
-		const anchor = computeHandleAnchor(controlPoints);
-		if (anchor) handles.push({
-			kind: "translate",
-			index: 0,
-			position: anchor
-		});
-	}
-	if (modes.includes("rotate")) {
-		const rotatePos = computeRotateHandlePosition(controlPoints);
-		if (rotatePos) handles.push({
-			kind: "rotate",
-			index: 0,
-			position: rotatePos
-		});
-	}
 	return handles;
 }
 function handleFeatureId(prefix, kind, index) {
 	switch (kind) {
 		case "vertex": return `${prefix}:handle-vertex:${index}`;
 		case "midpoint": return `${prefix}:handle-midpoint:${index}`;
-		case "translate": return `${prefix}:handle-translate`;
+		case "scale": return `${prefix}:handle-scale:${index}`;
 		case "rotate": return `${prefix}:handle-rotate`;
 	}
 }
@@ -1403,16 +1347,18 @@ function handleStyleFor(kind, interactionStyle) {
 	switch (kind) {
 		case "vertex": return interactionStyle?.vertexHandle;
 		case "midpoint": return interactionStyle?.midpointHandle;
-		case "translate": return interactionStyle?.translateHandle;
+		case "scale": return interactionStyle?.scaleHandle;
 		case "rotate": return interactionStyle?.rotateHandle;
 	}
 }
 /**
 * Project a handle set into the GeoJSON features that belong on the handles
-* layer — the render projection of `buildHandleSet` (ADR-0016). Stable
-* `featureIdPrefix`-namespaced ids let multiple edits share a handles layer
-* without colliding; per-slot `interactionStyle` rides on `properties.style`.
-* Pure: handle positions are copied, never aliased into the output geometry.
+* layer — the render projection of `buildHandleSet` (ADR-0016), also reused by
+* the edit controller to render the transform box's corner/rotate `Handle`s
+* (ADR-0017). Stable `featureIdPrefix`-namespaced ids let multiple edits share
+* a handles layer without colliding; per-slot `interactionStyle` rides on
+* `properties.style`. Pure: handle positions are copied, never aliased into
+* the output geometry.
 */
 function toFeatures(handles, featureIdPrefix, interactionStyle) {
 	return handles.map((handle) => {
@@ -1435,26 +1381,142 @@ function toFeatures(handles, featureIdPrefix, interactionStyle) {
 		};
 	});
 }
-function pixelDistance(a, b) {
+function pixelDistance$2(a, b) {
 	return Math.hypot(a[0] - b[0], a[1] - b[1]);
 }
 /**
 * The pick projection of `buildHandleSet` (ADR-0016): the first handle within
 * `tolerance` pixels of `pixel`, tested in the set's priority order. Because
-* `buildHandleSet` orders vertices before midpoints before translate before
-* rotate, "first within tolerance" preserves the legacy "vertex wins over a
-* pixel-closer midpoint" behaviour. Returns the full `Handle` so the drag
-* controller can seed a gesture from its `position` without recomputing
-* placement. Handles whose position fails to project (off-screen / degenerate
-* projection) are skipped. Returns `null` when nothing is within tolerance.
+* `buildHandleSet` orders vertices before midpoints, "first within tolerance"
+* preserves the legacy "vertex wins over a pixel-closer midpoint" behaviour.
+* Returns the full `Handle` so the drag controller can seed a gesture from its
+* `position` without recomputing placement. Handles whose position fails to
+* project (off-screen / degenerate projection) are skipped. Returns `null`
+* when nothing is within tolerance.
 */
 function pickHandle(handles, pixel, tolerance, toPixel) {
 	for (const handle of handles) {
 		const projected = toPixel(handle.position);
-		if (projected && pixelDistance(projected, pixel) <= tolerance) return handle;
+		if (projected && pixelDistance$2(projected, pixel) <= tolerance) return handle;
 	}
 	return null;
 }
+function rotate(x, y, angle) {
+	const cos = Math.cos(angle);
+	const sin = Math.sin(angle);
+	return [x * cos - y * sin, x * sin + y * cos];
+}
+/**
+* Fit an oriented `TransformBox` around `pixels` at a caller-chosen `angle`.
+* Rotates the points by `-angle` about their centroid, takes the axis-aligned
+* bounding box in that de-rotated frame, then re-expresses the result as an
+* oriented box at `angle` — so the box always has exactly the requested tilt,
+* sized to just contain the (de-rotated) points. Half-dimensions are floored
+* at `MIN_HALF_SIZE_PX` so a degenerate selection still yields a drawable,
+* pickable box. Returns `null` for an empty list — there is nothing to fit.
+*
+* `padding` (pixels, default `0`) is added to `halfWidth`/`halfHeight` *after*
+* the `MIN_HALF_SIZE_PX` floor, on every side, without moving `center` — the
+* `InteractionStyle.boxPadding` knob (ADR-0017) so the box doesn't tightly hug
+* the rendered geometry. Everything downstream that reads a fitted box
+* (`boxCorners`, `rotateGripPixel`, `pointInBox`, `pickBoxHandle`) derives from
+* `halfWidth`/`halfHeight` alone, so the padding flows through to corner
+* placement, the rotate grip, and picking automatically — no other function
+* needs to know about it.
+*/
+function fitTransformBox(pixels, angle, padding = 0) {
+	if (pixels.length === 0) return null;
+	let cx = 0;
+	let cy = 0;
+	for (const p of pixels) {
+		cx += p[0];
+		cy += p[1];
+	}
+	cx /= pixels.length;
+	cy /= pixels.length;
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	for (const p of pixels) {
+		const [rx, ry] = rotate(p[0] - cx, p[1] - cy, -angle);
+		if (rx < minX) minX = rx;
+		if (rx > maxX) maxX = rx;
+		if (ry < minY) minY = ry;
+		if (ry > maxY) maxY = ry;
+	}
+	const localCenterX = (minX + maxX) / 2;
+	const localCenterY = (minY + maxY) / 2;
+	const halfWidth = Math.max((maxX - minX) / 2, 1) + padding;
+	const halfHeight = Math.max((maxY - minY) / 2, 1) + padding;
+	const [ox, oy] = rotate(localCenterX, localCenterY, angle);
+	return {
+		center: [cx + ox, cy + oy],
+		halfWidth,
+		halfHeight,
+		angle
+	};
+}
+/**
+* The box's 4 corners in screen pixels: `[topLeft, topRight, bottomRight,
+* bottomLeft]` in the box's local (pre-rotation) frame, then rotated by
+* `box.angle` about `box.center`. Corner index is stable — `pickBoxHandle`
+* and the scale-drag transition (`handle-drag.ts`) key off it, and the scale
+* anchor is always the opposite corner, `(index + 2) % 4`.
+*/
+function boxCorners(box) {
+	const { center, halfWidth, halfHeight, angle } = box;
+	return [
+		[-halfWidth, -halfHeight],
+		[halfWidth, -halfHeight],
+		[halfWidth, halfHeight],
+		[-halfWidth, halfHeight]
+	].map(([x, y]) => {
+		const [rx, ry] = rotate(x, y, angle);
+		return [center[0] + rx, center[1] + ry];
+	});
+}
+/**
+* Where the rotate grip sits: `ROTATE_GRIP_OFFSET_PX` above the top-edge
+* midpoint, along the box's local "up" direction, so the grip stays glued to
+* the box (rotates with it) rather than floating at a fixed screen offset.
+*/
+function rotateGripPixel(box) {
+	const { center, halfHeight, angle } = box;
+	const [rx, ry] = rotate(0, -(halfHeight + 28), angle);
+	return [center[0] + rx, center[1] + ry];
+}
+/**
+* Point-in-oriented-rectangle test, used to start a body (translate) drag
+* when the pointer goes down inside the box but not on a corner/rotate grip.
+* De-rotates `pixel` into the box's local frame about `box.center` and
+* compares against the half-extents.
+*/
+function pointInBox(box, pixel) {
+	const { center, halfWidth, halfHeight, angle } = box;
+	const [lx, ly] = rotate(pixel[0] - center[0], pixel[1] - center[1], -angle);
+	return Math.abs(lx) <= halfWidth && Math.abs(ly) <= halfHeight;
+}
+function pixelDistance$1(a, b) {
+	return Math.hypot(a[0] - b[0], a[1] - b[1]);
+}
+/**
+* Pick what part of the box, if any, `pixel` hits — corners first, then the
+* rotate grip, then plain containment (body drag). Corners and the rotate
+* grip use `tolerance` pixels; body containment is exact (`pointInBox`), so a
+* click just outside the box never starts a body drag. Returns `null` when
+* nothing matches.
+*/
+function pickBoxHandle(box, pixel, tolerance) {
+	const corners = boxCorners(box);
+	for (let i = 0; i < corners.length; i++) if (pixelDistance$1(corners[i], pixel) <= tolerance) return {
+		kind: "scale",
+		index: i
+	};
+	if (pixelDistance$1(rotateGripPixel(box), pixel) <= tolerance) return { kind: "rotate" };
+	if (pointInBox(box, pixel)) return { kind: "body" };
+	return null;
+}
 //#endregion
 //#region src/tactical-draw/handle-drag.ts
 function clonePoints(points) {
@@ -1468,17 +1530,8 @@ function translatePoints(base, dx, dy) {
 		return out;
 	});
 }
-function angleFromAnchor(anchor, target) {
-	return Math.atan2(target[1] - anchor[1], target[0] - anchor[0]);
-}
-/**
-* Angle of `pixel` around the rotation pivot, measured in screen space so it
-* matches what the user sees and does. Falls back to lon/lat when the pivot
-* cannot be projected — exceedingly rare for an on-screen edit.
-*/
-function rotateAngleAt(pivot, pivotPixel, pixel, projection) {
-	if (pivotPixel) return Math.atan2(pixel[1] - pivotPixel[1], pixel[0] - pivotPixel[0]);
-	return angleFromAnchor(pivot, projection.fromPixel(pixel));
+function pixelDistance(a, b) {
+	return Math.hypot(a[0] - b[0], a[1] - b[1]);
 }
 /**
 * Rotate `points` by `angle` about the pivot in screen space — project each
@@ -1536,7 +1589,7 @@ function begun(kind, initialBase, move) {
 * caller's working copy.
 */
 function beginHandleDrag(args) {
-	const { hit, downPixel, points, projection, rule } = args;
+	const { hit, points, projection, rule } = args;
 	const { fromPixel } = projection;
 	const preDragPoints = clonePoints(points);
 	const snap = (next, activePointIndex) => rule ? rule.transform({
@@ -1546,46 +1599,103 @@ function beginHandleDrag(args) {
 	}) : next;
 	const dragOnePoint = (base, activeIndex) => {
 		const move = (pixel) => {
-			return {
-				points: snap(base.map((p, i) => i === activeIndex ? fromPixel(pixel) : [...p]), activeIndex),
-				rotateGripOverride: null
-			};
+			return { points: snap(base.map((p, i) => i === activeIndex ? fromPixel(pixel) : [...p]), activeIndex) };
 		};
 		return move;
 	};
 	if (hit.kind === "vertex") return begun("vertex", preDragPoints, dragOnePoint(preDragPoints, hit.index));
-	if (hit.kind === "midpoint") {
-		const insertIndex = hit.index + 1;
-		const segmentEndIndex = (hit.index + 1) % preDragPoints.length;
-		const mid = segmentMidpoint(preDragPoints[hit.index], preDragPoints[segmentEndIndex]);
-		const insertedBase = [
-			...preDragPoints.slice(0, insertIndex),
-			mid,
-			...preDragPoints.slice(insertIndex)
-		];
-		return begun("midpoint", insertedBase, dragOnePoint(insertedBase, insertIndex));
-	}
-	if (hit.kind === "translate") {
-		const origin = fromPixel(downPixel);
-		return begun("translate", preDragPoints, (pixel) => {
-			const cur = fromPixel(pixel);
+	const insertIndex = hit.index + 1;
+	const segmentEndIndex = (hit.index + 1) % preDragPoints.length;
+	const mid = segmentMidpoint(preDragPoints[hit.index], preDragPoints[segmentEndIndex]);
+	const insertedBase = [
+		...preDragPoints.slice(0, insertIndex),
+		mid,
+		...preDragPoints.slice(insertIndex)
+	];
+	return begun("midpoint", insertedBase, dragOnePoint(insertedBase, insertIndex));
+}
+/** No corner drag may scale below this factor — guards against reflection/collapse through the anchor. */
+const MIN_SCALE_FACTOR = .05;
+/**
+* Begin a transform-box drag: uniform corner scale, box-center rotate, or
+* body translate. Mirrors `beginHandleDrag`'s shape (a `move`/`end` FSM seeded
+* from the pre-drag points) but keyed on `BoxDragKind` instead of `HandleKind`,
+* and additionally threading the box itself through so the caller can paint
+* the live box without re-fitting from projected geometry every frame.
+*/
+function beginBoxDrag(args) {
+	const { kind, downPixel, points, projection, box, cornerIndex } = args;
+	const { toPixel, fromPixel } = projection;
+	const preDragPoints = clonePoints(points);
+	if (kind === "scale") {
+		const index = cornerIndex ?? 0;
+		const anchor = boxCorners(box)[(index + 2) % 4];
+		const downDist = pixelDistance(downPixel, anchor);
+		const move = (pixel) => {
+			const dist = pixelDistance(pixel, anchor);
+			const rawFactor = downDist === 0 ? 1 : dist / downDist;
+			const factor = Math.max(rawFactor, MIN_SCALE_FACTOR);
 			return {
-				points: translatePoints(preDragPoints, cur[0] - origin[0], cur[1] - origin[1]),
-				rotateGripOverride: null
+				points: preDragPoints.map((p) => {
+					const px = toPixel(p);
+					if (!px) return [...p];
+					const ll = fromPixel([anchor[0] + (px[0] - anchor[0]) * factor, anchor[1] + (px[1] - anchor[1]) * factor]);
+					const out = [ll[0], ll[1]];
+					for (let k = 2; k < p.length; k++) out.push(p[k]);
+					return out;
+				}),
+				box: {
+					center: [anchor[0] + (box.center[0] - anchor[0]) * factor, anchor[1] + (box.center[1] - anchor[1]) * factor],
+					halfWidth: box.halfWidth * factor,
+					halfHeight: box.halfHeight * factor,
+					angle: box.angle
+				}
 			};
-		});
+		};
+		return {
+			kind,
+			move,
+			end: (pixel) => move(pixel).points
+		};
 	}
-	const pivot = computeBoundingBoxCenter(preDragPoints) ?? [0, 0];
-	const pivotPixel = projection.toPixel(pivot);
-	const startAngle = rotateAngleAt(pivot, pivotPixel, downPixel, projection);
-	const startGrip = hit.position;
-	return begun("rotate", preDragPoints, (pixel) => {
-		const angle = rotateAngleAt(pivot, pivotPixel, pixel, projection) - startAngle;
+	if (kind === "rotate") {
+		const pivotPixel = box.center;
+		const pivot = fromPixel(pivotPixel);
+		const startAngle = Math.atan2(downPixel[1] - pivotPixel[1], downPixel[0] - pivotPixel[0]);
+		const move = (pixel) => {
+			const angle = Math.atan2(pixel[1] - pivotPixel[1], pixel[0] - pivotPixel[0]) - startAngle;
+			return {
+				points: rotatePointsAround(preDragPoints, pivot, pivotPixel, angle, projection),
+				box: {
+					center: [...pivotPixel],
+					halfWidth: box.halfWidth,
+					halfHeight: box.halfHeight,
+					angle: box.angle + angle
+				}
+			};
+		};
 		return {
-			points: rotatePointsAround(preDragPoints, pivot, pivotPixel, angle, projection),
-			rotateGripOverride: rotatePointsAround([startGrip], pivot, pivotPixel, angle, projection)[0]
+			kind,
+			move,
+			end: (pixel) => move(pixel).points
 		};
-	});
+	}
+	const origin = fromPixel(downPixel);
+	const move = (pixel) => {
+		const cur = fromPixel(pixel);
+		return {
+			points: translatePoints(preDragPoints, cur[0] - origin[0], cur[1] - origin[1]),
+			box: {
+				...box,
+				center: [box.center[0] + (pixel[0] - downPixel[0]), box.center[1] + (pixel[1] - downPixel[1])]
+			}
+		};
+	};
+	return {
+		kind,
+		move,
+		end: (pixel) => move(pixel).points
+	};
 }
 //#endregion
 //#region src/tactical-draw/edit-session.ts
@@ -1607,8 +1717,10 @@ const COMMIT_GESTURE_FOR_TEST = Symbol("EditSession.commitGestureForTest");
 const COMMIT_TRANSLATE_FOR_TEST = Symbol("EditSession.commitTranslateForTest");
 /**
 * Internal test seam — simulate a completed rotate gesture by passing an angle
-* in radians. Every control point rotates around the computed anchor (centroid);
-* one `EditChangeEvent` is emitted, matching the issue #50 emission contract.
+* in radians. Every control point rotates around the transform box's center
+* (falling back to the control-points' bounding-box center when no box has
+* been fitted yet); one `EditChangeEvent` is emitted, and `boxAngle` absorbs
+* the same delta a live rotate box-drag would (ADR-0017).
 *
 * @internal
 */
@@ -1629,6 +1741,78 @@ const BEGIN_DRAG_FOR_TEST = Symbol("EditSession.beginDragForTest");
 */
 const END_DRAG_FOR_TEST = Symbol("EditSession.endDragForTest");
 //#endregion
+//#region src/tactical-draw/box-features.ts
+/**
+* Rendering helpers shared by the single-measure edit controller
+* (`edit-controller.ts`) and the group transform controller
+* (`transform-controller.ts`): both paint the same `TransformBox` shape —
+* corner scale handles, a rotate grip, and a closed-ring outline — so the
+* projection from pure box geometry (`transform-box.ts`) to lonLat `Handle`s
+* / GeoJSON features lives in one place instead of two copies drifting apart.
+* See ADR-0017.
+*/
+/** Walk a GeoJSON `Geometry`'s coordinate arrays, pushing every `Position` onto `out`. */
+function collectFeaturePositions(geometry, out) {
+	switch (geometry.type) {
+		case "Point":
+			out.push(geometry.coordinates);
+			break;
+		case "MultiPoint":
+		case "LineString":
+			for (const p of geometry.coordinates) out.push(p);
+			break;
+		case "MultiLineString":
+		case "Polygon":
+			for (const ring of geometry.coordinates) for (const p of ring) out.push(p);
+			break;
+		case "MultiPolygon":
+			for (const poly of geometry.coordinates) for (const ring of poly) for (const p of ring) out.push(p);
+			break;
+		case "GeometryCollection":
+			for (const g of geometry.geometries) collectFeaturePositions(g, out);
+			break;
+	}
+}
+/**
+* Project a `TransformBox`'s 4 corner scale handles and rotate grip into
+* lonLat `Handle`s via `fromPixel` — the render projection of the box's
+* pixel-space geometry (`boxCorners` / `rotateGripPixel`), reused by both
+* controllers so box-handle placement can't drift between single-measure and
+* group transforms.
+*/
+function boxToHandles(box, fromPixel) {
+	const handles = boxCorners(box).map((corner, index) => ({
+		kind: "scale",
+		index,
+		position: fromPixel(corner)
+	}));
+	handles.push({
+		kind: "rotate",
+		index: 0,
+		position: fromPixel(rotateGripPixel(box))
+	});
+	return handles;
+}
+/**
+* Build the closed `LineString` outline feature for `box`, styled from
+* `style` (delivered per-feature via `properties.style`, as the adapters
+* already honor for line features). `featureId` is the caller's stable id —
+* `${prefix}:box-outline` for a single-measure or group box, or
+* `${prefix}:member-outline:{measureId}` for a group member's own outline.
+*/
+function boxOutlineFeature(box, fromPixel, featureId, style) {
+	const corners = boxCorners(box).map((c) => fromPixel(c));
+	return {
+		type: "Feature",
+		id: featureId,
+		geometry: {
+			type: "LineString",
+			coordinates: [...corners, corners[0]]
+		},
+		properties: style ? { style: { ...style } } : {}
+	};
+}
+//#endregion
 //#region src/tactical-draw/edit-controller.ts
 /**
 * Coordinate-space tolerance for `EditSession.dirty`. The working copy is
@@ -1637,27 +1821,32 @@ const END_DRAG_FOR_TEST = Symbol("EditSession.endDragForTest");
 * dirty tracking; the constant lives in one place so future slices can lift
 * it to an option without touching call sites.
 */
-const DIRTY_EPSILON = 1e-9;
-const HANDLE_HIT_TOLERANCE_PX = 12;
+const DIRTY_EPSILON$1 = 1e-9;
+const HANDLE_HIT_TOLERANCE_PX$1 = 12;
+/**
+* A body drag (drag-anywhere-inside-the-box translate) whose release pixel
+* lands within this many pixels of the down pixel is treated as a plain
+* click, not a gesture: it is not committed (geometry restored, no
+* `EditChangeEvent`, `dirty` untouched) but the click-away listener is
+* suppressed so the click doesn't close the edit. Corner/rotate drags commit
+* even at zero movement (matches the pre-ADR-0017 translate/rotate seams).
+*/
+const CLICK_SLOP_PX$1 = 3;
 const ALLOWED_EDIT_MODES = new Set([
 	"reshape",
-	"translate",
-	"rotate",
+	"transform",
 	"delete"
 ]);
 /**
-* Drive an interactive edit against a `MapAdapter`. Implements the first
-* edit slice (issue #48):
+* Drive an interactive edit against a `MapAdapter`. Implements the edit
+* lifecycle (issue #48) plus the ADR-0017 transform box:
 *
 *  - lift-original (remove from graphics layer) + working copy
-*  - preview + handle rendering for `reshape` mode
+*  - preview + reshape-handle rendering, and the oriented transform box
+*    (corner scale handles, rotate grip, drag-anywhere-inside body translate)
 *  - dirty tracking via [[DIRTY_EPSILON]] tolerance
 *  - default click-away close policy
 *  - close / abort / signal / preempt / destroy paths
-*
-* Pointer-driven vertex / midpoint drag is intentionally NOT wired here —
-* gesture binding lands with the change-event spec in #49 and the
-* translate/rotate handle set in #50.
 */
 function runEdit(opts) {
 	const { adapter, measure, graphicsLayer, previewLayer, guideLayer, handlesLayer, graphicsStyle, signal, closeOnClickAway = true, modes: initialModes, interactionStyle, onSession, handleIdPrefix, guide: guideOpt, restoreOriginalToGraphics, wasOnGraphicsLayer, onSettled, onClickAwayGraphicsPick } = opts;
@@ -1698,12 +1887,55 @@ function runEdit(opts) {
 	*/
 	let pendingModes = null;
 	const changeListeners = /* @__PURE__ */ new Set();
-	let ctx;
-	let driver;
-	const dragProjection = {
+	/**
+	* The transform box's rotation, in radians, session-scoped (ADR-0017 decision
+	* #2): starts at `0` (axis-aligned) and accumulates every committed rotate
+	* gesture's delta, so the box stays glued to the shape across gestures. Never
+	* persisted on the measure; a fresh edit always starts back at `0`.
+	*/
+	let boxAngle = 0;
+	/**
+	* The transform box fitted around the *rendered* working-copy geometry
+	* (pixel space), or `null` when nothing projected this frame. Re-fitted
+	* after every committed gesture, every reshape-drag paint, and on
+	* `onViewChange`; painted rigidly from the live drag's own snapshot instead
+	* while a box gesture (`activeBoxDrag`) is in flight.
+	*/
+	let box = null;
+	/** The features written to the preview layer on the last `renderPreview()` call — reused to refit `box` without a second render pass. */
+	let lastPreviewFeatures = [];
+	let ctx;
+	let driver;
+	const dragProjection = {
 		toPixel: (lonLat) => driver.toPixel(lonLat),
 		fromPixel: (pixel) => driver.fromPixel(pixel)
 	};
+	/**
+	* Fit the transform box around `features`' rendered geometry: every
+	* coordinate is projected to pixels via the pointer driver and
+	* `fitTransformBox`'d at the current `boxAngle`. `null` when nothing
+	* projects (e.g. the working copy renders no features this frame).
+	*/
+	function fitBoxFromFeatures(features) {
+		const positions = [];
+		for (const f of features) if (f.geometry) collectFeaturePositions(f.geometry, positions);
+		const pixels = [];
+		for (const p of positions) {
+			const px = driver.toPixel(p);
+			if (px) pixels.push(px);
+		}
+		return fitTransformBox(pixels, boxAngle, interactionStyle?.boxPadding ?? 0);
+	}
+	/**
+	* Re-fit `box` from `lastPreviewFeatures`. A no-op while a box gesture is
+	* in flight — that drag paints the box rigidly from its own snapshot
+	* (`BoxDragSnapshot.box`) instead of a re-fit, so a corner/rotate/body drag
+	* doesn't fight its own paint.
+	*/
+	function refitBox() {
+		if (activeBoxDrag) return;
+		box = fitBoxFromFeatures(lastPreviewFeatures);
+	}
 	function liftOriginalFromGraphics() {
 		if (!wasOnGraphicsLayer) return;
 		const originalFeatureIds = renderMeasureForAdapter(adapter, measure, renderOpts).features.map((f) => f.id).filter((id) => typeof id === "string");
@@ -1724,38 +1956,48 @@ function runEdit(opts) {
 			features = [];
 		}
 		ctx.writeLayer(previewLayer, features);
-		const guideFeatures = guideEnabled ? buildGuideFeatures(workingPoints, isAreaKind, trailingFixedSlots) : [];
+		lastPreviewFeatures = features;
+		refitBox();
+		const guidePoints = rule?.guidePoints ? rule.guidePoints(workingPoints) : workingPoints;
+		const guideFeatures = guideEnabled ? buildGuideFeatures(guidePoints, isAreaKind, trailingFixedSlots) : [];
 		ctx.writeLayer(guideLayer, guideFeatures);
 	}
 	function rescaleOnViewChange() {
-		if (!measureUsesAdapterResolution({
+		if (ctx.settled) return;
+		if (measureUsesAdapterResolution({
 			kind: measure.kind,
 			options: workingOptions
-		})) return;
-		renderPreview();
+		})) renderPreview();
+		else refitBox();
+		renderHandlesLayer();
 	}
 	function renderHandlesLayer() {
 		if (ctx.settled) return;
-		let handles = buildHandleSet(workingPoints, modes, {
+		const features = toFeatures(buildHandleSet(workingPoints, modes, {
 			includeMidpoints: midpointHandlesEnabled,
 			trailingFixedSlots,
 			closedRing
-		});
-		if (activeDrag?.fsm.kind === "rotate" && rotateHandleOverride) {
-			const override = rotateHandleOverride;
-			handles = handles.map((h) => h.kind === "rotate" ? {
-				...h,
-				position: override
-			} : h);
-		}
-		const features = toFeatures(handles, handleIdPrefix, interactionStyle);
+		}), handleIdPrefix, interactionStyle);
+		if (modes.includes("transform")) {
+			const liveBox = activeBoxDrag ? activeBoxDrag.lastSnapshot.box : box;
+			if (liveBox) {
+				features.push(boxOutlineFeature(liveBox, dragProjection.fromPixel, `${handleIdPrefix}:box-outline`, interactionStyle?.boxOutline));
+				features.push(...toFeatures(boxToHandles(liveBox, dragProjection.fromPixel), handleIdPrefix, interactionStyle));
+			}
+		}
 		ctx.writeLayer(handlesLayer, features);
 	}
-	function rebuildRendered() {
+	/**
+	* Builds the committed snapshot against explicit `options` rather than the
+	* live `workingOptions` — used to render a gesture's "previous" snapshot
+	* against pre-freeze options when a rotate has already merged its
+	* orientation freeze into `workingOptions` by the time the commit runs.
+	*/
+	function rebuildRenderedWith(options) {
 		const working = {
 			...measure,
 			style: currentStyle,
-			options: workingOptions,
+			options,
 			controlPoints: workingPoints.map((p) => [...p])
 		};
 		const committed = sizeAnchor === "screen" ? working : bakePixelSizeToGround(working, adapter);
@@ -1764,8 +2006,11 @@ function runEdit(opts) {
 			render: renderMeasureForAdapter(adapter, committed, renderOpts)
 		};
 	}
+	function rebuildRendered() {
+		return rebuildRenderedWith(workingOptions);
+	}
 	function recomputeDirty() {
-		dirty = nonGeometryDirty || !pointsEqualWithinTolerance(workingPoints, editStartPoints, DIRTY_EPSILON);
+		dirty = nonGeometryDirty || !pointsEqualWithinTolerance(workingPoints, editStartPoints, DIRTY_EPSILON$1);
 	}
 	function replaceWorkingPoints(next) {
 		workingPoints.splice(0, workingPoints.length, ...roundControlPoints(next));
@@ -1774,6 +2019,23 @@ function runEdit(opts) {
 		workingOptions = { ...next ?? {} };
 	}
 	/**
+	* Pin orientation-derived option defaults (e.g. Battle Position's echelon
+	* anchor) to their current concrete values, merging any patch onto
+	* `workingOptions` in place. Called the moment a rotate gesture starts (a
+	* box-drag rotate hit, or the `commitRotate` test seam) — a rigid rotation
+	* of `workingPoints` follows immediately after, so the freeze must land
+	* first or the orientation-relative default would re-derive against the
+	* rotated geometry (ADR-0023). No dirty/change-event side effects of its
+	* own — the rotate gesture's own commit carries the frozen options.
+	*/
+	function freezeOrientationForRotate() {
+		const patch = freezeOrientationOptions(measure.kind, workingPoints.map((p) => [...p]), workingOptions);
+		if (patch) workingOptions = {
+			...workingOptions ?? {},
+			...patch
+		};
+	}
+	/**
 	* Emit a completed gesture to every registered listener. The pre-gesture
 	* snapshot is provided as `previousRendered`; `commitGesture` has already
 	* mutated `workingPoints` and re-rendered preview / handle layers before
@@ -1839,19 +2101,20 @@ function runEdit(opts) {
 	* queued during the drag are applied after the listener emission (so the
 	* post-gesture render reflects the requested mode set).
 	*/
-	function commitGesture(nextPoints) {
+	function commitGesture(nextPoints, preGestureOptions) {
 		if (ctx.settled) return;
 		const previousPoints = workingPoints.map((p) => [...p]);
-		const previousOptions = { ...workingOptions ?? {} };
+		const previousOptions = { ...preGestureOptions ?? workingOptions ?? {} };
 		const previousStyle = currentStyle;
 		const previousNonGeometryDirty = nonGeometryDirty;
-		const previousRendered = rebuildRendered();
+		const previousRendered = rebuildRenderedWith(previousOptions);
 		replaceWorkingPoints(nextPoints);
 		let currentRendered;
 		try {
 			currentRendered = rebuildRendered();
 		} catch (err) {
 			replaceWorkingPoints(previousPoints);
+			if (preGestureOptions !== void 0) replaceWorkingOptions(previousOptions);
 			dragInFlight = false;
 			drainPendingModes();
 			throw err;
@@ -1941,16 +2204,23 @@ function runEdit(opts) {
 		}));
 	}
 	/**
-	* Apply a rotate gesture by rotating every working point by `angle` (radians)
-	* around the bounding-box center. The rotation runs in screen space (see
+	* Test seam for a rotate gesture: rotate every working point by `angle`
+	* (radians) around the transform box's center — falling back to the
+	* control-points' bounding-box center when no box has been fitted yet (e.g.
+	* before the first paint). The rotation runs in screen space (see
 	* `rotatePointsAround`) so it stays rigid and matches the pointer 1:1 at any
-	* latitude.
+	* latitude, and `boxAngle` absorbs the same delta a live rotate box-drag
+	* would (ADR-0017), so the box stays glued to the shape across seam calls.
 	*/
 	function commitRotate(angle) {
 		if (ctx.settled) return;
-		const pivot = computeBoundingBoxCenter(workingPoints);
+		const preFreezeOptions = { ...workingOptions ?? {} };
+		freezeOrientationForRotate();
+		const pivotPixel = box ? box.center : driver.toPixel(computeBoundingBoxCenter(workingPoints) ?? [0, 0]);
+		const pivot = box ? driver.fromPixel(box.center) : computeBoundingBoxCenter(workingPoints);
 		if (!pivot) return;
-		commitGesture(rotatePointsAround(workingPoints, pivot, driver.toPixel(pivot), angle, dragProjection));
+		boxAngle += angle;
+		commitGesture(rotatePointsAround(workingPoints, pivot, pivotPixel, angle, dragProjection), preFreezeOptions);
 	}
 	function modesEqual(a, b) {
 		if (a.length !== b.length) return false;
@@ -2042,13 +2312,14 @@ function runEdit(opts) {
 	};
 	let activeDrag = null;
 	/**
-	* Render-only rotate-grip override produced by the drag FSM: the start grip
-	* rotated rigidly with the gesture so it tracks the pointer instead of hopping
-	* between near-equidistant vertices. Cleared when the drag ends. Only
-	* consulted while a rotate drag is in flight — pick is gated off for the
-	* duration, so the resting handle set is never read against it (ADR-0016).
+	* A live transform-box gesture (corner scale, box rotate, or body
+	* translate — ADR-0017). `lastSnapshot` starts as the pre-drag points/box
+	* and is replaced on every `move()` tick; `renderHandlesLayer` paints
+	* `lastSnapshot.box` instead of re-fitting while this is non-null, and
+	* `preDragBox` lets a committed rotate compute the angle delta to fold into
+	* `boxAngle`.
 	*/
-	let rotateHandleOverride = null;
+	let activeBoxDrag = null;
 	/**
 	* Whether the vertex at `index` may be deleted (via Alt+click or in the
 	* exclusive `delete` mode). Deletion is
@@ -2087,74 +2358,149 @@ function runEdit(opts) {
 	}
 	const onDriverDown = (pixel, info) => {
 		if (ctx.settled || dragInFlight) return;
-		const tol = info?.hitTolerance ?? HANDLE_HIT_TOLERANCE_PX;
+		const tol = info?.hitTolerance ?? HANDLE_HIT_TOLERANCE_PX$1;
 		const hit = pickHandle(buildHandleSet(workingPoints, modes, {
 			includeMidpoints: midpointHandlesEnabled,
 			trailingFixedSlots,
 			closedRing
 		}), pixel, tol, (lonLat) => driver.toPixel(lonLat));
-		if (!hit) return;
-		if (modes.includes("delete")) {
-			if (hit.kind === "vertex" && canDeleteVertex(hit.index)) {
+		if (hit) {
+			if (modes.includes("delete")) {
+				if (hit.kind === "vertex" && canDeleteVertex(hit.index)) {
+					deleteVertex(hit.index);
+					suppressClickAway = true;
+				}
+				return;
+			}
+			if (hit.kind === "vertex" && info?.altKey && canDeleteVertex(hit.index)) {
 				deleteVertex(hit.index);
 				suppressClickAway = true;
+				return;
 			}
+			const preDragPoints = workingPoints.map((p) => [...p]);
+			const { drag: fsm, initialPoints } = beginHandleDrag({
+				hit,
+				downPixel: pixel,
+				points: preDragPoints,
+				projection: dragProjection,
+				rule
+			});
+			activeDrag = {
+				fsm,
+				preDragPoints
+			};
+			if (fsm.kind === "midpoint") {
+				workingPoints.splice(0, workingPoints.length, ...initialPoints);
+				renderPreview();
+				renderHandlesLayer();
+			}
+			dragInFlight = true;
+			driver.setDragPanEnabled(false);
 			return;
 		}
-		if (hit.kind === "vertex" && info?.altKey && canDeleteVertex(hit.index)) {
-			deleteVertex(hit.index);
-			suppressClickAway = true;
-			return;
-		}
-		const preDragPoints = workingPoints.map((p) => [...p]);
-		const { drag: fsm, initialPoints } = beginHandleDrag({
-			hit,
-			downPixel: pixel,
-			points: preDragPoints,
-			projection: dragProjection,
-			rule
-		});
-		activeDrag = {
-			fsm,
-			preDragPoints
-		};
-		if (fsm.kind === "midpoint") {
-			workingPoints.splice(0, workingPoints.length, ...initialPoints);
-			renderPreview();
-			renderHandlesLayer();
+		if (modes.includes("transform") && box) {
+			const boxHit = pickBoxHandle(box, pixel, tol);
+			if (boxHit) {
+				const preDragOptions = { ...workingOptions ?? {} };
+				if (boxHit.kind === "rotate") {
+					freezeOrientationForRotate();
+					renderPreview();
+					renderHandlesLayer();
+				}
+				const preDragPoints = workingPoints.map((p) => [...p]);
+				activeBoxDrag = {
+					fsm: beginBoxDrag({
+						kind: boxHit.kind,
+						downPixel: pixel,
+						points: preDragPoints,
+						projection: dragProjection,
+						box,
+						cornerIndex: boxHit.kind === "scale" ? boxHit.index : void 0
+					}),
+					preDragPoints,
+					preDragBox: box,
+					downPixel: pixel,
+					lastSnapshot: {
+						points: preDragPoints,
+						box
+					},
+					preDragOptions
+				};
+				dragInFlight = true;
+				driver.setDragPanEnabled(false);
+			}
 		}
-		dragInFlight = true;
-		driver.setDragPanEnabled(false);
 	};
 	function paintDragSnapshot(pixel) {
 		if (!activeDrag) return;
 		const snapshot = activeDrag.fsm.move(pixel);
 		workingPoints.splice(0, workingPoints.length, ...snapshot.points);
-		rotateHandleOverride = snapshot.rotateGripOverride;
+		renderPreview();
+		renderHandlesLayer();
+		recomputeDirty();
+	}
+	function paintBoxDragSnapshot(pixel) {
+		if (!activeBoxDrag) return;
+		const snapshot = activeBoxDrag.fsm.move(pixel);
+		activeBoxDrag.lastSnapshot = snapshot;
+		workingPoints.splice(0, workingPoints.length, ...snapshot.points);
 		renderPreview();
 		renderHandlesLayer();
 		recomputeDirty();
 	}
 	const onDriverMove = (pixel) => {
-		if (ctx.settled || !activeDrag) return;
-		paintDragSnapshot(pixel);
+		if (ctx.settled) return;
+		if (activeDrag) paintDragSnapshot(pixel);
+		else if (activeBoxDrag) paintBoxDragSnapshot(pixel);
 	};
+	/** Reset drag-in-flight bookkeeping shared by every "gesture ended" path. */
+	function endDragBookkeeping() {
+		driver.setDragPanEnabled(true);
+		dragInFlight = false;
+		drainPendingModes();
+	}
 	const onDriverUp = (pixel) => {
-		if (!activeDrag) return;
-		if (ctx.settled) {
+		if (activeDrag) {
+			if (ctx.settled) {
+				activeDrag = null;
+				dragInFlight = false;
+				driver.setDragPanEnabled(true);
+				return;
+			}
+			const { fsm, preDragPoints } = activeDrag;
 			activeDrag = null;
-			rotateHandleOverride = null;
-			dragInFlight = false;
 			driver.setDragPanEnabled(true);
+			const next = fsm.end(pixel);
+			replaceWorkingPoints(preDragPoints);
+			commitGesture(next);
+			return;
+		}
+		if (activeBoxDrag) {
+			if (ctx.settled) {
+				activeBoxDrag = null;
+				dragInFlight = false;
+				driver.setDragPanEnabled(true);
+				return;
+			}
+			const { fsm, preDragPoints, preDragBox, downPixel, preDragOptions } = activeBoxDrag;
+			activeBoxDrag = null;
+			driver.setDragPanEnabled(true);
+			const distance = Math.hypot(pixel[0] - downPixel[0], pixel[1] - downPixel[1]);
+			if (fsm.kind === "body" && distance <= CLICK_SLOP_PX$1) {
+				replaceWorkingPoints(preDragPoints);
+				renderPreview();
+				renderHandlesLayer();
+				recomputeDirty();
+				endDragBookkeeping();
+				suppressClickAway = true;
+				return;
+			}
+			const finalSnapshot = fsm.move(pixel);
+			replaceWorkingPoints(preDragPoints);
+			if (fsm.kind === "rotate") boxAngle += finalSnapshot.box.angle - preDragBox.angle;
+			commitGesture(finalSnapshot.points, preDragOptions);
 			return;
 		}
-		const { fsm, preDragPoints } = activeDrag;
-		activeDrag = null;
-		rotateHandleOverride = null;
-		driver.setDragPanEnabled(true);
-		const next = fsm.end(pixel);
-		replaceWorkingPoints(preDragPoints);
-		commitGesture(next);
 	};
 	let pickPreview;
 	let pickHandles;
@@ -2218,10 +2564,10 @@ function runEdit(opts) {
 				unsubDown();
 				unsubMove();
 				unsubUp();
-				if (activeDrag !== null) {
+				if (activeDrag !== null || activeBoxDrag !== null) {
 					driver.setDragPanEnabled(true);
 					activeDrag = null;
-					rotateHandleOverride = null;
+					activeBoxDrag = null;
 					dragInFlight = false;
 				}
 				driver.dispose();
@@ -2249,12 +2595,17 @@ function runEdit(opts) {
 		}
 	};
 }
+/**
+* Validate and normalise an `EditOptions.modes` / `EditSession.setModes` input:
+* throws `TypeError` synchronously for an unknown mode, collapses `delete` to
+* an exclusive set, dedupes, and defaults to `["reshape", "transform"]`.
+* Exported so the façade can hoist this validation *before* `guardAndPreempt`
+* — an invalid mode must not tear down whatever edit/draw is already active
+* (see the `td.edit` regression test for issue tracked alongside ADR-0017).
+*/
 function normaliseModes(modes) {
-	if (!modes || modes.length === 0) return ["reshape"];
-	for (const m of modes) {
-		if (m === "scale") throw new TypeError(`td.edit: edit mode "scale" is reserved and not yet implemented`);
-		if (!ALLOWED_EDIT_MODES.has(m)) throw new TypeError(`td.edit: unknown edit mode "${String(m)}"`);
-	}
+	if (!modes || modes.length === 0) return ["reshape", "transform"];
+	for (const m of modes) if (!ALLOWED_EDIT_MODES.has(m)) throw new TypeError(`td.edit: unknown edit mode "${String(m)}"`);
 	if (modes.includes("delete")) return ["delete"];
 	const seen = /* @__PURE__ */ new Set();
 	const out = [];
@@ -2282,6 +2633,531 @@ function pointsEqualWithinTolerance(a, b, epsilon) {
 	return true;
 }
 //#endregion
+//#region src/tactical-draw/transform-controller.ts
+/**
+* Coordinate-space tolerance for `TransformSession.dirty` — mirrors
+* `edit-controller.ts`'s `DIRTY_EPSILON` (kept as a sibling constant rather
+* than a shared import since the two controllers' dirty definitions may
+* diverge later: a group's dirty is "any member moved").
+*/
+const DIRTY_EPSILON = 1e-9;
+const HANDLE_HIT_TOLERANCE_PX = 12;
+/**
+* A body drag (drag-anywhere-inside-the-box translate) whose release pixel
+* lands within this many pixels of the down pixel is treated as a plain
+* click, not a gesture — same rationale as `edit-controller.ts`'s constant of
+* the same name.
+*/
+const CLICK_SLOP_PX = 3;
+/**
+* Drive an interactive group transform against a `MapAdapter` — the leaner,
+* multi-select sibling of `runEdit` (ADR-0017 "Multi-select" slice). No
+* reshape, no per-vertex handles, no guide layer, no per-measure
+* `setOptions`/`setStyle`: only the shared oriented box (corner scale, rotate
+* grip, drag-anywhere body translate), applied rigidly to every member's
+* control points at once.
+*
+*  - lift every member off the graphics layer + per-member working copies
+*  - render every member's preview to the shared preview layer each paint
+*  - group box = fit over the union of every member's rendered pixel
+*    coordinates at the session `boxAngle`; each member also gets its own
+*    thin outline (its own fit at the same angle)
+*  - dirty tracking, close/abort/signal/preempt/destroy, click-away — same
+*    contracts as `runEdit`, scoped to the group
+*/
+function runGroupTransform(opts) {
+	const { adapter, measures, graphicsLayer, previewLayer, handlesLayer, graphicsStyle, signal, closeOnClickAway = true, interactionStyle, onSession, handleIdPrefix, restoreOriginalToGraphics, wasOnGraphicsLayer, onSettled, onClickAwayGraphicsPick } = opts;
+	const renderOpts = graphicsStyle ? { graphicsStyle } : void 0;
+	const memberIds = new Set(measures.map((m) => m.id));
+	let sizeAnchor = opts.sizeAnchor ?? "ground";
+	const editStartPointsByMember = measures.map((m) => m.controlPoints.map((p) => [...p]));
+	const workingPointsByMember = editStartPointsByMember.map((pts) => pts.map((p) => [...p]));
+	const counts = workingPointsByMember.map((pts) => pts.length);
+	/**
+	* Per-member options patch, index-aligned with `measures`, applied on top of
+	* the member's own `options` when building its working/rendered measure.
+	* This exists solely to freeze orientation-derived option defaults (e.g.
+	* Battle Position's echelon anchor) the moment a group rotate gesture
+	* starts (ADR-0023) — there is no public per-member `setOptions` here, and
+	* the "no per-measure setOptions" contract for the group session still
+	* holds; a host cannot reach this array.
+	*/
+	let optionsOverrideByMember = measures.map(() => null);
+	/** Effective options for member `i` against a given override array, merged onto its own options. */
+	function effectiveOptionsWith(i, overrides) {
+		const override = overrides[i];
+		if (!override) return measures[i].options;
+		return {
+			...measures[i].options ?? {},
+			...override
+		};
+	}
+	/** Effective options for member `i`: its own options merged with the *live* override. */
+	function effectiveOptions(i) {
+		return effectiveOptionsWith(i, optionsOverrideByMember);
+	}
+	/** The working measure for member `i` against a given override array, with live working points. */
+	function workingMeasureForWith(i, overrides) {
+		return {
+			...measures[i],
+			options: effectiveOptionsWith(i, overrides),
+			controlPoints: workingPointsByMember[i].map((p) => [...p])
+		};
+	}
+	/** The working measure for member `i`: original measure, live effective options, live working points. */
+	function workingMeasureFor(i) {
+		return workingMeasureForWith(i, optionsOverrideByMember);
+	}
+	let dirty = false;
+	/**
+	* Set by non-geometry mutations (`setSizeAnchor`) so `dirty` reports them
+	* even when every control point still matches edit-start — mirrors
+	* `edit-controller.ts`'s flag of the same name.
+	*/
+	let nonGeometryDirty = false;
+	let dragInFlight = false;
+	/** Same click-away suppression role as `edit-controller.ts`'s flag of the same name. */
+	let suppressClickAway = false;
+	const changeListeners = /* @__PURE__ */ new Set();
+	/** Session-scoped box rotation (ADR-0017 decision #2), shared by the whole group. */
+	let boxAngle = 0;
+	/** The group box fitted over every member's rendered geometry, or `null` when nothing projects this frame. */
+	let groupBox = null;
+	/** Each member's own fitted box (same angle as `groupBox`), index-aligned with `measures`. */
+	let memberBoxes = measures.map(() => null);
+	/** The features written to the preview layer for each member on the last paint. */
+	let lastPreviewFeaturesByMember = measures.map(() => []);
+	let ctx;
+	let driver;
+	const dragProjection = {
+		toPixel: (lonLat) => driver.toPixel(lonLat),
+		fromPixel: (pixel) => driver.fromPixel(pixel)
+	};
+	function liftOriginalsFromGraphics() {
+		measures.forEach((measure, i) => {
+			if (!wasOnGraphicsLayer[i]) return;
+			const ids = renderMeasureForAdapter(adapter, measure, renderOpts).features.map((f) => f.id).filter((id) => typeof id === "string");
+			if (ids.length > 0) adapter.removeFeatures(graphicsLayer, ids);
+		});
+	}
+	function pixelsFor(features) {
+		const positions = [];
+		for (const f of features) if (f.geometry) collectFeaturePositions(f.geometry, positions);
+		const pixels = [];
+		for (const p of positions) {
+			const px = driver.toPixel(p);
+			if (px) pixels.push(px);
+		}
+		return pixels;
+	}
+	/** The live box angle: the in-flight drag's rigidly-transformed angle, or the committed `boxAngle`. */
+	function currentAngle() {
+		return activeBoxDrag ? activeBoxDrag.lastSnapshot.box.angle : boxAngle;
+	}
+	/**
+	* Re-fit `groupBox` and every `memberBoxes[i]` from `lastPreviewFeaturesByMember`.
+	* While a box gesture is in flight, `groupBox` itself is not touched here —
+	* `renderHandlesLayer` paints the drag's own rigidly-transformed box instead
+	* (matching `edit-controller.ts`'s `refitBox`) — but the member outlines are
+	* still re-fitted every paint at the drag's live angle, since they are a
+	* derived display only (no self-fight risk).
+	*/
+	function refitBoxes() {
+		const angle = currentAngle();
+		const padding = interactionStyle?.boxPadding ?? 0;
+		const allPixels = [];
+		memberBoxes = lastPreviewFeaturesByMember.map((features) => {
+			const pixels = pixelsFor(features);
+			allPixels.push(...pixels);
+			return fitTransformBox(pixels, angle, padding);
+		});
+		if (activeBoxDrag) return;
+		groupBox = fitTransformBox(allPixels, boxAngle, padding);
+	}
+	function renderAllPreviews() {
+		if (ctx.settled) return;
+		const allFeatures = [];
+		lastPreviewFeaturesByMember = measures.map((_measure, i) => {
+			const working = workingMeasureFor(i);
+			let features;
+			try {
+				features = renderMeasureForAdapter(adapter, working, renderOpts).features;
+			} catch {
+				features = [];
+			}
+			allFeatures.push(...features);
+			return features;
+		});
+		ctx.writeLayer(previewLayer, allFeatures);
+		refitBoxes();
+	}
+	function rescaleOnViewChange() {
+		if (ctx.settled) return;
+		if (measures.some((m) => measureUsesAdapterResolution({
+			kind: m.kind,
+			options: m.options
+		}))) renderAllPreviews();
+		else refitBoxes();
+		renderHandlesLayer();
+	}
+	/**
+	* The group's outline style: the resolved `boxOutline` plus `[4, 4]` dash
+	* so the group reads as dashed per the reference design — unless the host
+	* explicitly set their own `strokeDash`, which wins.
+	*/
+	function groupOutlineStyle() {
+		const base = interactionStyle?.boxOutline;
+		if (base?.strokeDash !== void 0) return base;
+		return {
+			...base ?? {},
+			strokeDash: [4, 4]
+		};
+	}
+	function renderHandlesLayer() {
+		if (ctx.settled) return;
+		const features = [];
+		const liveGroupBox = activeBoxDrag ? activeBoxDrag.lastSnapshot.box : groupBox;
+		if (liveGroupBox) {
+			features.push(boxOutlineFeature(liveGroupBox, dragProjection.fromPixel, `${handleIdPrefix}:box-outline`, groupOutlineStyle()));
+			features.push(...toFeatures(boxToHandles(liveGroupBox, dragProjection.fromPixel), handleIdPrefix, interactionStyle));
+		}
+		measures.forEach((measure, i) => {
+			const memberBox = memberBoxes[i];
+			if (!memberBox) return;
+			features.push(boxOutlineFeature(memberBox, dragProjection.fromPixel, `${handleIdPrefix}:member-outline:${measure.id}`, interactionStyle?.boxOutline));
+		});
+		ctx.writeLayer(handlesLayer, features);
+	}
+	/**
+	* Builds every member's committed snapshot against a given override array
+	* rather than the live `optionsOverrideByMember` — used to render a
+	* gesture's pre-freeze "previous" snapshot when a rotate has already
+	* mutated the live overrides by the time the commit runs.
+	*/
+	function rebuildRenderedAllWith(overrides) {
+		return measures.map((_measure, i) => {
+			const working = workingMeasureForWith(i, overrides);
+			const committed = sizeAnchor === "screen" ? working : bakePixelSizeToGround(working, adapter);
+			return {
+				measure: cloneControlMeasure(committed),
+				render: renderMeasureForAdapter(adapter, committed, renderOpts)
+			};
+		});
+	}
+	function rebuildRenderedAll() {
+		return rebuildRenderedAllWith(optionsOverrideByMember);
+	}
+	function recomputeDirty() {
+		dirty = nonGeometryDirty || workingPointsByMember.some((pts, i) => !pointsEqualWithinTolerance(pts, editStartPointsByMember[i], DIRTY_EPSILON));
+	}
+	/** Split `points` (the concatenation of every member's control points) back per member and write them into `workingPointsByMember`. */
+	function applyConcatenatedPoints(points) {
+		const rounded = roundControlPoints(points);
+		let offset = 0;
+		for (let i = 0; i < counts.length; i++) {
+			const c = counts[i];
+			const slice = rounded.slice(offset, offset + c);
+			workingPointsByMember[i].splice(0, workingPointsByMember[i].length, ...slice);
+			offset += c;
+		}
+	}
+	function concatWorkingPoints() {
+		const out = [];
+		for (const pts of workingPointsByMember) out.push(...pts.map((p) => [...p]));
+		return out;
+	}
+	function clonePointsByMember() {
+		return workingPointsByMember.map((pts) => pts.map((p) => [...p]));
+	}
+	function restorePointsByMember(snapshot) {
+		for (let i = 0; i < workingPointsByMember.length; i++) workingPointsByMember[i].splice(0, workingPointsByMember[i].length, ...snapshot[i]);
+	}
+	function cloneOptionsOverrideByMember() {
+		return optionsOverrideByMember.map((o) => o ? { ...o } : null);
+	}
+	/**
+	* Pin orientation-derived option defaults (e.g. Battle Position's echelon
+	* anchor) for every member, the moment a group rotate gesture starts —
+	* mirrors `edit-controller.ts`'s `freezeOrientationForRotate`, applied
+	* per-member since the group has no single working-options set.
+	*/
+	function freezeOrientationForRotate() {
+		measures.forEach((measure, i) => {
+			const patch = freezeOrientationOptions(measure.kind, workingPointsByMember[i].map((p) => [...p]), effectiveOptions(i));
+			if (patch) optionsOverrideByMember[i] = {
+				...optionsOverrideByMember[i] ?? {},
+				...patch
+			};
+		});
+	}
+	/**
+	* Emit a completed gesture to every registered listener — the group mirror
+	* of `edit-controller.ts`'s `emitChange` (issue #49 contract): same
+	* instance to all listeners in order, deferred `reject`/`close`/`abort`
+	* (close/abort override reject), exception collection with `AggregateError`.
+	*/
+	function emitChange(previousRendered, previousPointsByMember, previousSizeAnchor, previousNonGeometryDirty, previousOptionsOverrideByMember, currentRendered) {
+		if (ctx.settled) return;
+		let rejectRequested = false;
+		let closeRequested = false;
+		let abortRequested = false;
+		const event = {
+			measures: currentRendered,
+			previous: previousRendered,
+			session,
+			reject() {
+				rejectRequested = true;
+			},
+			close() {
+				closeRequested = true;
+			},
+			abort() {
+				abortRequested = true;
+			}
+		};
+		const errors = [];
+		for (const listener of [...changeListeners]) try {
+			listener(event);
+		} catch (err) {
+			errors.push(err);
+		}
+		if (abortRequested) ctx.fail(new TacticalDrawAbortError("session"));
+		else if (closeRequested) ctx.commit(rebuildRenderedAll);
+		else if (rejectRequested && !ctx.settled) {
+			restorePointsByMember(previousPointsByMember);
+			sizeAnchor = previousSizeAnchor;
+			nonGeometryDirty = previousNonGeometryDirty;
+			optionsOverrideByMember = previousOptionsOverrideByMember.map((o) => o ? { ...o } : null);
+			renderAllPreviews();
+			renderHandlesLayer();
+			recomputeDirty();
+		}
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, "TransformSession.onChange listener errors");
+	}
+	function commitGesture(nextConcatPoints, preGestureOptionsOverrideByMember) {
+		if (ctx.settled) return;
+		const previousPointsByMember = clonePointsByMember();
+		const previousOptionsOverrideByMember = preGestureOptionsOverrideByMember ?? cloneOptionsOverrideByMember();
+		const previousRendered = rebuildRenderedAllWith(previousOptionsOverrideByMember);
+		applyConcatenatedPoints(nextConcatPoints);
+		let currentRendered;
+		try {
+			currentRendered = rebuildRenderedAll();
+		} catch (err) {
+			restorePointsByMember(previousPointsByMember);
+			dragInFlight = false;
+			throw err;
+		}
+		renderAllPreviews();
+		renderHandlesLayer();
+		recomputeDirty();
+		dragInFlight = false;
+		emitChange(previousRendered, previousPointsByMember, sizeAnchor, nonGeometryDirty, previousOptionsOverrideByMember, currentRendered);
+	}
+	function setSizeAnchor(next) {
+		if (ctx.settled || sizeAnchor === next) return;
+		const previousPointsByMember = clonePointsByMember();
+		const previousSizeAnchor = sizeAnchor;
+		const previousNonGeometryDirty = nonGeometryDirty;
+		const previousOptionsOverrideByMember = cloneOptionsOverrideByMember();
+		const previousRendered = rebuildRenderedAll();
+		sizeAnchor = next;
+		const currentRendered = rebuildRenderedAll();
+		nonGeometryDirty = true;
+		dirty = true;
+		emitChange(previousRendered, previousPointsByMember, previousSizeAnchor, previousNonGeometryDirty, previousOptionsOverrideByMember, currentRendered);
+	}
+	const session = {
+		measures,
+		controlPointsFor(measureId) {
+			const index = measures.findIndex((m) => m.id === measureId);
+			if (index < 0) return void 0;
+			return workingPointsByMember[index].map((p) => [...p]);
+		},
+		get dirty() {
+			return dirty;
+		},
+		get sizeAnchor() {
+			return sizeAnchor;
+		},
+		setSizeAnchor(next) {
+			setSizeAnchor(next);
+		},
+		close() {
+			if (ctx.settled) return;
+			ctx.commit(rebuildRenderedAll);
+		},
+		abort() {
+			if (ctx.settled) return;
+			ctx.fail(new TacticalDrawAbortError("session"));
+		},
+		onChange(listener) {
+			if (ctx.settled) return () => {};
+			changeListeners.add(listener);
+			return () => {
+				changeListeners.delete(listener);
+			};
+		}
+	};
+	let activeBoxDrag = null;
+	const onDriverDown = (pixel, info) => {
+		if (ctx.settled || dragInFlight) return;
+		if (!groupBox) return;
+		const tol = info?.hitTolerance ?? HANDLE_HIT_TOLERANCE_PX;
+		const boxHit = pickBoxHandle(groupBox, pixel, tol);
+		if (!boxHit) return;
+		const preDragOptionsOverrideByMember = cloneOptionsOverrideByMember();
+		if (boxHit.kind === "rotate") {
+			freezeOrientationForRotate();
+			renderAllPreviews();
+			renderHandlesLayer();
+		}
+		const preDragPoints = concatWorkingPoints();
+		activeBoxDrag = {
+			fsm: beginBoxDrag({
+				kind: boxHit.kind,
+				downPixel: pixel,
+				points: preDragPoints,
+				projection: dragProjection,
+				box: groupBox,
+				cornerIndex: boxHit.kind === "scale" ? boxHit.index : void 0
+			}),
+			preDragPoints,
+			preDragBox: groupBox,
+			downPixel: pixel,
+			lastSnapshot: {
+				points: preDragPoints,
+				box: groupBox
+			},
+			preDragOptionsOverrideByMember
+		};
+		dragInFlight = true;
+		driver.setDragPanEnabled(false);
+	};
+	function paintBoxDragSnapshot(pixel) {
+		if (!activeBoxDrag) return;
+		const snapshot = activeBoxDrag.fsm.move(pixel);
+		activeBoxDrag.lastSnapshot = snapshot;
+		applyConcatenatedPoints(snapshot.points);
+		renderAllPreviews();
+		renderHandlesLayer();
+		recomputeDirty();
+	}
+	const onDriverMove = (pixel) => {
+		if (ctx.settled) return;
+		if (activeBoxDrag) paintBoxDragSnapshot(pixel);
+	};
+	const onDriverUp = (pixel) => {
+		if (!activeBoxDrag) return;
+		if (ctx.settled) {
+			activeBoxDrag = null;
+			dragInFlight = false;
+			driver.setDragPanEnabled(true);
+			return;
+		}
+		const { fsm, preDragPoints, preDragBox, downPixel, preDragOptionsOverrideByMember } = activeBoxDrag;
+		activeBoxDrag = null;
+		driver.setDragPanEnabled(true);
+		const distance = Math.hypot(pixel[0] - downPixel[0], pixel[1] - downPixel[1]);
+		if (fsm.kind === "body" && distance <= CLICK_SLOP_PX) {
+			applyConcatenatedPoints(preDragPoints);
+			renderAllPreviews();
+			renderHandlesLayer();
+			recomputeDirty();
+			dragInFlight = false;
+			suppressClickAway = true;
+			return;
+		}
+		const finalSnapshot = fsm.move(pixel);
+		applyConcatenatedPoints(preDragPoints);
+		if (fsm.kind === "rotate") boxAngle += finalSnapshot.box.angle - preDragBox.angle;
+		commitGesture(finalSnapshot.points, preDragOptionsOverrideByMember);
+	};
+	let pickPreview;
+	let pickHandles;
+	let pickGraphics;
+	const handlePickPreview = (e) => {
+		pickPreview = e;
+	};
+	const handlePickHandles = (e) => {
+		pickHandles = e;
+	};
+	const handlePickGraphics = (e) => {
+		pickGraphics = e;
+	};
+	const handleClick = () => {
+		const localPreview = pickPreview;
+		const localHandles = pickHandles;
+		const localGraphics = pickGraphics;
+		pickPreview = void 0;
+		pickHandles = void 0;
+		pickGraphics = void 0;
+		if (ctx.settled) return;
+		if (!closeOnClickAway) return;
+		if (suppressClickAway) {
+			suppressClickAway = false;
+			return;
+		}
+		if (localPreview || localHandles) return;
+		if (localGraphics && !memberIds.has(localGraphics.id)) {
+			ctx.commit(rebuildRenderedAll);
+			if (onClickAwayGraphicsPick) onClickAwayGraphicsPick(localGraphics);
+			return;
+		}
+		ctx.commit(rebuildRenderedAll);
+	};
+	const core = runInteraction({
+		adapter,
+		signal,
+		layers: [previewLayer, handlesLayer],
+		onViewChange: rescaleOnViewChange,
+		onSettled,
+		attach(c) {
+			ctx = c;
+			driver = adapter.createEditPointerDriver();
+			liftOriginalsFromGraphics();
+			const unsubDown = driver.onPointerDown(onDriverDown);
+			const unsubMove = driver.onPointerMove(onDriverMove);
+			const unsubUp = driver.onPointerUp(onDriverUp);
+			const unsubPickPreview = adapter.onPick(previewLayer, handlePickPreview);
+			const unsubPickHandles = adapter.onPick(handlesLayer, handlePickHandles);
+			const unsubPickGraphics = adapter.onPick(graphicsLayer, handlePickGraphics);
+			adapter.on("click", handleClick);
+			const anyWasOnGraphicsLayer = wasOnGraphicsLayer.some(Boolean);
+			c.onTeardown(() => {
+				adapter.off("click", handleClick);
+				unsubPickPreview();
+				unsubPickHandles();
+				unsubPickGraphics();
+				unsubDown();
+				unsubMove();
+				unsubUp();
+				if (activeBoxDrag !== null) {
+					driver.setDragPanEnabled(true);
+					activeBoxDrag = null;
+					dragInFlight = false;
+				}
+				driver.dispose();
+			}, anyWasOnGraphicsLayer ? restoreOriginalToGraphics : void 0);
+			renderAllPreviews();
+			renderHandlesLayer();
+			recomputeDirty();
+			if (onSession) onSession(session);
+		}
+	});
+	return {
+		promise: core.promise,
+		get settled() {
+			return core.settled;
+		},
+		measureIds: measures.map((m) => m.id),
+		abort(reason, cause) {
+			core.abort(reason, cause);
+		}
+	};
+}
+//#endregion
 //#region src/tactical-draw/errors.ts
 /**
 * Error thrown when any `TacticalDraw` method is called after `destroy()`.
@@ -2324,6 +3200,20 @@ var TacticalDraw = class {
 	*/
 	activeEdit = null;
 	/**
+	* Tracked alongside `activeInteraction` whenever the interaction is a group
+	* transform (`editMany`). The `render()` / view-change paths need every
+	* member's id (to exclude all of them from reconcile) — mirrors `activeEdit`
+	* but for `TransformHandle`'s `measureIds` array.
+	*/
+	activeTransform = null;
+	/**
+	* The live `TransformSession`, exposed via `activeTransformSession`. Set
+	* directly by `editMany`'s `onSession` wrapper (not routed through
+	* `ActiveInteractionTracker.session`, whose type is `DrawSession | EditSession`)
+	* and cleared on settle.
+	*/
+	activeTransformSessionRef = null;
+	/**
 	* Host pick handlers registered via `td.onPick` / `td.onMeasurePick`. The
 	* façade subscribes once to `adapter.onPick` per layer and routes events
 	* through this map so that close-then-pick ordering during an active edit can
@@ -2341,6 +3231,7 @@ var TacticalDraw = class {
 	deferredGraphicsPick = null;
 	idCounter = 0;
 	editCounter = 0;
+	transformCounter = 0;
 	/**
 	* Snapshot of the host's last `render()` argument. The edit slice uses it
 	* to recompute the graphics-layer state during a lift / restore — the
@@ -2392,12 +3283,24 @@ var TacticalDraw = class {
 	*/
 	handleViewChange = () => {
 		if (this.destroyed || !this.hasRendered) return;
-		const editedId = this.activeEdit?.measureId;
-		const visible = editedId !== void 0 ? this.lastRenderedMeasures.filter((m) => m.id !== editedId) : this.lastRenderedMeasures;
+		const excluded = this.excludedInteractionIds();
+		const visible = excluded.size > 0 ? this.lastRenderedMeasures.filter((m) => !excluded.has(m.id)) : this.lastRenderedMeasures;
 		if (!visible.some(measureUsesAdapterResolution)) return;
 		this.renderMeasuresToGraphics(visible);
 	};
 	/**
+	* Every measure id currently lifted onto the preview layer by an active
+	* edit or group transform — excluded from `render()` / view-change
+	* reconciliation because the preview layer (not graphics) owns their
+	* working copy. Empty while idle.
+	*/
+	excludedInteractionIds() {
+		const ids = /* @__PURE__ */ new Set();
+		if (this.activeEdit) ids.add(this.activeEdit.measureId);
+		if (this.activeTransform) for (const id of this.activeTransform.measureIds) ids.add(id);
+		return ids;
+	}
+	/**
 	* Reconcile the graphics layer against the authoritative list of measures.
 	* Idempotent. Throws synchronously on duplicate measure ids *before*
 	* mutating any layer. An empty list before any prior render is a no-op.
@@ -2436,7 +3339,10 @@ var TacticalDraw = class {
 			externalEdited = measures.find((m) => m.id === editedId);
 			editedRemoved = externalEdited === void 0;
 		}
-		const visible = editedId !== void 0 ? measures.filter((m) => m.id !== editedId) : measures;
+		const transformIds = this.activeTransform?.measureIds;
+		const transformMemberRemoved = transformIds ? transformIds.some((id) => !seen.has(id)) : false;
+		const excluded = this.excludedInteractionIds();
+		const visible = excluded.size > 0 ? measures.filter((m) => !excluded.has(m.id)) : measures;
 		if (!(visible.length === 0 && !this.hasRendered)) {
 			this.renderMeasuresToGraphics(visible);
 			this.hasRendered = true;
@@ -2449,6 +3355,12 @@ var TacticalDraw = class {
 				editHandle.abort("removed");
 			});
 		}
+		if (transformMemberRemoved && this.activeTransform) {
+			const transformHandle = this.activeTransform;
+			queueMicrotask(() => {
+				transformHandle.abort("removed");
+			});
+		}
 	}
 	/**
 	* Nested-call guard + preempt, shared by `draw` and `edit`. Returns a
@@ -2466,6 +3378,8 @@ var TacticalDraw = class {
 		}
 		if (this.activeInteraction.isActive) {
 			this.activeEdit = null;
+			this.activeTransform = null;
+			this.activeTransformSessionRef = null;
 			this.activeInteraction.cancel("preempted");
 		}
 		return null;
@@ -2481,14 +3395,17 @@ var TacticalDraw = class {
 	* whose `onSettled` fired before `active` was assigned. `extraSettle` runs the
 	* caller's own teardown (guide-style revert, dbl-click-zoom re-enable).
 	*/
-	runWithSlot(create, editHandleOf, extraSettle) {
+	runWithSlot(create, activate, extraSettle) {
 		let handle;
-		let editHandle = null;
+		let deactivate = null;
 		let settledDuringCreate = false;
 		const clearSlot = () => {
 			if (handle) {
 				this.activeInteraction.clear(handle);
-				if (editHandle && this.activeEdit === editHandle) this.activeEdit = null;
+				if (deactivate) {
+					deactivate();
+					deactivate = null;
+				}
 			} else {
 				settledDuringCreate = true;
 				this.activeInteraction.clear();
@@ -2501,7 +3418,6 @@ var TacticalDraw = class {
 		this.activeInteraction.begin();
 		try {
 			handle = create(onSettled);
-			editHandle = editHandleOf ? editHandleOf(handle) : null;
 		} catch (error) {
 			this.activeInteraction.clear();
 			if (!settledDuringCreate && extraSettle) extraSettle();
@@ -2509,7 +3425,7 @@ var TacticalDraw = class {
 		}
 		if (!settledDuringCreate) {
 			this.activeInteraction.set(handle);
-			if (editHandle && !handle.settled) this.activeEdit = editHandle;
+			if (activate && !handle.settled) deactivate = activate(handle) ?? null;
 		}
 		handle.promise.then(clearSlot, clearSlot);
 		return handle.promise;
@@ -2525,6 +3441,18 @@ var TacticalDraw = class {
 		};
 	}
 	/**
+	* Wrap a host `onSession` callback for `editMany`, recording the session on
+	* `activeTransformSessionRef` (exposed via `activeTransformSession`) before
+	* the host's own handler runs. Separate from `trackSession` because
+	* `ActiveInteractionTracker.session` is typed `DrawSession | EditSession`.
+	*/
+	trackTransformSession(hostOnSession) {
+		return (session) => {
+			this.activeTransformSessionRef = session;
+			hostOnSession?.(session);
+		};
+	}
+	/**
 	* Start an interactive draw. Fixed-length kinds commit automatically on the
 	* last required click. Variable-length kinds surface a `DrawSession` via
 	* `opts.onSession` and commit on `session.commit()`, `dblclick`, or a second
@@ -2551,6 +3479,7 @@ var TacticalDraw = class {
 			adapter: this.adapter,
 			kind,
 			previewLayer: this.previewLayer,
+			guideLayer: this.guideLayer,
 			graphicsStyle: this.graphicsStyle,
 			generateId: () => draft.id ?? this.generateId(),
 			signal: options?.signal,
@@ -2590,9 +3519,7 @@ var TacticalDraw = class {
 	*/
 	edit(measure, options) {
 		this.assertAlive();
-		if (options?.modes) {
-			for (const m of options.modes) if (m === "scale") throw new TypeError(`td.edit: edit mode "scale" is reserved and not yet implemented`);
-		}
+		normaliseModes(options?.modes);
 		const preempt = this.guardAndPreempt();
 		if (preempt) return preempt;
 		const wasOnGraphicsLayer = this.lastRenderedMeasures.some((m) => m.id === measure.id);
@@ -2625,7 +3552,71 @@ var TacticalDraw = class {
 			wasOnGraphicsLayer,
 			onSettled,
 			onClickAwayGraphicsPick
-		}), (handle) => handle, revertGuideStyle);
+		}), (handle) => {
+			this.activeEdit = handle;
+			return () => {
+				if (this.activeEdit === handle) this.activeEdit = null;
+			};
+		}, revertGuideStyle);
+	}
+	/**
+	* Start an interactive group transform (multi-select) over `measures`
+	* (ADR-0017 "Multi-select" slice). Every member is lifted onto the shared
+	* preview layer; the box (corner scale, rotate grip, drag-anywhere body
+	* translate) applies rigidly to all of them at once. Returns a Promise that
+	* resolves with index-aligned `ControlMeasureSnapshot[]` on
+	* `session.close()` and rejects with `TacticalDrawAbortError` on
+	* signal / Escape / destroy / preempt / `session.abort()`.
+	*
+	* `measures.length` must be >= 1; a single-element array behaves like an
+	* `edit` with only `transform` mode. Throws `TypeError` synchronously (before
+	* any preemption) for an empty array or duplicate ids.
+	*/
+	editMany(measures, options) {
+		this.assertAlive();
+		if (measures.length === 0) throw new TypeError("td.editMany: measures must not be empty");
+		const seenIds = /* @__PURE__ */ new Set();
+		for (const m of measures) {
+			if (seenIds.has(m.id)) throw new TypeError(`td.editMany: duplicate control measure id "${m.id}"`);
+			seenIds.add(m.id);
+		}
+		const preempt = this.guardAndPreempt();
+		if (preempt) return preempt;
+		const wasOnGraphicsLayer = measures.map((m) => this.lastRenderedMeasures.some((rendered) => rendered.id === m.id));
+		const restoreOriginalToGraphics = () => {
+			this.renderMeasuresToGraphics(this.lastRenderedMeasures);
+		};
+		const handleIdPrefix = `__td_transform_${++this.transformCounter}__`;
+		const mergedInteractionStyle = this.resolveInteractionStyle(options?.interactionStyle);
+		const onClickAwayGraphicsPick = (event) => {
+			this.dispatchHostPick(this.graphicsLayer, event);
+		};
+		const extraSettle = () => {
+			this.activeTransformSessionRef = null;
+		};
+		return this.runWithSlot((onSettled) => runGroupTransform({
+			adapter: this.adapter,
+			measures,
+			graphicsLayer: this.graphicsLayer,
+			previewLayer: this.previewLayer,
+			handlesLayer: this.handlesLayer,
+			graphicsStyle: this.graphicsStyle,
+			signal: options?.signal,
+			closeOnClickAway: options?.closeOnClickAway,
+			interactionStyle: mergedInteractionStyle,
+			onSession: this.trackTransformSession(options?.onSession),
+			handleIdPrefix,
+			sizeAnchor: options?.sizeAnchor,
+			restoreOriginalToGraphics,
+			wasOnGraphicsLayer,
+			onSettled,
+			onClickAwayGraphicsPick
+		}), (handle) => {
+			this.activeTransform = handle;
+			return () => {
+				if (this.activeTransform === handle) this.activeTransform = null;
+			};
+		}, extraSettle);
 	}
 	/**
 	* Subscribe to picks on committed control measures.
@@ -2693,6 +3684,15 @@ var TacticalDraw = class {
 		return this.activeInteraction.session;
 	}
 	/**
+	* The live `editMany` group-transform session, or `null` while idle (and
+	* during any other interaction). Separate from `activeSession` because
+	* `TransformSession` isn't part of its `DrawSession | EditSession` union —
+	* see `activeTransformSessionRef`. Safe to read after `destroy()`.
+	*/
+	get activeTransformSession() {
+		return this.activeTransformSessionRef;
+	}
+	/**
 	* Tear down the façade. Releases only layer slots the façade created; host
 	* supplied layer ids are left untouched. Safe to call multiple times. After
 	* the first call every public method throws `TacticalDrawDestroyedError`.
@@ -2702,6 +3702,8 @@ var TacticalDraw = class {
 		this.destroyed = true;
 		if (this.activeInteraction.isActive) {
 			this.activeEdit = null;
+			this.activeTransform = null;
+			this.activeTransformSessionRef = null;
 			this.activeInteraction.cancel("destroyed");
 		} else this.activeInteraction.clear();
 		this.adapter.offViewChange(this.handleViewChange);
@@ -2721,7 +3723,8 @@ var TacticalDraw = class {
 	* from a host pick handler observes a settled session.
 	*/
 	routePick(layerId, event) {
-		if (layerId === this.graphicsLayer && this.activeEdit !== null && this.activeEdit.measureId !== event.id) {
+		const excluded = this.excludedInteractionIds();
+		if (layerId === this.graphicsLayer && excluded.size > 0 && !excluded.has(event.id)) {
 			this.deferredGraphicsPick = event;
 			return;
 		}
@@ -2760,9 +3763,19 @@ var TacticalDraw = class {
 		return mergeSlot(BUILT_IN_INTERACTION_STYLE.guide, this.defaultInteractionStyle?.guide);
 	}
 	/**
-	* Resolve handle slots across built-in → façade → per-call with per-slot,
-	* per-property shallow merge. Explicit `undefined` at a higher-priority
-	* layer unsets the corresponding lower-priority field (ADR-0006).
+	* Resolve handle slots (plus `boxOutline`) across built-in → façade →
+	* per-call with per-slot, per-property shallow merge. Explicit `undefined`
+	* at a higher-priority layer unsets the corresponding lower-priority field
+	* (ADR-0006). `boxOutline` rides this same per-feature merge path (not the
+	* `guide` layer-style path) — the edit controller reads it off
+	* `properties.style` on the box outline `LineString` (ADR-0017).
+	*
+	* `boxPadding` is a scalar, not a mergeable style object, so it resolves
+	* separately with the same façade → per-call precedence and the same
+	* explicit-undefined-wins rule: a `boxPadding` key present at a
+	* higher-priority layer (even set to `undefined`) wins over a lower layer's
+	* value. There is no built-in `boxPadding` — an absent value at every layer
+	* falls through to the controllers' own `?? 0` default.
 	*
 	* Returns `undefined` only when no slot would carry any value — keeps the
 	* downstream "no style on the feature" path intact for tests that assert
@@ -2774,6 +3787,10 @@ var TacticalDraw = class {
 			const merged = mergeSlot(mergeSlot(BUILT_IN_INTERACTION_STYLE[slot], this.defaultInteractionStyle?.[slot]), perCall?.[slot]);
 			if (merged) out[slot] = merged;
 		}
+		const boxOutline = mergeSlot(mergeSlot(BUILT_IN_INTERACTION_STYLE.boxOutline, this.defaultInteractionStyle?.boxOutline), perCall?.boxOutline);
+		if (boxOutline) out.boxOutline = boxOutline;
+		const boxPadding = perCall && "boxPadding" in perCall ? perCall.boxPadding : this.defaultInteractionStyle && "boxPadding" in this.defaultInteractionStyle ? this.defaultInteractionStyle.boxPadding : void 0;
+		if (typeof boxPadding === "number") out.boxPadding = boxPadding;
 		return out;
 	}
 	assertAlive() {
@@ -2790,10 +3807,12 @@ const BUILT_IN_GRAPHICS_STYLE = {
 	strokeWidth: 2
 };
 /**
-* Built-in defaults for the interaction-affordance slots. The translate grip
-* sits on the centroid pivot and the rotate grip just outside the shape; their
-* distinct fills (blue / green) set them apart from the white vertex and gray
-* midpoint handles. See ADR-0006.
+* Built-in defaults for the interaction-affordance slots (ADR-0006, extended
+* for the ADR-0017 transform box). The scale (corner) grips are white-filled
+* with the same blue stroke as the box outline, so the box reads as one
+* coherent affordance; the rotate grip keeps its distinct green fill so it
+* doesn't get mistaken for a corner. Vertex/midpoint keep their existing
+* white/gray family.
 */
 const BUILT_IN_INTERACTION_STYLE = {
 	guide: {
@@ -2801,6 +3820,10 @@ const BUILT_IN_INTERACTION_STYLE = {
 		strokeWidth: 1,
 		strokeDash: [6, 4]
 	},
+	boxOutline: {
+		strokeColor: "#4f7cff",
+		strokeWidth: 1
+	},
 	vertexHandle: {
 		pointRadius: 6,
 		fillColor: "#ffffff",
@@ -2813,13 +3836,14 @@ const BUILT_IN_INTERACTION_STYLE = {
 		strokeColor: "#6b7280",
 		strokeWidth: 1.5
 	},
-	translateHandle: {
-		pointRadius: 7,
-		fillColor: "#2563eb",
-		strokeColor: "#ffffff"
+	scaleHandle: {
+		pointRadius: 5,
+		fillColor: "#ffffff",
+		strokeColor: "#4f7cff",
+		strokeWidth: 2
 	},
 	rotateHandle: {
-		pointRadius: 7,
+		pointRadius: 5,
 		fillColor: "#16a34a",
 		strokeColor: "#ffffff"
 	}
@@ -2827,7 +3851,7 @@ const BUILT_IN_INTERACTION_STYLE = {
 const HANDLE_SLOTS = [
 	"vertexHandle",
 	"midpointHandle",
-	"translateHandle",
+	"scaleHandle",
 	"rotateHandle"
 ];
 /**