@orbat-mapper/tactical-draw 0.2.0-alpha.24 → 0.2.0-alpha.25

package/dist/index.mjs

@@ -1427,6 +1427,71 @@ function createSettleEmitter(listenerErrorsMessage) {
 	};
 }
 /**
+* The deferred reject/close/abort change-emit protocol (issue #49 contract)
+* shared by `EditSession.onChange`, `TransformSession.onChange`, and
+* `GraphicEditSession.onChange`. Owns the listener `Set` (like
+* `createCommitEmitter.register`) and, per emission:
+*
+*  - builds one event by spreading the controller-supplied `payload` plus the
+*    injected `reject()` / `close()` / `abort()` recorders, and delivers that
+*    same instance to every listener in registration order;
+*  - collects listener exceptions (single → rethrow as-is, multiple →
+*    `AggregateError` with `listenerErrorsMessage`);
+*  - applies decisions after all listeners run, priority `abort` > `close` >
+*    `reject`, with `reject` further gated on `!isSettled()` and
+*    `stillApplicable()`;
+*  - runs `onAccepted` (when the change survived) *before* rethrowing listener
+*    errors — unifying every controller on edit's history-before-throw ordering
+*    — and returns whether the change was accepted.
+*
+* Registration-time `isSettled()` guards stay in the controllers' `onChange`
+* wrappers, mirroring `createCommitEmitter`.
+*/
+function createChangeEmitter(options) {
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		register(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		emit(payload, emission) {
+			if (options.isSettled()) return false;
+			let rejectRequested = false;
+			let closeRequested = false;
+			let abortRequested = false;
+			const event = {
+				...payload,
+				reject() {
+					rejectRequested = true;
+				},
+				close() {
+					closeRequested = true;
+				},
+				abort() {
+					abortRequested = true;
+				}
+			};
+			const errors = [];
+			for (const listener of [...listeners]) try {
+				listener(event);
+			} catch (err) {
+				errors.push(err);
+			}
+			const applicable = emission.stillApplicable?.() ?? true;
+			if (abortRequested) options.abort();
+			else if (closeRequested) options.close();
+			else if (rejectRequested && !options.isSettled() && applicable) emission.rollback();
+			const accepted = !options.isSettled() && !rejectRequested && applicable;
+			if (accepted) emission.onAccepted?.();
+			if (errors.length === 1) throw errors[0];
+			if (errors.length > 1) throw new AggregateError(errors, options.listenerErrorsMessage);
+			return accepted;
+		}
+	};
+}
+/**
 * Subscribe/emit machinery shared by `TransformSession.onCommit`,
 * `EditSession.onCommit`, and `DrawSession.onCommit`: a listener set with
 * synchronous, exception-collecting emission (single rethrow, `AggregateError`
@@ -1734,33 +1799,107 @@ function outlinePreview(points) {
 	}
 	return features;
 }
+/** Whether `b` lands within {@link CLICK_SLOP_PX} of `a` — a click, not a drag. */
+function withinClickSlop(a, b) {
+	return Math.hypot(a[0] - b[0], a[1] - b[1]) <= 3;
+}
+function runEditInteraction(spec) {
+	const { adapter, signal, layers, graphicsLayer, previewLayer, handlesLayer, closeOnClickAway } = spec;
+	let ctx;
+	let driver;
+	let previewPick;
+	let handlesPick;
+	let graphicsPick;
+	/**
+	* Consume exactly one trailing click without closing — set through
+	* `shell.suppressNextClickAway()` on delete / label-drag / post-drag paths.
+	*/
+	let suppressClickAway = false;
+	/** A zero-movement body drag released this pointer cycle — set through `shell.noteBodyClick()`. */
+	let bodyClickPending = false;
+	const shell = {
+		suppressNextClickAway() {
+			suppressClickAway = true;
+		},
+		noteBodyClick() {
+			bodyClickPending = true;
+		}
+	};
+	const onPreviewPick = (event) => {
+		previewPick = event;
+	};
+	const onHandlesPick = (event) => {
+		handlesPick = event;
+	};
+	const onGraphicsPick = (event) => {
+		graphicsPick = event;
+	};
+	const onClick = () => {
+		const localPreview = previewPick;
+		const localHandles = handlesPick;
+		const localGraphics = graphicsPick;
+		const wasBodyClick = bodyClickPending;
+		previewPick = void 0;
+		handlesPick = void 0;
+		graphicsPick = void 0;
+		bodyClickPending = false;
+		if (ctx.settled) return;
+		if (!closeOnClickAway) return;
+		if (suppressClickAway) {
+			suppressClickAway = false;
+			return;
+		}
+		if (localHandles) return;
+		if (localGraphics && !spec.ownsGraphic(localGraphics.id)) {
+			spec.close();
+			spec.onForeignPick?.(localGraphics);
+			return;
+		}
+		if (localPreview) return;
+		if (wasBodyClick) return;
+		spec.close();
+	};
+	return runInteraction({
+		adapter,
+		signal,
+		layers,
+		onViewChange: spec.onViewChange,
+		onSettled: (settlement) => {
+			try {
+				spec.historySettle();
+			} finally {
+				spec.facadeOnSettled?.();
+				spec.emitSettle(settlement);
+			}
+		},
+		attach(interaction) {
+			ctx = interaction;
+			driver = adapter.createEditPointerDriver();
+			const unsubDown = driver.onPointerDown(spec.onDown);
+			const unsubMove = driver.onPointerMove(spec.onMove);
+			const unsubUp = driver.onPointerUp(spec.onUp);
+			const unsubPreview = adapter.onPick(previewLayer, onPreviewPick);
+			const unsubHandles = adapter.onPick(handlesLayer, onHandlesPick);
+			const unsubGraphics = adapter.onPick(graphicsLayer, onGraphicsPick);
+			adapter.on("click", onClick);
+			interaction.onTeardown(() => {
+				adapter.off("click", onClick);
+				unsubPreview();
+				unsubHandles();
+				unsubGraphics();
+				unsubDown();
+				unsubMove();
+				unsubUp();
+				spec.extraTeardown?.();
+				driver.dispose();
+			}, spec.onAbort);
+			spec.attach(interaction, driver, shell);
+		}
+	});
+}
 //#endregion
 //#region src/tactical-draw/handles.ts
 /**
-* Axis-aligned bounding-box center of the control points — the midpoint of
-* `[minX, maxX] × [minY, maxY]`. Used as the fallback rotation pivot for the
-* `COMMIT_ROTATE_FOR_TEST` seam when no transform box exists yet (e.g. before
-* the first paint), matching mainstream drawing tools' "turn about the visual
-* middle" convention. Returns `null` for an empty list.
-*
-* Exported because the rotation pivot is *not* a handle — the edit controller
-* consults it directly. See ADR-0016/ADR-0017.
-*/
-function computeBoundingBoxCenter(controlPoints) {
-	if (controlPoints.length === 0) return null;
-	let minX = Infinity;
-	let minY = Infinity;
-	let maxX = -Infinity;
-	let maxY = -Infinity;
-	for (const p of controlPoints) {
-		if (p[0] < minX) minX = p[0];
-		if (p[0] > maxX) maxX = p[0];
-		if (p[1] < minY) minY = p[1];
-		if (p[1] > maxY) maxY = p[1];
-	}
-	return [(minX + maxX) / 2, (minY + maxY) / 2];
-}
-/**
 * Midpoint of the segment between two positions, in lonLat. The single source
 * for "where a midpoint handle sits": `buildHandleSet` places the handle here
 * and the handle-drag FSM (ADR-0017) inserts the new vertex here, so a grabbed
@@ -2032,8 +2171,7 @@ function pixelDistance(a, b) {
 * a lon/lat rotation when the pivot (or a point) cannot be projected. Extra
 * coordinate dimensions (z, m) are carried through untouched.
 *
-* Exported because the edit controller's `COMMIT_ROTATE_FOR_TEST` seam commits a
-* rotate by angle without driving the pointer FSM, and so re-uses this math.
+* Module-internal: the box-center rotate transition below is the only caller.
 */
 function rotatePointsAround(points, pivot, pivotPixel, angle, projection) {
 	const cos = Math.cos(angle);
@@ -2191,49 +2329,6 @@ function beginBoxDrag(args) {
 	};
 }
 //#endregion
-//#region src/tactical-draw/edit-session.ts
-/**
-* Internal test seam — call to simulate a completed gesture against an active
-* `EditSession`. Public drag plumbing lands in later slices; the contract
-* tested here is the listener-side emission contract from issue #49.
-*
-* @internal
-*/
-const COMMIT_GESTURE_FOR_TEST = Symbol("EditSession.commitGestureForTest");
-/**
-* Internal test seam — simulate a completed translate gesture by passing a
-* `[dx, dy]` delta. Every control point shifts by the delta; one
-* `EditChangeEvent` is emitted, matching the issue #50 emission contract.
-*
-* @internal
-*/
-const COMMIT_TRANSLATE_FOR_TEST = Symbol("EditSession.commitTranslateForTest");
-/**
-* Internal test seam — simulate a completed rotate gesture by passing an angle
-* in radians. Every control point rotates around the transform box's center
-* (falling back to the control-points' bounding-box center when no box has
-* been fitted yet); one `EditChangeEvent` is emitted, and `boxAngle` absorbs
-* the same delta a live rotate box-drag would (ADR-0017).
-*
-* @internal
-*/
-const COMMIT_ROTATE_FOR_TEST = Symbol("EditSession.commitRotateForTest");
-/**
-* Internal test seam — mark a drag as in-flight. Used to verify that
-* `setModes()` calls are queued until the drag ends. Public pointer plumbing
-* lives in later slices.
-*
-* @internal
-*/
-const BEGIN_DRAG_FOR_TEST = Symbol("EditSession.beginDragForTest");
-/**
-* Internal test seam — clear the in-flight drag flag without committing. Any
-* queued `setModes()` call is applied.
-*
-* @internal
-*/
-const END_DRAG_FOR_TEST = Symbol("EditSession.endDragForTest");
-//#endregion
 //#region src/tactical-draw/session-history.ts
 /** @internal Controller-owned history stack. */
 function createSessionHistory(options) {
@@ -2385,9 +2480,8 @@ function boxToHandles(box, fromPixel) {
 /**
 * The group's outline style: the resolved `boxOutline` plus `[4, 4]` dash so
 * the group reads as dashed per the reference design — unless the host
-* explicitly set their own `strokeDash`, which wins. Shared by
-* `transform-controller.ts` and `graphic-transform-controller.ts` so their
-* group boxes can't drift apart (member outlines stay solid).
+* explicitly set their own `strokeDash`, which wins. Used by
+* `transform-controller.ts` for every group box (member outlines stay solid).
 */
 function groupOutlineStyle(base) {
 	if (base?.strokeDash !== void 0) return base;
@@ -2400,10 +2494,9 @@ function groupOutlineStyle(base) {
 * Build the per-member outline features for a group transform — one closed
 * `LineString` per `[memberId, box]` pair, id'd
 * `${handleIdPrefix}:member-outline:{memberId}` and styled with the plain
-* (solid) `boxOutline`. Shared by `transform-controller.ts` and
-* `graphic-transform-controller.ts` so member outlines can't drift between
-* the measures-only and mixed-graphic group transforms — only the group box
-* gets the dashed default (`groupOutlineStyle`).
+* (solid) `boxOutline`. Used by `transform-controller.ts` for every member of a
+* (possibly mixed) group transform — only the group box gets the dashed default
+* (`groupOutlineStyle`).
 */
 function memberOutlineFeatures(members, fromPixel, handleIdPrefix, style) {
 	const features = [];
@@ -2429,51 +2522,12 @@ function boxOutlineFeature(box, fromPixel, featureId, style) {
 		properties: style ? { style: { ...style } } : {}
 	};
 }
-//#endregion
-//#region src/tactical-draw/transform-amplifier-placements.ts
-/**
-* Carry user-adjusted label anchors (and rotation overrides) through a
-* transform-box gesture. Anchors are transformed in pixel space alongside the
-* control points so the result remains visually rigid across map
-* projections.
-*
-* Rotation: `TransformBox.angle` is radians in screen pixel space, positive =
-* clockwise on screen (see `transform-box.ts`). Adapters render a label's
-* on-screen clockwise angle as `π − rotation`, and a rotation delta is
-* invariant under the map→screen bearing, so an on-screen delta
-* `Δ = to.angle − from.angle` means `π − rotation' = (π − rotation) + Δ`,
-* i.e. `rotation' = rotation − Δ`.
-*/
-function transformAmplifierPlacements(placements, from, to, projection) {
-	if (!placements) return void 0;
-	const scaleX = to.halfWidth / from.halfWidth;
-	const scaleY = to.halfHeight / from.halfHeight;
-	const angleDelta = to.angle - from.angle;
-	const transformed = {};
-	for (const [field, raw] of Object.entries(placements)) {
-		const resolved = resolveAmplifierPlacement(raw);
-		const rotation = resolved.rotation !== void 0 ? resolved.rotation - angleDelta : void 0;
-		if (!resolved.position) {
-			if (rotation !== void 0) transformed[field] = { rotation };
-			continue;
-		}
-		const pixel = projection.toPixel(resolved.position);
-		const position = pixel ? (() => {
-			const [localX, localY] = rotate(pixel[0] - from.center[0], pixel[1] - from.center[1], -from.angle);
-			const [outX, outY] = rotate(localX * scaleX, localY * scaleY, to.angle);
-			return projection.fromPixel([to.center[0] + outX, to.center[1] + outY]);
-		})() : [...resolved.position];
-		transformed[field] = rotation !== void 0 ? {
-			position,
-			rotation
-		} : position;
-	}
-	return transformed;
-}
 /** Estimated glyph width as a fraction of text height — a monospace-ish approximation, not a real text-metrics measurement. */
 const CHAR_WIDTH_FACTOR = .6;
 /** Estimated line height as a multiple of text height. */
 const LINE_HEIGHT_FACTOR = 1.2;
+/** Screen-space clearance between a label's anchor and its visible drag grip. */
+const LABEL_HANDLE_OFFSET_PX = 14;
 /**
 * Normalize `angle` (radians) into `(-π, π]`, matching the range
 * `Math.atan2`/screen-angle math elsewhere in `tactical-draw` produces.
@@ -2559,36 +2613,45 @@ function fitLabelBoxFromFeature(feature, anchorPixel, view) {
 		bearing: view.bearing
 	});
 }
-//#endregion
-//#region src/tactical-draw/edit-controller.ts
-/**
-* Coordinate-space tolerance for `EditSession.dirty`. The working copy is
-* considered equivalent to the edit-start input when every control-point
-* component agrees within this threshold. PRD #40 calls out tolerance-based
-* dirty tracking; the constant lives in one place so future slices can lift
-* it to an option without touching call sites.
-*/
-const DIRTY_EPSILON$1 = 1e-9;
-const HANDLE_HIT_TOLERANCE_PX$1 = 12;
-/** Screen-space clearance between a label's anchor and its visible drag grip. */
-const LABEL_HANDLE_OFFSET_PX = 14;
 /**
-* A body drag (drag-anywhere-inside-the-box translate) whose release pixel
-* lands within this many pixels of the down pixel is treated as a plain
-* click, not a gesture: it is not committed (geometry restored, no
-* `EditChangeEvent`, `dirty` untouched). The click-away's *empty-map* close is
-* suppressed so the click doesn't end the edit, but a pick on another
-* graphics-layer measure inside the box still closes-then-selects it.
-* Corner/rotate drags commit even at zero movement (matches the pre-ADR-0017
-* translate/rotate seams).
+* 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 − Δ`.
 */
-const CLICK_SLOP_PX$3 = 3;
-const ALLOWED_EDIT_MODES = new Set([
-	"reshape",
-	"transform",
-	"labeldrag",
-	"delete"
-]);
+function transformAmplifierPlacements(placements, from, to, projection) {
+	if (!placements) return void 0;
+	const scaleX = to.halfWidth / from.halfWidth;
+	const scaleY = to.halfHeight / from.halfHeight;
+	const angleDelta = to.angle - from.angle;
+	const transformed = {};
+	for (const [field, raw] of Object.entries(placements)) {
+		const resolved = resolveAmplifierPlacement(raw);
+		const rotation = resolved.rotation !== void 0 ? resolved.rotation - angleDelta : void 0;
+		if (!resolved.position) {
+			if (rotation !== void 0) transformed[field] = { rotation };
+			continue;
+		}
+		const pixel = projection.toPixel(resolved.position);
+		const position = pixel ? (() => {
+			const [localX, localY] = rotate(pixel[0] - from.center[0], pixel[1] - from.center[1], -from.angle);
+			const [outX, outY] = rotate(localX * scaleX, localY * scaleY, to.angle);
+			return projection.fromPixel([to.center[0] + outX, to.center[1] + outY]);
+		})() : [...resolved.position];
+		transformed[field] = rotation !== void 0 ? {
+			position,
+			rotation
+		} : position;
+	}
+	return transformed;
+}
 /**
 * Field-wise merge of one `amplifierPlacements` entry: fields present in
 * `incoming` (valid position / finite rotation) replace the same field on
@@ -2609,76 +2672,346 @@ function mergeAmplifierPlacementField(existing, incoming) {
 	} : { rotation: merged.rotation };
 }
 /**
-* Drive an interactive edit against a `MapAdapter`. Implements the edit
-* lifecycle (issue #48) plus the ADR-0017 transform box:
-*
-*  - lift-original (remove from graphics layer) + working copy
-*  - preview + reshape-handle rendering, and the oriented transform box
-*    (corner scale handles, rotate grip, drag-anywhere-inside body translate)
-*  - dirty tracking via [[DIRTY_EPSILON]] tolerance
-*  - default click-away close policy
-*  - close / abort / signal / preempt / destroy paths
+* The stateful label-interaction object owned by the edit controller's
+* `labeldrag` mode (ADR-0034). Holds the selection, the fitted selection box,
+* and the two live drag states; returns intents for the controller to apply to
+* its session-owned `workingAmplifierPlacements`.
 */
-function runEdit(opts) {
-	const { adapter, measure, graphicsLayer, previewLayer, guideLayer, handlesLayer, graphicsStyle, signal, closeOnClickAway = true, modes: initialModes, interactionStyle, onSession, handleIdPrefix, guide: guideOpt, restoreOriginalToGraphics, wasOnGraphicsLayer, onSettled, onClickAwayGraphicsPick, snap } = opts;
-	const renderOpts = graphicsStyle ? { graphicsStyle } : void 0;
-	let sizeAnchor = opts.sizeAnchor ?? "ground";
-	const metadata = getControlMeasureMetadata(measure.kind);
-	const rule = metadata.rule;
-	const midpointHandlesEnabled = rule?.canonicalPointCount === void 0;
-	const trailingFixedSlots = rule?.trailingFixedSlots ?? 0;
-	const closedRing = rule?.closedRing ?? false;
-	const guideEnabled = (guideOpt ?? true) && !shouldSuppressGuide(metadata);
-	const isAreaKind = metadata.geometry === "area";
-	const requestedModes = normaliseModes(initialModes);
-	const editStartPoints = measure.controlPoints.map((p) => [...p]);
-	const workingPoints = editStartPoints.map((p) => [...p]);
-	let workingOptions = { ...measure.options ?? {} };
-	let workingTextAmplifiers = measure.textAmplifiers && Object.keys(measure.textAmplifiers).length > 0 ? { ...measure.textAmplifiers } : void 0;
-	let workingAmplifierPlacements = measure.amplifierPlacements && Object.keys(measure.amplifierPlacements).length > 0 ? structuredClone(measure.amplifierPlacements) : void 0;
-	function snapshotAmplifierPlacements() {
-		return workingAmplifierPlacements ? structuredClone(workingAmplifierPlacements) : void 0;
-	}
-	let modes = requestedModes;
-	let dirty = false;
-	let nonGeometryDirty = false;
-	let dragInFlight = false;
-	/**
-	* Set when an Alt+click delete removes the vertex under the pointer, so the
-	* `click` that follows the same pointerup does not read the now-absent handle
-	* as a click-away and close the edit. Consumed by the next `handleClick`.
-	*/
-	let suppressClickAway = false;
+function createLabelPlacement(deps) {
+	const { projection, view, features, snapshotAmplifierPlacements, handleIdPrefix, interactionStyle } = deps;
 	/**
-	* Set when a zero-movement body drag (a plain click inside the transform
-	* box) released this pointer cycle. Unlike {@link suppressClickAway} it only
-	* suppresses the *empty-map* close in `handleClick` — a stashed pick on
-	* another graphics-layer measure still closes-then-re-dispatches, so
-	* measures sitting inside a large box stay selectable. Consumed by the next
-	* `handleClick`.
+	* The currently selected label's `labelPlacementKey`, or `null` when no label
+	* is selected. A click on a label toggles this (select / deselect / switch —
+	* see `onUp`'s move-drag click path); it is cleared whenever the feature
+	* disappears from the preview or the mode set drops `labeldrag`.
 	*/
-	let bodyClickPending = false;
+	let selectedLabelKey = null;
 	/**
-	* Mutable style snapshot. Initialised from the edit-start input; replaced
-	* when the façade routes an external style change to us via
-	* `notifyExternalMeasure`. `EditSession.measure` stays the immutable
-	* edit-start input per PRD #40 user-story 30.
+	* The transform box fitted around the selected label, re-fitted on every
+	* `handleFeatures` call from the preview features — 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 currentStyle = measure.style;
+	let labelBox = null;
 	/**
-	* `setModes()` called during an in-flight drag is queued here and drained
-	* when the gesture ends — handles must not disappear under the pointer
-	* (PRD #40 user-story-21).
+	* 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) — 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 pendingModes = null;
-	const changeListeners = /* @__PURE__ */ new Set();
-	const commitEmitter = createCommitEmitter("EditSession.onCommit listener errors");
-	const settleEmitter = createSettleEmitter("EditSession.onSettled listener errors");
+	let activeAmplifierDrag = null;
 	/**
-	* The transform box's rotation, in radians, session-scoped (ADR-0017 decision
-	* #2): starts at `0` (axis-aligned) and accumulates every committed rotate
-	* gesture's delta, so the box stays glued to the shape across gestures. Never
-	* persisted on the measure; a fresh edit always starts back at `0`.
+	* 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
+	* the preview features, which mirrors `activeBoxDrag.lastSnapshot` and
+	* keeps the box painted even if a transient preview render fails.
+	*/
+	let activeLabelRotateDrag = null;
+	function pickLabel(pixel, tolerance) {
+		for (const feature of features()) {
+			const key = feature.properties?.labelPlacementKey;
+			if (typeof key !== "string" || feature.geometry?.type !== "Point") continue;
+			const projected = projection.toPixel(feature.geometry.coordinates);
+			if (!projected) continue;
+			for (const handle of [false, true]) {
+				const targetY = projected[1] - (handle ? LABEL_HANDLE_OFFSET_PX : 0);
+				if (Math.hypot(projected[0] - pixel[0], targetY - pixel[1]) <= tolerance) return {
+					key,
+					anchorPixel: projected
+				};
+			}
+			const box = fitLabelBoxFromFeature(feature, projected, view());
+			if (box && pointInBox(box, pixel)) return {
+				key,
+				anchorPixel: projected
+			};
+		}
+		return null;
+	}
+	/**
+	* 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 projection.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 (`handleFeatures`) and the box-pick paths (`onDown`).
+	*/
+	function selectedLabelAnchor() {
+		if (!selectedLabelKey) return null;
+		const feature = features().find((f) => f.properties?.labelPlacementKey === selectedLabelKey && f.geometry?.type === "Point");
+		if (!feature || feature.geometry?.type !== "Point") return null;
+		const pixel = projection.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]);
+	}
+	function handleFeatures() {
+		const style = interactionStyle?.labelHandle;
+		const features_ = [];
+		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, view());
+		}
+		for (const feature of features()) {
+			const key = feature.properties?.labelPlacementKey;
+			if (typeof key !== "string" || feature.geometry?.type !== "Point") continue;
+			if (key === selectedLabelKey) continue;
+			const pixel = projection.toPixel(feature.geometry.coordinates);
+			if (!pixel) continue;
+			features_.push({
+				type: "Feature",
+				id: `${handleIdPrefix}:label-handle:${index}`,
+				geometry: {
+					type: "Point",
+					coordinates: projection.fromPixel([pixel[0], pixel[1] - LABEL_HANDLE_OFFSET_PX])
+				},
+				properties: {
+					handle: "label",
+					index,
+					labelPlacementKey: key,
+					...style ? { style: { ...style } } : {}
+				}
+			});
+			index += 1;
+		}
+		if (labelBox) {
+			features_.push(boxOutlineFeature(labelBox, projection.fromPixel, `${handleIdPrefix}:label-box-outline`, interactionStyle?.boxOutline));
+			const rotateHandle = {
+				kind: "rotate",
+				index: 0,
+				position: projection.fromPixel(rotateGripPixel(labelBox, 14))
+			};
+			features_.push(...toFeatures([rotateHandle], `${handleIdPrefix}:label`, interactionStyle));
+		}
+		return features_;
+	}
+	function onDown(pixel, tolerance) {
+		if (labelBox) {
+			const anchor = selectedLabelAnchor();
+			if (anchor) {
+				const gripPixel = rotateGripPixel(labelBox, 14);
+				if (Math.hypot(gripPixel[0] - pixel[0], gripPixel[1] - pixel[1]) <= tolerance) {
+					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
+					};
+					return true;
+				}
+				if (pointInBox(labelBox, pixel)) {
+					activeAmplifierDrag = {
+						field: selectedLabelKey,
+						grabOffset: [anchor.pixel[0] - pixel[0], anchor.pixel[1] - pixel[1]],
+						previous: snapshotAmplifierPlacements(),
+						downPixel: pixel
+					};
+					return true;
+				}
+			}
+		}
+		const labelHit = pickLabel(pixel, tolerance);
+		if (labelHit) {
+			activeAmplifierDrag = {
+				field: labelHit.key,
+				grabOffset: [labelHit.anchorPixel[0] - pixel[0], labelHit.anchorPixel[1] - pixel[1]],
+				previous: snapshotAmplifierPlacements(),
+				downPixel: pixel
+			};
+			return true;
+		}
+		return false;
+	}
+	function onMove(pixel) {
+		if (activeLabelRotateDrag) {
+			const drag = activeLabelRotateDrag;
+			const delta = pointerAngleAround(pixel, drag.anchorPixel) - drag.startPointerAngle;
+			const rotation = drag.startRotation - delta;
+			const { resolution, bearing } = view();
+			const liveBox = fitLabelTransformBox({
+				text: drag.text,
+				rotation,
+				textAnchor: drag.textAnchor,
+				textSizePixels: drag.textSizePixels,
+				textSizeMeters: drag.textSizeMeters,
+				anchor: drag.anchorPixel,
+				resolution,
+				bearing
+			});
+			if (liveBox) drag.lastBox = liveBox;
+			return {
+				field: drag.key,
+				value: { rotation }
+			};
+		}
+		if (activeAmplifierDrag) {
+			const position = labelAnchorFromPointer(pixel, activeAmplifierDrag.grabOffset);
+			if (!position) return null;
+			return {
+				field: activeAmplifierDrag.field,
+				value: position
+			};
+		}
+		return null;
+	}
+	function onUp(pixel) {
+		if (activeLabelRotateDrag) {
+			const drag = activeLabelRotateDrag;
+			activeLabelRotateDrag = null;
+			if (!withinClickSlop(pixel, drag.downPixel)) {
+				const delta = pointerAngleAround(pixel, drag.anchorPixel) - drag.startPointerAngle;
+				const rotation = drag.startRotation - delta;
+				return {
+					kind: "rotate",
+					key: drag.key,
+					rotation,
+					previous: drag.previous
+				};
+			}
+			return {
+				kind: "click",
+				previous: drag.previous
+			};
+		}
+		if (activeAmplifierDrag) {
+			const { field, grabOffset, previous, downPixel } = activeAmplifierDrag;
+			activeAmplifierDrag = null;
+			const position = labelAnchorFromPointer(pixel, grabOffset);
+			if (position && !withinClickSlop(pixel, downPixel)) return {
+				kind: "move",
+				field,
+				position,
+				previous
+			};
+			selectedLabelKey = selectedLabelKey === field ? null : field;
+			return {
+				kind: "click",
+				previous
+			};
+		}
+		return null;
+	}
+	return {
+		handleFeatures,
+		onDown,
+		onMove,
+		onUp,
+		get dragging() {
+			return activeAmplifierDrag !== null || activeLabelRotateDrag !== null;
+		},
+		endDrag() {
+			activeAmplifierDrag = null;
+			activeLabelRotateDrag = null;
+		},
+		syncModes(modes) {
+			if (!modes.includes("labeldrag")) selectedLabelKey = null;
+		}
+	};
+}
+//#endregion
+//#region src/tactical-draw/edit-controller.ts
+const ALLOWED_EDIT_MODES = new Set([
+	"reshape",
+	"transform",
+	"labeldrag",
+	"delete"
+]);
+/**
+* Drive an interactive edit against a `MapAdapter`. Implements the edit
+* lifecycle (issue #48) plus the ADR-0017 transform box:
+*
+*  - lift-original (remove from graphics layer) + working copy
+*  - preview + reshape-handle rendering, and the oriented transform box
+*    (corner scale handles, rotate grip, drag-anywhere-inside body translate)
+*  - dirty tracking via [[DIRTY_EPSILON]] tolerance
+*  - default click-away close policy
+*  - close / abort / signal / preempt / destroy paths
+*/
+function runEdit(opts) {
+	const { adapter, measure, graphicsLayer, previewLayer, guideLayer, handlesLayer, graphicsStyle, signal, closeOnClickAway = true, modes: initialModes, interactionStyle, onSession, handleIdPrefix, guide: guideOpt, restoreOriginalToGraphics, wasOnGraphicsLayer, onSettled, onClickAwayGraphicsPick, snap } = opts;
+	const renderOpts = graphicsStyle ? { graphicsStyle } : void 0;
+	let sizeAnchor = opts.sizeAnchor ?? "ground";
+	const metadata = getControlMeasureMetadata(measure.kind);
+	const rule = metadata.rule;
+	const midpointHandlesEnabled = rule?.canonicalPointCount === void 0;
+	const trailingFixedSlots = rule?.trailingFixedSlots ?? 0;
+	const closedRing = rule?.closedRing ?? false;
+	const guideEnabled = (guideOpt ?? true) && !shouldSuppressGuide(metadata);
+	const isAreaKind = metadata.geometry === "area";
+	const requestedModes = normaliseModes(initialModes);
+	const editStartPoints = measure.controlPoints.map((p) => [...p]);
+	const workingPoints = editStartPoints.map((p) => [...p]);
+	let workingOptions = { ...measure.options ?? {} };
+	let workingTextAmplifiers = measure.textAmplifiers && Object.keys(measure.textAmplifiers).length > 0 ? { ...measure.textAmplifiers } : void 0;
+	let workingAmplifierPlacements = measure.amplifierPlacements && Object.keys(measure.amplifierPlacements).length > 0 ? structuredClone(measure.amplifierPlacements) : void 0;
+	function snapshotAmplifierPlacements() {
+		return workingAmplifierPlacements ? structuredClone(workingAmplifierPlacements) : void 0;
+	}
+	let modes = requestedModes;
+	let dirty = false;
+	let nonGeometryDirty = false;
+	let dragInFlight = false;
+	/**
+	* Mutable style snapshot. Initialised from the edit-start input; replaced
+	* when the façade routes an external style change to us via
+	* `notifyExternalMeasure`. `EditSession.measure` stays the immutable
+	* edit-start input per PRD #40 user-story 30.
+	*/
+	let currentStyle = measure.style;
+	/**
+	* `setModes()` called during an in-flight drag is queued here and drained
+	* when the gesture ends — handles must not disappear under the pointer
+	* (PRD #40 user-story-21).
+	*/
+	let pendingModes = null;
+	const changeEmitter = createChangeEmitter({
+		listenerErrorsMessage: "EditSession.onChange listener errors",
+		isSettled: () => ctx.settled,
+		abort: () => ctx.fail(new TacticalDrawAbortError("session")),
+		close: () => {
+			ctx.commit(rebuildRendered);
+		}
+	});
+	const commitEmitter = createCommitEmitter("EditSession.onCommit listener errors");
+	const settleEmitter = createSettleEmitter("EditSession.onSettled listener errors");
+	/**
+	* The transform box's rotation, in radians, session-scoped (ADR-0017 decision
+	* #2): starts at `0` (axis-aligned) and accumulates every committed rotate
+	* gesture's delta, so the box stays glued to the shape across gestures. Never
+	* persisted on the measure; a fresh edit always starts back at `0`.
 	*/
 	let boxAngle = 0;
 	function captureHistory() {
@@ -2713,28 +3046,24 @@ 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;
+	let shell;
 	const dragProjection = {
 		toPixel: (lonLat) => driver.toPixel(lonLat),
 		fromPixel: (pixel) => driver.fromPixel(pixel)
 	};
+	const labels = createLabelPlacement({
+		projection: dragProjection,
+		view: () => ({
+			resolution: adapter.getResolution(),
+			bearing: adapter.getBearing()
+		}),
+		features: () => lastPreviewFeatures,
+		snapshotAmplifierPlacements,
+		handleIdPrefix,
+		interactionStyle
+	});
 	/**
 	* Fit the transform box around `features`' rendered geometry: every
 	* coordinate is projected to pixels via the pointer driver and
@@ -2807,51 +3136,7 @@ function runEdit(opts) {
 			trailingFixedSlots,
 			closedRing
 		}), handleIdPrefix, interactionStyle);
-		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({
-					type: "Feature",
-					id: `${handleIdPrefix}:label-handle:${index}`,
-					geometry: {
-						type: "Point",
-						coordinates: driver.fromPixel([pixel[0], pixel[1] - LABEL_HANDLE_OFFSET_PX])
-					},
-					properties: {
-						handle: "label",
-						index,
-						labelPlacementKey: key,
-						...style ? { style: { ...style } } : {}
-					}
-				});
-				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("labeldrag")) features.push(...labels.handleFeatures());
 		if (modes.includes("transform")) {
 			const liveBox = activeBoxDrag ? activeBoxDrag.lastSnapshot.box : box;
 			if (liveBox) {
@@ -2888,7 +3173,7 @@ function runEdit(opts) {
 		return rebuildRenderedWith(workingOptions);
 	}
 	function recomputeDirty() {
-		dirty = nonGeometryDirty || !pointsEqualWithinTolerance(workingPoints, editStartPoints, DIRTY_EPSILON$1);
+		dirty = nonGeometryDirty || !pointsEqualWithinTolerance(workingPoints, editStartPoints, 1e-9);
 	}
 	function replaceWorkingPoints(next) {
 		workingPoints.splice(0, workingPoints.length, ...roundControlPoints(next));
@@ -2914,65 +3199,37 @@ function runEdit(opts) {
 		};
 	}
 	/**
-	* Emit a completed gesture to every registered listener. The pre-gesture
-	* snapshot is provided as `previousRendered`; `commitGesture` has already
-	* mutated `workingPoints` and re-rendered preview / handle layers before
-	* this is called.
-	*
-	* Per issue #49:
-	*  - All listeners see the same event instance, in registration order.
-	*  - `event.reject()` / `event.close()` / `event.abort()` are recorded and
-	*    applied after every listener has run (and after exceptions are
-	*    collected). `close`/`abort` override `reject` when both are called.
-	*  - Listener exceptions are collected and rethrown after all listeners
-	*    run (single → as-is, multiple → AggregateError).
-	*  - Reject restores the working state to the pre-gesture snapshot and
-	*    recomputes `dirty`. Close/abort settle the session as normal.
+	* Emit a completed gesture through the shared change-emit protocol
+	* (`createChangeEmitter`, issue #49). The pre-gesture snapshot is provided as
+	* `previousRendered`; `commitGesture` has already mutated `workingPoints` and
+	* re-rendered preview / handle layers before this is called. Only this
+	* controller's variance stays here: the event payload, the reject rollback
+	* (restore the pre-gesture working state), and the recordable-source guard on
+	* the history record. The deferred reject/close/abort machinery, exception
+	* collection, and record-before-rethrow ordering live in the emitter.
 	*/
 	function emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, previousSizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, source = "gesture", historyLabel = "Edit", previousBoxAngle = boxAngle) {
-		if (ctx.settled) return;
-		let rejectRequested = false;
-		let closeRequested = false;
-		let abortRequested = false;
-		const event = {
+		changeEmitter.emit({
 			source,
 			graphic: currentRendered,
 			previous: previousRendered,
-			session,
-			reject() {
-				rejectRequested = true;
-			},
-			close() {
-				closeRequested = true;
+			session
+		}, {
+			rollback() {
+				replaceWorkingPoints(previousPoints);
+				replaceWorkingOptions(previousOptions);
+				currentStyle = previousStyle;
+				sizeAnchor = previousSizeAnchor;
+				workingTextAmplifiers = previousTextAmplifiers;
+				workingAmplifierPlacements = previousAmplifierPlacements;
+				boxAngle = previousBoxAngle;
+				nonGeometryDirty = previousNonGeometryDirty;
+				renderPreview();
+				renderHandlesLayer();
+				recomputeDirty();
 			},
-			abort() {
-				abortRequested = true;
-			}
-		};
-		const errors = [];
-		for (const listener of [...changeListeners]) try {
-			listener(event);
-		} catch (err) {
-			errors.push(err);
-		}
-		if (abortRequested) ctx.fail(new TacticalDrawAbortError("session"));
-		else if (closeRequested) ctx.commit(rebuildRendered);
-		else if (rejectRequested && !ctx.settled) {
-			replaceWorkingPoints(previousPoints);
-			replaceWorkingOptions(previousOptions);
-			currentStyle = previousStyle;
-			sizeAnchor = previousSizeAnchor;
-			workingTextAmplifiers = previousTextAmplifiers;
-			workingAmplifierPlacements = previousAmplifierPlacements;
-			boxAngle = previousBoxAngle;
-			nonGeometryDirty = previousNonGeometryDirty;
-			renderPreview();
-			renderHandlesLayer();
-			recomputeDirty();
-		}
-		if (!ctx.settled && !rejectRequested && (source === "gesture" || source === "programmatic")) history.record(captureHistory(), historyLabel);
-		if (errors.length === 1) throw errors[0];
-		if (errors.length > 1) throw new AggregateError(errors, "EditSession.onChange listener errors");
+			onAccepted: source === "gesture" || source === "programmatic" ? () => history.record(captureHistory(), historyLabel) : void 0
+		});
 	}
 	/**
 	* Apply a completed gesture: snapshot pre-state, write the new control
@@ -3161,35 +3418,6 @@ function runEdit(opts) {
 		dirty = true;
 		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, previousSizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, "programmatic", "Change size anchor");
 	}
-	/** Apply a translate gesture by shifting every working point by `delta`. */
-	function commitTranslate(delta) {
-		if (ctx.settled) return;
-		const [dx, dy] = delta;
-		commitGesture(workingPoints.map((p) => {
-			const out = [p[0] + dx, p[1] + dy];
-			for (let i = 2; i < p.length; i++) out.push(p[i]);
-			return out;
-		}));
-	}
-	/**
-	* Test seam for a rotate gesture: rotate every working point by `angle`
-	* (radians) around the transform box's center — falling back to the
-	* control-points' bounding-box center when no box has been fitted yet (e.g.
-	* before the first paint). The rotation runs in screen space (see
-	* `rotatePointsAround`) so it stays rigid and matches the pointer 1:1 at any
-	* latitude, and `boxAngle` absorbs the same delta a live rotate box-drag
-	* would (ADR-0017), so the box stays glued to the shape across seam calls.
-	*/
-	function commitRotate(angle) {
-		if (ctx.settled) return;
-		const preFreezeOptions = { ...workingOptions ?? {} };
-		freezeOrientationForRotate();
-		const pivotPixel = box ? box.center : driver.toPixel(computeBoundingBoxCenter(workingPoints) ?? [0, 0]);
-		const pivot = box ? driver.fromPixel(box.center) : computeBoundingBoxCenter(workingPoints);
-		if (!pivot) return;
-		boxAngle += angle;
-		commitGesture(rotatePointsAround(workingPoints, pivot, pivotPixel, angle, dragProjection), preFreezeOptions, void 0, boxAngle - angle);
-	}
 	function modesEqual(a, b) {
 		if (a.length !== b.length) return false;
 		for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
@@ -3198,7 +3426,7 @@ function runEdit(opts) {
 	function applyModes(next) {
 		if (modesEqual(modes, next)) return;
 		modes = next;
-		if (!modes.includes("labeldrag")) selectedLabelKey = null;
+		labels.syncModes(modes);
 		renderHandlesLayer();
 	}
 	function drainPendingModes() {
@@ -3322,10 +3550,7 @@ function runEdit(opts) {
 		},
 		onChange(listener) {
 			if (ctx.settled) return () => {};
-			changeListeners.add(listener);
-			return () => {
-				changeListeners.delete(listener);
-			};
+			return changeEmitter.register(listener);
 		},
 		onCommit(listener) {
 			if (ctx.settled) return () => {};
@@ -3333,24 +3558,6 @@ function runEdit(opts) {
 		},
 		onSettled(handler) {
 			return settleEmitter.register(handler);
-		},
-		[COMMIT_GESTURE_FOR_TEST]: (nextPoints) => {
-			commitGesture(nextPoints);
-		},
-		[COMMIT_TRANSLATE_FOR_TEST]: (delta) => {
-			commitTranslate(delta);
-		},
-		[COMMIT_ROTATE_FOR_TEST]: (angle) => {
-			commitRotate(angle);
-		},
-		[BEGIN_DRAG_FOR_TEST]: () => {
-			if (ctx.settled) return;
-			dragInFlight = true;
-		},
-		[END_DRAG_FOR_TEST]: () => {
-			if (ctx.settled) return;
-			dragInFlight = false;
-			drainPendingModes();
 		}
 	};
 	let activeDrag = null;
@@ -3387,83 +3594,6 @@ function runEdit(opts) {
 		return [pixel[0] + result.pixel[0] - anchorPixel[0], pixel[1] + result.pixel[1] - anchorPixel[1]];
 	}
 	/**
-	* 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) {
-			const key = feature.properties?.labelPlacementKey;
-			if (typeof key !== "string" || feature.geometry?.type !== "Point") continue;
-			const projected = driver.toPixel(feature.geometry.coordinates);
-			if (!projected) continue;
-			for (const handle of [false, true]) {
-				const targetY = projected[1] - (handle ? LABEL_HANDLE_OFFSET_PX : 0);
-				if (Math.hypot(projected[0] - pixel[0], targetY - pixel[1]) <= tolerance) return {
-					key,
-					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: `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 selectedLabelAnchor() {
-		if (!selectedLabelKey) return null;
-		const feature = lastPreviewFeatures.find((f) => f.properties?.labelPlacementKey === selectedLabelKey && f.geometry?.type === "Point");
-		if (!feature || feature.geometry?.type !== "Point") return null;
-		const pixel = driver.toPixel(feature.geometry.coordinates);
-		if (!pixel) return null;
-		return {
-			feature,
-			pixel
-		};
-	}
-	/** The screen-space angle (radians, y-down) from `anchor` to `pixel`, as used by the label rotate drag's pointer-angle math. */
-	function pointerAngleAround(pixel, anchor) {
-		return Math.atan2(pixel[1] - anchor[1], pixel[0] - anchor[0]);
-	}
-	/**
-	* A live label *rotate* drag (ADR-0017 box machinery applied to a label's
-	* rotate grip). `anchorPixel`/`text`/`textAnchor`/`textSizePixels`/
-	* `textSizeMeters` are captured at pointer-down so `lastBox` can be
-	* re-fitted purely from drag math on every move tick — independent of
-	* `lastPreviewFeatures`, which mirrors `activeBoxDrag.lastSnapshot` and
-	* keeps the box painted even if a transient preview render fails
-	* (`renderPreview`'s try/catch).
-	*/
-	let activeLabelRotateDrag = null;
-	/**
 	* A live transform-box gesture (corner scale, box rotate, or body
 	* translate — ADR-0017). `lastSnapshot` starts as the pre-drag points/box
 	* and is replaced on every `move()` tick; `renderHandlesLayer` paints
@@ -3510,51 +3640,8 @@ 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,
-				grabOffset: [labelHit.anchorPixel[0] - pixel[0], labelHit.anchorPixel[1] - pixel[1]],
-				previous: snapshotAmplifierPlacements(),
-				downPixel: pixel
-			};
+		const tol = info?.hitTolerance ?? 12;
+		if (modes.includes("labeldrag") && labels.onDown(pixel, tol)) {
 			dragInFlight = true;
 			driver.setDragPanEnabled(false);
 			return;
@@ -3568,13 +3655,13 @@ function runEdit(opts) {
 			if (modes.includes("delete")) {
 				if (hit.kind === "vertex" && canDeleteVertex(hit.index)) {
 					deleteVertex(hit.index);
-					suppressClickAway = true;
+					shell.suppressNextClickAway();
 				}
 				return;
 			}
 			if (hit.kind === "vertex" && info?.altKey && canDeleteVertex(hit.index)) {
 				deleteVertex(hit.index);
-				suppressClickAway = true;
+				shell.suppressNextClickAway();
 				return;
 			}
 			const preDragPoints = workingPoints.map((p) => [...p]);
@@ -3655,39 +3742,17 @@ function runEdit(opts) {
 	}
 	const onDriverMove = (pixel, info) => {
 		if (ctx.settled) return;
-		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 ?? {},
-				...merged !== void 0 ? { [field]: merged } : {}
-			};
-			renderPreview();
-			renderHandlesLayer();
+		if (labels.dragging) {
+			const patch = labels.onMove(pixel);
+			if (patch) {
+				const merged = mergeAmplifierPlacementField(workingAmplifierPlacements?.[patch.field], patch.value);
+				workingAmplifierPlacements = {
+					...workingAmplifierPlacements ?? {},
+					...merged !== void 0 ? { [patch.field]: merged } : {}
+				};
+				renderPreview();
+				renderHandlesLayer();
+			}
 		} else if (activeDrag) paintDragSnapshot(pixel, info);
 		else if (activeBoxDrag) paintBoxDragSnapshot(pixel, info, info?.shiftKey);
 	};
@@ -3698,35 +3763,17 @@ function runEdit(opts) {
 		drainPendingModes();
 	}
 	const onDriverUp = (pixel, info) => {
-		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$3) {
-				const delta = pointerAngleAround(pixel, drag.anchorPixel) - drag.startPointerAngle;
-				const rotation = drag.startRotation - delta;
-				setAmplifierPlacements({ [drag.key]: { rotation } }, "gesture", "Rotate label");
-			} else {
-				renderPreview();
-				renderHandlesLayer();
-			}
-			suppressClickAway = true;
-			return;
-		}
-		if (activeAmplifierDrag) {
-			const { field, grabOffset, previous, downPixel } = activeAmplifierDrag;
-			activeAmplifierDrag = null;
-			const position = labelAnchorFromPointer(pixel, grabOffset);
-			workingAmplifierPlacements = previous;
+		const labelOutcome = labels.onUp(pixel);
+		if (labelOutcome) {
+			workingAmplifierPlacements = labelOutcome.previous;
 			endDragBookkeeping();
-			if (position && Math.hypot(pixel[0] - downPixel[0], pixel[1] - downPixel[1]) > CLICK_SLOP_PX$3) setAmplifierPlacements({ [field]: position }, "gesture", "Move label");
+			if (labelOutcome.kind === "rotate") setAmplifierPlacements({ [labelOutcome.key]: { rotation: labelOutcome.rotation } }, "gesture", "Rotate label");
+			else if (labelOutcome.kind === "move") setAmplifierPlacements({ [labelOutcome.field]: labelOutcome.position }, "gesture", "Move label");
 			else {
-				selectedLabelKey = selectedLabelKey === field ? null : field;
 				renderPreview();
 				renderHandlesLayer();
 			}
-			suppressClickAway = true;
+			shell.suppressNextClickAway();
 			return;
 		}
 		if (activeDrag) {
@@ -3754,15 +3801,14 @@ function runEdit(opts) {
 			const { fsm, preDragPoints, preDragAmplifierPlacements, preDragBox, downPixel, preDragOptions } = activeBoxDrag;
 			activeBoxDrag = null;
 			driver.setDragPanEnabled(true);
-			const distance = Math.hypot(pixel[0] - downPixel[0], pixel[1] - downPixel[1]);
-			if (fsm.kind === "body" && distance <= CLICK_SLOP_PX$3) {
+			if (fsm.kind === "body" && withinClickSlop(pixel, downPixel)) {
 				replaceWorkingPoints(preDragPoints);
 				workingAmplifierPlacements = preDragAmplifierPlacements;
 				renderPreview();
 				renderHandlesLayer();
 				recomputeDirty();
 				endDragBookkeeping();
-				bodyClickPending = true;
+				shell.noteBodyClick();
 				return;
 			}
 			const finalPixel = translatedBoxPixel(pixel, info, {
@@ -3778,44 +3824,7 @@ function runEdit(opts) {
 			return;
 		}
 	};
-	let pickPreview;
-	let pickHandles;
-	let pickGraphics;
-	const handlePickPreview = (e) => {
-		pickPreview = e;
-	};
-	const handlePickHandles = (e) => {
-		pickHandles = e;
-	};
-	const handlePickGraphics = (e) => {
-		pickGraphics = e;
-	};
-	const handleClick = () => {
-		const localPreview = pickPreview;
-		const localHandles = pickHandles;
-		const localGraphics = pickGraphics;
-		const wasBodyClick = bodyClickPending;
-		pickPreview = void 0;
-		pickHandles = void 0;
-		pickGraphics = void 0;
-		bodyClickPending = false;
-		if (ctx.settled) return;
-		if (!closeOnClickAway) return;
-		if (suppressClickAway) {
-			suppressClickAway = false;
-			return;
-		}
-		if (localHandles) return;
-		if (localGraphics && localGraphics.id !== measure.id) {
-			ctx.commit(rebuildRendered);
-			if (onClickAwayGraphicsPick) onClickAwayGraphicsPick(localGraphics);
-			return;
-		}
-		if (localPreview) return;
-		if (wasBodyClick) return;
-		ctx.commit(rebuildRendered);
-	};
-	const core = runInteraction({
+	const core = runEditInteraction({
 		adapter,
 		signal,
 		layers: [
@@ -3823,44 +3832,37 @@ function runEdit(opts) {
 			guideLayer,
 			handlesLayer
 		],
+		graphicsLayer,
+		previewLayer,
+		handlesLayer,
+		closeOnClickAway,
 		onViewChange: rescaleOnViewChange,
-		onSettled: (settlement) => {
-			try {
-				history.settle();
-			} finally {
-				if (onSettled) onSettled();
-				settleFromInteraction(settlement, commitEmitter, settleEmitter);
+		onDown: onDriverDown,
+		onMove: onDriverMove,
+		onUp: onDriverUp,
+		ownsGraphic: (id) => id === measure.id,
+		close: () => {
+			ctx.commit(rebuildRendered);
+		},
+		onForeignPick: onClickAwayGraphicsPick,
+		historySettle: () => history.settle(),
+		facadeOnSettled: onSettled,
+		emitSettle: (settlement) => settleFromInteraction(settlement, commitEmitter, settleEmitter),
+		extraTeardown: () => {
+			if (activeDrag !== null || activeBoxDrag !== null || labels.dragging) {
+				driver.setDragPanEnabled(true);
+				activeDrag = null;
+				activeBoxDrag = null;
+				labels.endDrag();
+				dragInFlight = false;
 			}
 		},
-		attach(c) {
-			ctx = c;
-			driver = adapter.createEditPointerDriver();
+		onAbort: wasOnGraphicsLayer ? restoreOriginalToGraphics : void 0,
+		attach(interaction, createdDriver, createdShell) {
+			ctx = interaction;
+			driver = createdDriver;
+			shell = createdShell;
 			liftOriginalFromGraphics();
-			const unsubDown = driver.onPointerDown(onDriverDown);
-			const unsubMove = driver.onPointerMove(onDriverMove);
-			const unsubUp = driver.onPointerUp(onDriverUp);
-			const unsubPickPreview = adapter.onPick(previewLayer, handlePickPreview);
-			const unsubPickHandles = adapter.onPick(handlesLayer, handlePickHandles);
-			const unsubPickGraphics = adapter.onPick(graphicsLayer, handlePickGraphics);
-			adapter.on("click", handleClick);
-			c.onTeardown(() => {
-				adapter.off("click", handleClick);
-				unsubPickPreview();
-				unsubPickHandles();
-				unsubPickGraphics();
-				unsubDown();
-				unsubMove();
-				unsubUp();
-				if (activeDrag !== null || activeBoxDrag !== null || activeAmplifierDrag !== null || activeLabelRotateDrag !== null) {
-					driver.setDragPanEnabled(true);
-					activeDrag = null;
-					activeBoxDrag = null;
-					activeAmplifierDrag = null;
-					activeLabelRotateDrag = null;
-					dragInFlight = false;
-				}
-				driver.dispose();
-			}, wasOnGraphicsLayer ? restoreOriginalToGraphics : void 0);
 			renderPreview();
 			renderHandlesLayer();
 			recomputeDirty();
@@ -3922,125 +3924,282 @@ function pointsEqualWithinTolerance(a, b, epsilon) {
 	return true;
 }
 //#endregion
-//#region src/tactical-draw/transform-controller.ts
-/**
-* Coordinate-space tolerance for `TransformSession.dirty` — mirrors
-* `edit-controller.ts`'s `DIRTY_EPSILON` (kept as a sibling constant rather
-* than a shared import since the two controllers' dirty definitions may
-* diverge later: a group's dirty is "any member moved").
-*/
-const DIRTY_EPSILON = 1e-9;
-const HANDLE_HIT_TOLERANCE_PX = 12;
-/**
-* A body drag (drag-anywhere-inside-the-box translate) whose release pixel
-* lands within this many pixels of the down pixel is treated as a plain
-* click, not a gesture — same rationale as `edit-controller.ts`'s constant of
-* the same name.
-*/
-const CLICK_SLOP_PX$2 = 3;
+//#region src/tactical-draw/errors.ts
 /**
-* Drive an interactive group transform against a `MapAdapter` — the leaner,
-* multi-select sibling of `runEdit` (ADR-0017 "Multi-select" slice). No
-* reshape, no per-vertex handles, no guide layer, no per-measure
-* `setOptions`/`setStyle`: only the shared oriented box (corner scale, rotate
-* grip, drag-anywhere body translate), applied rigidly to every member's
-* control points at once.
-*
-*  - lift every member off the graphics layer + per-member working copies
-*  - render every member's preview to the shared preview layer each paint
-*  - group box = fit over the union of every member's rendered pixel
-*    coordinates at the session `boxAngle`; each member also gets its own
-*    thin outline (its own fit at the same angle)
-*  - dirty tracking, close/abort/signal/preempt/destroy, click-away — same
-*    contracts as `runEdit`, scoped to the group
-*  - membership is mutable via `session.setGraphics` (#187): members join/leave
-*    a live session without a session boundary
+* Error thrown when any `TacticalDraw` method is called after `destroy()`.
+* See PRD #40 / issue #45.
 */
-function runGroupTransform(opts) {
-	const { adapter, measures, graphicsLayer, previewLayer, handlesLayer, graphicsStyle, signal, closeOnClickAway = true, interactionStyle, onSession, handleIdPrefix, restoreOriginalToGraphics, isOnGraphicsLayer, onSettled, onClickAwayGraphicsPick } = opts;
-	const renderOpts = graphicsStyle ? { graphicsStyle } : void 0;
-	let sizeAnchor = opts.sizeAnchor ?? "ground";
-	/** Build a fresh working record for `measure`, snapshotting its edit-start points. */
-	function createMemberState(measure) {
-		const editStartPoints = measure.controlPoints.map((p) => [...p]);
-		return {
-			measure,
-			editStartPoints,
-			workingPoints: editStartPoints.map((p) => [...p]),
-			workingAmplifierPlacements: measure.amplifierPlacements ? structuredClone(measure.amplifierPlacements) : void 0,
-			optionsOverride: null,
-			box: null,
-			lastPreviewFeatures: []
-		};
-	}
-	/** The single mutable source of truth for the current member set. */
-	let members = measures.map(createMemberState);
-	/**
-	* `true` once any member has been lifted off the graphics layer (initial or a
-	* mid-session `setGraphics` add). Gates the abort-path restore so a session
-	* that never touched the graphics layer doesn't rewrite it on abort.
-	*/
-	let anyLiftedFromGraphics = false;
-	/** A member's own options merged with an override patch (a null override leaves them unchanged). */
-	function mergeOptions(base, override) {
-		if (!override) return base;
-		return {
-			...base ?? {},
-			...override
-		};
+var TacticalDrawDestroyedError = class TacticalDrawDestroyedError extends Error {
+	constructor(message = "TacticalDraw instance has been destroyed") {
+		super(message);
+		this.name = "TacticalDrawDestroyedError";
+		Object.setPrototypeOf(this, TacticalDrawDestroyedError.prototype);
 	}
-	/** Effective options for member `i`: its own options merged with its *live* override. */
-	function effectiveOptions(i) {
-		const member = members[i];
-		return mergeOptions(member.measure.options, member.optionsOverride);
+};
+var PointSymbolCapabilityRequiredError = class extends Error {
+	constructor() {
+		super("TacticalDraw: point-symbol capability is not configured");
+		this.name = "PointSymbolCapabilityRequiredError";
 	}
-	/** Build a member's committed snapshot with a given override, baking pixel size to ground unless "screen". */
-	function buildMemberSnapshot(member, override) {
-		const working = {
-			...member.measure,
-			options: mergeOptions(member.measure.options, override),
-			controlPoints: member.workingPoints.map((p) => [...p]),
-			...member.workingAmplifierPlacements ? { amplifierPlacements: member.workingAmplifierPlacements } : {}
+};
+//#endregion
+//#region src/tactical-draw/point-symbol-rendering.ts
+function effectivePointSymbolPixelSize(symbol, resolution) {
+	if (symbol.size.unit === "pixels") return symbol.size.value;
+	if (resolution === void 0 || resolution <= 0) return symbol.size.value;
+	const px = symbol.size.value / resolution;
+	const { minPixels, maxPixels } = symbol.size;
+	return Math.max(Number.isFinite(minPixels) && minPixels > 0 ? minPixels : 0, Math.min(Number.isFinite(maxPixels) && maxPixels > 0 ? maxPixels : Infinity, px));
+}
+function pointSymbolPixelScale(symbol, render, resolution) {
+	if (!Number.isFinite(render.octagonSize) || render.octagonSize <= 0) throw new TypeError("PointSymbolRender.octagonSize must be a positive finite number");
+	return effectivePointSymbolPixelSize(symbol, resolution) / render.octagonSize;
+}
+/** Complete rotated logical footprint for selection and transform chrome. */
+function pointSymbolFootprint(symbol, render, adapter) {
+	const anchor = adapter.getPixelFromCoordinate(symbol.position);
+	if (!anchor) return null;
+	const scale = pointSymbolPixelScale(symbol, render, adapter.getResolution());
+	const angle = symbol.rotation - adapter.getBearing();
+	const centerOffsetX = (render.width / 2 - render.anchor.x) * scale;
+	const centerOffsetY = (render.height / 2 - render.anchor.y) * scale;
+	const cos = Math.cos(angle);
+	const sin = Math.sin(angle);
+	const box = {
+		center: [anchor[0] + centerOffsetX * cos - centerOffsetY * sin, anchor[1] + centerOffsetX * sin + centerOffsetY * cos],
+		halfWidth: render.width * scale / 2,
+		halfHeight: render.height * scale / 2,
+		angle
+	};
+	return {
+		box,
+		corners: boxCorners(box)
+	};
+}
+function renderPointSymbolForAdapter(adapter, capability, symbol) {
+	const render = capability.render(symbol);
+	return {
+		render,
+		resource: {
+			id: render.resourceId,
+			svg: render.svg,
+			width: render.width,
+			height: render.height,
+			anchor: [render.anchor.x, render.anchor.y]
+		},
+		feature: pointSymbolFeature(symbol, render, adapter.getResolution())
+	};
+}
+function pointSymbolFeature(symbol, render, resolution) {
+	const groundSizeProperties = symbol.size.unit === "meters" ? {
+		iconSizeMeters: symbol.size.value,
+		iconOctagonSize: render.octagonSize,
+		...boundProperty("iconMinPixels", symbol.size.minPixels),
+		...boundProperty("iconMaxPixels", symbol.size.maxPixels)
+	} : void 0;
+	return {
+		type: "Feature",
+		id: `${symbol.id}:point-symbol`,
+		geometry: {
+			type: "Point",
+			coordinates: [...symbol.position]
+		},
+		properties: {
+			...symbol.properties ?? {},
+			graphicId: symbol.id,
+			graphicKind: "point-symbol",
+			iconId: render.resourceId,
+			iconScale: pointSymbolPixelScale(symbol, render, resolution),
+			iconRotation: symbol.rotation,
+			iconOpacity: symbol.style?.opacity ?? 1,
+			...groundSizeProperties
+		}
+	};
+}
+function boundProperty(key, value) {
+	return value !== void 0 && Number.isFinite(value) && value > 0 ? { [key]: value } : {};
+}
+//#endregion
+//#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 ? {
+		size: Math.max(MIN_POINT_SYMBOL_SIZE, state.size * scale),
+		rotation: normalizeRotation(state.rotation + rotation)
+	} : null);
+}
+/**
+* Drive an interactive group transform against a `MapAdapter` — the leaner,
+* multi-select sibling of `runEdit` (ADR-0017 "Multi-select" slice). No
+* reshape, no per-vertex handles, no guide layer, no per-measure
+* `setOptions`/`setStyle`: only the shared oriented box (corner scale, rotate
+* grip, drag-anywhere body translate), applied rigidly to every member at once.
+*
+* Typed on `Graphic` (ADR-0032): control measures and point symbols coexist in
+* one session. A measure's box gesture rewrites its control points (and bakes
+* pixel size per the group `sizeAnchor`); a point symbol's rewrites its
+* position, scales its size value, and rotates its rotation — its persisted
+* size unit is never converted.
+*
+*  - lift every member off the graphics layer + per-member working copies
+*  - render every member's preview to the shared preview layer each paint
+*  - group box = fit over the union of every member's rendered pixel footprint
+*    at the session `boxAngle`; each member also gets its own thin outline
+*  - dirty tracking, close/abort/signal/preempt/destroy, click-away — same
+*    contracts as `runEdit`, scoped to the group
+*  - membership is mutable via `session.setGraphics` (#187): members join/leave
+*    a live session without a session boundary
+*/
+function runGroupTransform(opts) {
+	const { adapter, capability, graphics, graphicsLayer, previewLayer, handlesLayer, graphicsStyle, signal, closeOnClickAway = true, interactionStyle, onSession, handleIdPrefix, restoreOriginalToGraphics, isOnGraphicsLayer, onSettled, onClickAwayGraphicsPick } = opts;
+	assertCapabilityFor(graphics);
+	const renderOpts = graphicsStyle ? { graphicsStyle } : void 0;
+	let sizeAnchor = opts.sizeAnchor ?? "ground";
+	/** Throw synchronously if any graphic in `list` is a point symbol and no capability was supplied. */
+	function assertCapabilityFor(list) {
+		if (!capability && list.some(isPointSymbol)) throw new PointSymbolCapabilityRequiredError();
+	}
+	function isPointSymbolMember(member) {
+		return isPointSymbol(member.graphic);
+	}
+	/** Build a fresh working record for `graphic`, snapshotting its edit-start state. */
+	function createMemberState(graphic) {
+		if (isPointSymbol(graphic)) {
+			const editStartPoints = [[...graphic.position]];
+			return {
+				graphic,
+				editStartPoints,
+				workingPoints: editStartPoints.map((p) => [...p]),
+				editStartSize: graphic.size.value,
+				editStartRotation: graphic.rotation,
+				workingSize: graphic.size.value,
+				workingRotation: graphic.rotation,
+				workingAmplifierPlacements: void 0,
+				optionsOverride: null,
+				box: null,
+				lastBoxPixels: []
+			};
+		}
+		const editStartPoints = graphic.controlPoints.map((p) => [...p]);
+		return {
+			graphic,
+			editStartPoints,
+			workingPoints: editStartPoints.map((p) => [...p]),
+			editStartSize: 0,
+			editStartRotation: 0,
+			workingSize: 0,
+			workingRotation: 0,
+			workingAmplifierPlacements: graphic.amplifierPlacements ? structuredClone(graphic.amplifierPlacements) : void 0,
+			optionsOverride: null,
+			box: null,
+			lastBoxPixels: []
 		};
-		const committed = sizeAnchor === "screen" ? working : bakePixelSizeToGround(working, adapter);
+	}
+	/** The single mutable source of truth for the current member set. */
+	let members = graphics.map(createMemberState);
+	/**
+	* `true` once any member has been lifted off the graphics layer (initial or a
+	* mid-session `setGraphics` add). Gates the abort-path restore so a session
+	* that never touched the graphics layer doesn't rewrite it on abort.
+	*/
+	let anyLiftedFromGraphics = false;
+	/** A member's own options merged with an override patch (a null override leaves them unchanged). */
+	function mergeOptions(base, override) {
+		if (!override) return base;
 		return {
-			graphic: cloneControlMeasure(committed),
-			render: renderMeasureForAdapter(adapter, committed, renderOpts)
+			...base ?? {},
+			...override
 		};
 	}
-	/** The working measure for member `i`: original measure, live effective options, live working points. */
-	function workingMeasureFor(i) {
+	/** Effective options for measure member `i`: its own options merged with its *live* override. */
+	function effectiveOptions(i) {
 		const member = members[i];
+		return mergeOptions(member.graphic.options, member.optionsOverride);
+	}
+	/** Build the working point symbol for a member from its live working state. */
+	function buildWorkingPointSymbol(member) {
+		const symbol = clonePointSymbol(member.graphic);
+		symbol.position = [...member.workingPoints[0]];
+		symbol.size = {
+			...symbol.size,
+			value: member.workingSize
+		};
+		symbol.rotation = member.workingRotation;
+		return symbol;
+	}
+	/** Build the working measure for member `i` with a given options override. */
+	function buildWorkingMeasureWith(member, override) {
+		const measure = member.graphic;
+		const options = mergeOptions(measure.options, override);
 		return {
-			...member.measure,
-			options: effectiveOptions(i),
+			...measure,
 			controlPoints: member.workingPoints.map((p) => [...p]),
+			...options !== void 0 ? { options } : {},
 			...member.workingAmplifierPlacements ? { amplifierPlacements: member.workingAmplifierPlacements } : {}
 		};
 	}
+	/** Build a member's committed snapshot with a given override; point symbols never bake. */
+	function buildMemberSnapshot(member, override) {
+		if (isPointSymbolMember(member)) {
+			const symbol = buildWorkingPointSymbol(member);
+			return {
+				graphic: clonePointSymbol(symbol),
+				render: capability.render(symbol)
+			};
+		}
+		const working = buildWorkingMeasureWith(member, override);
+		const committed = sizeAnchor === "screen" ? working : bakePixelSizeToGround(working, adapter);
+		return {
+			graphic: cloneControlMeasure(committed),
+			render: renderMeasureForAdapter(adapter, committed, renderOpts)
+		};
+	}
+	/** The working graphic for member `i` (measure or point symbol), for preview and `workingGraphics`. */
+	function workingGraphicFor(i) {
+		const member = members[i];
+		if (isPointSymbolMember(member)) return buildWorkingPointSymbol(member);
+		return buildWorkingMeasureWith(member, member.optionsOverride);
+	}
 	let dirty = false;
 	/**
 	* Set by non-geometry mutations (`setSizeAnchor`) so `dirty` reports them
-	* even when every control point still matches edit-start — mirrors
-	* `edit-controller.ts`'s flag of the same name.
+	* even when every control point still matches edit-start.
 	*/
 	let nonGeometryDirty = false;
 	let dragInFlight = false;
-	/** Same click-away suppression role as `edit-controller.ts`'s flag of the same name. */
-	let suppressClickAway = false;
-	/** Same body-click role as `edit-controller.ts`'s flag of the same name. */
-	let bodyClickPending = false;
-	const changeListeners = /* @__PURE__ */ new Set();
+	const changeEmitter = createChangeEmitter({
+		listenerErrorsMessage: "TransformSession.onChange listener errors",
+		isSettled: () => ctx.settled,
+		abort: () => ctx.fail(new TacticalDrawAbortError("session")),
+		close: () => {
+			commitClose();
+		}
+	});
 	const commitEmitter = createCommitEmitter("TransformSession.onCommit listener errors");
 	const settleEmitter = createSettleEmitter("TransformSession.onSettled listener errors");
 	/** Session-scoped box rotation (ADR-0017 decision #2), shared by the whole group. */
 	let boxAngle = 0;
 	function captureHistory() {
 		return {
-			ids: members.map((member) => member.measure.id),
+			ids: members.map((member) => member.graphic.id),
 			points: clonePointsByMember(),
 			amplifierPlacements: cloneAmplifierPlacementsByMember(),
 			optionsOverrides: cloneOptionsOverrideByMember(),
+			pointSymbolStates: clonePointSymbolStateByMember(),
 			sizeAnchor,
 			nonGeometryDirty,
 			boxAngle
@@ -4050,6 +4209,7 @@ function runGroupTransform(opts) {
 		restorePointsByMember(value.points);
 		applyAmplifierPlacementsByMember(value.amplifierPlacements.map((placements) => placements ? structuredClone(placements) : void 0));
 		applyOptionsOverrides(value.optionsOverrides);
+		applyPointSymbolStateByMember(value.pointSymbolStates);
 		sizeAnchor = value.sizeAnchor;
 		nonGeometryDirty = value.nonGeometryDirty;
 		boxAngle = value.boxAngle;
@@ -4058,6 +4218,7 @@ function runGroupTransform(opts) {
 	let groupBox = null;
 	let ctx;
 	let driver;
+	let shell;
 	const dragProjection = {
 		toPixel: (lonLat) => driver.toPixel(lonLat),
 		fromPixel: (pixel) => driver.fromPixel(pixel)
@@ -4068,12 +4229,15 @@ function runGroupTransform(opts) {
 	* Used for both initial and mid-session-added members.
 	*/
 	function liftMemberFromGraphics(member) {
-		if (!isOnGraphicsLayer(member.measure.id)) return;
-		const ids = renderMeasureForAdapter(adapter, member.measure, renderOpts).features.map((f) => f.id).filter((id) => typeof id === "string");
-		if (ids.length > 0) adapter.removeFeatures(graphicsLayer, ids);
+		if (!isOnGraphicsLayer(member.graphic.id)) return;
+		if (isPointSymbol(member.graphic)) adapter.removeFeatures(graphicsLayer, [`${member.graphic.id}:point-symbol`]);
+		else {
+			const ids = renderMeasureForAdapter(adapter, member.graphic, renderOpts).features.map((f) => f.id).filter((id) => typeof id === "string");
+			if (ids.length > 0) adapter.removeFeatures(graphicsLayer, ids);
+		}
 		anyLiftedFromGraphics = true;
 	}
-	function pixelsFor(features) {
+	function pixelsFromFeatures(features) {
 		const positions = [];
 		for (const f of features) if (f.geometry) collectFeaturePositions(f.geometry, positions);
 		const pixels = [];
@@ -4088,7 +4252,7 @@ function runGroupTransform(opts) {
 		return activeBoxDrag ? activeBoxDrag.lastSnapshot.box.angle : boxAngle;
 	}
 	/**
-	* Re-fit `groupBox` and every member's `box` from their `lastPreviewFeatures`.
+	* Re-fit `groupBox` and every member's `box` from their `lastBoxPixels`.
 	* While a box gesture is in flight, `groupBox` itself is not touched here —
 	* `renderHandlesLayer` paints the drag's own rigidly-transformed box instead
 	* (matching `edit-controller.ts`'s `refitBox`) — but the member outlines are
@@ -4100,9 +4264,8 @@ function runGroupTransform(opts) {
 		const padding = interactionStyle?.boxPadding ?? 0;
 		const allPixels = [];
 		for (const member of members) {
-			const pixels = pixelsFor(member.lastPreviewFeatures);
-			allPixels.push(...pixels);
-			member.box = fitTransformBox(pixels, angle, padding);
+			allPixels.push(...member.lastBoxPixels);
+			member.box = fitTransformBox(member.lastBoxPixels, angle, padding);
 		}
 		if (activeBoxDrag) return;
 		groupBox = fitTransformBox(allPixels, boxAngle, padding);
@@ -4110,25 +4273,38 @@ function runGroupTransform(opts) {
 	function renderAllPreviews() {
 		if (ctx.settled) return;
 		const allFeatures = [];
+		const resources = /* @__PURE__ */ new Map();
 		members.forEach((member, i) => {
-			const working = workingMeasureFor(i);
 			let features;
+			let boxPixels = [];
 			try {
-				features = renderMeasureForAdapter(adapter, working, renderOpts).features;
+				if (isPointSymbolMember(member)) {
+					const symbol = buildWorkingPointSymbol(member);
+					const plan = renderPointSymbolForAdapter(adapter, capability, symbol);
+					resources.set(plan.resource.id, plan.resource);
+					features = [plan.feature];
+					const footprint = pointSymbolFootprint(symbol, plan.render, adapter);
+					if (footprint) boxPixels = footprint.corners;
+				} else {
+					features = renderMeasureForAdapter(adapter, workingGraphicFor(i), renderOpts).features;
+					boxPixels = pixelsFromFeatures(features);
+				}
 			} catch {
 				features = [];
+				boxPixels = [];
 			}
-			member.lastPreviewFeatures = features;
+			member.lastBoxPixels = boxPixels;
 			allFeatures.push(...features);
 		});
+		adapter.reconcileLayerIconResources(previewLayer, [...resources.values()]);
 		ctx.writeLayer(previewLayer, allFeatures);
 		refitBoxes();
 	}
 	function rescaleOnViewChange() {
 		if (ctx.settled) return;
-		if (members.some((m) => measureRendersFromViewState({
-			kind: m.measure.kind,
-			options: m.measure.options
+		if (members.some((m) => isPointSymbolMember(m) || measureRendersFromViewState({
+			kind: m.graphic.kind,
+			options: m.graphic.options
 		}))) renderAllPreviews();
 		else refitBoxes();
 		renderHandlesLayer();
@@ -4141,7 +4317,7 @@ function runGroupTransform(opts) {
 			features.push(boxOutlineFeature(liveGroupBox, dragProjection.fromPixel, `${handleIdPrefix}:box-outline`, groupOutlineStyle(interactionStyle?.boxOutline)));
 			features.push(...toFeatures(boxToHandles(liveGroupBox, dragProjection.fromPixel), handleIdPrefix, interactionStyle));
 		}
-		features.push(...memberOutlineFeatures(members.flatMap((member) => member.box ? [[member.measure.id, member.box]] : []), dragProjection.fromPixel, handleIdPrefix, interactionStyle?.boxOutline));
+		features.push(...memberOutlineFeatures(members.flatMap((member) => member.box ? [[member.graphic.id, member.box]] : []), dragProjection.fromPixel, handleIdPrefix, interactionStyle?.boxOutline));
 		ctx.writeLayer(handlesLayer, features);
 	}
 	/**
@@ -4158,9 +4334,9 @@ function runGroupTransform(opts) {
 		return members.map((member) => buildMemberSnapshot(member, member.optionsOverride));
 	}
 	function recomputeDirty() {
-		dirty = nonGeometryDirty || members.some((m) => !pointsEqualWithinTolerance(m.workingPoints, m.editStartPoints, DIRTY_EPSILON));
+		dirty = nonGeometryDirty || members.some((m) => !pointsEqualWithinTolerance(m.workingPoints, m.editStartPoints, 1e-9) || isPointSymbolMember(m) && (m.workingSize !== m.editStartSize || m.workingRotation !== m.editStartRotation));
 	}
-	/** Split `points` (the concatenation of every member's control points) back per member. */
+	/** Split `points` (the concatenation of every member's anchor points) back per member. */
 	function applyConcatenatedPoints(points) {
 		const rounded = roundControlPoints(points);
 		let offset = 0;
@@ -4184,6 +4360,23 @@ function runGroupTransform(opts) {
 			member.workingPoints.splice(0, member.workingPoints.length, ...snapshot[i]);
 		});
 	}
+	/** Snapshot each point-symbol member's working size/rotation (`null` for measures). */
+	function clonePointSymbolStateByMember() {
+		return members.map((m) => isPointSymbolMember(m) ? {
+			size: m.workingSize,
+			rotation: m.workingRotation
+		} : null);
+	}
+	/** Write a point-symbol size/rotation snapshot back onto the live members (index-aligned). */
+	function applyPointSymbolStateByMember(states) {
+		members.forEach((member, i) => {
+			const state = states[i];
+			if (state && isPointSymbolMember(member)) {
+				member.workingSize = state.size;
+				member.workingRotation = state.rotation;
+			}
+		});
+	}
 	function cloneAmplifierPlacementsByMember() {
 		return members.map((member) => member.workingAmplifierPlacements ? structuredClone(member.workingAmplifierPlacements) : void 0);
 	}
@@ -4211,13 +4404,15 @@ function runGroupTransform(opts) {
 	}
 	/**
 	* Pin orientation-derived option defaults (e.g. Battle Position's echelon
-	* anchor) for every member, the moment a group rotate gesture starts —
+	* anchor) for every measure member, the moment a group rotate gesture starts —
 	* mirrors `edit-controller.ts`'s `freezeOrientationForRotate`, applied
-	* per-member since the group has no single working-options set.
+	* per-member since the group has no single working-options set. Point-symbol
+	* members carry no such options and are skipped.
 	*/
 	function freezeOrientationForRotate() {
 		members.forEach((member, i) => {
-			const patch = freezeOrientationOptions(member.measure.kind, member.workingPoints.map((p) => [...p]), effectiveOptions(i));
+			if (isPointSymbolMember(member)) return;
+			const patch = freezeOrientationOptions(member.graphic.kind, member.workingPoints.map((p) => [...p]), effectiveOptions(i));
 			if (patch) member.optionsOverride = {
 				...member.optionsOverride ?? {},
 				...patch
@@ -4225,54 +4420,35 @@ function runGroupTransform(opts) {
 		});
 	}
 	/**
-	* Emit a completed gesture to every registered listener — the group mirror
-	* of `edit-controller.ts`'s `emitChange` (issue #49 contract): same
-	* instance to all listeners in order, deferred `reject`/`close`/`abort`
-	* (close/abort override reject), exception collection with `AggregateError`.
+	* Emit a completed gesture through the shared change-emit protocol
+	* (`createChangeEmitter`, issue #49) — the group mirror of
+	* `edit-controller.ts`'s `emitChange`. Only this controller's variance stays
+	* here: the event payload, the per-member reject rollback, the
+	* membership-identity guard, and the recordable-source history record.
 	*/
-	function emitChange(previousRendered, previousPointsByMember, previousAmplifierPlacementsByMember, previousSizeAnchor, previousNonGeometryDirty, previousOptionsOverrideByMember, currentRendered, source = "gesture", historyLabel = "Transform", previousBoxAngle = boxAngle) {
-		if (ctx.settled) return;
-		let rejectRequested = false;
-		let closeRequested = false;
-		let abortRequested = false;
-		const event = {
+	function emitChange(previousRendered, previousPointsByMember, previousAmplifierPlacementsByMember, previousSizeAnchor, previousNonGeometryDirty, previousOptionsOverrideByMember, currentRendered, source = "gesture", historyLabel = "Transform", previousBoxAngle = boxAngle, previousPointSymbolStateByMember = clonePointSymbolStateByMember()) {
+		const membersAtEmission = members;
+		changeEmitter.emit({
 			source,
 			graphics: currentRendered,
 			previous: previousRendered,
-			session,
-			reject() {
-				rejectRequested = true;
-			},
-			close() {
-				closeRequested = true;
+			session
+		}, {
+			stillApplicable: () => members === membersAtEmission,
+			rollback() {
+				restorePointsByMember(previousPointsByMember);
+				applyAmplifierPlacementsByMember(previousAmplifierPlacementsByMember);
+				applyPointSymbolStateByMember(previousPointSymbolStateByMember);
+				sizeAnchor = previousSizeAnchor;
+				nonGeometryDirty = previousNonGeometryDirty;
+				applyOptionsOverrides(previousOptionsOverrideByMember);
+				boxAngle = previousBoxAngle;
+				renderAllPreviews();
+				renderHandlesLayer();
+				recomputeDirty();
 			},
-			abort() {
-				abortRequested = true;
-			}
-		};
-		const membersAtEmission = members;
-		const errors = [];
-		for (const listener of [...changeListeners]) try {
-			listener(event);
-		} catch (err) {
-			errors.push(err);
-		}
-		if (abortRequested) ctx.fail(new TacticalDrawAbortError("session"));
-		else if (closeRequested) commitClose();
-		else if (rejectRequested && !ctx.settled && members === membersAtEmission) {
-			restorePointsByMember(previousPointsByMember);
-			applyAmplifierPlacementsByMember(previousAmplifierPlacementsByMember);
-			sizeAnchor = previousSizeAnchor;
-			nonGeometryDirty = previousNonGeometryDirty;
-			applyOptionsOverrides(previousOptionsOverrideByMember);
-			boxAngle = previousBoxAngle;
-			renderAllPreviews();
-			renderHandlesLayer();
-			recomputeDirty();
-		}
-		if (!ctx.settled && !rejectRequested && members === membersAtEmission && (source === "gesture" || source === "programmatic")) history.record(captureHistory(), historyLabel);
-		if (errors.length === 1) throw errors[0];
-		if (errors.length > 1) throw new AggregateError(errors, "TransformSession.onChange listener errors");
+			onAccepted: source === "gesture" || source === "programmatic" ? () => history.record(captureHistory(), historyLabel) : void 0
+		});
 	}
 	/**
 	* Commit via `ctx.commit` and emit the close batch to `onCommit` listeners,
@@ -4296,13 +4472,15 @@ function runGroupTransform(opts) {
 		}
 		return snapshots;
 	}
-	function commitGesture(nextConcatPoints, preGestureOptionsOverrideByMember, nextAmplifierPlacementsByMember, preGestureBoxAngle = boxAngle) {
+	function commitGesture(nextConcatPoints, preGestureOptionsOverrideByMember, nextAmplifierPlacementsByMember, preGestureBoxAngle = boxAngle, nextPointSymbolStateByMember) {
 		if (ctx.settled) return;
 		const previousPointsByMember = clonePointsByMember();
 		const previousAmplifierPlacementsByMember = cloneAmplifierPlacementsByMember();
+		const previousPointSymbolStateByMember = clonePointSymbolStateByMember();
 		const previousOptionsOverrideByMember = preGestureOptionsOverrideByMember ?? cloneOptionsOverrideByMember();
 		const previousRendered = rebuildRenderedAllWith(previousOptionsOverrideByMember);
 		applyConcatenatedPoints(nextConcatPoints);
+		if (nextPointSymbolStateByMember) applyPointSymbolStateByMember(nextPointSymbolStateByMember);
 		if (nextAmplifierPlacementsByMember) applyAmplifierPlacementsByMember(nextAmplifierPlacementsByMember);
 		let currentRendered;
 		try {
@@ -4310,6 +4488,7 @@ function runGroupTransform(opts) {
 		} catch (err) {
 			restorePointsByMember(previousPointsByMember);
 			applyAmplifierPlacementsByMember(previousAmplifierPlacementsByMember);
+			applyPointSymbolStateByMember(previousPointSymbolStateByMember);
 			dragInFlight = false;
 			throw err;
 		}
@@ -4317,7 +4496,7 @@ function runGroupTransform(opts) {
 		renderHandlesLayer();
 		recomputeDirty();
 		dragInFlight = false;
-		emitChange(previousRendered, previousPointsByMember, previousAmplifierPlacementsByMember, sizeAnchor, nonGeometryDirty, previousOptionsOverrideByMember, currentRendered, "gesture", "Transform", preGestureBoxAngle);
+		emitChange(previousRendered, previousPointsByMember, previousAmplifierPlacementsByMember, sizeAnchor, nonGeometryDirty, previousOptionsOverrideByMember, currentRendered, "gesture", "Transform", preGestureBoxAngle, previousPointSymbolStateByMember);
 	}
 	function setSizeAnchor(next) {
 		if (ctx.settled || sizeAnchor === next) return;
@@ -4326,12 +4505,13 @@ function runGroupTransform(opts) {
 		const previousNonGeometryDirty = nonGeometryDirty;
 		const previousOptionsOverrideByMember = cloneOptionsOverrideByMember();
 		const previousAmplifierPlacementsByMember = cloneAmplifierPlacementsByMember();
+		const previousPointSymbolStateByMember = clonePointSymbolStateByMember();
 		const previousRendered = rebuildRenderedAll();
 		sizeAnchor = next;
 		const currentRendered = rebuildRenderedAll();
 		nonGeometryDirty = true;
 		dirty = true;
-		emitChange(previousRendered, previousPointsByMember, previousAmplifierPlacementsByMember, previousSizeAnchor, previousNonGeometryDirty, previousOptionsOverrideByMember, currentRendered, "programmatic", "Change size anchor");
+		emitChange(previousRendered, previousPointsByMember, previousAmplifierPlacementsByMember, previousSizeAnchor, previousNonGeometryDirty, previousOptionsOverrideByMember, currentRendered, "programmatic", "Change size anchor", boxAngle, previousPointSymbolStateByMember);
 	}
 	/**
 	* Cancel an in-flight box drag without committing it: restore the pre-drag
@@ -4343,663 +4523,252 @@ function runGroupTransform(opts) {
 	*/
 	function cancelActiveBoxDrag() {
 		if (!activeBoxDrag) return;
-		const { preDragPoints, preDragAmplifierPlacementsByMember, preDragOptionsOverrideByMember } = activeBoxDrag;
+		const { preDragPoints, preDragAmplifierPlacementsByMember, preDragOptionsOverrideByMember, preDragPointSymbolStateByMember } = activeBoxDrag;
 		activeBoxDrag = null;
 		driver.setDragPanEnabled(true);
 		applyConcatenatedPoints(preDragPoints);
 		applyAmplifierPlacementsByMember(preDragAmplifierPlacementsByMember);
 		applyOptionsOverrides(preDragOptionsOverrideByMember);
+		applyPointSymbolStateByMember(preDragPointSymbolStateByMember);
 		dragInFlight = false;
 	}
 	function setGraphics(next) {
 		if (ctx.settled) return void 0;
 		const seen = /* @__PURE__ */ new Set();
-		for (const m of next) {
-			if (seen.has(m.id)) throw new TypeError(`TransformSession.setGraphics: duplicate control measure id "${m.id}"`);
-			seen.add(m.id);
+		for (const g of next) {
+			if (seen.has(g.id)) throw new TypeError(`TransformSession.setGraphics: duplicate graphic id "${g.id}"`);
+			seen.add(g.id);
 		}
+		const currentIds = new Set(members.map((m) => m.graphic.id));
+		assertCapabilityFor(next.filter((g) => !currentIds.has(g.id)));
 		if (next.length === 0) return close();
 		cancelActiveBoxDrag();
-		const nextIds = new Set(next.map((m) => m.id));
-		const currentById = new Map(members.map((m) => [m.measure.id, m]));
+		const nextIds = new Set(next.map((g) => g.id));
+		const currentById = new Map(members.map((m) => [m.graphic.id, m]));
 		const removedSnapshots = [];
-		for (const member of members) if (!nextIds.has(member.measure.id)) removedSnapshots.push(buildMemberSnapshot(member, member.optionsOverride));
+		for (const member of members) if (!nextIds.has(member.graphic.id)) removedSnapshots.push(buildMemberSnapshot(member, member.optionsOverride));
 		const nextMembers = [];
-		for (const measure of next) {
-			const existing = currentById.get(measure.id);
+		for (const graphic of next) {
+			const existing = currentById.get(graphic.id);
 			if (existing) nextMembers.push(existing);
 			else {
-				const member = createMemberState(measure);
+				const member = createMemberState(graphic);
 				liftMemberFromGraphics(member);
-				nextMembers.push(member);
-			}
-		}
-		members = nextMembers;
-		renderAllPreviews();
-		renderHandlesLayer();
-		recomputeDirty();
-		const notificationErrors = [];
-		try {
-			history.reset(captureHistory());
-		} catch (error) {
-			notificationErrors.push(error);
-		}
-		if (removedSnapshots.length > 0) try {
-			commitEmitter.emit(removedSnapshots);
-		} catch (error) {
-			notificationErrors.push(error);
-		}
-		if (notificationErrors.length === 1) throw notificationErrors[0];
-		if (notificationErrors.length > 1) throw new AggregateError(notificationErrors, "TransformSession.setGraphics notification errors");
-		return removedSnapshots;
-	}
-	function close() {
-		return commitClose();
-	}
-	const history = createSessionHistory({
-		initial: captureHistory(),
-		clone: (value) => structuredClone(value),
-		equals: (a, b) => JSON.stringify(a) === JSON.stringify(b),
-		isCurrent: (value) => JSON.stringify(captureHistory()) === JSON.stringify(value),
-		apply(from, to, source) {
-			if (JSON.stringify(from.ids) !== JSON.stringify(to.ids)) return false;
-			const previousRendered = rebuildRenderedAll();
-			restoreHistory(to);
-			renderAllPreviews();
-			renderHandlesLayer();
-			recomputeDirty();
-			emitChange(previousRendered, from.points, from.amplifierPlacements, from.sizeAnchor, from.nonGeometryDirty, from.optionsOverrides, rebuildRenderedAll(), source, "Transform", from.boxAngle);
-			return !ctx.settled && JSON.stringify(captureHistory()) === JSON.stringify(to);
-		}
-	});
-	const session = {
-		history,
-		get graphics() {
-			return members.map((m) => m.measure);
-		},
-		controlPointsFor(graphicId) {
-			const member = members.find((m) => m.measure.id === graphicId);
-			if (!member) return void 0;
-			return member.workingPoints.map((p) => [...p]);
-		},
-		get dirty() {
-			return dirty;
-		},
-		get sizeAnchor() {
-			return sizeAnchor;
-		},
-		setSizeAnchor(next) {
-			setSizeAnchor(next);
-		},
-		setGraphics,
-		close,
-		abort() {
-			if (ctx.settled) return;
-			ctx.fail(new TacticalDrawAbortError("session"));
-		},
-		onChange(listener) {
-			if (ctx.settled) return () => {};
-			changeListeners.add(listener);
-			return () => {
-				changeListeners.delete(listener);
-			};
-		},
-		onCommit(listener) {
-			if (ctx.settled) return () => {};
-			return commitEmitter.register(listener);
-		},
-		onSettled(handler) {
-			return settleEmitter.register(handler);
-		}
-	};
-	let activeBoxDrag = null;
-	const onDriverDown = (pixel, info) => {
-		if (ctx.settled || dragInFlight) return;
-		if (!groupBox) return;
-		const tol = info?.hitTolerance ?? HANDLE_HIT_TOLERANCE_PX;
-		const boxHit = pickBoxHandle(groupBox, pixel, tol);
-		if (!boxHit) return;
-		const preDragOptionsOverrideByMember = cloneOptionsOverrideByMember();
-		if (boxHit.kind === "rotate") {
-			freezeOrientationForRotate();
-			renderAllPreviews();
-			renderHandlesLayer();
-		}
-		const preDragPoints = concatWorkingPoints();
-		const preDragAmplifierPlacementsByMember = cloneAmplifierPlacementsByMember();
-		activeBoxDrag = {
-			fsm: beginBoxDrag({
-				kind: boxHit.kind,
-				downPixel: pixel,
-				points: preDragPoints,
-				projection: dragProjection,
-				box: groupBox,
-				cornerIndex: boxHit.kind === "scale" ? boxHit.index : void 0
-			}),
-			preDragPoints,
-			preDragBox: groupBox,
-			downPixel: pixel,
-			lastSnapshot: {
-				points: preDragPoints,
-				box: groupBox
-			},
-			preDragOptionsOverrideByMember,
-			preDragAmplifierPlacementsByMember
-		};
-		dragInFlight = true;
-		driver.setDragPanEnabled(false);
-	};
-	function paintBoxDragSnapshot(pixel, constrainRotation = false) {
-		if (!activeBoxDrag) return;
-		const snapshot = activeBoxDrag.fsm.move(pixel, { constrainRotation });
-		activeBoxDrag.lastSnapshot = snapshot;
-		applyConcatenatedPoints(snapshot.points);
-		applyAmplifierPlacementsByMember(activeBoxDrag.preDragAmplifierPlacementsByMember.map((placements) => transformAmplifierPlacements(placements, activeBoxDrag.preDragBox, snapshot.box, driver)));
-		renderAllPreviews();
-		renderHandlesLayer();
-		recomputeDirty();
-	}
-	const onDriverMove = (pixel, info) => {
-		if (ctx.settled) return;
-		if (activeBoxDrag) paintBoxDragSnapshot(pixel, info?.shiftKey);
-	};
-	const onDriverUp = (pixel, info) => {
-		if (!activeBoxDrag) return;
-		if (ctx.settled) {
-			activeBoxDrag = null;
-			dragInFlight = false;
-			driver.setDragPanEnabled(true);
-			return;
-		}
-		const { fsm, preDragPoints, preDragBox, downPixel, preDragOptionsOverrideByMember, preDragAmplifierPlacementsByMember } = activeBoxDrag;
-		activeBoxDrag = null;
-		driver.setDragPanEnabled(true);
-		const distance = Math.hypot(pixel[0] - downPixel[0], pixel[1] - downPixel[1]);
-		if (fsm.kind === "body" && distance <= CLICK_SLOP_PX$2) {
-			applyConcatenatedPoints(preDragPoints);
-			applyAmplifierPlacementsByMember(preDragAmplifierPlacementsByMember);
-			renderAllPreviews();
-			renderHandlesLayer();
-			recomputeDirty();
-			dragInFlight = false;
-			bodyClickPending = true;
-			return;
-		}
-		const finalSnapshot = fsm.move(pixel, { constrainRotation: info?.shiftKey });
-		applyConcatenatedPoints(preDragPoints);
-		applyAmplifierPlacementsByMember(preDragAmplifierPlacementsByMember);
-		if (fsm.kind === "rotate") boxAngle += finalSnapshot.box.angle - preDragBox.angle;
-		commitGesture(finalSnapshot.points, preDragOptionsOverrideByMember, preDragAmplifierPlacementsByMember.map((placements) => transformAmplifierPlacements(placements, preDragBox, finalSnapshot.box, driver)), preDragBox.angle);
-	};
-	let pickPreview;
-	let pickHandles;
-	let pickGraphics;
-	const handlePickPreview = (e) => {
-		pickPreview = e;
-	};
-	const handlePickHandles = (e) => {
-		pickHandles = e;
-	};
-	const handlePickGraphics = (e) => {
-		pickGraphics = e;
-	};
-	const handleClick = () => {
-		const localPreview = pickPreview;
-		const localHandles = pickHandles;
-		const localGraphics = pickGraphics;
-		const wasBodyClick = bodyClickPending;
-		pickPreview = void 0;
-		pickHandles = void 0;
-		pickGraphics = void 0;
-		bodyClickPending = false;
-		if (ctx.settled) return;
-		if (!closeOnClickAway) return;
-		if (suppressClickAway) {
-			suppressClickAway = false;
-			return;
-		}
-		if (localHandles) return;
-		const isMember = localGraphics ? members.some((m) => m.measure.id === localGraphics.id) : false;
-		if (localGraphics && !isMember) {
-			commitClose();
-			if (onClickAwayGraphicsPick) onClickAwayGraphicsPick(localGraphics);
-			return;
-		}
-		if (localPreview) return;
-		if (wasBodyClick) return;
-		commitClose();
-	};
-	const core = runInteraction({
-		adapter,
-		signal,
-		layers: [previewLayer, handlesLayer],
-		onViewChange: rescaleOnViewChange,
-		onSettled: (settlement) => {
-			try {
-				history.settle();
-			} finally {
-				if (onSettled) onSettled();
-				if (settlement.status === "rejected") settleEmitter.emit(settleReasonFromError(settlement.error));
-			}
-		},
-		attach(c) {
-			ctx = c;
-			driver = adapter.createEditPointerDriver();
-			for (const member of members) liftMemberFromGraphics(member);
-			const unsubDown = driver.onPointerDown(onDriverDown);
-			const unsubMove = driver.onPointerMove(onDriverMove);
-			const unsubUp = driver.onPointerUp(onDriverUp);
-			const unsubPickPreview = adapter.onPick(previewLayer, handlePickPreview);
-			const unsubPickHandles = adapter.onPick(handlesLayer, handlePickHandles);
-			const unsubPickGraphics = adapter.onPick(graphicsLayer, handlePickGraphics);
-			adapter.on("click", handleClick);
-			c.onTeardown(() => {
-				adapter.off("click", handleClick);
-				unsubPickPreview();
-				unsubPickHandles();
-				unsubPickGraphics();
-				unsubDown();
-				unsubMove();
-				unsubUp();
-				if (activeBoxDrag !== null) {
-					driver.setDragPanEnabled(true);
-					activeBoxDrag = null;
-					dragInFlight = false;
-				}
-				driver.dispose();
-			}, () => {
-				if (anyLiftedFromGraphics) restoreOriginalToGraphics();
-			});
-			renderAllPreviews();
-			renderHandlesLayer();
-			recomputeDirty();
-			if (onSession) onSession(session);
-		}
-	});
-	return {
-		promise: core.promise,
-		get settled() {
-			return core.settled;
-		},
-		get graphicIds() {
-			return members.map((m) => m.measure.id);
-		},
-		abort(reason, cause) {
-			core.abort(reason, cause);
-		}
-	};
-}
-//#endregion
-//#region src/tactical-draw/point-symbol-rendering.ts
-function effectivePointSymbolPixelSize(symbol, resolution) {
-	if (symbol.size.unit === "pixels") return symbol.size.value;
-	if (resolution === void 0 || resolution <= 0) return symbol.size.value;
-	const px = symbol.size.value / resolution;
-	const { minPixels, maxPixels } = symbol.size;
-	return Math.max(Number.isFinite(minPixels) && minPixels > 0 ? minPixels : 0, Math.min(Number.isFinite(maxPixels) && maxPixels > 0 ? maxPixels : Infinity, px));
-}
-function pointSymbolPixelScale(symbol, render, resolution) {
-	if (!Number.isFinite(render.octagonSize) || render.octagonSize <= 0) throw new TypeError("PointSymbolRender.octagonSize must be a positive finite number");
-	return effectivePointSymbolPixelSize(symbol, resolution) / render.octagonSize;
-}
-/** Complete rotated logical footprint for selection and transform chrome. */
-function pointSymbolFootprint(symbol, render, adapter) {
-	const anchor = adapter.getPixelFromCoordinate(symbol.position);
-	if (!anchor) return null;
-	const scale = pointSymbolPixelScale(symbol, render, adapter.getResolution());
-	const angle = symbol.rotation - adapter.getBearing();
-	const centerOffsetX = (render.width / 2 - render.anchor.x) * scale;
-	const centerOffsetY = (render.height / 2 - render.anchor.y) * scale;
-	const cos = Math.cos(angle);
-	const sin = Math.sin(angle);
-	const box = {
-		center: [anchor[0] + centerOffsetX * cos - centerOffsetY * sin, anchor[1] + centerOffsetX * sin + centerOffsetY * cos],
-		halfWidth: render.width * scale / 2,
-		halfHeight: render.height * scale / 2,
-		angle
-	};
-	return {
-		box,
-		corners: boxCorners(box)
-	};
-}
-function renderPointSymbolForAdapter(adapter, capability, symbol) {
-	const render = capability.render(symbol);
-	return {
-		render,
-		resource: {
-			id: render.resourceId,
-			svg: render.svg,
-			width: render.width,
-			height: render.height,
-			anchor: [render.anchor.x, render.anchor.y]
-		},
-		feature: pointSymbolFeature(symbol, render, adapter.getResolution())
-	};
-}
-function pointSymbolFeature(symbol, render, resolution) {
-	const groundSizeProperties = symbol.size.unit === "meters" ? {
-		iconSizeMeters: symbol.size.value,
-		iconOctagonSize: render.octagonSize,
-		...boundProperty("iconMinPixels", symbol.size.minPixels),
-		...boundProperty("iconMaxPixels", symbol.size.maxPixels)
-	} : void 0;
-	return {
-		type: "Feature",
-		id: `${symbol.id}:point-symbol`,
-		geometry: {
-			type: "Point",
-			coordinates: [...symbol.position]
-		},
-		properties: {
-			...symbol.properties ?? {},
-			graphicId: symbol.id,
-			graphicKind: "point-symbol",
-			iconId: render.resourceId,
-			iconScale: pointSymbolPixelScale(symbol, render, resolution),
-			iconRotation: symbol.rotation,
-			iconOpacity: symbol.style?.opacity ?? 1,
-			...groundSizeProperties
-		}
-	};
-}
-function boundProperty(key, value) {
-	return value !== void 0 && Number.isFinite(value) && value > 0 ? { [key]: value } : {};
-}
-//#endregion
-//#region src/tactical-draw/graphic-transform-controller.ts
-const HIT_TOLERANCE_PX$1 = 12;
-const CLICK_SLOP_PX$1 = 3;
-function cloneGraphic(graphic) {
-	return isPointSymbol(graphic) ? clonePointSymbol(graphic) : cloneControlMeasure(graphic);
-}
-function runGraphicTransform(opts) {
-	const { adapter, capability, graphics, graphicsLayer, previewLayer, handlesLayer, graphicsStyle, signal, closeOnClickAway = true, interactionStyle, onSession, handleIdPrefix, restoreOriginalToGraphics, isOnGraphicsLayer, onSettled, onClickAwayGraphicsPick } = opts;
-	const original = graphics.map(cloneGraphic);
-	let working = original.map(cloneGraphic);
-	let dirty = false;
-	let boxAngle = 0;
-	let box = null;
-	let ctx;
-	let driver;
-	let drag = null;
-	const listeners = /* @__PURE__ */ new Set();
-	const commitEmitter = createCommitEmitter("GraphicTransformSession.onCommit listener errors");
-	const settleEmitter = createSettleEmitter("GraphicTransformSession.onSettled listener errors");
-	const renderOpts = graphicsStyle ? { graphicsStyle } : void 0;
-	const snapshotsFor = (source) => source.map((graphic) => isPointSymbol(graphic) ? {
-		graphic: clonePointSymbol(graphic),
-		render: capability.render(graphic)
-	} : {
-		graphic: cloneControlMeasure(graphic),
-		render: renderMeasureForAdapter(adapter, graphic, renderOpts)
-	});
-	const snapshots = () => snapshotsFor(working);
-	const captureHistory = () => ({
-		working: working.map(cloneGraphic),
-		boxAngle
-	});
-	const cloneHistory = (value) => ({
-		working: value.working.map(cloneGraphic),
-		boxAngle: value.boxAngle
-	});
-	function renderAll() {
-		if (ctx.settled) return;
-		const features = [];
-		const resources = /* @__PURE__ */ new Map();
-		const pixels = [];
-		const memberBoxes = [];
-		const angle = drag ? drag.liveBox.angle : boxAngle;
-		for (const graphic of working) {
-			const graphicPixels = [];
-			if (isPointSymbol(graphic)) {
-				const plan = renderPointSymbolForAdapter(adapter, capability, graphic);
-				resources.set(plan.resource.id, plan.resource);
-				features.push(plan.feature);
-				const footprint = pointSymbolFootprint(graphic, plan.render, adapter);
-				if (footprint) graphicPixels.push(...footprint.corners);
-			} else {
-				const rendered = renderMeasureForAdapter(adapter, graphic, renderOpts);
-				features.push(...rendered.features);
-				for (const feature of rendered.features) {
-					const positions = [];
-					if (feature.geometry) collectFeaturePositions(feature.geometry, positions);
-					for (const position of positions) {
-						const pixel = driver.toPixel(position);
-						if (pixel) graphicPixels.push(pixel);
-					}
-				}
-			}
-			pixels.push(...graphicPixels);
-			const memberBox = fitTransformBox(graphicPixels, angle, interactionStyle?.boxPadding);
-			if (memberBox) memberBoxes.push([graphic.id, memberBox]);
-		}
-		adapter.reconcileLayerIconResources(previewLayer, [...resources.values()]);
-		ctx.writeLayer(previewLayer, features);
-		if (!drag) box = fitTransformBox(pixels, boxAngle, interactionStyle?.boxPadding);
-		const liveBox = drag?.liveBox ?? box;
-		const handles = [];
-		if (liveBox) {
-			handles.push(boxOutlineFeature(liveBox, (pixel) => driver.fromPixel(pixel), `${handleIdPrefix}:box-outline`, groupOutlineStyle(interactionStyle?.boxOutline)));
-			handles.push(...toFeatures(boxToHandles(liveBox, (pixel) => driver.fromPixel(pixel)), handleIdPrefix, interactionStyle));
-		}
-		handles.push(...memberOutlineFeatures(memberBoxes, (pixel) => driver.fromPixel(pixel), handleIdPrefix, interactionStyle?.boxOutline));
-		ctx.writeLayer(handlesLayer, handles);
-	}
-	function anchorPoints(source) {
-		const points = [];
-		for (const graphic of source) if (isPointSymbol(graphic)) points.push([...graphic.position]);
-		else points.push(...graphic.controlPoints.map((point) => [...point]));
-		return points;
-	}
-	function applyPoints(source, points, scale, rotation) {
-		let offset = 0;
-		return source.map((graphic) => {
-			if (isPointSymbol(graphic)) {
-				const next = clonePointSymbol(graphic);
-				next.position = [...points[offset++]];
-				next.size.value = Math.max(.1, next.size.value * scale);
-				next.rotation = normalizeRotation(next.rotation + rotation);
-				return next;
+				nextMembers.push(member);
 			}
-			const next = cloneControlMeasure(graphic);
-			const count = next.controlPoints.length;
-			next.controlPoints = points.slice(offset, offset + count).map((point) => [...point]);
-			offset += count;
-			return next;
-		});
-	}
-	function emit(previousState, source) {
-		const previous = snapshotsFor(previousState.working);
-		const current = snapshots();
-		let reject = false;
-		let close = false;
-		let abort = false;
-		const event = {
-			source,
-			graphics: current,
-			previous,
-			session,
-			reject: () => reject = true,
-			close: () => close = true,
-			abort: () => abort = true
-		};
-		const errors = [];
-		for (const listener of [...listeners]) try {
-			listener(event);
+		}
+		members = nextMembers;
+		renderAllPreviews();
+		renderHandlesLayer();
+		recomputeDirty();
+		const notificationErrors = [];
+		try {
+			history.reset(captureHistory());
 		} catch (error) {
-			errors.push(error);
+			notificationErrors.push(error);
 		}
-		if (abort) ctx.fail(new TacticalDrawAbortError("session"));
-		else if (close) ctx.commit(snapshots);
-		else if (reject && !ctx.settled) {
-			working = previousState.working.map(cloneGraphic);
-			boxAngle = previousState.boxAngle;
-			dirty = JSON.stringify(working) !== JSON.stringify(original);
-			renderAll();
+		if (removedSnapshots.length > 0) try {
+			commitEmitter.emit(removedSnapshots);
+		} catch (error) {
+			notificationErrors.push(error);
 		}
-		if (errors.length === 1) throw errors[0];
-		if (errors.length > 1) throw new AggregateError(errors, "GraphicTransformSession.onChange errors");
-		return !ctx.settled && !reject;
+		if (notificationErrors.length === 1) throw notificationErrors[0];
+		if (notificationErrors.length > 1) throw new AggregateError(notificationErrors, "TransformSession.setGraphics notification errors");
+		return removedSnapshots;
+	}
+	function close() {
+		return commitClose();
 	}
 	const history = createSessionHistory({
 		initial: captureHistory(),
-		clone: cloneHistory,
-		equals: (a, b) => a.boxAngle === b.boxAngle && JSON.stringify(a.working) === JSON.stringify(b.working),
-		isCurrent: (value) => boxAngle === value.boxAngle && JSON.stringify(working) === JSON.stringify(value.working),
+		clone: (value) => structuredClone(value),
+		equals: (a, b) => JSON.stringify(a) === JSON.stringify(b),
+		isCurrent: (value) => JSON.stringify(captureHistory()) === JSON.stringify(value),
 		apply(from, to, source) {
-			working = to.working.map(cloneGraphic);
-			boxAngle = to.boxAngle;
-			dirty = JSON.stringify(working) !== JSON.stringify(original);
-			renderAll();
-			return emit(from, source);
+			if (JSON.stringify(from.ids) !== JSON.stringify(to.ids)) return false;
+			const previousRendered = rebuildRenderedAll();
+			restoreHistory(to);
+			renderAllPreviews();
+			renderHandlesLayer();
+			recomputeDirty();
+			emitChange(previousRendered, from.points, from.amplifierPlacements, from.sizeAnchor, from.nonGeometryDirty, from.optionsOverrides, rebuildRenderedAll(), source, "Transform", from.boxAngle, from.pointSymbolStates);
+			return !ctx.settled && JSON.stringify(captureHistory()) === JSON.stringify(to);
 		}
 	});
 	const session = {
 		history,
 		get graphics() {
-			return original.map(cloneGraphic);
+			return members.map((m) => m.graphic);
 		},
 		get workingGraphics() {
-			return working.map(cloneGraphic);
+			return members.map((_, i) => workingGraphicFor(i));
+		},
+		controlPointsFor(graphicId) {
+			const member = members.find((m) => m.graphic.id === graphicId);
+			if (!member || isPointSymbolMember(member)) return void 0;
+			return member.workingPoints.map((p) => [...p]);
 		},
 		get dirty() {
 			return dirty;
 		},
-		close: () => ctx.commit(snapshots),
-		abort: () => ctx.fail(new TacticalDrawAbortError("session")),
+		get sizeAnchor() {
+			return sizeAnchor;
+		},
+		setSizeAnchor(next) {
+			setSizeAnchor(next);
+		},
+		setGraphics,
+		close,
+		abort() {
+			if (ctx.settled) return;
+			ctx.fail(new TacticalDrawAbortError("session"));
+		},
 		onChange(listener) {
 			if (ctx.settled) return () => {};
-			listeners.add(listener);
-			return () => listeners.delete(listener);
+			return changeEmitter.register(listener);
 		},
 		onCommit(listener) {
 			if (ctx.settled) return () => {};
 			return commitEmitter.register(listener);
 		},
-		onSettled: (listener) => settleEmitter.register(listener)
+		onSettled(handler) {
+			return settleEmitter.register(handler);
+		}
 	};
-	const onDown = (pixel, info) => {
-		if (!box || ctx.settled) return;
-		const hit = pickBoxHandle(box, pixel, info?.hitTolerance ?? HIT_TOLERANCE_PX$1);
-		if (!hit) return;
-		const start = working.map(cloneGraphic);
-		drag = {
+	let activeBoxDrag = null;
+	/** Working point-symbol state for the given in-flight box, from each member's pre-drag state. */
+	function pointSymbolStateForBox(box) {
+		if (!activeBoxDrag) return clonePointSymbolStateByMember();
+		const { scale, rotation } = boxScaleRotation(activeBoxDrag.fsm.kind, box, activeBoxDrag.preDragBox);
+		return scalePointSymbolStates(activeBoxDrag.preDragPointSymbolStateByMember, scale, rotation);
+	}
+	const onDriverDown = (pixel, info) => {
+		if (ctx.settled || dragInFlight) return;
+		if (!groupBox) return;
+		const tol = info?.hitTolerance ?? 12;
+		const boxHit = pickBoxHandle(groupBox, pixel, tol);
+		if (!boxHit) return;
+		const preDragOptionsOverrideByMember = cloneOptionsOverrideByMember();
+		if (boxHit.kind === "rotate") {
+			freezeOrientationForRotate();
+			renderAllPreviews();
+			renderHandlesLayer();
+		}
+		const preDragPoints = concatWorkingPoints();
+		const preDragAmplifierPlacementsByMember = cloneAmplifierPlacementsByMember();
+		const preDragPointSymbolStateByMember = clonePointSymbolStateByMember();
+		activeBoxDrag = {
 			fsm: beginBoxDrag({
-				kind: hit.kind,
+				kind: boxHit.kind,
 				downPixel: pixel,
-				points: anchorPoints(start),
-				projection: {
-					toPixel: (p) => driver.toPixel(p),
-					fromPixel: (p) => driver.fromPixel(p)
-				},
-				box,
-				cornerIndex: hit.kind === "scale" ? hit.index : void 0
+				points: preDragPoints,
+				projection: dragProjection,
+				box: groupBox,
+				cornerIndex: boxHit.kind === "scale" ? boxHit.index : void 0
 			}),
-			start,
-			startBox: box,
-			liveBox: box,
-			down: [...pixel]
+			preDragPoints,
+			preDragBox: groupBox,
+			downPixel: pixel,
+			lastSnapshot: {
+				points: preDragPoints,
+				box: groupBox
+			},
+			preDragOptionsOverrideByMember,
+			preDragAmplifierPlacementsByMember,
+			preDragPointSymbolStateByMember
 		};
+		dragInFlight = true;
 		driver.setDragPanEnabled(false);
 	};
-	const dragResult = (pixel, constrainRotation = false) => {
-		if (!drag) return null;
-		const result = drag.fsm.move(pixel, { constrainRotation });
-		const scale = drag.fsm.kind === "scale" ? Math.max(result.box.halfWidth / drag.startBox.halfWidth, result.box.halfHeight / drag.startBox.halfHeight) : 1;
-		const rotation = drag.fsm.kind === "rotate" ? result.box.angle - drag.startBox.angle : 0;
-		return {
-			result,
-			graphics: applyPoints(drag.start, result.points, scale, rotation)
-		};
-	};
-	const onMove = (pixel, info) => {
-		const active = drag;
-		const next = dragResult(pixel, info?.shiftKey);
-		if (!active || !next) return;
-		working = next.graphics;
-		active.liveBox = next.result.box;
-		renderAll();
+	function paintBoxDragSnapshot(pixel, constrainRotation = false) {
+		if (!activeBoxDrag) return;
+		const snapshot = activeBoxDrag.fsm.move(pixel, { constrainRotation });
+		activeBoxDrag.lastSnapshot = snapshot;
+		applyConcatenatedPoints(snapshot.points);
+		applyPointSymbolStateByMember(pointSymbolStateForBox(snapshot.box));
+		applyAmplifierPlacementsByMember(activeBoxDrag.preDragAmplifierPlacementsByMember.map((placements) => transformAmplifierPlacements(placements, activeBoxDrag.preDragBox, snapshot.box, driver)));
+		renderAllPreviews();
+		renderHandlesLayer();
+		recomputeDirty();
+	}
+	const onDriverMove = (pixel, info) => {
+		if (ctx.settled) return;
+		if (activeBoxDrag) paintBoxDragSnapshot(pixel, info?.shiftKey);
 	};
-	const onUp = (pixel, info) => {
-		if (!drag) return;
-		const active = drag;
-		const next = dragResult(pixel, info?.shiftKey);
-		drag = null;
-		suppressClickAway = true;
-		driver.setDragPanEnabled(true);
-		working = active.start.map(cloneGraphic);
-		if (!next) return;
-		if (active.fsm.kind === "body" && Math.hypot(pixel[0] - active.down[0], pixel[1] - active.down[1]) <= CLICK_SLOP_PX$1) {
-			renderAll();
+	const onDriverUp = (pixel, info) => {
+		if (!activeBoxDrag) return;
+		if (ctx.settled) {
+			activeBoxDrag = null;
+			dragInFlight = false;
+			driver.setDragPanEnabled(true);
 			return;
 		}
-		const previousState = captureHistory();
-		working = next.graphics;
-		if (active.fsm.kind === "rotate") boxAngle += next.result.box.angle - active.startBox.angle;
-		dirty = JSON.stringify(working) !== JSON.stringify(original);
-		renderAll();
-		if (emit(previousState, "gesture")) {
-			const label = `${active.fsm.kind[0].toUpperCase()}${active.fsm.kind.slice(1)}`;
-			history.record(captureHistory(), label);
-		}
-	};
-	let previewPick;
-	let handlesPick;
-	let graphicsPick;
-	let suppressClickAway = false;
-	const onClick = () => {
-		const keepOpen = previewPick || handlesPick;
-		const deferred = graphicsPick;
-		previewPick = handlesPick = graphicsPick = void 0;
-		if (suppressClickAway) {
-			suppressClickAway = false;
+		const { fsm, preDragPoints, preDragBox, downPixel, preDragOptionsOverrideByMember, preDragAmplifierPlacementsByMember, preDragPointSymbolStateByMember } = activeBoxDrag;
+		activeBoxDrag = null;
+		driver.setDragPanEnabled(true);
+		if (fsm.kind === "body" && withinClickSlop(pixel, downPixel)) {
+			applyConcatenatedPoints(preDragPoints);
+			applyAmplifierPlacementsByMember(preDragAmplifierPlacementsByMember);
+			applyPointSymbolStateByMember(preDragPointSymbolStateByMember);
+			renderAllPreviews();
+			renderHandlesLayer();
+			recomputeDirty();
+			dragInFlight = false;
+			shell.noteBodyClick();
 			return;
 		}
-		if (!closeOnClickAway || keepOpen || drag) return;
-		if (ctx.commit(snapshots) && deferred) onClickAwayGraphicsPick?.(deferred);
+		const finalSnapshot = fsm.move(pixel, { constrainRotation: info?.shiftKey });
+		const { scale, rotation } = boxScaleRotation(fsm.kind, finalSnapshot.box, preDragBox);
+		const nextPointSymbolStateByMember = scalePointSymbolStates(preDragPointSymbolStateByMember, scale, rotation);
+		applyConcatenatedPoints(preDragPoints);
+		applyPointSymbolStateByMember(preDragPointSymbolStateByMember);
+		applyAmplifierPlacementsByMember(preDragAmplifierPlacementsByMember);
+		if (members.some(isPointSymbolMember)) shell.suppressNextClickAway();
+		if (fsm.kind === "rotate") boxAngle += finalSnapshot.box.angle - preDragBox.angle;
+		commitGesture(finalSnapshot.points, preDragOptionsOverrideByMember, preDragAmplifierPlacementsByMember.map((placements) => transformAmplifierPlacements(placements, preDragBox, finalSnapshot.box, driver)), preDragBox.angle, nextPointSymbolStateByMember);
 	};
-	const core = runInteraction({
+	const core = runEditInteraction({
 		adapter,
 		signal,
 		layers: [previewLayer, handlesLayer],
-		onViewChange: renderAll,
-		onSettled(settlement) {
-			try {
-				history.settle();
-			} finally {
-				onSettled?.();
-				settleFromInteraction(settlement, commitEmitter, settleEmitter);
+		graphicsLayer,
+		previewLayer,
+		handlesLayer,
+		closeOnClickAway,
+		onViewChange: rescaleOnViewChange,
+		onDown: onDriverDown,
+		onMove: onDriverMove,
+		onUp: onDriverUp,
+		ownsGraphic: (id) => members.some((m) => m.graphic.id === id),
+		close: () => {
+			commitClose();
+		},
+		onForeignPick: onClickAwayGraphicsPick,
+		historySettle: () => history.settle(),
+		facadeOnSettled: onSettled,
+		emitSettle: (settlement) => {
+			if (settlement.status === "rejected") settleEmitter.emit(settleReasonFromError(settlement.error));
+		},
+		extraTeardown: () => {
+			if (activeBoxDrag !== null) {
+				driver.setDragPanEnabled(true);
+				activeBoxDrag = null;
+				dragInFlight = false;
 			}
+			adapter.reconcileLayerIconResources(previewLayer, []);
 		},
-		attach(interaction) {
+		onAbort: () => {
+			if (anyLiftedFromGraphics) restoreOriginalToGraphics();
+		},
+		attach(interaction, createdDriver, createdShell) {
 			ctx = interaction;
-			driver = adapter.createEditPointerDriver();
-			const unsubs = [
-				driver.onPointerDown(onDown),
-				driver.onPointerMove(onMove),
-				driver.onPointerUp(onUp),
-				adapter.onPick(previewLayer, (event) => previewPick = event),
-				adapter.onPick(handlesLayer, (event) => handlesPick = event),
-				adapter.onPick(graphicsLayer, (event) => graphicsPick = event)
-			];
-			interaction.onTeardown(() => {
-				unsubs.forEach((unsubscribe) => unsubscribe());
-				adapter.off("click", onClick);
-				driver.dispose();
-				adapter.reconcileLayerIconResources(previewLayer, []);
-			}, restoreOriginalToGraphics);
-			for (const graphic of working) {
-				if (!isOnGraphicsLayer(graphic.id)) continue;
-				if (isPointSymbol(graphic)) adapter.removeFeatures(graphicsLayer, [`${graphic.id}:point-symbol`]);
-				else {
-					const ids = renderMeasureForAdapter(adapter, graphic, renderOpts).features.map((feature) => feature.id).filter((id) => typeof id === "string");
-					adapter.removeFeatures(graphicsLayer, ids);
-				}
-			}
-			adapter.on("click", onClick);
-			renderAll();
-			onSession?.(session);
+			driver = createdDriver;
+			shell = createdShell;
+			for (const member of members) liftMemberFromGraphics(member);
+			renderAllPreviews();
+			renderHandlesLayer();
+			recomputeDirty();
+			if (onSession) onSession(session);
 		}
 	});
 	return {
@@ -5008,31 +4777,14 @@ function runGraphicTransform(opts) {
 			return core.settled;
 		},
 		get graphicIds() {
-			return working.map((graphic) => graphic.id);
+			return members.map((m) => m.graphic.id);
 		},
-		abort: core.abort
+		abort(reason, cause) {
+			core.abort(reason, cause);
+		}
 	};
 }
 //#endregion
-//#region src/tactical-draw/errors.ts
-/**
-* Error thrown when any `TacticalDraw` method is called after `destroy()`.
-* See PRD #40 / issue #45.
-*/
-var TacticalDrawDestroyedError = class TacticalDrawDestroyedError extends Error {
-	constructor(message = "TacticalDraw instance has been destroyed") {
-		super(message);
-		this.name = "TacticalDrawDestroyedError";
-		Object.setPrototypeOf(this, TacticalDrawDestroyedError.prototype);
-	}
-};
-var PointSymbolCapabilityRequiredError = class extends Error {
-	constructor() {
-		super("TacticalDraw: point-symbol capability is not configured");
-		this.name = "PointSymbolCapabilityRequiredError";
-	}
-};
-//#endregion
 //#region src/tactical-draw/point-symbol-draw-controller.ts
 const PREVIEW_ID = "__td_point_symbol_preview__";
 function runPointSymbolDraw(options) {
@@ -5092,8 +4844,6 @@ function runPointSymbolDraw(options) {
 }
 //#endregion
 //#region src/tactical-draw/point-symbol-edit-controller.ts
-const HIT_TOLERANCE_PX = 12;
-const CLICK_SLOP_PX = 3;
 function normalisePointModes(input) {
 	const modes = input ?? ["transform"];
 	for (const mode of modes) if (mode !== "transform" && mode !== "delete") throw new TypeError(`Point-symbol editing does not support mode "${mode}"`);
@@ -5117,7 +4867,13 @@ function runPointSymbolEdit(opts) {
 	let drag = null;
 	let ctx;
 	let driver;
-	const listeners = /* @__PURE__ */ new Set();
+	let shell;
+	const changeEmitter = createChangeEmitter({
+		listenerErrorsMessage: "GraphicEditSession.onChange errors",
+		isSettled: () => ctx.settled,
+		abort: () => ctx.fail(new TacticalDrawAbortError("session")),
+		close: () => ctx.commit(snapshot)
+	});
 	const commitEmitter = createCommitEmitter("GraphicEditSession.onCommit listener errors");
 	const settleEmitter = createSettleEmitter("GraphicEditSession.onSettled listener errors");
 	const captureHistory = () => ({ working: clonePointSymbol(working) });
@@ -5139,46 +4895,24 @@ function runPointSymbolEdit(opts) {
 		}
 		ctx.writeLayer(handlesLayer, handles);
 	};
-	const emitChange = (previousState, source) => {
+	const emitChange = (previousState, source, onAccepted) => {
 		const previous = {
 			graphic: clonePointSymbol(previousState.working),
 			render: capability.render(previousState.working)
 		};
-		const current = snapshot();
-		let reject = false;
-		let close = false;
-		let abort = false;
-		const event = {
+		return changeEmitter.emit({
 			source,
-			graphic: current,
+			graphic: snapshot(),
 			previous,
-			session,
-			reject() {
-				reject = true;
-			},
-			close() {
-				close = true;
+			session
+		}, {
+			rollback() {
+				working = clonePointSymbol(previousState.working);
+				dirty = JSON.stringify(working) !== JSON.stringify(symbol);
+				render();
 			},
-			abort() {
-				abort = true;
-			}
-		};
-		const errors = [];
-		for (const listener of [...listeners]) try {
-			listener(event);
-		} catch (error) {
-			errors.push(error);
-		}
-		if (abort) ctx.fail(new TacticalDrawAbortError("session"));
-		else if (close) ctx.commit(snapshot);
-		else if (reject && !ctx.settled) {
-			working = clonePointSymbol(previousState.working);
-			dirty = JSON.stringify(working) !== JSON.stringify(symbol);
-			render();
-		}
-		if (errors.length === 1) throw errors[0];
-		if (errors.length > 1) throw new AggregateError(errors, "GraphicEditSession.onChange errors");
-		return !ctx.settled && !reject;
+			onAccepted
+		});
 	};
 	const history = createSessionHistory({
 		initial: captureHistory(),
@@ -5197,7 +4931,7 @@ function runPointSymbolEdit(opts) {
 		working = clonePointSymbol(next);
 		dirty = JSON.stringify(working) !== JSON.stringify(symbol);
 		render();
-		if (emitChange(previousState, source)) history.record(captureHistory(), label);
+		emitChange(previousState, source, () => history.record(captureHistory(), label));
 	};
 	const session = {
 		history,
@@ -5231,8 +4965,7 @@ function runPointSymbolEdit(opts) {
 		},
 		onChange(listener) {
 			if (ctx.settled) return () => {};
-			listeners.add(listener);
-			return () => listeners.delete(listener);
+			return changeEmitter.register(listener);
 		},
 		onCommit(listener) {
 			if (ctx.settled) return () => {};
@@ -5245,7 +4978,7 @@ function runPointSymbolEdit(opts) {
 	const pointerAngle = (pixel, anchor) => Math.atan2(pixel[1] - anchor[1], pixel[0] - anchor[0]);
 	const onDown = (pixel, info) => {
 		if (ctx.settled || !box || !modes.includes("transform")) return;
-		const hit = pickBoxHandle(box, pixel, info?.hitTolerance ?? HIT_TOLERANCE_PX);
+		const hit = pickBoxHandle(box, pixel, info?.hitTolerance ?? 12);
 		if (!hit) return;
 		const anchor = driver.toPixel(working.position);
 		if (!anchor) return;
@@ -5292,68 +5025,45 @@ function runPointSymbolEdit(opts) {
 		const currentDrag = drag;
 		const next = transformed(pixel, info);
 		drag = null;
-		suppressClickAway = true;
+		shell.suppressNextClickAway();
 		driver.setDragPanEnabled(true);
 		working = clonePointSymbol(currentDrag.start);
 		if (!next) return;
-		if (currentDrag.kind === "body" && Math.hypot(pixel[0] - currentDrag.down[0], pixel[1] - currentDrag.down[1]) <= CLICK_SLOP_PX) {
+		if (currentDrag.kind === "body" && withinClickSlop(pixel, currentDrag.down)) {
 			render();
 			return;
 		}
 		apply(next, "gesture", `${currentDrag.kind[0].toUpperCase()}${currentDrag.kind.slice(1)}`);
 	};
-	let previewPick;
-	let handlesPick;
-	let graphicsPick;
-	let suppressClickAway = false;
-	const onPreviewPick = (event) => previewPick = event;
-	const onHandlesPick = (event) => handlesPick = event;
-	const onGraphicsPick = (event) => graphicsPick = event;
-	const onClick = () => {
-		const keepOpen = previewPick || handlesPick;
-		const deferred = graphicsPick;
-		previewPick = handlesPick = graphicsPick = void 0;
-		if (suppressClickAway) {
-			suppressClickAway = false;
-			return;
-		}
-		if (!closeOnClickAway || keepOpen || drag) return;
-		if (ctx.commit(snapshot) && deferred) onClickAwayGraphicsPick?.(deferred);
-	};
-	const handle = runInteraction({
+	const handle = runEditInteraction({
 		adapter,
 		signal,
 		layers: [previewLayer, handlesLayer],
+		graphicsLayer,
+		previewLayer,
+		handlesLayer,
+		closeOnClickAway,
 		onViewChange: render,
-		onSettled(settlement) {
-			try {
-				history.settle();
-			} finally {
-				onSettled?.();
-				settleFromInteraction(settlement, commitEmitter, settleEmitter);
-			}
+		onDown,
+		onMove,
+		onUp,
+		ownsGraphic: (id) => id === symbol.id,
+		close: () => {
+			ctx.commit(snapshot);
 		},
-		attach(interaction) {
+		onForeignPick: onClickAwayGraphicsPick,
+		historySettle: () => history.settle(),
+		facadeOnSettled: onSettled,
+		emitSettle: (settlement) => settleFromInteraction(settlement, commitEmitter, settleEmitter),
+		extraTeardown: () => adapter.reconcileLayerIconResources(previewLayer, []),
+		onAbort: () => {
+			if (wasOnGraphicsLayer) restoreOriginalToGraphics();
+		},
+		attach(interaction, createdDriver, createdShell) {
 			ctx = interaction;
-			driver = adapter.createEditPointerDriver();
-			const unsubs = [
-				driver.onPointerDown(onDown),
-				driver.onPointerMove(onMove),
-				driver.onPointerUp(onUp),
-				adapter.onPick(previewLayer, onPreviewPick),
-				adapter.onPick(handlesLayer, onHandlesPick),
-				adapter.onPick(graphicsLayer, onGraphicsPick)
-			];
-			interaction.onTeardown(() => {
-				unsubs.forEach((unsubscribe) => unsubscribe());
-				adapter.off("click", onClick);
-				driver.dispose();
-				adapter.reconcileLayerIconResources(previewLayer, []);
-			}, () => {
-				if (wasOnGraphicsLayer) restoreOriginalToGraphics();
-			});
+			driver = createdDriver;
+			shell = createdShell;
 			if (wasOnGraphicsLayer) adapter.removeFeatures(graphicsLayer, [`${symbol.id}:point-symbol`]);
-			adapter.on("click", onClick);
 			render();
 			onSession?.(session);
 		}
@@ -5848,8 +5558,7 @@ var TacticalDraw = class {
 			if (seenIds.has(m.id)) throw new TypeError(`td.editMany: duplicate graphic id "${m.id}"`);
 			seenIds.add(m.id);
 		}
-		const hasPointSymbols = measures.some(isPointSymbol);
-		if (hasPointSymbols && !this.pointSymbols) throw new PointSymbolCapabilityRequiredError();
+		if (measures.some(isPointSymbol) && !this.pointSymbols) throw new PointSymbolCapabilityRequiredError();
 		const preempt = this.guardAndPreempt();
 		if (preempt) return preempt;
 		const isOnGraphicsLayer = (id) => this.lastRenderedMeasures.some((m) => m.id === id);
@@ -5864,7 +5573,7 @@ var TacticalDraw = class {
 		const extraSettle = () => {
 			this.activeTransformSessionRef = null;
 		};
-		if (hasPointSymbols) return this.runWithSlot((onSettled) => runGraphicTransform({
+		return this.runWithSlot((onSettled) => runGroupTransform({
 			adapter: this.adapter,
 			capability: this.pointSymbols,
 			graphics: measures,
@@ -5877,28 +5586,6 @@ var TacticalDraw = class {
 			interactionStyle: mergedInteractionStyle,
 			onSession: this.trackTransformSession(options?.onSession),
 			handleIdPrefix,
-			restoreOriginalToGraphics,
-			isOnGraphicsLayer,
-			onSettled,
-			onClickAwayGraphicsPick
-		}), (handle) => {
-			this.activeTransform = handle;
-			return () => {
-				if (this.activeTransform === handle) this.activeTransform = null;
-			};
-		}, extraSettle);
-		return this.runWithSlot((onSettled) => runGroupTransform({
-			adapter: this.adapter,
-			measures,
-			graphicsLayer: this.graphicsLayer,
-			previewLayer: this.previewLayer,
-			handlesLayer: this.handlesLayer,
-			graphicsStyle: this.graphicsStyle,
-			signal: options?.signal,
-			closeOnClickAway: options?.closeOnClickAway,
-			interactionStyle: mergedInteractionStyle,
-			onSession: this.trackTransformSession(options?.onSession),
-			handleIdPrefix,
 			sizeAnchor: options?.sizeAnchor,
 			restoreOriginalToGraphics,
 			isOnGraphicsLayer,
@@ -5912,12 +5599,15 @@ var TacticalDraw = class {
 		}, extraSettle);
 	}
 	/**
-	* One-call selection-sync: mutate a live control-measure-only transform's
-	* member set in place, or start a fresh `editMany` when no compatible
-	* transform is live (#191). A selection containing a point symbol uses the
-	* unified graphic transform session, which does not yet support mutable
-	* membership; changing that selection preempts the current session and starts
-	* a new one, resetting its box angle and other session-local state.
+	* One-call selection-sync: mutate a live transform's member set in place, or
+	* start a fresh `editMany` when none is live (#191). Any mix of control
+	* measures and point symbols is handled by the one Graphic-typed session
+	* (ADR-0032): a point symbol joins or leaves the live session exactly like a
+	* measure via `setGraphics`, preserving box angle, size anchor, and history
+	* baseline — no preempt-and-restart. A point symbol in the selection with no
+	* point-symbol capability configured throws `PointSymbolCapabilityRequiredError`
+	* synchronously (from `setGraphics` on a live session, or from `editMany` on a
+	* fresh one).
 	*
 	* The facade knows session liveness synchronously — `activeTransformSessionRef`
 	* is cleared inside the settle path, before control returns to host code — so
@@ -5946,7 +5636,7 @@ var TacticalDraw = class {
 	syncTransformGraphics(graphics, options) {
 		this.assertAlive();
 		const session = this.activeTransformSessionRef;
-		if (session && "setGraphics" in session && graphics.every((graphic) => !isPointSymbol(graphic))) {
+		if (session) {
 			if (session.setGraphics(graphics) !== void 0) return;
 		}
 		if (graphics.length === 0) {