@orbat-mapper/tactical-draw 0.2.0-alpha.1 → 0.2.0-alpha.11

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.
@@ -519,17 +519,21 @@ const PIXEL_SIZE_OPTIONS = {
 		pixels: "echelonSizePixels",
 		meters: "echelonSize"
 	},
+	"strong-point": {
+		pixels: "echelonSizePixels",
+		meters: "echelonSize"
+	},
 	flot: {
 		pixels: "radiusPixels",
 		meters: "radius"
 	},
 	"fortified-line": {
-		pixels: "sizePixels",
-		meters: "size"
+		pixels: "toothSizePixels",
+		meters: "toothSize"
 	},
 	"fortified-area": {
-		pixels: "sizePixels",
-		meters: "size"
+		pixels: "toothSizePixels",
+		meters: "toothSize"
 	},
 	"antitank-ditch-under-construction": {
 		pixels: "toothHeightPixels",
@@ -596,7 +600,7 @@ function bakePixelSizeToGround(measure, adapter) {
 /**
 * Stamp the adapter's current `metersPerPixel` onto a measure that sizes itself
 * in pixels, so the generator resolves pixel options (`radiusPixels`,
-* `sizePixels`, `toothHeightPixels`) against the live map zoom. Returns the
+* `toothSizePixels`, `toothHeightPixels`) against the live map zoom. Returns the
 * measure unchanged when the adapter has no usable resolution or the
 * kind/options don't opt into pixel sizing.
 */
@@ -695,7 +699,7 @@ function runInteraction(spec) {
 		clearLayers();
 	}
 	function commit(produce) {
-		if (settled) return;
+		if (settled) return void 0;
 		let value;
 		try {
 			value = produce();
@@ -703,13 +707,20 @@ function runInteraction(spec) {
 			settled = true;
 			teardown();
 			rejectFn(err);
-			if (onSettled) onSettled();
+			if (onSettled) onSettled({
+				status: "rejected",
+				error: err
+			});
 			return;
 		}
 		settled = true;
 		teardown();
 		resolveFn(value);
-		if (onSettled) onSettled();
+		if (onSettled) onSettled({
+			status: "committed",
+			value
+		});
+		return value;
 	}
 	function fail(error) {
 		if (settled) return;
@@ -719,7 +730,10 @@ function runInteraction(spec) {
 			controllerOnAbort();
 		} catch {}
 		rejectFn(error);
-		if (onSettled) onSettled();
+		if (onSettled) onSettled({
+			status: "rejected",
+			error
+		});
 	}
 	const ctx = {
 		get settled() {
@@ -769,6 +783,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";
@@ -786,7 +876,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;
@@ -796,6 +886,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;
@@ -820,11 +912,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({
@@ -852,7 +948,7 @@ function runFixedLengthDraw(options) {
 	return runInteraction({
 		adapter,
 		signal,
-		layers: [previewLayer],
+		layers: [previewLayer, guideLayer],
 		onViewChange: rescaleOnViewChange,
 		onSettled,
 		attach(c) {
@@ -911,77 +1007,115 @@ 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`;
+//#region src/tactical-draw/session-events.ts
 /**
-* 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.
+* Map a settle-time error to its `SettleReason`: a `TacticalDrawAbortError`
+* replays its own `reason` verbatim; anything else (a `produce` throw from
+* `ctx.commit`) is the commit-time snapshot build failing, reported as
+* `"error"`.
 */
-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;
+function settleReasonFromError(error) {
+	return isTacticalDrawAbortError(error) ? error.reason : "error";
 }
 /**
-* 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.
+* Fan a `runInteraction` settlement out to a session's commit + settle
+* emitters — the shared body of the `onSettled` wrappers in the edit and draw
+* controllers (transform emits its close-path settle from `commitClose`
+* instead, so it does not use this). On the commit path, emit the snapshot
+* then the `"close"` settle in a try/finally so a throwing `onCommit` listener
+* cannot starve the settle emission; on the reject path, emit the settle with
+* the reason derived from the error. Callers run their own facade
+* slot-clearing (`onSettled()`) before this so a listener observes a cleared
+* `td.activeSession`.
 */
-function shouldSuppressGuide(metadata) {
-	return metadata.geometry === "point" || isFixedLength(metadata);
+function settleFromInteraction(settlement, commitEmitter, settleEmitter) {
+	if (settlement.status === "committed") try {
+		commitEmitter.emit(settlement.value);
+	} finally {
+		settleEmitter.emit("close");
+	}
+	else settleEmitter.emit(settleReasonFromError(settlement.error));
 }
 /**
-* 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`.
+* Subscribe/emit machinery shared by `TransformSession.onSettled`,
+* `EditSession.onSettled`, and `DrawSession.onSettled` (#191 / #194 / #197):
+* a settle-exactly-once latch, synchronous emission to every listener with
+* exception collection (single rethrow, `AggregateError` otherwise when more
+* than one listener throws), and a late-registration path that delivers the
+* latched reason on a microtask exactly once when a handler subscribes after
+* the session has already settled.
 *
-* Callers are responsible for the opt-out (`guide: false`) and the suppression
-* check via [[shouldSuppressGuide]] — this function only emits geometry.
+* `listenerErrorsMessage` becomes the `AggregateError` message — pass a
+* session-specific string (e.g. `"EditSession.onSettled listener errors"`).
 */
-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"
+function createSettleEmitter(listenerErrorsMessage) {
+	const listeners = /* @__PURE__ */ new Set();
+	/** Set exactly once, by `emit` — also the "has settled" latch and the reason replayed to late registrations. */
+	let settledReason = null;
+	return {
+		emit(reason) {
+			if (settledReason !== null) return;
+			settledReason = reason;
+			const current = [...listeners];
+			listeners.clear();
+			const errors = [];
+			for (const listener of current) try {
+				listener(reason);
+			} catch (err) {
+				errors.push(err);
 			}
-		};
-		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"
+			if (errors.length === 1) throw errors[0];
+			if (errors.length > 1) throw new AggregateError(errors, listenerErrorsMessage);
+		},
+		register(handler) {
+			if (settledReason !== null) {
+				const reason = settledReason;
+				let cancelled = false;
+				queueMicrotask(() => {
+					if (!cancelled) handler(reason);
+				});
+				return () => {
+					cancelled = true;
+				};
 			}
-		};
-		features.push(closing);
-	}
-	return features;
+			listeners.add(handler);
+			return () => {
+				listeners.delete(handler);
+			};
+		}
+	};
+}
+/**
+* Subscribe/emit machinery shared by `TransformSession.onCommit`,
+* `EditSession.onCommit`, and `DrawSession.onCommit`: a listener set with
+* synchronous, exception-collecting emission (single rethrow, `AggregateError`
+* otherwise). Unlike `createSettleEmitter`, `emit` may be called more than
+* once — a transform's `setMembers` can commit several removal batches before
+* the close batch — and there is no latch or late-registration path:
+* registration-time `ctx.settled` guards stay in the controllers, mirroring
+* `onChange`.
+*/
+function createCommitEmitter(listenerErrorsMessage) {
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		emit(value) {
+			const current = [...listeners];
+			const errors = [];
+			for (const listener of current) try {
+				listener(value);
+			} catch (err) {
+				errors.push(err);
+			}
+			if (errors.length === 1) throw errors[0];
+			if (errors.length > 1) throw new AggregateError(errors, listenerErrorsMessage);
+		},
+		register(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
 }
 //#endregion
 //#region src/tactical-draw/draw-controller-variable.ts
@@ -1002,6 +1136,7 @@ function runVariableLengthDraw(options) {
 	const max = metadata.maxCoordinates;
 	const rule = metadata.rule;
 	const trailingFixed = rule?.trailingFixedSlots ?? 0;
+	const closedRing = rule?.closedRing ?? false;
 	const ruleMin = rule?.minimumUserPoints;
 	const guideEnabled = (guideOpt ?? true) && !shouldSuppressGuide(metadata);
 	const isAreaKind = metadata.geometry === "area";
@@ -1040,6 +1175,8 @@ function runVariableLengthDraw(options) {
 	let ctx;
 	const savedCursor = "";
 	const changeListeners = /* @__PURE__ */ new Set();
+	const commitEmitter = createCommitEmitter("DrawSession.onCommit listener errors");
+	const settleEmitter = createSettleEmitter("DrawSession.onSettled listener errors");
 	function canCommitNow() {
 		const n = committed.length;
 		if (typeof max === "number" && n > max) return false;
@@ -1076,6 +1213,13 @@ function runVariableLengthDraw(options) {
 			return () => {
 				changeListeners.delete(listener);
 			};
+		},
+		onCommit(listener) {
+			if (ctx.settled) return () => {};
+			return commitEmitter.register(listener);
+		},
+		onSettled(handler) {
+			return settleEmitter.register(handler);
 		}
 	};
 	function fireChange() {
@@ -1093,20 +1237,20 @@ function runVariableLengthDraw(options) {
 		if (ctx.settled) return;
 		const pos = roundControlPoint(event.coordinate);
 		const lastSpineIdx = committed.length - 1 - trailingFixed;
+		const finishIndices = closedRing && lastSpineIdx > 0 ? [lastSpineIdx, 0] : [lastSpineIdx];
 		for (let i = 0; i < committed.length; i++) if (positionsEqual(pos, committed[i])) {
-			if (i === lastSpineIdx && canCommitNow()) ctx.commit(buildSnapshot);
+			if (finishIndices.includes(i) && canCommitNow()) ctx.commit(buildSnapshot);
 			return;
 		}
-		if (lastSpineIdx >= 0 && canCommitNow()) {
-			const lastPixel = adapter.getPixelFromCoordinate(committed[lastSpineIdx]);
-			if (lastPixel) {
-				const tol = mapEventHitTolerance(event.originalEvent);
-				const dx = event.pixel[0] - lastPixel[0];
-				const dy = event.pixel[1] - lastPixel[1];
-				if (dx * dx + dy * dy <= tol * tol) {
-					ctx.commit(buildSnapshot);
-					return;
-				}
+		if (lastSpineIdx >= 0 && canCommitNow()) for (const finishIndex of finishIndices) {
+			const finishPixel = adapter.getPixelFromCoordinate(committed[finishIndex]);
+			if (!finishPixel) continue;
+			const tol = mapEventHitTolerance(event.originalEvent);
+			const dx = event.pixel[0] - finishPixel[0];
+			const dy = event.pixel[1] - finishPixel[1];
+			if (dx * dx + dy * dy <= tol * tol) {
+				ctx.commit(buildSnapshot);
+				return;
 			}
 		}
 		if (typeof max === "number" && committed.length >= max) return;
@@ -1175,7 +1319,10 @@ function runVariableLengthDraw(options) {
 		signal,
 		layers: [previewLayer, guideLayer],
 		onViewChange: rescaleOnViewChange,
-		onSettled,
+		onSettled: (settlement) => {
+			if (onSettled) onSettled();
+			settleFromInteraction(settlement, commitEmitter, settleEmitter);
+		},
 		attach(c) {
 			ctx = c;
 			c.onTeardown(() => {
@@ -1246,63 +1393,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;
@@ -1328,26 +1426,26 @@ 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 } = options;
+	const { includeMidpoints = true, trailingFixedSlots = 0, closedRing = false } = options;
 	const handles = [];
 	const wantsReshape = modes.includes("reshape");
 	if (wantsReshape || modes.includes("delete")) {
@@ -1357,37 +1455,24 @@ function buildHandleSet(controlPoints, modes, options = {}) {
 			position: [...controlPoints[i]]
 		});
 		if (wantsReshape && includeMidpoints) {
-			const midpointLimit = controlPoints.length - 1 - trailingFixedSlots;
-			for (let i = 0; i < midpointLimit; i++) handles.push({
-				kind: "midpoint",
-				index: i,
-				position: segmentMidpoint(controlPoints[i], controlPoints[i + 1])
-			});
+			const edgeCount = closedRing && trailingFixedSlots === 0 && controlPoints.length >= 3 ? controlPoints.length : controlPoints.length - 1 - trailingFixedSlots;
+			for (let i = 0; i < edgeCount; i++) {
+				const end = (i + 1) % controlPoints.length;
+				handles.push({
+					kind: "midpoint",
+					index: i,
+					position: segmentMidpoint(controlPoints[i], controlPoints[end])
+				});
+			}
 		}
 	}
-	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`;
 	}
 }
@@ -1395,16 +1480,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) => {
@@ -1427,24 +1514,140 @@ 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
@@ -1460,17 +1663,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
@@ -1528,7 +1722,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({
@@ -1538,45 +1732,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 mid = segmentMidpoint(preDragPoints[hit.index], preDragPoints[hit.index + 1]);
-		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
+		};
+	}
+	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 {
+			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;
+	const origin = fromPixel(downPixel);
+	const move = (pixel) => {
+		const cur = fromPixel(pixel);
 		return {
-			points: rotatePointsAround(preDragPoints, pivot, pivotPixel, angle, projection),
-			rotateGripOverride: rotatePointsAround([startGrip], pivot, pivotPixel, angle, projection)[0]
+			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
@@ -1598,8 +1850,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
 */
@@ -1620,6 +1874,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
@@ -1628,27 +1954,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;
@@ -1658,6 +1989,7 @@ function runEdit(opts) {
 	const rule = metadata.rule;
 	const midpointHandlesEnabled = rule?.canonicalPointCount === void 0;
 	const trailingFixedSlots = rule?.trailingFixedSlots ?? 0;
+	const closedRing = rule?.closedRing ?? false;
 	const guideEnabled = (guideOpt ?? true) && !shouldSuppressGuide(metadata);
 	const isAreaKind = metadata.geometry === "area";
 	const requestedModes = normaliseModes(initialModes);
@@ -1688,12 +2020,57 @@ function runEdit(opts) {
 	*/
 	let pendingModes = null;
 	const changeListeners = /* @__PURE__ */ new Set();
+	const commitEmitter = createCommitEmitter("EditSession.onCommit listener errors");
+	const settleEmitter = createSettleEmitter("EditSession.onSettled listener errors");
+	/**
+	* 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");
@@ -1714,37 +2091,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
-		});
-		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);
+			trailingFixedSlots,
+			closedRing
+		}), 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);
@@ -1753,8 +2141,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));
@@ -1763,6 +2154,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
@@ -1828,19 +2236,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;
@@ -1930,16 +2339,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;
@@ -1978,8 +2394,7 @@ function runEdit(opts) {
 			return sizeAnchor;
 		},
 		close() {
-			if (ctx.settled) return;
-			ctx.commit(rebuildRendered);
+			return ctx.commit(rebuildRendered);
 		},
 		abort() {
 			if (ctx.settled) return;
@@ -2010,6 +2425,13 @@ function runEdit(opts) {
 				changeListeners.delete(listener);
 			};
 		},
+		onCommit(listener) {
+			if (ctx.settled) return () => {};
+			return commitEmitter.register(listener);
+		},
+		onSettled(handler) {
+			return settleEmitter.register(handler);
+		},
 		[COMMIT_GESTURE_FOR_TEST]: (nextPoints) => {
 			commitGesture(nextPoints);
 		},
@@ -2031,13 +2453,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
@@ -2076,73 +2499,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
+			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;
@@ -2186,7 +2685,10 @@ function runEdit(opts) {
 			handlesLayer
 		],
 		onViewChange: rescaleOnViewChange,
-		onSettled,
+		onSettled: (settlement) => {
+			if (onSettled) onSettled();
+			settleFromInteraction(settlement, commitEmitter, settleEmitter);
+		},
 		attach(c) {
 			ctx = c;
 			driver = adapter.createEditPointerDriver();
@@ -2206,10 +2708,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();
@@ -2237,12 +2739,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 = [];
@@ -2270,6 +2777,641 @@ 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
+*  - membership is mutable via `session.setMembers` (#187): members join/leave
+*    a live session without a session boundary
+*/
+function runGroupTransform(opts) {
+	const { adapter, measures, graphicsLayer, previewLayer, handlesLayer, graphicsStyle, signal, closeOnClickAway = true, interactionStyle, onSession, handleIdPrefix, restoreOriginalToGraphics, isOnGraphicsLayer, onSettled, onClickAwayGraphicsPick } = opts;
+	const renderOpts = graphicsStyle ? { graphicsStyle } : void 0;
+	let sizeAnchor = opts.sizeAnchor ?? "ground";
+	/** Build a fresh working record for `measure`, snapshotting its edit-start points. */
+	function createMemberState(measure) {
+		const editStartPoints = measure.controlPoints.map((p) => [...p]);
+		return {
+			measure,
+			editStartPoints,
+			workingPoints: editStartPoints.map((p) => [...p]),
+			optionsOverride: null,
+			box: null,
+			lastPreviewFeatures: []
+		};
+	}
+	/** The single mutable source of truth for the current member set. */
+	let members = measures.map(createMemberState);
+	/**
+	* `true` once any member has been lifted off the graphics layer (initial or a
+	* mid-session `setMembers` add). Gates the abort-path restore so a session
+	* that never touched the graphics layer doesn't rewrite it on abort.
+	*/
+	let anyLiftedFromGraphics = false;
+	/** A member's own options merged with an override patch (a null override leaves them unchanged). */
+	function mergeOptions(base, override) {
+		if (!override) return base;
+		return {
+			...base ?? {},
+			...override
+		};
+	}
+	/** Effective options for member `i`: its own options merged with its *live* override. */
+	function effectiveOptions(i) {
+		const member = members[i];
+		return mergeOptions(member.measure.options, member.optionsOverride);
+	}
+	/** Build a member's committed snapshot with a given override, baking pixel size to ground unless "screen". */
+	function buildMemberSnapshot(member, override) {
+		const working = {
+			...member.measure,
+			options: mergeOptions(member.measure.options, override),
+			controlPoints: member.workingPoints.map((p) => [...p])
+		};
+		const committed = sizeAnchor === "screen" ? working : bakePixelSizeToGround(working, adapter);
+		return {
+			measure: cloneControlMeasure(committed),
+			render: renderMeasureForAdapter(adapter, committed, renderOpts)
+		};
+	}
+	/** The working measure for member `i`: original measure, live effective options, live working points. */
+	function workingMeasureFor(i) {
+		const member = members[i];
+		return {
+			...member.measure,
+			options: effectiveOptions(i),
+			controlPoints: member.workingPoints.map((p) => [...p])
+		};
+	}
+	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();
+	const commitEmitter = createCommitEmitter("TransformSession.onCommit listener errors");
+	const settleEmitter = createSettleEmitter("TransformSession.onSettled listener errors");
+	/** 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;
+	let ctx;
+	let driver;
+	const dragProjection = {
+		toPixel: (lonLat) => driver.toPixel(lonLat),
+		fromPixel: (pixel) => driver.fromPixel(pixel)
+	};
+	/**
+	* Lift `member` off the graphics layer when the host reports it currently
+	* there, flipping `anyLiftedFromGraphics` so the abort path knows to restore.
+	* Used for both initial and mid-session-added members.
+	*/
+	function liftMemberFromGraphics(member) {
+		if (!isOnGraphicsLayer(member.measure.id)) return;
+		const ids = renderMeasureForAdapter(adapter, member.measure, renderOpts).features.map((f) => f.id).filter((id) => typeof id === "string");
+		if (ids.length > 0) adapter.removeFeatures(graphicsLayer, ids);
+		anyLiftedFromGraphics = true;
+	}
+	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 member's `box` from their `lastPreviewFeatures`.
+	* 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 = [];
+		for (const member of members) {
+			const pixels = pixelsFor(member.lastPreviewFeatures);
+			allPixels.push(...pixels);
+			member.box = fitTransformBox(pixels, angle, padding);
+		}
+		if (activeBoxDrag) return;
+		groupBox = fitTransformBox(allPixels, boxAngle, padding);
+	}
+	function renderAllPreviews() {
+		if (ctx.settled) return;
+		const allFeatures = [];
+		members.forEach((member, i) => {
+			const working = workingMeasureFor(i);
+			let features;
+			try {
+				features = renderMeasureForAdapter(adapter, working, renderOpts).features;
+			} catch {
+				features = [];
+			}
+			member.lastPreviewFeatures = features;
+			allFeatures.push(...features);
+		});
+		ctx.writeLayer(previewLayer, allFeatures);
+		refitBoxes();
+	}
+	function rescaleOnViewChange() {
+		if (ctx.settled) return;
+		if (members.some((m) => measureUsesAdapterResolution({
+			kind: m.measure.kind,
+			options: m.measure.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));
+		}
+		for (const member of members) {
+			const memberBox = member.box;
+			if (!memberBox) continue;
+			features.push(boxOutlineFeature(memberBox, dragProjection.fromPixel, `${handleIdPrefix}:member-outline:${member.measure.id}`, interactionStyle?.boxOutline));
+		}
+		ctx.writeLayer(handlesLayer, features);
+	}
+	/**
+	* Builds every member's committed snapshot against a given override array
+	* rather than the live per-member override — 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. Index-aligned with `members`, which
+	* is sound because membership cannot change within a gesture emission.
+	*/
+	function rebuildRenderedAllWith(overrides) {
+		return members.map((member, i) => buildMemberSnapshot(member, overrides[i] ?? null));
+	}
+	function rebuildRenderedAll() {
+		return members.map((member) => buildMemberSnapshot(member, member.optionsOverride));
+	}
+	function recomputeDirty() {
+		dirty = nonGeometryDirty || members.some((m) => !pointsEqualWithinTolerance(m.workingPoints, m.editStartPoints, DIRTY_EPSILON));
+	}
+	/** Split `points` (the concatenation of every member's control points) back per member. */
+	function applyConcatenatedPoints(points) {
+		const rounded = roundControlPoints(points);
+		let offset = 0;
+		for (const member of members) {
+			const c = member.workingPoints.length;
+			const slice = rounded.slice(offset, offset + c);
+			member.workingPoints.splice(0, member.workingPoints.length, ...slice);
+			offset += c;
+		}
+	}
+	function concatWorkingPoints() {
+		const out = [];
+		for (const member of members) out.push(...member.workingPoints.map((p) => [...p]));
+		return out;
+	}
+	function clonePointsByMember() {
+		return members.map((m) => m.workingPoints.map((p) => [...p]));
+	}
+	function restorePointsByMember(snapshot) {
+		members.forEach((member, i) => {
+			member.workingPoints.splice(0, member.workingPoints.length, ...snapshot[i]);
+		});
+	}
+	function cloneOptionsOverrideByMember() {
+		return members.map((m) => m.optionsOverride ? { ...m.optionsOverride } : null);
+	}
+	/** Write a per-member override snapshot back onto the live members (index-aligned; gesture-scoped). */
+	function applyOptionsOverrides(overrides) {
+		members.forEach((member, i) => {
+			const o = overrides[i];
+			member.optionsOverride = 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() {
+		members.forEach((member, i) => {
+			const patch = freezeOrientationOptions(member.measure.kind, member.workingPoints.map((p) => [...p]), effectiveOptions(i));
+			if (patch) member.optionsOverride = {
+				...member.optionsOverride ?? {},
+				...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 membersAtEmission = members;
+		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) commitClose();
+		else if (rejectRequested && !ctx.settled && members === membersAtEmission) {
+			restorePointsByMember(previousPointsByMember);
+			sizeAnchor = previousSizeAnchor;
+			nonGeometryDirty = previousNonGeometryDirty;
+			applyOptionsOverrides(previousOptionsOverrideByMember);
+			renderAllPreviews();
+			renderHandlesLayer();
+			recomputeDirty();
+		}
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, "TransformSession.onChange listener errors");
+	}
+	/**
+	* Commit via `ctx.commit` and emit the close batch to `onCommit` listeners,
+	* then emit the settle to `onSettled` listeners (#194) — in a try/finally so
+	* a throwing `onCommit` listener cannot starve the settle emission. The
+	* emission happens after the interaction core has settled (teardown and
+	* `onSettled` already ran inside `ctx.commit`), so a listener that calls
+	* `td.render()` sees these members no longer excluded from reconcile — the
+	* fold-then-render pattern works from inside the handler. `undefined` covers
+	* both an already-settled session and a `produce` throw (the promise
+	* rejects); neither emits here — a `produce` throw already emitted the
+	* settle with reason `"error"` via the wrapped `onSettled` passed to
+	* `runInteraction`.
+	*/
+	function commitClose() {
+		const snapshots = ctx.commit(rebuildRenderedAll);
+		if (snapshots !== void 0) try {
+			commitEmitter.emit(snapshots);
+		} finally {
+			settleEmitter.emit("close");
+		}
+		return snapshots;
+	}
+	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);
+	}
+	/**
+	* Cancel an in-flight box drag without committing it: restore the pre-drag
+	* geometry and option overrides, re-enable drag pan, and clear the drag. Used
+	* by `setMembers` so a membership change never bakes a half-finished drag; the
+	* caller is responsible for the follow-up repaint (`renderAllPreviews` /
+	* `renderHandlesLayer` / `recomputeDirty`), so this leaves the paint to it
+	* rather than rendering the outgoing member set only to redo it immediately.
+	*/
+	function cancelActiveBoxDrag() {
+		if (!activeBoxDrag) return;
+		const { preDragPoints, preDragOptionsOverrideByMember } = activeBoxDrag;
+		activeBoxDrag = null;
+		driver.setDragPanEnabled(true);
+		applyConcatenatedPoints(preDragPoints);
+		applyOptionsOverrides(preDragOptionsOverrideByMember);
+		dragInFlight = false;
+	}
+	function setMembers(next) {
+		if (ctx.settled) return void 0;
+		const seen = /* @__PURE__ */ new Set();
+		for (const m of next) {
+			if (seen.has(m.id)) throw new TypeError(`TransformSession.setMembers: duplicate control measure id "${m.id}"`);
+			seen.add(m.id);
+		}
+		if (next.length === 0) return close();
+		cancelActiveBoxDrag();
+		const nextIds = new Set(next.map((m) => m.id));
+		const currentById = new Map(members.map((m) => [m.measure.id, m]));
+		const removedSnapshots = [];
+		for (const member of members) if (!nextIds.has(member.measure.id)) removedSnapshots.push(buildMemberSnapshot(member, member.optionsOverride));
+		const nextMembers = [];
+		for (const measure of next) {
+			const existing = currentById.get(measure.id);
+			if (existing) nextMembers.push(existing);
+			else {
+				const member = createMemberState(measure);
+				liftMemberFromGraphics(member);
+				nextMembers.push(member);
+			}
+		}
+		members = nextMembers;
+		renderAllPreviews();
+		renderHandlesLayer();
+		recomputeDirty();
+		if (removedSnapshots.length > 0) commitEmitter.emit(removedSnapshots);
+		return removedSnapshots;
+	}
+	function close() {
+		return commitClose();
+	}
+	const session = {
+		get measures() {
+			return members.map((m) => m.measure);
+		},
+		controlPointsFor(measureId) {
+			const member = members.find((m) => m.measure.id === measureId);
+			if (!member) return void 0;
+			return member.workingPoints.map((p) => [...p]);
+		},
+		get dirty() {
+			return dirty;
+		},
+		get sizeAnchor() {
+			return sizeAnchor;
+		},
+		setSizeAnchor(next) {
+			setSizeAnchor(next);
+		},
+		setMembers,
+		close,
+		abort() {
+			if (ctx.settled) return;
+			ctx.fail(new TacticalDrawAbortError("session"));
+		},
+		onChange(listener) {
+			if (ctx.settled) return () => {};
+			changeListeners.add(listener);
+			return () => {
+				changeListeners.delete(listener);
+			};
+		},
+		onCommit(listener) {
+			if (ctx.settled) return () => {};
+			return commitEmitter.register(listener);
+		},
+		onSettled(handler) {
+			return settleEmitter.register(handler);
+		}
+	};
+	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;
+		const isMember = localGraphics ? members.some((m) => m.measure.id === localGraphics.id) : false;
+		if (localGraphics && !isMember) {
+			commitClose();
+			if (onClickAwayGraphicsPick) onClickAwayGraphicsPick(localGraphics);
+			return;
+		}
+		commitClose();
+	};
+	const core = runInteraction({
+		adapter,
+		signal,
+		layers: [previewLayer, handlesLayer],
+		onViewChange: rescaleOnViewChange,
+		onSettled: (settlement) => {
+			if (onSettled) onSettled();
+			if (settlement.status === "rejected") settleEmitter.emit(settleReasonFromError(settlement.error));
+		},
+		attach(c) {
+			ctx = c;
+			driver = adapter.createEditPointerDriver();
+			for (const member of members) liftMemberFromGraphics(member);
+			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);
+			c.onTeardown(() => {
+				adapter.off("click", handleClick);
+				unsubPickPreview();
+				unsubPickHandles();
+				unsubPickGraphics();
+				unsubDown();
+				unsubMove();
+				unsubUp();
+				if (activeBoxDrag !== null) {
+					driver.setDragPanEnabled(true);
+					activeBoxDrag = null;
+					dragInFlight = false;
+				}
+				driver.dispose();
+			}, () => {
+				if (anyLiftedFromGraphics) restoreOriginalToGraphics();
+			});
+			renderAllPreviews();
+			renderHandlesLayer();
+			recomputeDirty();
+			if (onSession) onSession(session);
+		}
+	});
+	return {
+		promise: core.promise,
+		get settled() {
+			return core.settled;
+		},
+		get measureIds() {
+			return members.map((m) => m.measure.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()`.
@@ -2312,6 +3454,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
@@ -2329,6 +3485,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
@@ -2380,12 +3537,35 @@ 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);
+		for (const id of this.transformMemberIds() ?? []) ids.add(id);
+		return ids;
+	}
+	/**
+	* Live member ids of the active group transform, or `undefined` when none.
+	* Falls back to the session ref because `onSession` fires from inside the
+	* controller's attach, before `runWithSlot` has assigned `activeTransform` —
+	* the session ref is registered first (`trackTransformSession`), so a
+	* `render()` from inside `onSession` still sees live membership.
+	*/
+	transformMemberIds() {
+		if (this.activeTransform) return this.activeTransform.measureIds;
+		return this.activeTransformSessionRef?.measures.map((m) => m.id);
+	}
+	/**
 	* 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.
@@ -2424,7 +3604,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.transformMemberIds();
+		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;
@@ -2437,6 +3620,16 @@ var TacticalDraw = class {
 				editHandle.abort("removed");
 			});
 		}
+		if (transformMemberRemoved) {
+			const sessionRef = this.activeTransformSessionRef;
+			queueMicrotask(() => {
+				const handle = this.activeTransform;
+				if (!handle || handle.settled) return;
+				if (this.activeTransformSessionRef !== sessionRef) return;
+				const rendered = new Set(this.lastRenderedMeasures.map((m) => m.id));
+				if (handle.measureIds.some((id) => !rendered.has(id))) handle.abort("removed");
+			});
+		}
 	}
 	/**
 	* Nested-call guard + preempt, shared by `draw` and `edit`. Returns a
@@ -2454,6 +3647,8 @@ var TacticalDraw = class {
 		}
 		if (this.activeInteraction.isActive) {
 			this.activeEdit = null;
+			this.activeTransform = null;
+			this.activeTransformSessionRef = null;
 			this.activeInteraction.cancel("preempted");
 		}
 		return null;
@@ -2469,14 +3664,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();
@@ -2489,7 +3687,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();
@@ -2497,7 +3694,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;
@@ -2513,11 +3710,29 @@ 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
 	* click on the last added control point. All paths reject with
 	* `TacticalDrawAbortError` on signal / Escape / destroy / `session.abort()`.
+	*
+	* For a variable-length draw, `DrawSession.onCommit` is the single delivery
+	* channel for the committed snapshot and `DrawSession.onSettled` is the
+	* lifecycle signal for when the session is over and why (#197) — together
+	* they make the returned promise non-load-bearing for hosts that adopt them.
+	* Fixed-length kinds have no session and settle only through the promise.
 	*/
 	draw(draft, options) {
 		this.assertAlive();
@@ -2539,6 +3754,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,
@@ -2575,12 +3791,15 @@ var TacticalDraw = class {
 	* Default click-away (`closeOnClickAway: true`) closes the edit on a click
 	* outside the preview / handle features. Hosts that own close policy pass
 	* `false`.
+	*
+	* `EditSession.onCommit` is the single delivery channel for the committed
+	* snapshot and `EditSession.onSettled` is the lifecycle signal for when the
+	* session is over and why (#197) — together they make the returned promise
+	* non-load-bearing for hosts that adopt them.
 	*/
 	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);
@@ -2613,7 +3832,121 @@ 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 `ControlMeasureSnapshot[]` on `session.close()` and rejects
+	* with `TacticalDrawAbortError` on signal / Escape / destroy / preempt /
+	* `session.abort()`. Key the resolved snapshots by `snapshot.measure.id`:
+	* the member set is mutable (`session.setMembers`, #187) so snapshot arrays
+	* are id-keyed, not index-aligned with this input. The promise resolves with
+	* the members in the set at close time; a member removed mid-session had its
+	* exit snapshot returned from the `setMembers` call that removed it.
+	*
+	* `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.
+	*
+	* For a selection that changes over time (shift-click toggle, marquee
+	* replace), prefer [[syncTransformMembers]] over hand-rolling the
+	* live-session-vs-fresh-`editMany` branch, and subscribe to
+	* `TransformSession.onCommit` as the single fold path for exit snapshots
+	* and `TransformSession.onSettled` as the lifecycle signal for when the
+	* session is over and why.
+	*/
+	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 isOnGraphicsLayer = (id) => this.lastRenderedMeasures.some((m) => m.id === 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,
+			isOnGraphicsLayer,
+			onSettled,
+			onClickAwayGraphicsPick
+		}), (handle) => {
+			this.activeTransform = handle;
+			return () => {
+				if (this.activeTransform === handle) this.activeTransform = null;
+			};
+		}, extraSettle);
+	}
+	/**
+	* One-call selection-sync: mutate the live group transform's member set in
+	* place, or start a fresh `editMany` when no transform is live (#191). This
+	* owns the "live session → `setMembers`, else → `editMany`" branch that every
+	* host otherwise hand-rolls against `activeTransformSession`.
+	*
+	* The facade knows session liveness synchronously — `activeTransformSessionRef`
+	* is cleared inside the settle path, before control returns to host code — so
+	* unlike a host's own `activeTransformSession ? setMembers : editMany` check,
+	* this can never observe a stale ref pointing at an already-settled session.
+	* The settled-race fall-through hosts had to hand-roll for that gap is owned
+	* here instead: a `setMembers` call that (implausibly) still returns
+	* `undefined` falls through to a fresh `editMany` rather than silently
+	* dropping the selection.
+	*
+	* `measures: []` closes any live session (committing every member) and is a
+	* no-op while idle. With a live session, `options` is ignored — session-scoped
+	* state (`sizeAnchor`, box angle, close-on-click-away policy) is sticky per
+	* `setMembers`'s contract; `options` applies only when this call starts a
+	* fresh `editMany`. Exit snapshots are delivered via the session's
+	* `onCommit` — subscribe once in `options.onSession`. Session lifecycle —
+	* including an Escape / preempt / destroy abort the host did not itself
+	* initiate — is observed via the session's `onSettled` (#194); together
+	* `onCommit` and `onSettled` make the underlying `editMany` promise
+	* irrelevant to hosts. That promise is owned by the facade; its abort
+	* rejections are swallowed here (non-abort errors surface as unhandled
+	* rejections). Throws `TypeError` synchronously on duplicate ids, from
+	* either path. Starting a fresh transform preempts any other in-flight
+	* draw/edit exactly like `editMany`.
+	*/
+	syncTransformMembers(measures, options) {
+		this.assertAlive();
+		const session = this.activeTransformSessionRef;
+		if (session) {
+			if (session.setMembers(measures) !== void 0) return;
+		}
+		if (measures.length === 0) return;
+		this.editMany([...measures], options).catch(ignoreAbort);
 	}
 	/**
 	* Subscribe to picks on committed control measures.
@@ -2681,6 +4014,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`.
@@ -2690,6 +4032,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);
@@ -2709,7 +4053,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;
 		}
@@ -2748,9 +4093,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
@@ -2762,6 +4117,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() {
@@ -2778,10 +4137,11 @@ 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 and the rotate
+* grip are white-filled with the same blue stroke as the box outline, so the
+* box reads as one coherent affordance. Vertex/midpoint keep their existing
+* white/gray family.
 */
 const BUILT_IN_INTERACTION_STYLE = {
 	guide: {
@@ -2789,6 +4149,10 @@ const BUILT_IN_INTERACTION_STYLE = {
 		strokeWidth: 1,
 		strokeDash: [6, 4]
 	},
+	boxOutline: {
+		strokeColor: "#4f7cff",
+		strokeWidth: 1
+	},
 	vertexHandle: {
 		pointRadius: 6,
 		fillColor: "#ffffff",
@@ -2801,21 +4165,23 @@ 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,
-		fillColor: "#16a34a",
-		strokeColor: "#ffffff"
+		pointRadius: 5,
+		fillColor: "#ffffff",
+		strokeColor: "#4f7cff",
+		strokeWidth: 2
 	}
 };
 const HANDLE_SLOTS = [
 	"vertexHandle",
 	"midpointHandle",
-	"translateHandle",
+	"scaleHandle",
 	"rotateHandle"
 ];
 /**
@@ -2860,4 +4226,22 @@ function resolveSlot(adapter, supplied, owned) {
 	return id;
 }
 //#endregion
-export { BaseMapAdapter, PointerCallbackHub, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, TacticalDrawDestroyedError, bindAbortable, coerceHandleStyle, combineWithHostSignal, getSizeAnchor, hitTestFeature, ignoreAbort, isTacticalDrawAbortError, pickHitTolerance, tryControlMeasureIdFromFeature };
+//#region src/world-wrap.ts
+/**
+* Shift `lng` by whole world widths (360°) onto the copy nearest `refLng`.
+*
+* Map engines that wrap pointer longitudes into [-180, 180] (OpenLayers'
+* `toLonLat`, MapLibre's globe unproject) make positions jump ~360° when a
+* gesture crosses the antimeridian. Adapters use this to keep delivered
+* longitudes continuous with the view center, and to project coordinates on
+* the world copy the view is actually looking at.
+*/
+function nearestWorldCopyLng(lng, refLng) {
+	return lng + 360 * Math.round((refLng - lng) / 360);
+}
+/** `nearestWorldCopyLng` applied to a lon/lat position. */
+function nearestWorldCopyPosition(position, refLng) {
+	return [nearestWorldCopyLng(position[0], refLng), ...position.slice(1)];
+}
+//#endregion
+export { BaseMapAdapter, PointerCallbackHub, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, TacticalDrawDestroyedError, bindAbortable, coerceHandleStyle, combineWithHostSignal, getSizeAnchor, hitTestFeature, ignoreAbort, isTacticalDrawAbortError, nearestWorldCopyLng, nearestWorldCopyPosition, pickHitTolerance, tryControlMeasureIdFromFeature };