@orbat-mapper/tactical-draw 0.2.0-alpha.17 → 0.2.0-alpha.19

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)
    */
@@ -254,6 +260,13 @@ interface MapAdapter {
    * destruction.
    */
   destroy(): void;
+  /**
+   * Returns the features currently set on the layer — the adapter-side cache
+   * of the last `setLayerFeatures`/`updateLayerFeatures`/`removeFeatures`/
+   * `clearLayer` state. Empty array for an unknown layer. Callers must not
+   * mutate the returned array or features.
+   */
+  getLayerFeatures(layerId: LayerId): readonly Feature[];
 }
 //#endregion
 //#region src/base-map-adapter.d.ts
@@ -328,6 +341,12 @@ 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;
+  getLayerFeatures(layerId: LayerId): readonly Feature[];
 }
 //#endregion
 //#region src/pick-utils.d.ts
@@ -376,7 +395,7 @@ type ToPixel = (lonLat: Position) => PixelCoordinate | null;
  *
  * Returns the first matching feature in iteration order, or null.
  */
-declare function hitTestFeature(pixel: PixelCoordinate, features: Feature[], hitTolerance: number, toPixel: ToPixel): Feature | null;
+declare function hitTestFeature(pixel: PixelCoordinate, features: readonly Feature[], hitTolerance: number, toPixel: ToPixel): Feature | null;
 //#endregion
 //#region src/gestures/hit-tolerance.d.ts
 declare const TOUCH_HIT_TOLERANCE_PX = 22;
@@ -620,8 +639,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
@@ -975,6 +1001,18 @@ interface TacticalDrawLayerOptions {
   guide?: LayerId;
   handles?: LayerId;
 }
+/**
+ * Result of {@link TacticalDraw.ownsInteractionAt} — which layer claimed the
+ * pixel and the feature that matched.
+ */
+interface InteractionHit {
+  /** Which TacticalDraw layer owns the pixel — topmost match wins. */
+  layer: "handles" | "preview" | "graphics";
+  /** The hit feature (do not mutate). */
+  feature: Feature;
+  /** Control-measure id when the hit feature belongs to one (graphics/preview parts). */
+  measureId?: string;
+}
 interface TacticalDrawOptions {
   layers?: TacticalDrawLayerOptions;
   /**
@@ -1396,6 +1434,47 @@ declare class TacticalDraw {
    * Returns an unsubscribe function. Optional `signal` mirrors `adapter.onPick`.
    */
   onPick(layerId: LayerId, handler: PickHandler, opts?: PickOptions): () => void;
+  /**
+   * Stateless hit test answering "does TacticalDraw own the pixel at
+   * `pixel`?" — for hosts composing their own click-away / deselection logic
+   * (issue #216) alongside `TacticalDraw`'s draw/edit sessions. Today hosts
+   * hack this together from the `@internal` `layerIds` plus engine-specific
+   * layer queries; this is the supported replacement.
+   *
+   * Tests, topmost first, the three interactive layers — `handlesLayer`,
+   * then `previewLayer`, then `graphicsLayer` — against each layer's current
+   * `adapter.getLayerFeatures(...)` cache. The `guideLayer` is deliberately
+   * excluded: it is non-interactive draw-guide scaffolding, never a
+   * legitimate "owned" click target.
+   *
+   * `preview` and `graphics` each get a label text-extent fallback after the
+   * geometry pass misses on that layer: for every `Point` feature carrying a
+   * string `properties.text`, the anchor is projected and
+   * `fitLabelBoxFromFeature` (shared with the edit controller's `pickLabel`,
+   * see commit f908434) estimates the rendered text's box; a pixel inside
+   * that box counts as owned even though it's off the anchor point itself.
+   * This matters most for the active preview, since a click can land
+   * anywhere across a rotated/offset label during an edit.
+   *
+   * `tolerance` defaults to `mapEventHitTolerance(options?.originalEvent)` —
+   * pass the host's raw click event as `originalEvent` to get the same
+   * pointer-type-aware tolerance (4px mouse/pen, 12px touch) `onPick` uses;
+   * pass an explicit `tolerance` to override it outright.
+   *
+   * `measureId` is set when the hit feature resolves to a control-measure id
+   * via `tryControlMeasureIdFromFeature` — present for graphics/preview
+   * parts, generally absent for handles.
+   *
+   * This is a pure synchronous query over adapter-cached state: it does not
+   * depend on `onPick`/`"click"` dispatch having run first, so it is safe to
+   * call from any host click handler regardless of ordering relative to
+   * TacticalDraw's own pick/click pipeline.
+   */
+  ownsInteractionAt(pixel: PixelCoordinate, options?: {
+    tolerance?: number;
+    originalEvent?: unknown;
+  }): InteractionHit | null;
+  private toInteractionHit;
   /**
    * Abort the in-flight draw or edit. The default `"session"` reason matches
    * `DrawSession.abort()` / `EditSession.abort()`.
@@ -1525,4 +1604,4 @@ declare function nearestWorldCopyLng(lng: number, refLng: number): number;
 /** `nearestWorldCopyLng` applied to a lon/lat position. */
 declare function nearestWorldCopyPosition(position: Position, refLng: number): Position;
 //#endregion
-export { BaseMapAdapter, type CombinedAbort, DEFAULT_LABEL_SIZE_PIXELS, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, type DrawMeasureDraft, type DrawOptions, type DrawSession, type EditChangeEvent, type EditManyOptions, type EditMode, type EditOptions, type EditPointerDriver, type EditSession, type FeatureOps, type GuideStyle, type HandleStyle, type InteractionStyle, type LayerId, type MapAdapter, type MapCursor, type MapEvent, type MapEventHandler, type NativeEventEntry, type PickEvent, type PickHandler, type PickOptions, type PixelCoordinate, type PointerCallback, PointerCallbackHub, type PointerEventInfo, type SettleReason, type SizeAnchor, type StyleOptions, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, type TacticalDrawAbortReason, TacticalDrawDestroyedError, type TacticalDrawLayerOptions, type TacticalDrawOptions, type TextStyleOptions, type ToPixel, type TransformBox, type TransformChangeEvent, type TransformSession, bindAbortable, coerceHandleStyle, combineWithHostSignal, getSizeAnchor, hitTestFeature, ignoreAbort, isTacticalDrawAbortError, nearestWorldCopyLng, nearestWorldCopyPosition, pickHitTolerance, resolveGroundTextSizePixels, tryControlMeasureIdFromFeature };
+export { BaseMapAdapter, type CombinedAbort, DEFAULT_LABEL_SIZE_PIXELS, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, type DrawMeasureDraft, type DrawOptions, type DrawSession, type EditChangeEvent, type EditManyOptions, type EditMode, type EditOptions, type EditPointerDriver, type EditSession, type FeatureOps, type GuideStyle, type HandleStyle, type InteractionHit, type InteractionStyle, type LayerId, type MapAdapter, type MapCursor, type MapEvent, type MapEventHandler, type NativeEventEntry, type PickEvent, type PickHandler, type PickOptions, type PixelCoordinate, type PointerCallback, PointerCallbackHub, type PointerEventInfo, type SettleReason, type SizeAnchor, type StyleOptions, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, type TacticalDrawAbortReason, TacticalDrawDestroyedError, type TacticalDrawLayerOptions, type TacticalDrawOptions, type TextStyleOptions, type ToPixel, type TransformBox, type TransformChangeEvent, type TransformSession, bindAbortable, coerceHandleStyle, combineWithHostSignal, getSizeAnchor, hitTestFeature, ignoreAbort, isTacticalDrawAbortError, nearestWorldCopyLng, nearestWorldCopyPosition, pickHitTolerance, resolveGroundTextSizePixels, tryControlMeasureIdFromFeature };

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,16 @@ var BaseMapAdapter = class {
 		};
 	}
 	destroyEngineResources() {}
+	/**
+	* Default for engines/views that don't rotate (Leaflet). Rotating engines
+	* (MapLibre, OpenLayers) override this.
+	*/
+	getBearing() {
+		return 0;
+	}
+	getLayerFeatures(layerId) {
+		return this.featureCache.get(layerId) ?? [];
+	}
 };
 function pickHitTolerance(originalEvent) {
 	if (typeof PointerEvent !== "undefined" && originalEvent instanceof PointerEvent) return originalEvent.pointerType === "touch" ? 12 : 4;
@@ -1688,13 +1698,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 +2038,133 @@ 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
+	};
+}
+/**
+* Read a label `Point` feature's rendered props (`text`, `rotation`,
+* `textAnchor`, `textSizePixels`, `textSizeMeters`) into a
+* {@link fitLabelTransformBox} input, anchored at `anchorPixel`. Shared by
+* the edit controller's label picking/dragging and `TacticalDraw`'s
+* `ownsInteractionAt` label-extent fallback — both need the exact same
+* text-extent estimate so a click that "owns" a label during a host
+* click-away check matches what the edit controller would pick.
+*/
+function fitLabelBoxFromFeature(feature, anchorPixel, view) {
+	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: view.resolution,
+		bearing: view.bearing
+	});
+}
 //#endregion
 //#region src/tactical-draw/edit-controller.ts
 /**
@@ -2079,6 +2196,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 +2297,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 +2394,20 @@ 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, {
+					resolution: adapter.getResolution(),
+					bearing: adapter.getBearing()
+				});
+			}
 			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 +2426,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 +2699,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 +2775,7 @@ function runEdit(opts) {
 	function applyModes(next) {
 		if (modesEqual(modes, next)) return;
 		modes = next;
+		if (!modes.includes("labeldrag")) selectedLabelKey = null;
 		renderHandlesLayer();
 	}
 	function drainPendingModes() {
@@ -2695,6 +2875,18 @@ 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;
 	function pickLabel(pixel, tolerance) {
 		for (const feature of lastPreviewFeatures) {
@@ -2706,20 +2898,60 @@ 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, {
+				resolution: adapter.getResolution(),
+				bearing: adapter.getBearing()
+			});
+			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, 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 labelAnchorFromPointer(pixel, handle) {
-		return driver.fromPixel([pixel[0], pixel[1] + (handle ? LABEL_HANDLE_OFFSET_PX : 0)]);
+	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
@@ -2768,11 +3000,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 +3141,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 +3184,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 +3328,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();
@@ -4346,6 +4657,92 @@ var TacticalDraw = class {
 		return remove;
 	}
 	/**
+	* Stateless hit test answering "does TacticalDraw own the pixel at
+	* `pixel`?" — for hosts composing their own click-away / deselection logic
+	* (issue #216) alongside `TacticalDraw`'s draw/edit sessions. Today hosts
+	* hack this together from the `@internal` `layerIds` plus engine-specific
+	* layer queries; this is the supported replacement.
+	*
+	* Tests, topmost first, the three interactive layers — `handlesLayer`,
+	* then `previewLayer`, then `graphicsLayer` — against each layer's current
+	* `adapter.getLayerFeatures(...)` cache. The `guideLayer` is deliberately
+	* excluded: it is non-interactive draw-guide scaffolding, never a
+	* legitimate "owned" click target.
+	*
+	* `preview` and `graphics` each get a label text-extent fallback after the
+	* geometry pass misses on that layer: for every `Point` feature carrying a
+	* string `properties.text`, the anchor is projected and
+	* `fitLabelBoxFromFeature` (shared with the edit controller's `pickLabel`,
+	* see commit f908434) estimates the rendered text's box; a pixel inside
+	* that box counts as owned even though it's off the anchor point itself.
+	* This matters most for the active preview, since a click can land
+	* anywhere across a rotated/offset label during an edit.
+	*
+	* `tolerance` defaults to `mapEventHitTolerance(options?.originalEvent)` —
+	* pass the host's raw click event as `originalEvent` to get the same
+	* pointer-type-aware tolerance (4px mouse/pen, 12px touch) `onPick` uses;
+	* pass an explicit `tolerance` to override it outright.
+	*
+	* `measureId` is set when the hit feature resolves to a control-measure id
+	* via `tryControlMeasureIdFromFeature` — present for graphics/preview
+	* parts, generally absent for handles.
+	*
+	* This is a pure synchronous query over adapter-cached state: it does not
+	* depend on `onPick`/`"click"` dispatch having run first, so it is safe to
+	* call from any host click handler regardless of ordering relative to
+	* TacticalDraw's own pick/click pipeline.
+	*/
+	ownsInteractionAt(pixel, options) {
+		this.assertAlive();
+		const tolerance = options?.tolerance ?? mapEventHitTolerance(options?.originalEvent);
+		const toPixel = (lonLat) => this.adapter.getPixelFromCoordinate(lonLat);
+		const layers = [
+			{
+				layer: "handles",
+				layerId: this.handlesLayer,
+				labelFallback: false
+			},
+			{
+				layer: "preview",
+				layerId: this.previewLayer,
+				labelFallback: true
+			},
+			{
+				layer: "graphics",
+				layerId: this.graphicsLayer,
+				labelFallback: true
+			}
+		];
+		for (const { layer, layerId, labelFallback } of layers) {
+			const features = this.adapter.getLayerFeatures(layerId);
+			const hit = hitTestFeature(pixel, features, tolerance, toPixel);
+			if (hit) return this.toInteractionHit(layer, hit);
+			if (labelFallback) for (const feature of features) {
+				if (feature.geometry?.type !== "Point") continue;
+				if (typeof feature.properties?.text !== "string") continue;
+				const anchorPixel = toPixel(feature.geometry.coordinates);
+				if (!anchorPixel) continue;
+				const box = fitLabelBoxFromFeature(feature, anchorPixel, {
+					resolution: this.adapter.getResolution(),
+					bearing: this.adapter.getBearing()
+				});
+				if (box && pointInBox(box, pixel)) return this.toInteractionHit(layer, feature);
+			}
+		}
+		return null;
+	}
+	toInteractionHit(layer, feature) {
+		const measureId = tryControlMeasureIdFromFeature(feature);
+		return measureId != null ? {
+			layer,
+			feature,
+			measureId
+		} : {
+			layer,
+			feature
+		};
+	}
+	/**
 	* Abort the in-flight draw or edit. The default `"session"` reason matches
 	* `DrawSession.abort()` / `EditSession.abort()`.
 	*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbat-mapper/tactical-draw",
-  "version": "0.2.0-alpha.17",
+  "version": "0.2.0-alpha.19",
   "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",