@orbat-mapper/tactical-draw 0.2.0-alpha.37 → 0.2.0-alpha.39

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { S as PointerEventInfo, _ as fillPatternImageDimension, a as MapAdapter, b as EditPointerDriver, c as MapEventHandler, d as PickOptions, f as PixelCoordinate, g as HatchPattern, h as HATCH_PATTERNS, i as LayerId, l as PickEvent, m as TextStyleOptions, n as HandleStyle, o as MapCursor, p as StyleOptions, r as IconResource, s as MapEvent, t as FeatureGroup, u as PickHandler, v as fillPatternImageId, x as PointerCallback, y as makeFillPatternImage } from "./map-adapter-meRo5VY2.mjs";
+import { S as PointerEventInfo, _ as fillPatternImageDimension, a as MapAdapter, b as EditPointerDriver, c as MapEventHandler, d as PickOptions, f as PixelCoordinate, g as HatchPattern, h as HATCH_PATTERNS, i as LayerId, l as PickEvent, m as TextStyleOptions, n as HandleStyle, o as MapCursor, p as StyleOptions, r as IconResource, s as MapEvent, t as FeatureGroup, u as PickHandler, v as fillPatternImageId, x as PointerCallback, y as makeFillPatternImage } from "./map-adapter-84irgVJR.mjs";
 import { AmplifierPlacement, AmplifierPlacements, ControlMeasure, ControlMeasureKind, ControlMeasureRender, ControlMeasureStyle, TextAmplifiers } from "@orbat-mapper/control-measures";
 import { Feature, Position } from "geojson";
 
@@ -400,6 +400,15 @@ interface PointSymbolCapability {
   readonly defaultRotation: number;
   render(symbol: PointSymbol): PointSymbolRender;
   invalidate(): void;
+  /**
+   * Monotonic counter that increments on each `invalidate()` call. Consumers
+   * (e.g. a render cache keyed on graphic snapshot identity) may read this to
+   * detect that previously rendered point-symbol output is stale even though
+   * the graphic snapshot itself is unchanged. Optional — when absent,
+   * invalidation cannot be detected by cache layers, so they must not attempt
+   * to key on it.
+   */
+  readonly generation?: number;
 }
 declare function isPointSymbol(graphic: unknown): graphic is PointSymbol;
 declare function clonePointSymbol(symbol: PointSymbol): PointSymbol;
@@ -616,7 +625,15 @@ interface EditSession {
   readonly history: SessionHistory;
   /** Immutable edit-start input. */
   readonly graphic: ControlMeasure;
-  /** Live complete working graphic. Copy on read. */
+  /**
+   * Live complete working graphic. Copy on read. `properties` (host-owned
+   * metadata, e.g. `standardIdentity`/`colorMode`) is session-owned like every
+   * other working field: it starts at the edit-start value, is replaced
+   * wholesale by [[updateGraphic]], survives every subsequent gesture/setter
+   * call and in-session undo/redo, and is rolled back by `event.reject()`
+   * (issue #354). Absent when the edit-start measure carried none and
+   * [[updateGraphic]] has not set any since.
+   */
   readonly workingGraphic: ControlMeasure;
   /** Live working state. Copy on read. */
   readonly controlPoints: readonly Position[];
@@ -1443,6 +1460,23 @@ declare class TacticalDraw {
   /** Snapshot of the host's latest authoritative Graphic membership and order. */
   private lastRenderedMeasures;
   private snapGeometryFeatures;
+  /**
+   * Rendered graphics-layer groups, keyed on Graphic snapshot identity. See
+   * {@link renderGraphicGroup} for the invalidation contract; swapped for a
+   * fresh map (not cleared entry-by-entry) so stale entries are collectable.
+   */
+  private graphicGroupCache;
+  /**
+   * Last {@link PointSymbolCapability.generation} observed from `pointSymbols`,
+   * initialised from the capability at construction. Compared at the top of
+   * every {@link reconcileGraphicsStack} so a host calling `invalidate()` after
+   * changing renderer-global config (e.g. milsymbol options) drops the render
+   * cache even though the Graphic snapshots handed to `render()` are
+   * unchanged — otherwise the cache would keep serving pre-invalidation
+   * output and the capability would never be re-consulted. `undefined` when
+   * there is no capability, or the capability doesn't expose `generation`.
+   */
+  private lastSeenPointSymbolGeneration;
   /**
    * Ids of graphics currently carrying a passive selection-highlight outline
    * ({@link setHighlightedGraphics}). Declarative set-replace, no session —
@@ -1462,8 +1496,34 @@ declare class TacticalDraw {
   setSnappingOptions(options?: SnappingOptions): void;
   /** Clear transient host affordances when snapping or its interaction ends. */
   private clearSnapResult;
-  /** Render one atomic Graphic group for the engine-neutral graphics stack. */
+  /**
+   * Render one atomic Graphic group for the engine-neutral graphics stack,
+   * reusing the previous render when nothing that feeds it has changed.
+   *
+   * The cache is keyed on the Graphic snapshot's object identity: hosts hand
+   * `render()` a fresh object whenever a graphic's data changes, so a changed
+   * graphic misses by construction. (A host that mutates a Graphic in place and
+   * re-renders the same reference is outside the contract — `render()` has
+   * always been documented as taking snapshots.) Rendered output also depends
+   * on live view state and on the resolved graphics style; the style is fixed
+   * at construction, and every view change drops the whole cache. Crucially,
+   * the view cannot change during a box drag (drag-pan is disabled), so every
+   * graphic outside the selection stays a cache hit for the whole gesture and
+   * per-frame reconcile cost becomes O(selection) rather than O(document).
+   */
   private renderGraphicGroup;
+  /**
+   * Render a Graphic group from scratch and stamp it with a fresh revision,
+   * drawn from the module-scoped {@link nextGraphicGroupRevision} counter (see
+   * its doc comment for why it isn't a per-instance field).
+   */
+  private buildGraphicGroup;
+  /**
+   * Drop every cached render. Called whenever an input shared by all graphic
+   * renders changes — the live view state, or (via {@link reconcileGraphicsStack})
+   * the point-symbol capability's `generation`.
+   */
+  private invalidateGraphicGroupCache;
   /** Submit one complete grouped desired state for the host stack plus overrides. */
   private reconcileGraphicsStack;
   /** Atomically publish several live renders into their host-owned Graphic slots. */

package/dist/index.mjs

@@ -486,7 +486,8 @@ var BaseMapAdapter = class {
 		const nextGroups = groups.map((group) => ({
 			id: group.id,
 			features: [...group.features],
-			iconResources: [...group.iconResources]
+			iconResources: [...group.iconResources],
+			revision: group.revision
 		}));
 		const nextFeatures = nextGroups.flatMap((group) => group.features);
 		const nextResourcesById = /* @__PURE__ */ new Map();
@@ -2923,6 +2924,200 @@ function beginBoxDrag(args) {
 	};
 }
 //#endregion
+//#region src/tactical-draw/deep-equal.ts
+/**
+* @internal
+*
+* Structural equality for structured-cloneable values. Not exported from
+* `src/index.ts` — this is a private helper for comparing session-owned host
+* data (e.g. `ControlMeasure.properties`, `PointSymbol`) where `JSON.stringify`
+* is unsafe: it throws on `bigint` and cyclic graphs, and it silently
+* collapses values it cannot represent (`{x: undefined}` and `{}` both
+* stringify to `"{}"`; a `Map` stringifies to `"{}"` regardless of contents;
+* distinct `Date`s can coerce to the same string). See issue #354 review
+* follow-up.
+*
+* Design notes / deliberate limitations:
+*  - Uses `Object.is` as the base-case comparator, so `NaN` equals `NaN` but
+*    `0` and `-0` are treated as different values. This mirrors the semantics
+*    most callers actually want for "did this change" checks (a NaN-valued
+*    field shouldn't perpetually look dirty), and is cheap/well-defined; it
+*    is a deliberate choice, not an oversight.
+*  - Object comparison is key-set sensitive: `{}` and `{ x: undefined }` are
+*    NOT equal, because they have different keys, even though the values at
+*    key `x` compare loosely-equal-ish. This is required for `updateGraphic`
+*    dedupe correctness — a caller that explicitly adds an `undefined`-valued
+*    key is making a distinguishable structural edit.
+*  - Only "own enumerable string keys" are compared for plain objects
+*    (`Object.keys`), matching what `structuredClone` round-trips and what
+*    hosts can observe with normal iteration. Symbol-keyed properties are not
+*    considered (functions and symbols aren't structured-cloneable anyway).
+*  - `Set` members and `Map` keys/values are matched with a proper one-to-one
+*    (bipartite) matching, not a greedy or order-dependent search: primitive
+*    members/keys take an O(1) `has`/`get` fast path, and any remaining
+*    non-primitive members are matched with an augmenting-path search over
+*    the candidate deep-equal pairs (Kuhn's algorithm), which is O(n*m) in
+*    the number of non-primitive members/keys but correct in adversarial
+*    cases with multiple structurally-equal-but-distinct candidates.
+*  - Functions compare by reference (the `Object.is` fast path) and are
+*    otherwise unequal — `structuredClone` rejects functions outright, so any
+*    function-valued field here has already failed to round-trip through the
+*    session's clone boundary.
+*  - Cycle-safe: a stack of visited pairs is tracked so a self-referential
+*    graph terminates (returns a comparison result) instead of overflowing.
+*    The pair association is a bijection — an object already paired with a
+*    *different* counterpart along this comparison path is rejected, not
+*    just re-accepted because the exact pair recurred.
+*  - `Error` (and subclasses, including `AggregateError`) are special-cased:
+*    `name`, `message`, and `cause` are compared (`cause` is key-set
+*    sensitive too — an absent `cause` differs from `cause: undefined`),
+*    `AggregateError.errors` is compared as an array, plus any own
+*    enumerable properties as usual. `stack` is deliberately IGNORED: it's
+*    environment-dependent noise (file/line info), and two structurally
+*    identical errors constructed at different call sites shouldn't read as
+*    a host edit.
+*/
+function tag(value) {
+	return Object.prototype.toString.call(value);
+}
+function isTypedArrayOrDataView(value) {
+	return ArrayBuffer.isView(value);
+}
+function bytesOf(value) {
+	return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+}
+function bytesEqual(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+function isPrimitive(value) {
+	return typeof value !== "object" || value === null;
+}
+/**
+* Does a perfect one-to-one matching exist between the `leftCount` left-side
+* indices and `rightCount` right-side indices, given `canMatch(i, j)`?
+* Kuhn's augmenting-path algorithm — O(leftCount * rightCount * edges), fine
+* for the small collections (`Set`/`Map` members in a host properties bag)
+* this is used for.
+*/
+function hasPerfectMatching(leftCount, rightCount, canMatch) {
+	if (leftCount !== rightCount) return false;
+	const matchOfRight = new Array(rightCount).fill(-1);
+	function tryAugment(i, visited) {
+		for (let j = 0; j < rightCount; j++) {
+			if (visited[j] || !canMatch(i, j)) continue;
+			visited[j] = true;
+			if (matchOfRight[j] === -1 || tryAugment(matchOfRight[j], visited)) {
+				matchOfRight[j] = i;
+				return true;
+			}
+		}
+		return false;
+	}
+	for (let i = 0; i < leftCount; i++) if (!tryAugment(i, new Array(rightCount).fill(false))) return false;
+	return true;
+}
+/**
+* Deep structural equality for structured-cloneable values (plus `bigint`,
+* `symbol`, and functions, which compare by identity). See the module
+* doc-comment above for the exact rules and deliberate limitations.
+*/
+function deepEqual(a, b) {
+	return deepEqualInner(a, b, []);
+}
+function deepEqualInner(a, b, visited) {
+	if (Object.is(a, b)) return true;
+	if (typeof a !== typeof b) return false;
+	if (a === null || b === null) return false;
+	if (typeof a !== "object") return false;
+	const objA = a;
+	const objB = b;
+	if (Object.getPrototypeOf(objA) !== Object.getPrototypeOf(objB)) return false;
+	if (tag(objA) !== tag(objB)) return false;
+	for (const [seenA, seenB] of visited) {
+		if (seenA === objA && seenB === objB) return true;
+		if (seenA === objA || seenB === objB) return false;
+	}
+	visited.push([objA, objB]);
+	try {
+		if (objA instanceof Date && objB instanceof Date) return Object.is(objA.getTime(), objB.getTime());
+		if (objA instanceof RegExp && objB instanceof RegExp) return objA.source === objB.source && objA.flags === objB.flags;
+		if (objA instanceof Error && objB instanceof Error) {
+			if (objA.name !== objB.name) return false;
+			if (objA.message !== objB.message) return false;
+			const hasCauseA = Object.prototype.hasOwnProperty.call(objA, "cause");
+			if (hasCauseA !== Object.prototype.hasOwnProperty.call(objB, "cause")) return false;
+			if (hasCauseA && !deepEqualInner(objA.cause, objB.cause, visited)) return false;
+			if (objA instanceof AggregateError) {
+				if (!deepEqualInner(objA.errors, objB.errors, visited)) return false;
+			}
+			const keysA = Object.keys(objA);
+			const keysB = Object.keys(objB);
+			if (keysA.length !== keysB.length) return false;
+			for (const key of keysA) if (!Object.prototype.hasOwnProperty.call(objB, key)) return false;
+			for (const key of keysA) {
+				const valueA = objA[key];
+				const valueB = objB[key];
+				if (!deepEqualInner(valueA, valueB, visited)) return false;
+			}
+			return true;
+		}
+		if (isTypedArrayOrDataView(objA) && isTypedArrayOrDataView(objB)) return bytesEqual(bytesOf(objA), bytesOf(objB));
+		if (objA instanceof ArrayBuffer && objB instanceof ArrayBuffer) return bytesEqual(new Uint8Array(objA), new Uint8Array(objB));
+		if (objA instanceof Set && objB instanceof Set) {
+			if (objA.size !== objB.size) return false;
+			const remainingA = [];
+			const remainingB = new Set(objB);
+			for (const itemA of objA) {
+				if (isPrimitive(itemA) && remainingB.has(itemA)) {
+					remainingB.delete(itemA);
+					continue;
+				}
+				remainingA.push(itemA);
+			}
+			const remainingBArr = [...remainingB];
+			return hasPerfectMatching(remainingA.length, remainingBArr.length, (i, j) => deepEqualInner(remainingA[i], remainingBArr[j], visited));
+		}
+		if (objA instanceof Map && objB instanceof Map) {
+			if (objA.size !== objB.size) return false;
+			const remainingA = [];
+			const remainingB = new Map(objB);
+			for (const [keyA, valueA] of objA) {
+				if (isPrimitive(keyA) && remainingB.has(keyA)) {
+					if (!deepEqualInner(valueA, remainingB.get(keyA), visited)) return false;
+					remainingB.delete(keyA);
+					continue;
+				}
+				remainingA.push([keyA, valueA]);
+			}
+			const remainingBArr = [...remainingB];
+			return hasPerfectMatching(remainingA.length, remainingBArr.length, (i, j) => {
+				const [keyA, valueA] = remainingA[i];
+				const [keyB, valueB] = remainingBArr[j];
+				return deepEqualInner(keyA, keyB, visited) && deepEqualInner(valueA, valueB, visited);
+			});
+		}
+		if (Array.isArray(objA) && Array.isArray(objB)) {
+			if (objA.length !== objB.length) return false;
+			for (let i = 0; i < objA.length; i++) if (!deepEqualInner(objA[i], objB[i], visited)) return false;
+			return true;
+		}
+		const keysA = Object.keys(objA);
+		const keysB = Object.keys(objB);
+		if (keysA.length !== keysB.length) return false;
+		for (const key of keysA) if (!Object.prototype.hasOwnProperty.call(objB, key)) return false;
+		for (const key of keysA) {
+			const valueA = objA[key];
+			const valueB = objB[key];
+			if (!deepEqualInner(valueA, valueB, visited)) return false;
+		}
+		return true;
+	} finally {
+		visited.pop();
+	}
+}
+//#endregion
 //#region src/tactical-draw/session-history.ts
 /** @internal Controller-owned history stack. */
 function createSessionHistory(options) {
@@ -3611,9 +3806,28 @@ function runEdit(opts) {
 	let workingOptions = { ...measure.options ?? {} };
 	let workingTextAmplifiers = measure.textAmplifiers && Object.keys(measure.textAmplifiers).length > 0 ? { ...measure.textAmplifiers } : void 0;
 	let workingAmplifierPlacements = measure.amplifierPlacements && Object.keys(measure.amplifierPlacements).length > 0 ? structuredClone(measure.amplifierPlacements) : void 0;
+	let workingProperties = measure.properties ? structuredClone(measure.properties) : void 0;
 	function snapshotAmplifierPlacements() {
 		return workingAmplifierPlacements ? structuredClone(workingAmplifierPlacements) : void 0;
 	}
+	function snapshotProperties() {
+		return workingProperties ? structuredClone(workingProperties) : void 0;
+	}
+	/**
+	* Dedupe comparison for the library's own typed session data — `options`,
+	* `style`, `textAmplifiers`, `amplifierPlacements`. Those are declared as
+	* JSON-representable values, so serialising them is safe and cheaper than a
+	* structural walk.
+	*
+	* Deliberately NOT for anything that can carry `properties`: that bag is
+	* `Record<string, unknown>` cloned with `structuredClone`, so a host may put
+	* a bigint or a cyclic graph in it (throws here) or a `Map`/`undefined`-valued
+	* key in it (silently collapses to the same string). Those comparisons use
+	* `deepEqual` — see `./deep-equal` and issue #354.
+	*/
+	function jsonEqual(a, b) {
+		return JSON.stringify(a) === JSON.stringify(b);
+	}
 	let modes = requestedModes;
 	let dirty = false;
 	let nonGeometryDirty = false;
@@ -3684,6 +3898,7 @@ function runEdit(opts) {
 			style: currentStyle ? { ...currentStyle } : void 0,
 			textAmplifiers: workingTextAmplifiers ? { ...workingTextAmplifiers } : void 0,
 			amplifierPlacements: snapshotAmplifierPlacements(),
+			properties: snapshotProperties(),
 			sizeAnchor,
 			nonGeometryDirty,
 			boxAngle
@@ -3695,6 +3910,7 @@ function runEdit(opts) {
 		currentStyle = value.style ? { ...value.style } : void 0;
 		workingTextAmplifiers = value.textAmplifiers ? { ...value.textAmplifiers } : void 0;
 		workingAmplifierPlacements = value.amplifierPlacements ? structuredClone(value.amplifierPlacements) : void 0;
+		workingProperties = value.properties ? structuredClone(value.properties) : void 0;
 		sizeAnchor = value.sizeAnchor;
 		nonGeometryDirty = value.nonGeometryDirty;
 		boxAngle = value.boxAngle;
@@ -3781,6 +3997,8 @@ function runEdit(opts) {
 		else delete working.textAmplifiers;
 		if (workingAmplifierPlacements) working.amplifierPlacements = workingAmplifierPlacements;
 		else delete working.amplifierPlacements;
+		if (workingProperties) working.properties = workingProperties;
+		else delete working.properties;
 		let features;
 		try {
 			features = renderMeasureForAdapter(adapter, working, renderOpts).features;
@@ -3858,6 +4076,8 @@ function runEdit(opts) {
 		else delete working.textAmplifiers;
 		if (workingAmplifierPlacements) working.amplifierPlacements = workingAmplifierPlacements;
 		else delete working.amplifierPlacements;
+		if (workingProperties) working.properties = workingProperties;
+		else delete working.properties;
 		const committed = sizeAnchor === "screen" ? working : bakePixelSizeToGround(working, adapter);
 		return {
 			graphic: cloneControlMeasure(committed),
@@ -3903,7 +4123,7 @@ function runEdit(opts) {
 	* the history record. The deferred reject/close/abort machinery, exception
 	* collection, and record-before-rethrow ordering live in the emitter.
 	*/
-	function emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, previousSizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, source = "gesture", historyLabel = "Edit", previousBoxAngle = boxAngle) {
+	function emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, previousSizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, previousProperties, source = "gesture", historyLabel = "Edit", previousBoxAngle = boxAngle) {
 		changeEmitter.emit({
 			source,
 			graphic: currentRendered,
@@ -3917,6 +4137,7 @@ function runEdit(opts) {
 				sizeAnchor = previousSizeAnchor;
 				workingTextAmplifiers = previousTextAmplifiers;
 				workingAmplifierPlacements = previousAmplifierPlacements;
+				workingProperties = previousProperties;
 				boxAngle = previousBoxAngle;
 				nonGeometryDirty = previousNonGeometryDirty;
 				renderWorkingGraphic();
@@ -3944,6 +4165,7 @@ function runEdit(opts) {
 		const previousNonGeometryDirty = nonGeometryDirty;
 		const previousTextAmplifiers = workingTextAmplifiers;
 		const previousAmplifierPlacements = snapshotAmplifierPlacements();
+		const previousProperties = snapshotProperties();
 		const previousRendered = rebuildRenderedWith(previousOptions);
 		replaceWorkingPoints(nextPoints);
 		if (nextAmplifierPlacements !== void 0) workingAmplifierPlacements = structuredClone(nextAmplifierPlacements);
@@ -3963,7 +4185,7 @@ function runEdit(opts) {
 		recomputeDirty();
 		dragInFlight = false;
 		drainPendingModes();
-		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, sizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, "gesture", "Edit", preGestureBoxAngle);
+		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, sizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, previousProperties, "gesture", "Edit", preGestureBoxAngle);
 	}
 	function setOptions(partial) {
 		if (ctx.settled) return;
@@ -3973,12 +4195,13 @@ function runEdit(opts) {
 		const previousNonGeometryDirty = nonGeometryDirty;
 		const previousTextAmplifiers = workingTextAmplifiers;
 		const previousAmplifierPlacements = snapshotAmplifierPlacements();
+		const previousProperties = snapshotProperties();
 		const previousRendered = rebuildRendered();
 		replaceWorkingOptions({
 			...workingOptions ?? {},
 			...partial ?? {}
 		});
-		if (JSON.stringify(workingOptions) === JSON.stringify(previousOptions)) return;
+		if (jsonEqual(workingOptions, previousOptions)) return;
 		let currentRendered;
 		try {
 			currentRendered = rebuildRendered();
@@ -3989,7 +4212,7 @@ function runEdit(opts) {
 		renderWorkingGraphicAndHandles();
 		nonGeometryDirty = true;
 		dirty = true;
-		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, sizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, "programmatic", "Change options");
+		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, sizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, previousProperties, "programmatic", "Change options");
 	}
 	function setStyle(partial) {
 		if (ctx.settled) return;
@@ -3999,12 +4222,13 @@ function runEdit(opts) {
 		const previousNonGeometryDirty = nonGeometryDirty;
 		const previousTextAmplifiers = workingTextAmplifiers;
 		const previousAmplifierPlacements = snapshotAmplifierPlacements();
+		const previousProperties = snapshotProperties();
 		const previousRendered = rebuildRendered();
 		currentStyle = {
 			...currentStyle ?? {},
 			...partial
 		};
-		if (JSON.stringify(currentStyle) === JSON.stringify(previousStyle)) return;
+		if (jsonEqual(currentStyle, previousStyle)) return;
 		let currentRendered;
 		try {
 			currentRendered = rebuildRendered();
@@ -4015,7 +4239,7 @@ function runEdit(opts) {
 		renderWorkingGraphicAndHandles();
 		nonGeometryDirty = true;
 		dirty = true;
-		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, sizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, "programmatic", "Change style");
+		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, sizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, previousProperties, "programmatic", "Change style");
 	}
 	/**
 	* Shallow-merge into the live working text amplifiers. Mirrors
@@ -4040,6 +4264,7 @@ function runEdit(opts) {
 		const previousNonGeometryDirty = nonGeometryDirty;
 		const previousTextAmplifiers = workingTextAmplifiers;
 		const previousAmplifierPlacements = snapshotAmplifierPlacements();
+		const previousProperties = snapshotProperties();
 		const previousRendered = rebuildRendered();
 		const merged = { ...workingTextAmplifiers ?? {} };
 		for (const [key, value] of Object.entries(partial)) {
@@ -4050,7 +4275,7 @@ function runEdit(opts) {
 			if (value !== void 0 && value.trim() !== "") merged[canonicalKey ?? key] = value;
 		}
 		workingTextAmplifiers = Object.keys(merged).length > 0 ? merged : void 0;
-		if (JSON.stringify(workingTextAmplifiers) === JSON.stringify(previousTextAmplifiers)) return;
+		if (jsonEqual(workingTextAmplifiers, previousTextAmplifiers)) return;
 		let currentRendered;
 		try {
 			currentRendered = rebuildRendered();
@@ -4061,7 +4286,7 @@ function runEdit(opts) {
 		renderWorkingGraphicAndHandles();
 		nonGeometryDirty = true;
 		dirty = true;
-		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, sizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, "programmatic", "Change text");
+		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, sizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, previousProperties, "programmatic", "Change text");
 	}
 	function setAmplifierPlacements(partial, source = "programmatic", historyLabel = "Move label") {
 		if (ctx.settled) return;
@@ -4071,6 +4296,7 @@ function runEdit(opts) {
 		const previousNonGeometryDirty = nonGeometryDirty;
 		const previousTextAmplifiers = workingTextAmplifiers;
 		const previousAmplifierPlacements = snapshotAmplifierPlacements();
+		const previousProperties = snapshotProperties();
 		const previousRendered = rebuildRendered();
 		const next = { ...workingAmplifierPlacements ?? {} };
 		for (const [field, value] of Object.entries(partial)) {
@@ -4083,12 +4309,12 @@ function runEdit(opts) {
 			else next[field] = merged;
 		}
 		workingAmplifierPlacements = Object.keys(next).length > 0 ? next : void 0;
-		if (JSON.stringify(workingAmplifierPlacements) === JSON.stringify(previousAmplifierPlacements)) return;
+		if (jsonEqual(workingAmplifierPlacements, previousAmplifierPlacements)) return;
 		const currentRendered = rebuildRendered();
 		renderWorkingGraphicAndHandles();
 		nonGeometryDirty = true;
 		dirty = true;
-		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, sizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, source, historyLabel);
+		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, sizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, previousProperties, source, historyLabel);
 	}
 	/**
 	* Flip the size anchor for the measure under edit (ADR-0020). Re-renders the
@@ -4106,12 +4332,13 @@ function runEdit(opts) {
 		const previousSizeAnchor = sizeAnchor;
 		const previousTextAmplifiers = workingTextAmplifiers;
 		const previousAmplifierPlacements = snapshotAmplifierPlacements();
+		const previousProperties = snapshotProperties();
 		const previousRendered = rebuildRendered();
 		sizeAnchor = next;
 		const currentRendered = rebuildRendered();
 		nonGeometryDirty = true;
 		dirty = true;
-		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, previousSizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, "programmatic", "Change size anchor");
+		emitChange(previousRendered, previousPoints, previousOptions, previousStyle, previousNonGeometryDirty, previousSizeAnchor, currentRendered, previousTextAmplifiers, previousAmplifierPlacements, previousProperties, "programmatic", "Change size anchor");
 	}
 	function modesEqual(a, b) {
 		if (a.length !== b.length) return false;
@@ -4138,34 +4365,38 @@ function runEdit(opts) {
 			style: value.style ? { ...value.style } : void 0,
 			textAmplifiers: value.textAmplifiers ? { ...value.textAmplifiers } : void 0,
 			amplifierPlacements: value.amplifierPlacements ? structuredClone(value.amplifierPlacements) : void 0,
+			properties: value.properties ? structuredClone(value.properties) : void 0,
 			sizeAnchor: value.sizeAnchor,
 			nonGeometryDirty: value.nonGeometryDirty,
 			boxAngle: value.boxAngle
 		}),
-		equals: (a, b) => JSON.stringify(a) === JSON.stringify(b),
-		isCurrent: (value) => JSON.stringify(captureHistory()) === JSON.stringify(value),
+		equals: (a, b) => deepEqual(a, b),
+		isCurrent: (value) => deepEqual(captureHistory(), value),
 		apply(from, to, source) {
 			const previousRendered = rebuildRendered();
 			restoreHistory(to);
 			renderWorkingGraphic();
 			renderHandlesLayer();
 			recomputeDirty();
-			emitChange(previousRendered, from.points, from.options, from.style, from.nonGeometryDirty, from.sizeAnchor, rebuildRendered(), from.textAmplifiers, from.amplifierPlacements, source, "Edit", from.boxAngle);
-			return !ctx.settled && JSON.stringify(captureHistory()) === JSON.stringify(to);
+			emitChange(previousRendered, from.points, from.options, from.style, from.nonGeometryDirty, from.sizeAnchor, rebuildRendered(), from.textAmplifiers, from.amplifierPlacements, from.properties, source, "Edit", from.boxAngle);
+			return !ctx.settled && deepEqual(captureHistory(), to);
 		}
 	});
 	const session = {
 		history,
 		graphic: measure,
 		get workingGraphic() {
-			return cloneControlMeasure({
+			const working = {
 				...measure,
 				controlPoints: workingPoints.map((point) => [...point]),
 				options: { ...workingOptions ?? {} },
 				style: currentStyle ? { ...currentStyle } : void 0,
 				textAmplifiers: workingTextAmplifiers ? { ...workingTextAmplifiers } : void 0,
 				amplifierPlacements: snapshotAmplifierPlacements()
-			});
+			};
+			if (workingProperties) working.properties = workingProperties;
+			else delete working.properties;
+			return cloneControlMeasure(working);
 		},
 		get controlPoints() {
 			return workingPoints.map((p) => [...p]);
@@ -4212,21 +4443,23 @@ function runEdit(opts) {
 			const previous = rebuildRendered();
 			const previousNonGeometryDirty = nonGeometryDirty;
 			const previousSizeAnchor = sizeAnchor;
+			const previousProperties = snapshotProperties();
 			const current = session.workingGraphic;
 			const next = updater(current);
 			if (next.id !== measure.id || next.kind !== measure.kind) throw new TypeError("updateGraphic must preserve control-measure id and kind");
-			if (JSON.stringify(next) === JSON.stringify(current)) return;
+			if (deepEqual(next, current)) return;
 			renderMeasureForAdapter(adapter, next, renderOpts);
 			workingPoints.splice(0, workingPoints.length, ...next.controlPoints.map((point) => [...point]));
 			workingOptions = { ...next.options ?? {} };
 			currentStyle = next.style ? { ...next.style } : void 0;
 			workingTextAmplifiers = next.textAmplifiers ? { ...next.textAmplifiers } : void 0;
 			workingAmplifierPlacements = next.amplifierPlacements ? structuredClone(next.amplifierPlacements) : void 0;
+			workingProperties = next.properties ? structuredClone(next.properties) : void 0;
 			nonGeometryDirty = true;
 			renderWorkingGraphic();
 			renderHandlesLayer();
 			recomputeDirty();
-			emitChange(previous, previous.graphic.controlPoints.map((point) => [...point]), previous.graphic.options, previous.graphic.style, previousNonGeometryDirty, previousSizeAnchor, rebuildRendered(), previous.graphic.textAmplifiers, previous.graphic.amplifierPlacements, "programmatic", "Update graphic");
+			emitChange(previous, previous.graphic.controlPoints.map((point) => [...point]), previous.graphic.options, previous.graphic.style, previousNonGeometryDirty, previousSizeAnchor, rebuildRendered(), previous.graphic.textAmplifiers, previous.graphic.amplifierPlacements, previousProperties, "programmatic", "Update graphic");
 		},
 		setOptions(partial) {
 			setOptions(partial);
@@ -4768,6 +5001,42 @@ function boundProperty(key, value) {
 	return value !== void 0 && Number.isFinite(value) && value > 0 ? { [key]: value } : {};
 }
 //#endregion
+//#region src/tactical-draw/frame-coalescer.ts
+/**
+* @param run Callback invoked with the latest scheduled args, at most once per frame.
+*/
+function createFrameCoalescer(run) {
+	const raf = globalThis.requestAnimationFrame?.bind(globalThis);
+	const cancelRaf = globalThis.cancelAnimationFrame?.bind(globalThis);
+	if (!raf || !cancelRaf) return {
+		schedule(...args) {
+			run(...args);
+		},
+		cancel() {}
+	};
+	let handle = null;
+	let latestArgs = null;
+	return {
+		schedule(...args) {
+			latestArgs = args;
+			if (handle !== null) return;
+			handle = raf(() => {
+				handle = null;
+				const pending = latestArgs;
+				latestArgs = null;
+				if (pending) run(...pending);
+			});
+		},
+		cancel() {
+			if (handle !== null) {
+				cancelRaf(handle);
+				handle = null;
+			}
+			latestArgs = null;
+		}
+	};
+}
+//#endregion
 //#region src/tactical-draw/transform-controller.ts
 /** No point symbol may scale below this factor of its own size — mirrors the box-drag floor. */
 const MIN_POINT_SYMBOL_SIZE = .1;
@@ -5479,12 +5748,14 @@ function runGroupTransform(opts) {
 		renderHandlesLayer();
 		recomputeDirty();
 	}
+	const boxDragPaintCoalescer = createFrameCoalescer(paintBoxDragSnapshot);
 	const onDriverMove = (pixel, info) => {
 		if (ctx.settled) return;
-		if (activeBoxDrag) paintBoxDragSnapshot(pixel, info?.shiftKey);
+		if (activeBoxDrag) boxDragPaintCoalescer.schedule(pixel, info?.shiftKey);
 	};
 	const onDriverUp = (pixel, info) => {
 		if (!activeBoxDrag) return;
+		boxDragPaintCoalescer.cancel();
 		if (ctx.settled) {
 			activeBoxDrag = null;
 			dragInFlight = false;
@@ -5545,6 +5816,7 @@ function runGroupTransform(opts) {
 			if (settlement.status === "rejected") settleEmitter.emit(settleReasonFromError(settlement.error));
 		},
 		extraTeardown: () => {
+			boxDragPaintCoalescer.cancel();
 			if (activeBoxDrag !== null) {
 				driver.setDragPanEnabled(true);
 				activeBoxDrag = null;
@@ -5716,7 +5988,7 @@ function runPointSymbolEdit(opts) {
 		}, {
 			rollback() {
 				working = clonePointSymbol(previousState.working);
-				dirty = JSON.stringify(working) !== JSON.stringify(symbol);
+				dirty = !deepEqual(working, symbol);
 				render();
 			},
 			onAccepted
@@ -5725,11 +5997,11 @@ function runPointSymbolEdit(opts) {
 	const history = createSessionHistory({
 		initial: captureHistory(),
 		clone: cloneHistory,
-		equals: (a, b) => JSON.stringify(a.working) === JSON.stringify(b.working),
-		isCurrent: (value) => JSON.stringify(working) === JSON.stringify(value.working),
+		equals: (a, b) => deepEqual(a.working, b.working),
+		isCurrent: (value) => deepEqual(working, value.working),
 		apply(from, to, source) {
 			working = clonePointSymbol(to.working);
-			dirty = JSON.stringify(working) !== JSON.stringify(symbol);
+			dirty = !deepEqual(working, symbol);
 			render();
 			return emitChange(from, source);
 		}
@@ -5737,7 +6009,7 @@ function runPointSymbolEdit(opts) {
 	const apply = (next, source = "programmatic", label = "Update graphic") => {
 		const previousState = captureHistory();
 		working = clonePointSymbol(next);
-		dirty = JSON.stringify(working) !== JSON.stringify(symbol);
+		dirty = !deepEqual(working, symbol);
 		render();
 		emitChange(previousState, source, () => history.record(captureHistory(), label));
 	};
@@ -5930,6 +6202,17 @@ var GraphicStackCoordinator = class {
 //#endregion
 //#region src/tactical-draw/tactical-draw.ts
 /**
+* Source of {@link FeatureGroup.revision} stamps. Module-scoped rather than a
+* per-instance counter: adapters keep per-group bundles on host-supplied layer
+* handles, and `destroy()` intentionally leaves those layers untouched so a
+* host can attach a fresh façade to the same adapter/layer for reuse. An
+* instance counter would restart at 1 on the new façade, so a bundle the
+* previous façade stored at revision 1 — with different content — would
+* compare equal and the adapter would wrongly skip the repaint. A counter
+* shared across every façade in the JS realm guarantees revisions never repeat.
+*/
+let nextGraphicGroupRevision = 0;
+/**
 * `TacticalDraw` façade — slice #6 (issue #45).
 *
 * Provides the constructor + lifecycle + `render(measures)` reconcile path.
@@ -5998,6 +6281,23 @@ var TacticalDraw = class {
 	lastRenderedMeasures = [];
 	snapGeometryFeatures = [];
 	/**
+	* Rendered graphics-layer groups, keyed on Graphic snapshot identity. See
+	* {@link renderGraphicGroup} for the invalidation contract; swapped for a
+	* fresh map (not cleared entry-by-entry) so stale entries are collectable.
+	*/
+	graphicGroupCache = /* @__PURE__ */ new WeakMap();
+	/**
+	* Last {@link PointSymbolCapability.generation} observed from `pointSymbols`,
+	* initialised from the capability at construction. Compared at the top of
+	* every {@link reconcileGraphicsStack} so a host calling `invalidate()` after
+	* changing renderer-global config (e.g. milsymbol options) drops the render
+	* cache even though the Graphic snapshots handed to `render()` are
+	* unchanged — otherwise the cache would keep serving pre-invalidation
+	* output and the capability would never be re-consulted. `undefined` when
+	* there is no capability, or the capability doesn't expose `generation`.
+	*/
+	lastSeenPointSymbolGeneration;
+	/**
 	* Ids of graphics currently carrying a passive selection-highlight outline
 	* ({@link setHighlightedGraphics}). Declarative set-replace, no session —
 	* re-projected on every view change and re-evaluated at the end of every
@@ -6017,6 +6317,7 @@ var TacticalDraw = class {
 		this.defaultInteractionStyle = options?.interactionStyle;
 		this.generateId = options?.generateId ?? (() => `td-${++this.idCounter}`);
 		this.pointSymbols = options?.pointSymbols;
+		this.lastSeenPointSymbolGeneration = this.pointSymbols?.generation;
 		this.snappingOptions = options?.snapping;
 		this.resolveSnap = createSnapResolver(adapter, () => this.lastRenderedMeasures, () => this.snapGeometryFeatures, () => this.snappingOptions);
 		const owned = /* @__PURE__ */ new Set();
@@ -6044,27 +6345,68 @@ var TacticalDraw = class {
 	clearSnapResult() {
 		this.snappingOptions?.onSnap?.(null);
 	}
-	/** Render one atomic Graphic group for the engine-neutral graphics stack. */
+	/**
+	* Render one atomic Graphic group for the engine-neutral graphics stack,
+	* reusing the previous render when nothing that feeds it has changed.
+	*
+	* The cache is keyed on the Graphic snapshot's object identity: hosts hand
+	* `render()` a fresh object whenever a graphic's data changes, so a changed
+	* graphic misses by construction. (A host that mutates a Graphic in place and
+	* re-renders the same reference is outside the contract — `render()` has
+	* always been documented as taking snapshots.) Rendered output also depends
+	* on live view state and on the resolved graphics style; the style is fixed
+	* at construction, and every view change drops the whole cache. Crucially,
+	* the view cannot change during a box drag (drag-pan is disabled), so every
+	* graphic outside the selection stays a cache hit for the whole gesture and
+	* per-frame reconcile cost becomes O(selection) rather than O(document).
+	*/
 	renderGraphicGroup(graphic) {
-		const renderOpts = { graphicsStyle: this.graphicsStyle };
+		const cached = this.graphicGroupCache.get(graphic);
+		if (cached) return cached;
+		const group = this.buildGraphicGroup(graphic);
+		this.graphicGroupCache.set(graphic, group);
+		return group;
+	}
+	/**
+	* Render a Graphic group from scratch and stamp it with a fresh revision,
+	* drawn from the module-scoped {@link nextGraphicGroupRevision} counter (see
+	* its doc comment for why it isn't a per-instance field).
+	*/
+	buildGraphicGroup(graphic) {
+		const revision = ++nextGraphicGroupRevision;
 		if (isPointSymbol(graphic)) {
 			if (!this.pointSymbols) throw new PointSymbolCapabilityRequiredError();
 			const plan = renderPointSymbolForAdapter(this.adapter, this.pointSymbols, graphic);
 			return {
 				id: graphic.id,
 				features: [plan.feature],
-				iconResources: [plan.resource]
+				iconResources: [plan.resource],
+				revision
 			};
 		}
-		const render = renderMeasureForAdapter(this.adapter, graphic, renderOpts);
+		const render = renderMeasureForAdapter(this.adapter, graphic, { graphicsStyle: this.graphicsStyle });
 		return {
 			id: graphic.id,
 			features: render.features,
-			iconResources: []
+			iconResources: [],
+			revision
 		};
 	}
+	/**
+	* Drop every cached render. Called whenever an input shared by all graphic
+	* renders changes — the live view state, or (via {@link reconcileGraphicsStack})
+	* the point-symbol capability's `generation`.
+	*/
+	invalidateGraphicGroupCache() {
+		this.graphicGroupCache = /* @__PURE__ */ new WeakMap();
+	}
 	/** Submit one complete grouped desired state for the host stack plus overrides. */
 	reconcileGraphicsStack(graphics = this.lastRenderedMeasures) {
+		const currentGeneration = this.pointSymbols?.generation;
+		if (currentGeneration !== this.lastSeenPointSymbolGeneration) {
+			this.invalidateGraphicGroupCache();
+			this.lastSeenPointSymbolGeneration = currentGeneration;
+		}
 		const groups = this.graphicStack.desiredGroups(graphics, (graphic) => this.renderGraphicGroup(graphic));
 		this.adapter.setLayerFeatureGroups(this.graphicsLayer, groups);
 		this.snapGeometryFeatures = groups.flatMap((group) => group.features);
@@ -6093,6 +6435,7 @@ var TacticalDraw = class {
 	*/
 	handleViewChange = () => {
 		if (this.destroyed || !this.hasRendered) return;
+		this.invalidateGraphicGroupCache();
 		this.renderHighlights();
 		const excluded = this.graphicsStackExcludedIds();
 		const visible = excluded.size > 0 ? this.lastRenderedMeasures.filter((m) => !excluded.has(m.id)) : this.lastRenderedMeasures;
@@ -7055,15 +7398,25 @@ function resolveSlot(adapter, supplied, owned) {
 * expressions without re-spelling the pattern vocabulary.
 */
 const HATCH_PATTERNS = [
-	"hachure",
-	"backhachure",
-	"cross"
+	"hatch",
+	"reverse-hatch",
+	"cross-hatch",
+	"horizontal",
+	"vertical",
+	"dots"
 ];
 /** Tile edge length, CSS px, before `pixelRatio` scaling. Kept a power of two. */
 const BASE_TILE_SIZE = 32;
 /** Line spacing as a fraction of the tile edge — 4 repeats per tile. */
 const SPACING_DIVISOR = 4;
 /**
+* Dot radius, CSS px, before `pixelRatio` scaling — the `"dots"` counterpart to
+* the 1px line width, sized so a dot reads at the same weight as a hatch line.
+* Must stay in lockstep with the vector tiles in the Leaflet adapter and the
+* static previews.
+*/
+const DOT_RADIUS = 1.25;
+/**
 * Stable id for a rasterized tile, keyed by pattern and color. Adapters use
 * this as the image-registry key (MapLibre `addImage` id, OpenLayers pattern
 * cache key) so the same color+pattern never gets rasterized twice. Color is
@@ -7143,8 +7496,8 @@ const SQRT2 = Math.SQRT2;
 /**
 * Coverage in `[0, 1]` of one diagonal line family (slope +1 or -1, both
 * period `spacing`) at pixel center `(x, y)`, antialiased over a ~1 device-px
-* band. `axis` selects `y - x` (the "/" hachure) or `y + x` (the "\" mirror,
-* "backhachure", which "cross" unions on top of the hachure). Because `spacing`
+* band. `axis` selects `y - x` (the "/" hatch) or `y + x` (the "\" mirror,
+* "reverse-hatch", which "cross-hatch" unions on top of the hatch). Because `spacing`
 * divides the tile dimension evenly, shifting
 * `x` or `y` by a whole tile is a whole number of `spacing` periods, so the
 * mod-distance — and therefore the coverage — is identical at the tile edges
@@ -7152,30 +7505,61 @@ const SQRT2 = Math.SQRT2;
 * seamless.
 */
 function lineCoverage(x, y, spacing, lineWidth, axis) {
-	const t = axis === "/" ? y - x : y + x;
-	const perpDist = Math.abs(centeredMod(t, spacing)) / SQRT2;
+	const t = axis === "/" ? y - x : axis === "\\" ? y + x : (axis === "-" ? y : x) - spacing / 2;
+	const raw = Math.abs(centeredMod(t, spacing));
+	const perpDist = axis === "/" || axis === "\\" ? raw / SQRT2 : raw;
 	const halfWidth = lineWidth / 2;
 	return Math.min(1, Math.max(0, halfWidth + .5 - perpDist));
 }
 /**
+* Coverage in `[0, 1]` of a square lattice of dots — one per `spacing × spacing`
+* cell, centered in the cell so the tile stays seamless — antialiased over the
+* same ~1px band as {@link lineCoverage}.
+*/
+function dotCoverage(x, y, spacing, radius) {
+	const dx = centeredMod(x - spacing / 2, spacing);
+	const dy = centeredMod(y - spacing / 2, spacing);
+	return Math.min(1, Math.max(0, radius + .5 - Math.hypot(dx, dy)));
+}
+/**
 * Rasterize one seamless hatch tile as a straight RGBA pixel buffer — no
 * canvas involved, so this runs identically in a browser adapter and in
 * jsdom/node tests. Diagonal lines are snapped to slope ±1 (45°) so the
-* mod-based coverage math in {@link lineCoverage} tiles exactly. `"hachure"`
-* draws the "/" diagonal, `"backhachure"` its "\" mirror, and `"cross"` unions
-* both via `Math.max` coverage.
+* mod-based coverage math in {@link lineCoverage} tiles exactly. `"hatch"`
+* draws the "/" diagonal, `"reverse-hatch"` its "\" mirror, and `"cross-hatch"` unions
+* both via `Math.max` coverage. `"horizontal"`/`"vertical"` draw the
+* axis-aligned families at the same spacing, and `"dots"` a square lattice of
+* dots (see {@link dotCoverage}).
 */
 function makeFillPatternImage(color, pattern, pixelRatio = 1) {
 	const size = fillPatternImageDimension(pixelRatio);
 	const spacing = size / SPACING_DIVISOR;
 	const lineWidth = Math.max(1, Math.round(pixelRatio));
+	const dotRadius = DOT_RADIUS * Math.max(1, Math.round(pixelRatio));
 	const { r, g, b, a } = parseColor(color);
 	const data = new Uint8ClampedArray(size * size * 4);
 	for (let y = 0; y < size; y++) for (let x = 0; x < size; x++) {
 		const cx = x + .5;
 		const cy = y + .5;
-		let coverage = pattern === "backhachure" ? lineCoverage(cx, cy, spacing, lineWidth, "\\") : lineCoverage(cx, cy, spacing, lineWidth, "/");
-		if (pattern === "cross") coverage = Math.max(coverage, lineCoverage(cx, cy, spacing, lineWidth, "\\"));
+		let coverage;
+		switch (pattern) {
+			case "reverse-hatch":
+				coverage = lineCoverage(cx, cy, spacing, lineWidth, "\\");
+				break;
+			case "cross-hatch":
+				coverage = Math.max(lineCoverage(cx, cy, spacing, lineWidth, "/"), lineCoverage(cx, cy, spacing, lineWidth, "\\"));
+				break;
+			case "horizontal":
+				coverage = lineCoverage(cx, cy, spacing, lineWidth, "-");
+				break;
+			case "vertical":
+				coverage = lineCoverage(cx, cy, spacing, lineWidth, "|");
+				break;
+			case "dots":
+				coverage = dotCoverage(cx, cy, spacing, dotRadius);
+				break;
+			default: coverage = lineCoverage(cx, cy, spacing, lineWidth, "/");
+		}
 		const i = (y * size + x) * 4;
 		data[i] = r;
 		data[i + 1] = g;

package/dist/{map-adapter-meRo5VY2.d.mts → map-adapter-84irgVJR.d.mts}

@@ -45,7 +45,7 @@ interface EditPointerDriver {
  * Shared hatch fill-pattern tiles for area control-measure fills (ADR-0035
  * `FillPattern`, excluding `"solid"` which every adapter already renders as a
  * flat color). Both the MapLibre adapter (raster `addImage` pattern) and the
- * OpenLayers adapter (canvas `Pattern` fill) need the *same* diagonal-hachure
+ * OpenLayers adapter (canvas `Pattern` fill) need the *same* diagonal-hatch
  * texture, so it is rasterized once here in pure math — no `HTMLCanvasElement`
  * — so it works in adapter code and in jsdom/node tests alike.
  */
@@ -76,9 +76,11 @@ declare function fillPatternImageDimension(pixelRatio: number): number;
  * Rasterize one seamless hatch tile as a straight RGBA pixel buffer — no
  * canvas involved, so this runs identically in a browser adapter and in
  * jsdom/node tests. Diagonal lines are snapped to slope ±1 (45°) so the
- * mod-based coverage math in {@link lineCoverage} tiles exactly. `"hachure"`
- * draws the "/" diagonal, `"backhachure"` its "\" mirror, and `"cross"` unions
- * both via `Math.max` coverage.
+ * mod-based coverage math in {@link lineCoverage} tiles exactly. `"hatch"`
+ * draws the "/" diagonal, `"reverse-hatch"` its "\" mirror, and `"cross-hatch"` unions
+ * both via `Math.max` coverage. `"horizontal"`/`"vertical"` draw the
+ * axis-aligned families at the same spacing, and `"dots"` a square lattice of
+ * dots (see {@link dotCoverage}).
  */
 declare function makeFillPatternImage(color: string, pattern: HatchPattern, pixelRatio?: number): {
   width: number;
@@ -150,7 +152,7 @@ interface HandleStyle {
   fillColor?: string;
   /**
    * How `fillColor` paints a filled part's interior. Absent or `"solid"` is
-   * today's flat fill; `"hachure"`/`"backhachure"`/`"cross"` request the shared hatch texture
+   * today's flat fill; `"hatch"`/`"reverse-hatch"`/`"cross-hatch"`/`"horizontal"`/`"vertical"`/`"dots"` request the shared pattern texture
    * ({@link makeFillPatternImage}). Alpha rides in `fillColor` — there is no
    * separate opacity field. Adapters that cannot rasterize a pattern degrade
    * to solid. Per-feature only: layer-level `StyleOptions` has no equivalent.
@@ -188,6 +190,15 @@ interface FeatureGroup {
   id: string;
   features: readonly Feature[];
   iconResources: readonly IconResource[];
+  /**
+   * Monotonic stamp identifying this group's rendered content, when the
+   * producer supplies one. Two groups with the same `id` and the same
+   * `revision` carry byte-identical `features` and `iconResources`, so an
+   * adapter may skip any diff or upload work for them. A missing `revision`
+   * means "unknown" — adapters must fall back to their own comparison and
+   * must never treat two absent stamps as equal.
+   */
+  revision?: number;
 }
 /**
  * Click-style hit event delivered by {@link MapAdapter.onPick}.

package/dist/testing.d.mts

@@ -1,4 +1,4 @@
-import { a as MapAdapter, f as PixelCoordinate, i as LayerId } from "./map-adapter-meRo5VY2.mjs";
+import { a as MapAdapter, f as PixelCoordinate, i as LayerId } from "./map-adapter-84irgVJR.mjs";
 import { Feature } from "geojson";
 
 //#region src/testing/feature-group-conformance.d.ts

package/dist/testing.mjs

@@ -195,7 +195,7 @@ function runGroupedPickConformance(name, createSubject) {
 				"patterned",
 				{
 					fillColor: "#ff0000",
-					fillPattern: "hachure"
+					fillPattern: "hatch"
 				},
 				"lower"
 			]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbat-mapper/tactical-draw",
-  "version": "0.2.0-alpha.37",
+  "version": "0.2.0-alpha.39",
   "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.2.0-alpha.26"
+    "@orbat-mapper/control-measures": "^0.2.0-alpha.28"
   },
   "peerDependencies": {
     "vitest": ">=4.0.0"