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

package/dist/index.mjs

@@ -15,6 +15,8 @@ var BaseMapAdapter = class {
 	viewChangeTokens = /* @__PURE__ */ new Map();
 	featureCache = /* @__PURE__ */ new Map();
 	featuresChangedListeners = /* @__PURE__ */ new Map();
+	iconResources = /* @__PURE__ */ new Map();
+	layerIconResourceIds = /* @__PURE__ */ new Map();
 	layerCounter = 0;
 	destroyed = false;
 	nextLayerId() {
@@ -34,6 +36,19 @@ var BaseMapAdapter = class {
 		this.layers.delete(layerId);
 		this.featureCache.delete(layerId);
 		this.featuresChangedListeners.delete(layerId);
+		this.layerIconResourceIds.delete(layerId);
+		this.pruneIconResources();
+	}
+	reconcileLayerIconResources(layerId, resources) {
+		if (!this.layers.has(layerId)) return;
+		const ids = /* @__PURE__ */ new Set();
+		for (const resource of resources) {
+			ids.add(resource.id);
+			this.iconResources.set(resource.id, resource);
+		}
+		this.layerIconResourceIds.set(layerId, ids);
+		this.applyIconResources(resources);
+		this.pruneIconResources();
 	}
 	setLayerFeatures(layerId, features) {
 		if (!this.layers.has(layerId)) return;
@@ -148,6 +163,9 @@ var BaseMapAdapter = class {
 			this.layers.clear();
 			this.featureCache.clear();
 			this.featuresChangedListeners.clear();
+			for (const id of this.iconResources.keys()) this.removeIconResource(id);
+			this.iconResources.clear();
+			this.layerIconResourceIds.clear();
 			this.destroyEngineResources();
 		} finally {
 			this.destroyed = true;
@@ -173,6 +191,22 @@ var BaseMapAdapter = class {
 		};
 	}
 	destroyEngineResources() {}
+	applyIconResources(resources) {}
+	getIconResource(id) {
+		return this.iconResources.get(id);
+	}
+	removeIconResource(id) {}
+	pruneIconResources() {
+		const active = /* @__PURE__ */ new Set();
+		for (const ids of this.layerIconResourceIds.values()) for (const id of ids) active.add(id);
+		if (this.iconResources.size <= active.size + 32) return;
+		for (const id of this.iconResources.keys()) {
+			if (active.has(id)) continue;
+			this.iconResources.delete(id);
+			this.removeIconResource(id);
+			if (this.iconResources.size <= active.size + 32) break;
+		}
+	}
 	/**
 	* Default for engines/views that don't rotate (Leaflet). Rotating engines
 	* (MapLibre, OpenLayers) override this.
@@ -206,6 +240,8 @@ function mapEventHitTolerance(originalEvent) {
 	return direct;
 }
 function tryControlMeasureIdFromFeature(feature) {
+	const graphicId = feature.properties?.graphicId;
+	if (typeof graphicId === "string" && graphicId.length > 0) return graphicId;
 	try {
 		return controlMeasureIdFromFeature(feature);
 	} catch {
@@ -335,6 +371,33 @@ function hitTestFeature(pixel, features, hitTolerance, toPixel) {
 	}
 	return null;
 }
+/**
+* Test a rendered icon-backed Point feature against its actual pixel footprint.
+* The feature carries the adapter-neutral `iconScale` / `iconRotation` values
+* emitted by TacticalDraw; `resource.anchor` is the placement anchor within the
+* unscaled SVG viewport. A positive tolerance pads all four sides.
+*/
+function hitTestIconFeature(pixel, feature, resource, hitTolerance, toPixel, bearing = 0) {
+	if (feature.geometry.type !== "Point") return false;
+	const anchor = toPixel(feature.geometry.coordinates);
+	if (!anchor) return false;
+	const rawScale = feature.properties?.iconScale;
+	const scale = typeof rawScale === "number" ? rawScale : 1;
+	if (!Number.isFinite(scale) || scale <= 0) return false;
+	const rawRotation = feature.properties?.iconRotation;
+	const angle = (typeof rawRotation === "number" && Number.isFinite(rawRotation) ? rawRotation : 0) - bearing;
+	const cos = Math.cos(angle);
+	const sin = Math.sin(angle);
+	const dx = pixel[0] - anchor[0];
+	const dy = pixel[1] - anchor[1];
+	const localX = dx * cos + dy * sin;
+	const localY = -dx * sin + dy * cos;
+	const minX = -resource.anchor[0] * scale - hitTolerance;
+	const maxX = (resource.width - resource.anchor[0]) * scale + hitTolerance;
+	const minY = -resource.anchor[1] * scale - hitTolerance;
+	const maxY = (resource.height - resource.anchor[1]) * scale + hitTolerance;
+	return localX >= minX && localX <= maxX && localY >= minY && localY <= maxY;
+}
 //#endregion
 //#region src/gestures/hit-tolerance.ts
 const TOUCH_HIT_TOLERANCE_PX = 22;
@@ -388,6 +451,14 @@ var PointerCallbackHub = class {
 	}
 };
 //#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);
+}
+//#endregion
 //#region src/tactical-draw/active-interaction.ts
 /**
 * Owns the facade's public interaction state: the abort handle used by
@@ -1025,7 +1096,7 @@ function runFixedLengthDraw(options) {
 		});
 		const measure = sizeAnchor === "screen" ? captured : bakePixelSizeToGround(captured, adapter);
 		return {
-			measure: cloneControlMeasure(measure),
+			graphic: cloneControlMeasure(measure),
 			render: renderMeasureForAdapter(adapter, measure, renderOpts)
 		};
 	}
@@ -1175,7 +1246,7 @@ function createSettleEmitter(listenerErrorsMessage) {
 * `EditSession.onCommit`, and `DrawSession.onCommit`: a listener set with
 * synchronous, exception-collecting emission (single rethrow, `AggregateError`
 * otherwise). Unlike `createSettleEmitter`, `emit` may be called more than
-* once — a transform's `setMembers` can commit several removal batches before
+* 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`.
@@ -1397,7 +1468,7 @@ function runVariableLengthDraw(options) {
 		});
 		const measure = sizeAnchor === "screen" ? built : bakePixelSizeToGround(built, adapter);
 		return {
-			measure: cloneControlMeasure(measure),
+			graphic: cloneControlMeasure(measure),
 			render: renderMeasureForAdapter(adapter, measure, renderOpts)
 		};
 	}
@@ -2188,7 +2259,7 @@ const LABEL_HANDLE_OFFSET_PX = 14;
 * Corner/rotate drags commit even at zero movement (matches the pre-ADR-0017
 * translate/rotate seams).
 */
-const CLICK_SLOP_PX$1 = 3;
+const CLICK_SLOP_PX$3 = 3;
 const ALLOWED_EDIT_MODES = new Set([
 	"reshape",
 	"transform",
@@ -2464,7 +2535,7 @@ function runEdit(opts) {
 		else delete working.amplifierPlacements;
 		const committed = sizeAnchor === "screen" ? working : bakePixelSizeToGround(working, adapter);
 		return {
-			measure: cloneControlMeasure(committed),
+			graphic: cloneControlMeasure(committed),
 			render: renderMeasureForAdapter(adapter, committed, renderOpts)
 		};
 	}
@@ -2519,7 +2590,7 @@ function runEdit(opts) {
 		let closeRequested = false;
 		let abortRequested = false;
 		const event = {
-			measure: currentRendered,
+			graphic: currentRendered,
 			previous: previousRendered,
 			session,
 			reject() {
@@ -2785,7 +2856,17 @@ function runEdit(opts) {
 		applyModes(next);
 	}
 	const session = {
-		measure,
+		graphic: measure,
+		get workingGraphic() {
+			return cloneControlMeasure({
+				...measure,
+				controlPoints: workingPoints.map((point) => [...point]),
+				options: { ...workingOptions ?? {} },
+				style: currentStyle ? { ...currentStyle } : void 0,
+				textAmplifiers: workingTextAmplifiers ? { ...workingTextAmplifiers } : void 0,
+				amplifierPlacements: snapshotAmplifierPlacements()
+			});
+		},
 		get controlPoints() {
 			return workingPoints.map((p) => [...p]);
 		},
@@ -2826,6 +2907,26 @@ function runEdit(opts) {
 			}
 			applyModes(normalised);
 		},
+		updateGraphic(updater) {
+			if (ctx.settled) return;
+			const previous = rebuildRendered();
+			const previousNonGeometryDirty = nonGeometryDirty;
+			const previousSizeAnchor = sizeAnchor;
+			const current = session.workingGraphic;
+			const next = updater(current);
+			if (next.id !== measure.id || next.kind !== measure.kind) throw new TypeError("updateGraphic must preserve control-measure id and kind");
+			renderMeasureForAdapter(adapter, next, renderOpts);
+			workingPoints.splice(0, workingPoints.length, ...next.controlPoints.map((point) => [...point]));
+			workingOptions = { ...next.options ?? {} };
+			currentStyle = next.style ? { ...next.style } : void 0;
+			workingTextAmplifiers = next.textAmplifiers ? { ...next.textAmplifiers } : void 0;
+			workingAmplifierPlacements = next.amplifierPlacements ? structuredClone(next.amplifierPlacements) : void 0;
+			nonGeometryDirty = true;
+			renderPreview();
+			renderHandlesLayer();
+			recomputeDirty();
+			emitChange(previous, previous.graphic.controlPoints.map((point) => [...point]), previous.graphic.options, previous.graphic.style, previousNonGeometryDirty, previousSizeAnchor, rebuildRendered(), previous.graphic.textAmplifiers, previous.graphic.amplifierPlacements);
+		},
 		setOptions(partial) {
 			setOptions(partial);
 		},
@@ -3189,7 +3290,7 @@ function runEdit(opts) {
 			activeLabelRotateDrag = null;
 			workingAmplifierPlacements = drag.previous;
 			endDragBookkeeping();
-			if (Math.hypot(pixel[0] - drag.downPixel[0], pixel[1] - drag.downPixel[1]) > CLICK_SLOP_PX$1) {
+			if (Math.hypot(pixel[0] - drag.downPixel[0], pixel[1] - drag.downPixel[1]) > CLICK_SLOP_PX$3) {
 				const delta = pointerAngleAround(pixel, drag.anchorPixel) - drag.startPointerAngle;
 				const rotation = drag.startRotation - delta;
 				setAmplifierPlacements({ [drag.key]: { rotation } });
@@ -3206,7 +3307,7 @@ function runEdit(opts) {
 			const position = labelAnchorFromPointer(pixel, grabOffset);
 			workingAmplifierPlacements = previous;
 			endDragBookkeeping();
-			if (position && Math.hypot(pixel[0] - downPixel[0], pixel[1] - downPixel[1]) > CLICK_SLOP_PX$1) setAmplifierPlacements({ [field]: position });
+			if (position && Math.hypot(pixel[0] - downPixel[0], pixel[1] - downPixel[1]) > CLICK_SLOP_PX$3) setAmplifierPlacements({ [field]: position });
 			else {
 				selectedLabelKey = selectedLabelKey === field ? null : field;
 				renderPreview();
@@ -3241,7 +3342,7 @@ function runEdit(opts) {
 			activeBoxDrag = null;
 			driver.setDragPanEnabled(true);
 			const distance = Math.hypot(pixel[0] - downPixel[0], pixel[1] - downPixel[1]);
-			if (fsm.kind === "body" && distance <= CLICK_SLOP_PX$1) {
+			if (fsm.kind === "body" && distance <= CLICK_SLOP_PX$3) {
 				replaceWorkingPoints(preDragPoints);
 				workingAmplifierPlacements = preDragAmplifierPlacements;
 				renderPreview();
@@ -3414,7 +3515,7 @@ const HANDLE_HIT_TOLERANCE_PX = 12;
 * click, not a gesture — same rationale as `edit-controller.ts`'s constant of
 * the same name.
 */
-const CLICK_SLOP_PX = 3;
+const CLICK_SLOP_PX$2 = 3;
 /**
 * Drive an interactive group transform against a `MapAdapter` — the leaner,
 * multi-select sibling of `runEdit` (ADR-0017 "Multi-select" slice). No
@@ -3430,7 +3531,7 @@ const CLICK_SLOP_PX = 3;
 *    thin outline (its own fit at the same angle)
 *  - dirty tracking, close/abort/signal/preempt/destroy, click-away — same
 *    contracts as `runEdit`, scoped to the group
-*  - membership is mutable via `session.setMembers` (#187): members join/leave
+*  - membership is mutable via `session.setGraphics` (#187): members join/leave
 *    a live session without a session boundary
 */
 function runGroupTransform(opts) {
@@ -3454,7 +3555,7 @@ function runGroupTransform(opts) {
 	let members = measures.map(createMemberState);
 	/**
 	* `true` once any member has been lifted off the graphics layer (initial or a
-	* mid-session `setMembers` add). Gates the abort-path restore so a session
+	* mid-session `setGraphics` add). Gates the abort-path restore so a session
 	* that never touched the graphics layer doesn't rewrite it on abort.
 	*/
 	let anyLiftedFromGraphics = false;
@@ -3481,7 +3582,7 @@ function runGroupTransform(opts) {
 		};
 		const committed = sizeAnchor === "screen" ? working : bakePixelSizeToGround(working, adapter);
 		return {
-			measure: cloneControlMeasure(committed),
+			graphic: cloneControlMeasure(committed),
 			render: renderMeasureForAdapter(adapter, committed, renderOpts)
 		};
 	}
@@ -3711,7 +3812,7 @@ function runGroupTransform(opts) {
 		let closeRequested = false;
 		let abortRequested = false;
 		const event = {
-			measures: currentRendered,
+			graphics: currentRendered,
 			previous: previousRendered,
 			session,
 			reject() {
@@ -3808,7 +3909,7 @@ function runGroupTransform(opts) {
 	/**
 	* Cancel an in-flight box drag without committing it: restore the pre-drag
 	* geometry and option overrides, re-enable drag pan, and clear the drag. Used
-	* by `setMembers` so a membership change never bakes a half-finished drag; the
+	* by `setGraphics` so a membership change never bakes a half-finished drag; the
 	* caller is responsible for the follow-up repaint (`renderAllPreviews` /
 	* `renderHandlesLayer` / `recomputeDirty`), so this leaves the paint to it
 	* rather than rendering the outgoing member set only to redo it immediately.
@@ -3823,11 +3924,11 @@ function runGroupTransform(opts) {
 		applyOptionsOverrides(preDragOptionsOverrideByMember);
 		dragInFlight = false;
 	}
-	function setMembers(next) {
+	function setGraphics(next) {
 		if (ctx.settled) return void 0;
 		const seen = /* @__PURE__ */ new Set();
 		for (const m of next) {
-			if (seen.has(m.id)) throw new TypeError(`TransformSession.setMembers: duplicate control measure id "${m.id}"`);
+			if (seen.has(m.id)) throw new TypeError(`TransformSession.setGraphics: duplicate control measure id "${m.id}"`);
 			seen.add(m.id);
 		}
 		if (next.length === 0) return close();
@@ -3857,11 +3958,11 @@ function runGroupTransform(opts) {
 		return commitClose();
 	}
 	const session = {
-		get measures() {
+		get graphics() {
 			return members.map((m) => m.measure);
 		},
-		controlPointsFor(measureId) {
-			const member = members.find((m) => m.measure.id === measureId);
+		controlPointsFor(graphicId) {
+			const member = members.find((m) => m.measure.id === graphicId);
 			if (!member) return void 0;
 			return member.workingPoints.map((p) => [...p]);
 		},
@@ -3874,7 +3975,7 @@ function runGroupTransform(opts) {
 		setSizeAnchor(next) {
 			setSizeAnchor(next);
 		},
-		setMembers,
+		setGraphics,
 		close,
 		abort() {
 			if (ctx.settled) return;
@@ -3958,7 +4059,7 @@ function runGroupTransform(opts) {
 		activeBoxDrag = null;
 		driver.setDragPanEnabled(true);
 		const distance = Math.hypot(pixel[0] - downPixel[0], pixel[1] - downPixel[1]);
-		if (fsm.kind === "body" && distance <= CLICK_SLOP_PX) {
+		if (fsm.kind === "body" && distance <= CLICK_SLOP_PX$2) {
 			applyConcatenatedPoints(preDragPoints);
 			applyAmplifierPlacementsByMember(preDragAmplifierPlacementsByMember);
 			renderAllPreviews();
@@ -4060,7 +4161,7 @@ function runGroupTransform(opts) {
 		get settled() {
 			return core.settled;
 		},
-		get measureIds() {
+		get graphicIds() {
 			return members.map((m) => m.measure.id);
 		},
 		abort(reason, cause) {
@@ -4069,6 +4170,342 @@ function runGroupTransform(opts) {
 	};
 }
 //#endregion
+//#region src/tactical-draw/point-symbol-rendering.ts
+function effectivePointSymbolPixelSize(symbol, resolution) {
+	if (symbol.size.unit === "pixels") return symbol.size.value;
+	return resolution !== void 0 && resolution > 0 ? symbol.size.value / resolution : symbol.size.value;
+}
+function pointSymbolPixelScale(symbol, render, resolution) {
+	if (!Number.isFinite(render.octagonSize) || render.octagonSize <= 0) throw new TypeError("PointSymbolRender.octagonSize must be a positive finite number");
+	return effectivePointSymbolPixelSize(symbol, resolution) / render.octagonSize;
+}
+/** Complete rotated logical footprint for selection and transform chrome. */
+function pointSymbolFootprint(symbol, render, adapter) {
+	const anchor = adapter.getPixelFromCoordinate(symbol.position);
+	if (!anchor) return null;
+	const scale = pointSymbolPixelScale(symbol, render, adapter.getResolution());
+	const angle = symbol.rotation - adapter.getBearing();
+	const centerOffsetX = (render.width / 2 - render.anchor.x) * scale;
+	const centerOffsetY = (render.height / 2 - render.anchor.y) * scale;
+	const cos = Math.cos(angle);
+	const sin = Math.sin(angle);
+	const box = {
+		center: [anchor[0] + centerOffsetX * cos - centerOffsetY * sin, anchor[1] + centerOffsetX * sin + centerOffsetY * cos],
+		halfWidth: render.width * scale / 2,
+		halfHeight: render.height * scale / 2,
+		angle
+	};
+	return {
+		box,
+		corners: boxCorners(box)
+	};
+}
+function renderPointSymbolForAdapter(adapter, capability, symbol) {
+	const render = capability.render(symbol);
+	return {
+		render,
+		resource: {
+			id: render.resourceId,
+			svg: render.svg,
+			width: render.width,
+			height: render.height,
+			anchor: [render.anchor.x, render.anchor.y]
+		},
+		feature: pointSymbolFeature(symbol, render, adapter.getResolution())
+	};
+}
+function pointSymbolFeature(symbol, render, resolution) {
+	return {
+		type: "Feature",
+		id: `${symbol.id}:point-symbol`,
+		geometry: {
+			type: "Point",
+			coordinates: [...symbol.position]
+		},
+		properties: {
+			...symbol.properties ?? {},
+			graphicId: symbol.id,
+			graphicKind: "point-symbol",
+			iconId: render.resourceId,
+			iconScale: pointSymbolPixelScale(symbol, render, resolution),
+			iconRotation: symbol.rotation,
+			iconOpacity: symbol.style?.opacity ?? 1
+		}
+	};
+}
+//#endregion
+//#region src/tactical-draw/rotation.ts
+/** Normalize radians to the canonical clockwise [0, 2π) range. */
+function normalizeRotation(angle) {
+	const turn = Math.PI * 2;
+	return (angle % turn + turn) % turn;
+}
+//#endregion
+//#region src/tactical-draw/graphic-transform-controller.ts
+const HIT_TOLERANCE_PX$1 = 12;
+const CLICK_SLOP_PX$1 = 3;
+function cloneGraphic(graphic) {
+	return isPointSymbol(graphic) ? clonePointSymbol(graphic) : cloneControlMeasure(graphic);
+}
+function runGraphicTransform(opts) {
+	const { adapter, capability, graphics, graphicsLayer, previewLayer, handlesLayer, graphicsStyle, signal, closeOnClickAway = true, interactionStyle, onSession, handleIdPrefix, restoreOriginalToGraphics, isOnGraphicsLayer, onSettled, onClickAwayGraphicsPick } = opts;
+	const original = graphics.map(cloneGraphic);
+	let working = original.map(cloneGraphic);
+	let dirty = false;
+	let boxAngle = 0;
+	let box = null;
+	let ctx;
+	let driver;
+	let drag = null;
+	const listeners = /* @__PURE__ */ new Set();
+	const commitEmitter = createCommitEmitter("GraphicTransformSession.onCommit listener errors");
+	const settleEmitter = createSettleEmitter("GraphicTransformSession.onSettled listener errors");
+	const renderOpts = graphicsStyle ? { graphicsStyle } : void 0;
+	const snapshots = () => working.map((graphic) => isPointSymbol(graphic) ? {
+		graphic: clonePointSymbol(graphic),
+		render: capability.render(graphic)
+	} : {
+		graphic: cloneControlMeasure(graphic),
+		render: renderMeasureForAdapter(adapter, graphic, renderOpts)
+	});
+	function renderAll() {
+		if (ctx.settled) return;
+		const features = [];
+		const resources = /* @__PURE__ */ new Map();
+		const pixels = [];
+		for (const graphic of working) if (isPointSymbol(graphic)) {
+			const plan = renderPointSymbolForAdapter(adapter, capability, graphic);
+			resources.set(plan.resource.id, plan.resource);
+			features.push(plan.feature);
+			const footprint = pointSymbolFootprint(graphic, plan.render, adapter);
+			if (footprint) pixels.push(...footprint.corners);
+		} else {
+			const rendered = renderMeasureForAdapter(adapter, graphic, renderOpts);
+			features.push(...rendered.features);
+			for (const feature of rendered.features) {
+				const positions = [];
+				if (feature.geometry) collectFeaturePositions(feature.geometry, positions);
+				for (const position of positions) {
+					const pixel = driver.toPixel(position);
+					if (pixel) pixels.push(pixel);
+				}
+			}
+		}
+		adapter.reconcileLayerIconResources(previewLayer, [...resources.values()]);
+		ctx.writeLayer(previewLayer, features);
+		if (!drag) box = fitTransformBox(pixels, boxAngle, interactionStyle?.boxPadding);
+		const liveBox = drag?.liveBox ?? box;
+		const handles = [];
+		if (liveBox) {
+			handles.push(boxOutlineFeature(liveBox, (pixel) => driver.fromPixel(pixel), `${handleIdPrefix}:box-outline`, interactionStyle?.boxOutline));
+			handles.push(...toFeatures(boxToHandles(liveBox, (pixel) => driver.fromPixel(pixel)), handleIdPrefix, interactionStyle));
+		}
+		ctx.writeLayer(handlesLayer, handles);
+	}
+	function anchorPoints(source) {
+		const points = [];
+		for (const graphic of source) if (isPointSymbol(graphic)) points.push([...graphic.position]);
+		else points.push(...graphic.controlPoints.map((point) => [...point]));
+		return points;
+	}
+	function applyPoints(source, points, scale, rotation) {
+		let offset = 0;
+		return source.map((graphic) => {
+			if (isPointSymbol(graphic)) {
+				const next = clonePointSymbol(graphic);
+				next.position = [...points[offset++]];
+				next.size.value = Math.max(.1, next.size.value * scale);
+				next.rotation = normalizeRotation(next.rotation + rotation);
+				return next;
+			}
+			const next = cloneControlMeasure(graphic);
+			const count = next.controlPoints.length;
+			next.controlPoints = points.slice(offset, offset + count).map((point) => [...point]);
+			offset += count;
+			return next;
+		});
+	}
+	function emit(previous, previousGraphics) {
+		const current = snapshots();
+		let reject = false;
+		let close = false;
+		let abort = false;
+		const event = {
+			graphics: current,
+			previous,
+			session,
+			reject: () => reject = true,
+			close: () => close = true,
+			abort: () => abort = true
+		};
+		const errors = [];
+		for (const listener of [...listeners]) try {
+			listener(event);
+		} catch (error) {
+			errors.push(error);
+		}
+		if (abort) ctx.fail(new TacticalDrawAbortError("session"));
+		else if (close) ctx.commit(snapshots);
+		else if (reject && !ctx.settled) {
+			working = previousGraphics.map(cloneGraphic);
+			dirty = JSON.stringify(working) !== JSON.stringify(original);
+			renderAll();
+		}
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, "GraphicTransformSession.onChange errors");
+	}
+	const session = {
+		get graphics() {
+			return original.map(cloneGraphic);
+		},
+		get workingGraphics() {
+			return working.map(cloneGraphic);
+		},
+		get dirty() {
+			return dirty;
+		},
+		close: () => ctx.commit(snapshots),
+		abort: () => ctx.fail(new TacticalDrawAbortError("session")),
+		onChange(listener) {
+			if (ctx.settled) return () => {};
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		onCommit(listener) {
+			if (ctx.settled) return () => {};
+			return commitEmitter.register(listener);
+		},
+		onSettled: (listener) => settleEmitter.register(listener)
+	};
+	const onDown = (pixel, info) => {
+		if (!box || ctx.settled) return;
+		const hit = pickBoxHandle(box, pixel, info?.hitTolerance ?? HIT_TOLERANCE_PX$1);
+		if (!hit) return;
+		const start = working.map(cloneGraphic);
+		drag = {
+			fsm: beginBoxDrag({
+				kind: hit.kind,
+				downPixel: pixel,
+				points: anchorPoints(start),
+				projection: {
+					toPixel: (p) => driver.toPixel(p),
+					fromPixel: (p) => driver.fromPixel(p)
+				},
+				box,
+				cornerIndex: hit.kind === "scale" ? hit.index : void 0
+			}),
+			start,
+			startBox: box,
+			liveBox: box,
+			down: [...pixel]
+		};
+		driver.setDragPanEnabled(false);
+	};
+	const dragResult = (pixel) => {
+		if (!drag) return null;
+		const result = drag.fsm.move(pixel);
+		const scale = drag.fsm.kind === "scale" ? Math.max(result.box.halfWidth / drag.startBox.halfWidth, result.box.halfHeight / drag.startBox.halfHeight) : 1;
+		const rotation = drag.fsm.kind === "rotate" ? result.box.angle - drag.startBox.angle : 0;
+		return {
+			result,
+			graphics: applyPoints(drag.start, result.points, scale, rotation)
+		};
+	};
+	const onMove = (pixel) => {
+		const active = drag;
+		const next = dragResult(pixel);
+		if (!active || !next) return;
+		working = next.graphics;
+		active.liveBox = next.result.box;
+		renderAll();
+	};
+	const onUp = (pixel) => {
+		if (!drag) return;
+		const active = drag;
+		const next = dragResult(pixel);
+		drag = null;
+		suppressClickAway = true;
+		driver.setDragPanEnabled(true);
+		working = active.start.map(cloneGraphic);
+		if (!next) return;
+		if (active.fsm.kind === "body" && Math.hypot(pixel[0] - active.down[0], pixel[1] - active.down[1]) <= CLICK_SLOP_PX$1) {
+			renderAll();
+			return;
+		}
+		const previous = snapshots();
+		const previousGraphics = working.map(cloneGraphic);
+		working = next.graphics;
+		if (active.fsm.kind === "rotate") boxAngle += next.result.box.angle - active.startBox.angle;
+		dirty = JSON.stringify(working) !== JSON.stringify(original);
+		renderAll();
+		emit(previous, previousGraphics);
+	};
+	let previewPick;
+	let handlesPick;
+	let graphicsPick;
+	let suppressClickAway = false;
+	const onClick = () => {
+		const keepOpen = previewPick || handlesPick;
+		const deferred = graphicsPick;
+		previewPick = handlesPick = graphicsPick = void 0;
+		if (suppressClickAway) {
+			suppressClickAway = false;
+			return;
+		}
+		if (!closeOnClickAway || keepOpen || drag) return;
+		if (ctx.commit(snapshots) && deferred) onClickAwayGraphicsPick?.(deferred);
+	};
+	const core = runInteraction({
+		adapter,
+		signal,
+		layers: [previewLayer, handlesLayer],
+		onViewChange: renderAll,
+		onSettled(settlement) {
+			onSettled?.();
+			settleFromInteraction(settlement, commitEmitter, settleEmitter);
+		},
+		attach(interaction) {
+			ctx = interaction;
+			driver = adapter.createEditPointerDriver();
+			const unsubs = [
+				driver.onPointerDown(onDown),
+				driver.onPointerMove(onMove),
+				driver.onPointerUp(onUp),
+				adapter.onPick(previewLayer, (event) => previewPick = event),
+				adapter.onPick(handlesLayer, (event) => handlesPick = event),
+				adapter.onPick(graphicsLayer, (event) => graphicsPick = event)
+			];
+			interaction.onTeardown(() => {
+				unsubs.forEach((unsubscribe) => unsubscribe());
+				adapter.off("click", onClick);
+				driver.dispose();
+				adapter.reconcileLayerIconResources(previewLayer, []);
+			}, restoreOriginalToGraphics);
+			for (const graphic of working) {
+				if (!isOnGraphicsLayer(graphic.id)) continue;
+				if (isPointSymbol(graphic)) adapter.removeFeatures(graphicsLayer, [`${graphic.id}:point-symbol`]);
+				else {
+					const ids = renderMeasureForAdapter(adapter, graphic, renderOpts).features.map((feature) => feature.id).filter((id) => typeof id === "string");
+					adapter.removeFeatures(graphicsLayer, ids);
+				}
+			}
+			adapter.on("click", onClick);
+			renderAll();
+			onSession?.(session);
+		}
+	});
+	return {
+		promise: core.promise,
+		get settled() {
+			return core.settled;
+		},
+		get graphicIds() {
+			return working.map((graphic) => graphic.id);
+		},
+		abort: core.abort
+	};
+}
+//#endregion
 //#region src/tactical-draw/errors.ts
 /**
 * Error thrown when any `TacticalDraw` method is called after `destroy()`.
@@ -4081,6 +4518,308 @@ var TacticalDrawDestroyedError = class TacticalDrawDestroyedError extends Error
 		Object.setPrototypeOf(this, TacticalDrawDestroyedError.prototype);
 	}
 };
+var PointSymbolCapabilityRequiredError = class extends Error {
+	constructor() {
+		super("TacticalDraw: point-symbol capability is not configured");
+		this.name = "PointSymbolCapabilityRequiredError";
+	}
+};
+//#endregion
+//#region src/tactical-draw/point-symbol-draw-controller.ts
+const PREVIEW_ID = "__td_point_symbol_preview__";
+function runPointSymbolDraw(options) {
+	const { adapter, capability, draft, previewLayer, generateId, signal, onSettled } = options;
+	let latestPosition = draft.position;
+	let ctx;
+	const savedCursor = "";
+	const build = (id, position) => ({
+		...structuredClone(draft),
+		id,
+		kind: "point-symbol",
+		sidc: draft.sidc,
+		position: [...position],
+		rotation: normalizeRotation(draft.rotation ?? capability.defaultRotation),
+		size: structuredClone(draft.size ?? capability.defaultSize)
+	});
+	const renderPreview = () => {
+		if (!latestPosition) return;
+		const plan = renderPointSymbolForAdapter(adapter, capability, build(PREVIEW_ID, latestPosition));
+		adapter.reconcileLayerIconResources(previewLayer, [plan.resource]);
+		ctx.writeLayer(previewLayer, [plan.feature]);
+	};
+	const handlePointerMove = (event) => {
+		latestPosition = event.coordinate;
+		renderPreview();
+	};
+	const handleClick = (event) => {
+		latestPosition = event.coordinate;
+		ctx.commit(() => {
+			const graphic = build(draft.id ?? generateId(), event.coordinate);
+			return {
+				graphic: clonePointSymbol(graphic),
+				render: capability.render(graphic)
+			};
+		});
+	};
+	return runInteraction({
+		adapter,
+		signal,
+		layers: [previewLayer],
+		onViewChange: renderPreview,
+		onSettled,
+		attach(interaction) {
+			ctx = interaction;
+			interaction.onTeardown(() => {
+				adapter.off("pointermove", handlePointerMove);
+				adapter.off("click", handleClick);
+				adapter.reconcileLayerIconResources(previewLayer, []);
+				adapter.setCursor(savedCursor);
+			});
+			adapter.setCursor("crosshair");
+			adapter.on("pointermove", handlePointerMove);
+			adapter.on("click", handleClick);
+			renderPreview();
+		}
+	});
+}
+//#endregion
+//#region src/tactical-draw/point-symbol-edit-controller.ts
+const HIT_TOLERANCE_PX = 12;
+const CLICK_SLOP_PX = 3;
+function normalisePointModes(input) {
+	const modes = input ?? ["transform"];
+	for (const mode of modes) if (mode !== "transform" && mode !== "delete") throw new TypeError(`Point-symbol editing does not support mode "${mode}"`);
+	return modes.includes("delete") ? ["delete"] : [...new Set(modes)];
+}
+function symbolBox(adapter, capability, symbol, padding = 0) {
+	const footprint = pointSymbolFootprint(symbol, capability.render(symbol), adapter);
+	if (!footprint) return null;
+	return {
+		...footprint.box,
+		halfWidth: Math.max(1, footprint.box.halfWidth) + padding,
+		halfHeight: Math.max(1, footprint.box.halfHeight) + padding
+	};
+}
+function runPointSymbolEdit(opts) {
+	const { adapter, capability, symbol, graphicsLayer, previewLayer, handlesLayer, signal, closeOnClickAway = true, interactionStyle, onSession, handleIdPrefix, restoreOriginalToGraphics, wasOnGraphicsLayer, onSettled, onClickAwayGraphicsPick } = opts;
+	let modes = normalisePointModes(opts.modes);
+	let working = clonePointSymbol(symbol);
+	let dirty = false;
+	let box = null;
+	let drag = null;
+	let ctx;
+	let driver;
+	const listeners = /* @__PURE__ */ new Set();
+	const commitEmitter = createCommitEmitter("GraphicEditSession.onCommit listener errors");
+	const settleEmitter = createSettleEmitter("GraphicEditSession.onSettled listener errors");
+	const snapshot = () => ({
+		graphic: clonePointSymbol(working),
+		render: capability.render(working)
+	});
+	const render = () => {
+		if (ctx.settled) return;
+		const plan = renderPointSymbolForAdapter(adapter, capability, working);
+		adapter.reconcileLayerIconResources(previewLayer, [plan.resource]);
+		ctx.writeLayer(previewLayer, [plan.feature]);
+		box = symbolBox(adapter, capability, working, interactionStyle?.boxPadding);
+		const handles = [];
+		if (modes.includes("transform") && box) {
+			handles.push(boxOutlineFeature(box, (pixel) => driver.fromPixel(pixel), `${handleIdPrefix}:box-outline`, interactionStyle?.boxOutline));
+			handles.push(...toFeatures(boxToHandles(box, (pixel) => driver.fromPixel(pixel)), handleIdPrefix, interactionStyle));
+		}
+		ctx.writeLayer(handlesLayer, handles);
+	};
+	const apply = (next, previous = snapshot()) => {
+		working = clonePointSymbol(next);
+		dirty = JSON.stringify(working) !== JSON.stringify(symbol);
+		render();
+		const current = snapshot();
+		let reject = false;
+		let close = false;
+		let abort = false;
+		const event = {
+			graphic: current,
+			previous,
+			session,
+			reject() {
+				reject = true;
+			},
+			close() {
+				close = true;
+			},
+			abort() {
+				abort = true;
+			}
+		};
+		const errors = [];
+		for (const listener of [...listeners]) try {
+			listener(event);
+		} catch (error) {
+			errors.push(error);
+		}
+		if (abort) ctx.fail(new TacticalDrawAbortError("session"));
+		else if (close) ctx.commit(snapshot);
+		else if (reject && !ctx.settled) {
+			working = clonePointSymbol(previous.graphic);
+			dirty = JSON.stringify(working) !== JSON.stringify(symbol);
+			render();
+		}
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, "GraphicEditSession.onChange errors");
+	};
+	const session = {
+		graphic: clonePointSymbol(symbol),
+		get workingGraphic() {
+			return clonePointSymbol(working);
+		},
+		get dirty() {
+			return dirty;
+		},
+		get modes() {
+			return modes;
+		},
+		close() {
+			return ctx.commit(snapshot);
+		},
+		abort() {
+			ctx.fail(new TacticalDrawAbortError("session"));
+		},
+		setModes(next) {
+			if (ctx.settled) return;
+			modes = normalisePointModes(next);
+			render();
+		},
+		updateGraphic(updater) {
+			if (ctx.settled) return;
+			const previous = snapshot();
+			const next = updater(clonePointSymbol(working));
+			if (next.kind !== "point-symbol" || next.id !== symbol.id) throw new TypeError("updateGraphic must preserve point-symbol kind and id");
+			capability.render(next);
+			apply(next, previous);
+		},
+		onChange(listener) {
+			if (ctx.settled) return () => {};
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		onCommit(listener) {
+			if (ctx.settled) return () => {};
+			return commitEmitter.register(listener);
+		},
+		onSettled(listener) {
+			return settleEmitter.register(listener);
+		}
+	};
+	const pointerAngle = (pixel, anchor) => Math.atan2(pixel[1] - anchor[1], pixel[0] - anchor[0]);
+	const onDown = (pixel, info) => {
+		if (ctx.settled || !box || !modes.includes("transform")) return;
+		const hit = pickBoxHandle(box, pixel, info?.hitTolerance ?? HIT_TOLERANCE_PX);
+		if (!hit) return;
+		const anchor = driver.toPixel(working.position);
+		if (!anchor) return;
+		drag = {
+			kind: hit.kind,
+			down: [...pixel],
+			start: clonePointSymbol(working),
+			anchor,
+			startPointerAngle: pointerAngle(pixel, anchor),
+			startDistance: Math.max(1, Math.hypot(pixel[0] - anchor[0], pixel[1] - anchor[1]))
+		};
+		driver.setDragPanEnabled(false);
+	};
+	const transformed = (pixel) => {
+		if (!drag) return null;
+		const next = clonePointSymbol(drag.start);
+		if (drag.kind === "body") next.position = driver.fromPixel([drag.anchor[0] + pixel[0] - drag.down[0], drag.anchor[1] + pixel[1] - drag.down[1]]);
+		else if (drag.kind === "rotate") next.rotation = normalizeRotation(drag.start.rotation + pointerAngle(pixel, drag.anchor) - drag.startPointerAngle);
+		else {
+			const distance = Math.hypot(pixel[0] - drag.anchor[0], pixel[1] - drag.anchor[1]);
+			next.size.value = Math.max(.1, drag.start.size.value * (distance / drag.startDistance));
+		}
+		return next;
+	};
+	const onMove = (pixel) => {
+		const next = transformed(pixel);
+		if (!next) return;
+		working = next;
+		render();
+	};
+	const onUp = (pixel) => {
+		if (!drag) return;
+		const currentDrag = drag;
+		const next = transformed(pixel);
+		drag = null;
+		suppressClickAway = true;
+		driver.setDragPanEnabled(true);
+		working = clonePointSymbol(currentDrag.start);
+		if (!next) return;
+		if (currentDrag.kind === "body" && Math.hypot(pixel[0] - currentDrag.down[0], pixel[1] - currentDrag.down[1]) <= CLICK_SLOP_PX) {
+			render();
+			return;
+		}
+		apply(next);
+	};
+	let previewPick;
+	let handlesPick;
+	let graphicsPick;
+	let suppressClickAway = false;
+	const onPreviewPick = (event) => previewPick = event;
+	const onHandlesPick = (event) => handlesPick = event;
+	const onGraphicsPick = (event) => graphicsPick = event;
+	const onClick = () => {
+		const keepOpen = previewPick || handlesPick;
+		const deferred = graphicsPick;
+		previewPick = handlesPick = graphicsPick = void 0;
+		if (suppressClickAway) {
+			suppressClickAway = false;
+			return;
+		}
+		if (!closeOnClickAway || keepOpen || drag) return;
+		if (ctx.commit(snapshot) && deferred) onClickAwayGraphicsPick?.(deferred);
+	};
+	const handle = runInteraction({
+		adapter,
+		signal,
+		layers: [previewLayer, handlesLayer],
+		onViewChange: render,
+		onSettled(settlement) {
+			onSettled?.();
+			settleFromInteraction(settlement, commitEmitter, settleEmitter);
+		},
+		attach(interaction) {
+			ctx = interaction;
+			driver = adapter.createEditPointerDriver();
+			const unsubs = [
+				driver.onPointerDown(onDown),
+				driver.onPointerMove(onMove),
+				driver.onPointerUp(onUp),
+				adapter.onPick(previewLayer, onPreviewPick),
+				adapter.onPick(handlesLayer, onHandlesPick),
+				adapter.onPick(graphicsLayer, onGraphicsPick)
+			];
+			interaction.onTeardown(() => {
+				unsubs.forEach((unsubscribe) => unsubscribe());
+				adapter.off("click", onClick);
+				driver.dispose();
+				adapter.reconcileLayerIconResources(previewLayer, []);
+			}, () => {
+				if (wasOnGraphicsLayer) restoreOriginalToGraphics();
+			});
+			if (wasOnGraphicsLayer) adapter.removeFeatures(graphicsLayer, [`${symbol.id}:point-symbol`]);
+			adapter.on("click", onClick);
+			render();
+			onSession?.(session);
+		}
+	});
+	return {
+		promise: handle.promise,
+		get settled() {
+			return handle.settled;
+		},
+		measureId: symbol.id,
+		abort: handle.abort
+	};
+}
 //#endregion
 //#region src/tactical-draw/tactical-draw.ts
 /**
@@ -4100,6 +4839,7 @@ var TacticalDraw = class {
 	graphicsStyle;
 	defaultInteractionStyle;
 	generateId;
+	pointSymbols;
 	destroyed = false;
 	hasRendered = false;
 	activeInteraction = new ActiveInteractionTracker();
@@ -4114,7 +4854,7 @@ var TacticalDraw = class {
 	* Tracked alongside `activeInteraction` whenever the interaction is a group
 	* transform (`editMany`). The `render()` / view-change paths need every
 	* member's id (to exclude all of them from reconcile) — mirrors `activeEdit`
-	* but for `TransformHandle`'s `measureIds` array.
+	* but for `TransformHandle`'s `graphicIds` array.
 	*/
 	activeTransform = null;
 	/**
@@ -4125,7 +4865,7 @@ var TacticalDraw = class {
 	*/
 	activeTransformSessionRef = null;
 	/**
-	* Host pick handlers registered via `td.onPick` / `td.onMeasurePick`. The
+	* Host pick handlers registered via `td.onPick` / `td.onGraphicPick`. 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).
@@ -4155,6 +4895,7 @@ var TacticalDraw = class {
 		this.graphicsStyle = resolveStyleHints(BUILT_IN_GRAPHICS_STYLE, options?.graphicsStyle, void 0);
 		this.defaultInteractionStyle = options?.interactionStyle;
 		this.generateId = options?.generateId ?? (() => `td-${++this.idCounter}`);
+		this.pointSymbols = options?.pointSymbols;
 		const owned = /* @__PURE__ */ new Set();
 		const provided = options?.layers ?? {};
 		this.graphicsLayer = resolveSlot(adapter, provided.graphics, owned);
@@ -4175,13 +4916,20 @@ var TacticalDraw = class {
 	* `render()` (excludes the edited measure, owned by the preview layer) versus
 	* `restoreOriginalToGraphics` (no exclusion, the edit is ending).
 	*/
-	renderMeasuresToGraphics(measures) {
+	renderMeasuresToGraphics(graphics) {
 		const features = [];
+		const resources = /* @__PURE__ */ new Map();
 		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);
+		for (const graphic of graphics) if (isPointSymbol(graphic)) {
+			if (!this.pointSymbols) throw new PointSymbolCapabilityRequiredError();
+			const plan = renderPointSymbolForAdapter(this.adapter, this.pointSymbols, graphic);
+			resources.set(plan.resource.id, plan.resource);
+			features.push(plan.feature);
+		} else {
+			const render = renderMeasureForAdapter(this.adapter, graphic, renderOpts);
+			for (const feature of render.features) features.push(feature);
 		}
+		this.adapter.reconcileLayerIconResources(this.graphicsLayer, [...resources.values()]);
 		this.adapter.updateLayerFeatures(this.graphicsLayer, features);
 	}
 	/**
@@ -4197,7 +4945,7 @@ var TacticalDraw = class {
 		if (this.destroyed || !this.hasRendered) return;
 		const excluded = this.excludedInteractionIds();
 		const visible = excluded.size > 0 ? this.lastRenderedMeasures.filter((m) => !excluded.has(m.id)) : this.lastRenderedMeasures;
-		if (!visible.some(measureRendersFromViewState)) return;
+		if (!visible.some(graphicRendersFromViewState)) return;
 		this.renderMeasuresToGraphics(visible);
 	};
 	/**
@@ -4220,8 +4968,10 @@ var TacticalDraw = class {
 	* `render()` from inside `onSession` still sees live membership.
 	*/
 	transformMemberIds() {
-		if (this.activeTransform) return this.activeTransform.measureIds;
-		return this.activeTransformSessionRef?.measures.map((m) => m.id);
+		if (this.activeTransform) return this.activeTransform.graphicIds;
+		const session = this.activeTransformSessionRef;
+		if (!session) return void 0;
+		return session.graphics.map((graphic) => graphic.id);
 	}
 	/**
 	* Reconcile the graphics layer against the authoritative list of measures.
@@ -4252,14 +5002,15 @@ var TacticalDraw = class {
 		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}"`);
+			if (seen.has(m.id)) throw new Error(`TacticalDraw.render: duplicate graphic 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);
+			const candidate = measures.find((m) => m.id === editedId);
+			externalEdited = candidate && !isPointSymbol(candidate) ? candidate : void 0;
 			editedRemoved = externalEdited === void 0;
 		}
 		const transformIds = this.transformMemberIds();
@@ -4271,7 +5022,7 @@ var TacticalDraw = class {
 			this.hasRendered = true;
 		}
 		this.lastRenderedMeasures = measures.slice();
-		if (externalEdited && this.activeEdit) this.activeEdit.notifyExternalMeasure(externalEdited);
+		if (externalEdited && this.activeEdit && "notifyExternalMeasure" in this.activeEdit) this.activeEdit.notifyExternalMeasure(externalEdited);
 		if (editedRemoved && this.activeEdit) {
 			const editHandle = this.activeEdit;
 			queueMicrotask(() => {
@@ -4285,7 +5036,7 @@ var TacticalDraw = class {
 				if (!handle || handle.settled) return;
 				if (this.activeTransformSessionRef !== sessionRef) return;
 				const rendered = new Set(this.lastRenderedMeasures.map((m) => m.id));
-				if (handle.measureIds.some((id) => !rendered.has(id))) handle.abort("removed");
+				if (handle.graphicIds.some((id) => !rendered.has(id))) handle.abort("removed");
 			});
 		}
 	}
@@ -4379,22 +5130,25 @@ var TacticalDraw = class {
 			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()`.
-	*
-	* For a variable-length draw, `DrawSession.onCommit` is the single delivery
-	* channel for the committed snapshot and `DrawSession.onSettled` is the
-	* lifecycle signal for when the session is over and why (#197) — together
-	* they make the returned promise non-load-bearing for hosts that adopt them.
-	* Fixed-length kinds have no session and settle only through the promise.
-	*/
 	draw(draft, options) {
 		this.assertAlive();
-		const kind = draft.kind;
+		if (draft.kind === "point-symbol") {
+			if (!this.pointSymbols) throw new PointSymbolCapabilityRequiredError();
+			const preempt = this.guardAndPreempt();
+			if (preempt) return preempt;
+			const pointDraft = draft;
+			return this.runWithSlot((onSettled) => runPointSymbolDraw({
+				adapter: this.adapter,
+				capability: this.pointSymbols,
+				draft: pointDraft,
+				previewLayer: this.previewLayer,
+				generateId: this.generateId,
+				signal: options?.signal,
+				onSettled
+			}), null);
+		}
+		const measureDraft = draft;
+		const kind = measureDraft.kind;
 		const preempt = this.guardAndPreempt();
 		if (preempt) return preempt;
 		const fixedLength = isFixedLength(getControlMeasureMetadata(kind));
@@ -4414,12 +5168,12 @@ var TacticalDraw = class {
 			previewLayer: this.previewLayer,
 			guideLayer: this.guideLayer,
 			graphicsStyle: this.graphicsStyle,
-			generateId: () => draft.id ?? this.generateId(),
+			generateId: () => measureDraft.id ?? this.generateId(),
 			signal: options?.signal,
-			measureOptions: draft.options,
-			measureStyle: draft.style,
-			measureProperties: draft.properties,
-			measureTextAmplifiers: draft.textAmplifiers,
+			measureOptions: measureDraft.options,
+			measureStyle: measureDraft.style,
+			measureProperties: measureDraft.properties,
+			measureTextAmplifiers: measureDraft.textAmplifiers,
 			guide: options?.guide,
 			sizeAnchor: options?.sizeAnchor,
 			onSettled
@@ -4429,36 +5183,53 @@ var TacticalDraw = class {
 			previewLayer: this.previewLayer,
 			guideLayer: this.guideLayer,
 			graphicsStyle: this.graphicsStyle,
-			generateId: () => draft.id ?? this.generateId(),
+			generateId: () => measureDraft.id ?? this.generateId(),
 			signal: options?.signal,
 			onSession: this.trackSession(options?.onSession),
-			seed: draft.controlPoints,
-			measureOptions: draft.options,
-			measureStyle: draft.style,
-			measureProperties: draft.properties,
-			measureTextAmplifiers: draft.textAmplifiers,
+			seed: measureDraft.controlPoints,
+			measureOptions: measureDraft.options,
+			measureStyle: measureDraft.style,
+			measureProperties: measureDraft.properties,
+			measureTextAmplifiers: measureDraft.textAmplifiers,
 			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`.
-	*
-	* `EditSession.onCommit` is the single delivery channel for the committed
-	* snapshot and `EditSession.onSettled` is the lifecycle signal for when the
-	* session is over and why (#197) — together they make the returned promise
-	* non-load-bearing for hosts that adopt them.
-	*/
 	edit(measure, options) {
 		this.assertAlive();
+		if (isPointSymbol(measure)) {
+			normalisePointEditModes(options?.modes);
+			if (!this.pointSymbols) throw new PointSymbolCapabilityRequiredError();
+			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}__`;
+			return this.runWithSlot((onSettled) => runPointSymbolEdit({
+				adapter: this.adapter,
+				capability: this.pointSymbols,
+				symbol: measure,
+				graphicsLayer: this.graphicsLayer,
+				previewLayer: this.previewLayer,
+				handlesLayer: this.handlesLayer,
+				signal: options?.signal,
+				closeOnClickAway: options?.closeOnClickAway,
+				modes: options?.modes,
+				interactionStyle: this.resolveInteractionStyle(options?.interactionStyle),
+				onSession: options?.onSession,
+				handleIdPrefix,
+				restoreOriginalToGraphics,
+				wasOnGraphicsLayer,
+				onSettled,
+				onClickAwayGraphicsPick: (event) => this.dispatchHostPick(this.graphicsLayer, event)
+			}), (handle) => {
+				this.activeEdit = handle;
+				return () => {
+					if (this.activeEdit === handle) this.activeEdit = null;
+				};
+			});
+		}
 		normaliseModes(options?.modes);
 		const preempt = this.guardAndPreempt();
 		if (preempt) return preempt;
@@ -4499,38 +5270,16 @@ var TacticalDraw = class {
 			};
 		}, revertGuideStyle);
 	}
-	/**
-	* Start an interactive group transform (multi-select) over `measures`
-	* (ADR-0017 "Multi-select" slice). Every member is lifted onto the shared
-	* preview layer; the box (corner scale, rotate grip, drag-anywhere body
-	* translate) applies rigidly to all of them at once. Returns a Promise that
-	* resolves with `ControlMeasureSnapshot[]` on `session.close()` and rejects
-	* with `TacticalDrawAbortError` on signal / Escape / destroy / preempt /
-	* `session.abort()`. Key the resolved snapshots by `snapshot.measure.id`:
-	* the member set is mutable (`session.setMembers`, #187) so snapshot arrays
-	* are id-keyed, not index-aligned with this input. The promise resolves with
-	* the members in the set at close time; a member removed mid-session had its
-	* exit snapshot returned from the `setMembers` call that removed it.
-	*
-	* `measures.length` must be >= 1; a single-element array behaves like an
-	* `edit` with only `transform` mode. Throws `TypeError` synchronously (before
-	* any preemption) for an empty array or duplicate ids.
-	*
-	* For a selection that changes over time (shift-click toggle, marquee
-	* replace), prefer [[syncTransformMembers]] over hand-rolling the
-	* live-session-vs-fresh-`editMany` branch, and subscribe to
-	* `TransformSession.onCommit` as the single fold path for exit snapshots
-	* and `TransformSession.onSettled` as the lifecycle signal for when the
-	* session is over and why.
-	*/
 	editMany(measures, options) {
 		this.assertAlive();
 		if (measures.length === 0) throw new TypeError("td.editMany: measures must not be empty");
 		const seenIds = /* @__PURE__ */ new Set();
 		for (const m of measures) {
-			if (seenIds.has(m.id)) throw new TypeError(`td.editMany: duplicate control measure id "${m.id}"`);
+			if (seenIds.has(m.id)) throw new TypeError(`td.editMany: duplicate graphic id "${m.id}"`);
 			seenIds.add(m.id);
 		}
+		const hasPointSymbols = measures.some(isPointSymbol);
+		if (hasPointSymbols && !this.pointSymbols) throw new PointSymbolCapabilityRequiredError();
 		const preempt = this.guardAndPreempt();
 		if (preempt) return preempt;
 		const isOnGraphicsLayer = (id) => this.lastRenderedMeasures.some((m) => m.id === id);
@@ -4545,6 +5294,29 @@ var TacticalDraw = class {
 		const extraSettle = () => {
 			this.activeTransformSessionRef = null;
 		};
+		if (hasPointSymbols) return this.runWithSlot((onSettled) => runGraphicTransform({
+			adapter: this.adapter,
+			capability: this.pointSymbols,
+			graphics: measures,
+			graphicsLayer: this.graphicsLayer,
+			previewLayer: this.previewLayer,
+			handlesLayer: this.handlesLayer,
+			graphicsStyle: this.graphicsStyle,
+			signal: options?.signal,
+			closeOnClickAway: options?.closeOnClickAway,
+			interactionStyle: mergedInteractionStyle,
+			onSession: this.trackTransformSession(options?.onSession),
+			handleIdPrefix,
+			restoreOriginalToGraphics,
+			isOnGraphicsLayer,
+			onSettled,
+			onClickAwayGraphicsPick
+		}), (handle) => {
+			this.activeTransform = handle;
+			return () => {
+				if (this.activeTransform === handle) this.activeTransform = null;
+			};
+		}, extraSettle);
 		return this.runWithSlot((onSettled) => runGroupTransform({
 			adapter: this.adapter,
 			measures,
@@ -4570,24 +5342,26 @@ var TacticalDraw = class {
 		}, extraSettle);
 	}
 	/**
-	* One-call selection-sync: mutate the live group transform's member set in
-	* place, or start a fresh `editMany` when no transform is live (#191). This
-	* owns the "live session → `setMembers`, else → `editMany`" branch that every
-	* host otherwise hand-rolls against `activeTransformSession`.
+	* One-call selection-sync: mutate a live control-measure-only transform's
+	* member set in place, or start a fresh `editMany` when no compatible
+	* transform is live (#191). A selection containing a point symbol uses the
+	* unified graphic transform session, which does not yet support mutable
+	* membership; changing that selection preempts the current session and starts
+	* a new one, resetting its box angle and other session-local state.
 	*
 	* The facade knows session liveness synchronously — `activeTransformSessionRef`
 	* is cleared inside the settle path, before control returns to host code — so
-	* unlike a host's own `activeTransformSession ? setMembers : editMany` check,
+	* unlike a host's own `activeTransformSession ? setGraphics : editMany` check,
 	* this can never observe a stale ref pointing at an already-settled session.
 	* The settled-race fall-through hosts had to hand-roll for that gap is owned
-	* here instead: a `setMembers` call that (implausibly) still returns
+	* here instead: a `setGraphics` call that (implausibly) still returns
 	* `undefined` falls through to a fresh `editMany` rather than silently
 	* dropping the selection.
 	*
-	* `measures: []` closes any live session (committing every member) and is a
+	* `graphics: []` closes any live session (committing every member) and is a
 	* no-op while idle. With a live session, `options` is ignored — session-scoped
 	* state (`sizeAnchor`, box angle, close-on-click-away policy) is sticky per
-	* `setMembers`'s contract; `options` applies only when this call starts a
+	* `setGraphics`'s contract; `options` applies only when this call starts a
 	* fresh `editMany`. Exit snapshots are delivered via the session's
 	* `onCommit` — subscribe once in `options.onSession`. Session lifecycle —
 	* including an Escape / preempt / destroy abort the host did not itself
@@ -4599,14 +5373,17 @@ var TacticalDraw = class {
 	* either path. Starting a fresh transform preempts any other in-flight
 	* draw/edit exactly like `editMany`.
 	*/
-	syncTransformMembers(measures, options) {
+	syncTransformGraphics(graphics, options) {
 		this.assertAlive();
 		const session = this.activeTransformSessionRef;
-		if (session) {
-			if (session.setMembers(measures) !== void 0) return;
+		if (session && "setGraphics" in session && graphics.every((graphic) => !isPointSymbol(graphic))) {
+			if (session.setGraphics(graphics) !== void 0) return;
 		}
-		if (measures.length === 0) return;
-		this.editMany([...measures], options).catch(ignoreAbort);
+		if (graphics.length === 0) {
+			session?.close();
+			return;
+		}
+		this.editMany([...graphics], options).catch(ignoreAbort);
 	}
 	/**
 	* Subscribe to picks on committed control measures.
@@ -4619,7 +5396,7 @@ var TacticalDraw = class {
 	* Returns an idempotent unsubscribe function. An optional `signal` removes
 	* the handler when aborted.
 	*/
-	onMeasurePick(handler, opts) {
+	onGraphicPick(handler, opts) {
 		this.assertAlive();
 		return this.onPick(this.graphicsLayer, handler, opts);
 	}
@@ -4873,6 +5650,12 @@ var TacticalDraw = class {
 		if (this.destroyed) throw new TacticalDrawDestroyedError();
 	}
 };
+function graphicRendersFromViewState(graphic) {
+	return isPointSymbol(graphic) ? graphic.size.unit === "meters" : measureRendersFromViewState(graphic);
+}
+function normalisePointEditModes(modes) {
+	for (const mode of modes ?? ["transform"]) if (mode !== "transform" && mode !== "delete") throw new TypeError(`Point-symbol editing does not support mode "${mode}"`);
+}
 /**
 * Built-in default graphics style. Ensures OL / MapLibre / Leaflet render
 * identically when neither host nor measure supplies a style — without it,
@@ -4997,4 +5780,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, PointerCallbackHub, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, TacticalDrawDestroyedError, bindAbortable, coerceHandleStyle, combineWithHostSignal, getSizeAnchor, hitTestFeature, ignoreAbort, isTacticalDrawAbortError, nearestWorldCopyLng, nearestWorldCopyPosition, pickHitTolerance, resolveGroundTextSizePixels, tryControlMeasureIdFromFeature };
+export { BaseMapAdapter, DEFAULT_LABEL_SIZE_PIXELS, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, PointSymbolCapabilityRequiredError, PointerCallbackHub, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, TacticalDrawDestroyedError, bindAbortable, clonePointSymbol, coerceHandleStyle, combineWithHostSignal, getSizeAnchor, hitTestFeature, hitTestIconFeature, ignoreAbort, isPointSymbol, isTacticalDrawAbortError, nearestWorldCopyLng, nearestWorldCopyPosition, pickHitTolerance, pointSymbolFootprint, resolveGroundTextSizePixels, tryControlMeasureIdFromFeature };