@orbat-mapper/tactical-draw 0.2.0-alpha.9 → 0.2.0

package/dist/map-adapter-84irgVJR.d.mts

@@ -0,0 +1,372 @@
+import { FillPattern } from "@orbat-mapper/control-measures";
+import { Feature, Position } from "geojson";
+
+//#region src/gestures/types.d.ts
+interface PointerEventInfo {
+  /** Per-event hit-tolerance override (e.g. larger for touch). */
+  hitTolerance?: number;
+  /**
+   * Whether the Alt/Option modifier was held for this pointer event. The edit
+   * controller reads this on pointer-down to turn a vertex hit into a delete
+   * (the GIS-standard Alt+click-to-delete gesture) instead of a drag. Only the
+   * mouse paths populate it; touch leaves it `undefined`.
+   */
+  altKey?: boolean;
+  /**
+   * Whether Shift was held for this pointer event. Rotation gestures use the
+   * live value to constrain transform-box angles to 15-degree increments.
+   */
+  shiftKey?: boolean;
+  /** Engine-native event, for drivers that need to call preventDefault etc. */
+  native?: unknown;
+}
+interface PointerCallback {
+  (pixel: PixelCoordinate, info?: PointerEventInfo): void;
+}
+/**
+ * Engine-agnostic pointer driver consumed by `TacticalDraw`'s edit controller.
+ * The controller owns handle rendering and hit-tests handles in lonLat space;
+ * the driver only carries raw pointer events, drag-pan toggle, and pixel
+ * projection.
+ */
+interface EditPointerDriver {
+  onPointerDown(cb: PointerCallback): () => void;
+  onPointerMove(cb: PointerCallback): () => void;
+  onPointerUp(cb: PointerCallback): () => void;
+  setDragPanEnabled(enabled: boolean): void;
+  toPixel(lonLat: Position): PixelCoordinate | null;
+  fromPixel(pixel: PixelCoordinate): Position;
+  /** Idempotent. */
+  dispose(): void;
+}
+//#endregion
+//#region src/fill-pattern.d.ts
+/**
+ * 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-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.
+ */
+type HatchPattern = Exclude<FillPattern, "solid">;
+/**
+ * Every non-solid `FillPattern` as a runtime list — the value-level companion
+ * to {@link HatchPattern}, so adapters can test membership and build filter
+ * expressions without re-spelling the pattern vocabulary.
+ */
+declare const HATCH_PATTERNS: readonly HatchPattern[];
+/**
+ * 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
+ * lowercased so `"#FF0000"` and `"#ff0000"` share one texture.
+ */
+declare function fillPatternImageId(color: string, pattern: HatchPattern): string;
+/**
+ * Tile edge length in device pixels for a given `pixelRatio`. Must be a power
+ * of two — MapLibre requires POT dimensions for seamless WebGL texture wrap —
+ * and scales linearly with `pixelRatio` for the ratios that matter in
+ * practice (1x/2x displays: 32 -> 64, both already POT). Non-POT products
+ * (e.g. a 3x ratio, 32*3=96) round up to the next POT rather than losing the
+ * power-of-two guarantee.
+ */
+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. `"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;
+  height: number;
+  data: Uint8ClampedArray;
+};
+//#endregion
+//#region src/map-adapter.d.ts
+type PixelCoordinate = [number, number];
+type MapCursor = "" | "default" | "crosshair" | "grab" | "grabbing" | "pointer";
+interface MapEvent {
+  type: string;
+  coordinate: Position;
+  pixel: PixelCoordinate;
+  originalEvent: unknown;
+}
+type MapEventHandler = (event: MapEvent) => void;
+interface StyleOptions {
+  strokeColor?: string;
+  strokeWidth?: number;
+  strokeDash?: number[];
+  fillColor?: string;
+  pointFillColor?: string;
+  pointRadius?: number;
+  text?: TextStyleOptions;
+}
+/**
+ * Text (label) style for a layer. When `labelProperty` is set, adapters also
+ * read per-feature label properties: `rotation` (radians, rendered as
+ * `π − rotation`), the size anchor's `textSizeMeters` (ground) or
+ * `textSizePixels` (screen) (ADR-0028), and `textAnchor` (`"start"` = text
+ * begins at the label point, `"end"` = text ends there; absent = centered).
+ * A ground-anchored label renders at
+ * `clamp(textSizeMeters / resolution, textSizeMinPixels, textSizeMaxPixels)`;
+ * a screen-anchored one at a constant `textSizePixels`, unclamped.
+ */
+interface TextStyleOptions {
+  text?: string;
+  labelProperty?: string;
+  font?: string;
+  fillColor?: string;
+  strokeColor?: string;
+  strokeWidth?: number;
+  rotation?: number;
+  /**
+   * Lower edge of the ground-anchored label clamp band (ADR-0028): text never
+   * renders below this pixel size, however far the view zooms out.
+   * @default 8
+   */
+  textSizeMinPixels?: number;
+  /**
+   * Upper edge of the ground-anchored label clamp band (ADR-0028): text never
+   * renders above this pixel size, however far the view zooms in.
+   * @default 24
+   */
+  textSizeMaxPixels?: number;
+}
+/**
+ * Per-feature style for edit handles (vertex / midpoint / translate / rotate).
+ * The producer (`TacticalDraw`) rides this on `properties.style`; the adapter
+ * reads it back when rendering the handle, so it is part of the adapter
+ * contract rather than the tactical-draw authoring surface. `pointRadius` is a
+ * UI affordance not present on `ControlMeasureStyle`. See ADR-0006.
+ */
+interface HandleStyle {
+  strokeColor?: string;
+  strokeWidth?: number;
+  strokeDash?: readonly number[];
+  fillColor?: string;
+  /**
+   * How `fillColor` paints a filled part's interior. Absent or `"solid"` is
+   * 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.
+   */
+  fillPattern?: "solid" | HatchPattern;
+  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];
+  /**
+   * Direct visible mark used to rank icon picks, in unscaled canvas coordinates.
+   * Hits elsewhere in the full canvas measure their distance from this rectangle;
+   * omit it to preserve whole-canvas distance-zero behavior.
+   */
+  coreRect?: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+}
+/**
+ * One stable, atomic unit in a logical layer's bottom-to-top paint stack.
+ *
+ * Features retain their renderer-defined order inside the group. An empty
+ * group is valid and keeps its identity and stack position.
+ */
+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}.
+ *
+ * `id` is the control measure id, already split off the feature id by the
+ * adapter (see `controlMeasureIdFromFeature`).
+ *
+ * `originalEvent` is whatever the engine surfaces — OpenLayers normalises to
+ * `PointerEvent`, MapLibre delivers `MouseEvent`, Leaflet delivers
+ * `MouseEvent | TouchEvent`. Do not narrow to `PointerEvent` at the consumer.
+ */
+interface PickEvent {
+  id: string;
+  feature: Feature;
+  pixel: PixelCoordinate;
+  coordinate: Position;
+  originalEvent: MouseEvent | PointerEvent | TouchEvent;
+}
+type PickHandler = (event: PickEvent) => void;
+interface PickOptions {
+  signal?: AbortSignal;
+}
+interface MapAdapter {
+  /**
+   * Add a vector layer to the map.
+   * @returns unique layer ID
+   */
+  addVectorLayer(options?: {
+    style?: StyleOptions;
+  }): LayerId;
+  /**
+   * Remove a layer from the map.
+   */
+  removeLayer(layerId: LayerId): void;
+  /**
+   * Set the style for a specific layer.
+   */
+  setLayerStyle(layerId: LayerId, style: StyleOptions): void;
+  /**
+   * Reconcile one complete bottom-to-top desired state for a logical layer.
+   *
+   * Group IDs must be non-empty and unique within the layer. Every feature
+   * must have an ID that is unique across all groups in the layer. Invalid
+   * desired state throws synchronously before cache, resource, or engine
+   * mutation.
+   */
+  setLayerFeatureGroups(layerId: LayerId, groups: readonly FeatureGroup[]): void;
+  /**
+   * Subscribe to click-style "pick" events for a specific layer. Basemap and
+   * other-layer clicks never fire the handler.
+   *
+   * For control-measure features, adapters must set `PickEvent.id` to the
+   * originating control-measure id (not the rendered part's feature id).
+   * Features that do not satisfy the control-measure feature-id contract must
+   * be ignored rather than dispatched.
+   *
+   * Bound to the engine's tap-suppressing click event (OL `singleclick`,
+   * MapLibre `click`, Leaflet `click`) so the handler does not fire at the
+   * end of a pan or pinch-zoom gesture.
+   *
+   * Hit tolerance is pointer-type aware: 4 px for mouse/pen, 12 px for touch.
+   * Outline-only polygon interiors additionally have bounded inward selection
+   * reach from visible viewport-clipped boundaries: 24 px for mouse/pen and
+   * 36 px for touch. A visible solid or patterned fill owns its full interior.
+   * For grouped desired state, comparable hits follow authoritative group
+   * order even when the engine reports another native order. A fully opaque
+   * solid fill in a higher group suppresses lower candidates beneath its
+   * interior; translucent and patterned fills leave visible lower marks
+   * eligible.
+   *
+   * Returns an unsubscribe function. The returned function and the optional
+   * `signal` are both honoured; either teardown path stops further events,
+   * and both are idempotent.
+   */
+  onPick(layerId: LayerId, handler: PickHandler, opts?: PickOptions): () => void;
+  /**
+   * Map Event Listeners
+   *
+   * Ordering contract: a `"click"` handler and the `onPick` handlers for the
+   * same user click MUST observe the pick first — adapters deliver picks and
+   * `"click"` from the same underlying engine event, in registration order.
+   * The draw/edit controllers register their pick subscriptions before their
+   * click handler and read the stashed pick inside it (click-away close /
+   * close-then-pick re-dispatch); an adapter that fires `"click"` from an
+   * earlier engine event than its picks breaks that contract (e.g. OL
+   * `click` vs `singleclick`).
+   */
+  on(eventType: "click" | "pointermove" | "dblclick", handler: MapEventHandler): void;
+  off(eventType: "click" | "pointermove" | "dblclick", handler: MapEventHandler): void;
+  /**
+   * Projection / Coordinate Utilities
+   */
+  toLonLat(coordinate: number[]): Position;
+  fromLonLat(position: Position): number[];
+  getPixelFromCoordinate(position: Position): PixelCoordinate | null;
+  /**
+   * Convert a viewport pixel to longitude/latitude. Optional so third-party
+   * adapters compiled against an older ABI remain valid.
+   */
+  getCoordinateFromPixel?(pixel: PixelCoordinate): Position | null;
+  /**
+   * Get current viewport size in CSS pixels.
+   */
+  getViewportSize(): {
+    width: number;
+    height: number;
+  };
+  /**
+   * Pan the map by pixel delta.
+   * Positive delta means desired on-screen feature shift (right/down).
+   */
+  panByPixels(delta: PixelCoordinate, options?: {
+    durationMs?: number;
+  }): void;
+  /**
+   * Set the map viewport cursor. Pass an empty string to restore engine default styling.
+   */
+  setCursor(cursor: MapCursor): void;
+  /**
+   * Toggle the engine's native double-click-to-zoom gesture. `TacticalDraw`
+   * disables this for the lifetime of a variable-length draw so the commit
+   * `dblclick` doesn't also zoom the map.
+   */
+  setDoubleClickZoomEnabled(enabled: boolean): void;
+  /**
+   * Get current view resolution (meters per pixel at center or generally).
+   * returns undefined if not supported or not ready.
+   */
+  getResolution(): number | undefined;
+  /**
+   * Get current map zoom level
+   */
+  getZoom(): number | undefined;
+  /**
+   * Get current view bearing, radians — the clockwise-from-north compass
+   * direction that screen-up points to (MapLibre-bearing semantics). `0` for
+   * engines/views that don't rotate.
+   */
+  getBearing(): number;
+  /**
+   * Listen for view changes (zoom/resolution)
+   */
+  onViewChange(handler: () => void): void;
+  offViewChange(handler: () => void): void;
+  /**
+   * The engine evaluates the meters→pixels clamp for ground-sized point
+   * symbols inside its own style layer, so meters-sized point symbols don't
+   * need view-change re-renders for size.
+   */
+  readonly scalesGroundPointSymbolsNatively?: boolean;
+  /**
+   * Construct an {@link EditPointerDriver} for `TacticalDraw`'s edit
+   * controller. The controller subscribes to pointer events on the returned
+   * driver to wire handle drags (vertex / midpoint / translate / rotate).
+   */
+  createEditPointerDriver(): EditPointerDriver;
+  /**
+   * Release all adapter-owned map resources. Adapters must not be used after
+   * destruction.
+   */
+  destroy(): void;
+  /**
+   * Returns the features currently set on the layer — the adapter-side cache
+   * of the last grouped mutation, flattened in bottom-to-top group
+   * order. Empty array for an unknown layer. The private ordered group cache is
+   * not exposed. Callers must not mutate the returned array or features.
+   */
+  getLayerFeatures(layerId: LayerId): readonly Feature[];
+}
+//#endregion
+export { PointerEventInfo as S, fillPatternImageDimension as _, MapAdapter as a, EditPointerDriver as b, MapEventHandler as c, PickOptions as d, PixelCoordinate as f, HatchPattern as g, HATCH_PATTERNS as h, LayerId as i, PickEvent as l, TextStyleOptions as m, HandleStyle as n, MapCursor as o, StyleOptions as p, IconResource as r, MapEvent as s, FeatureGroup as t, PickHandler as u, fillPatternImageId as v, PointerCallback as x, makeFillPatternImage as y };

package/dist/testing.d.mts

@@ -0,0 +1,25 @@
+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
+interface FeatureGroupConformanceSubject {
+  adapter: MapAdapter;
+  layerId: LayerId;
+  engineFeatureIds(): Array<string | number | undefined>;
+  hasIconResource(id: string): boolean;
+  rendersIconFeature(id: string | number): boolean;
+  rendersFeatureStyle(id: string | number, channel: "fill" | "stroke"): boolean;
+  mutationCount(): number;
+  operationLog(): readonly string[];
+}
+declare function runFeatureGroupConformance(name: string, createSubject: () => FeatureGroupConformanceSubject): void;
+//#endregion
+//#region src/testing/grouped-pick-conformance.d.ts
+interface GroupedPickConformanceSubject {
+  adapter: MapAdapter;
+  layerId: LayerId;
+  pickAt(pixel: PixelCoordinate, nativeHitOrder: readonly Feature[]): string | null;
+}
+declare function runGroupedPickConformance(name: string, createSubject: () => GroupedPickConformanceSubject): void;
+//#endregion
+export { type FeatureGroupConformanceSubject, type GroupedPickConformanceSubject, runFeatureGroupConformance, runGroupedPickConformance };

package/dist/testing.mjs

@@ -0,0 +1,247 @@
+import { describe, expect, it } from "vitest";
+//#region src/testing/feature-group-conformance.ts
+function runFeatureGroupConformance(name, createSubject) {
+	describe(`${name} feature-group conformance`, () => {
+		it("reconciles complete ordered group state, including pure reorders", () => {
+			const subject = createSubject();
+			const { adapter, layerId } = subject;
+			const symbol = iconResource("lower-symbol");
+			adapter.setLayerFeatureGroups(layerId, [group$1("lower", [polygon$1("lower-area"), iconPoint("lower-symbol-feature", symbol.id)], [symbol]), group$1("upper", [line$1("upper-line")])]);
+			expect(featureIds(adapter.getLayerFeatures(layerId))).toEqual([
+				"lower-area",
+				"lower-symbol-feature",
+				"upper-line"
+			]);
+			expect(subject.engineFeatureIds()).toEqual([
+				"lower-area",
+				"lower-symbol-feature",
+				"upper-line"
+			]);
+			expect(subject.rendersIconFeature("lower-symbol-feature")).toBe(true);
+			expect(subject.rendersFeatureStyle("lower-area", "fill")).toBe(true);
+			expect(subject.rendersFeatureStyle("upper-line", "stroke")).toBe(true);
+			adapter.setLayerFeatureGroups(layerId, [group$1("upper", [line$1("upper-line")]), group$1("lower", [polygon$1("lower-area"), iconPoint("lower-symbol-feature", symbol.id)], [symbol])]);
+			expect(subject.engineFeatureIds()).toEqual([
+				"upper-line",
+				"lower-area",
+				"lower-symbol-feature"
+			]);
+		});
+		it("rejects invalid identities before cache or engine mutation", () => {
+			const invalidStates = [
+				["a missing group id", [group$1("", [point("a")], [iconResource("rejected")])]],
+				["a duplicate group id", [group$1("same", [point("a")]), group$1("same", [point("b")])]],
+				["a missing feature id", [group$1("a", [point(void 0)])]],
+				["a duplicate feature id", [group$1("a", [point("same")]), group$1("b", [point("same")])]]
+			];
+			for (const [label, invalidGroups] of invalidStates) {
+				const subject = createSubject();
+				const { adapter, layerId } = subject;
+				adapter.setLayerFeatureGroups(layerId, [group$1("valid", [point("kept")])]);
+				const mutationsBefore = subject.mutationCount();
+				expect(() => adapter.setLayerFeatureGroups(layerId, invalidGroups), label).toThrow();
+				expect(featureIds(adapter.getLayerFeatures(layerId))).toEqual(["kept"]);
+				expect(subject.engineFeatureIds()).toEqual(["kept"]);
+				expect(subject.hasIconResource("rejected")).toBe(false);
+				expect(subject.mutationCount()).toBe(mutationsBefore);
+			}
+			const unknownLayerSubject = createSubject();
+			unknownLayerSubject.adapter.removeLayer(unknownLayerSubject.layerId);
+			expect(() => unknownLayerSubject.adapter.setLayerFeatureGroups("unknown", [group$1("", [point("invalid")])])).toThrow();
+		});
+		it("preserves an empty group's stack position while reconciling icon resources", () => {
+			const subject = createSubject();
+			const { adapter, layerId } = subject;
+			const icon = iconResource("symbol");
+			adapter.setLayerFeatureGroups(layerId, [
+				group$1("lower", [point("lower")]),
+				group$1("recoverable", [iconPoint("symbol-feature", icon.id)], [icon]),
+				group$1("upper", [point("upper")])
+			]);
+			expect(subject.hasIconResource(icon.id)).toBe(true);
+			expect(subject.rendersIconFeature("symbol-feature")).toBe(true);
+			expect(subject.operationLog().slice(-2)).toEqual(["icons:symbol", "groups:lower,recoverable,upper"]);
+			adapter.setLayerFeatureGroups(layerId, [
+				group$1("lower", [point("lower")]),
+				group$1("recoverable", []),
+				group$1("upper", [point("upper")])
+			]);
+			expect(subject.engineFeatureIds()).toEqual(["lower", "upper"]);
+			expect(subject.hasIconResource(icon.id)).toBe(false);
+			adapter.setLayerFeatureGroups(layerId, [
+				group$1("lower", [point("lower")]),
+				group$1("recoverable", [iconPoint("replacement", icon.id)], [icon]),
+				group$1("upper", [point("upper")])
+			]);
+			expect(subject.engineFeatureIds()).toEqual([
+				"lower",
+				"replacement",
+				"upper"
+			]);
+			expect(subject.hasIconResource(icon.id)).toBe(true);
+			expect(subject.rendersIconFeature("replacement")).toBe(true);
+			expect(subject.operationLog().at(-1)).toBe("groups:lower,recoverable,upper");
+		});
+		it("returns a flattened read without exposing grouped state", () => {
+			const { adapter, layerId } = createSubject();
+			adapter.setLayerFeatureGroups(layerId, [
+				group$1("a", [point("a-1"), point("a-2")]),
+				group$1("empty", []),
+				group$1("b", [point("b-1")])
+			]);
+			const flattened = adapter.getLayerFeatures(layerId);
+			expect(featureIds(flattened)).toEqual([
+				"a-1",
+				"a-2",
+				"b-1"
+			]);
+			expect(flattened).not.toHaveProperty("groups");
+		});
+	});
+}
+function group$1(id, features, iconResources = []) {
+	return {
+		id,
+		features,
+		iconResources
+	};
+}
+function point(id) {
+	return {
+		type: "Feature",
+		...id === void 0 ? {} : { id },
+		properties: {},
+		geometry: {
+			type: "Point",
+			coordinates: [0, 0]
+		}
+	};
+}
+function iconPoint(id, iconId) {
+	return {
+		...point(id),
+		properties: { iconId }
+	};
+}
+function line$1(id) {
+	return {
+		type: "Feature",
+		id,
+		properties: { style: {
+			strokeColor: "#000000",
+			strokeWidth: 2
+		} },
+		geometry: {
+			type: "LineString",
+			coordinates: [[0, 0], [1, 1]]
+		}
+	};
+}
+function polygon$1(id) {
+	return {
+		type: "Feature",
+		id,
+		properties: { style: {
+			fillColor: "#ffffff",
+			strokeColor: "#000000",
+			strokeWidth: 2
+		} },
+		geometry: {
+			type: "Polygon",
+			coordinates: [[
+				[0, 0],
+				[1, 0],
+				[1, 1],
+				[0, 0]
+			]]
+		}
+	};
+}
+function featureIds(features) {
+	return features.map((feature) => feature.id);
+}
+function iconResource(id) {
+	return {
+		id,
+		svg: "<svg/>",
+		width: 1,
+		height: 1,
+		anchor: [0, 0]
+	};
+}
+//#endregion
+//#region src/testing/grouped-pick-conformance.ts
+function runGroupedPickConformance(name, createSubject) {
+	describe(`${name} grouped-pick conformance`, () => {
+		it("uses grouped desired-state order when native hit order disagrees", () => {
+			const subject = createSubject();
+			const lower = line("lower");
+			const higher = line("higher");
+			subject.adapter.setLayerFeatureGroups(subject.layerId, [group("lower", lower), group("higher", higher)]);
+			expect(subject.pickAt([0, 50], [lower, higher])).toBe("higher");
+		});
+		it.each([
+			[
+				"opaque",
+				{ fillColor: "#ff0000" },
+				"higher"
+			],
+			[
+				"translucent",
+				{ fillColor: "rgba(255, 0, 0, 0.5)" },
+				"lower"
+			],
+			[
+				"patterned",
+				{
+					fillColor: "#ff0000",
+					fillPattern: "hatch"
+				},
+				"lower"
+			]
+		])("%s higher fills resolve only genuinely visible marks", (_name, style, expected) => {
+			const subject = createSubject();
+			const lower = line("lower");
+			const higher = polygon("higher", style);
+			subject.adapter.setLayerFeatureGroups(subject.layerId, [group("lower", lower), group("higher", higher)]);
+			expect(subject.pickAt([0, 50], [lower, higher])).toBe(expected);
+		});
+	});
+}
+function group(id, feature) {
+	return {
+		id,
+		features: [feature],
+		iconResources: []
+	};
+}
+function line(id) {
+	return {
+		type: "Feature",
+		id: `${id}:main:0`,
+		geometry: {
+			type: "LineString",
+			coordinates: [[-100, 50], [100, 50]]
+		},
+		properties: {}
+	};
+}
+function polygon(id, style) {
+	return {
+		type: "Feature",
+		id: `${id}:main:0`,
+		geometry: {
+			type: "Polygon",
+			coordinates: [[
+				[-100, 0],
+				[100, 0],
+				[100, 100],
+				[-100, 100],
+				[-100, 0]
+			]]
+		},
+		properties: { style }
+	};
+}
+//#endregion
+export { runFeatureGroupConformance, runGroupedPickConformance };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbat-mapper/tactical-draw",
-  "version": "0.2.0-alpha.9",
+  "version": "0.2.0",
   "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",
@@ -26,6 +26,7 @@
   "type": "module",
   "exports": {
     ".": "./dist/index.mjs",
+    "./testing": "./dist/testing.mjs",
     "./package.json": "./package.json"
   },
   "sideEffects": false,
@@ -38,7 +39,15 @@
     "access": "public"
   },
   "dependencies": {
-    "@orbat-mapper/control-measures": "^0.2.0-alpha.8"
+    "@orbat-mapper/control-measures": "^0.2.0"
+  },
+  "peerDependencies": {
+    "vitest": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vitest": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@arethetypeswrong/core": "^0.18.3",