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

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

@@ -339,6 +339,23 @@ interface BattlePositionOptions {
  */
 declare function createBattlePosition(positions: Position[], options?: BattlePositionOptions): FeatureCollection<MultiLineString | MultiPolygon>;
 //#endregion
+//#region src/generators/cm15-maneuver-areas/strongPoint.d.ts
+/** Configuration options for the Strong Point control measure. */
+type StrongPointOptions = BattlePositionOptions;
+/** Default options for the Strong Point control measure. */
+declare const DEFAULT_STRONG_POINT_OPTIONS: StrongPointOptions;
+/**
+ * Creates a Strong Point control measure: a Battle Position boundary/echelon
+ * with outward tics whose length and spacing are the Field B echelon height.
+ * Shares the perimeter and echelon placement with Battle Position via the
+ * `area-echelon` primitive (single source of truth for ring and gap).
+ *
+ * @param positions - Area anchor points (>=3); the input contract is enforced
+ *   at the render seam (ADR-0014).
+ * @param options - {@link StrongPointOptions}.
+ */
+declare function createStrongPoint(positions: Position[], options?: StrongPointOptions): FeatureCollection<MultiLineString | MultiPolygon>;
+//#endregion
 //#region src/generators/cm14-maneuver-lines/principalDirectionOfFire.d.ts
 /**
  * Configuration options for the Principal Direction of Fire tactical symbol.
@@ -390,6 +407,47 @@ type FpfProps = {
 declare function createFinalProtectiveFireLeft(coordinates: Position[], options?: FinalProtectiveFireOptions): FeatureCollection<MultiLineString | Polygon, FpfProps>;
 declare function createFinalProtectiveFireRight(coordinates: Position[], options?: FinalProtectiveFireOptions): FeatureCollection<MultiLineString | Polygon, FpfProps>;
 //#endregion
+//#region src/generators/cm15-maneuver-areas/encirclement.d.ts
+/** Configuration options for the Encirclement control measure. */
+interface EncirclementOptions {
+  /**
+   * Spacing between adjacent barbs as a ratio of the symbol's mean radius;
+   * smaller values pack the barbs more densely. The barbs are then distributed
+   * evenly so they close the ring exactly.
+   * @default 0.4
+   */
+  barbSpacingRatio?: number;
+  /**
+   * Barb length (height/amplitude) as a ratio of the symbol's mean radius.
+   * @default 0.16
+   */
+  barbLengthRatio?: number;
+  /**
+   * Round the boundary by curving it through the control points (closed
+   * centripetal Catmull-Rom) before tracing the barbs.
+   * @default true
+   */
+  smooth?: boolean;
+  /**
+   * Number of samples per segment when `smooth` is enabled.
+   * @default 16
+   */
+  smoothResolution?: number;
+}
+/** Default options for the Encirclement control measure. */
+declare const DEFAULT_ENCIRCLEMENT_OPTIONS: Required<EncirclementOptions>;
+/**
+ * Creates an Encirclement tactical graphic: a complete smooth boundary ring
+ * with outward arrowhead barbs resting on it. The boundary is an unfilled
+ * Polygon; the barbs are open "V" strokes (a MultiLineString) whose base is the
+ * boundary arc itself.
+ *
+ * @param positions - Area anchor points (>=3); the input contract is enforced
+ *   at the render seam (ADR-0014).
+ * @param options - {@link EncirclementOptions}.
+ */
+declare function createEncirclement(positions: Position[], options?: EncirclementOptions): FeatureCollection<Polygon | MultiLineString>;
+//#endregion
 //#region src/projection.d.ts
 type Point2D = [number, number];
 /**
@@ -1193,6 +1251,7 @@ declare function createObstacleBypassImpossible(coordinates: Position[], options
 declare const DEFINITIONS: {
   boundary: ControlMeasureDefinition<"boundary", typeof createBoundary>;
   "battle-position": ControlMeasureDefinition<"battle-position", typeof createBattlePosition>;
+  "strong-point": ControlMeasureDefinition<"strong-point", typeof createStrongPoint>;
   ambush: ControlMeasureDefinition<"ambush", (controlPoints: import("geojson").Position[], options?: AmbushOptions) => import("geojson").FeatureCollection<import("geojson").MultiLineString, Record<string, never>>>;
   "principal-direction-of-fire": ControlMeasureDefinition<"principal-direction-of-fire", typeof createPrincipalDirectionOfFire>;
   "final-protective-fire-left": ControlMeasureDefinition<"final-protective-fire-left", typeof createFinalProtectiveFireLeft>;
@@ -1201,6 +1260,7 @@ declare const DEFINITIONS: {
     part: "shaft" | "head";
     fill?: boolean;
   }>>;
+  encirclement: ControlMeasureDefinition<"encirclement", typeof createEncirclement>;
   "main-attack": ControlMeasureDefinition<"main-attack", typeof createMainAttack>;
   "supporting-attack": ControlMeasureDefinition<"supporting-attack", typeof createSupportingAttack>;
   "classic-arrow": ControlMeasureDefinition<"classic-arrow", typeof createClassicArrow>;
@@ -1650,4 +1710,4 @@ interface TacticalArrowOptions {
  */
 declare const DEFAULT_TACTICAL_ARROW_OPTIONS: Required<TacticalArrowOptions>;
 //#endregion
-export { listControlMeasureMetadata as $, DEFAULT_FINAL_PROTECTIVE_FIRE_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, ControlMeasureMetadata as an, ObstacleBypassEasyOptions as at, pointOnMidpointPerpendicularAxis as b, AntitankDitchOptions as bt, line23DrawRule as c, ControlMeasureDrawRule as cn, DEFAULT_FIX_OPTIONS as ct, ambushDrawRule as d, DisruptOptions as dt, FinalProtectiveFireOptions as en, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as et, attackByFireDrawRule as f, BlockOptions as ft, MidpointPerpendicularDrawRuleOptions as g, DEFAULT_FORTIFIED_LINE_OPTIONS as gt, blockDrawRule as h, FortifiedAreaOptions as ht, DEFAULT_AMBUSH_OPTIONS as i, ControlMeasureGeometryType 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, FixOptions as lt, disruptDrawRule as m, DEFAULT_FORTIFIED_AREA_OPTIONS as mt, TacticalArrowOptions as n, PrincipalDirectionOfFireOptions as nn, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as nt, supportByFireDrawRule as o, ParamDescriptor as on, DEFAULT_TURN_OPTIONS as ot, point12DrawRule as p, DEFAULT_BLOCK_OPTIONS as pt, ControlMeasureId as q, MainAttackOptions as qt, AmbushOptions as r, ControlMeasureGeometry as rn, ObstacleBypassDifficultOptions as rt, line24DrawRule as s, AnchorTransformEvent as sn, TurnOptions as st, DEFAULT_TACTICAL_ARROW_OPTIONS as t, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as tn, ObstacleBypassImpossibleOptions as tt, line1DrawRule as u, 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 { 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 };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { $ as listControlMeasureMetadata, $t as DEFAULT_FINAL_PROTECTIVE_FIRE_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 ControlMeasureMetadata, at as ObstacleBypassEasyOptions, b as pointOnMidpointPerpendicularAxis, bt as AntitankDitchOptions, c as line23DrawRule, cn as ControlMeasureDrawRule, ct as DEFAULT_FIX_OPTIONS, d as ambushDrawRule, dt as DisruptOptions, en as FinalProtectiveFireOptions, et as DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, f as attackByFireDrawRule, 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 ControlMeasureGeometryType, 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, lt as FixOptions, m as disruptDrawRule, mt as DEFAULT_FORTIFIED_AREA_OPTIONS, n as TacticalArrowOptions, nn as PrincipalDirectionOfFireOptions, nt as DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, o as supportByFireDrawRule, on as ParamDescriptor, ot as DEFAULT_TURN_OPTIONS, p as point12DrawRule, pt as DEFAULT_BLOCK_OPTIONS, q as ControlMeasureId, qt as MainAttackOptions, r as AmbushOptions, rn as ControlMeasureGeometry, rt as ObstacleBypassDifficultOptions, s as line24DrawRule, sn as AnchorTransformEvent, st as TurnOptions, t as DEFAULT_TACTICAL_ARROW_OPTIONS, tn as DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, tt as ObstacleBypassImpossibleOptions, u as line1DrawRule, 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-D7uBPw7l.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_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_SUPPORTING_ATTACK_OPTIONS, DEFAULT_SUPPORT_BY_FIRE_OPTIONS, DEFAULT_TACTICAL_ARROW_OPTIONS, DEFAULT_TURN_OPTIONS, type DelayOptions, type DisruptOptions, EPSILON, 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 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 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 };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { $ as snapToMidpointPerpendicular, A as DEFAULT_BLOCK_MISSION_TASK_OPTIONS, B as line24DrawRule, C as DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, D as DEFAULT_CANALIZE_OPTIONS, E as DEFAULT_CLEAR_OPTIONS, F as DEFAULT_ANTITANK_DITCH_OPTIONS, G as attackByFireDrawRule, H as turnDrawRule, I as DEFAULT_AMBUSH_OPTIONS, J as blockDrawRule, K as point12DrawRule, L as DEFAULT_AIRBORNE_ATTACK_OPTIONS, M as DEFAULT_ATTACK_HELICOPTER_OPTIONS, N as DEFAULT_ATTACK_BY_FIRE_OPTIONS, O as DEFAULT_BYPASS_OPTIONS, P as DEFAULT_ANTITANK_WALL_OPTIONS, Q as pointOnMidpointPerpendicularAxis, R as axis1DrawRule, S as DEFAULT_FIX_OPTIONS, T as DEFAULT_DELAY_OPTIONS, U as line1DrawRule, V as line23DrawRule, W as ambushDrawRule, X as createMidpointPerpendicularDrawRule, Y as computeDefaultMidpointPerpendicularPoint, Z as getMidpointPerpendicularSignedDistance, _ as DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, at as EPSILON, b as DEFAULT_FORTIFIED_LINE_OPTIONS, c as getDefaultOptions, d as DEFAULT_SUPPORTING_ATTACK_OPTIONS, et as createBaselineFrame, f as DEFAULT_SUPPORT_BY_FIRE_OPTIONS, g as DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, h as DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, i as CONTROL_MEASURE_METADATA, it as unproject, j as DEFAULT_BLOCK_OPTIONS, k as DEFAULT_BREACH_OPTIONS, l as listControlMeasureMetadata, m as DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, n as resolveStyleHints, nt as computeInitialWidthPoint, o as getControlMeasureMetadata, ot as getMetersPerPixel, p as DEFAULT_TACTICAL_ARROW_OPTIONS, q as disruptDrawRule, r as CONTROL_MEASURE_IDS, rt as project, s as getControlMeasureMetadataByValue, st as roundToFixed, t as renderControlMeasure, tt as calculateMetrics, u as DEFAULT_TURN_OPTIONS, v as DEFAULT_MAIN_ATTACK_OPTIONS, w as DEFAULT_DISRUPT_OPTIONS, x as DEFAULT_FLOT_OPTIONS, y as DEFAULT_FORTIFIED_AREA_OPTIONS, z as supportByFireDrawRule } from "./renderControlMeasure-C7pY-TcL.mjs";
+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";
 //#region src/instance.ts
 function isKind(cm, kind) {
 	return cm.kind === kind;
@@ -99,4 +99,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_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_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_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 };

package/dist/preview/index.d.mts

@@ -1,4 +1,4 @@
-import { q as ControlMeasureId } from "../index-D7uBPw7l.mjs";
+import { q as ControlMeasureId } from "../index-BJYbQlzo.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-C7pY-TcL.mjs";
+import { a as DEFINITIONS, t as renderControlMeasure } from "../renderControlMeasure-CONa8M6M.mjs";
 //#region src/preview/index.ts
 /**
 * Unitless `previewSample` points (~`[-1, 1]`) are scaled by this degree offset

package/dist/{renderControlMeasure-C7pY-TcL.mjs → renderControlMeasure-CONa8M6M.mjs}

@@ -483,6 +483,32 @@ function samePosition(a, b) {
 	return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
 }
 //#endregion
+//#region src/draw-rules/area1.ts
+function derive$7(points) {
+	return clonePositions(points);
+}
+/**
+* Area1 anchor draw rule — a free closed area (Battle Position, Strong Point,
+* Encirclement, Fortified Area).
+*
+* Every anchor is a fully free, user-clicked ring vertex; the rule imposes no
+* constraint and derives no extra slots, so `derive`/`transform` pass the
+* points through unchanged. It is the area analog of the free-line {@link
+* line1DrawRule}: variable-length (no `canonicalPointCount`) with a three-point
+* floor to close a polygon. Behaviorally a no-op over the bare variable-length
+* path — it exists so these drawable areas expose a named rule on
+* `metadata.rule` rather than leaving it `undefined`, matching every other
+* doctrinal draw rule. Ring closure is a generator concern, not a draw-rule one.
+*/
+const area1DrawRule = {
+	id: "area1",
+	minimumUserPoints: 3,
+	derive: derive$7,
+	transform(event) {
+		return derive$7(event.next);
+	}
+};
+//#endregion
 //#region src/draw-rules/area11.ts
 const blockDrawRule = createMidpointPerpendicularDrawRule({ id: "area11:block" });
 //#endregion
@@ -875,11 +901,30 @@ const FIRE_ARROW_PARAMS = [
 		step: 1
 	}
 ];
-const FORTIFIED_AREA_PARAMS = [
+const FORTIFIED_AREA_SIZE_PARAMS = [{
+	key: "sizePixels",
+	label: "Size",
+	description: "Size of the fortified-area teeth, in pixels",
+	type: "number",
+	min: 5,
+	max: 50,
+	step: 1,
+	unit: "px"
+}, {
+	key: "size",
+	label: "Size",
+	description: "Size of the fortified-area teeth, in meters",
+	type: "number",
+	min: 1,
+	max: 500,
+	step: 1,
+	unit: "m"
+}];
+const ENCIRCLEMENT_PARAMS = [
 	{
 		key: "smooth",
 		label: "Smooth",
-		description: "Round the area's corners by curving the boundary through the control points.",
+		description: "Round the boundary by curving it through the control points.",
 		type: "boolean"
 	},
 	{
@@ -892,25 +937,43 @@ const FORTIFIED_AREA_PARAMS = [
 		step: 1,
 		visibleWhen: (opts) => Boolean(opts.smooth)
 	},
-	...[{
-		key: "sizePixels",
-		label: "Size",
-		description: "Size of the fortified-area teeth, in pixels",
+	{
+		key: "barbSpacingRatio",
+		label: "Spacing",
+		description: "Spacing between barbs as a ratio of the symbol radius (smaller is denser).",
 		type: "number",
-		min: 5,
-		max: 50,
-		step: 1,
-		unit: "px"
-	}, {
-		key: "size",
-		label: "Size",
-		description: "Size of the fortified-area teeth, in meters",
+		min: .15,
+		max: 1.5,
+		step: .05
+	},
+	{
+		key: "barbLengthRatio",
+		label: "Barb length",
+		description: "Barb height as a ratio of the symbol radius (amplitude).",
 		type: "number",
-		min: 1,
-		max: 500,
+		min: .02,
+		max: .5,
+		step: .01
+	}
+];
+const FORTIFIED_AREA_PARAMS = [
+	{
+		key: "smooth",
+		label: "Smooth",
+		description: "Round the area's corners by curving the boundary 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,
-		unit: "m"
-	}]
+		visibleWhen: (opts) => Boolean(opts.smooth)
+	},
+	...FORTIFIED_AREA_SIZE_PARAMS
 ];
 //#endregion
 //#region src/generators/cm15-maneuver-areas/airborneAttack.ts
@@ -2181,8 +2244,121 @@ function closedCatmullRom(points, samples) {
 	return out;
 }
 //#endregion
+//#region src/internal/area-echelon.ts
+/** Mean of the ring's distinct vertices, used as the outward-normal reference. */
+function ringCentroid(verts, count) {
+	let cx = 0;
+	let cy = 0;
+	for (let i = 0; i < count; i++) {
+		cx += verts[i][0];
+		cy += verts[i][1];
+	}
+	return [cx / count, cy / count];
+}
+/**
+* Projects `positions` and returns a closed ring (first == last), optionally
+* smoothed through the control points with a closed centripetal Catmull-Rom
+* spline. A trailing vertex that duplicates the first (already-closed input)
+* is dropped before closing/smoothing.
+*/
+function buildClosedRing(positions, smooth, smoothResolution, defaultSmoothResolution) {
+	const projected = positions.map((p) => project(p[0], p[1]));
+	const ringPts = projected.length > 1 && Math.abs(projected[0][0] - projected[projected.length - 1][0]) < 1e-6 && Math.abs(projected[0][1] - projected[projected.length - 1][1]) < 1e-6 ? projected.slice(0, -1) : projected;
+	return smooth ? closedCatmullRom(ringPts, normalizeSmoothResolution$2(smoothResolution, defaultSmoothResolution)) : [...ringPts, ringPts[0]];
+}
+/**
+* Walks a closed ring into per-segment metadata (unit direction, outward
+* normal, cumulative arc length) plus the total perimeter and the arc-length
+* anchor of the bottom edge — the segment whose midpoint sits lowest (min
+* projected y), the side opposite the front.
+*/
+function buildAreaPerimeter(verts) {
+	const centroid = ringCentroid(verts, verts.length - 1);
+	const segs = [];
+	let totalLength = 0;
+	let anchorTarget = 0;
+	let lowest = Infinity;
+	for (let i = 0; i < verts.length - 1; i++) {
+		const a = verts[i];
+		const b = verts[i + 1];
+		const edge = vecSub(b, a);
+		const length = vecMag(edge);
+		if (length < 1e-6) continue;
+		const along = vecNorm(edge);
+		const mid = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+		let perp = [-along[1], along[0]];
+		if (perp[0] * (mid[0] - centroid[0]) + perp[1] * (mid[1] - centroid[1]) < 0) perp = [-perp[0], -perp[1]];
+		segs.push({
+			start: a,
+			along,
+			perp,
+			length,
+			arcStart: totalLength
+		});
+		if (mid[1] < lowest) {
+			lowest = mid[1];
+			anchorTarget = totalLength + length / 2;
+		}
+		totalLength += length;
+	}
+	return {
+		verts,
+		segs,
+		totalLength,
+		anchorTarget
+	};
+}
+/** Resolves the arc-length `target` to a point and the segment frame it lands on. */
+function pointOnRing(segs, target) {
+	let seg = segs[segs.length - 1];
+	for (const candidate of segs) if (target < candidate.arcStart + candidate.length) {
+		seg = candidate;
+		break;
+	}
+	return {
+		point: vecAdd(seg.start, vecScale(seg.along, target - seg.arcStart)),
+		seg
+	};
+}
+/**
+* Effective echelon glyph height in meters. Screen-anchored when a pixel size
+* is supplied with a live resolution; ground-anchored (meters) otherwise.
+* Clamped strictly positive.
+*/
+function resolveEchelonHeight(echelonSize, echelonSizePixels, metersPerPixel) {
+	let h = echelonSize;
+	if (echelonSizePixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0) h = echelonSizePixels * metersPerPixel;
+	return Math.max(EPSILON, h);
+}
+/**
+* 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.
+*/
+function placeEchelon(perimeter, h, echelon, echelonPadding, echelonPosition) {
+	const { segs, totalLength, anchorTarget } = perimeter;
+	const spec = resolveEchelon(echelon);
+	if (!spec || segs.length === 0 || totalLength < 1e-6) return {
+		strokes: [],
+		fills: [],
+		gaps: []
+	};
+	const target = ((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 = [];
+	const halfGap = width / 2 + Math.max(0, echelonPadding) * h;
+	pushWrappedGap(gaps, target - halfGap, target + halfGap, totalLength);
+	return {
+		strokes,
+		fills,
+		gaps
+	};
+}
+//#endregion
 //#region src/generators/cm15-maneuver-areas/battlePosition.ts
-const DEFAULT_SMOOTH_RESOLUTION$4 = 16;
+const DEFAULT_SMOOTH_RESOLUTION$6 = 16;
 /** Default options for the Battle Position control measure. */
 const DEFAULT_BATTLE_POSITION_OPTIONS = {
 	echelon: "battalion",
@@ -2191,7 +2367,7 @@ const DEFAULT_BATTLE_POSITION_OPTIONS = {
 	echelonPadding: .3,
 	echelonPosition: 0,
 	smooth: false,
-	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$4
+	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$6
 };
 const BATTLE_POSITION_METADATA = {
 	id: "battle-position",
@@ -2268,16 +2444,6 @@ const BATTLE_POSITION_METADATA = {
 		}
 	]
 };
-/** Mean of the ring's distinct vertices, used as the outward-normal reference. */
-function ringCentroid(verts, count) {
-	let cx = 0;
-	let cy = 0;
-	for (let i = 0; i < count; i++) {
-		cx += verts[i][0];
-		cy += verts[i][1];
-	}
-	return [cx / count, cy / count];
-}
 /**
 * Creates a Battle Position control measure: a closed area through `positions`
 * carrying a single echelon (Field B) glyph straddling its boundary — anchored
@@ -2289,59 +2455,9 @@ function ringCentroid(verts, count) {
 */
 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;
-	let h = echelonSize;
-	if (echelonSizePixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0) h = echelonSizePixels * metersPerPixel;
-	h = Math.max(EPSILON, h);
-	const spec = resolveEchelon(echelon);
-	const projected = positions.map((p) => project(p[0], p[1]));
-	const ringPts = projected.length > 1 && Math.abs(projected[0][0] - projected[projected.length - 1][0]) < 1e-6 && Math.abs(projected[0][1] - projected[projected.length - 1][1]) < 1e-6 ? projected.slice(0, -1) : projected;
-	const verts = smooth ? closedCatmullRom(ringPts, normalizeSmoothResolution$2(smoothResolution, DEFAULT_SMOOTH_RESOLUTION$4)) : [...ringPts, ringPts[0]];
-	const glyphStrokes = [];
-	const glyphFills = [];
-	const gaps = [];
-	if (spec) {
-		const centroid = ringCentroid(verts, verts.length - 1);
-		const segs = [];
-		let totalLength = 0;
-		let anchorTarget = 0;
-		let lowest = Infinity;
-		for (let i = 0; i < verts.length - 1; i++) {
-			const a = verts[i];
-			const b = verts[i + 1];
-			const seg = vecSub(b, a);
-			const L = vecMag(seg);
-			if (L < 1e-6) continue;
-			const along = vecNorm(seg);
-			const mid = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
-			let perp = [-along[1], along[0]];
-			if (perp[0] * (mid[0] - centroid[0]) + perp[1] * (mid[1] - centroid[1]) < 0) perp = [-perp[0], -perp[1]];
-			segs.push({
-				start: a,
-				along,
-				perp,
-				length: L,
-				acc: totalLength
-			});
-			if (mid[1] < lowest) {
-				lowest = mid[1];
-				anchorTarget = totalLength + L / 2;
-			}
-			totalLength += L;
-		}
-		if (segs.length > 0 && totalLength >= 1e-6) {
-			const target = ((anchorTarget + echelonPosition * totalLength) % totalLength + totalLength) % totalLength;
-			let seg = segs[segs.length - 1];
-			for (const candidate of segs) if (target < candidate.acc + candidate.length) {
-				seg = candidate;
-				break;
-			}
-			const { strokes, fills, width } = buildEchelonGlyph(vecAdd(seg.start, vecScale(seg.along, target - seg.acc)), seg.along, seg.perp, h, spec);
-			glyphStrokes.push(...strokes);
-			glyphFills.push(...fills);
-			const halfGap = width / 2 + Math.max(0, echelonPadding) * h;
-			pushWrappedGap(gaps, target - halfGap, target + halfGap, totalLength);
-		}
-	}
+	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 boundaryCoords = buildGappedLine(verts, gaps);
 	const features = [];
 	if (boundaryCoords.length > 0) features.push({
@@ -2352,15 +2468,15 @@ function createBattlePosition(positions, options = {}) {
 			coordinates: boundaryCoords
 		}
 	});
-	if (glyphStrokes.length > 0) features.push({
+	if (strokes.length > 0) features.push({
 		type: "Feature",
 		properties: { part: "echelon" },
 		geometry: {
 			type: "MultiLineString",
-			coordinates: glyphStrokes
+			coordinates: strokes
 		}
 	});
-	if (glyphFills.length > 0) features.push({
+	if (fills.length > 0) features.push({
 		type: "Feature",
 		properties: {
 			part: "echelon",
@@ -2368,7 +2484,7 @@ function createBattlePosition(positions, options = {}) {
 		},
 		geometry: {
 			type: "MultiPolygon",
-			coordinates: glyphFills.map((ring) => [ring])
+			coordinates: fills.map((ring) => [ring])
 		}
 	});
 	return {
@@ -2380,6 +2496,7 @@ const BATTLE_POSITION = defineControlMeasure({
 	metadata: BATTLE_POSITION_METADATA,
 	generator: createBattlePosition,
 	defaultOptions: DEFAULT_BATTLE_POSITION_OPTIONS,
+	rule: area1DrawRule,
 	previewSample: {
 		controlPoints: [
 			[-1, -.5],
@@ -2387,7 +2504,10 @@ const BATTLE_POSITION = defineControlMeasure({
 			[1, .5],
 			[-1, .5]
 		],
-		options: { echelonSize: 375 }
+		options: {
+			echelonSize: 200,
+			smooth: true
+		}
 	}
 });
 //#endregion
@@ -2458,7 +2578,7 @@ const BLOCK = defineControlMeasure({
 });
 //#endregion
 //#region src/generators/cm99-generic-arrows/blockArrow.ts
-const DEFAULT_SMOOTH_RESOLUTION$3 = 12;
+const DEFAULT_SMOOTH_RESOLUTION$5 = 12;
 const MIN_SMOOTH_RESOLUTION$1 = 2;
 const MAX_SMOOTH_RESOLUTION$1 = 64;
 const DEFAULT_BLOCK_ARROW_OPTIONS = {
@@ -2467,7 +2587,7 @@ const DEFAULT_BLOCK_ARROW_OPTIONS = {
 	arrowheadWidthRatio: .18,
 	arrowheadLengthRatio: .22,
 	smooth: false,
-	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$3,
+	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$5,
 	filled: true
 };
 const BLOCK_ARROW_METADATA = {
@@ -2704,7 +2824,7 @@ function axis1Geometry(coordinates) {
 	};
 }
 function normalizeSmoothResolution$1(value) {
-	if (!Number.isFinite(value)) return DEFAULT_SMOOTH_RESOLUTION$3;
+	if (!Number.isFinite(value)) return DEFAULT_SMOOTH_RESOLUTION$5;
 	return Math.min(MAX_SMOOTH_RESOLUTION$1, Math.max(MIN_SMOOTH_RESOLUTION$1, Math.round(value)));
 }
 //#endregion
@@ -2730,7 +2850,7 @@ function keepTextLeftToRight(rotation) {
 }
 //#endregion
 //#region src/generators/cm11-command-control-lines/boundary.ts
-const DEFAULT_SMOOTH_RESOLUTION$2 = 12;
+const DEFAULT_SMOOTH_RESOLUTION$4 = 12;
 /** Default options for the Boundary control measure. */
 const DEFAULT_BOUNDARY_OPTIONS = {
 	echelon: "battalion",
@@ -2744,7 +2864,7 @@ const DEFAULT_BOUNDARY_OPTIONS = {
 	unit2Designator: "",
 	unit2Country: "",
 	smooth: false,
-	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$2
+	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$4
 };
 const BOUNDARY_METADATA = {
 	id: "boundary",
@@ -2897,7 +3017,7 @@ function createBoundary(positions, options = {}) {
 		if (labelSizeZoom !== void 0) labelSize.textSizeZoom = labelSizeZoom;
 	}
 	const rawVerts = positions.map((p) => project(p[0], p[1]));
-	const verts = smooth ? catmullRom(rawVerts, normalizeSmoothResolution$2(smoothResolution, DEFAULT_SMOOTH_RESOLUTION$2)) : rawVerts;
+	const verts = smooth ? catmullRom(rawVerts, normalizeSmoothResolution$2(smoothResolution, DEFAULT_SMOOTH_RESOLUTION$4)) : rawVerts;
 	const glyphStrokes = [];
 	const glyphFills = [];
 	const labelFeatures = [];
@@ -3488,13 +3608,13 @@ const CANALIZE = defineControlMeasure({
 });
 //#endregion
 //#region src/generators/cm99-generic-arrows/classicArrow.ts
-const DEFAULT_SMOOTH_RESOLUTION$1 = 12;
+const DEFAULT_SMOOTH_RESOLUTION$3 = 12;
 const MIN_SMOOTH_RESOLUTION = 2;
 const MAX_SMOOTH_RESOLUTION = 64;
 const DEFAULT_CLASSIC_ARROW_OPTIONS = {
 	arrowheadStyle: "triangle",
 	smooth: false,
-	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$1,
+	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$3,
 	arrowheadLengthRatio: .2,
 	arrowheadWidthRatio: .14
 };
@@ -3781,7 +3901,7 @@ const CLASSIC_ARROW = defineControlMeasure({
 	rule: line1DrawRule
 });
 function normalizeSmoothResolution(value) {
-	if (!Number.isFinite(value)) return DEFAULT_SMOOTH_RESOLUTION$1;
+	if (!Number.isFinite(value)) return DEFAULT_SMOOTH_RESOLUTION$3;
 	return Math.min(MAX_SMOOTH_RESOLUTION, Math.max(MIN_SMOOTH_RESOLUTION, Math.round(value)));
 }
 //#endregion
@@ -4271,6 +4391,139 @@ const DISRUPT = defineControlMeasure({
 	previewSample: { controlPoints: [[0, .4], [0, -.4]] }
 });
 //#endregion
+//#region src/generators/cm15-maneuver-areas/encirclement.ts
+const DEFAULT_BARB_SPACING_RATIO = .4;
+const DEFAULT_BARB_LENGTH_RATIO = .16;
+const DEFAULT_SMOOTH_RESOLUTION$2 = 16;
+/** Default options for the Encirclement control measure. */
+const DEFAULT_ENCIRCLEMENT_OPTIONS = {
+	barbSpacingRatio: DEFAULT_BARB_SPACING_RATIO,
+	barbLengthRatio: DEFAULT_BARB_LENGTH_RATIO,
+	smooth: true,
+	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$2
+};
+const ENCIRCLEMENT_METADATA = {
+	id: "encirclement",
+	name: "Encirclement",
+	description: "The loss of freedom of maneuver resulting from enemy control of all ground routes of evacuation and reinforcement.",
+	entity: "Maneuver Areas",
+	entityType: "Encirclement",
+	value: "151800",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: ["Polygon", "MultiLineString"],
+	drawRule: "Area1",
+	params: ENCIRCLEMENT_PARAMS
+};
+/** Mean distance from the ring centroid to its distinct vertices. */
+function meanRadius(verts) {
+	const n = verts.length - 1;
+	if (n <= 0) return 0;
+	let cx = 0;
+	let cy = 0;
+	for (let i = 0; i < n; i++) {
+		cx += verts[i][0];
+		cy += verts[i][1];
+	}
+	cx /= n;
+	cy /= n;
+	let sum = 0;
+	for (let i = 0; i < n; i++) sum += Math.hypot(verts[i][0] - cx, verts[i][1] - cy);
+	return sum / n;
+}
+/**
+* Builds the outward barbs as open "V" strokes sitting on the boundary, evenly
+* spaced around the perimeter. The requested `spacing` (arc length) is rounded
+* to a whole number of barbs so they close the ring exactly. Each barb runs
+* base-start → apex → base-end with the apex pushed out along the local outward
+* normal; the base ends are sampled on the ring at ±`barbLength/2` of arc so the
+* barb's base width equals its length (a clean arrowhead, as in Isolate) and
+* follows the boundary curvature. The base half-width is capped so dense barbs
+* never overlap.
+*/
+function buildBarbs(perimeter, spacing, barbLength) {
+	const { segs, totalLength } = perimeter;
+	if (segs.length === 0 || totalLength < 1e-6 || barbLength < 1e-6 || spacing < 1e-6) return [];
+	const count = Math.max(3, Math.round(totalLength / spacing));
+	const half = Math.min(barbLength / 2, totalLength / (2 * count));
+	const at = (arc) => pointOnRing(segs, (arc % totalLength + totalLength) % totalLength);
+	const barbs = [];
+	for (let k = 0; k < count; k++) {
+		const center = k * totalLength / count;
+		const baseStart = at(center - half).point;
+		const { point, seg } = at(center);
+		const apex = vecAdd(point, vecScale(seg.perp, barbLength));
+		const baseEnd = at(center + half).point;
+		barbs.push([
+			baseStart,
+			apex,
+			baseEnd
+		].map((p) => unproject(p[0], p[1])));
+	}
+	return barbs;
+}
+/**
+* Creates an Encirclement tactical graphic: a complete smooth boundary ring
+* with outward arrowhead barbs resting on it. The boundary is an unfilled
+* Polygon; the barbs are open "V" strokes (a MultiLineString) whose base is the
+* boundary arc itself.
+*
+* @param positions - Area anchor points (>=3); the input contract is enforced
+*   at the render seam (ADR-0014).
+* @param options - {@link EncirclementOptions}.
+*/
+function createEncirclement(positions, options = {}) {
+	const { barbSpacingRatio = DEFAULT_BARB_SPACING_RATIO, barbLengthRatio = DEFAULT_BARB_LENGTH_RATIO, smooth = DEFAULT_ENCIRCLEMENT_OPTIONS.smooth, smoothResolution = DEFAULT_ENCIRCLEMENT_OPTIONS.smoothResolution } = options;
+	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION$2);
+	const perimeter = buildAreaPerimeter(verts);
+	const radius = meanRadius(verts);
+	const barbLength = radius * Math.max(0, barbLengthRatio);
+	const barbs = buildBarbs(perimeter, radius * Math.max(0, barbSpacingRatio), barbLength);
+	const features = [{
+		type: "Feature",
+		properties: { part: "boundary" },
+		geometry: {
+			type: "Polygon",
+			coordinates: [verts.map((p) => unproject(p[0], p[1]))]
+		}
+	}];
+	if (barbs.length > 0) features.push({
+		type: "Feature",
+		properties: { part: "barbs" },
+		geometry: {
+			type: "MultiLineString",
+			coordinates: barbs
+		}
+	});
+	return {
+		type: "FeatureCollection",
+		features
+	};
+}
+const ENCIRCLEMENT = defineControlMeasure({
+	metadata: ENCIRCLEMENT_METADATA,
+	generator: createEncirclement,
+	defaultOptions: DEFAULT_ENCIRCLEMENT_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[-.4, -.85],
+			[.4, -.85],
+			[1, -.5],
+			[1, .5],
+			[.4, .85],
+			[-.4, .85],
+			[-1, .5]
+		],
+		options: {
+			barbSpacingRatio: .4,
+			barbLengthRatio: .18,
+			smooth: true
+		}
+	}
+});
+//#endregion
 //#region src/internal/field-of-fire.ts
 /**
 * Builds the open (stroked) arrowhead at the outward tip of one arm. The two
@@ -4810,7 +5063,7 @@ const FLOT = defineControlMeasure({
 //#region src/generators/cm29-protection-lines/fortifiedLine.ts
 const DEFAULT_SIZE = 50;
 const DEFAULT_SIZE_PIXELS = 10;
-const DEFAULT_SMOOTH_RESOLUTION = 16;
+const DEFAULT_SMOOTH_RESOLUTION$1 = 16;
 /**
 * Default options for the Fortified Line graphic.
 */
@@ -4818,7 +5071,7 @@ const DEFAULT_FORTIFIED_LINE_OPTIONS = {
 	size: DEFAULT_SIZE,
 	sizePixels: DEFAULT_SIZE_PIXELS,
 	smooth: false,
-	smoothResolution: DEFAULT_SMOOTH_RESOLUTION
+	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$1
 };
 const FORTIFIED_LINE_METADATA = {
 	id: "fortified-line",
@@ -4950,7 +5203,7 @@ function createFortifiedLine(positions, options = {}) {
 			properties: {},
 			geometry: {
 				type: "LineString",
-				coordinates: generateFortifiedPoints(smooth ? catmullRom(projectedPoints, normalizeSmoothResolution$2(smoothResolution, DEFAULT_SMOOTH_RESOLUTION)) : projectedPoints, safeSize).map((p) => unproject(p[0], p[1]))
+				coordinates: generateFortifiedPoints(smooth ? catmullRom(projectedPoints, normalizeSmoothResolution$2(smoothResolution, DEFAULT_SMOOTH_RESOLUTION$1)) : projectedPoints, safeSize).map((p) => unproject(p[0], p[1]))
 			}
 		}]
 	};
@@ -5018,6 +5271,7 @@ const FORTIFIED_AREA = defineControlMeasure({
 	metadata: FORTIFIED_AREA_METADATA,
 	generator: createFortifiedArea,
 	defaultOptions: DEFAULT_FORTIFIED_AREA_OPTIONS,
+	rule: area1DrawRule,
 	previewSample: { controlPoints: [
 		[-1, -.5],
 		[1, -.5],
@@ -5875,6 +6129,192 @@ const SEARCH_AREA = defineControlMeasure({
 	rule: searchAreaDrawRule
 });
 //#endregion
+//#region src/generators/cm15-maneuver-areas/strongPoint.ts
+const DEFAULT_SMOOTH_RESOLUTION = 16;
+/** Default options for the Strong Point control measure. */
+const DEFAULT_STRONG_POINT_OPTIONS = { ...DEFAULT_BATTLE_POSITION_OPTIONS };
+const STRONG_POINT_METADATA = {
+	id: "strong-point",
+	name: "Strong Point",
+	description: "A key point in a defensive position, usually strongly fortified and heavily armed, around which other positions are grouped for its protection.",
+	entity: "Maneuver Areas",
+	entityType: "Battle Position",
+	entitySubtype: "Strong Point",
+	value: "151203",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: ["MultiLineString", "MultiPolygon"],
+	drawRule: "Area1",
+	params: [
+		{
+			key: "smooth",
+			label: "Smooth",
+			description: "Round the area's corners by curving the boundary 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)
+		},
+		{
+			key: "echelon",
+			label: "Echelon",
+			description: "Field B unit-size amplifier, drawn on the boundary.",
+			type: "enum",
+			options: ECHELON_PARAM_OPTIONS
+		},
+		{
+			key: "echelonSizePixels",
+			label: "Echelon size",
+			description: "Echelon glyph height in screen pixels.",
+			type: "number",
+			min: 8,
+			max: 48,
+			step: 1,
+			unit: "px"
+		},
+		{
+			key: "echelonSize",
+			label: "Echelon size",
+			description: "Echelon glyph height in meters.",
+			type: "number",
+			min: 50,
+			max: 2e4,
+			step: 50,
+			unit: "m"
+		},
+		{
+			key: "echelonPadding",
+			label: "Echelon padding",
+			description: "Gap on each side of the echelon, as a ratio of its height.",
+			type: "number",
+			min: 0,
+			max: 2,
+			step: .05
+		},
+		{
+			key: "echelonPosition",
+			label: "Echelon position",
+			description: "Slide the echelon along the boundary, as a fraction of the perimeter from the bottom edge.",
+			type: "number",
+			min: -.5,
+			max: .5,
+			step: .01
+		}
+	]
+};
+/** True when the arc-length `target` falls inside any echelon masking gap. */
+function inGap(target, gaps) {
+	return gaps.some((gap) => target >= gap.g0 && target <= gap.g1);
+}
+/**
+* Outward perimeter tics: a stroke every `h` meters along the ring, each `h`
+* meters long along the segment's outward normal. Tic length, spacing, and the
+* first-tic phase are all the Field B echelon height `h`. Targets inside an
+* echelon gap are suppressed so the tics don't collide with the glyph.
+*
+* The `target` grows monotonically, so a single forward segment cursor walks
+* the perimeter in O(segments + tics) instead of rescanning per tic.
+*/
+function buildStrongPointTics(perimeter, gaps, h) {
+	const { segs, totalLength } = perimeter;
+	if (segs.length === 0 || totalLength < 1e-6) return [];
+	const tics = [];
+	let cursor = 0;
+	for (let target = h / 2; target < totalLength; target += h) {
+		if (inGap(target, gaps)) continue;
+		while (cursor < segs.length - 1 && target >= segs[cursor].arcStart + segs[cursor].length) cursor++;
+		const seg = segs[cursor];
+		const point = vecAdd(seg.start, vecScale(seg.along, target - seg.arcStart));
+		const end = vecAdd(point, vecScale(seg.perp, h));
+		tics.push([unproject(point[0], point[1]), unproject(end[0], end[1])]);
+	}
+	return tics;
+}
+/**
+* Creates a Strong Point control measure: a Battle Position boundary/echelon
+* with outward tics whose length and spacing are the Field B echelon height.
+* Shares the perimeter and echelon placement with Battle Position via the
+* `area-echelon` primitive (single source of truth for ring and gap).
+*
+* @param positions - Area anchor points (>=3); the input contract is enforced
+*   at the render seam (ADR-0014).
+* @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 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 boundaryCoords = buildGappedLine(verts, gaps);
+	const tics = buildStrongPointTics(perimeter, gaps, h);
+	const features = [];
+	if (boundaryCoords.length > 0) features.push({
+		type: "Feature",
+		properties: { part: "boundary" },
+		geometry: {
+			type: "MultiLineString",
+			coordinates: boundaryCoords
+		}
+	});
+	if (tics.length > 0) features.push({
+		type: "Feature",
+		properties: { part: "tics" },
+		geometry: {
+			type: "MultiLineString",
+			coordinates: tics
+		}
+	});
+	if (strokes.length > 0) features.push({
+		type: "Feature",
+		properties: { part: "echelon" },
+		geometry: {
+			type: "MultiLineString",
+			coordinates: strokes
+		}
+	});
+	if (fills.length > 0) features.push({
+		type: "Feature",
+		properties: {
+			part: "echelon",
+			fill: true
+		},
+		geometry: {
+			type: "MultiPolygon",
+			coordinates: fills.map((ring) => [ring])
+		}
+	});
+	return {
+		type: "FeatureCollection",
+		features
+	};
+}
+const STRONG_POINT = defineControlMeasure({
+	metadata: STRONG_POINT_METADATA,
+	generator: createStrongPoint,
+	defaultOptions: DEFAULT_STRONG_POINT_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.5],
+			[1, -.5],
+			[1, .5],
+			[-1, .5]
+		],
+		options: {
+			echelonSize: 200,
+			smooth: true
+		}
+	}
+});
+//#endregion
 //#region src/generators/cm15-maneuver-areas/supportByFire.ts
 const DEFAULT_SUPPORT_BY_FIRE_OPTIONS = {
 	arrowheadWidthRatio: .3,
@@ -6203,11 +6643,13 @@ function rotate(vector, angle) {
 const DEFINITIONS = {
 	boundary: BOUNDARY,
 	"battle-position": BATTLE_POSITION,
+	"strong-point": STRONG_POINT,
 	ambush: AMBUSH,
 	"principal-direction-of-fire": PRINCIPAL_DIRECTION_OF_FIRE,
 	"final-protective-fire-left": FINAL_PROTECTIVE_FIRE_LEFT,
 	"final-protective-fire-right": FINAL_PROTECTIVE_FIRE_RIGHT,
 	"search-area": SEARCH_AREA,
+	encirclement: ENCIRCLEMENT,
 	"main-attack": MAIN_ATTACK,
 	"supporting-attack": SUPPORTING_ATTACK,
 	"classic-arrow": CLASSIC_ARROW,
@@ -6462,4 +6904,4 @@ function assertNever(value) {
 	throw new Error(`Unhandled control measure kind: ${String(value)}`);
 }
 //#endregion
-export { snapToMidpointPerpendicular as $, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as A, line24DrawRule as B, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as C, DEFAULT_CANALIZE_OPTIONS as D, DEFAULT_CLEAR_OPTIONS as E, DEFAULT_ANTITANK_DITCH_OPTIONS as F, attackByFireDrawRule as G, turnDrawRule as H, DEFAULT_AMBUSH_OPTIONS as I, blockDrawRule as J, point12DrawRule as K, DEFAULT_AIRBORNE_ATTACK_OPTIONS as L, DEFAULT_ATTACK_HELICOPTER_OPTIONS as M, DEFAULT_ATTACK_BY_FIRE_OPTIONS as N, DEFAULT_BYPASS_OPTIONS as O, DEFAULT_ANTITANK_WALL_OPTIONS as P, pointOnMidpointPerpendicularAxis as Q, axis1DrawRule as R, DEFAULT_FIX_OPTIONS as S, DEFAULT_DELAY_OPTIONS as T, line1DrawRule as U, line23DrawRule as V, ambushDrawRule as W, createMidpointPerpendicularDrawRule as X, computeDefaultMidpointPerpendicularPoint as Y, getMidpointPerpendicularSignedDistance as Z, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as _, DEFINITIONS as a, EPSILON as at, DEFAULT_FORTIFIED_LINE_OPTIONS as b, getDefaultOptions as c, DEFAULT_SUPPORTING_ATTACK_OPTIONS as d, createBaselineFrame as et, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as f, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as g, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as h, CONTROL_MEASURE_METADATA as i, unproject as it, DEFAULT_BLOCK_OPTIONS as j, DEFAULT_BREACH_OPTIONS as k, listControlMeasureMetadata as l, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as m, resolveStyleHints as n, computeInitialWidthPoint as nt, getControlMeasureMetadata as o, getMetersPerPixel as ot, DEFAULT_TACTICAL_ARROW_OPTIONS as p, disruptDrawRule as q, CONTROL_MEASURE_IDS as r, project as rt, getControlMeasureMetadataByValue as s, roundToFixed as st, renderControlMeasure as t, calculateMetrics as tt, DEFAULT_TURN_OPTIONS as u, DEFAULT_MAIN_ATTACK_OPTIONS as v, DEFAULT_DISRUPT_OPTIONS as w, DEFAULT_FLOT_OPTIONS as x, DEFAULT_FORTIFIED_AREA_OPTIONS as y, supportByFireDrawRule as z };
+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 };

package/package.json

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