@orbat-mapper/tactical-draw 0.8.1 → 0.9.0

package/dist/index.mjs

@@ -485,6 +485,7 @@ var BaseMapAdapter = class {
 		if (!this.layers.has(layerId)) return;
 		const nextGroups = groups.map((group) => ({
 			id: group.id,
+			...group.pin ? { pin: group.pin } : {},
 			features: [...group.features],
 			iconResources: [...group.iconResources],
 			...group.imageOverlays ? { imageOverlays: [...group.imageOverlays] } : {},
@@ -655,8 +656,9 @@ const DEFAULT_TEXT_SIZE_MAX_PIXELS = 24;
 * Within the band the text scales with its graphic; past either edge it pins
 * to the bound, so zooming out never yields unreadable smudges and zooming in
 * never yields screen-covering text. Shared by the adapters that resolve text
-* size in code (OpenLayers, Leaflet); the MapLibre adapter evaluates the same
-* clamp inside its per-zoom-stop style expression.
+* size in code (OpenLayers, Leaflet); the MapLibre adapter reproduces the same
+* clamp as a native camera expression whose stops are the two clamp
+* boundaries, so it stays exact at fractional zooms.
 */
 function resolveGroundTextSizePixels(textSizeMeters, resolution, text) {
 	const min = text?.textSizeMinPixels ?? 8;
@@ -827,33 +829,791 @@ var PointerCallbackHub = class {
 	}
 };
 //#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
+	};
+}
+//#endregion
+//#region src/tactical-draw/session-events.ts
+/**
+* Map a settle-time error to its `SettleReason`: a `TacticalDrawAbortError`
+* replays its own `reason` verbatim; anything else (a `produce` throw from
+* `ctx.commit`) is the commit-time snapshot build failing, reported as
+* `"error"`.
+*/
+function settleReasonFromError(error) {
+	return isTacticalDrawAbortError(error) ? error.reason : "error";
+}
+/**
+* Fan a `runInteraction` settlement out to a session's commit + settle
+* emitters — the shared body of the `onSettled` wrappers in the edit and draw
+* controllers (transform emits its close-path settle from `commitClose`
+* instead, so it does not use this). On the commit path, emit the snapshot
+* then the `"close"` settle in a try/finally so a throwing `onCommit` listener
+* cannot starve the settle emission; on the reject path, emit the settle with
+* the reason derived from the error. Callers run their own facade
+* slot-clearing (`onSettled()`) before this so a listener observes a cleared
+* `td.activeSession`.
+*/
+function settleFromInteraction(settlement, commitEmitter, settleEmitter) {
+	if (settlement.status === "committed") try {
+		commitEmitter.emit(settlement.value);
+	} finally {
+		settleEmitter.emit("close");
+	}
+	else settleEmitter.emit(settleReasonFromError(settlement.error));
+}
+/**
+* Subscribe/emit machinery shared by `TransformSession.onSettled`,
+* `EditSession.onSettled`, and `DrawSession.onSettled` (#191 / #194 / #197):
+* a settle-exactly-once latch, synchronous emission to every listener with
+* exception collection (single rethrow, `AggregateError` otherwise when more
+* than one listener throws), and a late-registration path that delivers the
+* latched reason on a microtask exactly once when a handler subscribes after
+* the session has already settled.
+*
+* `listenerErrorsMessage` becomes the `AggregateError` message — pass a
+* session-specific string (e.g. `"EditSession.onSettled listener errors"`).
+*/
+function createSettleEmitter(listenerErrorsMessage) {
+	const listeners = /* @__PURE__ */ new Set();
+	/** Set exactly once, by `emit` — also the "has settled" latch and the reason replayed to late registrations. */
+	let settledReason = null;
+	return {
+		emit(reason) {
+			if (settledReason !== null) return;
+			settledReason = reason;
+			const current = [...listeners];
+			listeners.clear();
+			const errors = [];
+			for (const listener of current) try {
+				listener(reason);
+			} catch (err) {
+				errors.push(err);
+			}
+			if (errors.length === 1) throw errors[0];
+			if (errors.length > 1) throw new AggregateError(errors, listenerErrorsMessage);
+		},
+		register(handler) {
+			if (settledReason !== null) {
+				const reason = settledReason;
+				let cancelled = false;
+				queueMicrotask(() => {
+					if (!cancelled) handler(reason);
+				});
+				return () => {
+					cancelled = true;
+				};
+			}
+			listeners.add(handler);
+			return () => {
+				listeners.delete(handler);
+			};
+		}
+	};
+}
+/**
+* The deferred reject/close/abort change-emit protocol (issue #49 contract)
+* shared by `EditSession.onChange`, `TransformSession.onChange`, and
+* `GraphicEditSession.onChange`. Owns the listener `Set` (like
+* `createCommitEmitter.register`) and, per emission:
+*
+*  - builds one event by spreading the controller-supplied `payload` plus the
+*    injected `reject()` / `close()` / `abort()` recorders, and delivers that
+*    same instance to every listener in registration order;
+*  - collects listener exceptions (single → rethrow as-is, multiple →
+*    `AggregateError` with `listenerErrorsMessage`);
+*  - applies decisions after all listeners run, priority `abort` > `close` >
+*    `reject`, with `reject` further gated on `!isSettled()` and
+*    `stillApplicable()`;
+*  - runs `onAccepted` (when the change survived) *before* rethrowing listener
+*    errors — unifying every controller on edit's history-before-throw ordering
+*    — and returns whether the change was accepted.
+*
+* Registration-time `isSettled()` guards stay in the controllers' `onChange`
+* wrappers, mirroring `createCommitEmitter`.
+*/
+function createChangeEmitter(options) {
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		register(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		emit(payload, emission) {
+			if (options.isSettled()) return false;
+			let rejectRequested = false;
+			let closeRequested = false;
+			let abortRequested = false;
+			const event = {
+				...payload,
+				reject() {
+					rejectRequested = true;
+				},
+				close() {
+					closeRequested = true;
+				},
+				abort() {
+					abortRequested = true;
+				}
+			};
+			const errors = [];
+			for (const listener of [...listeners]) try {
+				listener(event);
+			} catch (err) {
+				errors.push(err);
+			}
+			const applicable = emission.stillApplicable?.() ?? true;
+			if (abortRequested) options.abort();
+			else if (closeRequested) options.close();
+			else if (rejectRequested && !options.isSettled() && applicable) emission.rollback();
+			const accepted = !options.isSettled() && !rejectRequested && applicable;
+			if (accepted) emission.onAccepted?.();
+			if (errors.length === 1) throw errors[0];
+			if (errors.length > 1) throw new AggregateError(errors, options.listenerErrorsMessage);
+			return accepted;
+		}
+	};
+}
+/**
+* Channel-neutral subscribe/emit machinery: a listener set with synchronous,
+* exception-collecting emission (single rethrow, `AggregateError` otherwise).
+* Named for its original `onCommit` channel (`TransformSession` /
+* `EditSession` / `DrawSession`), it also carries the `onTransientChange`
+* streams and the fixed/variable draw controllers' `onChange` — any
+* multi-emit channel with no latch. Unlike `createSettleEmitter`, `emit` may
+* be called more than
+* once — a transform's `setGraphics` can commit several removal batches before
+* the close batch — and there is no latch or late-registration path:
+* registration-time `ctx.settled` guards stay in the controllers, mirroring
+* `onChange`.
+*/
+function createCommitEmitter(listenerErrorsMessage) {
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		emit(value) {
+			const current = [...listeners];
+			const errors = [];
+			for (const listener of current) try {
+				listener(value);
+			} catch (err) {
+				errors.push(err);
+			}
+			if (errors.length === 1) throw errors[0];
+			if (errors.length > 1) throw new AggregateError(errors, listenerErrorsMessage);
+		},
+		register(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+//#endregion
+//#region src/pin-presentation.ts
+function validateOverride(patch) {
+	for (const key of ["mode", "occlusion"]) if (Object.hasOwn(patch, key)) throw new TypeError(`Pin setting ${key} is view-wide only`);
+}
+const DEFAULT_PIN_PRESENTATION = Object.freeze({
+	enabled: false,
+	mode: "screen",
+	liftPixels: 72,
+	heightMeters: 250,
+	sizePixels: 32,
+	occlusion: "none",
+	stem: Object.freeze({
+		color: "#172033",
+		width: 2,
+		opacity: 1
+	}),
+	dot: Object.freeze({
+		color: "#172033",
+		radius: 3,
+		opacity: 1
+	}),
+	halo: Object.freeze({
+		color: "#ffffff",
+		width: 1.5,
+		opacity: 1
+	}),
+	symbolHalo: Object.freeze({
+		color: "#ffffff",
+		width: 2,
+		opacity: .8
+	}),
+	plate: Object.freeze({
+		enabled: false,
+		color: "#ffffff",
+		borderColor: "#64748b",
+		borderWidth: 1,
+		padding: 4,
+		radius: 4,
+		opacity: .95
+	})
+});
+const sections = [
+	"stem",
+	"dot",
+	"halo",
+	"symbolHalo",
+	"plate"
+];
+/**
+* Whether `value` is an acceptable number for the pin setting named `key`.
+* Exported so a host's input handling can reject a value with the same rules
+* the store enforces, rather than re-encoding the bounds and drifting from it.
+*/
+function isValidPinNumber(key, value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 && !(key === "sizePixels" && value === 0) && !(key === "opacity" && value > 1);
+}
+/** Hex colors keep validation identical in browsers, workers and document hosts. */
+function validateSection(input, template, path) {
+	for (const [key, value] of Object.entries(input)) {
+		if (value === void 0) continue;
+		if (!Object.hasOwn(template, key)) throw new TypeError(`Unknown pin setting ${path}${key}`);
+		const expected = template[key];
+		if (typeof expected === "number") {
+			if (!isValidPinNumber(key, value)) throw new TypeError(`Invalid pin setting ${path}${key}`);
+		} else if (typeof expected === "boolean") {
+			if (typeof value !== "boolean") throw new TypeError(`Invalid pin setting ${path}${key}`);
+		} else if (key === "mode" || key === "occlusion") {
+			if (!(key === "mode" ? ["screen", "world"] : ["none", "terrain"]).includes(String(value))) throw new TypeError(`Invalid pin setting ${key}`);
+		} else if (typeof expected === "string") {
+			if (typeof value !== "string" || !/^#(?:[\da-f]{3}|[\da-f]{4}|[\da-f]{6}|[\da-f]{8})$/i.test(value)) throw new TypeError(`Pin color ${path}${key} must be a hex color`);
+		} else {
+			if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`Invalid pin setting ${key}`);
+			validateSection(value, expected, `${key}.`);
+		}
+	}
+}
+function resolvePinPresentation(...patches) {
+	const result = structuredClone(DEFAULT_PIN_PRESENTATION);
+	for (const patch of patches) {
+		if (!patch || typeof patch !== "object" || Array.isArray(patch)) throw new TypeError("Invalid pin presentation");
+		validateSection(patch, DEFAULT_PIN_PRESENTATION, "");
+		for (const [key, value] of Object.entries(patch)) {
+			if (value === void 0) continue;
+			if (sections.includes(key)) {
+				const target = result[key];
+				Object.assign(target, Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0)));
+			} else Object.assign(result, { [key]: value });
+		}
+	}
+	return result;
+}
+/** Replacing patches makes omitted override properties inherit again. */
+var PinPresentationStore = class {
+	state = {
+		defaults: {},
+		overrides: {}
+	};
+	emitter = createCommitEmitter("PinPresentationStore.onChange listener errors");
+	getState() {
+		return structuredClone(this.state);
+	}
+	resolve(id) {
+		return resolvePinPresentation(this.state.defaults, Object.hasOwn(this.state.overrides, id) ? this.state.overrides[id] : {});
+	}
+	replace(state) {
+		if (!state || !state.overrides || typeof state.overrides !== "object" || Array.isArray(state.overrides)) throw new TypeError("Invalid pin state");
+		if (!Object.is(state.defaults, this.state.defaults)) {
+			resolvePinPresentation(state.defaults);
+			for (const patch of Object.values(state.overrides)) {
+				validateOverride(patch);
+				resolvePinPresentation(state.defaults, patch);
+			}
+		} else for (const [id, patch] of Object.entries(state.overrides)) if (!Object.is(patch, this.state.overrides[id])) {
+			validateOverride(patch);
+			resolvePinPresentation(state.defaults, patch);
+		}
+		this.state = structuredClone(state);
+		this.emitter.emit(this.getState());
+	}
+	setDefaults(patch) {
+		this.replace({
+			...this.state,
+			defaults: patch
+		});
+	}
+	setOverride(id, patch) {
+		this.replace({
+			...this.state,
+			overrides: {
+				...this.state.overrides,
+				[id]: patch
+			}
+		});
+	}
+	resetOverride(id) {
+		const overrides = { ...this.state.overrides };
+		delete overrides[id];
+		this.replace({
+			...this.state,
+			overrides
+		});
+	}
+	onChange(listener) {
+		return this.emitter.register(listener);
+	}
+};
+//#endregion
 //#region src/point-symbol.ts
 function isPointSymbol(graphic) {
 	return typeof graphic === "object" && graphic !== null && "kind" in graphic && graphic.kind === "point-symbol";
 }
-function clonePointSymbol(symbol) {
-	return structuredClone(symbol);
+function clonePointSymbol(symbol) {
+	return structuredClone(symbol);
+}
+/**
+* Replace a point-symbol size value as a user-driven resize. Ground-size display
+* bounds scale with the value so they continue to constrain zoom changes rather
+* than preventing the resize itself.
+*/
+function resizePointSymbolSize(size, value) {
+	if (size.unit === "pixels") return {
+		value,
+		unit: "pixels"
+	};
+	const scale = value / size.value;
+	if (!Number.isFinite(scale) || scale <= 0) return {
+		...size,
+		value
+	};
+	return {
+		...size,
+		value,
+		...size.minPixels !== void 0 ? { minPixels: size.minPixels * scale } : {},
+		...size.maxPixels !== void 0 ? { maxPixels: size.maxPixels * scale } : {}
+	};
+}
+//#endregion
+//#region src/point-symbol-size.ts
+function effectivePointSymbolPixelSize(symbol, resolution) {
+	if (symbol.size.unit === "pixels") return symbol.size.value;
+	if (resolution === void 0 || resolution <= 0) return symbol.size.value;
+	const px = symbol.size.value / resolution;
+	const { minPixels, maxPixels } = symbol.size;
+	return Math.max(Number.isFinite(minPixels) && minPixels > 0 ? minPixels : 0, Math.min(Number.isFinite(maxPixels) && maxPixels > 0 ? maxPixels : Infinity, px));
+}
+function pointSymbolPixelScale(symbol, render, resolution) {
+	if (!Number.isFinite(render.octagonSize) || render.octagonSize <= 0) throw new TypeError("PointSymbolRender.octagonSize must be a positive finite number");
+	return effectivePointSymbolPixelSize(symbol, resolution) / render.octagonSize;
+}
+//#endregion
+//#region src/tactical-draw/transform-box.ts
+/**
+* The uniform scale factor and rotation delta a box implies relative to a
+* pre-drag box, given the gesture kind. A `body` translate reports neither
+* (1, 0). Consumed both by point symbols (size/rotation) and by Text graphics
+* (folding the delta into rotation/size options); the delta is pivot-
+* independent so either can apply it without knowing the box center.
+*/
+function boxScaleRotation(kind, box, preDragBox) {
+	return {
+		scale: kind === "scale" ? Math.max(box.halfWidth / preDragBox.halfWidth, box.halfHeight / preDragBox.halfHeight) : 1,
+		rotation: kind === "rotate" ? box.angle - preDragBox.angle : 0
+	};
+}
+function rotate(x, y, angle) {
+	const cos = Math.cos(angle);
+	const sin = Math.sin(angle);
+	return [x * cos - y * sin, x * sin + y * cos];
+}
+/**
+* Fit an oriented `TransformBox` around `pixels` at a caller-chosen `angle`.
+* Rotates the points by `-angle` about their centroid, takes the axis-aligned
+* bounding box in that de-rotated frame, then re-expresses the result as an
+* oriented box at `angle` — so the box always has exactly the requested tilt,
+* sized to just contain the (de-rotated) points. Half-dimensions are floored
+* at `MIN_HALF_SIZE_PX` so a degenerate selection still yields a drawable,
+* pickable box. Returns `null` for an empty list — there is nothing to fit.
+*
+* `padding` (pixels, default `0`) is added to `halfWidth`/`halfHeight` *after*
+* the `MIN_HALF_SIZE_PX` floor, on every side, without moving `center` — the
+* `InteractionStyle.boxPadding` knob (ADR-0017) so the box doesn't tightly hug
+* the rendered geometry. Everything downstream that reads a fitted box
+* (`boxCorners`, `rotateGripPixel`, `pointInBox`, `pickBoxHandle`) derives from
+* `halfWidth`/`halfHeight` alone, so the padding flows through to corner
+* placement, the rotate grip, and picking automatically — no other function
+* needs to know about it.
+*/
+function fitTransformBox(pixels, angle, padding = 0) {
+	if (pixels.length === 0) return null;
+	let cx = 0;
+	let cy = 0;
+	for (const p of pixels) {
+		cx += p[0];
+		cy += p[1];
+	}
+	cx /= pixels.length;
+	cy /= pixels.length;
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	for (const p of pixels) {
+		const [rx, ry] = rotate(p[0] - cx, p[1] - cy, -angle);
+		if (rx < minX) minX = rx;
+		if (rx > maxX) maxX = rx;
+		if (ry < minY) minY = ry;
+		if (ry > maxY) maxY = ry;
+	}
+	const localCenterX = (minX + maxX) / 2;
+	const localCenterY = (minY + maxY) / 2;
+	const halfWidth = Math.max((maxX - minX) / 2, 1) + padding;
+	const halfHeight = Math.max((maxY - minY) / 2, 1) + padding;
+	const [ox, oy] = rotate(localCenterX, localCenterY, angle);
+	return {
+		center: [cx + ox, cy + oy],
+		halfWidth,
+		halfHeight,
+		angle
+	};
+}
+/**
+* The box's 4 corners in screen pixels: `[topLeft, topRight, bottomRight,
+* bottomLeft]` in the box's local (pre-rotation) frame, then rotated by
+* `box.angle` about `box.center`. Corner index is stable — `pickBoxHandle`
+* and the scale-drag transition (`handle-drag.ts`) key off it, and the scale
+* anchor is always the opposite corner, `(index + 2) % 4`.
+*/
+function boxCorners(box) {
+	const { center, halfWidth, halfHeight, angle } = box;
+	return [
+		[-halfWidth, -halfHeight],
+		[halfWidth, -halfHeight],
+		[halfWidth, halfHeight],
+		[-halfWidth, halfHeight]
+	].map(([x, y]) => {
+		const [rx, ry] = rotate(x, y, angle);
+		return [center[0] + rx, center[1] + ry];
+	});
+}
+/**
+* Where the rotate grip sits: `offset` pixels (default `ROTATE_GRIP_OFFSET_PX`)
+* above the top-edge midpoint, along the box's local "up" direction, so the
+* grip stays glued to the box (rotates with it) rather than floating at a
+* fixed screen offset. The label transform box passes its own tighter
+* clearance (`LABEL_ROTATE_GRIP_OFFSET_PX`).
+*/
+function rotateGripPixel(box, offset = 28) {
+	const { center, halfHeight, angle } = box;
+	const [rx, ry] = rotate(0, -(halfHeight + offset), angle);
+	return [center[0] + rx, center[1] + ry];
+}
+/**
+* Point-in-oriented-rectangle test, used to start a body (translate) drag
+* when the pointer goes down inside the box but not on a corner/rotate grip.
+* De-rotates `pixel` into the box's local frame about `box.center` and
+* compares against the half-extents.
+*/
+function pointInBox(box, pixel) {
+	const { center, halfWidth, halfHeight, angle } = box;
+	const [lx, ly] = rotate(pixel[0] - center[0], pixel[1] - center[1], -angle);
+	return Math.abs(lx) <= halfWidth && Math.abs(ly) <= halfHeight;
+}
+/** Plain 2D distance between two pixel coordinates. */
+function pixelDistance$1(a, b) {
+	return Math.hypot(a[0] - b[0], a[1] - b[1]);
+}
+/**
+* Pick what part of the box, if any, `pixel` hits — corners first, then the
+* rotate grip, then plain containment (body drag). Corners and the rotate
+* grip use `tolerance` pixels; body containment is exact (`pointInBox`), so a
+* click just outside the box never starts a body drag. Returns `null` when
+* nothing matches.
+*/
+function pickBoxHandle(box, pixel, tolerance) {
+	const corners = boxCorners(box);
+	for (let i = 0; i < corners.length; i++) if (pixelDistance$1(corners[i], pixel) <= tolerance) return {
+		kind: "scale",
+		index: i
+	};
+	if (pixelDistance$1(rotateGripPixel(box), pixel) <= tolerance) return { kind: "rotate" };
+	if (pointInBox(box, pixel)) return { kind: "body" };
+	return null;
+}
+//#endregion
+//#region src/point-symbol-offset.ts
+const EPSILON = 1e-7;
+const distance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
+/** Trim from the symbol attachment end, including across a junction when necessary. */
+function padAnchor(path, padding) {
+	if (!Number.isFinite(padding) || padding <= 0) return path;
+	const trimmed = [...path];
+	while (trimmed.length > 1) {
+		const start = trimmed.shift();
+		const end = trimmed[0];
+		const length = distance(start, end);
+		if (length > padding) {
+			const fraction = padding / length;
+			trimmed.unshift([start[0] + (end[0] - start[0]) * fraction, start[1] + (end[1] - start[1]) * fraction]);
+			return trimmed;
+		}
+		padding -= length;
+	}
+	return [];
+}
+/** Pure layout: projection input/output is in CSS pixels, including document contexts. */
+function resolvePointSymbolOffset(symbol, render, view) {
+	const actual = view.getPixelFromCoordinate(symbol.position);
+	if (!actual) return null;
+	const scale = pointSymbolPixelScale(symbol, render, view.getResolution());
+	const angle = symbol.rotation - view.getBearing();
+	const metadata = render.offset;
+	const registration = metadata?.ordinaryRegistration ?? render.octagonAnchor;
+	const shift = rotate((registration.x - render.anchor.x) * scale, (registration.y - render.anchor.y) * scale, angle);
+	const ordinaryDisplay = [actual[0] + shift[0], actual[1] + shift[1]];
+	const layout = {
+		render,
+		resource: pointSymbolResource(render),
+		bodyOpacity: (symbol.style?.opacity ?? 1) * (symbol.style?.overallOpacity ?? 1),
+		rotation: angle,
+		actual,
+		display: ordinaryDisplay,
+		imageAnchor: actual,
+		ordinaryDisplay,
+		path: [],
+		kind: "ordinary",
+		status: "ok",
+		scale,
+		connectorStyle: {
+			strokeColor: symbol.offset?.style?.strokeColor ?? metadata?.strokeColor ?? "#000000",
+			opacity: (symbol.offset?.style?.opacity ?? symbol.style?.opacity ?? 1) * (symbol.style?.overallOpacity ?? 1),
+			strokeWidth: symbol.offset?.style?.strokeWidth ?? (metadata?.strokeWidth ?? 4) * scale,
+			strokeDash: [...symbol.offset?.style?.strokeDash ?? []]
+		}
+	};
+	if (!symbol.offset) return layout;
+	const { placement, connector, anchorPadding = 0 } = symbol.offset;
+	if (!metadata || connector !== "direct" && !metadata.indicator) return {
+		...layout,
+		status: "unsupported-presentation"
+	};
+	const display = placement.mode === "ground" ? view.getPixelFromCoordinate(placement.position) : [ordinaryDisplay[0] + placement.offset[0], ordinaryDisplay[1] + placement.offset[1]];
+	if (!display) return {
+		...layout,
+		status: "unsupported-presentation"
+	};
+	if (distance(display, ordinaryDisplay) < EPSILON) return layout;
+	const body = metadata.body;
+	const offset = rotate((metadata.attachment.x - body.anchor.x) * scale, (metadata.attachment.y - body.anchor.y) * scale, angle);
+	const attachment = [display[0] + offset[0], display[1] + offset[1]];
+	const resolved = {
+		...layout,
+		render: body,
+		resource: pointSymbolResource(body),
+		display,
+		imageAnchor: display,
+		attachment
+	};
+	if (connector === "direct") return {
+		...resolved,
+		kind: "direct",
+		path: padAnchor(distance(attachment, actual) < EPSILON ? [] : [attachment, actual], anchorPadding)
+	};
+	const indicator = metadata.indicator;
+	const rawDirection = rotate(indicator.direction.x, indicator.direction.y, angle);
+	const norm = Math.hypot(...rawDirection);
+	const direction = [rawDirection[0] / norm, rawDirection[1] / norm];
+	const dx = actual[0] - attachment[0], dy = actual[1] - attachment[1];
+	const forward = dx * direction[0] + dy * direction[1];
+	if (Math.abs(dx * direction[1] - dy * direction[0]) < EPSILON && forward >= (indicator.minLength ?? 0) * scale) return {
+		...resolved,
+		direction,
+		kind: "indicator-only",
+		path: padAnchor([attachment, actual], anchorPadding)
+	};
+	const length = symbol.offset.indicatorLength !== void 0 ? symbol.offset.indicatorLength * render.octagonSize : indicator.length;
+	const junction = [attachment[0] + direction[0] * length * scale, attachment[1] + direction[1] * length * scale];
+	return {
+		...resolved,
+		direction,
+		junction,
+		kind: "with-extension",
+		status: "ok",
+		path: padAnchor(distance(junction, actual) < EPSILON ? [attachment, junction] : [
+			attachment,
+			junction,
+			actual
+		], anchorPadding)
+	};
 }
 /**
-* Replace a point-symbol size value as a user-driven resize. Ground-size display
-* bounds scale with the value so they continue to constrain zoom changes rather
-* than preventing the resize itself.
+* Authored indicator length that puts the junction at `point`: the forward
+* projection onto the attachment ray, expressed as a multiple of the displayed
+* octagon size and clamped to a non-negative length.
 */
-function resizePointSymbolSize(size, value) {
-	if (size.unit === "pixels") return {
-		value,
-		unit: "pixels"
+function indicatorLengthAt(point, attachment, direction, scale, octagonSize) {
+	const forward = (point[0] - attachment[0]) * direction[0] + (point[1] - attachment[1]) * direction[1];
+	return Math.max(0, forward / (scale * octagonSize));
+}
+/** Set body placement without changing the authoritative coordinate. */
+function placePointSymbol(symbol, render, view, display, mode = symbol.offset?.placement.mode ?? "screen-relative") {
+	if (!render.offset) throw new TypeError("This renderer does not support offset placement");
+	const ordinary = resolvePointSymbolOffset({
+		...symbol,
+		offset: void 0
+	}, render, view);
+	if (!ordinary) throw new RangeError("Point symbol cannot be projected in this view");
+	const next = clonePointSymbol(symbol);
+	const coordinate = mode === "ground" ? view.getCoordinateFromPixel?.(display) : void 0;
+	if (mode === "ground" && !coordinate) throw new RangeError("Ground placement requires inverse projection");
+	next.offset = {
+		...next.offset,
+		connector: next.offset?.connector ?? (render.offset.indicator ? "auto" : "direct"),
+		placement: mode === "ground" ? {
+			mode,
+			position: [...coordinate]
+		} : {
+			mode,
+			offset: [display[0] - ordinary.display[0], display[1] - ordinary.display[1]]
+		}
 	};
-	const scale = value / size.value;
-	if (!Number.isFinite(scale) || scale <= 0) return {
-		...size,
-		value
+	return next;
+}
+function convertPointSymbolPlacement(symbol, render, view, mode) {
+	const layout = resolvePointSymbolOffset(symbol, render, view);
+	if (!layout || layout.status === "unsupported-presentation") throw new TypeError("Offset presentation is unavailable");
+	return placePointSymbol(symbol, render, view, layout.display, mode);
+}
+/** Explicit alignment, also used with hysteresis by pointer editing. */
+function alignPointSymbolIndicator(symbol, render, view) {
+	const layout = resolvePointSymbolOffset(symbol, render, view);
+	if (!layout?.attachment || !layout.direction || !render.offset?.indicator) return symbol;
+	const d = layout.direction;
+	const delta = [layout.actual[0] - layout.attachment[0], layout.actual[1] - layout.attachment[1]];
+	const forward = Math.max((render.offset.indicator.minLength ?? 0) * layout.scale, delta[0] * d[0] + delta[1] * d[1]);
+	return placePointSymbol(symbol, render, view, [layout.display[0] + delta[0] - forward * d[0], layout.display[1] + delta[1] - forward * d[1]]);
+}
+function movePointSymbolLocation(symbol, render, view, position) {
+	const before = resolvePointSymbolOffset(symbol, render, view);
+	let next = {
+		...clonePointSymbol(symbol),
+		position: [...position]
 	};
+	if (!symbol.offset || !before || before.status === "unsupported-presentation") return next;
+	next = placePointSymbol(next, render, view, before.display);
+	const after = resolvePointSymbolOffset(next, render, view);
+	if (before.junction && after?.attachment && after.direction && symbol.offset.indicatorLength !== void 0) next.offset.indicatorLength = indicatorLengthAt(before.junction, after.attachment, after.direction, after.scale, render.octagonSize);
+	return next;
+}
+/** Canonical resource metadata shared by native adapters and external exporters. */
+function pointSymbolResource(render) {
 	return {
-		...size,
-		value,
-		...size.minPixels !== void 0 ? { minPixels: size.minPixels * scale } : {},
-		...size.maxPixels !== void 0 ? { maxPixels: size.maxPixels * scale } : {}
+		id: render.resourceId,
+		svg: render.svg,
+		width: render.width,
+		height: render.height,
+		anchor: [render.anchor.x, render.anchor.y],
+		coreRect: {
+			x: render.octagonAnchor.x - render.octagonSize / 2,
+			y: render.octagonAnchor.y - render.octagonSize / 2,
+			width: render.octagonSize,
+			height: render.octagonSize
+		}
+	};
+}
+/**
+* Convert a resolved CSS-pixel layout to output units (e.g. 25.4 / 96 for mm).
+* Scales positions, body scale, line width and dashes together, including the
+* already-resolved offset and padding. Canonical resources, direction, rotation
+* and opacity stay unchanged. Does not mutate the input or authored symbol.
+*/
+function scalePointSymbolLayout(layout, factor) {
+	if (!Number.isFinite(factor) || factor <= 0) throw new RangeError("Layout scale factor must be positive and finite");
+	const point = ([x, y]) => [x * factor, y * factor];
+	return {
+		...layout,
+		actual: point(layout.actual),
+		display: point(layout.display),
+		imageAnchor: point(layout.imageAnchor),
+		ordinaryDisplay: point(layout.ordinaryDisplay),
+		attachment: layout.attachment && point(layout.attachment),
+		junction: layout.junction && point(layout.junction),
+		path: layout.path.map(point),
+		scale: layout.scale * factor,
+		connectorStyle: {
+			...layout.connectorStyle,
+			strokeWidth: layout.connectorStyle.strokeWidth * factor,
+			strokeDash: layout.connectorStyle.strokeDash.map((length) => length * factor)
+		}
 	};
 }
 //#endregion
@@ -953,97 +1713,19 @@ var ActiveInteractionTracker = class {
 			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
-		});
+		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;
 	}
 };
-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
-	};
-}
 //#endregion
 //#region src/tactical-draw/measure-options.ts
 const DEFAULT_LABEL_SIZE_PIXELS = DEFAULT_LABEL_HEIGHT_CSS_PIXELS;
@@ -1625,238 +2307,59 @@ function createSnapResolver(adapter, getGraphics, getGeometryFeatures, getOption
 	let indexedCandidates = [];
 	let indexedFeatures;
 	let indexedGeometryPaths = [];
-	const builtInCandidates = () => {
-		const graphics = getGraphics();
-		if (graphics !== indexedGraphics) {
-			indexedGraphics = graphics;
-			indexedCandidates = graphicCandidates(graphics);
-		}
-		return indexedCandidates;
-	};
-	const geometryPaths = () => {
-		const features = getGeometryFeatures();
-		if (features !== indexedFeatures) {
-			indexedFeatures = features;
-			indexedGeometryPaths = indexGeometryFeatures(features);
-		}
-		return indexedGeometryPaths;
-	};
-	return (request) => {
-		const options = getOptions();
-		const clear = () => options?.onSnap?.(null);
-		if (!options?.enabled || options.bypass?.(request.originalEvent)) {
-			clear();
-			return null;
-		}
-		const tolerance = options.tolerancePixels ?? DEFAULT_TOLERANCE_PIXELS;
-		if (!Number.isFinite(tolerance) || tolerance < 0) {
-			clear();
-			return null;
-		}
-		const candidateLists = [];
-		if (options.sources?.graphics !== false) candidateLists.push(builtInCandidates());
-		const graphicGeometry = options.sources?.graphicGeometry;
-		if (graphicGeometry) candidateLists.push(generatedGeometryCandidates(adapter, geometryPaths(), request, graphicGeometry));
-		const external = options.sources?.external?.(request);
-		if (external) candidateLists.push(external);
-		let best = null;
-		for (const list of candidateLists) for (const candidate of list) {
-			if (isSelfCandidate(candidate, request)) continue;
-			const pixel = adapter.getPixelFromCoordinate(candidate.coordinate);
-			if (!pixel) continue;
-			const distancePixels = Math.hypot(pixel[0] - request.pixel[0], pixel[1] - request.pixel[1]);
-			if (distancePixels > tolerance) continue;
-			const priority = candidate.priority ?? 0;
-			const bestPriority = best?.candidate.priority ?? 0;
-			if (best && (distancePixels > best.distancePixels || distancePixels === best.distancePixels && priority <= bestPriority)) continue;
-			best = {
-				coordinate: [...candidate.coordinate],
-				pixel: [...pixel],
-				candidate,
-				distancePixels
-			};
-		}
-		options.onSnap?.(best);
-		return best;
-	};
-}
-//#endregion
-//#region src/tactical-draw/session-events.ts
-/**
-* Map a settle-time error to its `SettleReason`: a `TacticalDrawAbortError`
-* replays its own `reason` verbatim; anything else (a `produce` throw from
-* `ctx.commit`) is the commit-time snapshot build failing, reported as
-* `"error"`.
-*/
-function settleReasonFromError(error) {
-	return isTacticalDrawAbortError(error) ? error.reason : "error";
-}
-/**
-* Fan a `runInteraction` settlement out to a session's commit + settle
-* emitters — the shared body of the `onSettled` wrappers in the edit and draw
-* controllers (transform emits its close-path settle from `commitClose`
-* instead, so it does not use this). On the commit path, emit the snapshot
-* then the `"close"` settle in a try/finally so a throwing `onCommit` listener
-* cannot starve the settle emission; on the reject path, emit the settle with
-* the reason derived from the error. Callers run their own facade
-* slot-clearing (`onSettled()`) before this so a listener observes a cleared
-* `td.activeSession`.
-*/
-function settleFromInteraction(settlement, commitEmitter, settleEmitter) {
-	if (settlement.status === "committed") try {
-		commitEmitter.emit(settlement.value);
-	} finally {
-		settleEmitter.emit("close");
-	}
-	else settleEmitter.emit(settleReasonFromError(settlement.error));
-}
-/**
-* Subscribe/emit machinery shared by `TransformSession.onSettled`,
-* `EditSession.onSettled`, and `DrawSession.onSettled` (#191 / #194 / #197):
-* a settle-exactly-once latch, synchronous emission to every listener with
-* exception collection (single rethrow, `AggregateError` otherwise when more
-* than one listener throws), and a late-registration path that delivers the
-* latched reason on a microtask exactly once when a handler subscribes after
-* the session has already settled.
-*
-* `listenerErrorsMessage` becomes the `AggregateError` message — pass a
-* session-specific string (e.g. `"EditSession.onSettled listener errors"`).
-*/
-function createSettleEmitter(listenerErrorsMessage) {
-	const listeners = /* @__PURE__ */ new Set();
-	/** Set exactly once, by `emit` — also the "has settled" latch and the reason replayed to late registrations. */
-	let settledReason = null;
-	return {
-		emit(reason) {
-			if (settledReason !== null) return;
-			settledReason = reason;
-			const current = [...listeners];
-			listeners.clear();
-			const errors = [];
-			for (const listener of current) try {
-				listener(reason);
-			} catch (err) {
-				errors.push(err);
-			}
-			if (errors.length === 1) throw errors[0];
-			if (errors.length > 1) throw new AggregateError(errors, listenerErrorsMessage);
-		},
-		register(handler) {
-			if (settledReason !== null) {
-				const reason = settledReason;
-				let cancelled = false;
-				queueMicrotask(() => {
-					if (!cancelled) handler(reason);
-				});
-				return () => {
-					cancelled = true;
-				};
-			}
-			listeners.add(handler);
-			return () => {
-				listeners.delete(handler);
-			};
-		}
-	};
-}
-/**
-* The deferred reject/close/abort change-emit protocol (issue #49 contract)
-* shared by `EditSession.onChange`, `TransformSession.onChange`, and
-* `GraphicEditSession.onChange`. Owns the listener `Set` (like
-* `createCommitEmitter.register`) and, per emission:
-*
-*  - builds one event by spreading the controller-supplied `payload` plus the
-*    injected `reject()` / `close()` / `abort()` recorders, and delivers that
-*    same instance to every listener in registration order;
-*  - collects listener exceptions (single → rethrow as-is, multiple →
-*    `AggregateError` with `listenerErrorsMessage`);
-*  - applies decisions after all listeners run, priority `abort` > `close` >
-*    `reject`, with `reject` further gated on `!isSettled()` and
-*    `stillApplicable()`;
-*  - runs `onAccepted` (when the change survived) *before* rethrowing listener
-*    errors — unifying every controller on edit's history-before-throw ordering
-*    — and returns whether the change was accepted.
-*
-* Registration-time `isSettled()` guards stay in the controllers' `onChange`
-* wrappers, mirroring `createCommitEmitter`.
-*/
-function createChangeEmitter(options) {
-	const listeners = /* @__PURE__ */ new Set();
-	return {
-		register(listener) {
-			listeners.add(listener);
-			return () => {
-				listeners.delete(listener);
-			};
-		},
-		emit(payload, emission) {
-			if (options.isSettled()) return false;
-			let rejectRequested = false;
-			let closeRequested = false;
-			let abortRequested = false;
-			const event = {
-				...payload,
-				reject() {
-					rejectRequested = true;
-				},
-				close() {
-					closeRequested = true;
-				},
-				abort() {
-					abortRequested = true;
-				}
-			};
-			const errors = [];
-			for (const listener of [...listeners]) try {
-				listener(event);
-			} catch (err) {
-				errors.push(err);
-			}
-			const applicable = emission.stillApplicable?.() ?? true;
-			if (abortRequested) options.abort();
-			else if (closeRequested) options.close();
-			else if (rejectRequested && !options.isSettled() && applicable) emission.rollback();
-			const accepted = !options.isSettled() && !rejectRequested && applicable;
-			if (accepted) emission.onAccepted?.();
-			if (errors.length === 1) throw errors[0];
-			if (errors.length > 1) throw new AggregateError(errors, options.listenerErrorsMessage);
-			return accepted;
+	const builtInCandidates = () => {
+		const graphics = getGraphics();
+		if (graphics !== indexedGraphics) {
+			indexedGraphics = graphics;
+			indexedCandidates = graphicCandidates(graphics);
 		}
+		return indexedCandidates;
 	};
-}
-/**
-* Channel-neutral subscribe/emit machinery: a listener set with synchronous,
-* exception-collecting emission (single rethrow, `AggregateError` otherwise).
-* Named for its original `onCommit` channel (`TransformSession` /
-* `EditSession` / `DrawSession`), it also carries the `onTransientChange`
-* streams and the fixed/variable draw controllers' `onChange` — any
-* multi-emit channel with no latch. Unlike `createSettleEmitter`, `emit` may
-* be called more than
-* once — a transform's `setGraphics` can commit several removal batches before
-* the close batch — and there is no latch or late-registration path:
-* registration-time `ctx.settled` guards stay in the controllers, mirroring
-* `onChange`.
-*/
-function createCommitEmitter(listenerErrorsMessage) {
-	const listeners = /* @__PURE__ */ new Set();
-	return {
-		emit(value) {
-			const current = [...listeners];
-			const errors = [];
-			for (const listener of current) try {
-				listener(value);
-			} catch (err) {
-				errors.push(err);
-			}
-			if (errors.length === 1) throw errors[0];
-			if (errors.length > 1) throw new AggregateError(errors, listenerErrorsMessage);
-		},
-		register(listener) {
-			listeners.add(listener);
-			return () => {
-				listeners.delete(listener);
+	const geometryPaths = () => {
+		const features = getGeometryFeatures();
+		if (features !== indexedFeatures) {
+			indexedFeatures = features;
+			indexedGeometryPaths = indexGeometryFeatures(features);
+		}
+		return indexedGeometryPaths;
+	};
+	return (request) => {
+		const options = getOptions();
+		const clear = () => options?.onSnap?.(null);
+		if (!options?.enabled || options.bypass?.(request.originalEvent)) {
+			clear();
+			return null;
+		}
+		const tolerance = options.tolerancePixels ?? DEFAULT_TOLERANCE_PIXELS;
+		if (!Number.isFinite(tolerance) || tolerance < 0) {
+			clear();
+			return null;
+		}
+		const candidateLists = [];
+		if (options.sources?.graphics !== false) candidateLists.push(builtInCandidates());
+		const graphicGeometry = options.sources?.graphicGeometry;
+		if (graphicGeometry) candidateLists.push(generatedGeometryCandidates(adapter, geometryPaths(), request, graphicGeometry));
+		const external = options.sources?.external?.(request);
+		if (external) candidateLists.push(external);
+		let best = null;
+		for (const list of candidateLists) for (const candidate of list) {
+			if (isSelfCandidate(candidate, request)) continue;
+			const pixel = adapter.getPixelFromCoordinate(candidate.coordinate);
+			if (!pixel) continue;
+			const distancePixels = Math.hypot(pixel[0] - request.pixel[0], pixel[1] - request.pixel[1]);
+			if (distancePixels > tolerance) continue;
+			const priority = candidate.priority ?? 0;
+			const bestPriority = best?.candidate.priority ?? 0;
+			if (best && (distancePixels > best.distancePixels || distancePixels === best.distancePixels && priority <= bestPriority)) continue;
+			best = {
+				coordinate: [...candidate.coordinate],
+				pixel: [...pixel],
+				candidate,
+				distancePixels
 			};
 		}
+		options.onSnap?.(best);
+		return best;
 	};
 }
 //#endregion
@@ -2557,181 +3060,47 @@ function runEditInteraction(spec) {
 							value
 						});
 						return value;
-					});
-				},
-				fail(error) {
-					if (!interaction.settled) runBeforeTeardown({
-						status: "rejected",
-						error
-					});
-					interaction.fail(error);
-				},
-				writeLayer: interaction.writeLayer,
-				onTeardown: interaction.onTeardown
-			};
-			const onDown = (pixel, info) => {
-				suppressClickAway = false;
-				spec.onDown(pixel, info);
-			};
-			const unsubDown = driver.onPointerDown(onDown);
-			const unsubMove = driver.onPointerMove(spec.onMove);
-			const unsubUp = driver.onPointerUp(spec.onUp);
-			const unsubPreview = adapter.onPick(previewLayer, onPreviewPick);
-			const unsubHandles = adapter.onPick(handlesLayer, onHandlesPick);
-			const unsubGraphics = adapter.onPick(graphicsLayer, onGraphicsPick);
-			adapter.on("click", onClick);
-			interaction.onTeardown(() => {
-				runBeforeTeardown({
-					status: "rejected",
-					error: void 0
-				});
-				adapter.off("click", onClick);
-				unsubPreview();
-				unsubHandles();
-				unsubGraphics();
-				unsubDown();
-				unsubMove();
-				unsubUp();
-				spec.extraTeardown?.();
-				driver.dispose();
-			}, spec.onAbort);
-			spec.attach(controllerContext, driver, shell);
-		}
-	});
-}
-//#endregion
-//#region src/tactical-draw/transform-box.ts
-/**
-* The uniform scale factor and rotation delta a box implies relative to a
-* pre-drag box, given the gesture kind. A `body` translate reports neither
-* (1, 0). Consumed both by point symbols (size/rotation) and by Text graphics
-* (folding the delta into rotation/size options); the delta is pivot-
-* independent so either can apply it without knowing the box center.
-*/
-function boxScaleRotation(kind, box, preDragBox) {
-	return {
-		scale: kind === "scale" ? Math.max(box.halfWidth / preDragBox.halfWidth, box.halfHeight / preDragBox.halfHeight) : 1,
-		rotation: kind === "rotate" ? box.angle - preDragBox.angle : 0
-	};
-}
-function rotate(x, y, angle) {
-	const cos = Math.cos(angle);
-	const sin = Math.sin(angle);
-	return [x * cos - y * sin, x * sin + y * cos];
-}
-/**
-* Fit an oriented `TransformBox` around `pixels` at a caller-chosen `angle`.
-* Rotates the points by `-angle` about their centroid, takes the axis-aligned
-* bounding box in that de-rotated frame, then re-expresses the result as an
-* oriented box at `angle` — so the box always has exactly the requested tilt,
-* sized to just contain the (de-rotated) points. Half-dimensions are floored
-* at `MIN_HALF_SIZE_PX` so a degenerate selection still yields a drawable,
-* pickable box. Returns `null` for an empty list — there is nothing to fit.
-*
-* `padding` (pixels, default `0`) is added to `halfWidth`/`halfHeight` *after*
-* the `MIN_HALF_SIZE_PX` floor, on every side, without moving `center` — the
-* `InteractionStyle.boxPadding` knob (ADR-0017) so the box doesn't tightly hug
-* the rendered geometry. Everything downstream that reads a fitted box
-* (`boxCorners`, `rotateGripPixel`, `pointInBox`, `pickBoxHandle`) derives from
-* `halfWidth`/`halfHeight` alone, so the padding flows through to corner
-* placement, the rotate grip, and picking automatically — no other function
-* needs to know about it.
-*/
-function fitTransformBox(pixels, angle, padding = 0) {
-	if (pixels.length === 0) return null;
-	let cx = 0;
-	let cy = 0;
-	for (const p of pixels) {
-		cx += p[0];
-		cy += p[1];
-	}
-	cx /= pixels.length;
-	cy /= pixels.length;
-	let minX = Infinity;
-	let minY = Infinity;
-	let maxX = -Infinity;
-	let maxY = -Infinity;
-	for (const p of pixels) {
-		const [rx, ry] = rotate(p[0] - cx, p[1] - cy, -angle);
-		if (rx < minX) minX = rx;
-		if (rx > maxX) maxX = rx;
-		if (ry < minY) minY = ry;
-		if (ry > maxY) maxY = ry;
-	}
-	const localCenterX = (minX + maxX) / 2;
-	const localCenterY = (minY + maxY) / 2;
-	const halfWidth = Math.max((maxX - minX) / 2, 1) + padding;
-	const halfHeight = Math.max((maxY - minY) / 2, 1) + padding;
-	const [ox, oy] = rotate(localCenterX, localCenterY, angle);
-	return {
-		center: [cx + ox, cy + oy],
-		halfWidth,
-		halfHeight,
-		angle
-	};
-}
-/**
-* The box's 4 corners in screen pixels: `[topLeft, topRight, bottomRight,
-* bottomLeft]` in the box's local (pre-rotation) frame, then rotated by
-* `box.angle` about `box.center`. Corner index is stable — `pickBoxHandle`
-* and the scale-drag transition (`handle-drag.ts`) key off it, and the scale
-* anchor is always the opposite corner, `(index + 2) % 4`.
-*/
-function boxCorners(box) {
-	const { center, halfWidth, halfHeight, angle } = box;
-	return [
-		[-halfWidth, -halfHeight],
-		[halfWidth, -halfHeight],
-		[halfWidth, halfHeight],
-		[-halfWidth, halfHeight]
-	].map(([x, y]) => {
-		const [rx, ry] = rotate(x, y, angle);
-		return [center[0] + rx, center[1] + ry];
-	});
-}
-/**
-* Where the rotate grip sits: `offset` pixels (default `ROTATE_GRIP_OFFSET_PX`)
-* above the top-edge midpoint, along the box's local "up" direction, so the
-* grip stays glued to the box (rotates with it) rather than floating at a
-* fixed screen offset. The label transform box passes its own tighter
-* clearance (`LABEL_ROTATE_GRIP_OFFSET_PX`).
-*/
-function rotateGripPixel(box, offset = 28) {
-	const { center, halfHeight, angle } = box;
-	const [rx, ry] = rotate(0, -(halfHeight + offset), angle);
-	return [center[0] + rx, center[1] + ry];
-}
-/**
-* Point-in-oriented-rectangle test, used to start a body (translate) drag
-* when the pointer goes down inside the box but not on a corner/rotate grip.
-* De-rotates `pixel` into the box's local frame about `box.center` and
-* compares against the half-extents.
-*/
-function pointInBox(box, pixel) {
-	const { center, halfWidth, halfHeight, angle } = box;
-	const [lx, ly] = rotate(pixel[0] - center[0], pixel[1] - center[1], -angle);
-	return Math.abs(lx) <= halfWidth && Math.abs(ly) <= halfHeight;
-}
-/** Plain 2D distance between two pixel coordinates. */
-function pixelDistance$1(a, b) {
-	return Math.hypot(a[0] - b[0], a[1] - b[1]);
-}
-/**
-* Pick what part of the box, if any, `pixel` hits — corners first, then the
-* rotate grip, then plain containment (body drag). Corners and the rotate
-* grip use `tolerance` pixels; body containment is exact (`pointInBox`), so a
-* click just outside the box never starts a body drag. Returns `null` when
-* nothing matches.
-*/
-function pickBoxHandle(box, pixel, tolerance) {
-	const corners = boxCorners(box);
-	for (let i = 0; i < corners.length; i++) if (pixelDistance$1(corners[i], pixel) <= tolerance) return {
-		kind: "scale",
-		index: i
-	};
-	if (pixelDistance$1(rotateGripPixel(box), pixel) <= tolerance) return { kind: "rotate" };
-	if (pointInBox(box, pixel)) return { kind: "body" };
-	return null;
+					});
+				},
+				fail(error) {
+					if (!interaction.settled) runBeforeTeardown({
+						status: "rejected",
+						error
+					});
+					interaction.fail(error);
+				},
+				writeLayer: interaction.writeLayer,
+				onTeardown: interaction.onTeardown
+			};
+			const onDown = (pixel, info) => {
+				suppressClickAway = false;
+				spec.onDown(pixel, info);
+			};
+			const unsubDown = driver.onPointerDown(onDown);
+			const unsubMove = driver.onPointerMove(spec.onMove);
+			const unsubUp = driver.onPointerUp(spec.onUp);
+			const unsubPreview = adapter.onPick(previewLayer, onPreviewPick);
+			const unsubHandles = adapter.onPick(handlesLayer, onHandlesPick);
+			const unsubGraphics = adapter.onPick(graphicsLayer, onGraphicsPick);
+			adapter.on("click", onClick);
+			interaction.onTeardown(() => {
+				runBeforeTeardown({
+					status: "rejected",
+					error: void 0
+				});
+				adapter.off("click", onClick);
+				unsubPreview();
+				unsubHandles();
+				unsubGraphics();
+				unsubDown();
+				unsubMove();
+				unsubUp();
+				spec.extraTeardown?.();
+				driver.dispose();
+			}, spec.onAbort);
+			spec.attach(controllerContext, driver, shell);
+		}
+	});
 }
 //#endregion
 //#region src/tactical-draw/handles.ts
@@ -5078,335 +5447,115 @@ function runEdit(opts) {
 		onMove: onDriverMove,
 		onUp: onDriverUp,
 		ownsGraphic: (id) => id === measure.id,
-		close: () => {
-			ctx.commit(rebuildRendered);
-		},
-		onForeignPick: onClickAwayGraphicsPick,
-		historySettle: () => history.settle(),
-		facadeOnSettled: onSettled,
-		emitSettle: (settlement) => settleFromInteraction(settlement, commitEmitter, settleEmitter),
-		extraTeardown: () => {
-			if (activeDrag !== null || activeOptionDrag !== null || activeBoxDrag !== null || labels.dragging) {
-				emitTransient("end", workingPoints, activeDrag?.controlPointIndex ?? null);
-				driver.setDragPanEnabled(true);
-				activeDrag = null;
-				activeOptionDrag = null;
-				activeBoxDrag = null;
-				labels.endDrag();
-				dragInFlight = false;
-			}
-		},
-		attach(interaction, createdDriver, createdShell) {
-			ctx = interaction;
-			driver = createdDriver;
-			shell = createdShell;
-			renderWorkingGraphic();
-			renderHandlesLayer();
-			recomputeDirty();
-			if (onSession) onSession(session);
-		}
-	});
-	return {
-		promise: core.promise,
-		get settled() {
-			return core.settled;
-		},
-		usesGraphicStack: true,
-		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;
-			renderWorkingGraphic();
-		}
-	};
-}
-/**
-* Validate and normalise an `EditOptions.modes` / `EditSession.setModes` input:
-* throws `TypeError` synchronously for an unknown mode, collapses `delete` to
-* an exclusive set, dedupes, and defaults to `["reshape", "transform"]`.
-* Exported so the façade can hoist this validation *before* `guardAndPreempt`
-* — an invalid mode must not tear down whatever edit/draw is already active
-* (see the `td.edit` regression test for issue tracked alongside ADR-0017).
-*/
-function normaliseModes(modes) {
-	if (!modes || modes.length === 0) return ["reshape", "transform"];
-	for (const m of modes) 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);
-	}
-};
-var PointSymbolCapabilityRequiredError = class extends Error {
-	constructor() {
-		super("TacticalDraw: point-symbol capability is not configured");
-		this.name = "PointSymbolCapabilityRequiredError";
-	}
-};
-var ImageCapabilityRequiredError = class ImageCapabilityRequiredError extends Error {
-	constructor() {
-		super("TacticalDraw: image capability is not configured");
-		this.name = "ImageCapabilityRequiredError";
-		Object.setPrototypeOf(this, ImageCapabilityRequiredError.prototype);
-	}
-};
-//#endregion
-//#region src/point-symbol-size.ts
-function effectivePointSymbolPixelSize(symbol, resolution) {
-	if (symbol.size.unit === "pixels") return symbol.size.value;
-	if (resolution === void 0 || resolution <= 0) return symbol.size.value;
-	const px = symbol.size.value / resolution;
-	const { minPixels, maxPixels } = symbol.size;
-	return Math.max(Number.isFinite(minPixels) && minPixels > 0 ? minPixels : 0, Math.min(Number.isFinite(maxPixels) && maxPixels > 0 ? maxPixels : Infinity, px));
-}
-function pointSymbolPixelScale(symbol, render, resolution) {
-	if (!Number.isFinite(render.octagonSize) || render.octagonSize <= 0) throw new TypeError("PointSymbolRender.octagonSize must be a positive finite number");
-	return effectivePointSymbolPixelSize(symbol, resolution) / render.octagonSize;
-}
-//#endregion
-//#region src/point-symbol-offset.ts
-const EPSILON = 1e-7;
-const distance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
-/** Trim from the symbol attachment end, including across a junction when necessary. */
-function padAnchor(path, padding) {
-	if (!Number.isFinite(padding) || padding <= 0) return path;
-	const trimmed = [...path];
-	while (trimmed.length > 1) {
-		const start = trimmed.shift();
-		const end = trimmed[0];
-		const length = distance(start, end);
-		if (length > padding) {
-			const fraction = padding / length;
-			trimmed.unshift([start[0] + (end[0] - start[0]) * fraction, start[1] + (end[1] - start[1]) * fraction]);
-			return trimmed;
-		}
-		padding -= length;
-	}
-	return [];
-}
-/** Pure layout: projection input/output is in CSS pixels, including document contexts. */
-function resolvePointSymbolOffset(symbol, render, view) {
-	const actual = view.getPixelFromCoordinate(symbol.position);
-	if (!actual) return null;
-	const scale = pointSymbolPixelScale(symbol, render, view.getResolution());
-	const angle = symbol.rotation - view.getBearing();
-	const metadata = render.offset;
-	const registration = metadata?.ordinaryRegistration ?? render.octagonAnchor;
-	const shift = rotate((registration.x - render.anchor.x) * scale, (registration.y - render.anchor.y) * scale, angle);
-	const ordinaryDisplay = [actual[0] + shift[0], actual[1] + shift[1]];
-	const layout = {
-		render,
-		resource: pointSymbolResource(render),
-		bodyOpacity: (symbol.style?.opacity ?? 1) * (symbol.style?.overallOpacity ?? 1),
-		rotation: angle,
-		actual,
-		display: ordinaryDisplay,
-		imageAnchor: actual,
-		ordinaryDisplay,
-		path: [],
-		kind: "ordinary",
-		status: "ok",
-		scale,
-		connectorStyle: {
-			strokeColor: symbol.offset?.style?.strokeColor ?? metadata?.strokeColor ?? "#000000",
-			opacity: (symbol.offset?.style?.opacity ?? symbol.style?.opacity ?? 1) * (symbol.style?.overallOpacity ?? 1),
-			strokeWidth: symbol.offset?.style?.strokeWidth ?? (metadata?.strokeWidth ?? 4) * scale,
-			strokeDash: [...symbol.offset?.style?.strokeDash ?? []]
-		}
-	};
-	if (!symbol.offset) return layout;
-	const { placement, connector, anchorPadding = 0 } = symbol.offset;
-	if (!metadata || connector !== "direct" && !metadata.indicator) return {
-		...layout,
-		status: "unsupported-presentation"
-	};
-	const display = placement.mode === "ground" ? view.getPixelFromCoordinate(placement.position) : [ordinaryDisplay[0] + placement.offset[0], ordinaryDisplay[1] + placement.offset[1]];
-	if (!display) return {
-		...layout,
-		status: "unsupported-presentation"
-	};
-	if (distance(display, ordinaryDisplay) < EPSILON) return layout;
-	const body = metadata.body;
-	const offset = rotate((metadata.attachment.x - body.anchor.x) * scale, (metadata.attachment.y - body.anchor.y) * scale, angle);
-	const attachment = [display[0] + offset[0], display[1] + offset[1]];
-	const resolved = {
-		...layout,
-		render: body,
-		resource: pointSymbolResource(body),
-		display,
-		imageAnchor: display,
-		attachment
-	};
-	if (connector === "direct") return {
-		...resolved,
-		kind: "direct",
-		path: padAnchor(distance(attachment, actual) < EPSILON ? [] : [attachment, actual], anchorPadding)
-	};
-	const indicator = metadata.indicator;
-	const rawDirection = rotate(indicator.direction.x, indicator.direction.y, angle);
-	const norm = Math.hypot(...rawDirection);
-	const direction = [rawDirection[0] / norm, rawDirection[1] / norm];
-	const dx = actual[0] - attachment[0], dy = actual[1] - attachment[1];
-	const forward = dx * direction[0] + dy * direction[1];
-	if (Math.abs(dx * direction[1] - dy * direction[0]) < EPSILON && forward >= (indicator.minLength ?? 0) * scale) return {
-		...resolved,
-		direction,
-		kind: "indicator-only",
-		path: padAnchor([attachment, actual], anchorPadding)
-	};
-	const length = symbol.offset.indicatorLength !== void 0 ? symbol.offset.indicatorLength * render.octagonSize : indicator.length;
-	const junction = [attachment[0] + direction[0] * length * scale, attachment[1] + direction[1] * length * scale];
+		close: () => {
+			ctx.commit(rebuildRendered);
+		},
+		onForeignPick: onClickAwayGraphicsPick,
+		historySettle: () => history.settle(),
+		facadeOnSettled: onSettled,
+		emitSettle: (settlement) => settleFromInteraction(settlement, commitEmitter, settleEmitter),
+		extraTeardown: () => {
+			if (activeDrag !== null || activeOptionDrag !== null || activeBoxDrag !== null || labels.dragging) {
+				emitTransient("end", workingPoints, activeDrag?.controlPointIndex ?? null);
+				driver.setDragPanEnabled(true);
+				activeDrag = null;
+				activeOptionDrag = null;
+				activeBoxDrag = null;
+				labels.endDrag();
+				dragInFlight = false;
+			}
+		},
+		attach(interaction, createdDriver, createdShell) {
+			ctx = interaction;
+			driver = createdDriver;
+			shell = createdShell;
+			renderWorkingGraphic();
+			renderHandlesLayer();
+			recomputeDirty();
+			if (onSession) onSession(session);
+		}
+	});
 	return {
-		...resolved,
-		direction,
-		junction,
-		kind: "with-extension",
-		status: "ok",
-		path: padAnchor(distance(junction, actual) < EPSILON ? [attachment, junction] : [
-			attachment,
-			junction,
-			actual
-		], anchorPadding)
+		promise: core.promise,
+		get settled() {
+			return core.settled;
+		},
+		usesGraphicStack: true,
+		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;
+			renderWorkingGraphic();
+		}
 	};
 }
 /**
-* Authored indicator length that puts the junction at `point`: the forward
-* projection onto the attachment ray, expressed as a multiple of the displayed
-* octagon size and clamped to a non-negative length.
+* Validate and normalise an `EditOptions.modes` / `EditSession.setModes` input:
+* throws `TypeError` synchronously for an unknown mode, collapses `delete` to
+* an exclusive set, dedupes, and defaults to `["reshape", "transform"]`.
+* Exported so the façade can hoist this validation *before* `guardAndPreempt`
+* — an invalid mode must not tear down whatever edit/draw is already active
+* (see the `td.edit` regression test for issue tracked alongside ADR-0017).
 */
-function indicatorLengthAt(point, attachment, direction, scale, octagonSize) {
-	const forward = (point[0] - attachment[0]) * direction[0] + (point[1] - attachment[1]) * direction[1];
-	return Math.max(0, forward / (scale * octagonSize));
-}
-/** Set body placement without changing the authoritative coordinate. */
-function placePointSymbol(symbol, render, view, display, mode = symbol.offset?.placement.mode ?? "screen-relative") {
-	if (!render.offset) throw new TypeError("This renderer does not support offset placement");
-	const ordinary = resolvePointSymbolOffset({
-		...symbol,
-		offset: void 0
-	}, render, view);
-	if (!ordinary) throw new RangeError("Point symbol cannot be projected in this view");
-	const next = clonePointSymbol(symbol);
-	const coordinate = mode === "ground" ? view.getCoordinateFromPixel?.(display) : void 0;
-	if (mode === "ground" && !coordinate) throw new RangeError("Ground placement requires inverse projection");
-	next.offset = {
-		...next.offset,
-		connector: next.offset?.connector ?? (render.offset.indicator ? "auto" : "direct"),
-		placement: mode === "ground" ? {
-			mode,
-			position: [...coordinate]
-		} : {
-			mode,
-			offset: [display[0] - ordinary.display[0], display[1] - ordinary.display[1]]
-		}
-	};
-	return next;
-}
-function convertPointSymbolPlacement(symbol, render, view, mode) {
-	const layout = resolvePointSymbolOffset(symbol, render, view);
-	if (!layout || layout.status === "unsupported-presentation") throw new TypeError("Offset presentation is unavailable");
-	return placePointSymbol(symbol, render, view, layout.display, mode);
-}
-/** Explicit alignment, also used with hysteresis by pointer editing. */
-function alignPointSymbolIndicator(symbol, render, view) {
-	const layout = resolvePointSymbolOffset(symbol, render, view);
-	if (!layout?.attachment || !layout.direction || !render.offset?.indicator) return symbol;
-	const d = layout.direction;
-	const delta = [layout.actual[0] - layout.attachment[0], layout.actual[1] - layout.attachment[1]];
-	const forward = Math.max((render.offset.indicator.minLength ?? 0) * layout.scale, delta[0] * d[0] + delta[1] * d[1]);
-	return placePointSymbol(symbol, render, view, [layout.display[0] + delta[0] - forward * d[0], layout.display[1] + delta[1] - forward * d[1]]);
+function normaliseModes(modes) {
+	if (!modes || modes.length === 0) return ["reshape", "transform"];
+	for (const m of modes) 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 movePointSymbolLocation(symbol, render, view, position) {
-	const before = resolvePointSymbolOffset(symbol, render, view);
-	let next = {
-		...clonePointSymbol(symbol),
-		position: [...position]
-	};
-	if (!symbol.offset || !before || before.status === "unsupported-presentation") return next;
-	next = placePointSymbol(next, render, view, before.display);
-	const after = resolvePointSymbolOffset(next, render, view);
-	if (before.junction && after?.attachment && after.direction && symbol.offset.indicatorLength !== void 0) next.offset.indicatorLength = indicatorLengthAt(before.junction, after.attachment, after.direction, after.scale, render.octagonSize);
-	return next;
+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;
 }
-/** Canonical resource metadata shared by native adapters and external exporters. */
-function pointSymbolResource(render) {
-	return {
-		id: render.resourceId,
-		svg: render.svg,
-		width: render.width,
-		height: render.height,
-		anchor: [render.anchor.x, render.anchor.y],
-		coreRect: {
-			x: render.octagonAnchor.x - render.octagonSize / 2,
-			y: render.octagonAnchor.y - render.octagonSize / 2,
-			width: render.octagonSize,
-			height: render.octagonSize
-		}
-	};
+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
 /**
-* Convert a resolved CSS-pixel layout to output units (e.g. 25.4 / 96 for mm).
-* Scales positions, body scale, line width and dashes together, including the
-* already-resolved offset and padding. Canonical resources, direction, rotation
-* and opacity stay unchanged. Does not mutate the input or authored symbol.
+* Error thrown when any `TacticalDraw` method is called after `destroy()`.
+* See PRD #40 / issue #45.
 */
-function scalePointSymbolLayout(layout, factor) {
-	if (!Number.isFinite(factor) || factor <= 0) throw new RangeError("Layout scale factor must be positive and finite");
-	const point = ([x, y]) => [x * factor, y * factor];
-	return {
-		...layout,
-		actual: point(layout.actual),
-		display: point(layout.display),
-		imageAnchor: point(layout.imageAnchor),
-		ordinaryDisplay: point(layout.ordinaryDisplay),
-		attachment: layout.attachment && point(layout.attachment),
-		junction: layout.junction && point(layout.junction),
-		path: layout.path.map(point),
-		scale: layout.scale * factor,
-		connectorStyle: {
-			...layout.connectorStyle,
-			strokeWidth: layout.connectorStyle.strokeWidth * factor,
-			strokeDash: layout.connectorStyle.strokeDash.map((length) => length * factor)
-		}
-	};
-}
+var TacticalDrawDestroyedError = class TacticalDrawDestroyedError extends Error {
+	constructor(message = "TacticalDraw instance has been destroyed") {
+		super(message);
+		this.name = "TacticalDrawDestroyedError";
+		Object.setPrototypeOf(this, TacticalDrawDestroyedError.prototype);
+	}
+};
+var PointSymbolCapabilityRequiredError = class extends Error {
+	constructor() {
+		super("TacticalDraw: point-symbol capability is not configured");
+		this.name = "PointSymbolCapabilityRequiredError";
+	}
+};
+var ImageCapabilityRequiredError = class ImageCapabilityRequiredError extends Error {
+	constructor() {
+		super("TacticalDraw: image capability is not configured");
+		this.name = "ImageCapabilityRequiredError";
+		Object.setPrototypeOf(this, ImageCapabilityRequiredError.prototype);
+	}
+};
 //#endregion
 //#region src/tactical-draw/point-symbol-rendering.ts
 /** Complete rotated logical footprint for selection and transform chrome. */
@@ -6626,6 +6775,8 @@ function runPointSymbolEdit(opts) {
 	const { adapter, capability, symbol, graphicsLayer, previewLayer, handlesLayer, signal, closeOnClickAway = true, interactionStyle, onSession, handleIdPrefix, settleToGraphics, publishWorkingGraphic, wasOnGraphicsLayer, onSettled, onClickAwayGraphicsPick, snap } = opts;
 	let modes = normalisePointModes(opts.modes ?? (symbol.offset ? ["transform", "offset"] : ["transform"]));
 	let usesGraphicStack = wasOnGraphicsLayer;
+	let pinEditing = !!opts.renderPin && opts.modes === void 0;
+	let pinDrag = null;
 	let working = clonePointSymbol(symbol);
 	let dirty = false;
 	let box = null;
@@ -6650,6 +6801,23 @@ function runPointSymbolEdit(opts) {
 	});
 	const render = () => {
 		if (ctx.settled) return;
+		if (pinEditing && opts.renderPin && opts.canRenderPin?.()) {
+			const group = opts.renderPin(working);
+			publishWorkingGraphic(group);
+			ctx.writeLayer(previewLayer, usesGraphicStack ? [] : [group]);
+			ctx.writeLayer(handlesLayer, group.pin ? [{
+				id: `${handleIdPrefix}:pin`,
+				features: [],
+				iconResources: [],
+				pin: {
+					...group.pin,
+					highlightOnly: true
+				}
+			}] : []);
+			currentLayout = null;
+			box = null;
+			return;
+		}
 		const plan = renderPointSymbolForAdapter(adapter, capability, working);
 		currentLayout = plan.layout;
 		const nextBox = symbolBox(adapter, working, plan.render, interactionStyle?.boxPadding);
@@ -6792,6 +6960,7 @@ function runPointSymbolEdit(opts) {
 		setModes(next) {
 			if (ctx.settled) return;
 			modes = normalisePointModes(next);
+			pinEditing = false;
 			render();
 		},
 		updateGraphic(updater) {
@@ -6815,6 +6984,18 @@ function runPointSymbolEdit(opts) {
 	};
 	const pointerAngle = (pixel, anchor) => Math.atan2(pixel[1] - anchor[1], pixel[0] - anchor[0]);
 	const onDown = (pixel, info) => {
+		if (pinEditing && opts.canRenderPin?.() && !ctx.settled) {
+			const footprint = adapter.getPinFootprint?.(working.id);
+			if (footprint && adapter.pickPin?.(working.id, pixel, info?.hitTolerance ?? 12)) {
+				pinDrag = {
+					start: clonePointSymbol(working),
+					down: [...pixel],
+					attachment: footprint.attachment
+				};
+				driver.setDragPanEnabled(false);
+			}
+			return;
+		}
 		if (ctx.settled || !box || !currentLayout || modes.includes("delete")) return;
 		let offsetMode = modes.includes("offset");
 		if (!offsetMode && !modes.includes("transform")) return;
@@ -6849,6 +7030,13 @@ function runPointSymbolEdit(opts) {
 		driver.setDragPanEnabled(false);
 	};
 	const transformed = (pixel, info) => {
+		if (pinDrag) {
+			const position = adapter.movePinFromPixel?.(working.id, [pinDrag.attachment[0] + pixel[0] - pinDrag.down[0], pinDrag.attachment[1] + pixel[1] - pinDrag.down[1]]);
+			return position ? {
+				...clonePointSymbol(pinDrag.start),
+				position
+			} : null;
+		}
 		if (!drag) return null;
 		let next = clonePointSymbol(drag.start);
 		const intrinsic = drag.render;
@@ -6905,6 +7093,16 @@ function runPointSymbolEdit(opts) {
 		render();
 	};
 	const onUp = (pixel, info) => {
+		if (pinDrag) {
+			const next = transformed(pixel, info), start = pinDrag.start, down = pinDrag.down;
+			pinDrag = null;
+			driver.setDragPanEnabled(true);
+			shell.suppressNextClickAway();
+			working = clonePointSymbol(start);
+			if (next && !withinClickSlop(pixel, down)) apply(next, "gesture", "Move unit");
+			else render();
+			return;
+		}
 		if (!drag) return;
 		const currentDrag = drag;
 		const next = transformed(pixel, info);
@@ -6927,7 +7125,9 @@ function runPointSymbolEdit(opts) {
 		previewLayer,
 		handlesLayer,
 		closeOnClickAway,
-		onViewChange: render,
+		onViewChange: () => {
+			if (!pinEditing || !opts.canRenderPin?.()) render();
+		},
 		onBeforeTeardown: (settlement) => {
 			settleToGraphics(settlement.status === "committed" ? settlement.value.graphic : void 0);
 		},
@@ -6952,6 +7152,7 @@ function runPointSymbolEdit(opts) {
 	});
 	return {
 		promise: handle.promise,
+		refreshPresentation: render,
 		get settled() {
 			return handle.settled;
 		},
@@ -7449,6 +7650,9 @@ var TacticalDraw = class {
 	* `render()` so outlines track geometry, style, and dropped graphics.
 	*/
 	highlightedIds = [];
+	pinBodies = /* @__PURE__ */ new WeakMap();
+	pins = new PinPresentationStore();
+	unsubscribePins;
 	/**
 	* Whether the highlight layer currently holds any outline. Lets
 	* `renderHighlights` skip a redundant empty write on every view change /
@@ -7484,6 +7688,54 @@ var TacticalDraw = class {
 		this.adapter.setLayerStyle(this.guideLayer, guideToStyleOptions(this.baseGuideStyle()));
 		this.adapter.setLayerStyle(this.highlightLayer, guideToStyleOptions(this.baseHighlightStyle()));
 		this.adapter.onViewChange(this.handleViewChange);
+		this.unsubscribePins = this.pins.onChange(() => {
+			this.invalidateGraphicGroupCache(false);
+			this.refreshActiveEditPresentation();
+			this.reconcileGraphicsStack();
+			this.renderHighlights();
+		});
+	}
+	setPinPresentation(defaults) {
+		this.assertAlive();
+		this.pins.setDefaults(defaults);
+	}
+	setPinOverride(id, patch) {
+		this.assertAlive();
+		this.pins.setOverride(id, patch);
+	}
+	resetPinOverride(id) {
+		this.assertAlive();
+		this.pins.resetOverride(id);
+	}
+	getPinPresentationCapability(id) {
+		return this.adapter.getPinPresentationCapability?.(id) ?? {
+			status: "unsupported",
+			reason: "This map adapter uses ordinary point-symbol presentation"
+		};
+	}
+	onPinPresentationStatusChange(listener) {
+		this.assertAlive();
+		return this.adapter.onPinPresentationStatusChange?.(listener) ?? (() => {});
+	}
+	getPinPresentationState() {
+		return this.pins.getState();
+	}
+	/**
+	* Let an in-flight edit session re-read pin presentation, when it is a kind
+	* of session that renders pins at all. Both the presentation-store change
+	* handler and the adapter-capability change in `handleViewChange` need it.
+	*/
+	refreshActiveEditPresentation() {
+		if (this.activeEdit && "refreshPresentation" in this.activeEdit) this.activeEdit.refreshPresentation();
+	}
+	/**
+	* Whether a point symbol should render as a billboard pin rather than an
+	* ordinary point symbol: its own presentation opts in, and the adapter
+	* currently supports rendering pins. Pass an already-resolved
+	* `presentation` to skip re-resolving it when a caller has one in hand.
+	*/
+	graphicUsesPinPresentation(graphic, presentation) {
+		return (presentation ?? this.pins.resolve(graphic.id)).enabled && this.adapter.getPinPresentationCapability?.().status === "supported";
 	}
 	/** Change the default shortcut for subsequent drags, including in an active edit. */
 	setOffsetDragModifier(modifier) {
@@ -7523,9 +7775,10 @@ var TacticalDraw = class {
 			if (cached.dependence === "none") return cached.group;
 			if (cached.dependence === "resolution" && Object.is(cached.resolution, this.adapter.getResolution())) return cached.group;
 		}
-		const dependence = graphicViewDependence(graphic, this.adapter.scalesGroundPointSymbolsNatively === true);
+		const presentation = isPointSymbol(graphic) ? this.pins.resolve(graphic.id) : void 0;
+		const dependence = presentation && this.graphicUsesPinPresentation(graphic, presentation) ? "none" : graphicViewDependence(graphic, this.adapter.scalesGroundPointSymbolsNatively === true);
 		const resolution = dependence === "none" ? void 0 : this.adapter.getResolution();
-		const group = this.buildGraphicGroup(graphic);
+		const group = this.buildGraphicGroup(graphic, presentation);
 		this.graphicGroupCache.set(graphic, {
 			group,
 			dependence,
@@ -7538,10 +7791,49 @@ var TacticalDraw = class {
 	* drawn from the module-scoped {@link nextGraphicGroupRevision} counter (see
 	* its doc comment for why it isn't a per-instance field).
 	*/
-	buildGraphicGroup(graphic) {
+	buildGraphicGroup(graphic, resolved) {
 		const revision = ++nextGraphicGroupRevision;
 		if (isPointSymbol(graphic)) {
 			if (!this.pointSymbols) throw new PointSymbolCapabilityRequiredError();
+			const presentation = resolved ?? this.pins.resolve(graphic.id);
+			if (this.graphicUsesPinPresentation(graphic, presentation)) {
+				const body = this.pinBodies.get(graphic) ?? this.pointSymbols.render({
+					...graphic,
+					graphicModifiers: {
+						...graphic.graphicModifiers,
+						direction: void 0
+					}
+				});
+				this.pinBodies.set(graphic, body);
+				const resource = pointSymbolResource(body);
+				return {
+					id: graphic.id,
+					revision,
+					features: [{
+						type: "Feature",
+						id: `${graphic.id}:pin`,
+						geometry: {
+							type: "Point",
+							coordinates: [...graphic.position]
+						},
+						properties: {
+							graphicId: graphic.id,
+							graphicKind: "point-symbol",
+							pinPresentation: true
+						}
+					}],
+					iconResources: [],
+					pin: {
+						id: graphic.id,
+						position: graphic.position,
+						resource,
+						octagonSize: body.octagonSize,
+						presentation,
+						opacity: (graphic.style?.opacity ?? 1) * (graphic.style?.overallOpacity ?? 1),
+						...graphic.graphicModifiers?.direction !== void 0 ? { direction: graphic.rotation + graphic.graphicModifiers.direction } : {}
+					}
+				};
+			}
 			const plan = renderPointSymbolForAdapter(this.adapter, this.pointSymbols, graphic);
 			return {
 				id: graphic.id,
@@ -7577,7 +7869,8 @@ var TacticalDraw = class {
 	* View changes are handled per entry by {@link renderGraphicGroup} so
 	* resolution-independent graphics remain cache hits.
 	*/
-	invalidateGraphicGroupCache() {
+	invalidateGraphicGroupCache(clearBodies = true) {
+		if (clearBodies) this.pinBodies = /* @__PURE__ */ new WeakMap();
 		this.graphicGroupCache = /* @__PURE__ */ new WeakMap();
 	}
 	/** Refresh capability-dependent renders before any caller-visible state is mutated. */
@@ -7619,8 +7912,16 @@ var TacticalDraw = class {
 	* point symbols and transform members already present in the host stack do
 	* the same. Graphics without a host slot remain on preview.
 	*/
+	pinSupport;
 	handleViewChange = () => {
 		if (this.destroyed) return;
+		const support = this.adapter.getPinPresentationCapability?.().status;
+		if (support !== this.pinSupport) {
+			this.pinSupport = support;
+			this.refreshActiveEditPresentation();
+			this.invalidateGraphicGroupCache();
+			if (this.hasRendered) this.reconcileGraphicsStack();
+		}
 		const resolution = this.adapter.getResolution();
 		const resolutionChanged = !Object.is(resolution, this.lastViewResolution);
 		this.lastViewResolution = resolution;
@@ -7630,7 +7931,7 @@ var TacticalDraw = class {
 		if (!resolutionChanged && !this.lastRenderedHasViewDependent) return;
 		const excluded = this.graphicsStackExcludedIds();
 		const visible = excluded.size > 0 ? this.lastRenderedMeasures.filter((m) => !excluded.has(m.id)) : this.lastRenderedMeasures;
-		if (!visible.some((g) => graphicViewDependence(g, nativePointSymbolScaling) !== "none")) return;
+		if (!visible.some((g) => this.renderGraphicGroup(g).pin ? false : graphicViewDependence(g, nativePointSymbolScaling) !== "none")) return;
 		this.reconcileGraphicsStack(visible);
 	};
 	/**
@@ -7714,7 +8015,7 @@ var TacticalDraw = class {
 			}
 		}
 		this.lastRenderedMeasures = measures.slice();
-		this.lastRenderedHasViewDependent = this.lastRenderedMeasures.some((g) => graphicViewDependence(g, this.adapter.scalesGroundPointSymbolsNatively === true) === "view");
+		this.lastRenderedHasViewDependent = this.lastRenderedMeasures.some((g) => !this.renderGraphicGroup(g).pin && graphicViewDependence(g, this.adapter.scalesGroundPointSymbolsNatively === true) === "view");
 		this.graphicStack.acknowledgeHostRender(measures);
 		if (activeEdit && "syncHostMembership" in activeEdit && measures.some((graphic) => graphic.id === activeEdit.measureId && graphic.kind === activeEdit.graphicKind)) activeEdit.syncHostMembership(true);
 		(this.activeTransform ?? this.activeTransformSessionRef)?.syncHostGraphics(measures);
@@ -7769,10 +8070,26 @@ var TacticalDraw = class {
 		const excluded = this.excludedInteractionIds();
 		const bearing = this.adapter.getBearing();
 		const features = [];
+		const pinGroups = [];
 		for (const id of this.highlightedIds) {
 			if (excluded.has(id)) continue;
 			const graphic = this.lastRenderedMeasures.find((g) => g.id === id);
 			if (!graphic) continue;
+			if (isPointSymbol(graphic)) {
+				const pin = this.renderGraphicGroup(graphic).pin;
+				if (pin) {
+					pinGroups.push({
+						id: `__td_highlight__:${id}`,
+						features: [],
+						iconResources: [],
+						pin: {
+							...pin,
+							highlightOnly: true
+						}
+					});
+					continue;
+				}
+			}
 			const box = this.highlightBoxForGraphic(graphic, bearing, padding);
 			if (!box) continue;
 			let invertFailed = false;
@@ -7787,12 +8104,12 @@ var TacticalDraw = class {
 			const feature = boxOutlineFeature(box, invert, `__td_highlight__:${id}`, style);
 			if (!invertFailed) features.push(feature);
 		}
-		this.adapter.setLayerFeatureGroups(this.highlightLayer, features.map((feature) => ({
+		this.adapter.setLayerFeatureGroups(this.highlightLayer, [...pinGroups, ...features.map((feature) => ({
 			id: String(feature.id),
 			features: [feature],
 			iconResources: []
-		})));
-		this.hasHighlightOutlines = features.length > 0;
+		}))]);
+		this.hasHighlightOutlines = features.length > 0 || pinGroups.length > 0;
 	}
 	/**
 	* Fit the passive-highlight transform box for one graphic: the point-symbol
@@ -8066,6 +8383,10 @@ var TacticalDraw = class {
 				adapter: this.adapter,
 				capability: this.pointSymbols,
 				symbol: measure,
+				...this.graphicUsesPinPresentation(measure) ? {
+					renderPin: (symbol) => this.buildGraphicGroup(symbol),
+					canRenderPin: () => this.graphicUsesPinPresentation(measure)
+				} : {},
 				offsetDragModifier: () => options?.offsetDragModifier ?? this.offsetDragModifier,
 				graphicsLayer: this.graphicsLayer,
 				previewLayer: this.previewLayer,
@@ -8432,6 +8753,7 @@ var TacticalDraw = class {
 	* the first call every public method throws `TacticalDrawDestroyedError`.
 	*/
 	destroy() {
+		this.unsubscribePins();
 		if (this.destroyed) return;
 		this.destroyed = true;
 		if (this.activeInteraction.isActive) {
@@ -8706,32 +9028,22 @@ function fillPatternImageDimension(pixelRatio) {
 	return 2 ** Math.ceil(Math.log2(target));
 }
 /**
-* Parse a hex (`#rgb`, `#rrggbb`, `#rrggbbaa`) or `rgb()`/`rgba()` color
-* string into normalized channels, alpha in `[0, 1]`. Unparseable input falls
-* back to opaque black rather than throwing, since a mis-themed fill should
-* still render *something*.
+* Parse a hex (`#rgb`, `#rgba`, `#rrggbb`, `#rrggbbaa`) or `rgb()`/`rgba()`
+* color string into normalized channels, alpha in `[0, 1]`. Unparseable input
+* falls back to opaque black rather than throwing, since a mis-themed fill
+* should still render *something*. Shared by every renderer that needs CSS
+* colors as numbers — hatch fills here, billboard pins in the MapLibre
+* adapter — so the accepted syntax stays identical across them.
 */
 function parseColor(color) {
 	const s = color.trim();
 	if (s.startsWith("#")) {
-		const hex = s.slice(1);
-		if (hex.length === 3) return {
-			r: parseInt(hex[0] + hex[0], 16),
-			g: parseInt(hex[1] + hex[1], 16),
-			b: parseInt(hex[2] + hex[2], 16),
-			a: 1
-		};
-		if (hex.length === 6) return {
-			r: parseInt(hex.slice(0, 2), 16),
-			g: parseInt(hex.slice(2, 4), 16),
-			b: parseInt(hex.slice(4, 6), 16),
-			a: 1
-		};
-		if (hex.length === 8) return {
+		const hex = s.length <= 5 ? s.slice(1).replace(/./g, (c) => c + c) : s.slice(1);
+		if (hex.length === 6 || hex.length === 8) return {
 			r: parseInt(hex.slice(0, 2), 16),
 			g: parseInt(hex.slice(2, 4), 16),
 			b: parseInt(hex.slice(4, 6), 16),
-			a: parseInt(hex.slice(6, 8), 16) / 255
+			a: hex.length === 8 ? parseInt(hex.slice(6, 8), 16) / 255 : 1
 		};
 	}
 	const fn = s.match(/^rgba?\(([^)]+)\)$/i);
@@ -8936,4 +9248,4 @@ function nearestWorldCopyPosition(position, refLng) {
 	return [nearestWorldCopyLng(position[0], refLng), ...position.slice(1)];
 }
 //#endregion
-export { BaseMapAdapter, DEFAULT_LABEL_SIZE_PIXELS, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, HATCH_PATTERNS, ImageCapabilityRequiredError, MINE_PATTERN_TILE_SIZE, PointSymbolCapabilityRequiredError, PointerCallbackHub, TEXT_HALO_COLOR, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, TacticalDrawDestroyedError, alignPointSymbolIndicator, bindAbortable, cloneImageGraphic, clonePointSymbol, coerceHandleStyle, combineWithHostSignal, convertPointSymbolPlacement, effectivePointSymbolPixelSize, evaluatePickCandidates, fillPatternImageDimension, fillPatternImageId, getSizeAnchor, hitTestFeature, hitTestIconFeature, ignoreAbort, imageFootprint, imageOpacity, isAnchoredGraphic, isImageGraphic, isMinePattern, isPointSymbol, isTacticalDrawAbortError, makeFillPatternImage, mergeNativeAndCachedPickFeatures, movePointSymbolLocation, nearestWorldCopyLng, nearestWorldCopyPosition, normalizeImageGraphic, pickHitTolerance, pickPointerType, placePointSymbol, pointSymbolFootprint, pointSymbolResource, renderOrderToVisualOrder, resizePointSymbolSize, resolveGroundTextSizePixels, resolvePickPresentation, resolvePointSymbolOffset, resolveTextHaloWidth, resolveTextSizePixels, scalePointSymbolLayout, tryControlMeasureIdFromFeature, validateImageGraphic };
+export { BaseMapAdapter, DEFAULT_LABEL_SIZE_PIXELS, DEFAULT_PIN_PRESENTATION, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, HATCH_PATTERNS, ImageCapabilityRequiredError, MINE_PATTERN_TILE_SIZE, PinPresentationStore, PointSymbolCapabilityRequiredError, PointerCallbackHub, TEXT_HALO_COLOR, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, TacticalDrawDestroyedError, alignPointSymbolIndicator, bindAbortable, cloneImageGraphic, clonePointSymbol, coerceHandleStyle, combineWithHostSignal, convertPointSymbolPlacement, effectivePointSymbolPixelSize, evaluatePickCandidates, fillPatternImageDimension, fillPatternImageId, getSizeAnchor, hitTestFeature, hitTestIconFeature, ignoreAbort, imageFootprint, imageOpacity, isAnchoredGraphic, isImageGraphic, isMinePattern, isPointSymbol, isTacticalDrawAbortError, isValidPinNumber, makeFillPatternImage, mergeNativeAndCachedPickFeatures, movePointSymbolLocation, nearestWorldCopyLng, nearestWorldCopyPosition, normalizeImageGraphic, parseColor, pickHitTolerance, pickPointerType, placePointSymbol, pointSymbolFootprint, pointSymbolResource, renderOrderToVisualOrder, resizePointSymbolSize, resolveGroundTextSizePixels, resolvePickPresentation, resolvePinPresentation, resolvePointSymbolOffset, resolveTextHaloWidth, resolveTextSizePixels, scalePointSymbolLayout, tryControlMeasureIdFromFeature, validateImageGraphic };