@orbat-mapper/control-measures 0.2.0-alpha.4 → 0.2.0-alpha.6

package/dist/{index-BJYbQlzo.d.mts → index-DUGzYzPy.d.mts}

@@ -23,6 +23,19 @@ interface ControlMeasureDrawRule {
    * `minimumUserPoints` (no early preview).
    */
   readonly minimumPreviewPoints?: number;
+  /**
+   * Opt a fixed-length draw into the standard dashed interaction guide. Fixed
+   * shapes suppress guides by default because their generator preview is
+   * normally sufficient. Use this when the guide communicates an incomplete
+   * construction state, such as Rectangle's P1-P2 baseline.
+   */
+  readonly showGuide?: boolean;
+  /**
+   * Convert raw draw points into the spine rendered by the interaction guide.
+   * Defaults to the raw points. A rule may return the first point again at the
+   * end when it needs to provide its own closed guide geometry.
+   */
+  guidePoints?(points: readonly Position[]): Position[];
   /**
    * Number of trailing slots in the canonical control-point array that are
    * NOT user-clicked spine vertices. For Axis1, this is 1 (the width handle
@@ -36,6 +49,12 @@ interface ControlMeasureDrawRule {
    * Defaults to 0 (the entire array is user-clicked spine). See ADR-0008.
    */
   readonly trailingFixedSlots?: number;
+  /**
+   * The user-spine points form a closed ring even though the first point is not
+   * duplicated at the end. TacticalDraw uses this to treat the last→first edge
+   * like every other edge for completion and midpoint insertion.
+   */
+  readonly closedRing?: boolean;
   derive(points: readonly Position[]): Position[];
   transform(event: AnchorTransformEvent): Position[];
 }
@@ -43,7 +62,7 @@ interface ControlMeasureDrawRule {
 //#region src/metadata.d.ts
 type ControlMeasureGeometryType = Geometry["type"];
 type ControlMeasureGeometry = "point" | "line" | "area";
-declare const DRAW_RULE_IDS: readonly ["Area1", "Area7", "Area8", "Area11", "Area12", "Area15", "Area21", "Axis1", "Line1", "Line3", "Line9", "Line10", "Line23", "Line24", "Line29", "Point12"];
+declare const DRAW_RULE_IDS: readonly ["Area1", "Area7", "Area8", "Area11", "Area12", "Area15", "Area21", "Axis1", "Line1", "Line3", "Line9", "Line10", "Line23", "Line24", "Line29", "Point12", "Rectangle"];
 type DrawRuleId = (typeof DRAW_RULE_IDS)[number];
 interface BaseParamDescriptor {
   key: string;
@@ -156,6 +175,18 @@ interface ControlMeasureDefinition<Id extends string, G extends ControlMeasureGe
    * ADR-0025.
    */
   previewSample?: PreviewSample<NonNullable<Parameters<G>[1]>>;
+  /**
+   * Pins orientation-derived defaults — options whose default value depends on
+   * the shape's current screen orientation (e.g. Battle Position's echelon
+   * anchor, which defaults to the bottom edge) — to their current concrete
+   * values. Returns an options patch to merge onto the working options, or
+   * `undefined` when there is nothing to freeze (already frozen, or nothing
+   * visible to pin). Called by edit hosts when a rotate gesture starts, so a
+   * subsequent rigid rotation of the control points preserves the rendered
+   * appearance instead of an orientation-relative default silently re-deriving
+   * against the new orientation. See ADR-0023.
+   */
+  freezeOrientation?: (controlPoints: Position[], options: NonNullable<Parameters<G>[1]>) => Partial<NonNullable<Parameters<G>[1]>> | undefined;
 }
 /**
  * A measure's representative preview input. Shared between the typed
@@ -309,6 +340,25 @@ interface BattlePositionOptions {
    * @default 0
    */
   echelonPosition?: number;
+  /**
+   * Absolute anchor for the echelon glyph, as a fraction of the total
+   * perimeter measured from the ring seam (the ring's first vertex), wrapped
+   * into `[0, 1)`. When omitted, the anchor is "auto": the bottom edge's
+   * midpoint (the side opposite the front), recomputed from the current
+   * geometry on every render — the long-standing default behavior.
+   * `echelonPosition` still applies on top of this anchor as a signed offset,
+   * exactly as it does against the auto anchor.
+   *
+   * Edit controllers freeze this from "auto" to a concrete fraction the
+   * moment a rotate gesture starts (see `freezeEchelonAnchor` /
+   * `freezeOrientationOptions`): the transform box rotates only the control
+   * points and re-renders, so without a pinned anchor the "bottom edge" would
+   * keep re-deriving against the rotated geometry and the glyph would jump to
+   * a different edge each time a new edge becomes lowest. Freezing the anchor
+   * first makes the rotation rigid — the glyph turns with the shape instead.
+   * See ADR-0023.
+   */
+  echelonAnchor?: number;
   /**
    * Meters-per-pixel at the current zoom/latitude. Stamped by the host when the
    * measure is screen-anchored; required to resolve `echelonSizePixels`.
@@ -613,6 +663,47 @@ declare function createBlockArrow(coordinates: Position[], options?: BlockArrowO
   fill: boolean;
 }>;
 //#endregion
+//#region src/generators/cm99-generic-graphics/params.d.ts
+interface SmoothPathOptions {
+  /** Curve the rendered path through the unchanged control points. */
+  smooth?: boolean;
+  /** Number of samples per segment when smoothing is enabled. */
+  smoothResolution?: number;
+}
+interface FilledAreaOptions {
+  /** Fill the polygon interior; false renders only its outline. */
+  filled?: boolean;
+}
+//#endregion
+//#region src/generators/cm99-generic-graphics/line.d.ts
+type GenericLineOptions = SmoothPathOptions;
+declare const DEFAULT_GENERIC_LINE_OPTIONS: Required<GenericLineOptions>;
+declare function createGenericLine(coordinates: Position[], options?: GenericLineOptions): FeatureCollection<LineString>;
+//#endregion
+//#region src/generators/cm99-generic-graphics/polygon.d.ts
+interface GenericPolygonOptions extends SmoothPathOptions, FilledAreaOptions {}
+declare const DEFAULT_GENERIC_POLYGON_OPTIONS: Required<GenericPolygonOptions>;
+declare function createGenericPolygon(coordinates: Position[], options?: GenericPolygonOptions): FeatureCollection<Polygon, {
+  part: string;
+  fill: boolean;
+}>;
+//#endregion
+//#region src/generators/cm99-generic-graphics/rectangle.d.ts
+type GenericRectangleOptions = FilledAreaOptions;
+declare const DEFAULT_GENERIC_RECTANGLE_OPTIONS: Required<GenericRectangleOptions>;
+declare function createGenericRectangle(coordinates: Position[], options?: GenericRectangleOptions): FeatureCollection<Polygon, {
+  part: string;
+  fill: boolean;
+}>;
+//#endregion
+//#region src/generators/cm99-generic-graphics/circle.d.ts
+type GenericCircleOptions = FilledAreaOptions;
+declare const DEFAULT_GENERIC_CIRCLE_OPTIONS: Required<GenericCircleOptions>;
+declare function createGenericCircle(coordinates: Position[], options?: GenericCircleOptions): FeatureCollection<Polygon, {
+  part: string;
+  fill: boolean;
+}>;
+//#endregion
 //#region src/generators/cm15-maneuver-areas/airborneAttack.d.ts
 type AirborneAttackOptions = AttackOptions;
 declare const DEFAULT_AIRBORNE_ATTACK_OPTIONS: Required<AirborneAttackOptions>;
@@ -1265,6 +1356,10 @@ declare const DEFINITIONS: {
   "supporting-attack": ControlMeasureDefinition<"supporting-attack", typeof createSupportingAttack>;
   "classic-arrow": ControlMeasureDefinition<"classic-arrow", typeof createClassicArrow>;
   "block-arrow": ControlMeasureDefinition<"block-arrow", typeof createBlockArrow>;
+  line: ControlMeasureDefinition<"line", typeof createGenericLine>;
+  polygon: ControlMeasureDefinition<"polygon", typeof createGenericPolygon>;
+  rectangle: ControlMeasureDefinition<"rectangle", typeof createGenericRectangle>;
+  circle: ControlMeasureDefinition<"circle", typeof createGenericCircle>;
   "airborne-attack": ControlMeasureDefinition<"airborne-attack", typeof createAirborneAttack>;
   "attack-helicopter": ControlMeasureDefinition<"attack-helicopter", typeof createAttackHelicopter>;
   "support-by-fire": ControlMeasureDefinition<"support-by-fire", typeof createSupportByFire>;
@@ -1454,6 +1549,17 @@ interface RenderOptions {
  */
 declare function renderControlMeasure<K extends ControlMeasureKind>(cm: ControlMeasure<K>, opts?: RenderOptions): ControlMeasureRender;
 //#endregion
+//#region src/freeze-orientation.d.ts
+/**
+ * Dispatches to a measure kind's `freezeOrientation` hook (see
+ * {@link import("./define").ControlMeasureDefinition.freezeOrientation}),
+ * pinning orientation-derived option defaults to their current concrete
+ * values ahead of a rigid rotation of `controlPoints`. Returns `undefined`
+ * when the kind declares no hook, or when the hook itself finds nothing to
+ * freeze. Edit hosts call this when a rotate gesture starts (ADR-0023).
+ */
+declare function freezeOrientationOptions<K extends ControlMeasureKind>(kind: K, controlPoints: Position[], options: OptionsByKind[K] | undefined): Partial<OptionsByKind[K]> | undefined;
+//#endregion
 //#region src/styleResolver.d.ts
 /**
  * Three-layer style precedence for `renderControlMeasure`.
@@ -1599,6 +1705,9 @@ declare const blockDrawRule: ControlMeasureDrawRule;
  */
 declare const disruptDrawRule: ControlMeasureDrawRule;
 //#endregion
+//#region src/draw-rules/area15.d.ts
+declare const centerRadiusDrawRule: ControlMeasureDrawRule;
+//#endregion
 //#region src/draw-rules/point12.d.ts
 /**
  * Point12 anchor draw rule for the obstacle-bypass family.
@@ -1669,6 +1778,9 @@ declare const supportByFireDrawRule: ControlMeasureDrawRule;
 //#region src/draw-rules/axis1.d.ts
 declare const axis1DrawRule: ControlMeasureDrawRule;
 //#endregion
+//#region src/draw-rules/rectangle.d.ts
+declare const rectangleDrawRule: ControlMeasureDrawRule;
+//#endregion
 //#region src/generators/cm14-maneuver-lines/ambush.d.ts
 /**
  * Configuration options for the Ambush tactical symbol.
@@ -1710,4 +1822,4 @@ interface TacticalArrowOptions {
  */
 declare const DEFAULT_TACTICAL_ARROW_OPTIONS: Required<TacticalArrowOptions>;
 //#endregion
-export { listControlMeasureMetadata as $, DEFAULT_ENCIRCLEMENT_OPTIONS as $t, SimpleStyleProps as A, BreachOptions as At, controlMeasureIdFromFeature as B, AttackHelicopterOptions as Bt, BaselineFrameNormal as C, DelayOptions as Ct, EPSILON as D, DEFAULT_CANALIZE_OPTIONS as Dt, createBaselineFrame as E, CanalizeOptions as Et, renderControlMeasure as F, FLOTOptions as Ft, CONTROL_MEASURE_IDS as G, SupportingAttackOptions as Gt, cloneControlMeasure as H, AirborneAttackOptions as Ht, ControlMeasureRender as I, AttackByFireOptions as It, ControlMeasureKind as J, calculateMetrics as Jt, CONTROL_MEASURE_METADATA as K, DEFAULT_MAIN_ATTACK_OPTIONS as Kt, ControlMeasureSnapshot as L, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Lt, toSimpleStyle as M, BlockMissionTaskOptions as Mt, resolveStyleHints as N, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as Nt, getMetersPerPixel as O, BypassOptions as Ot, RenderOptions as P, DEFAULT_FLOT_OPTIONS as Pt, getDefaultOptions as Q, unproject as Qt, FeaturePartProps as R, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as Rt, BaselineFrame as S, DEFAULT_DELAY_OPTIONS as St, BaselineFrameOrigin as T, DEFAULT_CLEAR_OPTIONS as Tt, isKind as U, DEFAULT_AIRBORNE_ATTACK_OPTIONS as Ut, ControlMeasure as V, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Vt, ControlMeasureStyle as W, DEFAULT_SUPPORTING_ATTACK_OPTIONS as Wt, getControlMeasureMetadata as X, Point2D as Xt, OptionsByKind as Y, computeInitialWidthPoint as Yt, getControlMeasureMetadataByValue as Z, project as Zt, computeDefaultMidpointPerpendicularPoint as _, FortifiedLineOptions as _t, axis1DrawRule as a, DEFAULT_STRONG_POINT_OPTIONS as an, ObstacleBypassEasyOptions as at, pointOnMidpointPerpendicularAxis as b, AntitankDitchOptions as bt, line23DrawRule as c, ControlMeasureGeometryType as cn, DEFAULT_FIX_OPTIONS as ct, ambushDrawRule as d, AnchorTransformEvent as dn, DisruptOptions as dt, EncirclementOptions as en, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as et, attackByFireDrawRule as f, ControlMeasureDrawRule as fn, BlockOptions as ft, MidpointPerpendicularDrawRuleOptions as g, DEFAULT_FORTIFIED_LINE_OPTIONS as gt, blockDrawRule as h, FortifiedAreaOptions as ht, DEFAULT_AMBUSH_OPTIONS as i, PrincipalDirectionOfFireOptions as in, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as it, SimpleStyleRender as j, DEFAULT_BREACH_OPTIONS as jt, roundToFixed as k, DEFAULT_BYPASS_OPTIONS as kt, turnDrawRule as l, ControlMeasureMetadata as ln, FixOptions as lt, disruptDrawRule as m, DEFAULT_FORTIFIED_AREA_OPTIONS as mt, TacticalArrowOptions as n, FinalProtectiveFireOptions as nn, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as nt, supportByFireDrawRule as o, StrongPointOptions as on, DEFAULT_TURN_OPTIONS as ot, point12DrawRule as p, DEFAULT_BLOCK_OPTIONS as pt, ControlMeasureId as q, MainAttackOptions as qt, AmbushOptions as r, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as rn, ObstacleBypassDifficultOptions as rt, line24DrawRule as s, ControlMeasureGeometry as sn, TurnOptions as st, DEFAULT_TACTICAL_ARROW_OPTIONS as t, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as tn, ObstacleBypassImpossibleOptions as tt, line1DrawRule as u, ParamDescriptor as un, DEFAULT_DISRUPT_OPTIONS as ut, createMidpointPerpendicularDrawRule as v, AntitankWallOptions as vt, BaselineFrameOptions as w, ClearOptions as wt, snapToMidpointPerpendicular as x, DEFAULT_ANTITANK_DITCH_OPTIONS as xt, getMidpointPerpendicularSignedDistance as y, DEFAULT_ANTITANK_WALL_OPTIONS as yt, StyleHints as z, SupportByFireOptions as zt };
+export { getControlMeasureMetadata as $, DEFAULT_GENERIC_LINE_OPTIONS as $t, getMetersPerPixel as A, DEFAULT_CANALIZE_OPTIONS as At, ControlMeasureSnapshot as B, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Bt, snapToMidpointPerpendicular as C, ControlMeasureDrawRule as Cn, AntitankDitchOptions as Ct, BaselineFrameOrigin as D, ClearOptions as Dt, BaselineFrameOptions as E, DelayOptions as Et, resolveStyleHints as F, BlockMissionTaskOptions as Ft, cloneControlMeasure as G, AirborneAttackOptions as Gt, StyleHints as H, SupportByFireOptions as Ht, freezeOrientationOptions as I, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as It, CONTROL_MEASURE_IDS as J, GenericCircleOptions as Jt, isKind as K, DEFAULT_AIRBORNE_ATTACK_OPTIONS as Kt, RenderOptions as L, DEFAULT_FLOT_OPTIONS as Lt, SimpleStyleProps as M, DEFAULT_BYPASS_OPTIONS as Mt, SimpleStyleRender as N, BreachOptions as Nt, createBaselineFrame as O, DEFAULT_CLEAR_OPTIONS as Ot, toSimpleStyle as P, DEFAULT_BREACH_OPTIONS as Pt, OptionsByKind as Q, GenericPolygonOptions as Qt, renderControlMeasure as R, FLOTOptions as Rt, pointOnMidpointPerpendicularAxis as S, AnchorTransformEvent as Sn, DEFAULT_ANTITANK_WALL_OPTIONS as St, BaselineFrameNormal as T, DEFAULT_DELAY_OPTIONS as Tt, controlMeasureIdFromFeature as U, AttackHelicopterOptions as Ut, FeaturePartProps as V, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as Vt, ControlMeasure as W, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Wt, ControlMeasureId as X, GenericRectangleOptions as Xt, CONTROL_MEASURE_METADATA as Y, DEFAULT_GENERIC_RECTANGLE_OPTIONS as Yt, ControlMeasureKind as Z, DEFAULT_GENERIC_POLYGON_OPTIONS as Zt, blockDrawRule as _, StrongPointOptions as _n, DEFAULT_FORTIFIED_AREA_OPTIONS as _t, rectangleDrawRule as a, calculateMetrics as an, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as at, createMidpointPerpendicularDrawRule as b, ControlMeasureMetadata as bn, FortifiedLineOptions as bt, line24DrawRule as c, project as cn, ObstacleBypassEasyOptions as ct, line1DrawRule as d, EncirclementOptions as dn, DEFAULT_FIX_OPTIONS as dt, GenericLineOptions as en, getControlMeasureMetadataByValue as et, ambushDrawRule as f, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as fn, FixOptions as ft, disruptDrawRule as g, DEFAULT_STRONG_POINT_OPTIONS as gn, DEFAULT_BLOCK_OPTIONS as gt, centerRadiusDrawRule as h, PrincipalDirectionOfFireOptions as hn, BlockOptions as ht, DEFAULT_AMBUSH_OPTIONS as i, MainAttackOptions as in, ObstacleBypassImpossibleOptions as it, roundToFixed as j, BypassOptions as jt, EPSILON as k, CanalizeOptions as kt, line23DrawRule as l, unproject as ln, DEFAULT_TURN_OPTIONS as lt, point12DrawRule as m, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as mn, DisruptOptions as mt, TacticalArrowOptions as n, SupportingAttackOptions as nn, listControlMeasureMetadata as nt, axis1DrawRule as o, computeInitialWidthPoint as on, ObstacleBypassDifficultOptions as ot, attackByFireDrawRule as p, FinalProtectiveFireOptions as pn, DEFAULT_DISRUPT_OPTIONS as pt, ControlMeasureStyle as q, DEFAULT_GENERIC_CIRCLE_OPTIONS as qt, AmbushOptions as r, DEFAULT_MAIN_ATTACK_OPTIONS as rn, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as rt, supportByFireDrawRule as s, Point2D as sn, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as st, DEFAULT_TACTICAL_ARROW_OPTIONS as t, DEFAULT_SUPPORTING_ATTACK_OPTIONS as tn, getDefaultOptions as tt, turnDrawRule as u, DEFAULT_ENCIRCLEMENT_OPTIONS as un, TurnOptions as ut, MidpointPerpendicularDrawRuleOptions as v, ControlMeasureGeometry as vn, FortifiedAreaOptions as vt, BaselineFrame as w, DEFAULT_ANTITANK_DITCH_OPTIONS as wt, getMidpointPerpendicularSignedDistance as x, ParamDescriptor as xn, AntitankWallOptions as xt, computeDefaultMidpointPerpendicularPoint as y, ControlMeasureGeometryType as yn, DEFAULT_FORTIFIED_LINE_OPTIONS as yt, ControlMeasureRender as z, AttackByFireOptions as zt };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { $ as listControlMeasureMetadata, $t as DEFAULT_ENCIRCLEMENT_OPTIONS, A as SimpleStyleProps, At as BreachOptions, B as controlMeasureIdFromFeature, Bt as AttackHelicopterOptions, C as BaselineFrameNormal, Ct as DelayOptions, D as EPSILON, Dt as DEFAULT_CANALIZE_OPTIONS, E as createBaselineFrame, Et as CanalizeOptions, F as renderControlMeasure, Ft as FLOTOptions, G as CONTROL_MEASURE_IDS, Gt as SupportingAttackOptions, H as cloneControlMeasure, Ht as AirborneAttackOptions, I as ControlMeasureRender, It as AttackByFireOptions, J as ControlMeasureKind, Jt as calculateMetrics, K as CONTROL_MEASURE_METADATA, Kt as DEFAULT_MAIN_ATTACK_OPTIONS, L as ControlMeasureSnapshot, Lt as DEFAULT_ATTACK_BY_FIRE_OPTIONS, M as toSimpleStyle, Mt as BlockMissionTaskOptions, N as resolveStyleHints, Nt as DEFAULT_BLOCK_MISSION_TASK_OPTIONS, O as getMetersPerPixel, Ot as BypassOptions, P as RenderOptions, Pt as DEFAULT_FLOT_OPTIONS, Q as getDefaultOptions, Qt as unproject, R as FeaturePartProps, Rt as DEFAULT_SUPPORT_BY_FIRE_OPTIONS, S as BaselineFrame, St as DEFAULT_DELAY_OPTIONS, T as BaselineFrameOrigin, Tt as DEFAULT_CLEAR_OPTIONS, U as isKind, Ut as DEFAULT_AIRBORNE_ATTACK_OPTIONS, V as ControlMeasure, Vt as DEFAULT_ATTACK_HELICOPTER_OPTIONS, W as ControlMeasureStyle, Wt as DEFAULT_SUPPORTING_ATTACK_OPTIONS, X as getControlMeasureMetadata, Xt as Point2D, Y as OptionsByKind, Yt as computeInitialWidthPoint, Z as getControlMeasureMetadataByValue, Zt as project, _ as computeDefaultMidpointPerpendicularPoint, _t as FortifiedLineOptions, a as axis1DrawRule, an as DEFAULT_STRONG_POINT_OPTIONS, at as ObstacleBypassEasyOptions, b as pointOnMidpointPerpendicularAxis, bt as AntitankDitchOptions, c as line23DrawRule, cn as ControlMeasureGeometryType, ct as DEFAULT_FIX_OPTIONS, d as ambushDrawRule, dn as AnchorTransformEvent, dt as DisruptOptions, en as EncirclementOptions, et as DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, f as attackByFireDrawRule, fn as ControlMeasureDrawRule, ft as BlockOptions, g as MidpointPerpendicularDrawRuleOptions, gt as DEFAULT_FORTIFIED_LINE_OPTIONS, h as blockDrawRule, ht as FortifiedAreaOptions, i as DEFAULT_AMBUSH_OPTIONS, in as PrincipalDirectionOfFireOptions, it as DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, j as SimpleStyleRender, jt as DEFAULT_BREACH_OPTIONS, k as roundToFixed, kt as DEFAULT_BYPASS_OPTIONS, l as turnDrawRule, ln as ControlMeasureMetadata, lt as FixOptions, m as disruptDrawRule, mt as DEFAULT_FORTIFIED_AREA_OPTIONS, n as TacticalArrowOptions, nn as FinalProtectiveFireOptions, nt as DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, o as supportByFireDrawRule, on as StrongPointOptions, ot as DEFAULT_TURN_OPTIONS, p as point12DrawRule, pt as DEFAULT_BLOCK_OPTIONS, q as ControlMeasureId, qt as MainAttackOptions, r as AmbushOptions, rn as DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, rt as ObstacleBypassDifficultOptions, s as line24DrawRule, sn as ControlMeasureGeometry, st as TurnOptions, t as DEFAULT_TACTICAL_ARROW_OPTIONS, tn as DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, tt as ObstacleBypassImpossibleOptions, u as line1DrawRule, un as ParamDescriptor, ut as DEFAULT_DISRUPT_OPTIONS, v as createMidpointPerpendicularDrawRule, vt as AntitankWallOptions, w as BaselineFrameOptions, wt as ClearOptions, x as snapToMidpointPerpendicular, xt as DEFAULT_ANTITANK_DITCH_OPTIONS, y as getMidpointPerpendicularSignedDistance, yt as DEFAULT_ANTITANK_WALL_OPTIONS, z as StyleHints, zt as SupportByFireOptions } from "./index-BJYbQlzo.mjs";
-export { type AirborneAttackOptions, type AmbushOptions, type AnchorTransformEvent, type AntitankDitchOptions, type AntitankWallOptions, type AttackByFireOptions, type AttackHelicopterOptions, type BaselineFrame, type BaselineFrameNormal, type BaselineFrameOptions, type BaselineFrameOrigin, type BlockMissionTaskOptions, type BlockOptions, type BreachOptions, type BypassOptions, CONTROL_MEASURE_IDS, CONTROL_MEASURE_METADATA, type CanalizeOptions, type ClearOptions, type ControlMeasure, type ControlMeasureDrawRule, type ControlMeasureGeometry, type ControlMeasureGeometryType, type ControlMeasureId, type ControlMeasureKind, type ControlMeasureMetadata, type ControlMeasureRender, type ControlMeasureSnapshot, type ControlMeasureStyle, DEFAULT_AIRBORNE_ATTACK_OPTIONS, DEFAULT_AMBUSH_OPTIONS, DEFAULT_ANTITANK_DITCH_OPTIONS, DEFAULT_ANTITANK_WALL_OPTIONS, DEFAULT_ATTACK_BY_FIRE_OPTIONS, DEFAULT_ATTACK_HELICOPTER_OPTIONS, DEFAULT_BLOCK_MISSION_TASK_OPTIONS, DEFAULT_BLOCK_OPTIONS, DEFAULT_BREACH_OPTIONS, DEFAULT_BYPASS_OPTIONS, DEFAULT_CANALIZE_OPTIONS, DEFAULT_CLEAR_OPTIONS, DEFAULT_DELAY_OPTIONS, DEFAULT_DISRUPT_OPTIONS, DEFAULT_ENCIRCLEMENT_OPTIONS, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, DEFAULT_FIX_OPTIONS, DEFAULT_FLOT_OPTIONS, DEFAULT_FORTIFIED_AREA_OPTIONS, DEFAULT_FORTIFIED_LINE_OPTIONS, DEFAULT_MAIN_ATTACK_OPTIONS, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, DEFAULT_STRONG_POINT_OPTIONS, DEFAULT_SUPPORTING_ATTACK_OPTIONS, DEFAULT_SUPPORT_BY_FIRE_OPTIONS, DEFAULT_TACTICAL_ARROW_OPTIONS, DEFAULT_TURN_OPTIONS, type DelayOptions, type DisruptOptions, EPSILON, type EncirclementOptions, type FLOTOptions, type FeaturePartProps, type FinalProtectiveFireOptions, type FixOptions, type FortifiedAreaOptions, type FortifiedLineOptions, type MainAttackOptions, type MidpointPerpendicularDrawRuleOptions, type ObstacleBypassDifficultOptions, type ObstacleBypassEasyOptions, type ObstacleBypassImpossibleOptions, type OptionsByKind, type ParamDescriptor, type Point2D, type PrincipalDirectionOfFireOptions, type RenderOptions, type SimpleStyleProps, type SimpleStyleRender, type StrongPointOptions, type StyleHints, type SupportByFireOptions, type SupportingAttackOptions, type TacticalArrowOptions, type TurnOptions, ambushDrawRule, attackByFireDrawRule, axis1DrawRule, blockDrawRule, calculateMetrics, cloneControlMeasure, computeDefaultMidpointPerpendicularPoint, computeInitialWidthPoint, controlMeasureIdFromFeature, createBaselineFrame, createMidpointPerpendicularDrawRule, disruptDrawRule, getControlMeasureMetadata, getControlMeasureMetadataByValue, getDefaultOptions, getMetersPerPixel, getMidpointPerpendicularSignedDistance, isKind, line1DrawRule, line23DrawRule, line24DrawRule, listControlMeasureMetadata, point12DrawRule, pointOnMidpointPerpendicularAxis, project, renderControlMeasure, resolveStyleHints, roundToFixed, snapToMidpointPerpendicular, supportByFireDrawRule, toSimpleStyle, turnDrawRule, unproject };
+import { $ as getControlMeasureMetadata, $t as DEFAULT_GENERIC_LINE_OPTIONS, A as getMetersPerPixel, At as DEFAULT_CANALIZE_OPTIONS, B as ControlMeasureSnapshot, Bt as DEFAULT_ATTACK_BY_FIRE_OPTIONS, C as snapToMidpointPerpendicular, Cn as ControlMeasureDrawRule, Ct as AntitankDitchOptions, D as BaselineFrameOrigin, Dt as ClearOptions, E as BaselineFrameOptions, Et as DelayOptions, F as resolveStyleHints, Ft as BlockMissionTaskOptions, G as cloneControlMeasure, Gt as AirborneAttackOptions, H as StyleHints, Ht as SupportByFireOptions, I as freezeOrientationOptions, It as DEFAULT_BLOCK_MISSION_TASK_OPTIONS, J as CONTROL_MEASURE_IDS, Jt as GenericCircleOptions, K as isKind, Kt as DEFAULT_AIRBORNE_ATTACK_OPTIONS, L as RenderOptions, Lt as DEFAULT_FLOT_OPTIONS, M as SimpleStyleProps, Mt as DEFAULT_BYPASS_OPTIONS, N as SimpleStyleRender, Nt as BreachOptions, O as createBaselineFrame, Ot as DEFAULT_CLEAR_OPTIONS, P as toSimpleStyle, Pt as DEFAULT_BREACH_OPTIONS, Q as OptionsByKind, Qt as GenericPolygonOptions, R as renderControlMeasure, Rt as FLOTOptions, S as pointOnMidpointPerpendicularAxis, Sn as AnchorTransformEvent, St as DEFAULT_ANTITANK_WALL_OPTIONS, T as BaselineFrameNormal, Tt as DEFAULT_DELAY_OPTIONS, U as controlMeasureIdFromFeature, Ut as AttackHelicopterOptions, V as FeaturePartProps, Vt as DEFAULT_SUPPORT_BY_FIRE_OPTIONS, W as ControlMeasure, Wt as DEFAULT_ATTACK_HELICOPTER_OPTIONS, X as ControlMeasureId, Xt as GenericRectangleOptions, Y as CONTROL_MEASURE_METADATA, Yt as DEFAULT_GENERIC_RECTANGLE_OPTIONS, Z as ControlMeasureKind, Zt as DEFAULT_GENERIC_POLYGON_OPTIONS, _ as blockDrawRule, _n as StrongPointOptions, _t as DEFAULT_FORTIFIED_AREA_OPTIONS, a as rectangleDrawRule, an as calculateMetrics, at as DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, b as createMidpointPerpendicularDrawRule, bn as ControlMeasureMetadata, bt as FortifiedLineOptions, c as line24DrawRule, cn as project, ct as ObstacleBypassEasyOptions, d as line1DrawRule, dn as EncirclementOptions, dt as DEFAULT_FIX_OPTIONS, en as GenericLineOptions, et as getControlMeasureMetadataByValue, f as ambushDrawRule, fn as DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, ft as FixOptions, g as disruptDrawRule, gn as DEFAULT_STRONG_POINT_OPTIONS, gt as DEFAULT_BLOCK_OPTIONS, h as centerRadiusDrawRule, hn as PrincipalDirectionOfFireOptions, ht as BlockOptions, i as DEFAULT_AMBUSH_OPTIONS, in as MainAttackOptions, it as ObstacleBypassImpossibleOptions, j as roundToFixed, jt as BypassOptions, k as EPSILON, kt as CanalizeOptions, l as line23DrawRule, ln as unproject, lt as DEFAULT_TURN_OPTIONS, m as point12DrawRule, mn as DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, mt as DisruptOptions, n as TacticalArrowOptions, nn as SupportingAttackOptions, nt as listControlMeasureMetadata, o as axis1DrawRule, on as computeInitialWidthPoint, ot as ObstacleBypassDifficultOptions, p as attackByFireDrawRule, pn as FinalProtectiveFireOptions, pt as DEFAULT_DISRUPT_OPTIONS, q as ControlMeasureStyle, qt as DEFAULT_GENERIC_CIRCLE_OPTIONS, r as AmbushOptions, rn as DEFAULT_MAIN_ATTACK_OPTIONS, rt as DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, s as supportByFireDrawRule, sn as Point2D, st as DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, t as DEFAULT_TACTICAL_ARROW_OPTIONS, tn as DEFAULT_SUPPORTING_ATTACK_OPTIONS, tt as getDefaultOptions, u as turnDrawRule, un as DEFAULT_ENCIRCLEMENT_OPTIONS, ut as TurnOptions, v as MidpointPerpendicularDrawRuleOptions, vn as ControlMeasureGeometry, vt as FortifiedAreaOptions, w as BaselineFrame, wt as DEFAULT_ANTITANK_DITCH_OPTIONS, x as getMidpointPerpendicularSignedDistance, xn as ParamDescriptor, xt as AntitankWallOptions, y as computeDefaultMidpointPerpendicularPoint, yn as ControlMeasureGeometryType, yt as DEFAULT_FORTIFIED_LINE_OPTIONS, z as ControlMeasureRender, zt as AttackByFireOptions } from "./index-DUGzYzPy.mjs";
+export { type AirborneAttackOptions, type AmbushOptions, type AnchorTransformEvent, type AntitankDitchOptions, type AntitankWallOptions, type AttackByFireOptions, type AttackHelicopterOptions, type BaselineFrame, type BaselineFrameNormal, type BaselineFrameOptions, type BaselineFrameOrigin, type BlockMissionTaskOptions, type BlockOptions, type BreachOptions, type BypassOptions, CONTROL_MEASURE_IDS, CONTROL_MEASURE_METADATA, type CanalizeOptions, type ClearOptions, type ControlMeasure, type ControlMeasureDrawRule, type ControlMeasureGeometry, type ControlMeasureGeometryType, type ControlMeasureId, type ControlMeasureKind, type ControlMeasureMetadata, type ControlMeasureRender, type ControlMeasureSnapshot, type ControlMeasureStyle, DEFAULT_AIRBORNE_ATTACK_OPTIONS, DEFAULT_AMBUSH_OPTIONS, DEFAULT_ANTITANK_DITCH_OPTIONS, DEFAULT_ANTITANK_WALL_OPTIONS, DEFAULT_ATTACK_BY_FIRE_OPTIONS, DEFAULT_ATTACK_HELICOPTER_OPTIONS, DEFAULT_BLOCK_MISSION_TASK_OPTIONS, DEFAULT_BLOCK_OPTIONS, DEFAULT_BREACH_OPTIONS, DEFAULT_BYPASS_OPTIONS, DEFAULT_CANALIZE_OPTIONS, DEFAULT_CLEAR_OPTIONS, DEFAULT_DELAY_OPTIONS, DEFAULT_DISRUPT_OPTIONS, DEFAULT_ENCIRCLEMENT_OPTIONS, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, DEFAULT_FIX_OPTIONS, DEFAULT_FLOT_OPTIONS, DEFAULT_FORTIFIED_AREA_OPTIONS, DEFAULT_FORTIFIED_LINE_OPTIONS, DEFAULT_GENERIC_CIRCLE_OPTIONS, DEFAULT_GENERIC_LINE_OPTIONS, DEFAULT_GENERIC_POLYGON_OPTIONS, DEFAULT_GENERIC_RECTANGLE_OPTIONS, DEFAULT_MAIN_ATTACK_OPTIONS, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, DEFAULT_STRONG_POINT_OPTIONS, DEFAULT_SUPPORTING_ATTACK_OPTIONS, DEFAULT_SUPPORT_BY_FIRE_OPTIONS, DEFAULT_TACTICAL_ARROW_OPTIONS, DEFAULT_TURN_OPTIONS, type DelayOptions, type DisruptOptions, EPSILON, type EncirclementOptions, type FLOTOptions, type FeaturePartProps, type FinalProtectiveFireOptions, type FixOptions, type FortifiedAreaOptions, type FortifiedLineOptions, type GenericCircleOptions, type GenericLineOptions, type GenericPolygonOptions, type GenericRectangleOptions, type MainAttackOptions, type MidpointPerpendicularDrawRuleOptions, type ObstacleBypassDifficultOptions, type ObstacleBypassEasyOptions, type ObstacleBypassImpossibleOptions, type OptionsByKind, type ParamDescriptor, type Point2D, type PrincipalDirectionOfFireOptions, type RenderOptions, type SimpleStyleProps, type SimpleStyleRender, type StrongPointOptions, type StyleHints, type SupportByFireOptions, type SupportingAttackOptions, type TacticalArrowOptions, type TurnOptions, ambushDrawRule, attackByFireDrawRule, axis1DrawRule, blockDrawRule, calculateMetrics, centerRadiusDrawRule, cloneControlMeasure, computeDefaultMidpointPerpendicularPoint, computeInitialWidthPoint, controlMeasureIdFromFeature, createBaselineFrame, createMidpointPerpendicularDrawRule, disruptDrawRule, freezeOrientationOptions, getControlMeasureMetadata, getControlMeasureMetadataByValue, getDefaultOptions, getMetersPerPixel, getMidpointPerpendicularSignedDistance, isKind, line1DrawRule, line23DrawRule, line24DrawRule, listControlMeasureMetadata, point12DrawRule, pointOnMidpointPerpendicularAxis, project, rectangleDrawRule, renderControlMeasure, resolveStyleHints, roundToFixed, snapToMidpointPerpendicular, supportByFireDrawRule, toSimpleStyle, turnDrawRule, unproject };

package/dist/index.mjs

@@ -1,4 +1,19 @@
-import { $ as getMidpointPerpendicularSignedDistance, A as DEFAULT_BYPASS_OPTIONS, B as axis1DrawRule, C as DEFAULT_FIX_OPTIONS, D as DEFAULT_DELAY_OPTIONS, E as DEFAULT_DISRUPT_OPTIONS, F as DEFAULT_ATTACK_BY_FIRE_OPTIONS, G as line1DrawRule, H as line24DrawRule, I as DEFAULT_ANTITANK_WALL_OPTIONS, J as point12DrawRule, K as ambushDrawRule, L as DEFAULT_ANTITANK_DITCH_OPTIONS, M as DEFAULT_BLOCK_MISSION_TASK_OPTIONS, N as DEFAULT_BLOCK_OPTIONS, O as DEFAULT_CLEAR_OPTIONS, P as DEFAULT_ATTACK_HELICOPTER_OPTIONS, Q as createMidpointPerpendicularDrawRule, R as DEFAULT_AMBUSH_OPTIONS, S as DEFAULT_FLOT_OPTIONS, T as DEFAULT_ENCIRCLEMENT_OPTIONS, U as line23DrawRule, V as supportByFireDrawRule, W as turnDrawRule, X as blockDrawRule, Y as disruptDrawRule, Z as computeDefaultMidpointPerpendicularPoint, _ as DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, at as project, b as DEFAULT_FORTIFIED_AREA_OPTIONS, c as getDefaultOptions, ct as getMetersPerPixel, d as DEFAULT_SUPPORTING_ATTACK_OPTIONS, et as pointOnMidpointPerpendicularAxis, f as DEFAULT_SUPPORT_BY_FIRE_OPTIONS, g as DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, h as DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, i as CONTROL_MEASURE_METADATA, it as computeInitialWidthPoint, j as DEFAULT_BREACH_OPTIONS, k as DEFAULT_CANALIZE_OPTIONS, l as listControlMeasureMetadata, lt as roundToFixed, m as DEFAULT_TACTICAL_ARROW_OPTIONS, n as resolveStyleHints, nt as createBaselineFrame, o as getControlMeasureMetadata, ot as unproject, p as DEFAULT_STRONG_POINT_OPTIONS, q as attackByFireDrawRule, r as CONTROL_MEASURE_IDS, rt as calculateMetrics, s as getControlMeasureMetadataByValue, st as EPSILON, t as renderControlMeasure, tt as snapToMidpointPerpendicular, u as DEFAULT_TURN_OPTIONS, v as DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, w as DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, x as DEFAULT_FORTIFIED_LINE_OPTIONS, y as DEFAULT_MAIN_ATTACK_OPTIONS, z as DEFAULT_AIRBORNE_ATTACK_OPTIONS } from "./renderControlMeasure-CONa8M6M.mjs";
+import { $ as point12DrawRule, A as DEFAULT_GENERIC_POLYGON_OPTIONS, B as DEFAULT_ANTITANK_WALL_OPTIONS, C as DEFAULT_FIX_OPTIONS, D as DEFAULT_DELAY_OPTIONS, E as DEFAULT_DISRUPT_OPTIONS, F as DEFAULT_BREACH_OPTIONS, G as axis1DrawRule, H as DEFAULT_AMBUSH_OPTIONS, I as DEFAULT_BLOCK_MISSION_TASK_OPTIONS, J as line23DrawRule, K as supportByFireDrawRule, L as DEFAULT_BLOCK_OPTIONS, M as DEFAULT_GENERIC_CIRCLE_OPTIONS, N as DEFAULT_CANALIZE_OPTIONS, O as DEFAULT_CLEAR_OPTIONS, P as DEFAULT_BYPASS_OPTIONS, Q as attackByFireDrawRule, R as DEFAULT_ATTACK_HELICOPTER_OPTIONS, S as DEFAULT_FLOT_OPTIONS, T as DEFAULT_ENCIRCLEMENT_OPTIONS, U as DEFAULT_AIRBORNE_ATTACK_OPTIONS, V as DEFAULT_ANTITANK_DITCH_OPTIONS, W as rectangleDrawRule, X as line1DrawRule, Y as turnDrawRule, Z as ambushDrawRule, _ as DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, a as DEFINITIONS, at as getMidpointPerpendicularSignedDistance, b as DEFAULT_FORTIFIED_AREA_OPTIONS, c as getDefaultOptions, ct as createBaselineFrame, d as DEFAULT_SUPPORTING_ATTACK_OPTIONS, dt as project, et as centerRadiusDrawRule, f as DEFAULT_SUPPORT_BY_FIRE_OPTIONS, ft as unproject, g as DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, h as DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, ht as roundToFixed, i as CONTROL_MEASURE_METADATA, it as createMidpointPerpendicularDrawRule, j as DEFAULT_GENERIC_LINE_OPTIONS, k as DEFAULT_GENERIC_RECTANGLE_OPTIONS, l as listControlMeasureMetadata, lt as calculateMetrics, m as DEFAULT_TACTICAL_ARROW_OPTIONS, mt as getMetersPerPixel, n as resolveStyleHints, nt as blockDrawRule, o as getControlMeasureMetadata, ot as pointOnMidpointPerpendicularAxis, p as DEFAULT_STRONG_POINT_OPTIONS, pt as EPSILON, q as line24DrawRule, r as CONTROL_MEASURE_IDS, rt as computeDefaultMidpointPerpendicularPoint, s as getControlMeasureMetadataByValue, st as snapToMidpointPerpendicular, t as renderControlMeasure, tt as disruptDrawRule, u as DEFAULT_TURN_OPTIONS, ut as computeInitialWidthPoint, v as DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, w as DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, x as DEFAULT_FORTIFIED_LINE_OPTIONS, y as DEFAULT_MAIN_ATTACK_OPTIONS, z as DEFAULT_ATTACK_BY_FIRE_OPTIONS } from "./renderControlMeasure-D5NKuws0.mjs";
+//#region src/freeze-orientation.ts
+/**
+* Dispatches to a measure kind's `freezeOrientation` hook (see
+* {@link import("./define").ControlMeasureDefinition.freezeOrientation}),
+* pinning orientation-derived option defaults to their current concrete
+* values ahead of a rigid rotation of `controlPoints`. Returns `undefined`
+* when the kind declares no hook, or when the hook itself finds nothing to
+* freeze. Edit hosts call this when a rotate gesture starts (ADR-0023).
+*/
+function freezeOrientationOptions(kind, controlPoints, options) {
+	const definition = DEFINITIONS[kind];
+	if (!definition.freezeOrientation) return void 0;
+	return definition.freezeOrientation(controlPoints, options ?? {});
+}
+//#endregion
 //#region src/instance.ts
 function isKind(cm, kind) {
 	return cm.kind === kind;
@@ -99,4 +114,4 @@ function toHexChannel(value) {
 	return Math.max(0, Math.min(255, Math.round(value))).toString(16).padStart(2, "0");
 }
 //#endregion
-export { CONTROL_MEASURE_IDS, CONTROL_MEASURE_METADATA, DEFAULT_AIRBORNE_ATTACK_OPTIONS, DEFAULT_AMBUSH_OPTIONS, DEFAULT_ANTITANK_DITCH_OPTIONS, DEFAULT_ANTITANK_WALL_OPTIONS, DEFAULT_ATTACK_BY_FIRE_OPTIONS, DEFAULT_ATTACK_HELICOPTER_OPTIONS, DEFAULT_BLOCK_MISSION_TASK_OPTIONS, DEFAULT_BLOCK_OPTIONS, DEFAULT_BREACH_OPTIONS, DEFAULT_BYPASS_OPTIONS, DEFAULT_CANALIZE_OPTIONS, DEFAULT_CLEAR_OPTIONS, DEFAULT_DELAY_OPTIONS, DEFAULT_DISRUPT_OPTIONS, DEFAULT_ENCIRCLEMENT_OPTIONS, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, DEFAULT_FIX_OPTIONS, DEFAULT_FLOT_OPTIONS, DEFAULT_FORTIFIED_AREA_OPTIONS, DEFAULT_FORTIFIED_LINE_OPTIONS, DEFAULT_MAIN_ATTACK_OPTIONS, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, DEFAULT_STRONG_POINT_OPTIONS, DEFAULT_SUPPORTING_ATTACK_OPTIONS, DEFAULT_SUPPORT_BY_FIRE_OPTIONS, DEFAULT_TACTICAL_ARROW_OPTIONS, DEFAULT_TURN_OPTIONS, EPSILON, ambushDrawRule, attackByFireDrawRule, axis1DrawRule, blockDrawRule, calculateMetrics, cloneControlMeasure, computeDefaultMidpointPerpendicularPoint, computeInitialWidthPoint, controlMeasureIdFromFeature, createBaselineFrame, createMidpointPerpendicularDrawRule, disruptDrawRule, getControlMeasureMetadata, getControlMeasureMetadataByValue, getDefaultOptions, getMetersPerPixel, getMidpointPerpendicularSignedDistance, isKind, line1DrawRule, line23DrawRule, line24DrawRule, listControlMeasureMetadata, point12DrawRule, pointOnMidpointPerpendicularAxis, project, renderControlMeasure, resolveStyleHints, roundToFixed, snapToMidpointPerpendicular, supportByFireDrawRule, toSimpleStyle, turnDrawRule, unproject };
+export { CONTROL_MEASURE_IDS, CONTROL_MEASURE_METADATA, DEFAULT_AIRBORNE_ATTACK_OPTIONS, DEFAULT_AMBUSH_OPTIONS, DEFAULT_ANTITANK_DITCH_OPTIONS, DEFAULT_ANTITANK_WALL_OPTIONS, DEFAULT_ATTACK_BY_FIRE_OPTIONS, DEFAULT_ATTACK_HELICOPTER_OPTIONS, DEFAULT_BLOCK_MISSION_TASK_OPTIONS, DEFAULT_BLOCK_OPTIONS, DEFAULT_BREACH_OPTIONS, DEFAULT_BYPASS_OPTIONS, DEFAULT_CANALIZE_OPTIONS, DEFAULT_CLEAR_OPTIONS, DEFAULT_DELAY_OPTIONS, DEFAULT_DISRUPT_OPTIONS, DEFAULT_ENCIRCLEMENT_OPTIONS, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, DEFAULT_FIX_OPTIONS, DEFAULT_FLOT_OPTIONS, DEFAULT_FORTIFIED_AREA_OPTIONS, DEFAULT_FORTIFIED_LINE_OPTIONS, DEFAULT_GENERIC_CIRCLE_OPTIONS, DEFAULT_GENERIC_LINE_OPTIONS, DEFAULT_GENERIC_POLYGON_OPTIONS, DEFAULT_GENERIC_RECTANGLE_OPTIONS, DEFAULT_MAIN_ATTACK_OPTIONS, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, DEFAULT_STRONG_POINT_OPTIONS, DEFAULT_SUPPORTING_ATTACK_OPTIONS, DEFAULT_SUPPORT_BY_FIRE_OPTIONS, DEFAULT_TACTICAL_ARROW_OPTIONS, DEFAULT_TURN_OPTIONS, EPSILON, ambushDrawRule, attackByFireDrawRule, axis1DrawRule, blockDrawRule, calculateMetrics, centerRadiusDrawRule, cloneControlMeasure, computeDefaultMidpointPerpendicularPoint, computeInitialWidthPoint, controlMeasureIdFromFeature, createBaselineFrame, createMidpointPerpendicularDrawRule, disruptDrawRule, freezeOrientationOptions, getControlMeasureMetadata, getControlMeasureMetadataByValue, getDefaultOptions, getMetersPerPixel, getMidpointPerpendicularSignedDistance, isKind, line1DrawRule, line23DrawRule, line24DrawRule, listControlMeasureMetadata, point12DrawRule, pointOnMidpointPerpendicularAxis, project, rectangleDrawRule, renderControlMeasure, resolveStyleHints, roundToFixed, snapToMidpointPerpendicular, supportByFireDrawRule, toSimpleStyle, turnDrawRule, unproject };

package/dist/preview/index.d.mts

@@ -1,4 +1,4 @@
-import { q as ControlMeasureId } from "../index-BJYbQlzo.mjs";
+import { X as ControlMeasureId } from "../index-DUGzYzPy.mjs";
 import { FeatureCollection, Geometry } from "geojson";
 
 //#region src/preview/index.d.ts

package/dist/preview/index.mjs

@@ -1,4 +1,4 @@
-import { a as DEFINITIONS, t as renderControlMeasure } from "../renderControlMeasure-CONa8M6M.mjs";
+import { a as DEFINITIONS, t as renderControlMeasure } from "../renderControlMeasure-D5NKuws0.mjs";
 //#region src/preview/index.ts
 /**
 * Unitless `previewSample` points (~`[-1, 1]`) are scaled by this degree offset

package/dist/{renderControlMeasure-CONa8M6M.mjs → renderControlMeasure-D5NKuws0.mjs}

@@ -484,7 +484,7 @@ function samePosition(a, b) {
 }
 //#endregion
 //#region src/draw-rules/area1.ts
-function derive$7(points) {
+function derive$8(points) {
 	return clonePositions(points);
 }
 /**
@@ -503,9 +503,10 @@ function derive$7(points) {
 const area1DrawRule = {
 	id: "area1",
 	minimumUserPoints: 3,
-	derive: derive$7,
+	closedRing: true,
+	derive: derive$8,
 	transform(event) {
-		return derive$7(event.next);
+		return derive$8(event.next);
 	}
 };
 //#endregion
@@ -531,14 +532,14 @@ const disruptDrawRule = createMidpointPerpendicularDrawRule({
 * that fixes both the radius and the bearing of the symbol's opening. Both
 * points are user-clicked, so the canonical array is just the (clamped) input.
 */
-function derive$6(points) {
+function derive$7(points) {
 	return clonePositions(points.slice(0, 2));
 }
-const isolateDrawRule = {
-	id: "area15:isolate",
+const centerRadiusDrawRule = {
+	id: "area15:center-radius",
 	minimumUserPoints: 2,
 	canonicalPointCount: 2,
-	derive: derive$6,
+	derive: derive$7,
 	transform(event) {
 		const { previous, next, activePointIndex } = event;
 		if (activePointIndex === 0 && previous.length >= 2 && next.length >= 2) {
@@ -547,9 +548,11 @@ const isolateDrawRule = {
 			const origin = previous[1];
 			return [clonePosition(next[0]), [origin[0] + dx, origin[1] + dy]];
 		}
-		return derive$6(next);
+		return derive$7(next);
 	}
 };
+/** Backward-compatible doctrinal name for Area15's shared center-radius rule. */
+const isolateDrawRule = centerRadiusDrawRule;
 //#endregion
 //#region src/draw-rules/point12.ts
 /**
@@ -590,20 +593,20 @@ const ambushDrawRule = createMidpointPerpendicularDrawRule({
 });
 //#endregion
 //#region src/draw-rules/line1.ts
-function derive$5(points) {
+function derive$6(points) {
 	return clonePositions(points);
 }
 const line1DrawRule = {
 	id: "line1",
 	minimumUserPoints: 2,
-	derive: derive$5,
+	derive: derive$6,
 	transform(event) {
-		return derive$5(event.next);
+		return derive$6(event.next);
 	}
 };
 //#endregion
 //#region src/draw-rules/line3.ts
-function derive$4(points) {
+function derive$5(points) {
 	return clonePositions(points);
 }
 /**
@@ -618,23 +621,23 @@ const line3DrawRule = {
 	id: "line3",
 	minimumUserPoints: 3,
 	canonicalPointCount: 3,
-	derive: derive$4,
+	derive: derive$5,
 	transform(event) {
-		return derive$4(event.next);
+		return derive$5(event.next);
 	}
 };
 //#endregion
 //#region src/draw-rules/line9.ts
-function derive$3(points) {
+function derive$4(points) {
 	return clonePositions(points);
 }
 const line9DrawRule = {
 	id: "line9",
 	minimumUserPoints: 2,
 	canonicalPointCount: 2,
-	derive: derive$3,
+	derive: derive$4,
 	transform(event) {
-		return derive$3(event.next);
+		return derive$4(event.next);
 	}
 };
 //#endregion
@@ -740,7 +743,7 @@ const line24DrawRule = createMidpointPerpendicularDrawRule({
 });
 //#endregion
 //#region src/draw-rules/area8.ts
-function derive$2(points) {
+function derive$3(points) {
 	if (points.length < 2) return clonePositions(points);
 	if (points.length !== 2) return clonePositions(points.slice(0, 4));
 	const p1 = clonePosition(points[0]);
@@ -764,16 +767,16 @@ const supportByFireDrawRule = {
 	id: "area8:support-by-fire",
 	minimumUserPoints: 2,
 	canonicalPointCount: 4,
-	derive: derive$2,
+	derive: derive$3,
 	transform(event) {
 		const { next } = event;
 		if (next.length === 4) return clonePositions(next);
-		return derive$2(next);
+		return derive$3(next);
 	}
 };
 //#endregion
 //#region src/draw-rules/axis1.ts
-function derive$1(points) {
+function derive$2(points) {
 	if (points.length < 2) return clonePositions(points);
 	if (points.length === 2) {
 		const tip = clonePosition(points[0]);
@@ -811,10 +814,10 @@ const axis1DrawRule = {
 	id: "axis1",
 	minimumUserPoints: 2,
 	trailingFixedSlots: 1,
-	derive: derive$1,
+	derive: derive$2,
 	transform(event) {
 		const { previous, next, activePointIndex } = event;
-		if (next.length < 3 || previous.length < 3) return derive$1(next);
+		if (next.length < 3 || previous.length < 3) return derive$2(next);
 		if (!(activePointIndex === 0 || activePointIndex === 1)) return clonePositions(next);
 		const metrics = calculateMetrics(previous);
 		if (!metrics) return clonePositions(next);
@@ -825,7 +828,7 @@ const axis1DrawRule = {
 };
 //#endregion
 //#region src/draw-rules/area21.ts
-function derive(points) {
+function derive$1(points) {
 	if (points.length === 2) return clonePositions([
 		points[0],
 		points[1],
@@ -838,9 +841,99 @@ const searchAreaDrawRule = {
 	minimumUserPoints: 3,
 	minimumPreviewPoints: 2,
 	canonicalPointCount: 3,
+	derive: derive$1,
+	transform(event) {
+		return derive$1(event.next);
+	}
+};
+//#endregion
+//#region src/draw-rules/rectangle.ts
+/**
+* Oriented rectangle: P1 and P2 are adjacent corners and define the first
+* edge. P3 is the next corner, constrained to the perpendicular through P2.
+* The generator derives the fourth corner.
+*/
+function derive(points) {
+	if (points.length < 2) return clonePositions(points);
+	const p1 = clonePosition(points[0]);
+	const p2 = clonePosition(points[1]);
+	if (points.length === 2) return [
+		p1,
+		p2,
+		clonePosition(p2)
+	];
+	const frame = createBaselineFrame(p1, p2, {
+		origin: "p2",
+		normal: "right"
+	});
+	return [
+		p1,
+		p2,
+		frame?.pointAtNormalDistance(frame.signedNormalDistance(points[2])) ?? clonePosition(points[2])
+	];
+}
+function guidePoints(points) {
+	const canonical = derive(points);
+	if (canonical.length < 3) return canonical;
+	const [c1, c2, c3] = canonical;
+	if (!c1 || !c2 || !c3) return canonical;
+	if (c2[0] === c3[0] && c2[1] === c3[1]) return [c1, c2];
+	const p1 = project(c1[0], c1[1]);
+	const p2 = project(c2[0], c2[1]);
+	const p4 = vecAdd(p1, vecSub(project(c3[0], c3[1]), p2));
+	return [
+		c1,
+		c2,
+		c3,
+		unproject(p4[0], p4[1]),
+		clonePosition(c1)
+	];
+}
+function snapToAxis(point, origin, direction) {
+	const snapped = vecAdd(origin, vecScale(direction, vecDot(vecSub(project(point[0], point[1]), origin), direction)));
+	return unproject(snapped[0], snapped[1]);
+}
+const rectangleDrawRule = {
+	id: "rectangle",
+	minimumUserPoints: 3,
+	minimumPreviewPoints: 2,
+	canonicalPointCount: 3,
+	showGuide: true,
+	guidePoints,
 	derive,
 	transform(event) {
-		return derive(event.next);
+		const { previous, next, activePointIndex } = event;
+		if (previous.length < 3 || next.length < 3) return derive(next);
+		const frame = createBaselineFrame(previous[0], previous[1], {
+			origin: "p2",
+			normal: "right"
+		});
+		if (!frame) return derive(next);
+		if (activePointIndex === 0) return [
+			snapToAxis(next[0], frame.p2, frame.direction),
+			clonePosition(previous[1]),
+			clonePosition(previous[2])
+		];
+		if (activePointIndex === 1) {
+			const p2 = snapToAxis(next[1], frame.p1, frame.direction);
+			const delta = vecSub(project(p2[0], p2[1]), frame.p2);
+			const projectedP3 = vecAdd(project(previous[2][0], previous[2][1]), delta);
+			const p3 = unproject(projectedP3[0], projectedP3[1]);
+			return [
+				clonePosition(previous[0]),
+				p2,
+				p3
+			];
+		}
+		if (activePointIndex === 2) {
+			const p3 = frame.pointAtNormalDistance(frame.signedNormalDistance(next[2]));
+			if (p3) return [
+				clonePosition(previous[0]),
+				clonePosition(previous[1]),
+				p3
+			];
+		}
+		return derive(next);
 	}
 };
 //#endregion
@@ -2330,13 +2423,21 @@ function resolveEchelonHeight(echelonSize, echelonSizePixels, metersPerPixel) {
 	if (echelonSizePixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0) h = echelonSizePixels * metersPerPixel;
 	return Math.max(EPSILON, h);
 }
+/** Wraps `x` into `[0, 1)`, treating `x` as a fraction (matches the arc-length wrap below). */
+function wrap01(x) {
+	return (x % 1 + 1) % 1;
+}
 /**
 * Places the Field B echelon glyph on the perimeter and computes its masking
-* gap, anchored to the bottom edge and slid by `echelonPosition` (a signed
-* fraction of the perimeter, wrapping at the seam). Returns empty geometry
-* when the echelon resolves to none or the ring is degenerate.
+* gap, anchored by default to the bottom edge and slid by `echelonPosition`
+* (a signed fraction of the perimeter, wrapping at the seam). When
+* `echelonAnchor` is supplied, it replaces the bottom-edge anchor with an
+* absolute perimeter fraction (measured from the ring seam) — see
+* `BattlePositionOptions.echelonAnchor` for why (ADR-0023 rotate-freeze).
+* Returns empty geometry when the echelon resolves to none or the ring is
+* degenerate.
 */
-function placeEchelon(perimeter, h, echelon, echelonPadding, echelonPosition) {
+function placeEchelon(perimeter, h, echelon, echelonPadding, echelonPosition, echelonAnchor) {
 	const { segs, totalLength, anchorTarget } = perimeter;
 	const spec = resolveEchelon(echelon);
 	if (!spec || segs.length === 0 || totalLength < 1e-6) return {
@@ -2344,7 +2445,7 @@ function placeEchelon(perimeter, h, echelon, echelonPadding, echelonPosition) {
 		fills: [],
 		gaps: []
 	};
-	const target = ((anchorTarget + echelonPosition * totalLength) % totalLength + totalLength) % totalLength;
+	const target = (((echelonAnchor !== void 0 ? wrap01(echelonAnchor) * totalLength : anchorTarget) + echelonPosition * totalLength) % totalLength + totalLength) % totalLength;
 	const { point, seg } = pointOnRing(segs, target);
 	const { strokes, fills, width } = buildEchelonGlyph(point, seg.along, seg.perp, h, spec);
 	const gaps = [];
@@ -2454,10 +2555,10 @@ const BATTLE_POSITION_METADATA = {
 * @param options - {@link BattlePositionOptions}.
 */
 function createBattlePosition(positions, options = {}) {
-	const { echelon = DEFAULT_BATTLE_POSITION_OPTIONS.echelon, echelonSize = DEFAULT_BATTLE_POSITION_OPTIONS.echelonSize, echelonSizePixels, echelonPadding = DEFAULT_BATTLE_POSITION_OPTIONS.echelonPadding, echelonPosition = DEFAULT_BATTLE_POSITION_OPTIONS.echelonPosition, metersPerPixel, smooth = DEFAULT_BATTLE_POSITION_OPTIONS.smooth, smoothResolution = DEFAULT_BATTLE_POSITION_OPTIONS.smoothResolution } = options;
+	const { echelon = DEFAULT_BATTLE_POSITION_OPTIONS.echelon, echelonSize = DEFAULT_BATTLE_POSITION_OPTIONS.echelonSize, echelonSizePixels, echelonPadding = DEFAULT_BATTLE_POSITION_OPTIONS.echelonPadding, echelonPosition = DEFAULT_BATTLE_POSITION_OPTIONS.echelonPosition, echelonAnchor, metersPerPixel, smooth = DEFAULT_BATTLE_POSITION_OPTIONS.smooth, smoothResolution = DEFAULT_BATTLE_POSITION_OPTIONS.smoothResolution } = options;
 	const h = resolveEchelonHeight(echelonSize, echelonSizePixels, metersPerPixel);
 	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION$6);
-	const { strokes, fills, gaps } = placeEchelon(buildAreaPerimeter(verts), h, echelon, echelonPadding, echelonPosition);
+	const { strokes, fills, gaps } = placeEchelon(buildAreaPerimeter(verts), h, echelon, echelonPadding, echelonPosition, echelonAnchor);
 	const boundaryCoords = buildGappedLine(verts, gaps);
 	const features = [];
 	if (boundaryCoords.length > 0) features.push({
@@ -2492,11 +2593,29 @@ function createBattlePosition(positions, options = {}) {
 		features
 	};
 }
+/**
+* `freezeOrientation` hook (ADR-0023) shared by Battle Position and Strong
+* Point: pins the echelon anchor to its current bottom-edge fraction so a
+* subsequent rigid rotation of `controlPoints` (e.g. the transform box's
+* rotate grip) does not re-derive a different "bottom edge" against the
+* rotated geometry. Returns `undefined` — nothing to freeze — when:
+*  - `echelonAnchor` is already set (previously frozen or user-authored), or
+*  - the echelon resolves to none (nothing visible to pin), or
+*  - the ring is degenerate (no segments, or a near-zero perimeter).
+*/
+function freezeEchelonAnchor(controlPoints, options) {
+	if (options.echelonAnchor !== void 0) return void 0;
+	if (!resolveEchelon(options.echelon ?? DEFAULT_BATTLE_POSITION_OPTIONS.echelon)) return void 0;
+	const perimeter = buildAreaPerimeter(buildClosedRing(controlPoints, options.smooth ?? DEFAULT_BATTLE_POSITION_OPTIONS.smooth, options.smoothResolution ?? DEFAULT_BATTLE_POSITION_OPTIONS.smoothResolution, DEFAULT_SMOOTH_RESOLUTION$6));
+	if (perimeter.segs.length === 0 || perimeter.totalLength < 1e-6) return void 0;
+	return { echelonAnchor: perimeter.anchorTarget / perimeter.totalLength };
+}
 const BATTLE_POSITION = defineControlMeasure({
 	metadata: BATTLE_POSITION_METADATA,
 	generator: createBattlePosition,
 	defaultOptions: DEFAULT_BATTLE_POSITION_OPTIONS,
 	rule: area1DrawRule,
+	freezeOrientation: freezeEchelonAnchor,
 	previewSample: {
 		controlPoints: [
 			[-1, -.5],
@@ -2594,7 +2713,7 @@ const BLOCK_ARROW_METADATA = {
 	id: "block-arrow",
 	name: "Block Arrow",
 	description: "Solid filled arrow with a controllable shaft width and selectable head (triangle, barbed, concave, diamond, harpoon, swallowtail, tee). Not a doctrinal symbol.",
-	entity: "Generic Arrows",
+	entity: "Generic Graphics",
 	entityType: "Illustrative Arrow",
 	entitySubtype: "Block Arrow",
 	value: "990001",
@@ -3622,7 +3741,7 @@ const CLASSIC_ARROW_METADATA = {
 	id: "classic-arrow",
 	name: "Classic Arrow",
 	description: "Clean straight arrow with a selectable head (triangle, barbed, concave, diamond, harpoon, swallowtail, chevron, circle, tee, open). Not a doctrinal symbol.",
-	entity: "Generic Arrows",
+	entity: "Generic Graphics",
 	entityType: "Illustrative Arrow",
 	entitySubtype: "Classic Arrow",
 	value: "990002",
@@ -3905,6 +4024,271 @@ function normalizeSmoothResolution(value) {
 	return Math.min(MAX_SMOOTH_RESOLUTION, Math.max(MIN_SMOOTH_RESOLUTION, Math.round(value)));
 }
 //#endregion
+//#region src/generators/cm99-generic-graphics/params.ts
+const SMOOTH_PATH_PARAMS = [{
+	key: "smooth",
+	label: "Smooth",
+	description: "Curve the path through the control points.",
+	type: "boolean"
+}, {
+	key: "smoothResolution",
+	label: "Smooth resolution",
+	description: "Number of samples per segment when smooth mode is enabled.",
+	type: "number",
+	min: 2,
+	max: 64,
+	step: 1,
+	visibleWhen: (opts) => Boolean(opts.smooth)
+}];
+const FILLED_AREA_PARAMS = [{
+	key: "filled",
+	label: "Filled",
+	description: "Fill the interior instead of rendering an outline only.",
+	type: "boolean"
+}];
+//#endregion
+//#region src/generators/cm99-generic-graphics/circle.ts
+const CIRCLE_SEGMENTS = 64;
+const DEFAULT_GENERIC_CIRCLE_OPTIONS = { filled: false };
+const GENERIC_CIRCLE_METADATA = {
+	id: "circle",
+	name: "Circle",
+	description: "A non-doctrinal circle defined by a center and radius point.",
+	entity: "Generic Graphics",
+	entityType: "Basic Shape",
+	entitySubtype: "Circle",
+	value: "990104",
+	minCoordinates: 2,
+	maxCoordinates: 2,
+	geometry: "area",
+	geometryTypes: ["Polygon"],
+	drawRule: "Area15",
+	params: FILLED_AREA_PARAMS
+};
+function createGenericCircle(coordinates, options = {}) {
+	const center = project(coordinates[0][0], coordinates[0][1]);
+	const radiusVector = vecSub(project(coordinates[1][0], coordinates[1][1]), center);
+	const radius = vecMag(radiusVector);
+	if (radius < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const startAngle = Math.atan2(radiusVector[1], radiusVector[0]);
+	const ring = [];
+	for (let index = 0; index <= CIRCLE_SEGMENTS; index++) {
+		const angle = startAngle + index / CIRCLE_SEGMENTS * Math.PI * 2;
+		ring.push(unproject(center[0] + Math.cos(angle) * radius, center[1] + Math.sin(angle) * radius));
+	}
+	return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: {
+				part: "circle",
+				fill: options.filled ?? DEFAULT_GENERIC_CIRCLE_OPTIONS.filled
+			},
+			geometry: {
+				type: "Polygon",
+				coordinates: [ring]
+			}
+		}]
+	};
+}
+const GENERIC_CIRCLE = defineControlMeasure({
+	metadata: GENERIC_CIRCLE_METADATA,
+	generator: createGenericCircle,
+	defaultOptions: DEFAULT_GENERIC_CIRCLE_OPTIONS,
+	rule: centerRadiusDrawRule,
+	previewSample: { controlPoints: [[0, 0], [.8, 0]] }
+});
+//#endregion
+//#region src/generators/cm99-generic-graphics/line.ts
+const DEFAULT_GENERIC_LINE_OPTIONS = {
+	smooth: false,
+	smoothResolution: 12
+};
+const GENERIC_LINE_METADATA = {
+	id: "line",
+	name: "Line",
+	description: "A non-doctrinal free polyline through two or more control points.",
+	entity: "Generic Graphics",
+	entityType: "Basic Shape",
+	entitySubtype: "Line",
+	value: "990101",
+	minCoordinates: 2,
+	geometry: "line",
+	geometryTypes: ["LineString"],
+	drawRule: "Line1",
+	params: SMOOTH_PATH_PARAMS
+};
+function createGenericLine(coordinates, options = {}) {
+	const projected = coordinates.map((point) => project(point[0], point[1]));
+	if (!projected.some((point, index) => {
+		const next = projected[index + 1];
+		return next ? Math.hypot(next[0] - point[0], next[1] - point[1]) >= 1e-6 : false;
+	})) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const { smooth, smoothResolution } = {
+		...DEFAULT_GENERIC_LINE_OPTIONS,
+		...options
+	};
+	const resolution = normalizeSmoothResolution$2(smoothResolution, 12);
+	return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: { part: "line" },
+			geometry: {
+				type: "LineString",
+				coordinates: (smooth ? catmullRom(projected, resolution) : projected).map((point) => unproject(point[0], point[1]))
+			}
+		}]
+	};
+}
+const GENERIC_LINE = defineControlMeasure({
+	metadata: GENERIC_LINE_METADATA,
+	generator: createGenericLine,
+	defaultOptions: DEFAULT_GENERIC_LINE_OPTIONS,
+	rule: line1DrawRule,
+	previewSample: { controlPoints: [
+		[-1, -.4],
+		[0, .5],
+		[1, -.2]
+	] }
+});
+//#endregion
+//#region src/generators/cm99-generic-graphics/polygon.ts
+const DEFAULT_GENERIC_POLYGON_OPTIONS = {
+	smooth: false,
+	smoothResolution: 12,
+	filled: false
+};
+const GENERIC_POLYGON_METADATA = {
+	id: "polygon",
+	name: "Polygon",
+	description: "A non-doctrinal free polygon with one outer ring.",
+	entity: "Generic Graphics",
+	entityType: "Basic Shape",
+	entitySubtype: "Polygon",
+	value: "990102",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: ["Polygon"],
+	drawRule: "Area1",
+	params: [...SMOOTH_PATH_PARAMS, ...FILLED_AREA_PARAMS]
+};
+function createGenericPolygon(coordinates, options = {}) {
+	const projected = coordinates.map((point) => project(point[0], point[1]));
+	const ringPoints = projected.length > 1 && vecMag(vecSub(projected[0], projected.at(-1))) < 1e-6 ? projected.slice(0, -1) : projected;
+	if (ringPoints.length < 3) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const { smooth, smoothResolution, filled } = {
+		...DEFAULT_GENERIC_POLYGON_OPTIONS,
+		...options
+	};
+	const resolution = normalizeSmoothResolution$2(smoothResolution, 12);
+	const ring = smooth ? closedCatmullRom(ringPoints, resolution) : [...ringPoints, ringPoints[0]];
+	return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: {
+				part: "polygon",
+				fill: filled
+			},
+			geometry: {
+				type: "Polygon",
+				coordinates: [ring.map((point) => unproject(point[0], point[1]))]
+			}
+		}]
+	};
+}
+const GENERIC_POLYGON = defineControlMeasure({
+	metadata: GENERIC_POLYGON_METADATA,
+	generator: createGenericPolygon,
+	defaultOptions: DEFAULT_GENERIC_POLYGON_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: { controlPoints: [
+		[-.9, -.7],
+		[.8, -.6],
+		[1, .5],
+		[-.4, .8]
+	] }
+});
+//#endregion
+//#region src/generators/cm99-generic-graphics/rectangle.ts
+const DEFAULT_GENERIC_RECTANGLE_OPTIONS = { filled: false };
+const GENERIC_RECTANGLE_METADATA = {
+	id: "rectangle",
+	name: "Rectangle",
+	description: "A non-doctrinal oriented rectangle defined by three adjacent corners.",
+	entity: "Generic Graphics",
+	entityType: "Basic Shape",
+	entitySubtype: "Rectangle",
+	value: "990103",
+	minCoordinates: 3,
+	maxCoordinates: 3,
+	geometry: "area",
+	geometryTypes: ["Polygon"],
+	drawRule: "Rectangle",
+	params: FILLED_AREA_PARAMS
+};
+function createGenericRectangle(coordinates, options = {}) {
+	const [c1, c2, c3] = rectangleDrawRule.derive(coordinates);
+	if (!c1 || !c2 || !c3) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const p1 = project(c1[0], c1[1]);
+	const p2 = project(c2[0], c2[1]);
+	const p3 = project(c3[0], c3[1]);
+	if (Math.hypot(p2[0] - p1[0], p2[1] - p1[1]) < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const fill = options.filled ?? DEFAULT_GENERIC_RECTANGLE_OPTIONS.filled;
+	if (Math.hypot(p3[0] - p2[0], p3[1] - p2[1]) < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const ring = [
+		p1,
+		p2,
+		p3,
+		[p1[0] + p3[0] - p2[0], p1[1] + p3[1] - p2[1]],
+		p1
+	].map((point) => unproject(point[0], point[1]));
+	return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: {
+				part: "rectangle",
+				fill
+			},
+			geometry: {
+				type: "Polygon",
+				coordinates: [ring]
+			}
+		}]
+	};
+}
+const GENERIC_RECTANGLE = defineControlMeasure({
+	metadata: GENERIC_RECTANGLE_METADATA,
+	generator: createGenericRectangle,
+	defaultOptions: DEFAULT_GENERIC_RECTANGLE_OPTIONS,
+	rule: rectangleDrawRule,
+	previewSample: { controlPoints: [
+		[-.9, -.55],
+		[.9, -.55],
+		[.9, .55]
+	] }
+});
+//#endregion
 //#region src/generators/cm34-mission-tasks/clear.ts
 /**
 * Default options for the CLEAR symbol.
@@ -6248,11 +6632,11 @@ function buildStrongPointTics(perimeter, gaps, h) {
 * @param options - {@link StrongPointOptions}.
 */
 function createStrongPoint(positions, options = {}) {
-	const { echelon = DEFAULT_STRONG_POINT_OPTIONS.echelon, echelonSize = DEFAULT_STRONG_POINT_OPTIONS.echelonSize, echelonSizePixels, echelonPadding = DEFAULT_STRONG_POINT_OPTIONS.echelonPadding, echelonPosition = DEFAULT_STRONG_POINT_OPTIONS.echelonPosition, metersPerPixel, smooth = DEFAULT_STRONG_POINT_OPTIONS.smooth, smoothResolution = DEFAULT_STRONG_POINT_OPTIONS.smoothResolution } = options;
+	const { echelon = DEFAULT_STRONG_POINT_OPTIONS.echelon, echelonSize = DEFAULT_STRONG_POINT_OPTIONS.echelonSize, echelonSizePixels, echelonPadding = DEFAULT_STRONG_POINT_OPTIONS.echelonPadding, echelonPosition = DEFAULT_STRONG_POINT_OPTIONS.echelonPosition, echelonAnchor, metersPerPixel, smooth = DEFAULT_STRONG_POINT_OPTIONS.smooth, smoothResolution = DEFAULT_STRONG_POINT_OPTIONS.smoothResolution } = options;
 	const h = resolveEchelonHeight(echelonSize, echelonSizePixels, metersPerPixel);
 	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION);
 	const perimeter = buildAreaPerimeter(verts);
-	const { strokes, fills, gaps } = placeEchelon(perimeter, h, echelon, echelonPadding, echelonPosition);
+	const { strokes, fills, gaps } = placeEchelon(perimeter, h, echelon, echelonPadding, echelonPosition, echelonAnchor);
 	const boundaryCoords = buildGappedLine(verts, gaps);
 	const tics = buildStrongPointTics(perimeter, gaps, h);
 	const features = [];
@@ -6301,6 +6685,7 @@ const STRONG_POINT = defineControlMeasure({
 	generator: createStrongPoint,
 	defaultOptions: DEFAULT_STRONG_POINT_OPTIONS,
 	rule: area1DrawRule,
+	freezeOrientation: freezeEchelonAnchor,
 	previewSample: {
 		controlPoints: [
 			[-1, -.5],
@@ -6654,6 +7039,10 @@ const DEFINITIONS = {
 	"supporting-attack": SUPPORTING_ATTACK,
 	"classic-arrow": CLASSIC_ARROW,
 	"block-arrow": BLOCK_ARROW,
+	line: GENERIC_LINE,
+	polygon: GENERIC_POLYGON,
+	rectangle: GENERIC_RECTANGLE,
+	circle: GENERIC_CIRCLE,
 	"airborne-attack": AIRBORNE_ATTACK,
 	"attack-helicopter": ATTACK_HELICOPTER,
 	"support-by-fire": SUPPORT_BY_FIRE,
@@ -6904,4 +7293,4 @@ function assertNever(value) {
 	throw new Error(`Unhandled control measure kind: ${String(value)}`);
 }
 //#endregion
-export { getMidpointPerpendicularSignedDistance as $, DEFAULT_BYPASS_OPTIONS as A, axis1DrawRule as B, DEFAULT_FIX_OPTIONS as C, DEFAULT_DELAY_OPTIONS as D, DEFAULT_DISRUPT_OPTIONS as E, DEFAULT_ATTACK_BY_FIRE_OPTIONS as F, line1DrawRule as G, line24DrawRule as H, DEFAULT_ANTITANK_WALL_OPTIONS as I, point12DrawRule as J, ambushDrawRule as K, DEFAULT_ANTITANK_DITCH_OPTIONS as L, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as M, DEFAULT_BLOCK_OPTIONS as N, DEFAULT_CLEAR_OPTIONS as O, DEFAULT_ATTACK_HELICOPTER_OPTIONS as P, createMidpointPerpendicularDrawRule as Q, DEFAULT_AMBUSH_OPTIONS as R, DEFAULT_FLOT_OPTIONS as S, DEFAULT_ENCIRCLEMENT_OPTIONS as T, line23DrawRule as U, supportByFireDrawRule as V, turnDrawRule as W, blockDrawRule as X, disruptDrawRule as Y, computeDefaultMidpointPerpendicularPoint as Z, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as _, DEFINITIONS as a, project as at, DEFAULT_FORTIFIED_AREA_OPTIONS as b, getDefaultOptions as c, getMetersPerPixel as ct, DEFAULT_SUPPORTING_ATTACK_OPTIONS as d, pointOnMidpointPerpendicularAxis as et, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as f, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as g, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as h, CONTROL_MEASURE_METADATA as i, computeInitialWidthPoint as it, DEFAULT_BREACH_OPTIONS as j, DEFAULT_CANALIZE_OPTIONS as k, listControlMeasureMetadata as l, roundToFixed as lt, DEFAULT_TACTICAL_ARROW_OPTIONS as m, resolveStyleHints as n, createBaselineFrame as nt, getControlMeasureMetadata as o, unproject as ot, DEFAULT_STRONG_POINT_OPTIONS as p, attackByFireDrawRule as q, CONTROL_MEASURE_IDS as r, calculateMetrics as rt, getControlMeasureMetadataByValue as s, EPSILON as st, renderControlMeasure as t, snapToMidpointPerpendicular as tt, DEFAULT_TURN_OPTIONS as u, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as v, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as w, DEFAULT_FORTIFIED_LINE_OPTIONS as x, DEFAULT_MAIN_ATTACK_OPTIONS as y, DEFAULT_AIRBORNE_ATTACK_OPTIONS as z };
+export { point12DrawRule as $, DEFAULT_GENERIC_POLYGON_OPTIONS as A, DEFAULT_ANTITANK_WALL_OPTIONS as B, DEFAULT_FIX_OPTIONS as C, DEFAULT_DELAY_OPTIONS as D, DEFAULT_DISRUPT_OPTIONS as E, DEFAULT_BREACH_OPTIONS as F, axis1DrawRule as G, DEFAULT_AMBUSH_OPTIONS as H, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as I, line23DrawRule as J, supportByFireDrawRule as K, DEFAULT_BLOCK_OPTIONS as L, DEFAULT_GENERIC_CIRCLE_OPTIONS as M, DEFAULT_CANALIZE_OPTIONS as N, DEFAULT_CLEAR_OPTIONS as O, DEFAULT_BYPASS_OPTIONS as P, attackByFireDrawRule as Q, DEFAULT_ATTACK_HELICOPTER_OPTIONS as R, DEFAULT_FLOT_OPTIONS as S, DEFAULT_ENCIRCLEMENT_OPTIONS as T, DEFAULT_AIRBORNE_ATTACK_OPTIONS as U, DEFAULT_ANTITANK_DITCH_OPTIONS as V, rectangleDrawRule as W, line1DrawRule as X, turnDrawRule as Y, ambushDrawRule as Z, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as _, DEFINITIONS as a, getMidpointPerpendicularSignedDistance as at, DEFAULT_FORTIFIED_AREA_OPTIONS as b, getDefaultOptions as c, createBaselineFrame as ct, DEFAULT_SUPPORTING_ATTACK_OPTIONS as d, project as dt, centerRadiusDrawRule as et, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as f, unproject as ft, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as g, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as h, roundToFixed as ht, CONTROL_MEASURE_METADATA as i, createMidpointPerpendicularDrawRule as it, DEFAULT_GENERIC_LINE_OPTIONS as j, DEFAULT_GENERIC_RECTANGLE_OPTIONS as k, listControlMeasureMetadata as l, calculateMetrics as lt, DEFAULT_TACTICAL_ARROW_OPTIONS as m, getMetersPerPixel as mt, resolveStyleHints as n, blockDrawRule as nt, getControlMeasureMetadata as o, pointOnMidpointPerpendicularAxis as ot, DEFAULT_STRONG_POINT_OPTIONS as p, EPSILON as pt, line24DrawRule as q, CONTROL_MEASURE_IDS as r, computeDefaultMidpointPerpendicularPoint as rt, getControlMeasureMetadataByValue as s, snapToMidpointPerpendicular as st, renderControlMeasure as t, disruptDrawRule as tt, DEFAULT_TURN_OPTIONS as u, computeInitialWidthPoint as ut, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as v, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as w, DEFAULT_FORTIFIED_LINE_OPTIONS as x, DEFAULT_MAIN_ATTACK_OPTIONS as y, DEFAULT_ATTACK_BY_FIRE_OPTIONS as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbat-mapper/control-measures",
-  "version": "0.2.0-alpha.4",
+  "version": "0.2.0-alpha.6",
   "description": "Library for drawing tactical graphics and control measures according to MIL-STD-2525 and APP-6 standards.",
   "license": "MIT",
   "author": "Orbat Mapper",