@orbat-mapper/tactical-draw 0.2.0-alpha.0

package/dist/index.mjs

@@ -0,0 +1,2855 @@
+import { cloneControlMeasure, controlMeasureIdFromFeature, getControlMeasureMetadata, renderControlMeasure, resolveStyleHints, roundToFixed } from "@orbat-mapper/control-measures";
+//#region src/base-map-adapter.ts
+/**
+* Abstract base class shared by all `MapAdapter` implementations.
+*
+* Owns shared bookkeeping (layer registry, feature cache, event-token
+* tracking) and orchestrates the public methods over a small
+* protected primitive surface that subclasses implement. See
+* `docs/adr/0001-map-adapter-base-class.md` for the rationale, in particular
+* around the `applyFeatureOps` primitive shape.
+*/
+var BaseMapAdapter = class {
+	layers = /* @__PURE__ */ new Map();
+	eventTokens = /* @__PURE__ */ new Map();
+	viewChangeTokens = /* @__PURE__ */ new Map();
+	featureCache = /* @__PURE__ */ new Map();
+	featuresChangedListeners = /* @__PURE__ */ new Map();
+	layerCounter = 0;
+	destroyed = false;
+	nextLayerId() {
+		return `layer-${++this.layerCounter}`;
+	}
+	addVectorLayer(options) {
+		const id = this.nextLayerId();
+		const handle = this.createLayer(id, options?.style);
+		this.layers.set(id, handle);
+		this.featureCache.set(id, []);
+		return id;
+	}
+	removeLayer(layerId) {
+		const handle = this.layers.get(layerId);
+		if (!handle) return;
+		this.destroyLayer(handle);
+		this.layers.delete(layerId);
+		this.featureCache.delete(layerId);
+		this.featuresChangedListeners.delete(layerId);
+	}
+	setLayerFeatures(layerId, features) {
+		if (!this.layers.has(layerId)) return;
+		const next = [...features];
+		this.featureCache.set(layerId, next);
+		this.applyFeatureOps(layerId, {
+			adds: next,
+			updates: [],
+			full: next,
+			replace: true
+		});
+		this.emitLayerFeaturesChanged(layerId, next);
+	}
+	updateLayerFeatures(layerId, features) {
+		if (!this.layers.has(layerId)) return;
+		const existing = this.featureCache.get(layerId) ?? [];
+		const existingIds = /* @__PURE__ */ new Set();
+		for (const f of existing) if (f.id != null) existingIds.add(f.id);
+		const adds = [];
+		const updates = [];
+		const updateById = /* @__PURE__ */ new Map();
+		for (const f of features) {
+			if (f.id == null) continue;
+			if (existingIds.has(f.id)) updates.push(f);
+			else adds.push(f);
+			updateById.set(f.id, f);
+		}
+		const merged = [];
+		const removed = [];
+		for (const f of existing) if (f.id != null && updateById.has(f.id)) {
+			merged.push(updateById.get(f.id));
+			updateById.delete(f.id);
+		} else if (f.id != null && !updateById.has(f.id)) removed.push(f);
+		else merged.push(f);
+		for (const f of updateById.values()) merged.push(f);
+		this.featureCache.set(layerId, merged);
+		this.applyFeatureOps(layerId, {
+			adds,
+			updates,
+			removes: removed,
+			full: merged,
+			replace: false
+		});
+		this.emitLayerFeaturesChanged(layerId, merged);
+	}
+	removeFeatures(layerId, ids) {
+		if (!this.layers.has(layerId)) return;
+		if (ids.length === 0) return;
+		const existing = this.featureCache.get(layerId) ?? [];
+		const idSet = new Set(ids);
+		const merged = [];
+		const removed = [];
+		for (const f of existing) if (typeof f.id === "string" && idSet.has(f.id)) removed.push(f);
+		else merged.push(f);
+		if (removed.length === 0) return;
+		this.featureCache.set(layerId, merged);
+		this.applyFeatureOps(layerId, {
+			adds: [],
+			updates: [],
+			removes: removed,
+			full: merged,
+			replace: false
+		});
+		this.emitLayerFeaturesChanged(layerId, merged);
+	}
+	clearLayer(layerId) {
+		if (!this.layers.has(layerId)) return;
+		this.featureCache.set(layerId, []);
+		this.applyFeatureOps(layerId, {
+			adds: [],
+			updates: [],
+			full: [],
+			replace: true
+		});
+		this.emitLayerFeaturesChanged(layerId, []);
+	}
+	on(eventType, handler) {
+		const entry = this.attachNativeEvent(eventType, (lonLat, pixel, originalEvent) => {
+			handler({
+				type: eventType,
+				coordinate: lonLat,
+				pixel,
+				originalEvent
+			});
+		});
+		this.eventTokens.set(handler, entry);
+	}
+	off(eventType, handler) {
+		const entry = this.eventTokens.get(handler);
+		if (!entry) return;
+		this.detachNativeEvent(entry);
+		this.eventTokens.delete(handler);
+	}
+	onViewChange(handler) {
+		const token = this.attachViewChange(handler);
+		this.viewChangeTokens.set(handler, token);
+	}
+	offViewChange(handler) {
+		const token = this.viewChangeTokens.get(handler);
+		if (token === void 0) return;
+		this.detachViewChange(token);
+		this.viewChangeTokens.delete(handler);
+	}
+	destroy() {
+		if (this.destroyed) return;
+		try {
+			for (const entry of this.eventTokens.values()) this.detachNativeEvent(entry);
+			this.eventTokens.clear();
+			for (const token of this.viewChangeTokens.values()) this.detachViewChange(token);
+			this.viewChangeTokens.clear();
+			for (const handle of this.layers.values()) this.destroyLayer(handle);
+			this.layers.clear();
+			this.featureCache.clear();
+			this.featuresChangedListeners.clear();
+			this.destroyEngineResources();
+		} finally {
+			this.destroyed = true;
+		}
+	}
+	emitLayerFeaturesChanged(layerId, features) {
+		const listeners = this.featuresChangedListeners.get(layerId);
+		if (!listeners) return;
+		for (const fn of listeners) fn(features);
+	}
+	onLayerFeaturesChanged(layerId, listener) {
+		let listeners = this.featuresChangedListeners.get(layerId);
+		if (!listeners) {
+			listeners = /* @__PURE__ */ new Set();
+			this.featuresChangedListeners.set(layerId, listeners);
+		}
+		listeners.add(listener);
+		return () => {
+			const set = this.featuresChangedListeners.get(layerId);
+			if (!set) return;
+			set.delete(listener);
+			if (set.size === 0) this.featuresChangedListeners.delete(layerId);
+		};
+	}
+	destroyEngineResources() {}
+};
+function pickHitTolerance(originalEvent) {
+	if (typeof PointerEvent !== "undefined" && originalEvent instanceof PointerEvent) return originalEvent.pointerType === "touch" ? 12 : 4;
+	if (typeof TouchEvent !== "undefined" && originalEvent instanceof TouchEvent) return 12;
+	return 4;
+}
+/**
+* Resolve a pixel hit-tolerance for a `MapEvent.originalEvent` delivered by the
+* `MapAdapter.on(...)` pipeline. Unlike {@link PickEvent}, that pipeline forwards
+* the *engine wrapper* event (OpenLayers `MapBrowserEvent`, MapLibre
+* `MapMouseEvent`, Leaflet `LeafletMouseEvent`), each of which carries the raw
+* DOM event on a `.originalEvent` property. {@link pickHitTolerance} only
+* recognizes a real `PointerEvent` / `TouchEvent`, so unwrap one level when the
+* wrapper itself is not recognized as touch. Falls back to the mouse tolerance
+* when the input type cannot be determined.
+*/
+function mapEventHitTolerance(originalEvent) {
+	const direct = pickHitTolerance(originalEvent);
+	if (direct === 12) return direct;
+	if (originalEvent && typeof originalEvent === "object" && "originalEvent" in originalEvent) return pickHitTolerance(originalEvent.originalEvent);
+	return direct;
+}
+function tryControlMeasureIdFromFeature(feature) {
+	try {
+		return controlMeasureIdFromFeature(feature);
+	} catch {
+		return null;
+	}
+}
+/**
+* Wire a subscription to honour both an optional AbortSignal and a returned
+* dispose function. `attach` runs immediately (unless the signal is already
+* aborted) and must return its own teardown function. The returned dispose is
+* idempotent.
+*/
+function bindAbortable(signal, attach) {
+	if (signal?.aborted) return () => {};
+	let disposed = false;
+	const teardown = attach();
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		teardown();
+		if (signal) signal.removeEventListener("abort", dispose);
+	};
+	if (signal) signal.addEventListener("abort", dispose, { once: true });
+	return dispose;
+}
+//#endregion
+//#region src/feature-style.ts
+/**
+* Coerce a raw `properties.style` value into a `HandleStyle` for the
+* per-feature interaction-affordance overlay (ADR-0006). Returns `undefined`
+* when missing or shaped wrong so callers fall through to the layer style.
+*/
+function coerceHandleStyle(raw) {
+	if (!raw || typeof raw !== "object") return void 0;
+	return raw;
+}
+//#endregion
+//#region src/gestures/hit-test.ts
+/** Squared distance from `pixel` to the segment p1→p2 in pixel space, or null if either endpoint fails to project or the segment has zero length. */
+function pixelDistanceToSegment(pixel, p1, p2, toPixel) {
+	const a = toPixel(p1);
+	const b = toPixel(p2);
+	if (!a || !b) return null;
+	const dx = b[0] - a[0];
+	const dy = b[1] - a[1];
+	const lengthSq = dx * dx + dy * dy;
+	if (lengthSq === 0) return null;
+	let t = ((pixel[0] - a[0]) * dx + (pixel[1] - a[1]) * dy) / lengthSq;
+	t = Math.max(0, Math.min(1, t));
+	const cx = a[0] + t * dx;
+	const cy = a[1] + t * dy;
+	const ddx = pixel[0] - cx;
+	const ddy = pixel[1] - cy;
+	return Math.sqrt(ddx * ddx + ddy * ddy);
+}
+/** Even-odd point-in-ring test in pixel space. */
+function pixelPointInRing(pixel, ring, toPixel) {
+	const projected = [];
+	for (const c of ring) {
+		const p = toPixel(c);
+		if (!p) return false;
+		projected.push(p);
+	}
+	const [px, py] = pixel;
+	let inside = false;
+	for (let i = 0, j = projected.length - 1; i < projected.length; j = i++) {
+		const xi = projected[i][0], yi = projected[i][1];
+		const xj = projected[j][0], yj = projected[j][1];
+		if (yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi) + xi) inside = !inside;
+	}
+	return inside;
+}
+function isNearAnySegment(pixel, ring, hitTolerance, toPixel) {
+	for (let i = 0; i < ring.length - 1; i++) {
+		const d = pixelDistanceToSegment(pixel, ring[i], ring[i + 1], toPixel);
+		if (d !== null && d <= hitTolerance) return true;
+	}
+	return false;
+}
+/**
+* Test whether `pixel` hits any feature in `features`, in pixel space.
+*
+* Hit semantics:
+* - Point: within `hitTolerance` of the projected vertex
+* - LineString / MultiLineString: within `hitTolerance` of any segment
+* - Polygon / MultiPolygon: inside the projected ring, OR within
+*   `hitTolerance` of a ring segment (so border hits work outside fill)
+*
+* Returns the first matching feature in iteration order, or null.
+*/
+function hitTestFeature(pixel, features, hitTolerance, toPixel) {
+	const [px, py] = pixel;
+	for (const f of features) {
+		if (!f) continue;
+		const geom = f.geometry;
+		let hit = false;
+		if (geom.type === "Point") {
+			const p = toPixel(geom.coordinates);
+			if (p) {
+				const dx = p[0] - px;
+				const dy = p[1] - py;
+				hit = Math.sqrt(dx * dx + dy * dy) <= hitTolerance;
+			}
+		} else if (geom.type === "LineString") hit = isNearAnySegment(pixel, geom.coordinates, hitTolerance, toPixel);
+		else if (geom.type === "MultiLineString") hit = geom.coordinates.some((line) => isNearAnySegment(pixel, line, hitTolerance, toPixel));
+		else if (geom.type === "Polygon") hit = geom.coordinates.some((ring) => pixelPointInRing(pixel, ring, toPixel)) || geom.coordinates.some((ring) => isNearAnySegment(pixel, ring, hitTolerance, toPixel));
+		else if (geom.type === "MultiPolygon") hit = geom.coordinates.some((poly) => poly.some((ring) => pixelPointInRing(pixel, ring, toPixel))) || geom.coordinates.some((poly) => poly.some((ring) => isNearAnySegment(pixel, ring, hitTolerance, toPixel)));
+		if (hit) return f;
+	}
+	return null;
+}
+//#endregion
+//#region src/gestures/hit-tolerance.ts
+const TOUCH_HIT_TOLERANCE_PX = 22;
+//#endregion
+//#region src/gestures/pointer-callback-hub.ts
+/**
+* The subscriber registry behind every {@link EditPointerDriver}.
+*
+* Each engine adapter sources pointer events differently — OpenLayers from
+* unified DOM `PointerEvent`s, MapLibre and Leaflet from split mouse/touch
+* streams — and each owns its own multi-touch capture FSM. What does *not*
+* vary is the registry: three callback sets, the subscribe-returns-disposer
+* contract, the snapshot-before-dispatch semantics, and teardown. That lived
+* in four hand-rolled copies (the three adapters plus the test fake); it now
+* lives here once.
+*
+* Adapters fan their normalized events in through {@link fireDown} /
+* {@link fireMove} / {@link fireUp} and expose the `onPointer*` methods on
+* their driver; teardown calls {@link clear}.
+*/
+var PointerCallbackHub = class {
+	downCbs = /* @__PURE__ */ new Set();
+	moveCbs = /* @__PURE__ */ new Set();
+	upCbs = /* @__PURE__ */ new Set();
+	onPointerDown(cb) {
+		this.downCbs.add(cb);
+		return () => this.downCbs.delete(cb);
+	}
+	onPointerMove(cb) {
+		this.moveCbs.add(cb);
+		return () => this.moveCbs.delete(cb);
+	}
+	onPointerUp(cb) {
+		this.upCbs.add(cb);
+		return () => this.upCbs.delete(cb);
+	}
+	fireDown(pixel, info) {
+		for (const cb of [...this.downCbs]) cb(pixel, info);
+	}
+	fireMove(pixel, info) {
+		for (const cb of [...this.moveCbs]) cb(pixel, info);
+	}
+	fireUp(pixel, info) {
+		for (const cb of [...this.upCbs]) cb(pixel, info);
+	}
+	/** Drop every subscriber. Idempotent; call from the driver's `dispose`. */
+	clear() {
+		this.downCbs.clear();
+		this.moveCbs.clear();
+		this.upCbs.clear();
+	}
+};
+//#endregion
+//#region src/tactical-draw/active-interaction.ts
+/**
+* Owns the facade's public interaction state: the abort handle used by
+* cancel/preempt/destroy and the optional session exposed to hosts.
+*/
+var ActiveInteractionTracker = class {
+	handle = null;
+	currentSession = null;
+	starting = false;
+	pendingCancel = null;
+	begin() {
+		this.handle = null;
+		this.currentSession = null;
+		this.starting = true;
+		this.pendingCancel = null;
+	}
+	set(handle) {
+		if (handle.settled) {
+			this.clear();
+			return;
+		}
+		this.handle = handle;
+		this.starting = false;
+		const pendingCancel = this.pendingCancel;
+		this.pendingCancel = null;
+		if (pendingCancel) handle.abort(pendingCancel);
+	}
+	setSession(session) {
+		this.currentSession = session;
+	}
+	/**
+	* Clear only the expected interaction when a handle is supplied. This keeps
+	* an old promise's backstop cleanup from clearing a newer interaction.
+	*/
+	clear(expected) {
+		if (expected && this.handle !== expected) return;
+		this.handle = null;
+		this.currentSession = null;
+		this.starting = false;
+		this.pendingCancel = null;
+	}
+	cancel(reason = "session") {
+		const handle = this.handle;
+		if (handle && !handle.settled) {
+			handle.abort(reason);
+			return true;
+		}
+		if (this.starting) {
+			this.pendingCancel = reason;
+			this.currentSession = null;
+			return true;
+		}
+		return false;
+	}
+	get session() {
+		return this.currentSession;
+	}
+	/** True while an interaction is mid-construction (between `begin` and `set`). */
+	get isStarting() {
+		return this.starting;
+	}
+	get isActive() {
+		return this.starting || this.handle !== null && !this.handle.settled;
+	}
+};
+//#endregion
+//#region src/tactical-draw/abort.ts
+const ABORT_REASONS = new Set([
+	"escape",
+	"signal",
+	"preempted",
+	"destroyed",
+	"session",
+	"removed"
+]);
+/**
+* Façade abort error. Extends `DOMException` with `name: "AbortError"` so it
+* still matches platform `AbortSignal` semantics and `instanceof DOMException`.
+*/
+var TacticalDrawAbortError = class TacticalDrawAbortError extends DOMException {
+	reason;
+	constructor(reason, options) {
+		if (!ABORT_REASONS.has(reason)) throw new TypeError(`Invalid TacticalDrawAbortReason: ${String(reason)}`);
+		super(options?.message ?? `TacticalDraw aborted (${reason})`, "AbortError");
+		Object.setPrototypeOf(this, TacticalDrawAbortError.prototype);
+		this.reason = reason;
+		if (options && "cause" in options) Object.defineProperty(this, "cause", {
+			value: options.cause,
+			writable: true,
+			configurable: true,
+			enumerable: false
+		});
+	}
+};
+function isTacticalDrawAbortError(error) {
+	return error instanceof TacticalDrawAbortError;
+}
+/**
+* Swallow façade `TacticalDrawAbortError` *and* plain DOM `AbortError`s;
+* rethrow every other value unchanged. Designed for use as
+* `promise.catch(ignoreAbort)`.
+*/
+function ignoreAbort(error) {
+	if (isTacticalDrawAbortError(error)) return;
+	if (error instanceof DOMException && error.name === "AbortError") return;
+	throw error;
+}
+/**
+* Compose the façade's internal abort controller with an optional host
+* `AbortSignal`. Host aborts surface as `reason: "signal"` with the host's
+* `signal.reason` on `error.cause`. An already-aborted host signal triggers
+* a next-microtask abort (never synchronous), so callers can register await
+* handlers before the rejection fires.
+*/
+function combineWithHostSignal(hostSignal) {
+	const controller = new AbortController();
+	let disposed = false;
+	const abortFromHost = () => {
+		if (controller.signal.aborted) return;
+		const cause = hostSignal?.reason;
+		controller.abort(new TacticalDrawAbortError("signal", { cause }));
+	};
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		if (hostSignal) hostSignal.removeEventListener("abort", abortFromHost);
+	};
+	if (hostSignal) if (hostSignal.aborted) queueMicrotask(abortFromHost);
+	else hostSignal.addEventListener("abort", abortFromHost, { once: true });
+	return {
+		signal: controller.signal,
+		abort(reason, cause) {
+			if (controller.signal.aborted) {
+				dispose();
+				return;
+			}
+			const options = arguments.length > 1 ? { cause } : void 0;
+			controller.abort(new TacticalDrawAbortError(reason, options));
+			dispose();
+		},
+		dispose
+	};
+}
+/**
+* Per-kind pixel-denominated size option and the meter option it bakes into —
+* the single source of which option makes a measure screen-anchored. Both the
+* resolution gate ([[measureUsesAdapterResolution]]) and the bake
+* ([[bakePixelSizeToGround]]) derive from this table, so a new pixel-sized kind
+* is one entry here (ADR-0020).
+*/
+const PIXEL_SIZE_OPTIONS = {
+	flot: {
+		pixels: "radiusPixels",
+		meters: "radius"
+	},
+	"fortified-line": {
+		pixels: "sizePixels",
+		meters: "size"
+	},
+	"fortified-area": {
+		pixels: "sizePixels",
+		meters: "size"
+	},
+	"antitank-ditch-under-construction": {
+		pixels: "toothHeightPixels",
+		meters: "toothHeight"
+	},
+	"antitank-ditch-completed": {
+		pixels: "toothHeightPixels",
+		meters: "toothHeight"
+	},
+	"antitank-wall": {
+		pixels: "toothHeightPixels",
+		meters: "toothHeight"
+	}
+};
+/**
+* Whether `measure` carries a pixel-denominated size option whose resolution
+* to meters depends on the live map (`metersPerPixel`) — i.e. it is
+* *screen-anchored*. Used both to inject the override
+* ([[withAdapterMeasureOptions]]) and to let zoom-driven re-renders skip
+* measures whose geometry is resolution-independent. Accepts the minimal
+* `{ kind, options }` shape so in-flight draw/edit handlers can gate against
+* working options without materialising a full measure.
+*/
+function measureUsesAdapterResolution(measure) {
+	const spec = PIXEL_SIZE_OPTIONS[measure.kind];
+	if (!spec) return false;
+	return measure.options?.[spec.pixels] !== void 0;
+}
+/**
+* The [[SizeAnchor]] a measure currently encodes (ADR-0020): `screen` when it
+* carries its kind's pixel-denominated size option, `ground` otherwise. Keys off
+* the same `PIXEL_SIZE_OPTIONS` table as the bake, so a consumer deciding how to
+* re-edit a graphic never has to re-derive the per-kind pixel-option knowledge
+* (e.g. via a fragile key-name heuristic). Accepts the minimal `{ kind, options }`
+* shape, mirroring [[measureUsesAdapterResolution]].
+*/
+function getSizeAnchor(measure) {
+	return measureUsesAdapterResolution(measure) ? "screen" : "ground";
+}
+/**
+* Bake a screen-anchored (pixel) size to a ground-anchored (meter) size at the
+* adapter's current resolution, then strip the pixel + `metersPerPixel` keys so
+* the result is an ordinary meters graphic carrying no pixel intent — afterward
+* indistinguishable from one drawn directly in meters (ADR-0020). Invoked on
+* draw/edit commit for the default `ground` anchor. No-op when the measure
+* carries no pixel size or the adapter has no usable resolution.
+*/
+function bakePixelSizeToGround(measure, adapter) {
+	const spec = PIXEL_SIZE_OPTIONS[measure.kind];
+	if (!spec) return measure;
+	const options = measure.options ?? {};
+	const pixels = options[spec.pixels];
+	if (typeof pixels !== "number") return measure;
+	const mpp = adapter.getResolution();
+	if (mpp === void 0 || mpp <= 0) return measure;
+	const rest = {};
+	for (const [key, value] of Object.entries(options)) if (key !== spec.pixels && key !== "metersPerPixel") rest[key] = value;
+	rest[spec.meters] = pixels * mpp;
+	return {
+		...measure,
+		options: rest
+	};
+}
+/**
+* Stamp the adapter's current `metersPerPixel` onto a measure that sizes itself
+* in pixels, so the generator resolves pixel options (`radiusPixels`,
+* `sizePixels`, `toothHeightPixels`) against the live map zoom. Returns the
+* measure unchanged when the adapter has no usable resolution or the
+* kind/options don't opt into pixel sizing.
+*/
+function withAdapterMeasureOptions(measure, adapter) {
+	const mpp = adapter.getResolution();
+	if (mpp === void 0 || mpp <= 0) return measure;
+	if (!measureUsesAdapterResolution(measure)) return measure;
+	return {
+		...measure,
+		options: {
+			...measure.options,
+			metersPerPixel: mpp
+		}
+	};
+}
+/**
+* Capture draw-time label sizing options on commit. These are stable feature
+* style inputs; adapters scale from them without TacticalDraw re-rendering on
+* every zoom.
+*/
+function withCommittedAdapterMeasureOptions(measure, adapter) {
+	if (!getControlMeasureMetadata(measure.kind).capturesLabelSize) return measure;
+	if (typeof measure.options?.labelSizePixels === "number") return measure;
+	const zoom = adapter.getZoom();
+	const resolution = adapter.getResolution();
+	return {
+		...measure,
+		options: {
+			...measure.options,
+			labelSizePixels: 14,
+			...zoom !== void 0 ? { labelSizeZoom: zoom } : {},
+			...resolution !== void 0 && resolution > 0 ? { labelSizeResolution: resolution } : {}
+		}
+	};
+}
+/**
+* Render a measure with the adapter's resolution injected. The single seam for
+* "turn a measure into features against the live map" — every TacticalDraw
+* layer write (graphics reconcile, draw preview, edit preview, commit snapshot)
+* routes through here so pixel sizing is resolved identically everywhere and no
+* call site can forget the injection. See [[withAdapterMeasureOptions]].
+*/
+function renderMeasureForAdapter(adapter, measure, opts) {
+	return renderControlMeasure(withAdapterMeasureOptions(measure, adapter), opts);
+}
+//#endregion
+//#region src/tactical-draw/run-interaction.ts
+function runInteraction(spec) {
+	const { adapter, signal, layers, onViewChange, onSettled, attach } = spec;
+	if (signal?.aborted) {
+		const error = new TacticalDrawAbortError("signal", { cause: signal.reason });
+		const promise = Promise.reject(error);
+		promise.catch(() => {});
+		return {
+			promise,
+			settled: true,
+			abort: () => {}
+		};
+	}
+	let settled = false;
+	const combined = combineWithHostSignal(signal);
+	let resolveFn;
+	let rejectFn;
+	const promise = new Promise((resolve, reject) => {
+		resolveFn = resolve;
+		rejectFn = reject;
+	});
+	const idsByLayer = /* @__PURE__ */ new Map();
+	for (const layer of layers) idsByLayer.set(layer, /* @__PURE__ */ new Set());
+	let controllerDetach = null;
+	let controllerOnAbort = null;
+	function writeLayer(layer, features) {
+		adapter.updateLayerFeatures(layer, features);
+		const set = idsByLayer.get(layer);
+		if (!set) return;
+		set.clear();
+		for (const f of features) if (typeof f.id === "string") set.add(f.id);
+	}
+	function clearLayers() {
+		for (const [layer, set] of idsByLayer) {
+			if (set.size === 0) continue;
+			adapter.removeFeatures(layer, [...set]);
+			set.clear();
+		}
+	}
+	const handleKeydown = (event) => {
+		if (settled) return;
+		if (event.key !== "Escape") return;
+		fail(new TacticalDrawAbortError("escape"));
+	};
+	function teardown() {
+		if (controllerDetach) controllerDetach();
+		if (onViewChange) adapter.offViewChange(onViewChange);
+		if (typeof window !== "undefined") window.removeEventListener("keydown", handleKeydown);
+		combined.dispose();
+		clearLayers();
+	}
+	function commit(produce) {
+		if (settled) return;
+		let value;
+		try {
+			value = produce();
+		} catch (err) {
+			settled = true;
+			teardown();
+			rejectFn(err);
+			if (onSettled) onSettled();
+			return;
+		}
+		settled = true;
+		teardown();
+		resolveFn(value);
+		if (onSettled) onSettled();
+	}
+	function fail(error) {
+		if (settled) return;
+		settled = true;
+		teardown();
+		if (controllerOnAbort) try {
+			controllerOnAbort();
+		} catch {}
+		rejectFn(error);
+		if (onSettled) onSettled();
+	}
+	const ctx = {
+		get settled() {
+			return settled;
+		},
+		commit,
+		fail,
+		writeLayer,
+		onTeardown(detach, onAbort) {
+			controllerDetach = detach;
+			controllerOnAbort = onAbort ?? null;
+		}
+	};
+	combined.signal.addEventListener("abort", () => {
+		if (settled) return;
+		const reason = combined.signal.reason;
+		if (reason instanceof TacticalDrawAbortError) fail(reason);
+		else fail(new TacticalDrawAbortError("signal", { cause: reason }));
+	}, { once: true });
+	if (onViewChange) adapter.onViewChange(onViewChange);
+	if (typeof window !== "undefined") window.addEventListener("keydown", handleKeydown);
+	attach(ctx);
+	return {
+		promise,
+		get settled() {
+			return settled;
+		},
+		abort(reason, cause) {
+			combined.abort(reason, cause);
+		}
+	};
+}
+/**
+* Round every component of a single position to {@link CONTROL_POINT_PRECISION}
+* places. Handles optional altitude (any trailing components) too.
+*/
+function roundControlPoint(point) {
+	return point.map((v) => roundToFixed(v, 6));
+}
+/**
+* Round every position in a control-point array, returning a fresh array of
+* fresh positions. Applied at the points where TacticalDraw writes
+* gesture-produced geometry into working / committed state so full-precision
+* floats never reach a stored measure or an emitted snapshot.
+*/
+function roundControlPoints(points) {
+	return points.map(roundControlPoint);
+}
+//#endregion
+//#region src/tactical-draw/draw-controller.ts
+const PREVIEW_CM_ID$1 = "__td_preview__";
+const PREVIEW_CURSOR$1 = "crosshair";
+/**
+* Drive an interactive fixed-length draw against a `MapAdapter`.
+*
+* Caller is the `TacticalDraw` façade. The controller owns:
+*  - control-point accumulation via `click`
+*  - rubber-band preview via `pointermove`
+*  - Escape cancellation via `keydown`
+*  - cursor capture / restore for the duration of the draw
+*  - host `AbortSignal` plumbing and reason mapping
+*
+* Auto-commits when the user clicks the final required point — fixed-length
+* kinds need no host UI.
+*/
+function runFixedLengthDraw(options) {
+	const { adapter, kind, previewLayer, graphicsStyle, generateId, signal, measureOptions, measureStyle, measureProperties, sizeAnchor, onSettled } = options;
+	const metadata = getControlMeasureMetadata(kind);
+	const rule = metadata.rule;
+	const min = metadata.minCoordinates;
+	const max = metadata.maxCoordinates;
+	let required;
+	if (rule) required = rule.minimumUserPoints;
+	else if (typeof min === "number" && typeof max === "number" && min === max) required = min;
+	else throw new Error(`runFixedLengthDraw: kind "${kind}" is not fixed-length (min=${min}, max=${max})`);
+	const renderOpts = graphicsStyle ? { graphicsStyle } : void 0;
+	const committed = [];
+	let rubberBand;
+	let ctx;
+	const savedCursor = "";
+	const handleClick = (event) => {
+		if (ctx.settled) return;
+		committed.push(event.coordinate);
+		rubberBand = void 0;
+		if (committed.length >= required) {
+			ctx.commit(buildSnapshot);
+			return;
+		}
+		renderPreview();
+	};
+	const handlePointerMove = (event) => {
+		if (ctx.settled) return;
+		if (committed.length === 0) return;
+		rubberBand = event.coordinate;
+		renderPreview();
+	};
+	function renderPreview() {
+		const raw = rubberBand !== void 0 ? [...committed, rubberBand] : [...committed];
+		if (raw.length === 0) {
+			ctx.writeLayer(previewLayer, []);
+			return;
+		}
+		const previewThreshold = rule?.minimumPreviewPoints ?? required;
+		const features = buildPreviewFeatures$1(adapter, kind, rule && raw.length >= previewThreshold ? rule.derive(raw) : raw, measureOptions, measureStyle, renderOpts);
+		ctx.writeLayer(previewLayer, features);
+	}
+	function rescaleOnViewChange() {
+		if (!measureUsesAdapterResolution({
+			kind,
+			options: measureOptions
+		})) return;
+		renderPreview();
+	}
+	function buildSnapshot() {
+		const finalPoints = roundControlPoints(rule ? rule.derive(committed) : committed);
+		const captured = withCommittedAdapterMeasureOptions({
+			id: generateId(),
+			kind,
+			controlPoints: finalPoints,
+			...measureOptions !== void 0 ? { options: measureOptions } : {},
+			...measureStyle !== void 0 ? { style: measureStyle } : {},
+			...measureProperties !== void 0 ? { properties: measureProperties } : {}
+		}, adapter);
+		const measure = sizeAnchor === "screen" ? captured : bakePixelSizeToGround(captured, adapter);
+		return {
+			measure: cloneControlMeasure(measure),
+			render: renderMeasureForAdapter(adapter, measure, renderOpts)
+		};
+	}
+	return runInteraction({
+		adapter,
+		signal,
+		layers: [previewLayer],
+		onViewChange: rescaleOnViewChange,
+		onSettled,
+		attach(c) {
+			ctx = c;
+			c.onTeardown(() => {
+				adapter.off("click", handleClick);
+				adapter.off("pointermove", handlePointerMove);
+				adapter.setCursor(savedCursor);
+			});
+			adapter.setCursor(PREVIEW_CURSOR$1);
+			adapter.on("click", handleClick);
+			adapter.on("pointermove", handlePointerMove);
+		}
+	});
+}
+/**
+* Produce preview features for the partial geometry. Tries the full renderer
+* first so the preview looks like the real symbol once enough points are in;
+* falls back to a plain Point/LineString outline when the kind's generator
+* cannot produce a shape yet (under-min count).
+*/
+function buildPreviewFeatures$1(adapter, kind, points, measureOptions, measureStyle, renderOpts) {
+	const measure = {
+		id: PREVIEW_CM_ID$1,
+		kind,
+		controlPoints: points,
+		...measureOptions !== void 0 ? { options: measureOptions } : {},
+		...measureStyle !== void 0 ? { style: measureStyle } : {}
+	};
+	try {
+		return renderMeasureForAdapter(adapter, measure, {
+			...renderOpts,
+			validationMode: "throw"
+		}).features;
+	} catch {
+		return outlinePreview$1(points);
+	}
+}
+function outlinePreview$1(points) {
+	const features = [];
+	for (let i = 0; i < points.length; i++) {
+		const pt = {
+			type: "Feature",
+			id: `${PREVIEW_CM_ID$1}:vertex:${i}`,
+			geometry: {
+				type: "Point",
+				coordinates: points[i]
+			},
+			properties: {
+				part: "vertex",
+				index: i
+			}
+		};
+		features.push(pt);
+	}
+	return features;
+}
+//#endregion
+//#region src/tactical-draw/guide.ts
+/**
+* Stable preview-layer ids and emission rules for the rubber-band guide
+* (ADR-0004). Shared between `td.draw` and `td.edit` so hosts can apply a
+* single styling rule across both interactions.
+*/
+const PREVIEW_GUIDE_FEATURE_PREFIX = "__td_preview__";
+const PREVIEW_GUIDE_OPEN_ID = `${PREVIEW_GUIDE_FEATURE_PREFIX}:guide:open`;
+const PREVIEW_GUIDE_CLOSING_ID = `${PREVIEW_GUIDE_FEATURE_PREFIX}:guide:closing`;
+/**
+* A kind is fixed-length when its draw rule pins the slot count
+* (`canonicalPointCount`) or its metadata declares `min === max`. The
+* generator preview is already authoritative for these, so the rubber-band
+* guide adds no information.
+*/
+function isFixedLength(metadata) {
+	if (metadata.rule?.canonicalPointCount !== void 0) return true;
+	const min = metadata.minCoordinates;
+	const max = metadata.maxCoordinates;
+	return typeof min === "number" && typeof max === "number" && min === max;
+}
+/**
+* Guide is mechanically suppressed for kinds where it carries no information:
+* point kinds and fixed-length kinds. Independent of the host's `guide`
+* opt-out.
+*/
+function shouldSuppressGuide(metadata) {
+	return metadata.geometry === "point" || isFixedLength(metadata);
+}
+/**
+* Build the guide LineString features for a point list.
+*  - Open polyline through `points` once `points.length >= 2`.
+*  - Closing segment `[last, first]` for area kinds once `points.length >= 3`.
+*
+* Callers are responsible for the opt-out (`guide: false`) and the suppression
+* check via [[shouldSuppressGuide]] — this function only emits geometry.
+*/
+function buildGuideFeatures(points, isAreaKind, trailingFixedSlots = 0) {
+	const features = [];
+	const spine = trailingFixedSlots > 0 ? points.slice(0, points.length - trailingFixedSlots) : points;
+	if (spine.length >= 2) {
+		const open = {
+			type: "Feature",
+			id: PREVIEW_GUIDE_OPEN_ID,
+			geometry: {
+				type: "LineString",
+				coordinates: spine.slice()
+			},
+			properties: {
+				part: "guide",
+				segment: "open"
+			}
+		};
+		features.push(open);
+	}
+	if (isAreaKind && spine.length >= 3) {
+		const closing = {
+			type: "Feature",
+			id: PREVIEW_GUIDE_CLOSING_ID,
+			geometry: {
+				type: "LineString",
+				coordinates: [spine[spine.length - 1], spine[0]]
+			},
+			properties: {
+				part: "guide",
+				segment: "closing"
+			}
+		};
+		features.push(closing);
+	}
+	return features;
+}
+//#endregion
+//#region src/tactical-draw/draw-controller-variable.ts
+const PREVIEW_CM_ID = "__td_preview__";
+const PREVIEW_CURSOR = "crosshair";
+/**
+* Drive an interactive variable-length draw against a `MapAdapter`.
+*
+* Surfaces a scoped `DrawSession` via `opts.onSession`. The session owns the
+* commit decision (`session.commit()`), with `dblclick` and "click the last
+* added point again" as additional gesture-level commit triggers.
+*/
+function runVariableLengthDraw(options) {
+	const { adapter, kind, previewLayer, guideLayer, graphicsStyle, generateId, signal, onSession, seed, measureOptions, measureStyle, measureProperties, guide: guideOpt, sizeAnchor, onSettled } = options;
+	const metadata = getControlMeasureMetadata(kind);
+	if (typeof metadata.minCoordinates !== "number") throw new Error(`runVariableLengthDraw: kind "${kind}" has no minCoordinates metadata`);
+	const min = metadata.minCoordinates;
+	const max = metadata.maxCoordinates;
+	const rule = metadata.rule;
+	const trailingFixed = rule?.trailingFixedSlots ?? 0;
+	const ruleMin = rule?.minimumUserPoints;
+	const guideEnabled = (guideOpt ?? true) && !shouldSuppressGuide(metadata);
+	const isAreaKind = metadata.geometry === "area";
+	function canonicalFormed(len) {
+		if (!rule || ruleMin === void 0) return false;
+		return len >= trailingFixed + ruleMin;
+	}
+	function insertionIndex(len) {
+		return canonicalFormed(len) ? len - trailingFixed : len;
+	}
+	const renderOpts = graphicsStyle ? { graphicsStyle } : void 0;
+	const initialPoints = [];
+	if (seed) {
+		for (const pos of seed) {
+			if (!isValidPosition(pos)) throw new TypeError(`td.draw: seed contains invalid coordinate ${JSON.stringify(pos)}`);
+			initialPoints.push([...pos]);
+		}
+		if (typeof max === "number" && initialPoints.length > max) throw new RangeError(`td.draw: seed has ${initialPoints.length} points but kind "${kind}" allows at most ${max}`);
+		if (rule && initialPoints.length > 0) {
+			const derived = rule.derive(initialPoints);
+			initialPoints.splice(0, initialPoints.length, ...derived);
+		}
+		if (initialPoints.length >= min) renderMeasureForAdapter(adapter, {
+			id: PREVIEW_CM_ID,
+			kind,
+			controlPoints: initialPoints.map((p) => [...p]),
+			...measureOptions !== void 0 ? { options: measureOptions } : {},
+			...measureStyle !== void 0 ? { style: measureStyle } : {}
+		}, {
+			...renderOpts,
+			validationMode: "throw"
+		});
+	}
+	const committed = initialPoints;
+	let rubberBand;
+	let ctx;
+	const savedCursor = "";
+	const changeListeners = /* @__PURE__ */ new Set();
+	function canCommitNow() {
+		const n = committed.length;
+		if (typeof max === "number" && n > max) return false;
+		if (n < min) return false;
+		if (rule && ruleMin !== void 0 && n - trailingFixed < ruleMin) return false;
+		return true;
+	}
+	const session = {
+		get controlPoints() {
+			return committed.map((p) => [...p]);
+		},
+		get canCommit() {
+			return !ctx.settled && canCommitNow();
+		},
+		get minControlPoints() {
+			return min;
+		},
+		get maxControlPoints() {
+			return max;
+		},
+		commit() {
+			if (ctx.settled) return false;
+			if (!canCommitNow()) return false;
+			ctx.commit(buildSnapshot);
+			return true;
+		},
+		abort() {
+			if (ctx.settled) return;
+			ctx.fail(new TacticalDrawAbortError("session"));
+		},
+		onChange(listener) {
+			if (ctx.settled) return () => {};
+			changeListeners.add(listener);
+			return () => {
+				changeListeners.delete(listener);
+			};
+		}
+	};
+	function fireChange() {
+		if (ctx.settled) return;
+		const errors = [];
+		for (const listener of [...changeListeners]) try {
+			listener(session);
+		} catch (err) {
+			errors.push(err);
+		}
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, "DrawSession.onChange listener errors");
+	}
+	const handleClick = (event) => {
+		if (ctx.settled) return;
+		const pos = roundControlPoint(event.coordinate);
+		const lastSpineIdx = committed.length - 1 - trailingFixed;
+		for (let i = 0; i < committed.length; i++) if (positionsEqual(pos, committed[i])) {
+			if (i === lastSpineIdx && canCommitNow()) ctx.commit(buildSnapshot);
+			return;
+		}
+		if (lastSpineIdx >= 0 && canCommitNow()) {
+			const lastPixel = adapter.getPixelFromCoordinate(committed[lastSpineIdx]);
+			if (lastPixel) {
+				const tol = mapEventHitTolerance(event.originalEvent);
+				const dx = event.pixel[0] - lastPixel[0];
+				const dy = event.pixel[1] - lastPixel[1];
+				if (dx * dx + dy * dy <= tol * tol) {
+					ctx.commit(buildSnapshot);
+					return;
+				}
+			}
+		}
+		if (typeof max === "number" && committed.length >= max) return;
+		const idx = insertionIndex(committed.length);
+		committed.splice(idx, 0, [...pos]);
+		if (rule) {
+			const derived = rule.derive(committed);
+			committed.splice(0, committed.length, ...derived);
+		}
+		committed.splice(0, committed.length, ...roundControlPoints(committed));
+		rubberBand = void 0;
+		renderPreview();
+		try {
+			fireChange();
+		} catch (err) {
+			ctx.fail(err);
+		}
+	};
+	const handleDblClick = (event) => {
+		if (ctx.settled) return;
+		if (canCommitNow()) ctx.commit(buildSnapshot);
+	};
+	const handlePointerMove = (event) => {
+		if (ctx.settled) return;
+		if (committed.length === 0) return;
+		rubberBand = event.coordinate;
+		renderPreview();
+	};
+	function renderPreview() {
+		let points;
+		if (rubberBand !== void 0) {
+			points = [...committed];
+			const idx = insertionIndex(points.length);
+			points.splice(idx, 0, rubberBand);
+		} else points = [...committed];
+		if (rule) points = rule.derive(points);
+		const previewFeatures = points.length === 0 ? [] : buildPreviewFeatures(adapter, kind, points, measureOptions, measureStyle, renderOpts);
+		ctx.writeLayer(previewLayer, previewFeatures);
+		const guideFeatures = points.length === 0 || !guideEnabled ? [] : buildGuideFeatures(points, isAreaKind, trailingFixed);
+		ctx.writeLayer(guideLayer, guideFeatures);
+	}
+	function rescaleOnViewChange() {
+		if (!measureUsesAdapterResolution({
+			kind,
+			options: measureOptions
+		})) return;
+		renderPreview();
+	}
+	function buildSnapshot() {
+		const built = {
+			id: generateId(),
+			kind,
+			controlPoints: committed.map((p) => [...p]),
+			...measureOptions !== void 0 ? { options: measureOptions } : {},
+			...measureStyle !== void 0 ? { style: measureStyle } : {},
+			...measureProperties !== void 0 ? { properties: measureProperties } : {}
+		};
+		const measure = sizeAnchor === "screen" ? built : bakePixelSizeToGround(built, adapter);
+		return {
+			measure: cloneControlMeasure(measure),
+			render: renderMeasureForAdapter(adapter, measure, renderOpts)
+		};
+	}
+	return runInteraction({
+		adapter,
+		signal,
+		layers: [previewLayer, guideLayer],
+		onViewChange: rescaleOnViewChange,
+		onSettled,
+		attach(c) {
+			ctx = c;
+			c.onTeardown(() => {
+				adapter.off("click", handleClick);
+				adapter.off("pointermove", handlePointerMove);
+				adapter.off("dblclick", handleDblClick);
+				adapter.setCursor(savedCursor);
+			});
+			adapter.setCursor(PREVIEW_CURSOR);
+			adapter.on("click", handleClick);
+			adapter.on("pointermove", handlePointerMove);
+			adapter.on("dblclick", handleDblClick);
+			if (committed.length > 0) renderPreview();
+			if (onSession) onSession(session);
+		}
+	});
+}
+function positionsEqual(a, b) {
+	if (a.length !== b.length) {}
+	if (a[0] !== b[0] || a[1] !== b[1]) return false;
+	const az = a[2];
+	const bz = b[2];
+	if (az === void 0 && bz === void 0) return true;
+	return az === bz;
+}
+function isValidPosition(value) {
+	if (!Array.isArray(value)) return false;
+	if (value.length < 2 || value.length > 3) return false;
+	for (let i = 0; i < value.length; i++) {
+		const n = value[i];
+		if (typeof n !== "number" || !Number.isFinite(n)) return false;
+	}
+	return true;
+}
+function buildPreviewFeatures(adapter, kind, points, measureOptions, measureStyle, renderOpts) {
+	const measure = {
+		id: PREVIEW_CM_ID,
+		kind,
+		controlPoints: points,
+		...measureOptions !== void 0 ? { options: measureOptions } : {},
+		...measureStyle !== void 0 ? { style: measureStyle } : {}
+	};
+	try {
+		return renderMeasureForAdapter(adapter, measure, renderOpts).features;
+	} catch {
+		return outlinePreview(points);
+	}
+}
+function outlinePreview(points) {
+	const features = [];
+	for (let i = 0; i < points.length; i++) {
+		const pt = {
+			type: "Feature",
+			id: `${PREVIEW_CM_ID}:vertex:${i}`,
+			geometry: {
+				type: "Point",
+				coordinates: points[i]
+			},
+			properties: {
+				part: "vertex",
+				index: i
+			}
+		};
+		features.push(pt);
+	}
+	return features;
+}
+//#endregion
+//#region src/tactical-draw/handles.ts
+/**
+* Compute the anchor used by translate and rotate handles. The anchor is the
+* centroid (arithmetic mean) of the control-point list — stable, kind
+* agnostic, and well-defined for any non-empty point set.
+*/
+function computeHandleAnchor(controlPoints) {
+	if (controlPoints.length === 0) return null;
+	let sx = 0;
+	let sy = 0;
+	for (const p of controlPoints) {
+		sx += p[0];
+		sy += p[1];
+	}
+	return [sx / controlPoints.length, sy / controlPoints.length];
+}
+/**
+* How far past the outermost control point the rotate grip sits. `1.3` places
+* it 30% beyond the farthest vertex, clearing the geometry while staying
+* proportional to the shape's size.
+*/
+const ROTATE_HANDLE_REACH_FACTOR = 1.3;
+/**
+* Position of the rotate grip. Unlike the translate handle — which sits on the
+* centroid pivot — the rotate handle needs a lever arm, so it is offset from
+* the centroid along the ray toward the control point farthest from it, just
+* outside the shape. Anchoring to a *material* point (rather than the
+* axis-aligned bbox top) keeps this stateless yet glued to the geometry: the
+* grip orbits with the shape as it rotates, since the farthest vertex rotates
+* with it. Falls back to the centroid when every point coincides (no
+* well-defined direction) or the list is empty.
+*/
+function computeRotateHandlePosition(controlPoints) {
+	const anchor = computeHandleAnchor(controlPoints);
+	if (!anchor) return null;
+	let farthest = null;
+	let maxDistSq = 0;
+	for (const p of controlPoints) {
+		const dx = p[0] - anchor[0];
+		const dy = p[1] - anchor[1];
+		const distSq = dx * dx + dy * dy;
+		if (distSq > maxDistSq) {
+			maxDistSq = distSq;
+			farthest = p;
+		}
+	}
+	if (!farthest) return anchor;
+	return [anchor[0] + (farthest[0] - anchor[0]) * ROTATE_HANDLE_REACH_FACTOR, anchor[1] + (farthest[1] - anchor[1]) * ROTATE_HANDLE_REACH_FACTOR];
+}
+/**
+* Axis-aligned bounding-box center of the control points — the midpoint of
+* `[minX, maxX] × [minY, maxY]`. Used as the rotation pivot so a shape turns
+* about its visual middle (matching mainstream drawing tools) rather than the
+* vertex mean (`computeHandleAnchor`), which is pulled off-center on asymmetric
+* measures. Returns `null` for an empty list.
+*
+* Exported because the rotation pivot is *not* a handle: it is the rotation
+* center, distinct from the rotate grip's lever-arm position. The edit
+* controller computes it directly at drag-start. See ADR-0016.
+*/
+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
+* midpoint and the vertex it becomes cannot drift apart.
+*/
+function segmentMidpoint(a, b) {
+	return [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+}
+/**
+* The single source of truth for edit-handle placement and the
+* `EditMode → which handles` gating (ADR-0016). Pure and projection-free:
+* positions are lonLat. Handles are emitted in **pick priority order** —
+* `[vertices…, midpoints…, translate, rotate]` — so `pickHandle` can return the
+* first within tolerance and preserve "vertex wins over a pixel-closer
+* midpoint." Rendering (`toFeatures`) and picking (`pickHandle`) are thin
+* projections of this set; the drag controller seeds gestures from it too.
+*
+* Emits handles only for modes present in `modes`:
+*  - `reshape`: vertex handle at every control point + midpoint handle on
+*    every adjacent pair (subject to `includeMidpoints` / `trailingFixedSlots`);
+*  - `delete`: vertex handles only (tapped to remove), no midpoint/grips;
+*  - `translate`: a single translate handle at the centroid anchor;
+*  - `rotate`: a single rotate grip offset outside the shape.
+*
+* `scale` is a reserved enum value rejected at the façade boundary — no handles
+* are emitted for it here. Returns `[]` for an empty control-point list.
+*/
+function buildHandleSet(controlPoints, modes, options = {}) {
+	const { includeMidpoints = true, trailingFixedSlots = 0 } = options;
+	const handles = [];
+	const wantsReshape = modes.includes("reshape");
+	if (wantsReshape || modes.includes("delete")) {
+		for (let i = 0; i < controlPoints.length; i++) handles.push({
+			kind: "vertex",
+			index: i,
+			position: [...controlPoints[i]]
+		});
+		if (wantsReshape && includeMidpoints) {
+			const midpointLimit = controlPoints.length - 1 - trailingFixedSlots;
+			for (let i = 0; i < midpointLimit; i++) handles.push({
+				kind: "midpoint",
+				index: i,
+				position: segmentMidpoint(controlPoints[i], controlPoints[i + 1])
+			});
+		}
+	}
+	if (modes.includes("translate")) {
+		const anchor = computeHandleAnchor(controlPoints);
+		if (anchor) handles.push({
+			kind: "translate",
+			index: 0,
+			position: anchor
+		});
+	}
+	if (modes.includes("rotate")) {
+		const rotatePos = computeRotateHandlePosition(controlPoints);
+		if (rotatePos) handles.push({
+			kind: "rotate",
+			index: 0,
+			position: rotatePos
+		});
+	}
+	return handles;
+}
+function handleFeatureId(prefix, kind, index) {
+	switch (kind) {
+		case "vertex": return `${prefix}:handle-vertex:${index}`;
+		case "midpoint": return `${prefix}:handle-midpoint:${index}`;
+		case "translate": return `${prefix}:handle-translate`;
+		case "rotate": return `${prefix}:handle-rotate`;
+	}
+}
+function handleStyleFor(kind, interactionStyle) {
+	switch (kind) {
+		case "vertex": return interactionStyle?.vertexHandle;
+		case "midpoint": return interactionStyle?.midpointHandle;
+		case "translate": return interactionStyle?.translateHandle;
+		case "rotate": return interactionStyle?.rotateHandle;
+	}
+}
+/**
+* Project a handle set into the GeoJSON features that belong on the handles
+* layer — the render projection of `buildHandleSet` (ADR-0016). Stable
+* `featureIdPrefix`-namespaced ids let multiple edits share a handles layer
+* without colliding; per-slot `interactionStyle` rides on `properties.style`.
+* Pure: handle positions are copied, never aliased into the output geometry.
+*/
+function toFeatures(handles, featureIdPrefix, interactionStyle) {
+	return handles.map((handle) => {
+		const style = handleStyleFor(handle.kind, interactionStyle);
+		return {
+			type: "Feature",
+			id: handleFeatureId(featureIdPrefix, handle.kind, handle.index),
+			geometry: {
+				type: "Point",
+				coordinates: [...handle.position]
+			},
+			properties: style ? {
+				handle: handle.kind,
+				index: handle.index,
+				style: { ...style }
+			} : {
+				handle: handle.kind,
+				index: handle.index
+			}
+		};
+	});
+}
+function pixelDistance(a, b) {
+	return Math.hypot(a[0] - b[0], a[1] - b[1]);
+}
+/**
+* The pick projection of `buildHandleSet` (ADR-0016): the first handle within
+* `tolerance` pixels of `pixel`, tested in the set's priority order. Because
+* `buildHandleSet` orders vertices before midpoints before translate before
+* rotate, "first within tolerance" preserves the legacy "vertex wins over a
+* pixel-closer midpoint" behaviour. Returns the full `Handle` so the drag
+* controller can seed a gesture from its `position` without recomputing
+* placement. Handles whose position fails to project (off-screen / degenerate
+* projection) are skipped. Returns `null` when nothing is within tolerance.
+*/
+function pickHandle(handles, pixel, tolerance, toPixel) {
+	for (const handle of handles) {
+		const projected = toPixel(handle.position);
+		if (projected && pixelDistance(projected, pixel) <= tolerance) return handle;
+	}
+	return null;
+}
+//#endregion
+//#region src/tactical-draw/handle-drag.ts
+function clonePoints(points) {
+	return points.map((p) => [...p]);
+}
+/** Shift every point by `(dx, dy)`, carrying any extra (z / m) dimensions through. */
+function translatePoints(base, dx, dy) {
+	return base.map((p) => {
+		const out = [p[0] + dx, p[1] + dy];
+		for (let k = 2; k < p.length; k++) out.push(p[k]);
+		return out;
+	});
+}
+function angleFromAnchor(anchor, target) {
+	return Math.atan2(target[1] - anchor[1], target[0] - anchor[0]);
+}
+/**
+* Angle of `pixel` around the rotation pivot, measured in screen space so it
+* matches what the user sees and does. Falls back to lon/lat when the pivot
+* cannot be projected — exceedingly rare for an on-screen edit.
+*/
+function rotateAngleAt(pivot, pivotPixel, pixel, projection) {
+	if (pivotPixel) return Math.atan2(pixel[1] - pivotPixel[1], pixel[0] - pivotPixel[0]);
+	return angleFromAnchor(pivot, projection.fromPixel(pixel));
+}
+/**
+* Rotate `points` by `angle` about the pivot in screen space — project each
+* point to pixels, rotate around the pivot's pixel, unproject — so the result is
+* a rigid on-screen rotation regardless of latitude / projection. Falls back to
+* 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.
+*/
+function rotatePointsAround(points, pivot, pivotPixel, angle, projection) {
+	const cos = Math.cos(angle);
+	const sin = Math.sin(angle);
+	if (pivotPixel) return points.map((p) => {
+		const px = projection.toPixel(p);
+		if (!px) return [...p];
+		const dx = px[0] - pivotPixel[0];
+		const dy = px[1] - pivotPixel[1];
+		const ll = projection.fromPixel([pivotPixel[0] + dx * cos - dy * sin, pivotPixel[1] + dx * sin + dy * cos]);
+		const out = [ll[0], ll[1]];
+		for (let k = 2; k < p.length; k++) out.push(p[k]);
+		return out;
+	});
+	const [ax, ay] = pivot;
+	return points.map((p) => {
+		const dx = p[0] - ax;
+		const dy = p[1] - ay;
+		const out = [ax + dx * cos - dy * sin, ay + dx * sin + dy * cos];
+		for (let k = 2; k < p.length; k++) out.push(p[k]);
+		return out;
+	});
+}
+/**
+* Build the drag-start result from a transition's `move` and the points to paint
+* at drag-start. `end` is derived from `move` here, so the "commit what the last
+* move would show" invariant holds by construction for every kind.
+*/
+function begun(kind, initialBase, move) {
+	return {
+		drag: {
+			kind,
+			move,
+			end: (pixel) => move(pixel).points
+		},
+		initialPoints: clonePoints(initialBase)
+	};
+}
+/**
+* Begin a handle drag from a picked handle and the pre-drag control points.
+* Returns the live FSM plus the points to paint at drag-start (see
+* [[BegunHandleDrag.initialPoints]]). The grabbed handle's kind selects the
+* transition; every transition computes its geometry from a private copy of the
+* pre-drag points, so the returned `move` / `end` snapshots never alias the
+* caller's working copy.
+*/
+function beginHandleDrag(args) {
+	const { hit, downPixel, points, projection, rule } = args;
+	const { fromPixel } = projection;
+	const preDragPoints = clonePoints(points);
+	const snap = (next, activePointIndex) => rule ? rule.transform({
+		previous: preDragPoints,
+		next,
+		activePointIndex
+	}) : next;
+	const dragOnePoint = (base, activeIndex) => {
+		const move = (pixel) => {
+			return {
+				points: snap(base.map((p, i) => i === activeIndex ? fromPixel(pixel) : [...p]), activeIndex),
+				rotateGripOverride: null
+			};
+		};
+		return move;
+	};
+	if (hit.kind === "vertex") return begun("vertex", preDragPoints, dragOnePoint(preDragPoints, hit.index));
+	if (hit.kind === "midpoint") {
+		const insertIndex = hit.index + 1;
+		const mid = segmentMidpoint(preDragPoints[hit.index], preDragPoints[hit.index + 1]);
+		const insertedBase = [
+			...preDragPoints.slice(0, insertIndex),
+			mid,
+			...preDragPoints.slice(insertIndex)
+		];
+		return begun("midpoint", insertedBase, dragOnePoint(insertedBase, insertIndex));
+	}
+	if (hit.kind === "translate") {
+		const origin = fromPixel(downPixel);
+		return begun("translate", preDragPoints, (pixel) => {
+			const cur = fromPixel(pixel);
+			return {
+				points: translatePoints(preDragPoints, cur[0] - origin[0], cur[1] - origin[1]),
+				rotateGripOverride: null
+			};
+		});
+	}
+	const pivot = computeBoundingBoxCenter(preDragPoints) ?? [0, 0];
+	const pivotPixel = projection.toPixel(pivot);
+	const startAngle = rotateAngleAt(pivot, pivotPixel, downPixel, projection);
+	const startGrip = hit.position;
+	return begun("rotate", preDragPoints, (pixel) => {
+		const angle = rotateAngleAt(pivot, pivotPixel, pixel, projection) - startAngle;
+		return {
+			points: rotatePointsAround(preDragPoints, pivot, pivotPixel, angle, projection),
+			rotateGripOverride: rotatePointsAround([startGrip], pivot, pivotPixel, angle, projection)[0]
+		};
+	});
+}
+//#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 computed anchor (centroid);
+* one `EditChangeEvent` is emitted, matching the issue #50 emission contract.
+*
+* @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/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 = 1e-9;
+const HANDLE_HIT_TOLERANCE_PX = 12;
+const ALLOWED_EDIT_MODES = new Set([
+	"reshape",
+	"translate",
+	"rotate",
+	"delete"
+]);
+/**
+* Drive an interactive edit against a `MapAdapter`. Implements the first
+* edit slice (issue #48):
+*
+*  - lift-original (remove from graphics layer) + working copy
+*  - preview + handle rendering for `reshape` mode
+*  - dirty tracking via [[DIRTY_EPSILON]] tolerance
+*  - default click-away close policy
+*  - close / abort / signal / preempt / destroy paths
+*
+* Pointer-driven vertex / midpoint drag is intentionally NOT wired here —
+* gesture binding lands with the change-event spec in #49 and the
+* translate/rotate handle set in #50.
+*/
+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 } = 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 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 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;
+	/**
+	* 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 changeListeners = /* @__PURE__ */ new Set();
+	let ctx;
+	let driver;
+	const dragProjection = {
+		toPixel: (lonLat) => driver.toPixel(lonLat),
+		fromPixel: (pixel) => driver.fromPixel(pixel)
+	};
+	function liftOriginalFromGraphics() {
+		if (!wasOnGraphicsLayer) return;
+		const originalFeatureIds = renderMeasureForAdapter(adapter, measure, renderOpts).features.map((f) => f.id).filter((id) => typeof id === "string");
+		if (originalFeatureIds.length > 0) adapter.removeFeatures(graphicsLayer, originalFeatureIds);
+	}
+	function renderPreview() {
+		if (ctx.settled) return;
+		const working = {
+			...measure,
+			style: currentStyle,
+			options: workingOptions,
+			controlPoints: workingPoints.map((p) => [...p])
+		};
+		let features;
+		try {
+			features = renderMeasureForAdapter(adapter, working, renderOpts).features;
+		} catch {
+			features = [];
+		}
+		ctx.writeLayer(previewLayer, features);
+		const guideFeatures = guideEnabled ? buildGuideFeatures(workingPoints, isAreaKind, trailingFixedSlots) : [];
+		ctx.writeLayer(guideLayer, guideFeatures);
+	}
+	function rescaleOnViewChange() {
+		if (!measureUsesAdapterResolution({
+			kind: measure.kind,
+			options: workingOptions
+		})) return;
+		renderPreview();
+	}
+	function renderHandlesLayer() {
+		if (ctx.settled) return;
+		let handles = buildHandleSet(workingPoints, modes, {
+			includeMidpoints: midpointHandlesEnabled,
+			trailingFixedSlots
+		});
+		if (activeDrag?.fsm.kind === "rotate" && rotateHandleOverride) {
+			const override = rotateHandleOverride;
+			handles = handles.map((h) => h.kind === "rotate" ? {
+				...h,
+				position: override
+			} : h);
+		}
+		const features = toFeatures(handles, handleIdPrefix, interactionStyle);
+		ctx.writeLayer(handlesLayer, features);
+	}
+	function rebuildRendered() {
+		const working = {
+			...measure,
+			style: currentStyle,
+			options: workingOptions,
+			controlPoints: workingPoints.map((p) => [...p])
+		};
+		const committed = sizeAnchor === "screen" ? working : bakePixelSizeToGround(working, adapter);
+		return {
+			measure: cloneControlMeasure(committed),
+			render: renderMeasureForAdapter(adapter, committed, renderOpts)
+		};
+	}
+	function recomputeDirty() {
+		dirty = nonGeometryDirty || !pointsEqualWithinTolerance(workingPoints, editStartPoints, DIRTY_EPSILON);
+	}
+	function replaceWorkingPoints(next) {
+		workingPoints.splice(0, workingPoints.length, ...roundControlPoints(next));
+	}
+	function replaceWorkingOptions(next) {
+		workingOptions = { ...next ?? {} };
+	}
+	/**
+	* 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.
+	*/
+	function emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, previousSizeAnchor, currentRendered) {
+		if (ctx.settled) return;
+		let rejectRequested = false;
+		let closeRequested = false;
+		let abortRequested = false;
+		const event = {
+			measure: currentRendered,
+			previous: previousRendered,
+			session,
+			reject() {
+				rejectRequested = true;
+			},
+			close() {
+				closeRequested = true;
+			},
+			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;
+			nonGeometryDirty = previousNonGeometryDirty;
+			renderPreview();
+			renderHandlesLayer();
+			recomputeDirty();
+		}
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, "EditSession.onChange listener errors");
+	}
+	/**
+	* Apply a completed gesture: snapshot pre-state, write the new control
+	* points, re-render preview / handles, recompute `dirty`, then emit. Bad
+	* geometry restores the previous state and re-throws synchronously without
+	* notifying listeners.
+	*
+	* A completed gesture also ends the in-flight drag. Any `setModes()` calls
+	* queued during the drag are applied after the listener emission (so the
+	* post-gesture render reflects the requested mode set).
+	*/
+	function commitGesture(nextPoints) {
+		if (ctx.settled) return;
+		const previousPoints = workingPoints.map((p) => [...p]);
+		const previousOptions = { ...workingOptions ?? {} };
+		const previousStyle = currentStyle;
+		const previousNonGeometryDirty = nonGeometryDirty;
+		const previousRendered = rebuildRendered();
+		replaceWorkingPoints(nextPoints);
+		let currentRendered;
+		try {
+			currentRendered = rebuildRendered();
+		} catch (err) {
+			replaceWorkingPoints(previousPoints);
+			dragInFlight = false;
+			drainPendingModes();
+			throw err;
+		}
+		renderPreview();
+		renderHandlesLayer();
+		recomputeDirty();
+		dragInFlight = false;
+		drainPendingModes();
+		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, sizeAnchor, currentRendered);
+	}
+	function setOptions(partial) {
+		if (ctx.settled) return;
+		const previousPoints = workingPoints.map((p) => [...p]);
+		const previousOptions = { ...workingOptions ?? {} };
+		const previousStyle = currentStyle;
+		const previousNonGeometryDirty = nonGeometryDirty;
+		const previousRendered = rebuildRendered();
+		replaceWorkingOptions({
+			...workingOptions ?? {},
+			...partial ?? {}
+		});
+		let currentRendered;
+		try {
+			currentRendered = rebuildRendered();
+		} catch (err) {
+			replaceWorkingOptions(previousOptions);
+			throw err;
+		}
+		renderPreview();
+		nonGeometryDirty = true;
+		dirty = true;
+		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, sizeAnchor, currentRendered);
+	}
+	function setStyle(partial) {
+		if (ctx.settled) return;
+		const previousPoints = workingPoints.map((p) => [...p]);
+		const previousOptions = { ...workingOptions ?? {} };
+		const previousStyle = currentStyle;
+		const previousNonGeometryDirty = nonGeometryDirty;
+		const previousRendered = rebuildRendered();
+		currentStyle = {
+			...currentStyle ?? {},
+			...partial
+		};
+		let currentRendered;
+		try {
+			currentRendered = rebuildRendered();
+		} catch (err) {
+			currentStyle = previousStyle;
+			throw err;
+		}
+		renderPreview();
+		nonGeometryDirty = true;
+		dirty = true;
+		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, sizeAnchor, currentRendered);
+	}
+	/**
+	* Flip the size anchor for the measure under edit (ADR-0020). Re-renders the
+	* emitted snapshot through `rebuildRendered` (which reads `sizeAnchor` live)
+	* and emits a change so hosts see the re-anchored measure. The preview layer
+	* is unaffected — it renders from `workingOptions`, which still carry the
+	* pixel size, so the in-flight symbol stays screen-locked until commit.
+	*/
+	function setSizeAnchor(next) {
+		if (ctx.settled || sizeAnchor === next) return;
+		const previousPoints = workingPoints.map((p) => [...p]);
+		const previousOptions = { ...workingOptions ?? {} };
+		const previousStyle = currentStyle;
+		const previousNonGeometryDirty = nonGeometryDirty;
+		const previousSizeAnchor = sizeAnchor;
+		const previousRendered = rebuildRendered();
+		sizeAnchor = next;
+		const currentRendered = rebuildRendered();
+		nonGeometryDirty = true;
+		dirty = true;
+		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, previousSizeAnchor, currentRendered);
+	}
+	/** 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;
+		}));
+	}
+	/**
+	* Apply a rotate gesture by rotating every working point by `angle` (radians)
+	* around the bounding-box center. The rotation runs in screen space (see
+	* `rotatePointsAround`) so it stays rigid and matches the pointer 1:1 at any
+	* latitude.
+	*/
+	function commitRotate(angle) {
+		if (ctx.settled) return;
+		const pivot = computeBoundingBoxCenter(workingPoints);
+		if (!pivot) return;
+		commitGesture(rotatePointsAround(workingPoints, pivot, driver.toPixel(pivot), angle, dragProjection));
+	}
+	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;
+		return true;
+	}
+	function applyModes(next) {
+		if (modesEqual(modes, next)) return;
+		modes = next;
+		renderHandlesLayer();
+	}
+	function drainPendingModes() {
+		if (pendingModes === null) return;
+		const next = pendingModes;
+		pendingModes = null;
+		applyModes(next);
+	}
+	const session = {
+		measure,
+		get controlPoints() {
+			return workingPoints.map((p) => [...p]);
+		},
+		get options() {
+			return { ...workingOptions ?? {} };
+		},
+		get style() {
+			return currentStyle ? { ...currentStyle } : void 0;
+		},
+		get dirty() {
+			return dirty;
+		},
+		get modes() {
+			return modes;
+		},
+		get sizeAnchor() {
+			return sizeAnchor;
+		},
+		close() {
+			if (ctx.settled) return;
+			ctx.commit(rebuildRendered);
+		},
+		abort() {
+			if (ctx.settled) return;
+			ctx.fail(new TacticalDrawAbortError("session"));
+		},
+		setModes(next) {
+			if (ctx.settled) return;
+			const normalised = normaliseModes(next);
+			if (dragInFlight) {
+				pendingModes = normalised;
+				return;
+			}
+			applyModes(normalised);
+		},
+		setOptions(partial) {
+			setOptions(partial);
+		},
+		setStyle(partial) {
+			setStyle(partial);
+		},
+		setSizeAnchor(next) {
+			setSizeAnchor(next);
+		},
+		onChange(listener) {
+			if (ctx.settled) return () => {};
+			changeListeners.add(listener);
+			return () => {
+				changeListeners.delete(listener);
+			};
+		},
+		[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;
+	/**
+	* Render-only rotate-grip override produced by the drag FSM: the start grip
+	* rotated rigidly with the gesture so it tracks the pointer instead of hopping
+	* between near-equidistant vertices. Cleared when the drag ends. Only
+	* consulted while a rotate drag is in flight — pick is gated off for the
+	* duration, so the resting handle set is never read against it (ADR-0016).
+	*/
+	let rotateHandleOverride = null;
+	/**
+	* Whether the vertex at `index` may be deleted (via Alt+click or in the
+	* exclusive `delete` mode). Deletion is
+	* confined to variable-length measures (the same condition that enables
+	* midpoint inserts — see ADR-0005) and is denied when it would:
+	*   - target a trailing fixed slot (e.g. Axis1's width handle), or
+	*   - drop the user-spine point count below the rule's `minimumUserPoints`.
+	* Fixed-count measures re-pad on derive, so deleting a vertex there is moot.
+	*/
+	function canDeleteVertex(index) {
+		if (!midpointHandlesEnabled) return false;
+		if (!modes.includes("reshape") && !modes.includes("delete")) return false;
+		const spineCount = workingPoints.length - trailingFixedSlots;
+		if (index < 0 || index >= spineCount) return false;
+		const minimum = rule?.minimumUserPoints ?? (isAreaKind ? 3 : 2);
+		return spineCount - 1 >= minimum;
+	}
+	/**
+	* Remove the vertex at `index` and commit through the normal gesture path so
+	* a single `EditChangeEvent` covers the delete and dirty tracking stays
+	* consistent. The rule's `transform` runs with the removed index as the
+	* active point so frame-relative invariants survive the delete: for Axis1
+	* this re-projects the trailing width handle into the new tip→neck frame,
+	* keeping the main-attack arrow's width unchanged even when the tip or neck
+	* is removed. Rules without that concern (Line1) pass the points through.
+	*/
+	function deleteVertex(index) {
+		if (ctx.settled) return;
+		const previous = workingPoints.map((p) => [...p]);
+		const spliced = previous.filter((_, i) => i !== index);
+		commitGesture(rule ? rule.transform({
+			previous,
+			next: spliced,
+			activePointIndex: index
+		}) : spliced);
+	}
+	const onDriverDown = (pixel, info) => {
+		if (ctx.settled || dragInFlight) return;
+		const tol = info?.hitTolerance ?? HANDLE_HIT_TOLERANCE_PX;
+		const hit = pickHandle(buildHandleSet(workingPoints, modes, {
+			includeMidpoints: midpointHandlesEnabled,
+			trailingFixedSlots
+		}), pixel, tol, (lonLat) => driver.toPixel(lonLat));
+		if (!hit) return;
+		if (modes.includes("delete")) {
+			if (hit.kind === "vertex" && canDeleteVertex(hit.index)) {
+				deleteVertex(hit.index);
+				suppressClickAway = true;
+			}
+			return;
+		}
+		if (hit.kind === "vertex" && info?.altKey && canDeleteVertex(hit.index)) {
+			deleteVertex(hit.index);
+			suppressClickAway = true;
+			return;
+		}
+		const preDragPoints = workingPoints.map((p) => [...p]);
+		const { drag: fsm, initialPoints } = beginHandleDrag({
+			hit,
+			downPixel: pixel,
+			points: preDragPoints,
+			projection: dragProjection,
+			rule
+		});
+		activeDrag = {
+			fsm,
+			preDragPoints
+		};
+		if (fsm.kind === "midpoint") {
+			workingPoints.splice(0, workingPoints.length, ...initialPoints);
+			renderPreview();
+			renderHandlesLayer();
+		}
+		dragInFlight = true;
+		driver.setDragPanEnabled(false);
+	};
+	function paintDragSnapshot(pixel) {
+		if (!activeDrag) return;
+		const snapshot = activeDrag.fsm.move(pixel);
+		workingPoints.splice(0, workingPoints.length, ...snapshot.points);
+		rotateHandleOverride = snapshot.rotateGripOverride;
+		renderPreview();
+		renderHandlesLayer();
+		recomputeDirty();
+	}
+	const onDriverMove = (pixel) => {
+		if (ctx.settled || !activeDrag) return;
+		paintDragSnapshot(pixel);
+	};
+	const onDriverUp = (pixel) => {
+		if (!activeDrag) return;
+		if (ctx.settled) {
+			activeDrag = null;
+			rotateHandleOverride = null;
+			dragInFlight = false;
+			driver.setDragPanEnabled(true);
+			return;
+		}
+		const { fsm, preDragPoints } = activeDrag;
+		activeDrag = null;
+		rotateHandleOverride = null;
+		driver.setDragPanEnabled(true);
+		const next = fsm.end(pixel);
+		replaceWorkingPoints(preDragPoints);
+		commitGesture(next);
+	};
+	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;
+		pickPreview = void 0;
+		pickHandles = void 0;
+		pickGraphics = void 0;
+		if (ctx.settled) return;
+		if (!closeOnClickAway) return;
+		if (suppressClickAway) {
+			suppressClickAway = false;
+			return;
+		}
+		if (localPreview || localHandles) return;
+		if (localGraphics && localGraphics.id !== measure.id) {
+			ctx.commit(rebuildRendered);
+			if (onClickAwayGraphicsPick) onClickAwayGraphicsPick(localGraphics);
+			return;
+		}
+		ctx.commit(rebuildRendered);
+	};
+	const core = runInteraction({
+		adapter,
+		signal,
+		layers: [
+			previewLayer,
+			guideLayer,
+			handlesLayer
+		],
+		onViewChange: rescaleOnViewChange,
+		onSettled,
+		attach(c) {
+			ctx = c;
+			driver = adapter.createEditPointerDriver();
+			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) {
+					driver.setDragPanEnabled(true);
+					activeDrag = null;
+					rotateHandleOverride = null;
+					dragInFlight = false;
+				}
+				driver.dispose();
+			}, wasOnGraphicsLayer ? restoreOriginalToGraphics : void 0);
+			renderPreview();
+			renderHandlesLayer();
+			recomputeDirty();
+			if (onSession) onSession(session);
+		}
+	});
+	return {
+		promise: core.promise,
+		get settled() {
+			return core.settled;
+		},
+		measureId: measure.id,
+		abort(reason, cause) {
+			core.abort(reason, cause);
+		},
+		notifyExternalMeasure(next) {
+			if (core.settled) return;
+			if (stylesEqual(currentStyle, next.style)) return;
+			currentStyle = next.style;
+			renderPreview();
+		}
+	};
+}
+function normaliseModes(modes) {
+	if (!modes || modes.length === 0) return ["reshape"];
+	for (const m of modes) {
+		if (m === "scale") throw new TypeError(`td.edit: edit mode "scale" is reserved and not yet implemented`);
+		if (!ALLOWED_EDIT_MODES.has(m)) throw new TypeError(`td.edit: unknown edit mode "${String(m)}"`);
+	}
+	if (modes.includes("delete")) return ["delete"];
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const m of modes) if (!seen.has(m)) {
+		seen.add(m);
+		out.push(m);
+	}
+	return out;
+}
+function stylesEqual(a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+	for (const key of keys) if (a[key] !== b[key]) return false;
+	return true;
+}
+function pointsEqualWithinTolerance(a, b, epsilon) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) {
+		const pa = a[i];
+		const pb = b[i];
+		if (pa.length !== pb.length) return false;
+		for (let k = 0; k < pa.length; k++) if (Math.abs((pa[k] ?? 0) - (pb[k] ?? 0)) > epsilon) return false;
+	}
+	return true;
+}
+//#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);
+	}
+};
+//#endregion
+//#region src/tactical-draw/tactical-draw.ts
+/**
+* `TacticalDraw` façade — slice #6 (issue #45).
+*
+* Provides the constructor + lifecycle + `render(measures)` reconcile path.
+* Interactive draw and edit live in later slices; the shape is in place so
+* the surface is stable.
+*/
+var TacticalDraw = class {
+	adapter;
+	graphicsLayer;
+	previewLayer;
+	guideLayer;
+	handlesLayer;
+	ownedLayers;
+	graphicsStyle;
+	defaultInteractionStyle;
+	generateId;
+	destroyed = false;
+	hasRendered = false;
+	activeInteraction = new ActiveInteractionTracker();
+	/**
+	* Tracked alongside `activeInteraction` whenever the interaction is an edit. The
+	* `render()` path needs the edited measure's id (to exclude it from
+	* reconcile) and a hook to surface external style changes — both live on
+	* `EditHandle` so the controller stays the single owner of edit state.
+	*/
+	activeEdit = null;
+	/**
+	* Host pick handlers registered via `td.onPick` / `td.onMeasurePick`. The
+	* façade subscribes once to `adapter.onPick` per layer and routes events
+	* through this map so that close-then-pick ordering during an active edit can
+	* be enforced (issue #52).
+	*/
+	hostPickHandlers = /* @__PURE__ */ new Map();
+	adapterPickUnsubs = /* @__PURE__ */ new Map();
+	/**
+	* Captured graphics-layer pick that arrived during an active edit on a
+	* *different* measure. The edit controller closes the active session and
+	* then asks the façade to re-dispatch this pick to host handlers so that
+	* `td.edit(otherMeasure)` from a host pick handler runs as a fresh edit,
+	* not as a programmatic preemption.
+	*/
+	deferredGraphicsPick = null;
+	idCounter = 0;
+	editCounter = 0;
+	/**
+	* Snapshot of the host's last `render()` argument. The edit slice uses it
+	* to recompute the graphics-layer state during a lift / restore — the
+	* façade owns the policy because controllers shouldn't need to know the
+	* surrounding collection state.
+	*/
+	lastRenderedMeasures = [];
+	constructor(adapter, options) {
+		this.adapter = adapter;
+		this.graphicsStyle = resolveStyleHints(BUILT_IN_GRAPHICS_STYLE, options?.graphicsStyle, void 0);
+		this.defaultInteractionStyle = options?.interactionStyle;
+		this.generateId = options?.generateId ?? (() => `td-${++this.idCounter}`);
+		const owned = /* @__PURE__ */ new Set();
+		const provided = options?.layers ?? {};
+		this.graphicsLayer = resolveSlot(adapter, provided.graphics, owned);
+		this.previewLayer = resolveSlot(adapter, provided.preview, owned);
+		this.guideLayer = resolveSlot(adapter, provided.guide, owned);
+		this.handlesLayer = resolveSlot(adapter, provided.handles, owned);
+		this.ownedLayers = owned;
+		const graphicsLayerStyle = styleToStyleOptions(this.graphicsStyle);
+		this.adapter.setLayerStyle(this.graphicsLayer, graphicsLayerStyle);
+		this.adapter.setLayerStyle(this.previewLayer, graphicsLayerStyle);
+		this.adapter.setLayerStyle(this.guideLayer, guideToStyleOptions(this.baseGuideStyle()));
+		this.adapter.onViewChange(this.handleViewChange);
+	}
+	/**
+	* Render `measures` into features and write them to the graphics layer.
+	* Routes every measure through [[renderMeasureForAdapter]] so pixel sizing is
+	* resolved against the live map. Callers own any edit-exclusion policy — see
+	* `render()` (excludes the edited measure, owned by the preview layer) versus
+	* `restoreOriginalToGraphics` (no exclusion, the edit is ending).
+	*/
+	renderMeasuresToGraphics(measures) {
+		const features = [];
+		const renderOpts = { graphicsStyle: this.graphicsStyle };
+		for (const m of measures) {
+			const render = renderMeasureForAdapter(this.adapter, m, renderOpts);
+			for (const f of render.features) features.push(f);
+		}
+		this.adapter.updateLayerFeatures(this.graphicsLayer, features);
+	}
+	/**
+	* Re-render the graphics layer on a view (zoom) change so pixel-denominated
+	* measures rescale live. Skipped entirely when nothing rendered carries a
+	* resolution-dependent size — meter geometry is zoom-independent, so a rebuild
+	* would be wasted layer writes. During an active edit the edited measure lives
+	* on the preview layer (lifted from graphics), so it is excluded here exactly
+	* as in `render()`; the preview's own view-change subscription rescales it.
+	*/
+	handleViewChange = () => {
+		if (this.destroyed || !this.hasRendered) return;
+		const editedId = this.activeEdit?.measureId;
+		const visible = editedId !== void 0 ? this.lastRenderedMeasures.filter((m) => m.id !== editedId) : this.lastRenderedMeasures;
+		if (!visible.some(measureUsesAdapterResolution)) return;
+		this.renderMeasuresToGraphics(visible);
+	};
+	/**
+	* Reconcile the graphics layer against the authoritative list of measures.
+	* Idempotent. Throws synchronously on duplicate measure ids *before*
+	* mutating any layer. An empty list before any prior render is a no-op.
+	*
+	* Cross-layer semantics with an active edit (issue #51):
+	*  - The measure under edit is **excluded** from the reconcile pass — the
+	*    preview layer owns its working copy and the lift on the graphics layer
+	*    must stay in place.
+	*  - If the edited measure is absent from `measures`, the pending `edit`
+	*    promise rejects on the **next microtask** with reason `"removed"`.
+	*    `render` itself returns normally so host collection ops stay synchronous.
+	*  - If the edited measure is present and its `style` changed, the preview
+	*    picks up the new style on this render. `controlPoints` changes on the
+	*    edited measure are routed nowhere — the user's in-flight drag is never
+	*    yanked out from under them.
+	*
+	* Cross-layer semantics with an active draw: `render` only touches the
+	* graphics layer, so the draw's preview is undisturbed.
+	*
+	* Reentrancy: calling `td.render(...)` from inside `EditSession.onChange` is
+	* safe — `render` never re-enters the active edit or its preview / handle
+	* layers (the only edit-facing side effect, `notifyExternalMeasure`, is a
+	* pure style replay).
+	*/
+	render(measures) {
+		this.assertAlive();
+		const seen = /* @__PURE__ */ new Set();
+		for (const m of measures) {
+			if (seen.has(m.id)) throw new Error(`TacticalDraw.render: duplicate control measure id "${m.id}"`);
+			seen.add(m.id);
+		}
+		const editedId = this.activeEdit?.measureId;
+		let externalEdited;
+		let editedRemoved = false;
+		if (editedId !== void 0) {
+			externalEdited = measures.find((m) => m.id === editedId);
+			editedRemoved = externalEdited === void 0;
+		}
+		const visible = editedId !== void 0 ? measures.filter((m) => m.id !== editedId) : measures;
+		if (!(visible.length === 0 && !this.hasRendered)) {
+			this.renderMeasuresToGraphics(visible);
+			this.hasRendered = true;
+		}
+		this.lastRenderedMeasures = measures.slice();
+		if (externalEdited && this.activeEdit) this.activeEdit.notifyExternalMeasure(externalEdited);
+		if (editedRemoved && this.activeEdit) {
+			const editHandle = this.activeEdit;
+			queueMicrotask(() => {
+				editHandle.abort("removed");
+			});
+		}
+	}
+	/**
+	* Nested-call guard + preempt, shared by `draw` and `edit`. Returns a
+	* pre-rejected promise when called re-entrantly from inside another
+	* interaction's `onSession` (the outer is still mid-construction, so the
+	* nested one is preempted synchronously — #52). Otherwise preempts whichever
+	* draw / edit is in flight and returns `null`, signalling the caller to
+	* proceed. One interaction at a time per PRD #40.
+	*/
+	guardAndPreempt() {
+		if (this.activeInteraction.isStarting) {
+			const rejected = Promise.reject(new TacticalDrawAbortError("preempted"));
+			rejected.catch(() => {});
+			return rejected;
+		}
+		if (this.activeInteraction.isActive) {
+			this.activeEdit = null;
+			this.activeInteraction.cancel("preempted");
+		}
+		return null;
+	}
+	/**
+	* Reserve the single interaction slot around `create`, shared by `draw` and
+	* `edit`. Reserves the active tracker (and `activeEdit` for edits) synchronously so
+	* `onSettled` callbacks see a coherent state; the handle's settle path calls
+	* the wrapped `onSettled` which clears the slot for us, avoiding the
+	* "promise.then(clearActive)" microtask gap that left the interaction set across
+	* re-dispatched pick handlers. The backstop `.then` covers a controller that
+	* settled synchronously (already-aborted signal returns a pre-settled handle),
+	* whose `onSettled` fired before `active` was assigned. `extraSettle` runs the
+	* caller's own teardown (guide-style revert, dbl-click-zoom re-enable).
+	*/
+	runWithSlot(create, editHandleOf, extraSettle) {
+		let handle;
+		let editHandle = null;
+		let settledDuringCreate = false;
+		const clearSlot = () => {
+			if (handle) {
+				this.activeInteraction.clear(handle);
+				if (editHandle && this.activeEdit === editHandle) this.activeEdit = null;
+			} else {
+				settledDuringCreate = true;
+				this.activeInteraction.clear();
+			}
+		};
+		const onSettled = () => {
+			clearSlot();
+			if (extraSettle) extraSettle();
+		};
+		this.activeInteraction.begin();
+		try {
+			handle = create(onSettled);
+			editHandle = editHandleOf ? editHandleOf(handle) : null;
+		} catch (error) {
+			this.activeInteraction.clear();
+			if (!settledDuringCreate && extraSettle) extraSettle();
+			throw error;
+		}
+		if (!settledDuringCreate) {
+			this.activeInteraction.set(handle);
+			if (editHandle && !handle.settled) this.activeEdit = editHandle;
+		}
+		handle.promise.then(clearSlot, clearSlot);
+		return handle.promise;
+	}
+	/**
+	* Wrap a host `onSession` callback so the session is recorded on the tracker
+	* (exposing it via `activeSession`) before the host's own handler runs.
+	*/
+	trackSession(hostOnSession) {
+		return (session) => {
+			this.activeInteraction.setSession(session);
+			hostOnSession?.(session);
+		};
+	}
+	/**
+	* Start an interactive draw. Fixed-length kinds commit automatically on the
+	* last required click. Variable-length kinds surface a `DrawSession` via
+	* `opts.onSession` and commit on `session.commit()`, `dblclick`, or a second
+	* click on the last added control point. All paths reject with
+	* `TacticalDrawAbortError` on signal / Escape / destroy / `session.abort()`.
+	*/
+	draw(draft, options) {
+		this.assertAlive();
+		const kind = draft.kind;
+		const preempt = this.guardAndPreempt();
+		if (preempt) return preempt;
+		const fixedLength = isFixedLength(getControlMeasureMetadata(kind));
+		const suppressDblclickZoom = !fixedLength && !options?.signal?.aborted;
+		if (suppressDblclickZoom) this.adapter.setDoubleClickZoomEnabled(false);
+		const revertGuideStyle = this.applyGuideStyle(options?.interactionStyle?.guide);
+		const extraSettle = () => {
+			revertGuideStyle();
+			if (suppressDblclickZoom) setTimeout(() => {
+				if (this.destroyed) return;
+				this.adapter.setDoubleClickZoomEnabled(true);
+			}, 0);
+		};
+		return this.runWithSlot((onSettled) => fixedLength ? runFixedLengthDraw({
+			adapter: this.adapter,
+			kind,
+			previewLayer: this.previewLayer,
+			graphicsStyle: this.graphicsStyle,
+			generateId: () => draft.id ?? this.generateId(),
+			signal: options?.signal,
+			measureOptions: draft.options,
+			measureStyle: draft.style,
+			measureProperties: draft.properties,
+			guide: options?.guide,
+			sizeAnchor: options?.sizeAnchor,
+			onSettled
+		}) : runVariableLengthDraw({
+			adapter: this.adapter,
+			kind,
+			previewLayer: this.previewLayer,
+			guideLayer: this.guideLayer,
+			graphicsStyle: this.graphicsStyle,
+			generateId: () => draft.id ?? this.generateId(),
+			signal: options?.signal,
+			onSession: this.trackSession(options?.onSession),
+			seed: draft.controlPoints,
+			measureOptions: draft.options,
+			measureStyle: draft.style,
+			measureProperties: draft.properties,
+			guide: options?.guide,
+			sizeAnchor: options?.sizeAnchor,
+			onSettled
+		}), null, extraSettle);
+	}
+	/**
+	* Start an interactive edit on a single control measure. Returns a Promise
+	* that resolves with a `ControlMeasureSnapshot` of the working state on
+	* `session.close()` and rejects with `TacticalDrawAbortError` on
+	* signal / Escape / destroy / preempt / `session.abort()`.
+	*
+	* Default click-away (`closeOnClickAway: true`) closes the edit on a click
+	* outside the preview / handle features. Hosts that own close policy pass
+	* `false`.
+	*/
+	edit(measure, options) {
+		this.assertAlive();
+		if (options?.modes) {
+			for (const m of options.modes) if (m === "scale") throw new TypeError(`td.edit: edit mode "scale" is reserved and not yet implemented`);
+		}
+		const preempt = this.guardAndPreempt();
+		if (preempt) return preempt;
+		const wasOnGraphicsLayer = this.lastRenderedMeasures.some((m) => m.id === measure.id);
+		const restoreOriginalToGraphics = () => {
+			this.renderMeasuresToGraphics(this.lastRenderedMeasures);
+		};
+		const handleIdPrefix = `__td_edit_${++this.editCounter}__`;
+		const mergedInteractionStyle = this.resolveInteractionStyle(options?.interactionStyle);
+		const revertGuideStyle = this.applyGuideStyle(options?.interactionStyle?.guide);
+		const onClickAwayGraphicsPick = (event) => {
+			this.dispatchHostPick(this.graphicsLayer, event);
+		};
+		return this.runWithSlot((onSettled) => runEdit({
+			adapter: this.adapter,
+			measure,
+			graphicsLayer: this.graphicsLayer,
+			previewLayer: this.previewLayer,
+			guideLayer: this.guideLayer,
+			handlesLayer: this.handlesLayer,
+			graphicsStyle: this.graphicsStyle,
+			signal: options?.signal,
+			closeOnClickAway: options?.closeOnClickAway,
+			modes: options?.modes,
+			interactionStyle: mergedInteractionStyle,
+			onSession: this.trackSession(options?.onSession),
+			handleIdPrefix,
+			guide: options?.guide,
+			sizeAnchor: options?.sizeAnchor,
+			restoreOriginalToGraphics,
+			wasOnGraphicsLayer,
+			onSettled,
+			onClickAwayGraphicsPick
+		}), (handle) => handle, revertGuideStyle);
+	}
+	/**
+	* Subscribe to picks on committed control measures.
+	*
+	* The graphics layer is pre-bound, and `event.id` is the originating control
+	* measure id. Events retain the same close-then-pick ordering as
+	* {@link onPick}: when another measure is picked during an active edit, the
+	* current edit closes before the handler runs.
+	*
+	* Returns an idempotent unsubscribe function. An optional `signal` removes
+	* the handler when aborted.
+	*/
+	onMeasurePick(handler, opts) {
+		this.assertAlive();
+		return this.onPick(this.graphicsLayer, handler, opts);
+	}
+	/**
+	* Subscribe to pick events on `layerId`. Routed through the façade so the
+	* close-then-pick contract (issue #52) is observable: when an active edit
+	* sees a click on a *different* graphics-layer measure, the edit closes
+	* first and only then are pick events delivered to host handlers — letting
+	* a host `td.edit(other)` from a pick handler run as a fresh edit instead
+	* of a programmatic preemption.
+	*
+	* Returns an unsubscribe function. Optional `signal` mirrors `adapter.onPick`.
+	*/
+	onPick(layerId, handler, opts) {
+		this.assertAlive();
+		if (opts?.signal?.aborted) return () => {};
+		let handlers = this.hostPickHandlers.get(layerId);
+		if (!handlers) {
+			handlers = /* @__PURE__ */ new Set();
+			this.hostPickHandlers.set(layerId, handlers);
+			const unsub = this.adapter.onPick(layerId, (event) => {
+				this.routePick(layerId, event);
+			});
+			this.adapterPickUnsubs.set(layerId, unsub);
+		}
+		handlers.add(handler);
+		let removed = false;
+		const remove = () => {
+			if (removed) return;
+			removed = true;
+			const current = this.hostPickHandlers.get(layerId);
+			if (current) current.delete(handler);
+		};
+		opts?.signal?.addEventListener("abort", remove, { once: true });
+		return remove;
+	}
+	/**
+	* Abort the in-flight draw or edit. The default `"session"` reason matches
+	* `DrawSession.abort()` / `EditSession.abort()`.
+	*
+	* Returns `true` when an interaction was active, otherwise `false`.
+	*/
+	cancel(reason = "session") {
+		this.assertAlive();
+		return this.activeInteraction.cancel(reason);
+	}
+	/**
+	* The live variable-draw or edit session, or `null` while idle and during
+	* fixed-length draws. Safe to read after `destroy()`.
+	*/
+	get activeSession() {
+		return this.activeInteraction.session;
+	}
+	/**
+	* Tear down the façade. Releases only layer slots the façade created; host
+	* supplied layer ids are left untouched. Safe to call multiple times. After
+	* the first call every public method throws `TacticalDrawDestroyedError`.
+	*/
+	destroy() {
+		if (this.destroyed) return;
+		this.destroyed = true;
+		if (this.activeInteraction.isActive) {
+			this.activeEdit = null;
+			this.activeInteraction.cancel("destroyed");
+		} else this.activeInteraction.clear();
+		this.adapter.offViewChange(this.handleViewChange);
+		for (const unsub of this.adapterPickUnsubs.values()) unsub();
+		this.adapterPickUnsubs.clear();
+		this.hostPickHandlers.clear();
+		this.deferredGraphicsPick = null;
+		for (const id of this.ownedLayers) this.adapter.removeLayer(id);
+		this.ownedLayers.clear();
+	}
+	/**
+	* Decide whether to deliver `event` to host pick handlers immediately or
+	* defer it until after the active edit closes. The "defer" branch is the
+	* close-then-pick path: the edit controller's click handler will close the
+	* session and then invoke `dispatchHostPick(graphicsLayer, event)` via
+	* `onClickAwayGraphicsPick` to redeliver — guaranteeing `td.edit(other)`
+	* from a host pick handler observes a settled session.
+	*/
+	routePick(layerId, event) {
+		if (layerId === this.graphicsLayer && this.activeEdit !== null && this.activeEdit.measureId !== event.id) {
+			this.deferredGraphicsPick = event;
+			return;
+		}
+		this.dispatchHostPick(layerId, event);
+	}
+	dispatchHostPick(layerId, event) {
+		this.deferredGraphicsPick = null;
+		const handlers = this.hostPickHandlers.get(layerId);
+		if (!handlers || handlers.size === 0) return;
+		for (const handler of [...handlers]) handler(event);
+	}
+	/** @internal — exposed for tests and future controllers. */
+	get layerIds() {
+		return {
+			graphics: this.graphicsLayer,
+			preview: this.previewLayer,
+			guide: this.guideLayer,
+			handles: this.handlesLayer
+		};
+	}
+	/**
+	* Apply the resolved guide-slot style for an interaction and return a
+	* revert closure to re-apply the base (built-in + façade) style on settle.
+	* Per-call overrides are scoped to a single interaction (ADR-0004/0006).
+	*/
+	applyGuideStyle(perCall) {
+		if (!perCall) return () => {};
+		const merged = mergeSlot(this.baseGuideStyle(), perCall) ?? {};
+		this.adapter.setLayerStyle(this.guideLayer, guideToStyleOptions(merged));
+		return () => {
+			if (this.destroyed) return;
+			this.adapter.setLayerStyle(this.guideLayer, guideToStyleOptions(this.baseGuideStyle()));
+		};
+	}
+	baseGuideStyle() {
+		return mergeSlot(BUILT_IN_INTERACTION_STYLE.guide, this.defaultInteractionStyle?.guide);
+	}
+	/**
+	* Resolve handle slots across built-in → façade → per-call with per-slot,
+	* per-property shallow merge. Explicit `undefined` at a higher-priority
+	* layer unsets the corresponding lower-priority field (ADR-0006).
+	*
+	* Returns `undefined` only when no slot would carry any value — keeps the
+	* downstream "no style on the feature" path intact for tests that assert
+	* the absence of `properties.style`.
+	*/
+	resolveInteractionStyle(perCall) {
+		const out = {};
+		for (const slot of HANDLE_SLOTS) {
+			const merged = mergeSlot(mergeSlot(BUILT_IN_INTERACTION_STYLE[slot], this.defaultInteractionStyle?.[slot]), perCall?.[slot]);
+			if (merged) out[slot] = merged;
+		}
+		return out;
+	}
+	assertAlive() {
+		if (this.destroyed) throw new TacticalDrawDestroyedError();
+	}
+};
+/**
+* Built-in default graphics style. Ensures OL / MapLibre / Leaflet render
+* identically when neither host nor measure supplies a style — without it,
+* each engine falls through to its own native (and different) vector default.
+*/
+const BUILT_IN_GRAPHICS_STYLE = {
+	color: "#000000",
+	strokeWidth: 2
+};
+/**
+* Built-in defaults for the interaction-affordance slots. The translate grip
+* sits on the centroid pivot and the rotate grip just outside the shape; their
+* distinct fills (blue / green) set them apart from the white vertex and gray
+* midpoint handles. See ADR-0006.
+*/
+const BUILT_IN_INTERACTION_STYLE = {
+	guide: {
+		strokeColor: "#6b7280",
+		strokeWidth: 1,
+		strokeDash: [6, 4]
+	},
+	vertexHandle: {
+		pointRadius: 6,
+		fillColor: "#ffffff",
+		strokeColor: "#1f2937",
+		strokeWidth: 2
+	},
+	midpointHandle: {
+		pointRadius: 4,
+		fillColor: "#d1d5db",
+		strokeColor: "#6b7280",
+		strokeWidth: 1.5
+	},
+	translateHandle: {
+		pointRadius: 7,
+		fillColor: "#2563eb",
+		strokeColor: "#ffffff"
+	},
+	rotateHandle: {
+		pointRadius: 7,
+		fillColor: "#16a34a",
+		strokeColor: "#ffffff"
+	}
+};
+const HANDLE_SLOTS = [
+	"vertexHandle",
+	"midpointHandle",
+	"translateHandle",
+	"rotateHandle"
+];
+/**
+* Per-slot, per-property shallow merge with explicit-undefined-unsets
+* semantics. Either side may be undefined; the result is undefined only when
+* both are.
+*/
+function mergeSlot(base, override) {
+	if (!base && !override) return void 0;
+	if (!override) return { ...base };
+	if (!base) {
+		const out = {};
+		for (const [k, v] of Object.entries(override)) if (v !== void 0) out[k] = v;
+		return out;
+	}
+	const out = { ...base };
+	for (const [k, v] of Object.entries(override)) if (v === void 0) delete out[k];
+	else out[k] = v;
+	return out;
+}
+function styleToStyleOptions(style) {
+	const out = {};
+	const strokeColor = style.strokeColor ?? style.color;
+	if (strokeColor !== void 0) out.strokeColor = strokeColor;
+	if (style.strokeWidth !== void 0) out.strokeWidth = style.strokeWidth;
+	if (style.strokeDash !== void 0) out.strokeDash = [...style.strokeDash];
+	if (style.fillColor !== void 0) out.fillColor = style.fillColor;
+	out.text = { labelProperty: "text" };
+	return out;
+}
+function guideToStyleOptions(style) {
+	const out = {};
+	if (style.strokeColor !== void 0) out.strokeColor = style.strokeColor;
+	if (style.strokeWidth !== void 0) out.strokeWidth = style.strokeWidth;
+	if (style.strokeDash !== void 0) out.strokeDash = [...style.strokeDash];
+	return out;
+}
+function resolveSlot(adapter, supplied, owned) {
+	if (supplied !== void 0) return supplied;
+	const id = adapter.addVectorLayer();
+	owned.add(id);
+	return id;
+}
+//#endregion
+export { BaseMapAdapter, PointerCallbackHub, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, TacticalDrawDestroyedError, bindAbortable, coerceHandleStyle, combineWithHostSignal, getSizeAnchor, hitTestFeature, ignoreAbort, isTacticalDrawAbortError, pickHitTolerance, tryControlMeasureIdFromFeature };