@orbat-mapper/tactical-draw 0.2.0-alpha.17 → 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];
 }
 /**
@@ -2026,28 +2035,111 @@ function boxOutlineFeature(box, fromPixel, featureId, style) {
 //#endregion
 //#region src/tactical-draw/transform-amplifier-placements.ts
 /**
-* Carry user-adjusted label anchors through a transform-box gesture. Anchors
-* are transformed in pixel space alongside the control points so the result
-* remains visually rigid across map projections.
+* 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, position] of Object.entries(placements)) {
-		if (position === void 0) continue;
-		const pixel = projection.toPixel(position);
-		if (!pixel) {
-			transformed[field] = [...position];
+	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 [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] = projection.fromPixel([to.center[0] + outX, to.center[1] + outY]);
+		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
 /**
@@ -2079,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:
 *
@@ -2161,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 = {
@@ -2242,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({
@@ -2263,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;
@@ -2527,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();
@@ -2596,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() {
@@ -2695,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;
@@ -2706,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
@@ -2768,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
 			};
@@ -2873,12 +3124,36 @@ function runEdit(opts) {
 	}
 	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();
@@ -2892,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) {
@@ -3018,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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbat-mapper/tactical-draw",
-  "version": "0.2.0-alpha.17",
+  "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.13"
+    "@orbat-mapper/control-measures": "^0.2.0-alpha.14"
   },
   "devDependencies": {
     "@arethetypeswrong/core": "^0.18.3",