@orbat-mapper/tactical-draw 0.2.0-alpha.30 → 0.2.0-alpha.32

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { canonicalTextAmplifierKey, cloneControlMeasure, controlMeasureIdFromFeature, freezeOrientationOptions, getControlMeasureMetadata, renderControlMeasure, resolveAmplifierPlacement, resolveStyleHints, roundToFixed } from "@orbat-mapper/control-measures";
+import { applyBoxTransformOptions, canonicalTextAmplifierKey, cloneControlMeasure, controlMeasureIdFromFeature, freezeOrientationOptions, getControlMeasureMetadata, getDefaultOptions, renderControlMeasure, resolveAmplifierPlacement, resolveStyleHints, roundToFixed } from "@orbat-mapper/control-measures";
 //#region src/base-map-adapter.ts
 /**
 * Abstract base class shared by all `MapAdapter` implementations.
@@ -218,26 +218,17 @@ var BaseMapAdapter = class {
 		return this.featureCache.get(layerId) ?? [];
 	}
 };
-function pickHitTolerance(originalEvent) {
-	if (typeof PointerEvent !== "undefined" && originalEvent instanceof PointerEvent) return originalEvent.pointerType === "touch" ? 12 : 4;
-	if (typeof TouchEvent !== "undefined" && originalEvent instanceof TouchEvent) return 12;
-	return 4;
+function pickPointerType(originalEvent) {
+	if (typeof PointerEvent !== "undefined" && originalEvent instanceof PointerEvent) {
+		if (originalEvent.pointerType === "touch") return "touch";
+		return originalEvent.pointerType === "pen" ? "pen" : "mouse";
+	}
+	if (typeof TouchEvent !== "undefined" && originalEvent instanceof TouchEvent) return "touch";
+	if (originalEvent && typeof originalEvent === "object" && "originalEvent" in originalEvent) return pickPointerType(originalEvent.originalEvent);
+	return "mouse";
 }
-/**
-* Resolve a pixel hit-tolerance for a `MapEvent.originalEvent` delivered by the
-* `MapAdapter.on(...)` pipeline. Unlike {@link PickEvent}, that pipeline forwards
-* the *engine wrapper* event (OpenLayers `MapBrowserEvent`, MapLibre
-* `MapMouseEvent`, Leaflet `LeafletMouseEvent`), each of which carries the raw
-* DOM event on a `.originalEvent` property. {@link pickHitTolerance} only
-* recognizes a real `PointerEvent` / `TouchEvent`, so unwrap one level when the
-* wrapper itself is not recognized as touch. Falls back to the mouse tolerance
-* when the input type cannot be determined.
-*/
-function mapEventHitTolerance(originalEvent) {
-	const direct = pickHitTolerance(originalEvent);
-	if (direct === 12) return direct;
-	if (originalEvent && typeof originalEvent === "object" && "originalEvent" in originalEvent) return pickHitTolerance(originalEvent.originalEvent);
-	return direct;
+function pickHitTolerance(originalEvent) {
+	return pickPointerType(originalEvent) === "touch" ? 12 : 4;
 }
 function tryControlMeasureIdFromFeature(feature) {
 	const graphicId = feature.properties?.graphicId;
@@ -268,6 +259,392 @@ function bindAbortable(signal, attach) {
 	return dispose;
 }
 //#endregion
+//#region src/pick-candidates.ts
+/**
+* The `visualOrder` for the feature at `index` of a render-ordered
+* (bottom-first) list of `total` features: reversing the index makes the
+* topmost-rendered feature the lowest, and therefore winning, order.
+*/
+function renderOrderToVisualOrder(index, total) {
+	return total - 1 - index;
+}
+/**
+* Preserve native visual ordering/hit evidence while keeping cached source
+* geometry authoritative. Native polygon geometry may be tile-clipped and
+* therefore contain artificial edges that are not part of the graphic.
+*
+* Normalizes to the shared `visualOrder` contract (lower = visually
+* topmost): native hits already arrive topmost-first from the engines and
+* keep that order at the front. Cached-only features (not among the native
+* hits) are appended after them, in reverse cache order — cache arrays are
+* render order (bottom-first), so reversing yields topmost-first — with
+* `visualOrder` numbering continuing on from the native section.
+*/
+function mergeNativeAndCachedPickFeatures(nativeFeatures, cachedFeatures) {
+	const cachedById = /* @__PURE__ */ new Map();
+	for (const feature of cachedFeatures) if (feature.id != null) cachedById.set(feature.id, feature);
+	const merged = [];
+	const seenIds = /* @__PURE__ */ new Set();
+	for (const nativeFeature of nativeFeatures) {
+		if (nativeFeature.id != null && seenIds.has(nativeFeature.id)) continue;
+		const feature = nativeFeature.id == null ? nativeFeature : cachedById.get(nativeFeature.id) ?? nativeFeature;
+		merged.push({
+			feature,
+			visualOrder: merged.length,
+			nativeHit: true
+		});
+		if (nativeFeature.id != null) seenIds.add(nativeFeature.id);
+	}
+	for (let i = cachedFeatures.length - 1; i >= 0; i--) {
+		const feature = cachedFeatures[i];
+		if (feature.id != null && seenIds.has(feature.id)) continue;
+		merged.push({
+			feature,
+			visualOrder: merged.length,
+			nativeHit: false
+		});
+		if (feature.id != null) seenIds.add(feature.id);
+	}
+	return merged;
+}
+/**
+* Evaluate every relevant rendered part in screen space, then return the
+* primary candidate under the visible-intent ranking policy: direct visible
+* marks (strokes, points, icons, labels) outrank visibly filled interiors,
+* which outrank inferred outline-only reach; competing direct marks rank by
+* screen-space distance; visual topmost order is only the final tie-break.
+* See `rankPickCandidates` for the full ordered list — that ordering stays
+* internal adapter-author plumbing; the public pick event exposes only this
+* primary candidate.
+*/
+function evaluatePickCandidates(inputs, context) {
+	let best = null;
+	for (const input of inputs) {
+		const candidate = buildCandidate(input, context);
+		if (candidate && (best === null || compareCandidates(candidate, best) < 0)) best = candidate;
+	}
+	return best;
+}
+function buildCandidate(input, context) {
+	const presentation = input.presentation ?? resolvePickPresentation(input.feature, input.layerStyle);
+	const evaluated = evaluateInput(input, presentation, context);
+	if (!evaluated) return null;
+	return {
+		feature: input.feature,
+		graphicId: tryControlMeasureIdFromFeature(input.feature),
+		renderedPartId: typeof input.feature.id === "string" || typeof input.feature.id === "number" ? input.feature.id : null,
+		hit: evaluated.hit,
+		viewport: context.viewport,
+		presentation,
+		visualOrder: input.visualOrder,
+		...evaluated.iconFootprint ? { iconFootprint: evaluated.iconFootprint } : {},
+		...input.labelExtent ? { labelExtent: input.labelExtent } : {}
+	};
+}
+function compareCandidates(a, b) {
+	const rankA = selectionSurfaceRank(a);
+	const rankDifference = rankA - selectionSurfaceRank(b);
+	if (rankDifference !== 0) return rankDifference;
+	if (rankA === 0 && a.hit.distance !== null && b.hit.distance !== null) {
+		const distanceDifference = a.hit.distance - b.hit.distance;
+		if (distanceDifference !== 0) return distanceDifference;
+	}
+	return a.visualOrder - b.visualOrder;
+}
+function selectionSurfaceRank(candidate) {
+	if (candidate.hit.kind !== "polygon-interior") return 0;
+	return (candidate.presentation.fill?.opacity ?? 0) > 0 ? 1 : 2;
+}
+function resolvePickPresentation(feature, layerStyle) {
+	const featureStyle = asRecord(feature.properties?.style);
+	const strokeColor = stringValue(featureStyle?.strokeColor) ?? layerStyle?.strokeColor;
+	const strokeWidth = numberValue(featureStyle?.strokeWidth) ?? layerStyle?.strokeWidth;
+	const strokeDash = numberArray(featureStyle?.strokeDash) ?? layerStyle?.strokeDash;
+	const fillColor = stringValue(featureStyle?.fillColor) ?? layerStyle?.fillColor;
+	const fillPattern = stringValue(featureStyle?.fillPattern);
+	const pointFillColor = stringValue(featureStyle?.pointFillColor) ?? stringValue(featureStyle?.fillColor) ?? layerStyle?.pointFillColor ?? layerStyle?.fillColor;
+	const pointRadius = numberValue(featureStyle?.pointRadius) ?? layerStyle?.pointRadius;
+	const presentation = {};
+	if (strokeColor !== void 0 || strokeWidth !== void 0 || strokeDash !== void 0) presentation.stroke = {
+		...strokeColor !== void 0 ? { color: strokeColor } : {},
+		...strokeWidth !== void 0 ? { width: strokeWidth } : {},
+		...strokeDash !== void 0 ? { dash: strokeDash } : {}
+	};
+	if (fillColor !== void 0 || fillPattern !== void 0) presentation.fill = {
+		...fillColor !== void 0 ? { color: fillColor } : {},
+		...fillPattern !== void 0 ? { pattern: fillPattern } : {},
+		opacity: colorOpacity(fillColor)
+	};
+	if (feature.geometry.type === "Point" && (pointFillColor !== void 0 || pointRadius !== void 0)) presentation.point = {
+		...pointFillColor !== void 0 ? { fillColor: pointFillColor } : {},
+		...pointRadius !== void 0 ? { radius: pointRadius } : {}
+	};
+	if (layerStyle?.text !== void 0) presentation.text = { ...layerStyle.text };
+	return presentation;
+}
+function evaluateInput(input, presentation, context) {
+	if (input.labelExtent && pointInExtent(context.pixel, input.labelExtent)) return { hit: {
+		kind: "label",
+		distance: 0
+	} };
+	if (input.icon) return evaluateIcon(input.feature, input.icon, context);
+	const geometryHit = evaluateGeometry(input.feature, presentation, context);
+	if (geometryHit) return { hit: geometryHit };
+	if (input.feature.geometry.type === "Polygon" || input.feature.geometry.type === "MultiPolygon") return null;
+	return input.nativeHit ? { hit: {
+		kind: inferNativeHitKind(input.feature),
+		distance: null
+	} } : null;
+}
+function inferNativeHitKind(feature) {
+	if (typeof feature.properties?.iconId === "string") return "icon";
+	if (typeof feature.properties?.text === "string") return "label";
+	if (feature.geometry.type === "Point") return "point";
+	if (feature.geometry.type === "LineString" || feature.geometry.type === "MultiLineString") return "line";
+	return "native";
+}
+function evaluateGeometry(feature, presentation, context) {
+	const geometry = feature.geometry;
+	const { pixel, tolerance, toPixel } = context;
+	if (geometry.type === "Point") {
+		const projected = toPixel(geometry.coordinates);
+		if (!projected) return null;
+		const distance = pointDistance(pixel, projected);
+		return distance <= tolerance ? {
+			kind: "point",
+			distance
+		} : null;
+	}
+	if (geometry.type === "LineString") {
+		const distance = distanceToLine(pixel, geometry.coordinates, toPixel);
+		return distance !== null && distance <= tolerance ? {
+			kind: "line",
+			distance
+		} : null;
+	}
+	if (geometry.type === "MultiLineString") {
+		const distance = minimum(geometry.coordinates.map((line) => distanceToLine(pixel, line, toPixel)));
+		return distance !== null && distance <= tolerance ? {
+			kind: "line",
+			distance
+		} : null;
+	}
+	if (geometry.type === "Polygon") return evaluatePolygon(pixel, geometry.coordinates, presentation, context);
+	if (geometry.type === "MultiPolygon") return bestPolygonHit(geometry.coordinates.map((polygon) => evaluatePolygon(pixel, polygon, presentation, context)).filter((hit) => hit !== null));
+	return null;
+}
+function evaluatePolygon(pixel, rings, presentation, context) {
+	const { tolerance, toPixel, viewport } = context;
+	const projectedRings = rings.map((ring) => ring.map(toPixel));
+	const distance = hasVisibleBoundary(presentation) ? minimum(projectedRings.map((points) => minVisibleSegmentDistance(pixel, points, viewport))) : null;
+	if (distance !== null && distance <= tolerance) return {
+		kind: "polygon-boundary",
+		distance
+	};
+	if (!(projectedRings.length > 0 && pointInProjectedRing(pixel, projectedRings[0]) && !projectedRings.slice(1).some((points) => pointInProjectedRing(pixel, points)))) return null;
+	const visiblyFilled = (presentation.fill?.opacity ?? 0) > 0;
+	const inwardReach = context.pointerType === "touch" ? 36 : 24;
+	if (visiblyFilled || distance !== null && distance <= inwardReach) return {
+		kind: "polygon-interior",
+		distance
+	};
+	return null;
+}
+function bestPolygonHit(hits) {
+	if (hits.length === 0) return null;
+	const boundary = hits.filter((hit) => hit.kind === "polygon-boundary");
+	if (boundary.length > 0) return boundary.reduce((best, hit) => (hit.distance ?? Infinity) < (best.distance ?? Infinity) ? hit : best);
+	return hits[0];
+}
+function evaluateIcon(feature, resource, context) {
+	if (feature.geometry.type !== "Point") return null;
+	const anchor = context.toPixel(feature.geometry.coordinates);
+	if (!anchor) return null;
+	const rawScale = feature.properties?.iconScale;
+	const scale = typeof rawScale === "number" ? rawScale : 1;
+	if (!Number.isFinite(scale) || scale <= 0) return null;
+	const rawRotation = feature.properties?.iconRotation;
+	const angle = (typeof rawRotation === "number" && Number.isFinite(rawRotation) ? rawRotation : 0) - (context.bearing ?? 0);
+	const cos = Math.cos(angle);
+	const sin = Math.sin(angle);
+	const minX = -resource.anchor[0] * scale;
+	const maxX = (resource.width - resource.anchor[0]) * scale;
+	const minY = -resource.anchor[1] * scale;
+	const maxY = (resource.height - resource.anchor[1]) * scale;
+	const dx = context.pixel[0] - anchor[0];
+	const dy = context.pixel[1] - anchor[1];
+	const localX = dx * cos + dy * sin;
+	const localY = -dx * sin + dy * cos;
+	const outsideX = Math.max(minX - localX, 0, localX - maxX);
+	const outsideY = Math.max(minY - localY, 0, localY - maxY);
+	if (outsideX > context.tolerance || outsideY > context.tolerance) return null;
+	const coreRect = resource.coreRect ?? {
+		x: 0,
+		y: 0,
+		width: resource.width,
+		height: resource.height
+	};
+	const coreMinX = (coreRect.x - resource.anchor[0]) * scale;
+	const coreMaxX = (coreRect.x + coreRect.width - resource.anchor[0]) * scale;
+	const coreMinY = (coreRect.y - resource.anchor[1]) * scale;
+	const coreMaxY = (coreRect.y + coreRect.height - resource.anchor[1]) * scale;
+	const coreOutsideX = Math.max(coreMinX - localX, 0, localX - coreMaxX);
+	const coreOutsideY = Math.max(coreMinY - localY, 0, localY - coreMaxY);
+	const distance = Math.hypot(coreOutsideX, coreOutsideY);
+	const corner = (x, y) => [anchor[0] + x * cos - y * sin, anchor[1] + x * sin + y * cos];
+	return {
+		hit: {
+			kind: "icon",
+			distance
+		},
+		iconFootprint: [
+			corner(minX, minY),
+			corner(maxX, minY),
+			corner(maxX, maxY),
+			corner(minX, maxY)
+		]
+	};
+}
+function distanceToLine(pixel, coordinates, toPixel) {
+	return minSegmentDistance(pixel, coordinates.map(toPixel));
+}
+/** Nearest distance from `pixel` to any segment of a pre-projected polyline. */
+function minSegmentDistance(pixel, points) {
+	let closest = null;
+	for (let i = 0; i < points.length - 1; i++) {
+		const a = points[i];
+		const b = points[i + 1];
+		if (!a || !b) continue;
+		const distance = distanceToSegment(pixel, a, b);
+		if (distance !== null && (closest === null || distance < closest)) closest = distance;
+	}
+	return closest;
+}
+/** As `minSegmentDistance`, but each segment is first clipped to `viewport`. */
+function minVisibleSegmentDistance(pixel, points, viewport) {
+	let closest = null;
+	for (let i = 0; i < points.length - 1; i++) {
+		const a = points[i];
+		const b = points[i + 1];
+		if (!a || !b) continue;
+		const visible = clipSegmentToBounds(a, b, viewport);
+		if (!visible) continue;
+		const [visibleA, visibleB] = visible;
+		const distance = visibleA[0] === visibleB[0] && visibleA[1] === visibleB[1] ? pointDistance(pixel, visibleA) : distanceToSegment(pixel, visibleA, visibleB);
+		if (distance !== null && (closest === null || distance < closest)) closest = distance;
+	}
+	return closest;
+}
+function clipSegmentToBounds(a, b, bounds) {
+	const dx = b[0] - a[0];
+	const dy = b[1] - a[1];
+	let start = 0;
+	let end = 1;
+	const edges = [
+		[-dx, a[0] - bounds.minX],
+		[dx, bounds.maxX - a[0]],
+		[-dy, a[1] - bounds.minY],
+		[dy, bounds.maxY - a[1]]
+	];
+	for (const [direction, offset] of edges) {
+		if (direction === 0) {
+			if (offset < 0) return null;
+			continue;
+		}
+		const ratio = offset / direction;
+		if (direction < 0) start = Math.max(start, ratio);
+		else end = Math.min(end, ratio);
+		if (start > end) return null;
+	}
+	return [[a[0] + start * dx, a[1] + start * dy], [a[0] + end * dx, a[1] + end * dy]];
+}
+function distanceToSegment(pixel, a, b) {
+	const dx = b[0] - a[0];
+	const dy = b[1] - a[1];
+	const lengthSq = dx * dx + dy * dy;
+	if (lengthSq === 0) return null;
+	const unclamped = ((pixel[0] - a[0]) * dx + (pixel[1] - a[1]) * dy) / lengthSq;
+	const t = Math.max(0, Math.min(1, unclamped));
+	return Math.hypot(pixel[0] - (a[0] + t * dx), pixel[1] - (a[1] + t * dy));
+}
+/**
+* Even-odd point-in-ring test over a pre-projected ring. Any vertex that
+* failed to project makes the whole ring inconclusive, matching the prior
+* "project every vertex or bail" contract.
+*/
+function pointInProjectedRing(pixel, points) {
+	let inside = false;
+	for (let i = 0, j = points.length - 1; i < points.length; j = i++) {
+		const pi = points[i];
+		const pj = points[j];
+		if (!pi || !pj) return false;
+		const [xi, yi] = pi;
+		const [xj, yj] = pj;
+		if (yi > pixel[1] !== yj > pixel[1] && pixel[0] < (xj - xi) * (pixel[1] - yi) / (yj - yi) + xi) inside = !inside;
+	}
+	return inside;
+}
+function pointInExtent(pixel, extent) {
+	if ("minX" in extent) return pixel[0] >= extent.minX && pixel[0] <= extent.maxX && pixel[1] >= extent.minY && pixel[1] <= extent.maxY;
+	const dx = pixel[0] - extent.center[0];
+	const dy = pixel[1] - extent.center[1];
+	const cos = Math.cos(-extent.angle);
+	const sin = Math.sin(-extent.angle);
+	const localX = dx * cos - dy * sin;
+	const localY = dx * sin + dy * cos;
+	return Math.abs(localX) <= extent.halfWidth && Math.abs(localY) <= extent.halfHeight;
+}
+function pointDistance(a, b) {
+	return Math.hypot(a[0] - b[0], a[1] - b[1]);
+}
+function minimum(values) {
+	let result = null;
+	for (const value of values) if (value !== null && (result === null || value < result)) result = value;
+	return result;
+}
+function colorOpacity(color) {
+	if (color === void 0) return 0;
+	const normalized = color.trim().toLowerCase();
+	if (normalized === "transparent") return 0;
+	if (/^#[0-9a-f]{4}$/i.test(normalized)) return parseInt(normalized[4], 16) / 15;
+	if (/^#[0-9a-f]{8}$/i.test(normalized)) return parseInt(normalized.slice(7, 9), 16) / 255;
+	const functional = normalized.match(/^[a-z]+\((.*)\)$/);
+	if (functional) {
+		const body = functional[1];
+		const slashAlpha = body.match(/\/\s*([+-]?(?:\d*\.)?\d+)(%)?\s*$/);
+		if (slashAlpha) return normalizedAlpha(slashAlpha[1], slashAlpha[2] === "%");
+		const commaParts = body.split(",").map((part) => part.trim());
+		if (commaParts.length === 4) {
+			const alpha = commaParts[3].match(/^([+-]?(?:\d*\.)?\d+)(%)?$/);
+			if (alpha) return normalizedAlpha(alpha[1], alpha[2] === "%");
+		}
+	}
+	return 1;
+}
+function normalizedAlpha(value, percentage) {
+	const alpha = Number(value);
+	if (!Number.isFinite(alpha)) return 1;
+	return Math.max(0, Math.min(1, percentage ? alpha / 100 : alpha));
+}
+function hasVisibleBoundary(presentation) {
+	const stroke = presentation.stroke;
+	if (!stroke || stroke.color === void 0) return false;
+	if (stroke.width !== void 0 && stroke.width <= 0) return false;
+	return colorOpacity(stroke.color) > 0;
+}
+function asRecord(value) {
+	return value !== null && typeof value === "object" ? value : void 0;
+}
+function stringValue(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function numberValue(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function numberArray(value) {
+	return Array.isArray(value) && value.every((item) => typeof item === "number") ? [...value] : void 0;
+}
+//#endregion
 //#region src/feature-style.ts
 /**
 * Coerce a raw `properties.style` value into a `HandleStyle` for the
@@ -296,6 +673,33 @@ function resolveGroundTextSizePixels(textSizeMeters, resolution, text) {
 	const max = text?.textSizeMaxPixels ?? 24;
 	return Math.min(max, Math.max(min, textSizeMeters / resolution));
 }
+/**
+* Resolve a Text graphic's on-screen size in pixels, honoring the
+* `textMaxSizePixels` hide threshold (ADR-0037). Returns `null` — the "hidden"
+* signal — when the graphic should render no text this frame; adapters emit no
+* text style for a `null`. Distinct from [[resolveGroundTextSizePixels]], which
+* keeps the 8–24 px clamp band for amplifier labels: this helper is the Text
+* graphic's own sizing rule.
+*
+*  - screen-anchored (`textSizePixels`): the fixed pixel size, never scaled or
+*    hidden by zoom.
+*  - ground-anchored (`textSizeMeters`) with a `textMaxSizePixels` threshold:
+*    *unclamped* `meters / resolution` (the 8–24 band does NOT apply), hidden
+*    (`null`) once that exceeds the threshold — text shrinks freely zooming out
+*    and vanishes rather than clamps zooming in.
+*  - ground-anchored without a threshold: falls back to the clamped band.
+*  - no usable size or resolution: `null`.
+*/
+function resolveTextSizePixels(props, resolution) {
+	if (typeof props.textSizePixels === "number") return props.textSizePixels;
+	const meters = props.textSizeMeters;
+	if (typeof meters !== "number" || !(resolution > 0)) return null;
+	if (typeof props.textMaxSizePixels === "number") {
+		const px = meters / resolution;
+		return px > props.textMaxSizePixels ? null : px;
+	}
+	return resolveGroundTextSizePixels(meters, resolution, props);
+}
 //#endregion
 //#region src/gestures/hit-test.ts
 /** Clamped parameter t ∈ [0, 1] of `pixel` projected onto the segment a→b in pixel space, or null for a zero-length segment. */
@@ -307,41 +711,6 @@ function clampedSegmentParameter(pixel, a, b) {
 	const t = ((pixel[0] - a[0]) * dx + (pixel[1] - a[1]) * dy) / lengthSq;
 	return Math.max(0, Math.min(1, t));
 }
-/** Distance from `pixel` to the segment p1→p2 in pixel space, or null if either endpoint fails to project or the segment has zero length. */
-function pixelDistanceToSegment(pixel, p1, p2, toPixel) {
-	const a = toPixel(p1);
-	const b = toPixel(p2);
-	if (!a || !b) return null;
-	const t = clampedSegmentParameter(pixel, a, b);
-	if (t === null) return null;
-	const ddx = pixel[0] - (a[0] + t * (b[0] - a[0]));
-	const ddy = pixel[1] - (a[1] + t * (b[1] - a[1]));
-	return Math.sqrt(ddx * ddx + ddy * ddy);
-}
-/** Even-odd point-in-ring test in pixel space. */
-function pixelPointInRing(pixel, ring, toPixel) {
-	const projected = [];
-	for (const c of ring) {
-		const p = toPixel(c);
-		if (!p) return false;
-		projected.push(p);
-	}
-	const [px, py] = pixel;
-	let inside = false;
-	for (let i = 0, j = projected.length - 1; i < projected.length; j = i++) {
-		const xi = projected[i][0], yi = projected[i][1];
-		const xj = projected[j][0], yj = projected[j][1];
-		if (yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi) + xi) inside = !inside;
-	}
-	return inside;
-}
-function isNearAnySegment(pixel, ring, hitTolerance, toPixel) {
-	for (let i = 0; i < ring.length - 1; i++) {
-		const d = pixelDistanceToSegment(pixel, ring[i], ring[i + 1], toPixel);
-		if (d !== null && d <= hitTolerance) return true;
-	}
-	return false;
-}
 /**
 * Test whether `pixel` hits any feature in `features`, in pixel space.
 *
@@ -354,23 +723,28 @@ function isNearAnySegment(pixel, ring, hitTolerance, toPixel) {
 * Returns the first matching feature in iteration order, or null.
 */
 function hitTestFeature(pixel, features, hitTolerance, toPixel) {
-	const [px, py] = pixel;
-	for (const f of features) {
-		if (!f) continue;
-		const geom = f.geometry;
-		let hit = false;
-		if (geom.type === "Point") {
-			const p = toPixel(geom.coordinates);
-			if (p) {
-				const dx = p[0] - px;
-				const dy = p[1] - py;
-				hit = Math.sqrt(dx * dx + dy * dy) <= hitTolerance;
-			}
-		} else if (geom.type === "LineString") hit = isNearAnySegment(pixel, geom.coordinates, hitTolerance, toPixel);
-		else if (geom.type === "MultiLineString") hit = geom.coordinates.some((line) => isNearAnySegment(pixel, line, hitTolerance, toPixel));
-		else if (geom.type === "Polygon") hit = geom.coordinates.some((ring) => pixelPointInRing(pixel, ring, toPixel)) || geom.coordinates.some((ring) => isNearAnySegment(pixel, ring, hitTolerance, toPixel));
-		else if (geom.type === "MultiPolygon") hit = geom.coordinates.some((poly) => poly.some((ring) => pixelPointInRing(pixel, ring, toPixel))) || geom.coordinates.some((poly) => poly.some((ring) => isNearAnySegment(pixel, ring, hitTolerance, toPixel)));
-		if (hit) return f;
+	for (const feature of features) {
+		if (!feature) continue;
+		const candidate = evaluatePickCandidates([{
+			feature,
+			visualOrder: 0,
+			...feature.geometry.type === "Polygon" || feature.geometry.type === "MultiPolygon" ? { presentation: {
+				stroke: {
+					color: "#000",
+					width: 1
+				},
+				fill: {
+					color: "#000",
+					opacity: 1
+				}
+			} } : {}
+		}], {
+			pixel,
+			tolerance: hitTolerance,
+			toPixel,
+			viewport: UNBOUNDED_VIEWPORT
+		});
+		if (candidate) return candidate.feature;
 	}
 	return null;
 }
@@ -381,26 +755,24 @@ function hitTestFeature(pixel, features, hitTolerance, toPixel) {
 * unscaled SVG viewport. A positive tolerance pads all four sides.
 */
 function hitTestIconFeature(pixel, feature, resource, hitTolerance, toPixel, bearing = 0) {
-	if (feature.geometry.type !== "Point") return false;
-	const anchor = toPixel(feature.geometry.coordinates);
-	if (!anchor) return false;
-	const rawScale = feature.properties?.iconScale;
-	const scale = typeof rawScale === "number" ? rawScale : 1;
-	if (!Number.isFinite(scale) || scale <= 0) return false;
-	const rawRotation = feature.properties?.iconRotation;
-	const angle = (typeof rawRotation === "number" && Number.isFinite(rawRotation) ? rawRotation : 0) - bearing;
-	const cos = Math.cos(angle);
-	const sin = Math.sin(angle);
-	const dx = pixel[0] - anchor[0];
-	const dy = pixel[1] - anchor[1];
-	const localX = dx * cos + dy * sin;
-	const localY = -dx * sin + dy * cos;
-	const minX = -resource.anchor[0] * scale - hitTolerance;
-	const maxX = (resource.width - resource.anchor[0]) * scale + hitTolerance;
-	const minY = -resource.anchor[1] * scale - hitTolerance;
-	const maxY = (resource.height - resource.anchor[1]) * scale + hitTolerance;
-	return localX >= minX && localX <= maxX && localY >= minY && localY <= maxY;
+	return evaluatePickCandidates([{
+		feature,
+		visualOrder: 0,
+		icon: resource
+	}], {
+		pixel,
+		tolerance: hitTolerance,
+		toPixel,
+		viewport: UNBOUNDED_VIEWPORT,
+		bearing
+	}) !== null;
 }
+const UNBOUNDED_VIEWPORT = {
+	minX: Number.NEGATIVE_INFINITY,
+	minY: Number.NEGATIVE_INFINITY,
+	maxX: Number.POSITIVE_INFINITY,
+	maxY: Number.POSITIVE_INFINITY
+};
 //#endregion
 //#region src/gestures/hit-tolerance.ts
 const TOUCH_HIT_TOLERANCE_PX = 22;
@@ -684,6 +1056,10 @@ const PIXEL_SIZE_OPTIONS = {
 	"antitank-wall": {
 		pixels: "toothHeightPixels",
 		meters: "toothHeight"
+	},
+	text: {
+		pixels: "sizePixels",
+		meters: "sizeMeters"
 	}
 };
 /** The shared label-size pair every `capturesLabelSize` kind carries (ADR-0028). */
@@ -745,6 +1121,34 @@ function getSizeAnchor(measure) {
 	return measureUsesAdapterResolution(measure) ? "screen" : "ground";
 }
 /**
+* Materialise a *pixel-authored* kind's default pixel size onto a measure that
+* carries neither size key, so the ADR-0020 ground bake has a pixel value to
+* resolve to meters at commit. A kind is pixel-authored when its default
+* options declare the pixel-size option but no meter counterpart (e.g. Text's
+* `sizePixels: 24` with no `sizeMeters`) — such a fresh draw is authored in
+* pixels and must bake to meters, but a default draw commits with no options,
+* so the pixel size would otherwise never land and the graphic would persist
+* screen-anchored forever. No-op when the measure already carries a size key,
+* the kind has no pixel-size option, or the kind's default is meter-denominated
+* (e.g. FLOT, whose meter default governs a default draw without any bake) —
+* so this never changes the committed size of the pre-existing pixel kinds.
+*/
+function withDefaultAuthoringSize(measure) {
+	const spec = PIXEL_SIZE_OPTIONS[measure.kind];
+	if (!spec) return measure;
+	const options = measure.options ?? {};
+	if (options[spec.pixels] !== void 0 || options[spec.meters] !== void 0) return measure;
+	const defaults = getDefaultOptions(measure.kind);
+	if (defaults[spec.meters] !== void 0 || defaults[spec.pixels] === void 0) return measure;
+	return {
+		...measure,
+		options: {
+			...options,
+			[spec.pixels]: defaults[spec.pixels]
+		}
+	};
+}
+/**
 * Bake a screen-anchored (pixel) size to a ground-anchored (meter) size at the
 * adapter's current resolution, then strip the pixel + `metersPerPixel` keys so
 * the result is an ordinary meters graphic carrying no pixel intent — afterward
@@ -1535,7 +1939,7 @@ function runFixedLengthDraw(options) {
 	}
 	function buildSnapshot() {
 		const finalPoints = roundControlPoints(rule ? rule.derive(committed) : committed);
-		const captured = withCommittedAdapterMeasureOptions({
+		const sized = withDefaultAuthoringSize(withCommittedAdapterMeasureOptions({
 			id: generateId(),
 			kind,
 			controlPoints: finalPoints,
@@ -1543,8 +1947,8 @@ function runFixedLengthDraw(options) {
 			...measureStyle !== void 0 ? { style: measureStyle } : {},
 			...measureProperties !== void 0 ? { properties: measureProperties } : {},
 			...measureTextAmplifiers !== void 0 ? { textAmplifiers: measureTextAmplifiers } : {}
-		});
-		const measure = sizeAnchor === "screen" ? captured : bakePixelSizeToGround(captured, adapter);
+		}));
+		const measure = sizeAnchor === "screen" ? sized : bakePixelSizeToGround(sized, adapter);
 		return {
 			graphic: cloneControlMeasure(measure),
 			render: renderMeasureForAdapter(adapter, measure, renderOpts)
@@ -1750,7 +2154,7 @@ function runVariableLengthDraw(options) {
 		if (lastSpineIdx >= 0 && canCommitNow()) for (const finishIndex of finishIndices) {
 			const finishPixel = adapter.getPixelFromCoordinate(committed[finishIndex]);
 			if (!finishPixel) continue;
-			const tol = mapEventHitTolerance(event.originalEvent);
+			const tol = pickHitTolerance(event.originalEvent);
 			const dx = event.pixel[0] - finishPixel[0];
 			const dy = event.pixel[1] - finishPixel[1];
 			if (dx * dx + dy * dy <= tol * tol) {
@@ -1815,7 +2219,7 @@ function runVariableLengthDraw(options) {
 		renderPreview();
 	}
 	function buildSnapshot() {
-		const built = withCommittedAdapterMeasureOptions({
+		const sized = withDefaultAuthoringSize(withCommittedAdapterMeasureOptions({
 			id: generateId(),
 			kind,
 			controlPoints: committed.map((p) => [...p]),
@@ -1823,8 +2227,8 @@ function runVariableLengthDraw(options) {
 			...measureStyle !== void 0 ? { style: measureStyle } : {},
 			...measureProperties !== void 0 ? { properties: measureProperties } : {},
 			...measureTextAmplifiers !== void 0 ? { textAmplifiers: measureTextAmplifiers } : {}
-		});
-		const measure = sizeAnchor === "screen" ? built : bakePixelSizeToGround(built, adapter);
+		}));
+		const measure = sizeAnchor === "screen" ? sized : bakePixelSizeToGround(sized, adapter);
 		return {
 			graphic: cloneControlMeasure(measure),
 			render: renderMeasureForAdapter(adapter, measure, renderOpts)
@@ -2182,6 +2586,21 @@ function normalizeRotation(angle) {
 function constrainRotation(angle) {
 	return Math.round(angle / CONSTRAINED_ROTATION_STEP) * CONSTRAINED_ROTATION_STEP;
 }
+//#endregion
+//#region src/tactical-draw/transform-box.ts
+/**
+* The uniform scale factor and rotation delta a box implies relative to a
+* pre-drag box, given the gesture kind. A `body` translate reports neither
+* (1, 0). Consumed both by point symbols (size/rotation) and by Text graphics
+* (folding the delta into rotation/size options); the delta is pivot-
+* independent so either can apply it without knowing the box center.
+*/
+function boxScaleRotation(kind, box, preDragBox) {
+	return {
+		scale: kind === "scale" ? Math.max(box.halfWidth / preDragBox.halfWidth, box.halfHeight / preDragBox.halfHeight) : 1,
+		rotation: kind === "rotate" ? box.angle - preDragBox.angle : 0
+	};
+}
 function rotate(x, y, angle) {
 	const cos = Math.cos(angle);
 	const sin = Math.sin(angle);
@@ -2720,12 +3139,16 @@ function normalizeAngle(angle) {
 *   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.
+* - **Hidden**: a ground-anchored size past `textMaxSizePixels` (ADR-0037)
+*   returns `null` — the box tracks `resolveTextSizePixels`'s hide rule
+*   rather than keep boxing text that no adapter is drawing.
 */
 function fitLabelTransformBox(input) {
-	const { text, rotation, textAnchor, textSizePixels, textSizeMeters, anchor, resolution, bearing } = input;
+	const { text, rotation, textAnchor, textSizePixels, textSizeMeters, anchor, resolution, bearing, unclamped, textMaxSizePixels } = input;
 	if (!text) return null;
+	if (typeof textMaxSizePixels === "number" && textSizePixels === void 0 && typeof textSizeMeters === "number" && typeof resolution === "number" && resolution > 0 && textSizeMeters / resolution > textMaxSizePixels) 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 h = textSizePixels !== void 0 ? Math.max(1, textSizePixels) : textSizeMeters !== void 0 && resolution !== void 0 && resolution > 0 ? unclamped ? Math.max(1, textSizeMeters / resolution) : 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;
@@ -2760,12 +3183,47 @@ function fitLabelBoxFromFeature(feature, anchorPixel, view) {
 		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,
+		textMaxSizePixels: typeof props.textMaxSizePixels === "number" ? props.textMaxSizePixels : void 0,
 		anchor: anchorPixel,
 		resolution: view.resolution,
-		bearing: view.bearing
+		bearing: view.bearing,
+		unclamped: view.unclamped
+	});
+}
+/**
+* Fit a `TransformBox` around a rendered **Text generic graphic** feature — the
+* Text analogue of the point-symbol footprint (ADR-0031): a rotated logical
+* rectangle centered on / shifted from the anchor per `textAlign` (via the
+* feature's `textAnchor` prop), sized from the text's line count and longest
+* line at the actual rendered height (screen `textSizePixels` as-is; ground
+* `textSizeMeters / resolution` unclamped). Drives the Text edit/transform box
+* outline, its corner-scale handles, and the pick extent, and updates live as a
+* rotate/scale gesture folds new rotation/size into the feature. Returns `null`
+* when the feature carries no text. Rotation pivots at the anchor, so the box
+* orbits the anchor when the text rotates — matching how the adapters render a
+* `textAnchor`-shifted, rotated label.
+*/
+function fitTextGraphicFootprint(feature, anchorPixel, view) {
+	return fitLabelBoxFromFeature(feature, anchorPixel, {
+		...view,
+		unclamped: true
 	});
 }
 /**
+* Locate the single Text `Point` feature in `features`, project its anchor, and
+* return its {@link fitTextGraphicFootprint} box — the shared body behind the
+* edit controller's Text box and the group transform-controller's Text member
+* footprint. Returns `null` when there is no text feature or its anchor is
+* off-screen.
+*/
+function fitTextFootprintFromFeatures(features, toPixel, view) {
+	const f = features.find((feat) => feat.geometry?.type === "Point" && typeof feat.properties?.text === "string");
+	if (!f || f.geometry?.type !== "Point") return null;
+	const anchorPixel = toPixel(f.geometry.coordinates);
+	if (!anchorPixel) return null;
+	return fitTextGraphicFootprint(f, anchorPixel, view);
+}
+/**
 * 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
@@ -3123,6 +3581,7 @@ function runEdit(opts) {
 	const closedRing = rule?.closedRing ?? false;
 	const guideEnabled = (guideOpt ?? true) && !shouldSuppressGuide(metadata);
 	const isAreaKind = metadata.geometry === "area";
+	const isTextGraphic = measure.kind === "text";
 	const requestedModes = normaliseModes(initialModes);
 	const editStartPoints = measure.controlPoints.map((p) => [...p]);
 	const workingPoints = editStartPoints.map((p) => [...p]);
@@ -3252,6 +3711,7 @@ function runEdit(opts) {
 	* projects (e.g. the working copy renders no features this frame).
 	*/
 	function fitBoxFromFeatures(features) {
+		if (isTextGraphic) return fitTextBox(features);
 		const positions = [];
 		for (const f of features) if (f.geometry) collectFeaturePositions(f.geometry, positions);
 		const pixels = [];
@@ -3262,13 +3722,28 @@ function runEdit(opts) {
 		return fitTransformBox(pixels, boxAngle, interactionStyle?.boxPadding ?? 0);
 	}
 	/**
+	* The Text footprint box (rotated rectangle hugging the rendered text),
+	* derived from the single Point feature's text props. Unlike geometry-fit
+	* boxes it carries the text's own on-screen angle (so it tilts with the
+	* rotation option) and honors `textAnchor` alignment; the session `boxAngle`
+	* is not used for Text.
+	*/
+	function fitTextBox(features) {
+		return fitTextFootprintFromFeatures(features, driver.toPixel, {
+			resolution: adapter.getResolution(),
+			bearing: adapter.getBearing()
+		});
+	}
+	/**
 	* Re-fit `box` from `lastPreviewFeatures`. A no-op while a box gesture is
 	* in flight — that drag paints the box rigidly from its own snapshot
 	* (`BoxDragSnapshot.box`) instead of a re-fit, so a corner/rotate/body drag
-	* doesn't fight its own paint.
+	* doesn't fight its own paint. Text is the exception: its box follows the
+	* rendered footprint live (a rotate/scale gesture changes the rendered text),
+	* so it re-fits every frame, drag included.
 	*/
 	function refitBox() {
-		if (activeBoxDrag) return;
+		if (activeBoxDrag && !isTextGraphic) return;
 		box = fitBoxFromFeatures(lastPreviewFeatures);
 	}
 	function liftOriginalFromGraphics() {
@@ -3319,7 +3794,7 @@ function runEdit(opts) {
 		}), handleIdPrefix, interactionStyle);
 		if (modes.includes("labeldrag")) features.push(...labels.handleFeatures());
 		if (modes.includes("transform")) {
-			const liveBox = activeBoxDrag ? activeBoxDrag.lastSnapshot.box : box;
+			const liveBox = activeBoxDrag && !isTextGraphic ? activeBoxDrag.lastSnapshot.box : box;
 			if (liveBox) {
 				features.push(boxOutlineFeature(liveBox, dragProjection.fromPixel, `${handleIdPrefix}:box-outline`, interactionStyle?.boxOutline));
 				features.push(...toFeatures(boxToHandles(liveBox, dragProjection.fromPixel), handleIdPrefix, interactionStyle));
@@ -3328,6 +3803,19 @@ function runEdit(opts) {
 		ctx.writeLayer(handlesLayer, features);
 	}
 	/**
+	* Repaint the preview and, in lockstep, the handles. `renderPreview` re-fits
+	* `box` (for Text, the footprint depends on options — size/rotation/
+	* alignment/text), so the transform-box outline and its corner/rotate handles
+	* must repaint to match; otherwise they stay where the old options placed them
+	* and the pick target (`box`) drifts out from under the visible handles
+	* (#scale-handle desync). Used by the non-geometry option/style/amplifier
+	* setters, which change what the preview renders without moving a point.
+	*/
+	function renderPreviewAndHandles() {
+		renderPreview();
+		renderHandlesLayer();
+	}
+	/**
 	* Builds the committed snapshot against explicit `options` rather than the
 	* live `workingOptions` — used to render a gesture's "previous" snapshot
 	* against pre-freeze options when a rotate has already merged its
@@ -3472,7 +3960,7 @@ function runEdit(opts) {
 			replaceWorkingOptions(previousOptions);
 			throw err;
 		}
-		renderPreview();
+		renderPreviewAndHandles();
 		nonGeometryDirty = true;
 		dirty = true;
 		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, sizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, "programmatic", "Change options");
@@ -3498,7 +3986,7 @@ function runEdit(opts) {
 			currentStyle = previousStyle;
 			throw err;
 		}
-		renderPreview();
+		renderPreviewAndHandles();
 		nonGeometryDirty = true;
 		dirty = true;
 		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, sizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, "programmatic", "Change style");
@@ -3544,7 +4032,7 @@ function runEdit(opts) {
 			workingTextAmplifiers = previousTextAmplifiers;
 			throw err;
 		}
-		renderPreview();
+		renderPreviewAndHandles();
 		nonGeometryDirty = true;
 		dirty = true;
 		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, sizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, "programmatic", "Change text");
@@ -3571,7 +4059,7 @@ function runEdit(opts) {
 		workingAmplifierPlacements = Object.keys(next).length > 0 ? next : void 0;
 		if (JSON.stringify(workingAmplifierPlacements) === JSON.stringify(previousAmplifierPlacements)) return;
 		const currentRendered = rebuildRendered();
-		renderPreview();
+		renderPreviewAndHandles();
 		nonGeometryDirty = true;
 		dirty = true;
 		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, sizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, source, historyLabel);
@@ -3917,11 +4405,40 @@ function runEdit(opts) {
 		recomputeDirty();
 		emitTransient("move", snapshot.points, activeDrag.controlPointIndex);
 	}
+	/**
+	* Fold a box gesture's delta (the box `to` relative to `from`, given the
+	* gesture `kind`) into a Text graphic's `rotation`/size options, on top of
+	* `base`. A `scale` grows the active size anchor; a `rotate` adds to the
+	* rotation. Returns `base` unchanged when the kind produces no patch. The
+	* delta (uniform scale ratio, angle difference) is pivot-independent, so
+	* folding it keeps the anchor point fixed while the glyph turns/grows.
+	*/
+	function foldTextTransform(from, to, kind, base) {
+		const { scale, rotation } = boxScaleRotation(kind, to, from);
+		const patch = applyBoxTransformOptions(measure.kind, base ?? {}, {
+			scale,
+			rotationRadians: rotation
+		});
+		return patch ? {
+			...base ?? {},
+			...patch
+		} : base;
+	}
 	function paintBoxDragSnapshot(pixel, info, constrainRotation = false) {
 		if (!activeBoxDrag) return;
 		const resolvedPixel = translatedBoxPixel(pixel, info, activeBoxDrag);
 		const snapshot = activeBoxDrag.fsm.move(resolvedPixel, { constrainRotation });
 		activeBoxDrag.lastSnapshot = snapshot;
+		if (isTextGraphic && (activeBoxDrag.fsm.kind === "rotate" || activeBoxDrag.fsm.kind === "scale")) {
+			workingPoints.splice(0, workingPoints.length, ...activeBoxDrag.preDragPoints);
+			workingOptions = foldTextTransform(activeBoxDrag.preDragBox, snapshot.box, activeBoxDrag.fsm.kind, activeBoxDrag.preDragOptions);
+			nonGeometryDirty = true;
+			renderPreview();
+			renderHandlesLayer();
+			recomputeDirty();
+			emitTransient("move", activeBoxDrag.preDragPoints, null);
+			return;
+		}
 		workingPoints.splice(0, workingPoints.length, ...snapshot.points);
 		workingAmplifierPlacements = transformAmplifierPlacements(activeBoxDrag.preDragAmplifierPlacements, activeBoxDrag.preDragBox, snapshot.box, driver);
 		renderPreview();
@@ -4012,9 +4529,15 @@ function runEdit(opts) {
 			const finalSnapshot = fsm.move(finalPixel, { constrainRotation: info?.shiftKey });
 			replaceWorkingPoints(preDragPoints);
 			workingAmplifierPlacements = preDragAmplifierPlacements;
-			if (fsm.kind === "rotate") boxAngle += finalSnapshot.box.angle - preDragBox.angle;
-			emitTransient("end", finalSnapshot.points, null);
-			commitGesture(finalSnapshot.points, preDragOptions, transformAmplifierPlacements(preDragAmplifierPlacements, preDragBox, finalSnapshot.box, driver), preDragBox.angle);
+			const textOptionFold = isTextGraphic && (fsm.kind === "rotate" || fsm.kind === "scale");
+			if (fsm.kind === "rotate" && !isTextGraphic) boxAngle += finalSnapshot.box.angle - preDragBox.angle;
+			if (textOptionFold) {
+				workingOptions = foldTextTransform(preDragBox, finalSnapshot.box, fsm.kind, preDragOptions);
+				nonGeometryDirty = true;
+			}
+			const committedPoints = textOptionFold ? preDragPoints : finalSnapshot.points;
+			emitTransient("end", committedPoints, null);
+			commitGesture(committedPoints, preDragOptions, transformAmplifierPlacements(preDragAmplifierPlacements, preDragBox, finalSnapshot.box, driver), preDragBox.angle);
 			return;
 		}
 	};
@@ -4185,7 +4708,13 @@ function renderPointSymbolForAdapter(adapter, capability, symbol) {
 			svg: render.svg,
 			width: render.width,
 			height: render.height,
-			anchor: [render.anchor.x, render.anchor.y]
+			anchor: [render.anchor.x, render.anchor.y],
+			coreRect: {
+				x: render.octagonAnchor.x - render.octagonSize / 2,
+				y: render.octagonAnchor.y - render.octagonSize / 2,
+				width: render.octagonSize,
+				height: render.octagonSize
+			}
 		},
 		feature: pointSymbolFeature(symbol, render, adapter.getResolution())
 	};
@@ -4223,18 +4752,6 @@ function boundProperty(key, value) {
 //#region src/tactical-draw/transform-controller.ts
 /** No point symbol may scale below this factor of its own size — mirrors the box-drag floor. */
 const MIN_POINT_SYMBOL_SIZE = .1;
-/**
-* The uniform scale factor and rotation delta a box implies relative to a
-* pre-drag box, given the gesture kind. Body translate reports neither (1, 0);
-* measures ignore this and take their geometry straight from the transformed
-* anchor points — only point symbols consume it.
-*/
-function boxScaleRotation(kind, box, preDragBox) {
-	return {
-		scale: kind === "scale" ? Math.max(box.halfWidth / preDragBox.halfWidth, box.halfHeight / preDragBox.halfHeight) : 1,
-		rotation: kind === "rotate" ? box.angle - preDragBox.angle : 0
-	};
-}
 /** Apply a box's scale/rotation deltas to each member's pre-drag point-symbol state. */
 function scalePointSymbolStates(pre, scale, rotation) {
 	return pre.map((state) => state ? {
@@ -4444,6 +4961,40 @@ function runGroupTransform(opts) {
 		}
 		return pixels;
 	}
+	/** The rotated-text footprint corners for a Text member's rendered feature, or `null`. */
+	function textFootprintCorners(features) {
+		const box = fitTextFootprintFromFeatures(features, driver.toPixel, {
+			resolution: adapter.getResolution(),
+			bearing: adapter.getBearing()
+		});
+		return box ? boxCorners(box) : null;
+	}
+	/**
+	* Fold a box gesture's delta (`box` vs the pre-drag box) into each measure
+	* member that persists orientation/size as options (e.g. Text), off the
+	* per-member `baseOverrides` so live ticks recompute rather than compound.
+	* Only members whose kind returns a patch (Text) are touched — members that
+	* carry an orientation *freeze* (Battle Position's echelon anchor) return no
+	* patch and keep their live override untouched. Point-symbol members take the
+	* delta through their own working state, not here.
+	*/
+	function applyMeasureTransformForBox(box, fromBox, kind, baseOverrides) {
+		const { scale, rotation } = boxScaleRotation(kind, box, fromBox);
+		if (scale === 1 && rotation === 0) return;
+		members.forEach((member, i) => {
+			if (isPointSymbolMember(member)) return;
+			const base = baseOverrides[i] ?? null;
+			const effective = mergeOptions(member.graphic.options, base);
+			const patch = applyBoxTransformOptions(member.graphic.kind, effective, {
+				scale,
+				rotationRadians: rotation
+			});
+			if (patch) member.optionsOverride = {
+				...base ?? {},
+				...patch
+			};
+		});
+	}
 	/** The live box angle: the in-flight drag's rigidly-transformed angle, or the committed `boxAngle`. */
 	function currentAngle() {
 		return activeBoxDrag ? activeBoxDrag.lastSnapshot.box.angle : boxAngle;
@@ -4483,8 +5034,9 @@ function runGroupTransform(opts) {
 					const footprint = pointSymbolFootprint(symbol, plan.render, adapter);
 					if (footprint) boxPixels = footprint.corners;
 				} else {
-					features = renderMeasureForAdapter(adapter, workingGraphicFor(i), renderOpts).features;
-					boxPixels = pixelsFromFeatures(features);
+					const working = workingGraphicFor(i);
+					features = renderMeasureForAdapter(adapter, working, renderOpts).features;
+					boxPixels = (working.kind === "text" ? textFootprintCorners(features) : null) ?? pixelsFromFeatures(features);
 				}
 			} catch {
 				features = [];
@@ -4883,6 +5435,7 @@ function runGroupTransform(opts) {
 		activeBoxDrag.lastSnapshot = snapshot;
 		applyConcatenatedPoints(snapshot.points);
 		applyPointSymbolStateByMember(pointSymbolStateForBox(snapshot.box));
+		applyMeasureTransformForBox(snapshot.box, activeBoxDrag.preDragBox, activeBoxDrag.fsm.kind, activeBoxDrag.preDragOptionsOverrideByMember);
 		applyAmplifierPlacementsByMember(activeBoxDrag.preDragAmplifierPlacementsByMember.map((placements) => transformAmplifierPlacements(placements, activeBoxDrag.preDragBox, snapshot.box, driver)));
 		renderAllPreviews();
 		renderHandlesLayer();
@@ -4922,6 +5475,7 @@ function runGroupTransform(opts) {
 		applyAmplifierPlacementsByMember(preDragAmplifierPlacementsByMember);
 		if (members.some(isPointSymbolMember)) shell.suppressNextClickAway();
 		if (fsm.kind === "rotate") boxAngle += finalSnapshot.box.angle - preDragBox.angle;
+		applyMeasureTransformForBox(finalSnapshot.box, preDragBox, fsm.kind, preDragOptionsOverrideByMember);
 		commitGesture(finalSnapshot.points, preDragOptionsOverrideByMember, preDragAmplifierPlacementsByMember.map((placements) => transformAmplifierPlacements(placements, preDragBox, finalSnapshot.box, driver)), preDragBox.angle, nextPointSymbolStateByMember);
 	};
 	const core = runEditInteraction({
@@ -5913,7 +6467,11 @@ var TacticalDraw = class {
 	* 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.
+	* legitimate "owned" click target. Within each layer, candidates follow
+	* the shared visible-intent ranking (direct marks, then filled interiors,
+	* then inferred outline-only reach, distance within direct marks, then
+	* visual topmost order) — this explicit-affordance layer order is the
+	* tier above all of it.
 	*
 	* `preview` and `graphics` each get a label text-extent fallback after the
 	* geometry pass misses on that layer: for every `Point` feature carrying a
@@ -5924,7 +6482,7 @@ var TacticalDraw = class {
 	* 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)` —
+	* `tolerance` defaults to `pickHitTolerance(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.
@@ -5940,7 +6498,7 @@ var TacticalDraw = class {
 	*/
 	ownsInteractionAt(pixel, options) {
 		this.assertAlive();
-		const tolerance = options?.tolerance ?? mapEventHitTolerance(options?.originalEvent);
+		const tolerance = options?.tolerance ?? pickHitTolerance(options?.originalEvent);
 		const toPixel = (lonLat) => this.adapter.getPixelFromCoordinate(lonLat);
 		const layers = [
 			{
@@ -5959,20 +6517,48 @@ var TacticalDraw = class {
 				labelFallback: true
 			}
 		];
+		const size = this.adapter.getViewportSize();
+		const context = {
+			pixel,
+			pointerType: pickPointerType(options?.originalEvent),
+			tolerance,
+			toPixel,
+			viewport: {
+				minX: 0,
+				minY: 0,
+				maxX: size.width,
+				maxY: size.height
+			},
+			bearing: this.adapter.getBearing()
+		};
 		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);
+			const geometryCandidate = evaluatePickCandidates(features.map((feature, index) => ({
+				feature,
+				visualOrder: renderOrderToVisualOrder(index, features.length)
+			})), context);
+			if (geometryCandidate) return this.toInteractionHit(layer, geometryCandidate.feature);
+			if (labelFallback) {
+				const labelCandidates = [];
+				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) labelCandidates.push({
+						feature,
+						labelExtent: box
+					});
+				}
+				const labelCandidate = evaluatePickCandidates(labelCandidates.map((candidate, index) => ({
+					...candidate,
+					visualOrder: renderOrderToVisualOrder(index, labelCandidates.length)
+				})), context);
+				if (labelCandidate) return this.toInteractionHit(layer, labelCandidate.feature);
 			}
 		}
 		return null;
@@ -6390,4 +6976,4 @@ function nearestWorldCopyPosition(position, refLng) {
 	return [nearestWorldCopyLng(position[0], refLng), ...position.slice(1)];
 }
 //#endregion
-export { BaseMapAdapter, DEFAULT_LABEL_SIZE_PIXELS, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, HATCH_PATTERNS, PointSymbolCapabilityRequiredError, PointerCallbackHub, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, TacticalDrawDestroyedError, bindAbortable, clonePointSymbol, coerceHandleStyle, combineWithHostSignal, effectivePointSymbolPixelSize, fillPatternImageDimension, fillPatternImageId, getSizeAnchor, hitTestFeature, hitTestIconFeature, ignoreAbort, isPointSymbol, isTacticalDrawAbortError, makeFillPatternImage, nearestWorldCopyLng, nearestWorldCopyPosition, pickHitTolerance, pointSymbolFootprint, resizePointSymbolSize, resolveGroundTextSizePixels, tryControlMeasureIdFromFeature };
+export { BaseMapAdapter, DEFAULT_LABEL_SIZE_PIXELS, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, HATCH_PATTERNS, PointSymbolCapabilityRequiredError, PointerCallbackHub, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, TacticalDrawDestroyedError, bindAbortable, clonePointSymbol, coerceHandleStyle, combineWithHostSignal, effectivePointSymbolPixelSize, evaluatePickCandidates, fillPatternImageDimension, fillPatternImageId, getSizeAnchor, hitTestFeature, hitTestIconFeature, ignoreAbort, isPointSymbol, isTacticalDrawAbortError, makeFillPatternImage, mergeNativeAndCachedPickFeatures, nearestWorldCopyLng, nearestWorldCopyPosition, pickHitTolerance, pickPointerType, pointSymbolFootprint, renderOrderToVisualOrder, resizePointSymbolSize, resolveGroundTextSizePixels, resolvePickPresentation, resolveTextSizePixels, tryControlMeasureIdFromFeature };