@orbat-mapper/tactical-draw 0.13.2 → 0.14.1

package/dist/index.d.mts

@@ -519,19 +519,84 @@ declare function normalizeImageGraphic(image: ImageGraphic): ImageGraphic;
 declare function imageOpacity(image: ImageGraphic): number;
 declare function validateImageGraphic(image: ImageGraphic): void;
 //#endregion
+//#region src/marker.d.ts
+/** Displayed icon height; same pixel/meter contract as point-symbol sizes. */
+type MarkerSize = PointSymbolSize;
+interface MarkerStyle {
+  /** Host-interpreted tint, handed to {@link MarkerCapability.render}. */
+  color?: string;
+  /** 0–1 display multiplier applied by TacticalDraw. */
+  opacity?: number;
+}
+/**
+ * Persisted generic marker (e.g. a pin) whose icon is supplied by the
+ * host application. TacticalDraw treats `symbolId` as opaque (ADR-0059).
+ */
+interface Marker {
+  id: string;
+  kind: "marker";
+  /** Host-defined icon identifier resolved by the {@link MarkerCapability}. */
+  symbolId: string;
+  position: Position;
+  /** Normalized radians clockwise from geographic north, around the icon anchor. */
+  rotation: number;
+  size: MarkerSize;
+  /** Optional text; the capability decides whether and how to draw it. */
+  label?: string;
+  style?: MarkerStyle;
+  properties?: Record<string, unknown>;
+  schemaVersion: 1;
+}
+interface MarkerAnchor {
+  x: number;
+  y: number;
+}
+/** Host-prepared marker icon in canonical SVG units. */
+interface MarkerIcon {
+  /**
+   * Content-derived identity for adapter-wide icon reuse: equal ids must mean
+   * identical SVG. Include anything that changes the drawing (symbol, color, label).
+   */
+  resourceId: string;
+  /** Self-contained SVG markup. Producing safe content is the host's responsibility. */
+  svg: string;
+  width: number;
+  height: number;
+  /** Point placed at `Marker.position` (e.g. a pin's tip); rotation and scale pivot here. */
+  anchor: MarkerAnchor;
+}
+interface MarkerRender extends MarkerIcon {
+  /** False when the capability did not recognize `symbolId` and a placeholder is shown. */
+  available: boolean;
+}
+interface MarkerCapability {
+  /** Return `undefined` for an unknown `symbolId`; TacticalDraw renders a placeholder. */
+  render(marker: Marker): MarkerIcon | undefined;
+  /** Monotonic host-owned revision; bump it when icon resolution changes. */
+  readonly generation?: number;
+}
+declare function isMarker(graphic: unknown): graphic is Marker;
+declare function cloneMarker(marker: Marker): Marker;
+declare function markerOpacity(marker: Marker): number;
+declare function validateMarker(marker: Marker): void;
+declare function normalizeMarker(marker: Marker): Marker;
+//#endregion
 //#region src/graphic.d.ts
-type Graphic = ControlMeasure | PointSymbol | ImageGraphic;
-type GraphicRender = ControlMeasureRender | PointSymbolRender | ImageRender;
+type Graphic = ControlMeasure | PointSymbol | ImageGraphic | Marker;
+type GraphicRender = ControlMeasureRender | PointSymbolRender | ImageRender | MarkerRender;
 interface GraphicSnapshot<G extends Graphic = Graphic> {
   graphic: G;
-  render: G extends PointSymbol ? PointSymbolRender : G extends ImageGraphic ? ImageRender : ControlMeasureRender;
+  render: G extends PointSymbol ? PointSymbolRender : G extends ImageGraphic ? ImageRender : G extends Marker ? MarkerRender : ControlMeasureRender;
 }
 /**
  * A graphic whose identity is one geographic anchor + size + rotation,
- * rather than a control-point geometry: `PointSymbol` or `ImageGraphic`.
+ * rather than a control-point geometry: `PointSymbol`, `ImageGraphic`, or `Marker`.
  */
-type AnchoredGraphic = PointSymbol | ImageGraphic;
+type AnchoredGraphic = PointSymbol | ImageGraphic | Marker;
 declare function isAnchoredGraphic(graphic: Graphic): graphic is AnchoredGraphic;
+/** A graphic that can take view-owned pin presentation (ADR-0056): a point symbol or marker. */
+type PinnableGraphic = PointSymbol | Marker;
+declare function isPinnableGraphic(graphic: Graphic): graphic is PinnableGraphic;
 //#endregion
 //#region src/tactical-draw/abort.d.ts
 /**
@@ -1413,6 +1478,11 @@ type DrawPointSymbolDraft = Pick<PointSymbol, "kind" | "sidc"> & Partial<Omit<Po
 //#region src/tactical-draw/image-draw-controller.d.ts
 type DrawImageDraft = Pick<ImageGraphic, "kind" | "resourceId" | "intrinsicSize"> & Partial<Omit<ImageGraphic, "kind" | "resourceId" | "intrinsicSize">>;
 //#endregion
+//#region src/tactical-draw/marker-draw-controller.d.ts
+type DrawMarkerDraft = Pick<Marker, "kind" | "symbolId"> & Partial<Omit<Marker, "kind" | "symbolId">>;
+/** Default icon height for a drawn marker when the draft omits `size`. */
+declare const DEFAULT_MARKER_SIZE: MarkerSize;
+//#endregion
 //#region src/tactical-draw/tactical-draw.d.ts
 /**
  * Host-supplied layer slot ids. Any omitted slot is allocated by the façade and
@@ -1450,6 +1520,8 @@ interface TacticalDrawOptions {
   pointSymbols?: PointSymbolCapability;
   /** Synchronous host-supplied resolver for first-class Image resources. */
   images?: ImageCapability;
+  /** Synchronous host-supplied icon resolver for generic Markers (ADR-0059). */
+  markers?: MarkerCapability;
   /**
    * Façade-level default style passed through to `renderControlMeasure` as the
    * third (lowest priority) style layer per StyleResolver (#44). Shallow-merged
@@ -1483,7 +1555,7 @@ interface EditOptions {
    * Called synchronously once when the edit starts, before any pointer event
    * is processed. Lets a host wire commit / cancel buttons to the active edit.
    */
-  onSession?: (session: EditSession | GraphicEditSession<PointSymbol> | GraphicEditSession<ImageGraphic>) => void;
+  onSession?: (session: EditSession | GraphicEditSession<PointSymbol> | GraphicEditSession<ImageGraphic> | GraphicEditSession<Marker>) => void;
   /**
    * Default `true`. When `true`, a click on empty map (or on another graphics
    * layer measure) closes the active edit. Clicks on preview / handle
@@ -1639,6 +1711,7 @@ declare class TacticalDraw {
   private offsetDragModifier;
   private readonly pointSymbols;
   private readonly images;
+  private readonly markers;
   private snappingOptions;
   private readonly resolveSnap;
   private readonly graphicStack;
@@ -1717,6 +1790,7 @@ declare class TacticalDraw {
    */
   private lastSeenPointSymbolGeneration;
   private lastSeenImageGeneration;
+  private lastSeenMarkerGeneration;
   /**
    * Ids of graphics currently carrying a passive selection-highlight outline
    * ({@link setHighlightedGraphics}). Declarative set-replace, no session —
@@ -1725,6 +1799,8 @@ declare class TacticalDraw {
    */
   private highlightedIds;
   private pinBodies;
+  /** Resolved marker icons, so pin, highlight and view rebuilds don't re-ask the host. */
+  private markerRenders;
   readonly pins: PinPresentationStore;
   private unsubscribePins;
   /**
@@ -1756,9 +1832,11 @@ declare class TacticalDraw {
    * handler and the adapter-capability change in `handleViewChange` need it.
    */
   private refreshActiveEditPresentation;
+  /** The capability's icon for a marker snapshot, resolved once per snapshot. */
+  private markerRender;
   /**
-   * Whether a point symbol should render as a billboard pin rather than an
-   * ordinary point symbol: its own presentation opts in, and the adapter
+   * Whether a point symbol or marker should render as a billboard pin rather
+   * than an ordinary icon: 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.
    */
@@ -1945,6 +2023,7 @@ declare class TacticalDraw {
    */
   draw(draft: DrawPointSymbolDraft, options?: DrawOptions): Promise<GraphicSnapshot<PointSymbol>>;
   draw(draft: DrawImageDraft, options?: DrawOptions): Promise<GraphicSnapshot<ImageGraphic>>;
+  draw(draft: DrawMarkerDraft, options?: DrawOptions): Promise<GraphicSnapshot<Marker>>;
   draw<K extends ControlMeasureKind>(draft: DrawMeasureDraft<K>, options?: DrawOptions): Promise<GraphicSnapshot<ControlMeasure<K>>>;
   /**
    * Start an interactive edit on a single control measure. Returns a Promise
@@ -1963,6 +2042,7 @@ declare class TacticalDraw {
    */
   edit(graphic: PointSymbol, options?: EditOptions): Promise<GraphicSnapshot<PointSymbol>>;
   edit(graphic: ImageGraphic, options?: EditOptions): Promise<GraphicSnapshot<ImageGraphic>>;
+  edit(graphic: Marker, options?: EditOptions): Promise<GraphicSnapshot<Marker>>;
   edit(measure: ControlMeasure, options?: EditOptions): Promise<GraphicSnapshot<ControlMeasure>>;
   /**
    * Start an interactive group transform (multi-select) over `measures`
@@ -2183,6 +2263,9 @@ declare class PointSymbolCapabilityRequiredError extends Error {
 declare class ImageCapabilityRequiredError extends Error {
   constructor();
 }
+declare class MarkerCapabilityRequiredError extends Error {
+  constructor();
+}
 //#endregion
 //#region src/tactical-draw/transform-box.d.ts
 /**
@@ -2238,6 +2321,13 @@ interface ImageFootprint {
 }
 declare function imageFootprint(image: ImageGraphic, render: ImageRender, adapter: Pick<MapAdapter, "getBearing" | "getPixelFromCoordinate" | "getResolution">): ImageFootprint | null;
 //#endregion
+//#region src/tactical-draw/marker-rendering.d.ts
+type MarkerFootprint = Omit<PointSymbolFootprint, "connector">;
+/** Resolve a marker's icon, substituting the built-in placeholder for unknown symbols. */
+declare function resolveMarkerRender(capability: MarkerCapability, marker: Marker): MarkerRender;
+/** Complete rotated footprint for selection and transform chrome. */
+declare function markerFootprint(marker: Marker, render: MarkerRender, adapter: PointSymbolProjection): MarkerFootprint | null;
+//#endregion
 //#region src/world-wrap.d.ts
 /**
  * Shift `lng` by whole world widths (360°) onto the copy nearest `refLng`.
@@ -2252,4 +2342,4 @@ declare function nearestWorldCopyLng(lng: number, refLng: number): number;
 /** `nearestWorldCopyLng` applied to a lon/lat position. */
 declare function nearestWorldCopyPosition(position: Position, refLng: number): Position;
 //#endregion
-export { type AnchoredGraphic, BaseMapAdapter, type CombinedAbort, DEFAULT_LABEL_SIZE_PIXELS, DEFAULT_PIN_PRESENTATION, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, type DrawImageDraft, type DrawMeasureDraft, type DrawOptions, type DrawPointSymbolDraft, type DrawSession, type EditChangeEvent, type EditManyOptions, type EditMode, type EditOptions, type EditPointerDriver, type EditSession, type FeatureGroup, type Graphic, type GraphicEditChangeEvent, type GraphicEditSession, type GraphicGeometrySnappingOptions, type GraphicRender, type GraphicSnapshot, type GuideStyle, HATCH_PATTERNS, type HandleStyle, type HatchPattern, type IconResource, type ImageCapability, ImageCapabilityRequiredError, type ImageFootprint, type ImageGraphic, type ImageGraphicStyle, type ImageIntrinsicSize, type ImageOverlayResource, type ImageRender, type ImageResource, type ImageSize, type InteractionHit, type InteractionStyle, type LabelExtent, type LayerId, MINE_PATTERN_TILE_SIZE, type MapAdapter, type MapCursor, type MapEvent, type MapEventHandler, type MergedPickFeature, type NativeEventEntry, type OffsetDragModifier, type PickCandidate, type PickCandidateHit, type PickCandidateHitKind, type PickCandidateInput, type PickEvaluationContext, type PickEvent, type PickHandler, type PickOptions, type PickPointerType, PinFootprint, PinOverridePatch, PinPresentation, PinPresentationCapability, PinPresentationPatch, PinPresentationState, PinPresentationStatus, PinPresentationStatusEvent, PinPresentationStore, PinRender, type PixelCoordinate, type PointSymbol, type PointSymbolAnchor, type PointSymbolCapability, PointSymbolCapabilityRequiredError, type PointSymbolColors, type PointSymbolConnector, type PointSymbolFootprint, type PointSymbolGraphicModifiers, type PointSymbolOffset, type PointSymbolOffsetControls, type PointSymbolOffsetLayout, type PointSymbolOffsetStyle, type PointSymbolPlacement, type PointSymbolProjection, type PointSymbolRender, type PointSymbolSize, type PointSymbolStyle, type PointSymbolView, type PointerCallback, PointerCallbackHub, type PointerEventInfo, type ResolvedPickPresentation, type Rgba, type RotatedScreenBounds, type ScreenBounds, type SessionChangeSource, type SessionHistory, type SessionHistoryState, type SettleReason, type SizeAnchor, type SnapCandidate, type SnapCandidateProvider, type SnapCandidateRequest, type SnapInteraction, type SnapResult, type SnappingOptions, type StyleOptions, TEXT_HALO_COLOR, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, type TacticalDrawAbortReason, TacticalDrawDestroyedError, type TacticalDrawLayerOptions, type TacticalDrawOptions, type TextSizeProps, type TextStyleOptions, type ToPixel, type TransformBox, type TransformChangeEvent, type TransformSession, type TransientChangeEvent, type TransientPhase, alignPointSymbolIndicator, bindAbortable, cloneImageGraphic, clonePointSymbol, coerceHandleStyle, combinePinScale, 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, pinDistanceScale, pinZoomScale, placePointSymbol, pointSymbolFootprint, pointSymbolResource, renderOrderToVisualOrder, resizePointSymbolSize, resolveGroundTextSizePixels, resolvePickPresentation, resolvePinPresentation, resolvePointSymbolOffset, resolveTextHaloWidth, resolveTextSizePixels, scalePointSymbolLayout, tryControlMeasureIdFromFeature, validateImageGraphic };
+export { type AnchoredGraphic, BaseMapAdapter, type CombinedAbort, DEFAULT_LABEL_SIZE_PIXELS, DEFAULT_MARKER_SIZE, DEFAULT_PIN_PRESENTATION, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, type DrawImageDraft, type DrawMarkerDraft, type DrawMeasureDraft, type DrawOptions, type DrawPointSymbolDraft, type DrawSession, type EditChangeEvent, type EditManyOptions, type EditMode, type EditOptions, type EditPointerDriver, type EditSession, type FeatureGroup, type Graphic, type GraphicEditChangeEvent, type GraphicEditSession, type GraphicGeometrySnappingOptions, type GraphicRender, type GraphicSnapshot, type GuideStyle, HATCH_PATTERNS, type HandleStyle, type HatchPattern, type IconResource, type ImageCapability, ImageCapabilityRequiredError, type ImageFootprint, type ImageGraphic, type ImageGraphicStyle, type ImageIntrinsicSize, type ImageOverlayResource, type ImageRender, type ImageResource, type ImageSize, type InteractionHit, type InteractionStyle, type LabelExtent, type LayerId, MINE_PATTERN_TILE_SIZE, type MapAdapter, type MapCursor, type MapEvent, type MapEventHandler, type Marker, type MarkerAnchor, type MarkerCapability, MarkerCapabilityRequiredError, type MarkerFootprint, type MarkerIcon, type MarkerRender, type MarkerSize, type MarkerStyle, type MergedPickFeature, type NativeEventEntry, type OffsetDragModifier, type PickCandidate, type PickCandidateHit, type PickCandidateHitKind, type PickCandidateInput, type PickEvaluationContext, type PickEvent, type PickHandler, type PickOptions, type PickPointerType, PinFootprint, PinOverridePatch, PinPresentation, PinPresentationCapability, PinPresentationPatch, PinPresentationState, PinPresentationStatus, PinPresentationStatusEvent, PinPresentationStore, PinRender, type PinnableGraphic, type PixelCoordinate, type PointSymbol, type PointSymbolAnchor, type PointSymbolCapability, PointSymbolCapabilityRequiredError, type PointSymbolColors, type PointSymbolConnector, type PointSymbolFootprint, type PointSymbolGraphicModifiers, type PointSymbolOffset, type PointSymbolOffsetControls, type PointSymbolOffsetLayout, type PointSymbolOffsetStyle, type PointSymbolPlacement, type PointSymbolProjection, type PointSymbolRender, type PointSymbolSize, type PointSymbolStyle, type PointSymbolView, type PointerCallback, PointerCallbackHub, type PointerEventInfo, type ResolvedPickPresentation, type Rgba, type RotatedScreenBounds, type ScreenBounds, type SessionChangeSource, type SessionHistory, type SessionHistoryState, type SettleReason, type SizeAnchor, type SnapCandidate, type SnapCandidateProvider, type SnapCandidateRequest, type SnapInteraction, type SnapResult, type SnappingOptions, type StyleOptions, TEXT_HALO_COLOR, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, type TacticalDrawAbortReason, TacticalDrawDestroyedError, type TacticalDrawLayerOptions, type TacticalDrawOptions, type TextSizeProps, type TextStyleOptions, type ToPixel, type TransformBox, type TransformChangeEvent, type TransformSession, type TransientChangeEvent, type TransientPhase, alignPointSymbolIndicator, bindAbortable, cloneImageGraphic, cloneMarker, clonePointSymbol, coerceHandleStyle, combinePinScale, combineWithHostSignal, convertPointSymbolPlacement, effectivePointSymbolPixelSize, evaluatePickCandidates, fillPatternImageDimension, fillPatternImageId, getSizeAnchor, hitTestFeature, hitTestIconFeature, ignoreAbort, imageFootprint, imageOpacity, isAnchoredGraphic, isImageGraphic, isMarker, isMinePattern, isPinnableGraphic, isPointSymbol, isTacticalDrawAbortError, isValidPinNumber, makeFillPatternImage, markerFootprint, markerOpacity, mergeNativeAndCachedPickFeatures, movePointSymbolLocation, nearestWorldCopyLng, nearestWorldCopyPosition, normalizeImageGraphic, normalizeMarker, parseColor, pickHitTolerance, pickPointerType, pinDistanceScale, pinZoomScale, placePointSymbol, pointSymbolFootprint, pointSymbolResource, renderOrderToVisualOrder, resizePointSymbolSize, resolveGroundTextSizePixels, resolveMarkerRender, resolvePickPresentation, resolvePinPresentation, resolvePointSymbolOffset, resolveTextHaloWidth, resolveTextSizePixels, scalePointSymbolLayout, tryControlMeasureIdFromFeature, validateImageGraphic, validateMarker };

package/dist/index.mjs

@@ -1448,6 +1448,10 @@ function pointInBox(box, pixel) {
 	const [lx, ly] = rotate(pixel[0] - center[0], pixel[1] - center[1], -angle);
 	return Math.abs(lx) <= halfWidth && Math.abs(ly) <= halfHeight;
 }
+/** Screen angle in radians from `anchor` to `pixel`, for rotate drags pivoting on an anchor. */
+function pointerAngle(pixel, anchor) {
+	return Math.atan2(pixel[1] - anchor[1], pixel[0] - anchor[0]);
+}
 /** Plain 2D distance between two pixel coordinates. */
 function pixelDistance$1(a, b) {
 	return Math.hypot(a[0] - b[0], a[1] - b[1]);
@@ -1716,9 +1720,55 @@ function normalizeImageRotation(value) {
 	return (value % turn + turn) % turn;
 }
 //#endregion
+//#region src/tactical-draw/rotation.ts
+/** Excalidraw-style rotation increment used while Shift is held. */
+const CONSTRAINED_ROTATION_STEP = Math.PI / 12;
+/** Normalize radians to the canonical clockwise [0, 2π) range. */
+function normalizeRotation(angle) {
+	const turn = Math.PI * 2;
+	return (angle % turn + turn) % turn;
+}
+/** Snap an absolute rotation angle to the nearest 15-degree increment. */
+function constrainRotation(angle) {
+	return Math.round(angle / CONSTRAINED_ROTATION_STEP) * CONSTRAINED_ROTATION_STEP;
+}
+//#endregion
+//#region src/marker.ts
+function isMarker(graphic) {
+	return typeof graphic === "object" && graphic !== null && "kind" in graphic && graphic.kind === "marker";
+}
+function cloneMarker(marker) {
+	return structuredClone(marker);
+}
+function markerOpacity(marker) {
+	const opacity = marker.style?.opacity ?? 1;
+	if (!Number.isFinite(opacity)) throw new TypeError("Marker.style.opacity must be finite");
+	return Math.max(0, Math.min(1, opacity));
+}
+function validateMarker(marker) {
+	if (!marker.id) throw new TypeError("Marker.id must not be empty");
+	if (!marker.symbolId) throw new TypeError("Marker.symbolId must not be empty");
+	if (!Number.isFinite(marker.size.value) || marker.size.value <= 0) throw new TypeError("Marker.size.value must be a positive finite number");
+	if (marker.size.unit !== "pixels" && marker.size.unit !== "meters") throw new TypeError("Marker.size.unit must be \"pixels\" or \"meters\"");
+	if (!Number.isFinite(marker.rotation)) throw new TypeError("Marker.rotation must be finite");
+	if (marker.schemaVersion !== 1) throw new TypeError("Marker.schemaVersion must be 1");
+	markerOpacity(marker);
+	if (!Array.isArray(marker.position) || marker.position.length < 2 || !Number.isFinite(marker.position[0]) || !Number.isFinite(marker.position[1])) throw new TypeError("Marker.position must be a finite geographic position");
+}
+function normalizeMarker(marker) {
+	validateMarker(marker);
+	const next = cloneMarker(marker);
+	next.rotation = normalizeRotation(next.rotation);
+	if (next.style?.opacity !== void 0) next.style.opacity = markerOpacity(next);
+	return next;
+}
+//#endregion
 //#region src/graphic.ts
 function isAnchoredGraphic(graphic) {
-	return isPointSymbol(graphic) || isImageGraphic(graphic);
+	return isPointSymbol(graphic) || isImageGraphic(graphic) || isMarker(graphic);
+}
+function isPinnableGraphic(graphic) {
+	return isPointSymbol(graphic) || isMarker(graphic);
 }
 //#endregion
 //#region src/tactical-draw/active-interaction.ts
@@ -3298,19 +3348,6 @@ function pickHandle(handles, pixel, tolerance, toPixel) {
 	return null;
 }
 //#endregion
-//#region src/tactical-draw/rotation.ts
-/** Excalidraw-style rotation increment used while Shift is held. */
-const CONSTRAINED_ROTATION_STEP = Math.PI / 12;
-/** Normalize radians to the canonical clockwise [0, 2π) range. */
-function normalizeRotation(angle) {
-	const turn = Math.PI * 2;
-	return (angle % turn + turn) % turn;
-}
-/** Snap an absolute rotation angle to the nearest 15-degree increment. */
-function constrainRotation(angle) {
-	return Math.round(angle / CONSTRAINED_ROTATION_STEP) * CONSTRAINED_ROTATION_STEP;
-}
-//#endregion
 //#region src/tactical-draw/handle-drag.ts
 function clonePoints(points) {
 	return points.map((p) => [...p]);
@@ -5687,6 +5724,13 @@ var ImageCapabilityRequiredError = class ImageCapabilityRequiredError extends Er
 		Object.setPrototypeOf(this, ImageCapabilityRequiredError.prototype);
 	}
 };
+var MarkerCapabilityRequiredError = class MarkerCapabilityRequiredError extends Error {
+	constructor() {
+		super("TacticalDraw: marker capability is not configured");
+		this.name = "MarkerCapabilityRequiredError";
+		Object.setPrototypeOf(this, MarkerCapabilityRequiredError.prototype);
+	}
+};
 //#endregion
 //#region src/tactical-draw/point-symbol-rendering.ts
 /** Complete rotated logical footprint for selection and transform chrome. */
@@ -5910,6 +5954,147 @@ function missingResource(image) {
 	};
 }
 //#endregion
+//#region src/tactical-draw/marker-rendering.ts
+const PLACEHOLDER_SIZE = 24;
+const PLACEHOLDER = {
+	resourceId: "__td_missing_marker__",
+	svg: `<svg xmlns="http://www.w3.org/2000/svg" width="${PLACEHOLDER_SIZE}" height="${PLACEHOLDER_SIZE}" viewBox="0 0 24 24"><circle cx="12" cy="12" r="10" fill="#f3f4f6" fill-opacity="0.85" stroke="#6b7280" stroke-width="2" stroke-dasharray="3 2"/><text x="12" y="16.5" text-anchor="middle" font-family="sans-serif" font-size="13" font-weight="bold" fill="#6b7280">?</text></svg>`,
+	width: PLACEHOLDER_SIZE,
+	height: PLACEHOLDER_SIZE,
+	anchor: {
+		x: PLACEHOLDER_SIZE / 2,
+		y: PLACEHOLDER_SIZE / 2
+	}
+};
+/** Resolve a marker's icon, substituting the built-in placeholder for unknown symbols. */
+function resolveMarkerRender(capability, marker) {
+	validateMarker(marker);
+	const icon = capability.render(marker);
+	if (!icon) return {
+		...PLACEHOLDER,
+		anchor: { ...PLACEHOLDER.anchor },
+		available: false
+	};
+	validateMarkerIcon(icon);
+	return {
+		resourceId: icon.resourceId,
+		svg: icon.svg,
+		width: icon.width,
+		height: icon.height,
+		anchor: {
+			x: icon.anchor.x,
+			y: icon.anchor.y
+		},
+		available: true
+	};
+}
+/**
+* Markers reuse the point-symbol icon path (ADR-0030) by presenting the icon
+* height as the "octagon" size, so `Marker.size` sizes the whole icon.
+*/
+function asPointSymbol(marker, render) {
+	return [{
+		id: marker.id,
+		kind: "point-symbol",
+		sidc: "",
+		position: marker.position,
+		rotation: marker.rotation,
+		size: marker.size,
+		style: { opacity: markerOpacity(marker) },
+		...marker.properties ? { properties: marker.properties } : {}
+	}, asPointSymbolRender(render)];
+}
+/**
+* Canonical icon-resource height. Engines rasterize an icon resource at its
+* declared size and then scale the bitmap, so a small host icon (e.g. a 44-unit
+* pin) would blur when enlarged. Presenting every marker at this height means
+* engines scale the bitmap down for typical sizes, like milsymbol's 100-unit
+* octagon does for point symbols.
+*/
+const MARKER_RESOURCE_HEIGHT = 256;
+const symbolRenders = /* @__PURE__ */ new WeakMap();
+function asPointSymbolRender(render) {
+	let symbolRender = symbolRenders.get(render);
+	if (!symbolRender) {
+		symbolRender = supersample(render);
+		symbolRenders.set(render, symbolRender);
+	}
+	return symbolRender;
+}
+function supersample(render) {
+	const k = Math.max(1, MARKER_RESOURCE_HEIGHT / render.height);
+	const width = render.width * k;
+	const height = render.height * k;
+	const svg = k === 1 ? render.svg : `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${render.width} ${render.height}">${render.svg}</svg>`;
+	return {
+		resourceId: render.resourceId,
+		svg,
+		octagonSize: height,
+		width,
+		height,
+		anchor: {
+			x: render.anchor.x * k,
+			y: render.anchor.y * k
+		},
+		octagonAnchor: {
+			x: width / 2,
+			y: height / 2
+		},
+		valid: render.available
+	};
+}
+function markerFeature(marker, render, resolution) {
+	const feature = pointSymbolFeature(...asPointSymbol(marker, render), resolution);
+	feature.id = `${marker.id}:marker`;
+	feature.properties.graphicKind = "marker";
+	feature.properties.markerAvailable = render.available;
+	return feature;
+}
+function markerResource(render) {
+	return pointSymbolResource(asPointSymbolRender(render));
+}
+/**
+* The upright body a marker shows in pin presentation (ADR-0056): its icon
+* resource plus the canonical height the pin's `sizePixels` scales against.
+* The pin stem attaches below the icon, centred on the marker's anchor.
+*/
+function markerPinBody(render) {
+	const symbolRender = asPointSymbolRender(render);
+	return {
+		resource: pointSymbolResource(symbolRender),
+		octagonSize: symbolRender.octagonSize
+	};
+}
+/** Complete rotated footprint for selection and transform chrome. */
+function markerFootprint(marker, render, adapter) {
+	const footprint = pointSymbolFootprint(...asPointSymbol(marker, render), adapter);
+	return footprint ? {
+		box: footprint.box,
+		corners: footprint.corners
+	} : null;
+}
+/**
+* Whether a marker's rendered icon depends on map resolution: meter sizes carry
+* a resolution-derived `iconScale` unless the engine scales ground icons itself.
+*/
+function markerScalesWithResolution(marker, nativeGroundScaling) {
+	return marker.size.unit === "meters" && !nativeGroundScaling;
+}
+/** Pass an already-resolved `render` to skip asking the capability again. */
+function renderMarkerForAdapter(adapter, capability, marker, render = resolveMarkerRender(capability, marker)) {
+	return {
+		render,
+		features: [markerFeature(marker, render, adapter.getResolution())],
+		resource: markerResource(render)
+	};
+}
+function validateMarkerIcon(icon) {
+	if (!icon.resourceId) throw new TypeError("MarkerIcon.resourceId must not be empty");
+	if (typeof icon.svg !== "string" || !icon.svg) throw new TypeError("MarkerIcon.svg must be a non-empty SVG string");
+	for (const [value, name] of [[icon.width, "width"], [icon.height, "height"]]) if (!Number.isFinite(value) || value <= 0) throw new TypeError(`MarkerIcon.${name} must be a positive finite number`);
+	if (!Number.isFinite(icon.anchor?.x) || !Number.isFinite(icon.anchor?.y)) throw new TypeError("MarkerIcon.anchor must be finite");
+}
+//#endregion
 //#region src/tactical-draw/frame-coalescer.ts
 /**
 * @param run Callback invoked with the latest scheduled args, at most once per frame.
@@ -5990,9 +6175,9 @@ function defaultGroupSizeAnchor(graphics) {
 *    a live session without a session boundary
 */
 function runGroupTransform(opts) {
-	const { adapter, capability, imageCapability, graphics, graphicsLayer, previewLayer, handlesLayer, graphicsStyle, symbolColors, signal, closeOnClickAway = true, interactionStyle, onSession, handleIdPrefix, publishWorkingGraphics, settleWorkingGraphics, isOnGraphicsLayer, onSettled, onClickAwayGraphicsPick } = opts;
+	const { adapter, capability, imageCapability, markerCapability, graphics, graphicsLayer, previewLayer, handlesLayer, graphicsStyle, symbolColors, signal, closeOnClickAway = true, interactionStyle, onSession, handleIdPrefix, publishWorkingGraphics, settleWorkingGraphics, isOnGraphicsLayer, onSettled, onClickAwayGraphicsPick } = opts;
 	assertCapabilityFor(graphics);
-	validateImageResources(graphics);
+	validateHostResources(graphics);
 	const renderOpts = {
 		graphicsStyle,
 		symbolColors
@@ -6002,10 +6187,14 @@ function runGroupTransform(opts) {
 	function assertCapabilityFor(list) {
 		if (!capability && list.some(isPointSymbol)) throw new PointSymbolCapabilityRequiredError();
 		if (!imageCapability && list.some(isImageGraphic)) throw new ImageCapabilityRequiredError();
+		if (!markerCapability && list.some(isMarker)) throw new MarkerCapabilityRequiredError();
 	}
 	/** Validate host integration before listeners, layers, or interaction state are created. */
-	function validateImageResources(list) {
-		for (const graphic of list) if (isImageGraphic(graphic)) renderImageForAdapter(adapter, imageCapability, graphic);
+	function validateHostResources(list) {
+		for (const graphic of list) {
+			if (isImageGraphic(graphic)) renderImageForAdapter(adapter, imageCapability, graphic);
+			if (isMarker(graphic)) resolveMarkerRender(markerCapability, graphic);
+		}
 	}
 	function isPointSymbolMember(member) {
 		return isPointSymbol(member.graphic);
@@ -6013,6 +6202,9 @@ function runGroupTransform(opts) {
 	function isImageMember(member) {
 		return isImageGraphic(member.graphic);
 	}
+	function isMarkerMember(member) {
+		return isMarker(member.graphic);
+	}
 	function isAnchoredMember(member) {
 		return isAnchoredGraphic(member.graphic);
 	}
@@ -6093,6 +6285,13 @@ function runGroupTransform(opts) {
 		image.rotation = member.workingRotation;
 		return image;
 	}
+	function buildWorkingMarker(member) {
+		const marker = cloneMarker(member.graphic);
+		marker.position = [...member.workingPoints[0]];
+		marker.size = resizePointSymbolSize(marker.size, member.workingSize);
+		marker.rotation = member.workingRotation;
+		return marker;
+	}
 	/** Build the working measure for member `i` with a given options override. */
 	function buildWorkingMeasureWith(member, override) {
 		const measure = member.graphic;
@@ -6120,6 +6319,13 @@ function runGroupTransform(opts) {
 				render: renderImageForAdapter(adapter, imageCapability, image).render
 			};
 		}
+		if (isMarkerMember(member)) {
+			const marker = buildWorkingMarker(member);
+			return {
+				graphic: cloneMarker(marker),
+				render: resolveMarkerRender(markerCapability, marker)
+			};
+		}
 		const working = buildWorkingMeasureWith(member, override);
 		const committed = getControlMeasureMetadata(working.kind).uniformSizing || sizeAnchor === "screen" ? working : bakePixelSizeToGround(working, adapter);
 		return {
@@ -6132,6 +6338,7 @@ function runGroupTransform(opts) {
 		const member = members[i];
 		if (isPointSymbolMember(member)) return buildWorkingPointSymbol(member);
 		if (isImageMember(member)) return buildWorkingImage(member);
+		if (isMarkerMember(member)) return buildWorkingMarker(member);
 		return buildWorkingMeasureWith(member, member.optionsOverride);
 	}
 	let dirty = false;
@@ -6276,6 +6483,24 @@ function runGroupTransform(opts) {
 				features = [plan.feature];
 				const footprint = imageFootprint(image, plan.render, adapter);
 				if (footprint) boxPixels = footprint.corners;
+			} else if (isMarkerMember(member)) {
+				const marker = buildWorkingMarker(member);
+				pinGroup = opts.renderPin?.(marker);
+				const pinFootprint = pinGroup?.pin && adapter.getPinFootprint?.(marker.id);
+				const render = pinFootprint ? void 0 : resolveMarkerRender(markerCapability, marker);
+				if (pinGroup?.pin) {
+					features = pinGroup.features;
+					iconResources = pinGroup.iconResources;
+				} else {
+					const plan = renderMarkerForAdapter(adapter, markerCapability, marker, render);
+					features = plan.features;
+					iconResources = [plan.resource];
+				}
+				if (pinFootprint) boxPixels = boxCorners(boxFromPixelBounds(pinFootprint.min, pinFootprint.max));
+				else {
+					const footprint = markerFootprint(marker, render, adapter);
+					if (footprint) boxPixels = footprint.corners;
+				}
 			} else try {
 				if (isPointSymbolMember(member)) {
 					const symbol = buildWorkingPointSymbol(member);
@@ -6835,7 +7060,7 @@ function runGroupTransform(opts) {
 }
 //#endregion
 //#region src/tactical-draw/point-symbol-draw-controller.ts
-const PREVIEW_ID$1 = "__td_point_symbol_preview__";
+const PREVIEW_ID$2 = "__td_point_symbol_preview__";
 function runPointSymbolDraw(options) {
 	const { adapter, capability, draft, previewLayer, generateId, signal, onSettled, snap } = options;
 	let latestPosition = draft.position;
@@ -6852,9 +7077,9 @@ function runPointSymbolDraw(options) {
 	});
 	const renderPreview = () => {
 		if (!latestPosition) return;
-		const plan = renderPointSymbolForAdapter(adapter, capability, build(PREVIEW_ID$1, latestPosition));
+		const plan = renderPointSymbolForAdapter(adapter, capability, build(PREVIEW_ID$2, latestPosition));
 		ctx.writeLayer(previewLayer, [{
-			id: PREVIEW_ID$1,
+			id: PREVIEW_ID$2,
 			features: plan.features,
 			iconResources: [plan.resource]
 		}]);
@@ -7130,7 +7355,6 @@ function runPointSymbolEdit(opts) {
 			return settleEmitter.register(listener);
 		}
 	};
-	const pointerAngle = (pixel, anchor) => Math.atan2(pixel[1] - anchor[1], pixel[0] - anchor[0]);
 	const snapTranslate = (position, fallbackPixel, info) => snap?.({
 		coordinate: position,
 		pixel: driver.toPixel(position) ?? fallbackPixel,
@@ -7326,7 +7550,7 @@ function runPointSymbolEdit(opts) {
 }
 //#endregion
 //#region src/tactical-draw/image-draw-controller.ts
-const PREVIEW_ID = "__td_image_preview__";
+const PREVIEW_ID$1 = "__td_image_preview__";
 const DEFAULT_IMAGE_WIDTH_PIXELS = 128;
 function runImageDraw(options) {
 	const { adapter, capability, draft, previewLayer, generateId, signal, onSettled, snap } = options;
@@ -7354,9 +7578,9 @@ function runImageDraw(options) {
 	const planFor = (id, position) => renderImageForAdapter(adapter, capability, build(id, position));
 	const renderPreview = () => {
 		if (!latestPosition) return;
-		const plan = planFor(PREVIEW_ID, latestPosition);
+		const plan = planFor(PREVIEW_ID$1, latestPosition);
 		ctx.writeLayer(previewLayer, [{
-			id: PREVIEW_ID,
+			id: PREVIEW_ID$1,
 			features: [plan.feature],
 			iconResources: [],
 			...plan.overlay ? { imageOverlays: [plan.overlay] } : {}
@@ -7656,6 +7880,382 @@ function runImageEdit(opts) {
 	};
 }
 //#endregion
+//#region src/tactical-draw/marker-draw-controller.ts
+/** Default icon height for a drawn marker when the draft omits `size`. */
+const DEFAULT_MARKER_SIZE = {
+	value: 32,
+	unit: "pixels"
+};
+const PREVIEW_ID = "__td_marker_preview__";
+function runMarkerDraw(options) {
+	const { adapter, capability, draft, previewLayer, generateId, signal, onSettled, snap } = options;
+	let latestPosition = draft.position;
+	let ctx;
+	const savedCursor = "";
+	const build = (id, position) => ({
+		...structuredClone(draft),
+		id,
+		kind: "marker",
+		position: [...position],
+		rotation: normalizeRotation(draft.rotation ?? 0),
+		size: structuredClone(draft.size ?? DEFAULT_MARKER_SIZE),
+		schemaVersion: 1
+	});
+	let previewRender;
+	const renderPreview = () => {
+		if (!latestPosition) return;
+		const preview = build(PREVIEW_ID, latestPosition);
+		previewRender ??= resolveMarkerRender(capability, preview);
+		const plan = renderMarkerForAdapter(adapter, capability, preview, previewRender);
+		ctx.writeLayer(previewLayer, [{
+			id: PREVIEW_ID,
+			features: plan.features,
+			iconResources: [plan.resource]
+		}]);
+	};
+	const handlePointerMove = (event) => {
+		latestPosition = snappedDrawPosition(snap, event);
+		renderPreview();
+	};
+	const handleClick = (event) => {
+		latestPosition = snappedDrawPosition(snap, event);
+		ctx.commit(() => {
+			const graphic = build(draft.id ?? generateId(), latestPosition);
+			return {
+				graphic,
+				render: resolveMarkerRender(capability, 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.setCursor(savedCursor);
+			});
+			adapter.setCursor("crosshair");
+			adapter.on("pointermove", handlePointerMove);
+			adapter.on("click", handleClick);
+			renderPreview();
+		}
+	});
+}
+//#endregion
+//#region src/tactical-draw/marker-edit-controller.ts
+function normaliseMarkerModes(input) {
+	const modes = input ?? ["transform"];
+	for (const mode of modes) if (mode !== "transform" && mode !== "delete") throw new TypeError(`Marker editing does not support mode "${mode}"`);
+	return modes.includes("delete") ? ["delete"] : [...new Set(modes)];
+}
+function runMarkerEdit(opts) {
+	const { adapter, capability, marker, graphicsLayer, previewLayer, handlesLayer, signal, closeOnClickAway = true, interactionStyle, onSession, handleIdPrefix, settleToGraphics, publishWorkingGraphic, wasOnGraphicsLayer, onSettled, onClickAwayGraphicsPick, snap } = opts;
+	validateMarker(marker);
+	let modes = normaliseMarkerModes(opts.modes);
+	let usesGraphicStack = wasOnGraphicsLayer;
+	let pinEditing = !!opts.renderPin && opts.modes === void 0;
+	let pinDrag = null;
+	let working = cloneMarker(marker);
+	let dirty = false;
+	let box = null;
+	let drag = null;
+	let ctx;
+	let driver;
+	let shell;
+	const changeEmitter = createChangeEmitter({
+		listenerErrorsMessage: "GraphicEditSession.onChange errors",
+		isSettled: () => ctx.settled,
+		abort: () => ctx.fail(new TacticalDrawAbortError("session")),
+		close: () => ctx.commit(snapshot)
+	});
+	const commitEmitter = createCommitEmitter("GraphicEditSession.onCommit listener errors");
+	const settleEmitter = createSettleEmitter("GraphicEditSession.onSettled listener errors");
+	const captureHistory = () => ({ working: cloneMarker(working) });
+	const renders = /* @__PURE__ */ new WeakMap();
+	const renderOf = (value) => {
+		let render = renders.get(value);
+		if (!render) {
+			render = resolveMarkerRender(capability, value);
+			renders.set(value, render);
+		}
+		return render;
+	};
+	const snapshotOf = (value) => ({
+		graphic: cloneMarker(value),
+		render: renderOf(value)
+	});
+	const snapshot = () => snapshotOf(working);
+	const pinActive = () => pinEditing && !!opts.renderPin && opts.canRenderPin?.() === true;
+	const render = (publishGraphic = true) => {
+		if (ctx.settled) return;
+		if (pinActive()) {
+			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
+				}
+			}] : []);
+			box = null;
+			return;
+		}
+		const plan = renderMarkerForAdapter(adapter, capability, working, renderOf(working));
+		const footprint = markerFootprint(working, plan.render, adapter);
+		const padding = interactionStyle?.boxPadding ?? 0;
+		const nextBox = footprint ? {
+			...footprint.box,
+			halfWidth: Math.max(1, footprint.box.halfWidth) + padding,
+			halfHeight: Math.max(1, footprint.box.halfHeight) + padding
+		} : null;
+		const handles = [];
+		if (modes.includes("transform") && nextBox) handles.push(boxOutlineFeature(nextBox, (pixel) => driver.fromPixel(pixel), `${handleIdPrefix}:box-outline`, interactionStyle?.boxOutline), ...toFeatures(boxToHandles(nextBox, (pixel) => driver.fromPixel(pixel)), handleIdPrefix, interactionStyle));
+		const group = {
+			id: working.id,
+			features: plan.features,
+			iconResources: [plan.resource]
+		};
+		if (publishGraphic) {
+			publishWorkingGraphic(group);
+			ctx.writeLayer(previewLayer, usesGraphicStack ? [] : [group]);
+		}
+		box = nextBox;
+		ctx.writeLayer(handlesLayer, [{
+			id: `__td_marker_edit_handles__:${working.id}`,
+			features: handles,
+			iconResources: []
+		}]);
+	};
+	const emitChange = (previousState, source, onAccepted) => changeEmitter.emit({
+		source,
+		graphic: snapshot(),
+		previous: snapshotOf(previousState.working),
+		session
+	}, {
+		rollback() {
+			working = cloneMarker(previousState.working);
+			dirty = !deepEqual(working, marker);
+			render();
+		},
+		onAccepted
+	});
+	const history = createSessionHistory({
+		initial: captureHistory(),
+		clone: (value) => ({ working: cloneMarker(value.working) }),
+		equals: (a, b) => deepEqual(a.working, b.working),
+		isCurrent: (value) => deepEqual(working, value.working),
+		apply(from, to, source) {
+			working = cloneMarker(to.working);
+			dirty = !deepEqual(working, marker);
+			render();
+			return emitChange(from, source);
+		}
+	});
+	/** `next` must be a fresh snapshot the caller no longer mutates. */
+	const apply = (next, source, label) => {
+		const previous = captureHistory();
+		working = next;
+		dirty = !deepEqual(working, marker);
+		render();
+		emitChange(previous, source, () => history.record(captureHistory(), label));
+	};
+	const session = {
+		history,
+		graphic: cloneMarker(marker),
+		get workingGraphic() {
+			return cloneMarker(working);
+		},
+		get dirty() {
+			return dirty;
+		},
+		get modes() {
+			return modes;
+		},
+		close: () => ctx.commit(snapshot),
+		abort: () => ctx.fail(new TacticalDrawAbortError("session")),
+		setModes(next) {
+			if (ctx.settled) return;
+			modes = normaliseMarkerModes(next);
+			pinEditing = false;
+			render();
+		},
+		updateGraphic(updater) {
+			if (ctx.settled) return;
+			const next = normalizeMarker(updater(cloneMarker(working)));
+			if (next.kind !== "marker" || next.id !== marker.id) throw new TypeError("updateGraphic must preserve marker kind and id");
+			renderOf(next);
+			apply(next, "programmatic", "Update graphic");
+		},
+		onChange(listener) {
+			if (ctx.settled) return () => {};
+			return changeEmitter.register(listener);
+		},
+		onCommit(listener) {
+			if (ctx.settled) return () => {};
+			return commitEmitter.register(listener);
+		},
+		onSettled(listener) {
+			return settleEmitter.register(listener);
+		}
+	};
+	const snapTranslate = (position, pixel, info) => snap?.({
+		coordinate: position,
+		pixel,
+		interaction: "translate",
+		graphicId: marker.id,
+		originalEvent: info?.native
+	})?.coordinate ?? position;
+	const transformed = (pixel, info) => {
+		if (pinDrag) {
+			const attachment = [pinDrag.attachment[0] + pixel[0] - pinDrag.down[0], pinDrag.attachment[1] + pixel[1] - pinDrag.down[1]];
+			const position = adapter.movePinFromPixel?.(working.id, attachment);
+			if (!position) return null;
+			return {
+				...cloneMarker(pinDrag.start),
+				position: snapTranslate(position, attachment, info)
+			};
+		}
+		if (!drag) return null;
+		const next = cloneMarker(drag.start);
+		if (drag.kind === "body") {
+			const position = driver.fromPixel([drag.anchor[0] + pixel[0] - drag.down[0], drag.anchor[1] + pixel[1] - drag.down[1]]);
+			next.position = snapTranslate(position, driver.toPixel(position) ?? pixel, info);
+		} else if (drag.kind === "rotate") {
+			const rotation = drag.start.rotation + pointerAngle(pixel, drag.anchor) - drag.startPointerAngle;
+			next.rotation = normalizeRotation(info?.shiftKey ? constrainRotation(rotation) : rotation);
+		} else {
+			const distance = pixelDistance$1(pixel, drag.anchor);
+			next.size = resizePointSymbolSize(drag.start.size, Math.max(.1, drag.start.size.value * (distance / drag.startDistance)));
+		}
+		return next;
+	};
+	const onDown = (pixel, info) => {
+		if (pinActive()) {
+			if (ctx.settled) return;
+			const footprint = adapter.getPinFootprint?.(working.id);
+			if (footprint && adapter.pickPin?.(working.id, pixel, info?.hitTolerance ?? 12)) {
+				pinDrag = {
+					start: cloneMarker(working),
+					down: [...pixel],
+					attachment: footprint.attachment
+				};
+				driver.setDragPanEnabled(false);
+			}
+			return;
+		}
+		if (ctx.settled || !box || !modes.includes("transform")) return;
+		const hit = pickBoxHandle(box, pixel, info?.hitTolerance ?? 12);
+		if (!hit) return;
+		const anchor = driver.toPixel(working.position);
+		if (!anchor) return;
+		drag = {
+			kind: hit.kind,
+			down: [...pixel],
+			start: cloneMarker(working),
+			anchor,
+			startPointerAngle: pointerAngle(pixel, anchor),
+			startDistance: Math.max(1, pixelDistance$1(pixel, anchor))
+		};
+		driver.setDragPanEnabled(false);
+	};
+	const onMove = (pixel, info) => {
+		const next = transformed(pixel, info);
+		if (!next) return;
+		working = next;
+		render();
+	};
+	const onUp = (pixel, info) => {
+		if (pinDrag) {
+			const next = transformed(pixel, info);
+			const { start, down } = pinDrag;
+			pinDrag = null;
+			driver.setDragPanEnabled(true);
+			shell.suppressNextClickAway();
+			working = cloneMarker(start);
+			if (next && !withinClickSlop(pixel, down)) apply(next, "gesture", "Move marker");
+			else render();
+			return;
+		}
+		if (!drag) return;
+		const current = drag;
+		const next = transformed(pixel, info);
+		drag = null;
+		shell.suppressNextClickAway();
+		driver.setDragPanEnabled(true);
+		working = cloneMarker(current.start);
+		if (!next) return;
+		if (current.kind === "body" && withinClickSlop(pixel, current.down)) {
+			render();
+			return;
+		}
+		apply(next, "gesture", `${current.kind[0].toUpperCase()}${current.kind.slice(1)}`);
+	};
+	const handle = runEditInteraction({
+		adapter,
+		signal,
+		layers: [previewLayer, handlesLayer],
+		graphicsLayer,
+		previewLayer,
+		handlesLayer,
+		closeOnClickAway,
+		onViewChange: () => {
+			if (pinActive()) return;
+			render(markerScalesWithResolution(working, adapter.scalesGroundPointSymbolsNatively === true));
+		},
+		onBeforeTeardown: (settlement) => settleToGraphics(settlement.status === "committed" ? settlement.value.graphic : void 0),
+		onDown,
+		onMove,
+		onUp,
+		ownsGraphic: (id) => id === marker.id,
+		close: () => ctx.commit(snapshot),
+		onForeignPick: onClickAwayGraphicsPick,
+		historySettle: () => history.settle(),
+		facadeOnSettled: onSettled,
+		emitSettle: (settlement) => settleFromInteraction(settlement, commitEmitter, settleEmitter),
+		attach(interaction, createdDriver, createdShell) {
+			ctx = interaction;
+			driver = createdDriver;
+			shell = createdShell;
+			render();
+			onSession?.(session);
+		}
+	});
+	return {
+		promise: handle.promise,
+		refreshPresentation: () => render(),
+		get settled() {
+			return handle.settled;
+		},
+		get usesGraphicStack() {
+			return usesGraphicStack;
+		},
+		measureId: marker.id,
+		graphicKind: "marker",
+		abort: handle.abort,
+		syncHostMembership(present) {
+			if (handle.settled || usesGraphicStack === present) return;
+			const previous = usesGraphicStack;
+			usesGraphicStack = present;
+			try {
+				render();
+			} catch (error) {
+				usesGraphicStack = previous;
+				throw error;
+			}
+		}
+	};
+}
+//#endregion
 //#region src/tactical-draw/graphic-stack-coordinator.ts
 /**
 * Combines host-owned Graphic order with live or settled render overrides.
@@ -7720,6 +8320,7 @@ var TacticalDraw = class {
 	offsetDragModifier;
 	pointSymbols;
 	images;
+	markers;
 	snappingOptions;
 	resolveSnap;
 	graphicStack = new GraphicStackCoordinator();
@@ -7798,6 +8399,7 @@ var TacticalDraw = class {
 	*/
 	lastSeenPointSymbolGeneration;
 	lastSeenImageGeneration;
+	lastSeenMarkerGeneration;
 	/**
 	* Ids of graphics currently carrying a passive selection-highlight outline
 	* ({@link setHighlightedGraphics}). Declarative set-replace, no session —
@@ -7806,6 +8408,8 @@ var TacticalDraw = class {
 	*/
 	highlightedIds = [];
 	pinBodies = /* @__PURE__ */ new WeakMap();
+	/** Resolved marker icons, so pin, highlight and view rebuilds don't re-ask the host. */
+	markerRenders = /* @__PURE__ */ new WeakMap();
 	pins = new PinPresentationStore();
 	unsubscribePins;
 	/**
@@ -7836,6 +8440,8 @@ var TacticalDraw = class {
 		this.images = options?.images;
 		this.lastSeenPointSymbolGeneration = this.pointSymbols?.generation;
 		this.lastSeenImageGeneration = this.images?.generation;
+		this.markers = options?.markers;
+		this.lastSeenMarkerGeneration = this.markers?.generation;
 		this.snappingOptions = options?.snapping;
 		this.resolveSnap = createSnapResolver(adapter, () => this.lastRenderedMeasures, () => this.snapGeometryFeatures, () => this.snappingOptions);
 		const owned = /* @__PURE__ */ new Set();
@@ -7892,9 +8498,18 @@ var TacticalDraw = class {
 	refreshActiveEditPresentation() {
 		if (this.activeEdit && "refreshPresentation" in this.activeEdit) this.activeEdit.refreshPresentation();
 	}
+	/** The capability's icon for a marker snapshot, resolved once per snapshot. */
+	markerRender(marker) {
+		let render = this.markerRenders.get(marker);
+		if (!render) {
+			render = resolveMarkerRender(this.markers, marker);
+			this.markerRenders.set(marker, render);
+		}
+		return render;
+	}
 	/**
-	* Whether a point symbol should render as a billboard pin rather than an
-	* ordinary point symbol: its own presentation opts in, and the adapter
+	* Whether a point symbol or marker should render as a billboard pin rather
+	* than an ordinary icon: 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.
 	*/
@@ -7939,7 +8554,7 @@ 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 presentation = isPointSymbol(graphic) ? this.pins.resolve(graphic.id) : void 0;
+		const presentation = isPinnableGraphic(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, presentation);
@@ -7969,34 +8584,13 @@ var TacticalDraw = class {
 					}
 				});
 				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 } : {}
-					}
-				};
+				return pinGroup(graphic, revision, {
+					resource: pointSymbolResource(body),
+					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 {
@@ -8017,6 +8611,23 @@ var TacticalDraw = class {
 				revision
 			};
 		}
+		if (isMarker(graphic)) {
+			if (!this.markers) throw new MarkerCapabilityRequiredError();
+			const presentation = resolved ?? this.pins.resolve(graphic.id);
+			const render = this.markerRender(graphic);
+			if (this.graphicUsesPinPresentation(graphic, presentation)) return pinGroup(graphic, revision, {
+				...markerPinBody(render),
+				presentation,
+				opacity: markerOpacity(graphic)
+			});
+			const plan = renderMarkerForAdapter(this.adapter, this.markers, graphic, render);
+			return {
+				id: graphic.id,
+				features: plan.features,
+				iconResources: [plan.resource],
+				revision
+			};
+		}
 		const render = renderMeasureForAdapter(this.adapter, graphic, {
 			graphicsStyle: this.graphicsStyle,
 			symbolColors: this.symbolColors
@@ -8034,17 +8645,22 @@ var TacticalDraw = class {
 	* resolution-independent graphics remain cache hits.
 	*/
 	invalidateGraphicGroupCache(clearBodies = true) {
-		if (clearBodies) this.pinBodies = /* @__PURE__ */ new WeakMap();
+		if (clearBodies) {
+			this.pinBodies = /* @__PURE__ */ new WeakMap();
+			this.markerRenders = /* @__PURE__ */ new WeakMap();
+		}
 		this.graphicGroupCache = /* @__PURE__ */ new WeakMap();
 	}
 	/** Refresh capability-dependent renders before any caller-visible state is mutated. */
 	refreshCapabilityGenerations() {
 		const currentPointSymbolGeneration = this.pointSymbols?.generation;
 		const currentImageGeneration = this.images?.generation;
-		if (currentPointSymbolGeneration !== this.lastSeenPointSymbolGeneration || currentImageGeneration !== this.lastSeenImageGeneration) {
+		const currentMarkerGeneration = this.markers?.generation;
+		if (currentPointSymbolGeneration !== this.lastSeenPointSymbolGeneration || currentImageGeneration !== this.lastSeenImageGeneration || currentMarkerGeneration !== this.lastSeenMarkerGeneration) {
 			this.invalidateGraphicGroupCache();
 			this.lastSeenPointSymbolGeneration = currentPointSymbolGeneration;
 			this.lastSeenImageGeneration = currentImageGeneration;
+			this.lastSeenMarkerGeneration = currentMarkerGeneration;
 		}
 	}
 	/** Submit one complete grouped desired state for the host stack plus overrides. */
@@ -8161,7 +8777,7 @@ var TacticalDraw = class {
 			seen.add(m.id);
 		}
 		this.refreshCapabilityGenerations();
-		for (const graphic of measures) if (isImageGraphic(graphic)) this.renderGraphicGroup(graphic);
+		for (const graphic of measures) if (isImageGraphic(graphic) || isMarker(graphic)) this.renderGraphicGroup(graphic);
 		const activeEdit = this.activeEdit;
 		const constructingSession = activeEdit ? null : this.activeInteraction.session;
 		const constructingGraphic = constructingSession && "workingGraphic" in constructingSession ? constructingSession.workingGraphic : void 0;
@@ -8251,7 +8867,7 @@ var TacticalDraw = class {
 			if (excluded.has(id)) continue;
 			const graphic = this.lastRenderedMeasuresById.get(id);
 			if (!graphic) continue;
-			if (isPointSymbol(graphic)) {
+			if (isPinnableGraphic(graphic)) {
 				const pin = this.renderGraphicGroup(graphic).pin;
 				if (pin) {
 					pinGroups.push({
@@ -8302,6 +8918,10 @@ var TacticalDraw = class {
 			if (!this.images) return null;
 			return imageFootprint(graphic, renderImageForAdapter(this.adapter, this.images, graphic).render, this.adapter)?.box ?? null;
 		}
+		if (isMarker(graphic)) {
+			if (!this.markers) return null;
+			return markerFootprint(graphic, this.markerRender(graphic), this.adapter)?.box ?? null;
+		}
 		const features = this.renderGraphicGroup(graphic).features;
 		if (graphic.kind === "text") return fitTextFootprintFromFeatures(features, (lonLat) => this.adapter.getPixelFromCoordinate(lonLat), {
 			resolution: this.adapter.getResolution(),
@@ -8413,6 +9033,21 @@ var TacticalDraw = class {
 	}
 	draw(draft, options) {
 		this.assertAlive();
+		if (draft.kind === "marker") {
+			if (!this.markers) throw new MarkerCapabilityRequiredError();
+			const preempt = this.guardAndPreempt();
+			if (preempt) return preempt;
+			return this.runWithSlot((onSettled) => runMarkerDraw({
+				adapter: this.adapter,
+				capability: this.markers,
+				draft,
+				previewLayer: this.previewLayer,
+				generateId: this.generateId,
+				signal: options?.signal,
+				onSettled,
+				snap: this.resolveSnap
+			}), null);
+		}
 		if (draft.kind === "image") {
 			if (!this.images) throw new ImageCapabilityRequiredError();
 			const preempt = this.guardAndPreempt();
@@ -8502,6 +9137,47 @@ var TacticalDraw = class {
 	}
 	edit(measure, options) {
 		this.assertAlive();
+		if (isMarker(measure)) {
+			normaliseMarkerModes(options?.modes);
+			if (!this.markers) throw new MarkerCapabilityRequiredError();
+			const preempt = this.guardAndPreempt();
+			if (preempt) return preempt;
+			const wasOnGraphicsLayer = this.lastRenderedMeasures.some((g) => g.id === measure.id);
+			const handleIdPrefix = `__td_edit_${++this.editCounter}__`;
+			return this.runWithSlot((onSettled) => runMarkerEdit({
+				adapter: this.adapter,
+				capability: this.markers,
+				marker: measure,
+				...this.graphicUsesPinPresentation(measure) ? {
+					renderPin: (marker) => this.buildGraphicGroup(marker),
+					canRenderPin: () => this.graphicUsesPinPresentation(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: this.trackSession(options?.onSession),
+				handleIdPrefix,
+				settleToGraphics: (settled) => this.settleWorkingGraphics([{
+					id: measure.id,
+					committed: settled
+				}]),
+				publishWorkingGraphic: (group) => this.publishWorkingGraphics([group]),
+				wasOnGraphicsLayer,
+				onSettled,
+				onClickAwayGraphicsPick: (event) => this.dispatchHostPick(this.graphicsLayer, event),
+				snap: this.resolveSnap
+			}), (handle) => {
+				handle.syncHostMembership(this.lastRenderedMeasures.some((graphic) => graphic.id === handle.measureId && isMarker(graphic)));
+				this.activeEdit = handle;
+				return () => {
+					if (this.activeEdit === handle) this.activeEdit = null;
+				};
+			});
+		}
 		if (isImageGraphic(measure)) {
 			normaliseImageModes(options?.modes);
 			if (!this.images) throw new ImageCapabilityRequiredError();
@@ -8643,6 +9319,7 @@ var TacticalDraw = class {
 		}
 		if (measures.some(isPointSymbol) && !this.pointSymbols) throw new PointSymbolCapabilityRequiredError();
 		if (measures.some(isImageGraphic) && !this.images) throw new ImageCapabilityRequiredError();
+		if (measures.some(isMarker) && !this.markers) throw new MarkerCapabilityRequiredError();
 		const preempt = this.guardAndPreempt();
 		if (preempt) return preempt;
 		const isOnGraphicsLayer = (id) => this.lastRenderedMeasures.some((m) => m.id === id);
@@ -8658,7 +9335,8 @@ var TacticalDraw = class {
 			adapter: this.adapter,
 			capability: this.pointSymbols,
 			imageCapability: this.images,
-			...this.pointSymbols ? { renderPin: (symbol) => this.buildGraphicGroup(symbol) } : {},
+			markerCapability: this.markers,
+			...this.pointSymbols || this.markers ? { renderPin: (graphic) => this.buildGraphicGroup(graphic) } : {},
 			graphics: measures,
 			graphicsLayer: this.graphicsLayer,
 			previewLayer: this.previewLayer,
@@ -9037,6 +9715,35 @@ var TacticalDraw = class {
 	}
 };
 /**
+* The graphics-stack group for a pin-presented point symbol or marker
+* (ADR-0056): a pickable ground point plus the adapter-drawn billboard.
+*/
+function pinGroup(graphic, revision, pin) {
+	return {
+		id: graphic.id,
+		revision,
+		features: [{
+			type: "Feature",
+			id: `${graphic.id}:pin`,
+			geometry: {
+				type: "Point",
+				coordinates: [...graphic.position]
+			},
+			properties: {
+				graphicId: graphic.id,
+				graphicKind: graphic.kind,
+				pinPresentation: true
+			}
+		}],
+		iconResources: [],
+		pin: {
+			id: graphic.id,
+			position: graphic.position,
+			...pin
+		}
+	};
+}
+/**
 * Classify what live view state a graphic's render reads. Offset point symbols
 * resolve their body and connector in pixel space, so they depend on the whole
 * camera rather than on scale alone.
@@ -9047,6 +9754,7 @@ function graphicViewDependence(graphic, nativePointSymbolScaling) {
 		return graphic.size.unit === "meters" && !nativePointSymbolScaling ? "resolution" : "none";
 	}
 	if (isImageGraphic(graphic)) return "none";
+	if (isMarker(graphic)) return markerScalesWithResolution(graphic, nativePointSymbolScaling) ? "resolution" : "none";
 	return measureRendersFromViewState(graphic) ? "resolution" : "none";
 }
 function normalisePointEditModes(modes) {
@@ -9431,4 +10139,4 @@ function nearestWorldCopyPosition(position, refLng) {
 	return [nearestWorldCopyLng(position[0], refLng), ...position.slice(1)];
 }
 //#endregion
-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, combinePinScale, 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, pinDistanceScale, pinZoomScale, placePointSymbol, pointSymbolFootprint, pointSymbolResource, renderOrderToVisualOrder, resizePointSymbolSize, resolveGroundTextSizePixels, resolvePickPresentation, resolvePinPresentation, resolvePointSymbolOffset, resolveTextHaloWidth, resolveTextSizePixels, scalePointSymbolLayout, tryControlMeasureIdFromFeature, validateImageGraphic };
+export { BaseMapAdapter, DEFAULT_LABEL_SIZE_PIXELS, DEFAULT_MARKER_SIZE, DEFAULT_PIN_PRESENTATION, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, HATCH_PATTERNS, ImageCapabilityRequiredError, MINE_PATTERN_TILE_SIZE, MarkerCapabilityRequiredError, PinPresentationStore, PointSymbolCapabilityRequiredError, PointerCallbackHub, TEXT_HALO_COLOR, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, TacticalDrawDestroyedError, alignPointSymbolIndicator, bindAbortable, cloneImageGraphic, cloneMarker, clonePointSymbol, coerceHandleStyle, combinePinScale, combineWithHostSignal, convertPointSymbolPlacement, effectivePointSymbolPixelSize, evaluatePickCandidates, fillPatternImageDimension, fillPatternImageId, getSizeAnchor, hitTestFeature, hitTestIconFeature, ignoreAbort, imageFootprint, imageOpacity, isAnchoredGraphic, isImageGraphic, isMarker, isMinePattern, isPinnableGraphic, isPointSymbol, isTacticalDrawAbortError, isValidPinNumber, makeFillPatternImage, markerFootprint, markerOpacity, mergeNativeAndCachedPickFeatures, movePointSymbolLocation, nearestWorldCopyLng, nearestWorldCopyPosition, normalizeImageGraphic, normalizeMarker, parseColor, pickHitTolerance, pickPointerType, pinDistanceScale, pinZoomScale, placePointSymbol, pointSymbolFootprint, pointSymbolResource, renderOrderToVisualOrder, resizePointSymbolSize, resolveGroundTextSizePixels, resolveMarkerRender, resolvePickPresentation, resolvePinPresentation, resolvePointSymbolOffset, resolveTextHaloWidth, resolveTextSizePixels, scalePointSymbolLayout, tryControlMeasureIdFromFeature, validateImageGraphic, validateMarker };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbat-mapper/tactical-draw",
-  "version": "0.13.2",
+  "version": "0.14.1",
   "description": "Engine-agnostic draw/edit core for tactical control measures (MIL-STD-2525 / APP-6). The MapAdapter ABI and bring-your-own-engine entry point for the tactical-draw package family.",
   "license": "MIT",
   "author": "Orbat Mapper",
@@ -39,7 +39,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@orbat-mapper/control-measures": "^0.32.0"
+    "@orbat-mapper/control-measures": "^0.33.0"
   },
   "peerDependencies": {
     "vitest": ">=4.0.0"