@orbat-mapper/tactical-draw 0.2.0-alpha.16 → 0.2.0-alpha.18

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { AmplifierPlacements, ControlMeasure, ControlMeasureKind, ControlMeasureSnapshot, ControlMeasureStyle, TextAmplifiers } from "@orbat-mapper/control-measures";
+import { AmplifierPlacement, AmplifierPlacements, ControlMeasure, ControlMeasureKind, ControlMeasureSnapshot, ControlMeasureStyle, TextAmplifiers } from "@orbat-mapper/control-measures";
 import { Feature, Position } from "geojson";
 
 //#region src/gestures/types.d.ts
@@ -238,6 +238,12 @@ interface MapAdapter {
    * Get current map zoom level
    */
   getZoom(): number | undefined;
+  /**
+   * Get current view bearing, radians — the clockwise-from-north compass
+   * direction that screen-up points to (MapLibre-bearing semantics). `0` for
+   * engines/views that don't rotate.
+   */
+  getBearing(): number;
   /**
    * Listen for view changes (zoom/resolution)
    */
@@ -328,6 +334,11 @@ declare abstract class BaseMapAdapter<TLayerHandle, TEventToken, TViewToken> imp
   abstract setDoubleClickZoomEnabled(enabled: boolean): void;
   abstract getResolution(): number | undefined;
   abstract getZoom(): number | undefined;
+  /**
+   * Default for engines/views that don't rotate (Leaflet). Rotating engines
+   * (MapLibre, OpenLayers) override this.
+   */
+  getBearing(): number;
 }
 //#endregion
 //#region src/pick-utils.d.ts
@@ -620,8 +631,15 @@ interface EditSession {
    * silent no-op after the session has settled (like [[setOptions]]).
    */
   setTextAmplifiers(partial: Record<string, string | undefined>): void;
-  /** Merge field-keyed label anchors; `undefined` resets a field to its doctrinal position. */
-  setAmplifierPlacements(partial: Record<string, Position | undefined>): void;
+  /**
+   * Merge field-keyed label overrides (position and/or rotation). The merge is
+   * **field-wise per key**: a bare `Position` value means `{ position }`;
+   * fields absent from the incoming value (e.g. `rotation` when only
+   * `position` is supplied) are preserved from the existing entry; an
+   * explicit `undefined` value deletes the key entirely — a full reset to the
+   * doctrinal placement (both position and rotation).
+   */
+  setAmplifierPlacements(partial: Record<string, AmplifierPlacement | undefined>): void;
   /**
    * Subscribe to working-copy changes. The listener receives an
    * [[EditChangeEvent]] for each completed gesture (drag end, insert/delete

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { canonicalTextAmplifierKey, cloneControlMeasure, controlMeasureIdFromFeature, freezeOrientationOptions, getControlMeasureMetadata, renderControlMeasure, resolveStyleHints, roundToFixed } from "@orbat-mapper/control-measures";
+import { canonicalTextAmplifierKey, cloneControlMeasure, controlMeasureIdFromFeature, freezeOrientationOptions, getControlMeasureMetadata, renderControlMeasure, resolveAmplifierPlacement, resolveStyleHints, roundToFixed } from "@orbat-mapper/control-measures";
 //#region src/base-map-adapter.ts
 /**
 * Abstract base class shared by all `MapAdapter` implementations.
@@ -173,6 +173,13 @@ var BaseMapAdapter = class {
 		};
 	}
 	destroyEngineResources() {}
+	/**
+	* Default for engines/views that don't rotate (Leaflet). Rotating engines
+	* (MapLibre, OpenLayers) override this.
+	*/
+	getBearing() {
+		return 0;
+	}
 };
 function pickHitTolerance(originalEvent) {
 	if (typeof PointerEvent !== "undefined" && originalEvent instanceof PointerEvent) return originalEvent.pointerType === "touch" ? 12 : 4;
@@ -1688,13 +1695,15 @@ function boxCorners(box) {
 	});
 }
 /**
-* 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.
+* Where the rotate grip sits: `offset` pixels (default `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. The label transform box passes its own tighter
+* clearance (`LABEL_ROTATE_GRIP_OFFSET_PX`).
 */
-function rotateGripPixel(box) {
+function rotateGripPixel(box, offset = 28) {
 	const { center, halfHeight, angle } = box;
-	const [rx, ry] = rotate(0, -(halfHeight + 28), angle);
+	const [rx, ry] = rotate(0, -(halfHeight + offset), angle);
 	return [center[0] + rx, center[1] + ry];
 }
 /**
@@ -2024,6 +2033,114 @@ function boxOutlineFeature(box, fromPixel, featureId, style) {
 	};
 }
 //#endregion
+//#region src/tactical-draw/transform-amplifier-placements.ts
+/**
+* Carry user-adjusted label anchors (and rotation overrides) through a
+* transform-box gesture. Anchors are transformed in pixel space alongside the
+* control points so the result remains visually rigid across map
+* projections.
+*
+* Rotation: `TransformBox.angle` is radians in screen pixel space, positive =
+* clockwise on screen (see `transform-box.ts`). Adapters render a label's
+* on-screen clockwise angle as `π − rotation`, and a rotation delta is
+* invariant under the map→screen bearing, so an on-screen delta
+* `Δ = to.angle − from.angle` means `π − rotation' = (π − rotation) + Δ`,
+* i.e. `rotation' = rotation − Δ`.
+*/
+function transformAmplifierPlacements(placements, from, to, projection) {
+	if (!placements) return void 0;
+	const scaleX = to.halfWidth / from.halfWidth;
+	const scaleY = to.halfHeight / from.halfHeight;
+	const angleDelta = to.angle - from.angle;
+	const transformed = {};
+	for (const [field, raw] of Object.entries(placements)) {
+		const resolved = resolveAmplifierPlacement(raw);
+		const rotation = resolved.rotation !== void 0 ? resolved.rotation - angleDelta : void 0;
+		if (!resolved.position) {
+			if (rotation !== void 0) transformed[field] = { rotation };
+			continue;
+		}
+		const pixel = projection.toPixel(resolved.position);
+		const position = pixel ? (() => {
+			const [localX, localY] = rotate(pixel[0] - from.center[0], pixel[1] - from.center[1], -from.angle);
+			const [outX, outY] = rotate(localX * scaleX, localY * scaleY, to.angle);
+			return projection.fromPixel([to.center[0] + outX, to.center[1] + outY]);
+		})() : [...resolved.position];
+		transformed[field] = rotation !== void 0 ? {
+			position,
+			rotation
+		} : position;
+	}
+	return transformed;
+}
+/** Estimated glyph width as a fraction of text height — a monospace-ish approximation, not a real text-metrics measurement. */
+const CHAR_WIDTH_FACTOR = .6;
+/** Estimated line height as a multiple of text height. */
+const LINE_HEIGHT_FACTOR = 1.2;
+/**
+* Normalize `angle` (radians) into `(-π, π]`, matching the range
+* `Math.atan2`/screen-angle math elsewhere in `tactical-draw` produces.
+*/
+function normalizeAngle(angle) {
+	const twoPi = Math.PI * 2;
+	let a = angle % twoPi;
+	if (a <= -Math.PI) a += twoPi;
+	else if (a > Math.PI) a -= twoPi;
+	return a;
+}
+/**
+* Fit a `TransformBox` around `input`'s label. Returns `null` when `text` is
+* empty/absent — there is nothing to box.
+*
+* - **Angle**: on-screen clockwise, derived from the stored `rotation` by the
+*   same `π − rotation` formula adapters use to render the label (see
+*   `ml-adapter.ts`'s `buildSymbolLayer`), further offset by `−bearing` since
+*   labels render map-aligned (`text-rotation-alignment: "map"` / OL
+*   `rotateWithView: true`) and rotate with the view, so the box tilts
+*   exactly as the rendered text does.
+* - **Size**: `text` is split on `"\n"`; the longest line's character count
+*   times `CHAR_WIDTH_FACTOR × h` gives the width, the line count times
+*   `LINE_HEIGHT_FACTOR × h` gives the height, where `h` is the resolved
+*   text-height-in-pixels, mirroring how the adapters render each anchor
+*   kind (ADR-0028): screen-anchored `textSizePixels` is used as-is,
+*   unclamped (only a `1px` sanity floor to keep the box non-degenerate);
+*   ground-anchored `textSizeMeters / resolution` is clamped to the default
+*   `[DEFAULT_TEXT_SIZE_MIN_PIXELS, DEFAULT_TEXT_SIZE_MAX_PIXELS]` band via
+*   `resolveGroundTextSizePixels` (`feature-style.ts`); absent both,
+*   `DEFAULT_LABEL_TEXT_SIZE_PX`. `LABEL_BOX_PADDING_PX` is added on every
+*   side. Hosts can override the clamp band per layer style
+*   (`TextStyleOptions.textSizeMinPixels`/`textSizeMaxPixels`), which this
+*   estimate can't see — the default band keeps the box honest at extreme
+*   zooms even when a host has customized it.
+* - **Center**: `anchor` for centered text (`textAnchor` absent); offset by
+*   half the fitted width along the label's local +x for `"start"` (text
+*   grows away from the anchor) or local −x for `"end"` (text grows back
+*   toward the anchor) — `rotate()` (`transform-box.ts`) already uses the
+*   screen (y-down) convention this offset needs.
+*/
+function fitLabelTransformBox(input) {
+	const { text, rotation, textAnchor, textSizePixels, textSizeMeters, anchor, resolution, bearing } = input;
+	if (!text) return null;
+	const angle = normalizeAngle(Math.PI - (rotation ?? 0) - (bearing ?? 0));
+	const h = textSizePixels !== void 0 ? Math.max(1, textSizePixels) : textSizeMeters !== void 0 && resolution !== void 0 && resolution > 0 ? resolveGroundTextSizePixels(textSizeMeters, resolution) : 16;
+	const lines = text.split("\n");
+	const width = lines.reduce((max, line) => Math.max(max, line.length), 0) * CHAR_WIDTH_FACTOR * h;
+	const height = lines.length * LINE_HEIGHT_FACTOR * h;
+	const halfWidth = width / 2 + 4;
+	const halfHeight = height / 2 + 4;
+	let center = anchor;
+	if (textAnchor === "start" || textAnchor === "end") {
+		const [ox, oy] = rotate((textAnchor === "start" ? 1 : -1) * width / 2, 0, angle);
+		center = [anchor[0] + ox, anchor[1] + oy];
+	}
+	return {
+		center,
+		halfWidth,
+		halfHeight,
+		angle
+	};
+}
+//#endregion
 //#region src/tactical-draw/edit-controller.ts
 /**
 * Coordinate-space tolerance for `EditSession.dirty`. The working copy is
@@ -2054,6 +2171,25 @@ const ALLOWED_EDIT_MODES = new Set([
 	"delete"
 ]);
 /**
+* Field-wise merge of one `amplifierPlacements` entry: fields present in
+* `incoming` (valid position / finite rotation) replace the same field on
+* `existing`; fields absent from `incoming` are preserved. Returns the
+* *storage shape* for the merged entry — a bare `Position` when no rotation
+* survives (matching the legacy shorthand), the object form when a rotation
+* is present, or `undefined` when nothing survives.
+*/
+function mergeAmplifierPlacementField(existing, incoming) {
+	const merged = {
+		...resolveAmplifierPlacement(existing),
+		...resolveAmplifierPlacement(incoming)
+	};
+	if (merged.rotation === void 0) return merged.position ? [...merged.position] : void 0;
+	return merged.position ? {
+		position: [...merged.position],
+		rotation: merged.rotation
+	} : { rotation: merged.rotation };
+}
+/**
 * Drive an interactive edit against a `MapAdapter`. Implements the edit
 * lifecycle (issue #48) plus the ADR-0017 transform box:
 *
@@ -2136,6 +2272,22 @@ function runEdit(opts) {
 	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 = [];
+	/**
+	* The currently selected label's `labelPlacementKey` in `labeldrag` mode, or
+	* `null` when no label is selected. A click on a label toggles this (select
+	* / deselect / switch — see `onDriverUp`'s amplifier-drag click path); it is
+	* cleared whenever the feature disappears from `lastPreviewFeatures` or the
+	* mode set drops `labeldrag` (see `applyModes`).
+	*/
+	let selectedLabelKey = null;
+	/**
+	* The transform box fitted around the selected label (`label-transform-box.ts`),
+	* re-fitted on every `renderHandlesLayer` call from `lastPreviewFeatures` —
+	* except while a label rotate drag is in flight, when it is painted rigidly
+	* from the drag's own live snapshot instead (mirrors `activeBoxDrag.lastSnapshot`).
+	* `null` when nothing is selected or the selection couldn't be fitted this frame.
+	*/
+	let labelBox = null;
 	let ctx;
 	let driver;
 	const dragProjection = {
@@ -2217,9 +2369,17 @@ function runEdit(opts) {
 		if (modes.includes("labeldrag")) {
 			const style = interactionStyle?.labelHandle;
 			let index = 0;
+			labelBox = null;
+			if (activeLabelRotateDrag) labelBox = activeLabelRotateDrag.lastBox;
+			else {
+				const anchor = selectedLabelAnchor();
+				if (selectedLabelKey && !anchor) selectedLabelKey = null;
+				else if (anchor) labelBox = fitLabelBoxFromFeature(anchor.feature, anchor.pixel);
+			}
 			for (const feature of lastPreviewFeatures) {
 				const key = feature.properties?.labelPlacementKey;
 				if (typeof key !== "string" || feature.geometry?.type !== "Point") continue;
+				if (key === selectedLabelKey) continue;
 				const pixel = driver.toPixel(feature.geometry.coordinates);
 				if (!pixel) continue;
 				features.push({
@@ -2238,6 +2398,15 @@ function runEdit(opts) {
 				});
 				index += 1;
 			}
+			if (labelBox) {
+				features.push(boxOutlineFeature(labelBox, dragProjection.fromPixel, `${handleIdPrefix}:label-box-outline`, interactionStyle?.boxOutline));
+				const rotateHandle = {
+					kind: "rotate",
+					index: 0,
+					position: dragProjection.fromPixel(rotateGripPixel(labelBox, 14))
+				};
+				features.push(...toFeatures([rotateHandle], `${handleIdPrefix}:label`, interactionStyle));
+			}
 		}
 		if (modes.includes("transform")) {
 			const liveBox = activeBoxDrag ? activeBoxDrag.lastSnapshot.box : box;
@@ -2502,8 +2671,15 @@ function runEdit(opts) {
 		const previousAmplifierPlacements = snapshotAmplifierPlacements();
 		const previousRendered = rebuildRendered();
 		const next = { ...workingAmplifierPlacements ?? {} };
-		for (const [field, position] of Object.entries(partial)) if (position === void 0) delete next[field];
-		else next[field] = [...position];
+		for (const [field, value] of Object.entries(partial)) {
+			if (value === void 0) {
+				delete next[field];
+				continue;
+			}
+			const merged = mergeAmplifierPlacementField(next[field], value);
+			if (merged === void 0) delete next[field];
+			else next[field] = merged;
+		}
 		workingAmplifierPlacements = Object.keys(next).length > 0 ? next : void 0;
 		const currentRendered = rebuildRendered();
 		renderPreview();
@@ -2571,6 +2747,7 @@ function runEdit(opts) {
 	function applyModes(next) {
 		if (modesEqual(modes, next)) return;
 		modes = next;
+		if (!modes.includes("labeldrag")) selectedLabelKey = null;
 		renderHandlesLayer();
 	}
 	function drainPendingModes() {
@@ -2670,7 +2847,33 @@ function runEdit(opts) {
 		}
 	};
 	let activeDrag = null;
+	/**
+	* A live label *move* drag: direct label grab, the floating grip, or a body
+	* grab inside the selected label's transform box (ADR-0017 box machinery
+	* applied to labels — see `label-transform-box.ts`) — all three funnel
+	* through this one state, distinguished only by `grabOffset`. `grabOffset`
+	* is the anchor-pixel-minus-down-pixel delta captured at pointer-down, so
+	* `labelAnchorFromPointer` can re-derive the intended anchor from any
+	* subsequent pointer pixel without the label snapping to the pointer's
+	* exact position (a direct grab derives `[0, 0]`; the floating grip derives
+	* `[0, LABEL_HANDLE_OFFSET_PX]`; a box-body grab derives whatever offset the
+	* click landed at within the box).
+	*/
 	let activeAmplifierDrag = null;
+	/** Read a label feature's rendered props into a `fitLabelTransformBox` input, anchored at `anchorPixel`. */
+	function fitLabelBoxFromFeature(feature, anchorPixel) {
+		const props = feature.properties ?? {};
+		return fitLabelTransformBox({
+			text: typeof props.text === "string" ? props.text : void 0,
+			rotation: typeof props.rotation === "number" ? props.rotation : void 0,
+			textAnchor: props.textAnchor === "start" || props.textAnchor === "end" ? props.textAnchor : void 0,
+			textSizePixels: typeof props.textSizePixels === "number" ? props.textSizePixels : void 0,
+			textSizeMeters: typeof props.textSizeMeters === "number" ? props.textSizeMeters : void 0,
+			anchor: anchorPixel,
+			resolution: adapter.getResolution(),
+			bearing: adapter.getBearing()
+		});
+	}
 	function pickLabel(pixel, tolerance) {
 		for (const feature of lastPreviewFeatures) {
 			const key = feature.properties?.labelPlacementKey;
@@ -2681,21 +2884,58 @@ function runEdit(opts) {
 				const targetY = projected[1] - (handle ? LABEL_HANDLE_OFFSET_PX : 0);
 				if (Math.hypot(projected[0] - pixel[0], targetY - pixel[1]) <= tolerance) return {
 					key,
-					handle
+					anchorPixel: projected
 				};
 			}
+			const box = fitLabelBoxFromFeature(feature, projected);
+			if (box && pointInBox(box, pixel)) return {
+				key,
+				anchorPixel: projected
+			};
 		}
 		return null;
 	}
 	/**
-	* The label anchor a pointer pixel maps to: 1:1 for a grab on the label
-	* itself, offset back down by the grip clearance when the drag rides the
-	* visible handle, so the label lands where the anchor (not the grip) points.
+	* The label anchor a pointer pixel maps to: `pixel` shifted by the drag's
+	* `grabOffset` (anchor-pixel-minus-down-pixel, captured at pointer-down —
+	* see `activeAmplifierDrag`), so the label keeps whatever offset it was
+	* grabbed at instead of snapping to the pointer.
 	*/
-	function labelAnchorFromPointer(pixel, handle) {
-		return driver.fromPixel([pixel[0], pixel[1] + (handle ? LABEL_HANDLE_OFFSET_PX : 0)]);
+	function labelAnchorFromPointer(pixel, grabOffset) {
+		return driver.fromPixel([pixel[0] + grabOffset[0], pixel[1] + grabOffset[1]]);
 	}
 	/**
+	* The selected label's rendered feature + its current anchor pixel, or
+	* `null` when nothing is selected, the feature is gone from this frame's
+	* preview, or its anchor fails to project. The single lookup shared by the
+	* box fit (`renderHandlesLayer`) and the box-pick paths (`onDriverDown`).
+	*/
+	function selectedLabelAnchor() {
+		if (!selectedLabelKey) return null;
+		const feature = lastPreviewFeatures.find((f) => f.properties?.labelPlacementKey === selectedLabelKey && f.geometry?.type === "Point");
+		if (!feature || feature.geometry?.type !== "Point") return null;
+		const pixel = driver.toPixel(feature.geometry.coordinates);
+		if (!pixel) return null;
+		return {
+			feature,
+			pixel
+		};
+	}
+	/** The screen-space angle (radians, y-down) from `anchor` to `pixel`, as used by the label rotate drag's pointer-angle math. */
+	function pointerAngleAround(pixel, anchor) {
+		return Math.atan2(pixel[1] - anchor[1], pixel[0] - anchor[0]);
+	}
+	/**
+	* A live label *rotate* drag (ADR-0017 box machinery applied to a label's
+	* rotate grip). `anchorPixel`/`text`/`textAnchor`/`textSizePixels`/
+	* `textSizeMeters` are captured at pointer-down so `lastBox` can be
+	* re-fitted purely from drag math on every move tick — independent of
+	* `lastPreviewFeatures`, which mirrors `activeBoxDrag.lastSnapshot` and
+	* keeps the box painted even if a transient preview render fails
+	* (`renderPreview`'s try/catch).
+	*/
+	let activeLabelRotateDrag = null;
+	/**
 	* 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
@@ -2704,24 +2944,6 @@ function runEdit(opts) {
 	* `boxAngle`.
 	*/
 	let activeBoxDrag = null;
-	function transformAmplifierPlacements(placements, from, to) {
-		if (!placements) return void 0;
-		const scaleX = to.halfWidth / from.halfWidth;
-		const scaleY = to.halfHeight / from.halfHeight;
-		const transformed = {};
-		for (const [field, position] of Object.entries(placements)) {
-			if (position === void 0) continue;
-			const pixel = driver.toPixel(position);
-			if (!pixel) {
-				transformed[field] = [...position];
-				continue;
-			}
-			const [localX, localY] = rotate(pixel[0] - from.center[0], pixel[1] - from.center[1], -from.angle);
-			const [outX, outY] = rotate(localX * scaleX, localY * scaleY, to.angle);
-			transformed[field] = driver.fromPixel([to.center[0] + outX, to.center[1] + outY]);
-		}
-		return transformed;
-	}
 	/**
 	* Whether the vertex at `index` may be deleted (via Alt+click or in the
 	* exclusive `delete` mode). Deletion is
@@ -2761,11 +2983,47 @@ function runEdit(opts) {
 	const onDriverDown = (pixel, info) => {
 		if (ctx.settled || dragInFlight) return;
 		const tol = info?.hitTolerance ?? HANDLE_HIT_TOLERANCE_PX$1;
+		if (modes.includes("labeldrag") && labelBox) {
+			const anchor = selectedLabelAnchor();
+			if (anchor) {
+				const gripPixel = rotateGripPixel(labelBox, 14);
+				if (Math.hypot(gripPixel[0] - pixel[0], gripPixel[1] - pixel[1]) <= tol) {
+					const props = anchor.feature.properties ?? {};
+					activeLabelRotateDrag = {
+						key: selectedLabelKey,
+						anchorPixel: anchor.pixel,
+						startPointerAngle: pointerAngleAround(pixel, anchor.pixel),
+						startRotation: typeof props.rotation === "number" ? props.rotation : 0,
+						previous: snapshotAmplifierPlacements(),
+						downPixel: pixel,
+						text: typeof props.text === "string" ? props.text : void 0,
+						textAnchor: props.textAnchor === "start" || props.textAnchor === "end" ? props.textAnchor : void 0,
+						textSizePixels: typeof props.textSizePixels === "number" ? props.textSizePixels : void 0,
+						textSizeMeters: typeof props.textSizeMeters === "number" ? props.textSizeMeters : void 0,
+						lastBox: labelBox
+					};
+					dragInFlight = true;
+					driver.setDragPanEnabled(false);
+					return;
+				}
+				if (pointInBox(labelBox, pixel)) {
+					activeAmplifierDrag = {
+						field: selectedLabelKey,
+						grabOffset: [anchor.pixel[0] - pixel[0], anchor.pixel[1] - pixel[1]],
+						previous: snapshotAmplifierPlacements(),
+						downPixel: pixel
+					};
+					dragInFlight = true;
+					driver.setDragPanEnabled(false);
+					return;
+				}
+			}
+		}
 		const labelHit = modes.includes("labeldrag") ? pickLabel(pixel, tol) : null;
 		if (labelHit) {
 			activeAmplifierDrag = {
 				field: labelHit.key,
-				handle: labelHit.handle,
+				grabOffset: [labelHit.anchorPixel[0] - pixel[0], labelHit.anchorPixel[1] - pixel[1]],
 				previous: snapshotAmplifierPlacements(),
 				downPixel: pixel
 			};
@@ -2859,19 +3117,43 @@ function runEdit(opts) {
 		const snapshot = activeBoxDrag.fsm.move(pixel);
 		activeBoxDrag.lastSnapshot = snapshot;
 		workingPoints.splice(0, workingPoints.length, ...snapshot.points);
-		workingAmplifierPlacements = transformAmplifierPlacements(activeBoxDrag.preDragAmplifierPlacements, activeBoxDrag.preDragBox, snapshot.box);
+		workingAmplifierPlacements = transformAmplifierPlacements(activeBoxDrag.preDragAmplifierPlacements, activeBoxDrag.preDragBox, snapshot.box, driver);
 		renderPreview();
 		renderHandlesLayer();
 		recomputeDirty();
 	}
 	const onDriverMove = (pixel) => {
 		if (ctx.settled) return;
-		if (activeAmplifierDrag) {
-			const position = labelAnchorFromPointer(pixel, activeAmplifierDrag.handle);
+		if (activeLabelRotateDrag) {
+			const drag = activeLabelRotateDrag;
+			const delta = pointerAngleAround(pixel, drag.anchorPixel) - drag.startPointerAngle;
+			const rotation = drag.startRotation - delta;
+			const merged = mergeAmplifierPlacementField(workingAmplifierPlacements?.[drag.key], { rotation });
+			workingAmplifierPlacements = {
+				...workingAmplifierPlacements ?? {},
+				...merged !== void 0 ? { [drag.key]: merged } : {}
+			};
+			const liveBox = fitLabelTransformBox({
+				text: drag.text,
+				rotation,
+				textAnchor: drag.textAnchor,
+				textSizePixels: drag.textSizePixels,
+				textSizeMeters: drag.textSizeMeters,
+				anchor: drag.anchorPixel,
+				resolution: adapter.getResolution(),
+				bearing: adapter.getBearing()
+			});
+			if (liveBox) drag.lastBox = liveBox;
+			renderPreview();
+			renderHandlesLayer();
+		} else if (activeAmplifierDrag) {
+			const position = labelAnchorFromPointer(pixel, activeAmplifierDrag.grabOffset);
 			if (!position) return;
+			const field = activeAmplifierDrag.field;
+			const merged = mergeAmplifierPlacementField(workingAmplifierPlacements?.[field], position);
 			workingAmplifierPlacements = {
 				...workingAmplifierPlacements ?? {},
-				[activeAmplifierDrag.field]: position
+				...merged !== void 0 ? { [field]: merged } : {}
 			};
 			renderPreview();
 			renderHandlesLayer();
@@ -2885,17 +3167,35 @@ function runEdit(opts) {
 		drainPendingModes();
 	}
 	const onDriverUp = (pixel) => {
+		if (activeLabelRotateDrag) {
+			const drag = activeLabelRotateDrag;
+			activeLabelRotateDrag = null;
+			workingAmplifierPlacements = drag.previous;
+			endDragBookkeeping();
+			if (Math.hypot(pixel[0] - drag.downPixel[0], pixel[1] - drag.downPixel[1]) > CLICK_SLOP_PX$1) {
+				const delta = pointerAngleAround(pixel, drag.anchorPixel) - drag.startPointerAngle;
+				const rotation = drag.startRotation - delta;
+				setAmplifierPlacements({ [drag.key]: { rotation } });
+			} else {
+				renderPreview();
+				renderHandlesLayer();
+			}
+			suppressClickAway = true;
+			return;
+		}
 		if (activeAmplifierDrag) {
-			const { field, handle, previous, downPixel } = activeAmplifierDrag;
+			const { field, grabOffset, previous, downPixel } = activeAmplifierDrag;
 			activeAmplifierDrag = null;
-			const position = labelAnchorFromPointer(pixel, handle);
+			const position = labelAnchorFromPointer(pixel, grabOffset);
 			workingAmplifierPlacements = previous;
 			endDragBookkeeping();
 			if (position && Math.hypot(pixel[0] - downPixel[0], pixel[1] - downPixel[1]) > CLICK_SLOP_PX$1) setAmplifierPlacements({ [field]: position });
 			else {
+				selectedLabelKey = selectedLabelKey === field ? null : field;
 				renderPreview();
 				renderHandlesLayer();
 			}
+			suppressClickAway = true;
 			return;
 		}
 		if (activeDrag) {
@@ -2938,7 +3238,7 @@ function runEdit(opts) {
 			replaceWorkingPoints(preDragPoints);
 			workingAmplifierPlacements = preDragAmplifierPlacements;
 			if (fsm.kind === "rotate") boxAngle += finalSnapshot.box.angle - preDragBox.angle;
-			commitGesture(finalSnapshot.points, preDragOptions, transformAmplifierPlacements(preDragAmplifierPlacements, preDragBox, finalSnapshot.box));
+			commitGesture(finalSnapshot.points, preDragOptions, transformAmplifierPlacements(preDragAmplifierPlacements, preDragBox, finalSnapshot.box, driver));
 			return;
 		}
 	};
@@ -3011,11 +3311,12 @@ function runEdit(opts) {
 				unsubDown();
 				unsubMove();
 				unsubUp();
-				if (activeDrag !== null || activeBoxDrag !== null || activeAmplifierDrag !== null) {
+				if (activeDrag !== null || activeBoxDrag !== null || activeAmplifierDrag !== null || activeLabelRotateDrag !== null) {
 					driver.setDragPanEnabled(true);
 					activeDrag = null;
 					activeBoxDrag = null;
 					activeAmplifierDrag = null;
+					activeLabelRotateDrag = null;
 					dragInFlight = false;
 				}
 				driver.dispose();
@@ -3126,6 +3427,7 @@ function runGroupTransform(opts) {
 			measure,
 			editStartPoints,
 			workingPoints: editStartPoints.map((p) => [...p]),
+			workingAmplifierPlacements: measure.amplifierPlacements ? structuredClone(measure.amplifierPlacements) : void 0,
 			optionsOverride: null,
 			box: null,
 			lastPreviewFeatures: []
@@ -3157,7 +3459,8 @@ function runGroupTransform(opts) {
 		const working = {
 			...member.measure,
 			options: mergeOptions(member.measure.options, override),
-			controlPoints: member.workingPoints.map((p) => [...p])
+			controlPoints: member.workingPoints.map((p) => [...p]),
+			...member.workingAmplifierPlacements ? { amplifierPlacements: member.workingAmplifierPlacements } : {}
 		};
 		const committed = sizeAnchor === "screen" ? working : bakePixelSizeToGround(working, adapter);
 		return {
@@ -3171,7 +3474,8 @@ function runGroupTransform(opts) {
 		return {
 			...member.measure,
 			options: effectiveOptions(i),
-			controlPoints: member.workingPoints.map((p) => [...p])
+			controlPoints: member.workingPoints.map((p) => [...p]),
+			...member.workingAmplifierPlacements ? { amplifierPlacements: member.workingAmplifierPlacements } : {}
 		};
 	}
 	let dirty = false;
@@ -3338,6 +3642,21 @@ function runGroupTransform(opts) {
 			member.workingPoints.splice(0, member.workingPoints.length, ...snapshot[i]);
 		});
 	}
+	function cloneAmplifierPlacementsByMember() {
+		return members.map((member) => member.workingAmplifierPlacements ? structuredClone(member.workingAmplifierPlacements) : void 0);
+	}
+	/**
+	* Adopts `placements[i]` by reference — callers hand over ownership (the
+	* sources are freshly built transforms or snapshot arrays that are dead
+	* after the restore), and working placements are only ever replaced
+	* wholesale, never mutated in place. This runs on every pointermove of a
+	* box drag, so it must not deep-clone.
+	*/
+	function applyAmplifierPlacementsByMember(placements) {
+		members.forEach((member, i) => {
+			member.workingAmplifierPlacements = placements[i];
+		});
+	}
 	function cloneOptionsOverrideByMember() {
 		return members.map((m) => m.optionsOverride ? { ...m.optionsOverride } : null);
 	}
@@ -3369,7 +3688,7 @@ function runGroupTransform(opts) {
 	* 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) {
+	function emitChange(previousRendered, previousPointsByMember, previousAmplifierPlacementsByMember, previousSizeAnchor, previousNonGeometryDirty, previousOptionsOverrideByMember, currentRendered) {
 		if (ctx.settled) return;
 		let rejectRequested = false;
 		let closeRequested = false;
@@ -3399,6 +3718,7 @@ function runGroupTransform(opts) {
 		else if (closeRequested) commitClose();
 		else if (rejectRequested && !ctx.settled && members === membersAtEmission) {
 			restorePointsByMember(previousPointsByMember);
+			applyAmplifierPlacementsByMember(previousAmplifierPlacementsByMember);
 			sizeAnchor = previousSizeAnchor;
 			nonGeometryDirty = previousNonGeometryDirty;
 			applyOptionsOverrides(previousOptionsOverrideByMember);
@@ -3431,17 +3751,20 @@ function runGroupTransform(opts) {
 		}
 		return snapshots;
 	}
-	function commitGesture(nextConcatPoints, preGestureOptionsOverrideByMember) {
+	function commitGesture(nextConcatPoints, preGestureOptionsOverrideByMember, nextAmplifierPlacementsByMember) {
 		if (ctx.settled) return;
 		const previousPointsByMember = clonePointsByMember();
+		const previousAmplifierPlacementsByMember = cloneAmplifierPlacementsByMember();
 		const previousOptionsOverrideByMember = preGestureOptionsOverrideByMember ?? cloneOptionsOverrideByMember();
 		const previousRendered = rebuildRenderedAllWith(previousOptionsOverrideByMember);
 		applyConcatenatedPoints(nextConcatPoints);
+		if (nextAmplifierPlacementsByMember) applyAmplifierPlacementsByMember(nextAmplifierPlacementsByMember);
 		let currentRendered;
 		try {
 			currentRendered = rebuildRenderedAll();
 		} catch (err) {
 			restorePointsByMember(previousPointsByMember);
+			applyAmplifierPlacementsByMember(previousAmplifierPlacementsByMember);
 			dragInFlight = false;
 			throw err;
 		}
@@ -3449,7 +3772,7 @@ function runGroupTransform(opts) {
 		renderHandlesLayer();
 		recomputeDirty();
 		dragInFlight = false;
-		emitChange(previousRendered, previousPointsByMember, sizeAnchor, nonGeometryDirty, previousOptionsOverrideByMember, currentRendered);
+		emitChange(previousRendered, previousPointsByMember, previousAmplifierPlacementsByMember, sizeAnchor, nonGeometryDirty, previousOptionsOverrideByMember, currentRendered);
 	}
 	function setSizeAnchor(next) {
 		if (ctx.settled || sizeAnchor === next) return;
@@ -3457,12 +3780,13 @@ function runGroupTransform(opts) {
 		const previousSizeAnchor = sizeAnchor;
 		const previousNonGeometryDirty = nonGeometryDirty;
 		const previousOptionsOverrideByMember = cloneOptionsOverrideByMember();
+		const previousAmplifierPlacementsByMember = cloneAmplifierPlacementsByMember();
 		const previousRendered = rebuildRenderedAll();
 		sizeAnchor = next;
 		const currentRendered = rebuildRenderedAll();
 		nonGeometryDirty = true;
 		dirty = true;
-		emitChange(previousRendered, previousPointsByMember, previousSizeAnchor, previousNonGeometryDirty, previousOptionsOverrideByMember, currentRendered);
+		emitChange(previousRendered, previousPointsByMember, previousAmplifierPlacementsByMember, previousSizeAnchor, previousNonGeometryDirty, previousOptionsOverrideByMember, currentRendered);
 	}
 	/**
 	* Cancel an in-flight box drag without committing it: restore the pre-drag
@@ -3474,10 +3798,11 @@ function runGroupTransform(opts) {
 	*/
 	function cancelActiveBoxDrag() {
 		if (!activeBoxDrag) return;
-		const { preDragPoints, preDragOptionsOverrideByMember } = activeBoxDrag;
+		const { preDragPoints, preDragAmplifierPlacementsByMember, preDragOptionsOverrideByMember } = activeBoxDrag;
 		activeBoxDrag = null;
 		driver.setDragPanEnabled(true);
 		applyConcatenatedPoints(preDragPoints);
+		applyAmplifierPlacementsByMember(preDragAmplifierPlacementsByMember);
 		applyOptionsOverrides(preDragOptionsOverrideByMember);
 		dragInFlight = false;
 	}
@@ -3567,6 +3892,7 @@ function runGroupTransform(opts) {
 			renderHandlesLayer();
 		}
 		const preDragPoints = concatWorkingPoints();
+		const preDragAmplifierPlacementsByMember = cloneAmplifierPlacementsByMember();
 		activeBoxDrag = {
 			fsm: beginBoxDrag({
 				kind: boxHit.kind,
@@ -3583,7 +3909,8 @@ function runGroupTransform(opts) {
 				points: preDragPoints,
 				box: groupBox
 			},
-			preDragOptionsOverrideByMember
+			preDragOptionsOverrideByMember,
+			preDragAmplifierPlacementsByMember
 		};
 		dragInFlight = true;
 		driver.setDragPanEnabled(false);
@@ -3593,6 +3920,7 @@ function runGroupTransform(opts) {
 		const snapshot = activeBoxDrag.fsm.move(pixel);
 		activeBoxDrag.lastSnapshot = snapshot;
 		applyConcatenatedPoints(snapshot.points);
+		applyAmplifierPlacementsByMember(activeBoxDrag.preDragAmplifierPlacementsByMember.map((placements) => transformAmplifierPlacements(placements, activeBoxDrag.preDragBox, snapshot.box, driver)));
 		renderAllPreviews();
 		renderHandlesLayer();
 		recomputeDirty();
@@ -3609,12 +3937,13 @@ function runGroupTransform(opts) {
 			driver.setDragPanEnabled(true);
 			return;
 		}
-		const { fsm, preDragPoints, preDragBox, downPixel, preDragOptionsOverrideByMember } = activeBoxDrag;
+		const { fsm, preDragPoints, preDragBox, downPixel, preDragOptionsOverrideByMember, preDragAmplifierPlacementsByMember } = 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);
+			applyAmplifierPlacementsByMember(preDragAmplifierPlacementsByMember);
 			renderAllPreviews();
 			renderHandlesLayer();
 			recomputeDirty();
@@ -3624,8 +3953,9 @@ function runGroupTransform(opts) {
 		}
 		const finalSnapshot = fsm.move(pixel);
 		applyConcatenatedPoints(preDragPoints);
+		applyAmplifierPlacementsByMember(preDragAmplifierPlacementsByMember);
 		if (fsm.kind === "rotate") boxAngle += finalSnapshot.box.angle - preDragBox.angle;
-		commitGesture(finalSnapshot.points, preDragOptionsOverrideByMember);
+		commitGesture(finalSnapshot.points, preDragOptionsOverrideByMember, preDragAmplifierPlacementsByMember.map((placements) => transformAmplifierPlacements(placements, preDragBox, finalSnapshot.box, driver)));
 	};
 	let pickPreview;
 	let pickHandles;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbat-mapper/tactical-draw",
-  "version": "0.2.0-alpha.16",
+  "version": "0.2.0-alpha.18",
   "description": "Engine-agnostic draw/edit core for tactical control measures (MIL-STD-2525 / APP-6). The MapAdapter ABI and bring-your-own-engine entry point for the tactical-draw package family.",
   "license": "MIT",
   "author": "Orbat Mapper",
@@ -38,7 +38,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@orbat-mapper/control-measures": "^0.2.0-alpha.12"
+    "@orbat-mapper/control-measures": "^0.2.0-alpha.14"
   },
   "devDependencies": {
     "@arethetypeswrong/core": "^0.18.3",