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

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { AmplifierPlacement, AmplifierPlacements, ControlMeasure, ControlMeasureKind, ControlMeasureSnapshot, ControlMeasureStyle, TextAmplifiers } from "@orbat-mapper/control-measures";
+import { AmplifierPlacement, AmplifierPlacements, ControlMeasure, ControlMeasureKind, ControlMeasureRender, ControlMeasureStyle, TextAmplifiers } from "@orbat-mapper/control-measures";
 import { Feature, Position } from "geojson";
 
 //#region src/gestures/types.d.ts
@@ -100,6 +100,14 @@ interface HandleStyle {
   pointRadius?: number;
 }
 type LayerId = string;
+/** Canonical SVG resource shared by point features through `iconId`. */
+interface IconResource {
+  id: string;
+  svg: string;
+  width: number;
+  height: number;
+  anchor: [number, number];
+}
 /**
  * Click-style hit event delivered by {@link MapAdapter.onPick}.
  *
@@ -137,6 +145,8 @@ interface MapAdapter {
    * Set the style for a specific layer.
    */
   setLayerStyle(layerId: LayerId, style: StyleOptions): void;
+  /** Reconcile the layer's desired shared icon resources. */
+  reconcileLayerIconResources(layerId: LayerId, resources: readonly IconResource[]): void;
   /**
    * Set features on a vector layer.
    * Features should be standard GeoJSON Features.
@@ -298,6 +308,8 @@ declare abstract class BaseMapAdapter<TLayerHandle, TEventToken, TViewToken> imp
   protected viewChangeTokens: Map<() => void, TViewToken>;
   protected featureCache: Map<string, Feature<import("geojson").Geometry, import("geojson").GeoJsonProperties>[]>;
   protected featuresChangedListeners: Map<string, Set<(features: Feature[]) => void>>;
+  protected iconResources: Map<string, IconResource>;
+  private layerIconResourceIds;
   private layerCounter;
   private destroyed;
   protected nextLayerId(): LayerId;
@@ -305,6 +317,7 @@ declare abstract class BaseMapAdapter<TLayerHandle, TEventToken, TViewToken> imp
     style?: StyleOptions;
   }): LayerId;
   removeLayer(layerId: LayerId): void;
+  reconcileLayerIconResources(layerId: LayerId, resources: readonly IconResource[]): void;
   setLayerFeatures(layerId: LayerId, features: readonly Feature[]): void;
   updateLayerFeatures(layerId: LayerId, features: readonly Feature[]): void;
   removeFeatures(layerId: LayerId, ids: readonly string[]): void;
@@ -319,6 +332,10 @@ declare abstract class BaseMapAdapter<TLayerHandle, TEventToken, TViewToken> imp
   protected emitLayerFeaturesChanged(layerId: LayerId, features: Feature[]): void;
   protected onLayerFeaturesChanged(layerId: LayerId, listener: (features: Feature[]) => void): () => void;
   protected destroyEngineResources(): void;
+  protected applyIconResources(resources: readonly IconResource[]): void;
+  protected getIconResource(id: string): IconResource | undefined;
+  protected removeIconResource(id: string): void;
+  private pruneIconResources;
   protected abstract createLayer(layerId: LayerId, style?: StyleOptions): TLayerHandle;
   protected abstract destroyLayer(handle: TLayerHandle): void;
   protected abstract applyFeatureOps(layerId: LayerId, ops: FeatureOps): void;
@@ -396,6 +413,13 @@ type ToPixel = (lonLat: Position) => PixelCoordinate | null;
  * Returns the first matching feature in iteration order, or null.
  */
 declare function hitTestFeature(pixel: PixelCoordinate, features: readonly Feature[], hitTolerance: number, toPixel: ToPixel): Feature | 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.
+ */
+declare function hitTestIconFeature(pixel: PixelCoordinate, feature: Feature, resource: IconResource, hitTolerance: number, toPixel: ToPixel, bearing?: number): boolean;
 //#endregion
 //#region src/gestures/hit-tolerance.d.ts
 declare const TOUCH_HIT_TOLERANCE_PX = 22;
@@ -430,6 +454,87 @@ declare class PointerCallbackHub {
   clear(): void;
 }
 //#endregion
+//#region src/point-symbol.d.ts
+type PointSymbolSize = {
+  value: number;
+  unit: "pixels";
+} | {
+  value: number;
+  unit: "meters";
+};
+interface PointSymbolGraphicModifiers {
+  /** Radians clockwise, relative to the point symbol's own orientation. */
+  direction?: number;
+}
+interface PointSymbolColors {
+  fill?: string;
+  frame?: string;
+  icon?: string;
+  info?: string;
+  outline?: string;
+}
+interface PointSymbolStyle {
+  colors?: PointSymbolColors;
+  monoColor?: string;
+  opacity?: number;
+  outlineWidth?: number;
+  fill?: boolean;
+  frame?: boolean;
+  icon?: boolean;
+}
+interface PointSymbol {
+  id: string;
+  kind: "point-symbol";
+  sidc: string;
+  position: Position;
+  /** Normalized radians clockwise from geographic north. */
+  rotation: number;
+  /** Milsymbol's octagon-based L dimension. */
+  size: PointSymbolSize;
+  textAmplifiers?: TextAmplifiers;
+  graphicModifiers?: PointSymbolGraphicModifiers;
+  style?: PointSymbolStyle;
+  rendererOptions?: {
+    milsymbol?: Record<string, unknown>;
+  };
+  properties?: Record<string, unknown>;
+  schemaVersion?: 1;
+}
+interface PointSymbolAnchor {
+  x: number;
+  y: number;
+}
+/** Canonical-size, renderer-neutral point-symbol output. */
+interface PointSymbolRender {
+  /** Content-derived identity for adapter-wide native-resource reuse. */
+  resourceId: string;
+  svg: string;
+  /** Renderer-space octagon size used to interpret persisted symbol size. */
+  octagonSize: number;
+  width: number;
+  height: number;
+  anchor: PointSymbolAnchor;
+  octagonAnchor: PointSymbolAnchor;
+  valid: boolean;
+  validation?: unknown;
+}
+interface PointSymbolCapability {
+  readonly defaultSize: PointSymbolSize;
+  readonly defaultRotation: number;
+  render(symbol: PointSymbol): PointSymbolRender;
+  invalidate(): void;
+}
+declare function isPointSymbol(graphic: unknown): graphic is PointSymbol;
+declare function clonePointSymbol(symbol: PointSymbol): PointSymbol;
+//#endregion
+//#region src/graphic.d.ts
+type Graphic = ControlMeasure | PointSymbol;
+type GraphicRender = ControlMeasureRender | PointSymbolRender;
+interface GraphicSnapshot<G extends Graphic = Graphic> {
+  graphic: G;
+  render: G extends PointSymbol ? PointSymbolRender : ControlMeasureRender;
+}
+//#endregion
 //#region src/tactical-draw/abort.d.ts
 /**
  * AbortPlumbing for the TacticalDraw façade.
@@ -557,7 +662,7 @@ type EditMode = "reshape" | "transform" | "labeldrag" | "delete";
  * `TransformSession.close()` / `EditSession.close()` / `DrawSession.commit()`,
  * a click-away close, a gesture commit (dblclick, a second click/tap on the
  * finishing vertex, a click on another graphics-layer measure), or
- * `TransformSession.setMembers([])`. `"error"` is the commit-time snapshot
+ * `TransformSession.setGraphics([])`. `"error"` is the commit-time snapshot
  * build throwing (the outer promise rejects with that error, not a
  * `TacticalDrawAbortError`). The remaining values replay
  * `TacticalDrawAbortError.reason` verbatim: `"escape"`, `"signal"`,
@@ -579,7 +684,9 @@ type SettleReason = "close" | "error" | TacticalDrawAbortReason;
  */
 interface EditSession {
   /** Immutable edit-start input. */
-  readonly measure: ControlMeasure;
+  readonly graphic: ControlMeasure;
+  /** Live complete working graphic. Copy on read. */
+  readonly workingGraphic: ControlMeasure;
   /** Live working state. Copy on read. */
   readonly controlPoints: readonly Position[];
   /** Live working options. Copy on read. */
@@ -605,12 +712,12 @@ interface EditSession {
    */
   readonly sizeAnchor: SizeAnchor;
   /**
-   * Commit: returns the `ControlMeasureSnapshot` of the current working state
+   * Commit: returns the `GraphicSnapshot<ControlMeasure>` of the current working state
    * and resolves the outer `edit` promise with the same value (the same
    * reference — no double-bake of ground-anchored sizes). Returns `undefined`
    * after the session has settled (idempotent no-op).
    */
-  close(): ControlMeasureSnapshot | undefined;
+  close(): GraphicSnapshot<ControlMeasure> | undefined;
   /** Reject the outer `edit` promise with reason `"session"`. */
   abort(): void;
   /**
@@ -621,6 +728,8 @@ interface EditSession {
    * is rejected with `TypeError`.
    */
   setModes(modes: readonly EditMode[]): void;
+  /** Atomically replace the live working graphic while preserving id and kind. */
+  updateGraphic(updater: (graphic: ControlMeasure) => ControlMeasure): void;
   /** Shallow-merge per-measure generator options into the live working copy. */
   setOptions(partial: ControlMeasure["options"]): void;
   /**
@@ -662,7 +771,7 @@ interface EditSession {
   onChange(listener: (event: EditChangeEvent) => void): () => void;
   /**
    * Subscribe to the committed snapshot — the single delivery channel for the
-   * `ControlMeasureSnapshot` this session ever commits (#197, mirroring
+   * `GraphicSnapshot<ControlMeasure>` this session ever commits (#197, mirroring
    * `TransformSession.onCommit` #191). Fires exactly once, synchronously from
    * within the [[close]] call that produced it (`session.close()`,
    * `event.close()` from [[onChange]], a click-away close, or a click on
@@ -675,7 +784,7 @@ interface EditSession {
    * session has settled returns a no-op unsubscribe and the listener never
    * fires.
    */
-  onCommit(handler: (snapshot: ControlMeasureSnapshot) => void): () => void;
+  onCommit(handler: (snapshot: GraphicSnapshot<ControlMeasure>) => void): () => void;
   /**
    * Subscribe to the session's settlement — the lifecycle complement of
    * [[onCommit]]: `onCommit` delivers *what* was committed, `onSettled` says
@@ -712,9 +821,9 @@ interface EditSession {
  */
 interface EditChangeEvent {
   /** Working state after the completed gesture. */
-  readonly measure: ControlMeasureSnapshot;
+  readonly graphic: GraphicSnapshot<ControlMeasure>;
   /** State immediately before this gesture. */
-  readonly previous: ControlMeasureSnapshot;
+  readonly previous: GraphicSnapshot<ControlMeasure>;
   /** The session the event belongs to. */
   readonly session: EditSession;
   /**
@@ -729,38 +838,65 @@ interface EditChangeEvent {
   abort(): void;
 }
 //#endregion
+//#region src/tactical-draw/graphic-edit-session.d.ts
+interface GraphicEditChangeEvent<G extends Graphic = Graphic> {
+  readonly graphic: GraphicSnapshot<G>;
+  readonly previous: GraphicSnapshot<G>;
+  readonly session: GraphicEditSession<G>;
+  reject(): void;
+  close(): void;
+  abort(): void;
+}
+/** Common selection/editing contract shared by control measures and point symbols. */
+interface GraphicEditSession<G extends Graphic = Graphic> {
+  /** Immutable edit-start input. */
+  readonly graphic: G;
+  /** Live working graphic. Copy on read. */
+  readonly workingGraphic: G;
+  readonly dirty: boolean;
+  readonly modes: readonly EditMode[];
+  close(): GraphicSnapshot<G> | undefined;
+  abort(): void;
+  setModes(modes: readonly EditMode[]): void;
+  /** Atomically replace any part of the live working graphic. */
+  updateGraphic(updater: (graphic: G) => G): void;
+  onChange(listener: (event: GraphicEditChangeEvent<G>) => void): () => void;
+  onCommit(handler: (snapshot: GraphicSnapshot<G>) => void): () => void;
+  onSettled(handler: (reason: SettleReason) => void): () => void;
+}
+//#endregion
 //#region src/tactical-draw/transform-session.d.ts
 /**
- * Surface delivered via `td.editMany(measures, opts).onSession` and
+ * Surface delivered via `td.editMany(graphics, opts).onSession` and
  * synchronously available from `td.activeTransformSession` while the group
  * transform is live. The group sibling of `EditSession` (`edit-session.ts`):
  * no reshape, no per-measure `setOptions`/`setStyle` — only the shared
  * transform box's corner-scale / rotate / body-translate gestures, applied to
  * every member at once. See the Phase 3 ("Multi-select") slice of ADR-0017.
  *
- * The member set is mutable via [[setMembers]] (#187): members can join or
+ * The member set is mutable via [[setGraphics]] (#187): members can join or
  * leave a live session without a session boundary. Because membership changes
  * over the session's lifetime, snapshot arrays are keyed by **measure id**, not
- * by index — a snapshot's identity is `snapshot.measure.id`. `measures` is a
+ * by index — a snapshot's identity is `snapshot.graphic.id`. `graphics` is a
  * live view of the current members' join-time inputs; a `TransformChangeEvent`'s
- * arrays are index-aligned with `session.measures` *as of that emission*. After
- * the session settles (`close` / `abort` / an emptying `setMembers`), every
+ * arrays are index-aligned with `session.graphics` *as of that emission*. After
+ * the session settles (`close` / `abort` / an emptying `setGraphics`), every
  * method is a silent no-op (except [[onSettled]] — late registration still
  * delivers, asynchronously).
  */
 interface TransformSession {
   /**
-   * Live view of the current members' join-time input measures — a fresh array
-   * on each read, in current membership order. Grows/shrinks as [[setMembers]]
+   * Live view of the current members' join-time input graphics — a fresh array
+   * on each read, in current membership order. Grows/shrinks as [[setGraphics]]
    * adds or removes members. Not stable across membership changes: key
-   * snapshots by `snapshot.measure.id` rather than relying on index alignment.
+   * snapshots by `snapshot.graphic.id` rather than relying on index alignment.
    */
-  readonly measures: readonly ControlMeasure[];
+  readonly graphics: readonly ControlMeasure[];
   /**
-   * Live working control points for the member whose id is `measureId`, or
+   * Live working control points for the member whose id is `graphicId`, or
    * `undefined` when no member carries that id. Copy on read.
    */
-  controlPointsFor(measureId: string): readonly Position[] | undefined;
+  controlPointsFor(graphicId: string): readonly Position[] | undefined;
   /** `true` when any member's working points differ from its edit-start input beyond tolerance. */
   readonly dirty: boolean;
   /**
@@ -803,22 +939,22 @@ interface TransformSession {
    * resolution through a single subscription. Returns `undefined` (a silent
    * no-op) after the session has settled.
    *
-   * `setMembers([])` on a live session delegates to [[close]]: it commits every
+   * `setGraphics([])` on a live session delegates to [[close]]: it commits every
    * current member, resolves the promise with their snapshots, and returns that
-   * same array. Duplicate ids in `measures` throw `TypeError` synchronously,
+   * same array. Duplicate ids in `graphics` throw `TypeError` synchronously,
    * without mutating session state.
    */
-  setMembers(measures: readonly ControlMeasure[]): ControlMeasureSnapshot[] | undefined;
+  setGraphics(graphics: readonly ControlMeasure[]): GraphicSnapshot<ControlMeasure>[] | undefined;
   /**
-   * Commit: returns the members' `ControlMeasureSnapshot[]` (the members in the
+   * Commit: returns the members' `GraphicSnapshot<ControlMeasure>[]` (the members in the
    * set at close time) and resolves the outer `editMany` promise with the same
    * value (the same reference — no double-bake of ground-anchored sizes). A
-   * member removed mid-session via [[setMembers]] is not included here; its exit
-   * snapshot was returned from that `setMembers` call (and delivered to
+   * member removed mid-session via [[setGraphics]] is not included here; its exit
+   * snapshot was returned from that `setGraphics` call (and delivered to
    * [[onCommit]] at that time). Returns `undefined` after the session has
    * settled (idempotent no-op).
    */
-  close(): ControlMeasureSnapshot[] | undefined;
+  close(): GraphicSnapshot<ControlMeasure>[] | undefined;
   /** Reject the outer `editMany` promise with reason `"session"`. */
   abort(): void;
   /**
@@ -836,22 +972,22 @@ interface TransformSession {
   onChange(listener: (event: TransformChangeEvent) => void): () => void;
   /**
    * Subscribe to committed exit-snapshot batches — the single delivery channel
-   * for every `ControlMeasureSnapshot[]` this session ever commits (#191). Fires
+   * for every `GraphicSnapshot<ControlMeasure>[]` this session ever commits (#191). Fires
    * exactly once per batch:
    *
-   * - The members [[setMembers]] removes, but only when that call actually
+   * - The members [[setGraphics]] removes, but only when that call actually
    *   removed at least one member.
-   * - The close-time members on any commit path: [[close]], `setMembers([])`,
+   * - The close-time members on any commit path: [[close]], `setGraphics([])`,
    *   a click-away close, or `TransformChangeEvent.close()`.
    *
    * Never fires on an abort/reject path — pair it with [[onSettled]] to also
    * observe abort settles. Fires synchronously from within the
-   * `setMembers`/`close` call that produced the batch, before that call
+   * `setGraphics`/`close` call that produced the batch, before that call
    * returns, and the array delivered here is the same reference that call
    * returns (and, for the close batch, the same reference the `editMany`
    * promise resolves with). This is the recommended single fold path for exit
    * state — subscribe once in `onSession` and every committed snapshot, from
-   * either delivery site, arrives here exactly once; the `setMembers` return
+   * either delivery site, arrives here exactly once; the `setGraphics` return
    * value and the promise resolution are unchanged and remain valid for
    * backward compatibility.
    *
@@ -861,7 +997,7 @@ interface TransformSession {
    * session has settled returns a no-op unsubscribe and the listener never
    * fires.
    */
-  onCommit(handler: (snapshots: ControlMeasureSnapshot[]) => void): () => void;
+  onCommit(handler: (snapshots: GraphicSnapshot<ControlMeasure>[]) => void): () => void;
   /**
    * Subscribe to the session's settlement — the lifecycle complement of
    * [[onCommit]]: `onCommit` delivers *what* was committed, `onSettled` says
@@ -891,26 +1027,26 @@ interface TransformSession {
 }
 /**
  * Delivered to `TransformSession.onChange` listeners once per completed group
- * gesture. Both `measures` and `previous` are index-aligned with
- * `session.measures` *as of this emission*. Key by `measure.id` rather than
- * relying on index alignment across emissions. A `setMembers` call from within
+ * gesture. Both `graphics` and `previous` are index-aligned with
+ * `session.graphics` *as of this emission*. Key by `graphic.id` rather than
+ * relying on index alignment across emissions. A `setGraphics` call from within
  * a listener takes effect immediately and supersedes this emission's
  * `reject()` (the rollback baseline no longer matches the member set);
  * `close()` and `abort()` still apply, against the new membership. See
  * `EditChangeEvent` for the identical emission contract this mirrors.
  */
 interface TransformChangeEvent {
-  /** Working state after the completed gesture, index-aligned with `session.measures` as of this emission. */
-  readonly measures: ControlMeasureSnapshot[];
-  /** State immediately before this gesture, index-aligned with `session.measures` as of this emission. */
-  readonly previous: ControlMeasureSnapshot[];
+  /** Working state after the completed gesture, index-aligned with `session.graphics` as of this emission. */
+  readonly graphics: GraphicSnapshot<ControlMeasure>[];
+  /** State immediately before this gesture, index-aligned with `session.graphics` as of this emission. */
+  readonly previous: GraphicSnapshot<ControlMeasure>[];
   /** The session the event belongs to. */
   readonly session: TransformSession;
   /**
    * Roll every member's working preview back to `previous` after all
    * listeners have run. Multiple calls collapse to a single rollback.
    * Overridden by `close()` or `abort()` if either is also called during this
-   * emission, and dropped if a listener called `session.setMembers` (the
+   * emission, and dropped if a listener called `session.setGraphics` (the
    * rollback baseline no longer matches the member set).
    */
   reject(): void;
@@ -920,6 +1056,26 @@ interface TransformChangeEvent {
   abort(): void;
 }
 //#endregion
+//#region src/tactical-draw/graphic-transform-session.d.ts
+interface GraphicTransformChangeEvent {
+  readonly graphics: GraphicSnapshot[];
+  readonly previous: GraphicSnapshot[];
+  readonly session: GraphicTransformSession;
+  reject(): void;
+  close(): void;
+  abort(): void;
+}
+interface GraphicTransformSession {
+  readonly graphics: readonly Graphic[];
+  readonly workingGraphics: readonly Graphic[];
+  readonly dirty: boolean;
+  close(): GraphicSnapshot[] | undefined;
+  abort(): void;
+  onChange(listener: (event: GraphicTransformChangeEvent) => void): () => void;
+  onCommit(listener: (snapshots: GraphicSnapshot[]) => void): () => void;
+  onSettled(listener: (reason: SettleReason) => void): () => void;
+}
+//#endregion
 //#region src/tactical-draw/session.d.ts
 /**
  * Scoped surface delivered via `td.draw({ onSession })` for variable-length
@@ -951,7 +1107,7 @@ interface DrawSession {
   onChange(listener: (session: DrawSession) => void): () => void;
   /**
    * Subscribe to the committed snapshot — the single delivery channel for the
-   * `ControlMeasureSnapshot` this session ever commits (#197, mirroring
+   * `GraphicSnapshot<ControlMeasure>` this session ever commits (#197, mirroring
    * `TransformSession.onCommit` #191). Fires exactly once, synchronously from
    * within the commit that produced it (`session.commit()`, dblclick, or a
    * second click/tap on the finishing vertex), with the same reference the
@@ -964,7 +1120,7 @@ interface DrawSession {
    * session has settled returns a no-op unsubscribe and the listener never
    * fires.
    */
-  onCommit(handler: (snapshot: ControlMeasureSnapshot) => void): () => void;
+  onCommit(handler: (snapshot: GraphicSnapshot<ControlMeasure>) => void): () => void;
   /**
    * Subscribe to the session's settlement — the lifecycle complement of
    * [[onCommit]]: `onCommit` delivers *what* was committed, `onSettled` says
@@ -990,6 +1146,9 @@ interface DrawSession {
   onSettled(handler: (reason: SettleReason) => void): () => void;
 }
 //#endregion
+//#region src/tactical-draw/point-symbol-draw-controller.d.ts
+type DrawPointSymbolDraft = Pick<PointSymbol, "kind" | "sidc"> & Partial<Omit<PointSymbol, "kind" | "sidc">>;
+//#endregion
 //#region src/tactical-draw/tactical-draw.d.ts
 /**
  * Host-supplied layer slot ids. Any omitted slot is allocated by the façade and
@@ -1015,6 +1174,8 @@ interface InteractionHit {
 }
 interface TacticalDrawOptions {
   layers?: TacticalDrawLayerOptions;
+  /** Optional renderer capability for first-class point symbols (ADR-0029). */
+  pointSymbols?: PointSymbolCapability;
   /**
    * Façade-level default style passed through to `renderControlMeasure` as the
    * third (lowest priority) style layer per StyleResolver (#44). Shallow-merged
@@ -1042,7 +1203,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) => void;
+  onSession?: (session: EditSession | GraphicEditSession<PointSymbol>) => void;
   /**
    * Default `true`. When `true`, a click on empty map (or on another graphics
    * layer measure) closes the active edit. Clicks on preview / handle
@@ -1101,7 +1262,7 @@ interface EditManyOptions {
    * pointer event is processed. Lets a host wire Done/Cancel/Delete buttons to
    * the active session.
    */
-  onSession?: (session: TransformSession) => void;
+  onSession?: (session: TransformSession | GraphicTransformSession) => void;
   /**
    * Default `true`. When `true`, a click on empty map (or on a graphics-layer
    * measure outside the group) closes the active transform. Clicks on preview
@@ -1182,6 +1343,7 @@ declare class TacticalDraw {
   private readonly graphicsStyle;
   private readonly defaultInteractionStyle;
   private readonly generateId;
+  private readonly pointSymbols;
   private destroyed;
   private hasRendered;
   private readonly activeInteraction;
@@ -1196,7 +1358,7 @@ declare class TacticalDraw {
    * 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.
    */
   private activeTransform;
   /**
@@ -1207,7 +1369,7 @@ declare class TacticalDraw {
    */
   private activeTransformSessionRef;
   /**
-   * 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).
@@ -1291,7 +1453,7 @@ declare class TacticalDraw {
    * layers (the only edit-facing side effect, `notifyExternalMeasure`, is a
    * pure style replay).
    */
-  render(measures: readonly ControlMeasure[]): void;
+  render(measures: readonly Graphic[]): void;
   /**
    * Nested-call guard + preempt, shared by `draw` and `edit`. Returns a
    * pre-rejected promise when called re-entrantly from inside another
@@ -1338,10 +1500,11 @@ declare class TacticalDraw {
    * 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<K extends ControlMeasureKind>(draft: DrawMeasureDraft<K>, options?: DrawOptions): Promise<ControlMeasureSnapshot<K>>;
+  draw(draft: DrawPointSymbolDraft, options?: DrawOptions): Promise<GraphicSnapshot<PointSymbol>>;
+  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
-   * that resolves with a `ControlMeasureSnapshot` of the working state on
+   * that resolves with a `GraphicSnapshot<ControlMeasure>` of the working state on
    * `session.close()` and rejects with `TacticalDrawAbortError` on
    * signal / Escape / destroy / preempt / `session.abort()`.
    *
@@ -1354,51 +1517,55 @@ declare class TacticalDraw {
    * session is over and why (#197) — together they make the returned promise
    * non-load-bearing for hosts that adopt them.
    */
-  edit(measure: ControlMeasure, options?: EditOptions): Promise<ControlMeasureSnapshot>;
+  edit(graphic: PointSymbol, options?: EditOptions): Promise<GraphicSnapshot<PointSymbol>>;
+  edit(measure: ControlMeasure, options?: EditOptions): Promise<GraphicSnapshot<ControlMeasure>>;
   /**
    * 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
+   * resolves with `GraphicSnapshot<ControlMeasure>[]` 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
+   * `session.abort()`. Key the resolved snapshots by `snapshot.graphic.id`:
+   * the member set is mutable (`session.setGraphics`, #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.
+   * exit snapshot returned from the `setGraphics` 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
+   * replace), prefer [[syncTransformGraphics]] 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: ControlMeasure[], options?: EditManyOptions): Promise<ControlMeasureSnapshot[]>;
+  editMany(measures: ControlMeasure[], options?: EditManyOptions): Promise<GraphicSnapshot<ControlMeasure>[]>;
+  editMany(graphics: Graphic[], options?: EditManyOptions): Promise<GraphicSnapshot[]>;
   /**
-   * 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
@@ -1410,7 +1577,7 @@ declare class TacticalDraw {
    * either path. Starting a fresh transform preempts any other in-flight
    * draw/edit exactly like `editMany`.
    */
-  syncTransformMembers(measures: readonly ControlMeasure[], options?: EditManyOptions): void;
+  syncTransformGraphics(graphics: readonly Graphic[], options?: EditManyOptions): void;
   /**
    * Subscribe to picks on committed control measures.
    *
@@ -1422,7 +1589,7 @@ declare class TacticalDraw {
    * Returns an idempotent unsubscribe function. An optional `signal` removes
    * the handler when aborted.
    */
-  onMeasurePick(handler: PickHandler, opts?: PickOptions): () => void;
+  onGraphicPick(handler: PickHandler, opts?: PickOptions): () => void;
   /**
    * Subscribe to pick events on `layerId`. Routed through the façade so the
    * close-then-pick contract (issue #52) is observable: when an active edit
@@ -1486,14 +1653,14 @@ declare class TacticalDraw {
    * The live variable-draw or edit session, or `null` while idle and during
    * fixed-length draws. Safe to read after `destroy()`.
    */
-  get activeSession(): DrawSession | EditSession | null;
+  get activeSession(): DrawSession | EditSession | GraphicEditSession<PointSymbol> | null;
   /**
    * The live `editMany` group-transform session, or `null` while idle (and
    * during any other interaction). Separate from `activeSession` because
    * `TransformSession` isn't part of its `DrawSession | EditSession` union —
    * see `activeTransformSessionRef`. Safe to read after `destroy()`.
    */
-  get activeTransformSession(): TransformSession | null;
+  get activeTransformSession(): TransformSession | GraphicTransformSession | null;
   /**
    * Tear down the façade. Releases only layer slots the façade created; host
    * supplied layer ids are left untouched. Safe to call multiple times. After
@@ -1555,6 +1722,9 @@ declare class TacticalDraw {
 declare class TacticalDrawDestroyedError extends Error {
   constructor(message?: string);
 }
+declare class PointSymbolCapabilityRequiredError extends Error {
+  constructor();
+}
 //#endregion
 //#region src/tactical-draw/transform-box.d.ts
 /**
@@ -1590,6 +1760,14 @@ interface TransformBox {
   angle: number;
 }
 //#endregion
+//#region src/tactical-draw/point-symbol-rendering.d.ts
+interface PointSymbolFootprint {
+  box: TransformBox;
+  corners: PixelCoordinate[];
+}
+/** Complete rotated logical footprint for selection and transform chrome. */
+declare function pointSymbolFootprint(symbol: PointSymbol, render: PointSymbolRender, adapter: Pick<MapAdapter, "getBearing" | "getPixelFromCoordinate" | "getResolution">): PointSymbolFootprint | null;
+//#endregion
 //#region src/world-wrap.d.ts
 /**
  * Shift `lng` by whole world widths (360°) onto the copy nearest `refLng`.
@@ -1604,4 +1782,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 { BaseMapAdapter, type CombinedAbort, DEFAULT_LABEL_SIZE_PIXELS, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, type DrawMeasureDraft, type DrawOptions, type DrawSession, type EditChangeEvent, type EditManyOptions, type EditMode, type EditOptions, type EditPointerDriver, type EditSession, type FeatureOps, type GuideStyle, type HandleStyle, type InteractionHit, type InteractionStyle, type LayerId, type MapAdapter, type MapCursor, type MapEvent, type MapEventHandler, type NativeEventEntry, type PickEvent, type PickHandler, type PickOptions, type PixelCoordinate, type PointerCallback, PointerCallbackHub, type PointerEventInfo, type SettleReason, type SizeAnchor, type StyleOptions, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, type TacticalDrawAbortReason, TacticalDrawDestroyedError, type TacticalDrawLayerOptions, type TacticalDrawOptions, type TextStyleOptions, type ToPixel, type TransformBox, type TransformChangeEvent, type TransformSession, bindAbortable, coerceHandleStyle, combineWithHostSignal, getSizeAnchor, hitTestFeature, ignoreAbort, isTacticalDrawAbortError, nearestWorldCopyLng, nearestWorldCopyPosition, pickHitTolerance, resolveGroundTextSizePixels, tryControlMeasureIdFromFeature };
+export { BaseMapAdapter, type CombinedAbort, DEFAULT_LABEL_SIZE_PIXELS, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, type DrawMeasureDraft, type DrawOptions, type DrawPointSymbolDraft, type DrawSession, type EditChangeEvent, type EditManyOptions, type EditMode, type EditOptions, type EditPointerDriver, type EditSession, type FeatureOps, type Graphic, type GraphicEditChangeEvent, type GraphicEditSession, type GraphicRender, type GraphicSnapshot, type GraphicTransformChangeEvent, type GraphicTransformSession, type GuideStyle, type HandleStyle, type IconResource, type InteractionHit, type InteractionStyle, type LayerId, type MapAdapter, type MapCursor, type MapEvent, type MapEventHandler, type NativeEventEntry, type PickEvent, type PickHandler, type PickOptions, type PixelCoordinate, type PointSymbol, type PointSymbolAnchor, type PointSymbolCapability, PointSymbolCapabilityRequiredError, type PointSymbolColors, type PointSymbolFootprint, type PointSymbolGraphicModifiers, type PointSymbolRender, type PointSymbolSize, type PointSymbolStyle, type PointerCallback, PointerCallbackHub, type PointerEventInfo, type SettleReason, type SizeAnchor, type StyleOptions, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, type TacticalDrawAbortReason, TacticalDrawDestroyedError, type TacticalDrawLayerOptions, type TacticalDrawOptions, type TextStyleOptions, type ToPixel, type TransformBox, type TransformChangeEvent, type TransformSession, bindAbortable, clonePointSymbol, coerceHandleStyle, combineWithHostSignal, getSizeAnchor, hitTestFeature, hitTestIconFeature, ignoreAbort, isPointSymbol, isTacticalDrawAbortError, nearestWorldCopyLng, nearestWorldCopyPosition, pickHitTolerance, pointSymbolFootprint, resolveGroundTextSizePixels, tryControlMeasureIdFromFeature };