@mlightcad/cad-simple-viewer 1.6.1 → 1.6.2

package/lib/command/measure/AcApMeasureArcCmd.js

@@ -13,6 +13,17 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -49,6 +60,31 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var __values = (this && this.__values) || function(o) {
     var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
     if (m) return m.call(o);
@@ -60,109 +96,158 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
-import { AcDbArc, AcDbCircle } from '@mlightcad/data-model';
-import { AcTrHtmlBadge, AcTrHtmlCanvasOverlay, AcTrHtmlDot, AcTrHtmlSnapIndicator } from '@mlightcad/three-renderer';
+import { AcGeCircArc2d, AcGeMathUtil } from '@mlightcad/data-model';
+import { AcTrHtmlBadge, AcTrHtmlDot, AcTrHtmlSnapIndicator } from '@mlightcad/three-renderer';
+import { AcApDocManager } from '../../app';
 import { AcEdCommand, AcEdCorsorType, AcEdOpenMode, AcEdPreviewJig, AcEdPromptPointOptions, AcEdPromptStatus, AcEdViewMode } from '../../editor';
 import { AcApI18n } from '../../i18n';
-import { acapCssColor, acapGetCurrentMeasurementStyle, acapGetMeasurementColor, acapMeasurementCanvasLineWidth, formatMeasurementLength } from '../../util';
+import { acapGetCurrentMeasurementStyle, acapGetMeasurementColor, acapGetMeasurementFontSize, acapGetMeasurementLineWeight, acapMeasurementCanvasLineWidth, formatMeasurementLength } from '../../util';
+import { AcApHtmlLivePreview, acapStrokeLivePolyline, acapStrokeLiveSegment } from '../overlay/AcApHtmlLivePreview';
+import { inwardLockAlignment, isBetterLockCandidate, lockCurvesFromEntity, pointLiesOnCircle, sameCircleGeom } from './AcApMeasureArcLock';
 import { MEASUREMENT_LIVE_LAYER } from './AcApMeasurementStore';
-import { AcApMeasureArcEntity } from './entity';
-/** Returns the world point snapped to the nearest point on the circle circumference */
-function snapToCircle(p, g) {
-    var angle = Math.atan2(p.y - g.cy, p.x - g.cx);
+import { AcApMeasureArcEntity, strokeMeasureArcOnContext } from './entity';
+/** Screen-pixel aperture for locking the first pick onto a CIRCLE/ARC stroke. */
+var SNAP_SCREEN_PX = 20;
+/** Minimum angular move (radians) before the locked-arc sweep direction is chosen. */
+var DIR_LOCK_RAD = 0.02;
+/**
+ * Wraps an angle delta into (−π, π].
+ */
+function wrapAngleToPi(delta) {
+    return AcGeMathUtil.normalizeAngle(delta + Math.PI) - Math.PI;
+}
+/**
+ * Sweep on `g` from `start` to `end`.
+ *
+ * Default is counter-clockwise so the arc can grow past 180° without
+ * jumping to the complementary minor arc. `clockwise` selects that
+ * complementary direction (Ctrl toggle).
+ */
+function lockedSweep(start, end, g, clockwise) {
+    var a1 = Math.atan2(start.y - g.cy, start.x - g.cx);
+    var a2 = Math.atan2(end.y - g.cy, end.x - g.cx);
+    var span = AcGeMathUtil.normalizeAngle(clockwise ? a1 - a2 : a2 - a1);
+    if (!(span > 1e-10) || span >= Math.PI * 2 - 1e-10)
+        return undefined;
+    var mid = clockwise ? a1 - span / 2 : a1 + span / 2;
     return {
-        x: g.cx + g.r * Math.cos(angle),
-        y: g.cy + g.r * Math.sin(angle),
-        z: 0
+        through: { x: g.cx + g.r * Math.cos(mid), y: g.cy + g.r * Math.sin(mid) },
+        length: span * g.r
     };
 }
-/** Returns the shorter arc length between two points on a circle */
-function shortArcLength(p1, p2, g) {
-    var a1 = Math.atan2(p1.y - g.cy, p1.x - g.cx);
-    var a2 = Math.atan2(p2.y - g.cy, p2.x - g.cx);
-    var norm = function (a) {
-        return ((a % (2 * Math.PI)) + 2 * Math.PI) % (2 * Math.PI);
-    };
-    var span = norm(a2 - a1);
-    return Math.min(span, 2 * Math.PI - span) * g.r;
+function toPoint2(p) {
+    return { x: p.x, y: p.y };
 }
-/** World midpoint of the shorter arc between two circle points */
-function shortArcMid(p1, p2, g) {
-    var a1 = Math.atan2(p1.y - g.cy, p1.x - g.cx);
-    var a2 = Math.atan2(p2.y - g.cy, p2.x - g.cx);
-    var norm = function (a) {
-        return ((a % (2 * Math.PI)) + 2 * Math.PI) % (2 * Math.PI);
-    };
-    var ccwSpan = norm(a2 - a1);
-    var mid = ccwSpan <= Math.PI ? a1 + ccwSpan / 2 : a1 - (2 * Math.PI - ccwSpan) / 2;
-    return { x: g.cx + g.r * Math.cos(mid), y: g.cy + g.r * Math.sin(mid), z: 0 };
+function circleGeomFromArc(arc) {
+    return { cx: arc.center.x, cy: arc.center.y, r: arc.radius };
 }
 /**
- * Draws the arc between two snapped circle points onto a canvas element.
- * Uses screen-space angles so the Y-axis flip is handled automatically.
+ * Projects `p` onto the circle circumference. If `p` is the center, the
+ * point at angle 0 is returned.
+ */
+function snapToCircle(p, g) {
+    var dx = p.x - g.cx;
+    var dy = p.y - g.cy;
+    var d = Math.hypot(dx, dy);
+    if (!(d > 0))
+        return { x: g.cx + g.r, y: g.cy, z: 0 };
+    var s = g.r / d;
+    return { x: g.cx + dx * s, y: g.cy + dy * s, z: 0 };
+}
+/**
+ * Picks the CIRCLE / ARC / polyline-bulge stroke closest to `p` in screen space.
+ *
+ * Distance is measured to the drawn curve (not the complementary full circle)
+ * so a click on a gap or a straight polyline chord does not lock.
+ *
+ * @returns Geometry and the nearest point on that stroke, or `null`.
  */
-function drawArcOnCanvas(canvas, view, g, p1, p2, color, lineWidth) {
-    if (lineWidth === void 0) { lineWidth = 4; }
-    var rect = view.canvas.getBoundingClientRect();
-    var dpr = window.devicePixelRatio || 1;
-    var w = Math.round(rect.width);
-    var h = Math.round(rect.height);
-    var origin = view.canvasToContainer({ x: 0, y: 0 });
-    canvas.style.left = "".concat(origin.x, "px");
-    canvas.style.top = "".concat(origin.y, "px");
-    canvas.style.width = "".concat(w, "px");
-    canvas.style.height = "".concat(h, "px");
-    if (canvas.width !== w * dpr || canvas.height !== h * dpr) {
-        canvas.width = w * dpr;
-        canvas.height = h * dpr;
+function pickCircleGeomAtPoint(context, p) {
+    var e_1, _a, e_2, _b;
+    var blockTable = context.doc.database.tables.blockTable;
+    // OSNAP may have pulled `p` onto a shared polyline vertex. Score against
+    // the live cursor so the lock follows whichever arc the mouse is nearer.
+    var mouse = context.view.curPos;
+    var seen = new Set();
+    var hits = __spreadArray(__spreadArray([], __read(context.view.pick(mouse, SNAP_SCREEN_PX)), false), __read(context.view.pick(p, SNAP_SCREEN_PX)), false).filter(function (hit) {
+        if (seen.has(hit.id))
+            return false;
+        seen.add(hit.id);
+        return true;
+    });
+    var cursorScreen = context.view.worldToScreen(mouse);
+    var pick = { x: mouse.x, y: mouse.y, z: 0 };
+    var best = null;
+    var bestScreen = SNAP_SCREEN_PX;
+    var bestAlign = -Infinity;
+    try {
+        for (var hits_1 = __values(hits), hits_1_1 = hits_1.next(); !hits_1_1.done; hits_1_1 = hits_1.next()) {
+            var hit = hits_1_1.value;
+            var entity = blockTable.getEntityById(hit.id);
+            if (!entity)
+                continue;
+            try {
+                for (var _c = (e_2 = void 0, __values(lockCurvesFromEntity(entity))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var curve = _d.value;
+                    if (!(curve.radius > 0))
+                        continue;
+                    var nearest = curve.nearestPoint(pick);
+                    var nearScreen = context.view.worldToScreen(nearest);
+                    var screenDist = Math.hypot(cursorScreen.x - nearScreen.x, cursorScreen.y - nearScreen.y);
+                    if (screenDist > SNAP_SCREEN_PX)
+                        continue;
+                    var align = inwardLockAlignment(curve, { x: nearest.x, y: nearest.y }, { x: mouse.x, y: mouse.y });
+                    if (!best ||
+                        isBetterLockCandidate(screenDist * screenDist, align, bestScreen * bestScreen, bestAlign)) {
+                        bestScreen = screenDist;
+                        bestAlign = align;
+                        var geom = circleGeomFromArc(curve);
+                        best = {
+                            geom: geom,
+                            snapped: { x: nearest.x, y: nearest.y, z: 0 }
+                        };
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
     }
-    var ctx = canvas.getContext('2d');
-    if (!ctx)
-        return;
-    ctx.clearRect(0, 0, canvas.width, canvas.height);
-    ctx.save();
-    ctx.scale(dpr, dpr);
-    var sc = view.worldToScreen({ x: g.cx, y: g.cy });
-    var ss = view.worldToScreen(p1);
-    var se = view.worldToScreen(p2);
-    var screenR = Math.hypot(ss.x - sc.x, ss.y - sc.y);
-    var sa = Math.atan2(ss.y - sc.y, ss.x - sc.x);
-    var ea = Math.atan2(se.y - sc.y, se.x - sc.x);
-    var norm = function (a) {
-        return ((a % (2 * Math.PI)) + 2 * Math.PI) % (2 * Math.PI);
-    };
-    var cwSpan = norm(ea - sa);
-    var antiClockwise = cwSpan > Math.PI;
-    ctx.beginPath();
-    ctx.arc(sc.x, sc.y, screenR, sa, ea, antiClockwise);
-    ctx.strokeStyle = acapCssColor(color);
-    ctx.lineWidth = lineWidth;
-    ctx.stroke();
-    ctx.restore();
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (hits_1_1 && !hits_1_1.done && (_a = hits_1.return)) _a.call(hits_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return best;
 }
 /**
  * Commit an arc-length measurement overlay (also used when importing a sidecar).
  */
-export function placeArcMeasurement(view, db, geom, start, end, style, options) {
-    AcApMeasureArcEntity.create(geom, start, end, style, options).commit(view, db);
+export function placeArcMeasurement(view, db, geom, start, through, end, style, options) {
+    AcApMeasureArcEntity.create(geom, start, end, style, __assign(__assign({}, options), { through: through })).commit(view, db);
 }
 /**
- * Jig for the first point: shows a small square snap indicator when the
- * cursor hovers over a circle or arc entity. Notifies the caller via onSnap.
+ * First-point jig: square snap indicator when the cursor is on a CIRCLE/ARC
+ * or a polyline bulge.
  */
 var AcApArcSnapJig = /** @class */ (function (_super) {
     __extends(AcApArcSnapJig, _super);
-    function AcApArcSnapJig(context, color, onSnap) {
+    function AcApArcSnapJig(context, color) {
         var _this = _super.call(this, context.view) || this;
         _this._ctx = context;
-        _this._onSnap = onSnap;
-        var o = { x: 0, y: 0, z: 0 };
         _this._indicatorId = "live-arc-snap-".concat(Date.now());
         _this._htManager = context.view.htmlTransientManager;
         _this._indicator = new AcTrHtmlSnapIndicator({
             id: _this._indicatorId,
             color: color,
-            worldPosition: o,
+            worldPosition: { x: 0, y: 0, z: 0 },
             layer: MEASUREMENT_LIVE_LAYER,
             layoutId: context.view.activeLayoutBtrId
         });
@@ -179,59 +264,13 @@ var AcApArcSnapJig = /** @class */ (function (_super) {
         configurable: true
     });
     AcApArcSnapJig.prototype.update = function (p) {
-        var e_1, _a;
-        var hits = this._ctx.view.pick(p);
-        var modelSpace = this._ctx.doc.database.tables.blockTable.modelSpace;
-        // Collect all circle/arc candidates, then pick the one whose
-        // circumference is closest to the cursor (fixes wrong-arc selection
-        // when multiple arcs overlap in the pick area).
-        var bestGeom = null;
-        var bestDist = Number.MAX_VALUE;
-        try {
-            for (var hits_1 = __values(hits), hits_1_1 = hits_1.next(); !hits_1_1.done; hits_1_1 = hits_1.next()) {
-                var hit = hits_1_1.value;
-                var entity = modelSpace.getIdAt(hit.id);
-                var geom = null;
-                if (entity instanceof AcDbCircle) {
-                    geom = { cx: entity.center.x, cy: entity.center.y, r: entity.radius };
-                }
-                else if (entity instanceof AcDbArc) {
-                    geom = { cx: entity.center.x, cy: entity.center.y, r: entity.radius };
-                }
-                if (geom) {
-                    // Distance from cursor to circumference
-                    var distToCenter = Math.hypot(p.x - geom.cx, p.y - geom.cy);
-                    var distToCircumference = Math.abs(distToCenter - geom.r);
-                    if (distToCircumference < bestDist) {
-                        bestDist = distToCircumference;
-                        bestGeom = geom;
-                    }
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (hits_1_1 && !hits_1_1.done && (_a = hits_1.return)) _a.call(hits_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        if (bestGeom) {
-            // Only snap when cursor is close enough to the circumference in
-            // screen space (20 px threshold) — prevents snapping from far away.
-            var snapped = snapToCircle(p, bestGeom);
-            var cursorScreen = this._ctx.view.worldToScreen(p);
-            var snapScreen = this._ctx.view.worldToScreen(snapped);
-            var screenDist = Math.hypot(cursorScreen.x - snapScreen.x, cursorScreen.y - snapScreen.y);
-            if (screenDist <= 20) {
-                this._indicator.setPosition(snapped);
-                this._indicator.object.visible = true;
-                this._onSnap(bestGeom, snapped);
-                return;
-            }
+        var hit = pickCircleGeomAtPoint(this._ctx, p);
+        if (hit) {
+            this._indicator.setPosition(hit.snapped);
+            this._indicator.object.visible = true;
+            return;
         }
         this._indicator.object.visible = false;
-        this._onSnap(null, null);
     };
     AcApArcSnapJig.prototype.end = function () {
         _super.prototype.end.call(this);
@@ -240,29 +279,54 @@ var AcApArcSnapJig = /** @class */ (function (_super) {
     return AcApArcSnapJig;
 }(AcEdPreviewJig));
 /**
- * Jig for the second point: snaps cursor to the known circle, shows the
- * square snap indicator, and fires onMove with the already-snapped point.
+ * End-point jig when a circle is already locked: cursor stays on the
+ * circumference, with a live arc preview (major or minor) and length badge.
+ *
+ * Sweep direction follows the first mouse movement past a small angle
+ * threshold, so dragging past 180° keeps the same side. Ctrl (the same
+ * sticky toggle as the ARC command) flips to the complementary sweep.
  */
-var AcApArcEndSnapJig = /** @class */ (function (_super) {
-    __extends(AcApArcEndSnapJig, _super);
-    function AcApArcEndSnapJig(view, geom, color, onMove) {
-        var _this = _super.call(this, view) || this;
+var AcApArcLockedEndJig = /** @class */ (function (_super) {
+    __extends(AcApArcLockedEndJig, _super);
+    function AcApArcLockedEndJig(context, db, geom, start, color) {
+        var _this = _super.call(this, context.view) || this;
+        /**
+         * Clockwise vs CCW chosen from the first significant mouse move.
+         * `null` until that move; preview then defaults to CCW.
+         */
+        _this._baseClockwise = null;
+        _this._ctx = context;
+        _this._view = context.view;
         _this._geom = geom;
-        _this._onMove = onMove;
-        var o = { x: 0, y: 0, z: 0 };
+        _this._start = toPoint2(start);
+        _this._db = db;
+        _this._color = color;
+        _this._lastAngle = Math.atan2(start.y - geom.cy, start.x - geom.cx);
+        _this._htManager = _this._view.htmlTransientManager;
         _this._indicatorId = "live-arc-end-snap-".concat(Date.now());
-        _this._htManager = view.htmlTransientManager;
         _this._indicator = new AcTrHtmlSnapIndicator({
             id: _this._indicatorId,
             color: color,
-            worldPosition: o,
+            worldPosition: start,
             layer: MEASUREMENT_LIVE_LAYER,
-            layoutId: view.activeLayoutBtrId
+            layoutId: _this._view.activeLayoutBtrId
         });
         _this._htManager.add(_this._indicator);
+        _this._badgeId = "live-arc-locked-badge-".concat(Date.now());
+        _this._badge = new AcTrHtmlBadge({
+            id: _this._badgeId,
+            color: color,
+            worldPosition: start,
+            layer: MEASUREMENT_LIVE_LAYER,
+            layoutId: _this._view.activeLayoutBtrId,
+            fontSize: acapGetMeasurementFontSize()
+        });
+        _this._badge.object.visible = false;
+        _this._htManager.add(_this._badge);
+        _this._preview = new AcApHtmlLivePreview(_this._view, "live-arc-locked-".concat(Date.now()), MEASUREMENT_LIVE_LAYER);
         return _this;
     }
-    Object.defineProperty(AcApArcEndSnapJig.prototype, "entity", {
+    Object.defineProperty(AcApArcLockedEndJig.prototype, "entity", {
         /** HTML-only preview — no CAD transient. */
         get: function () {
             return null;
@@ -270,35 +334,195 @@ var AcApArcEndSnapJig = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
-    AcApArcEndSnapJig.prototype.update = function (p) {
-        var snapped = snapToCircle(p, this._geom);
+    Object.defineProperty(AcApArcLockedEndJig.prototype, "geom", {
+        /**
+         * Circle currently locked for the end pick. May switch between polyline
+         * bulge segments that share the start vertex as the cursor moves.
+         */
+        get: function () {
+            return this._geom;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcApArcLockedEndJig.prototype, "clockwise", {
+        /**
+         * Effective sweep direction after mouse-lock XOR the Ctrl sticky toggle.
+         */
+        get: function () {
+            var _a;
+            return ((_a = this._baseClockwise) !== null && _a !== void 0 ? _a : false) !== this._isCtrlFlipped();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AcApArcLockedEndJig.prototype._isCtrlFlipped = function () {
+        return AcApDocManager.instance.editor.getInputToggles().ctrlArcFlip;
+    };
+    AcApArcLockedEndJig.prototype._trackSweepDirection = function (end) {
+        var angle = Math.atan2(end.y - this._geom.cy, end.x - this._geom.cx);
+        if (this._baseClockwise == null) {
+            var delta = wrapAngleToPi(angle - this._lastAngle);
+            if (Math.abs(delta) > DIR_LOCK_RAD) {
+                this._baseClockwise = delta < 0;
+            }
+        }
+        this._lastAngle = angle;
+    };
+    AcApArcLockedEndJig.prototype.update = function (p) {
+        var _this = this;
+        var mouse = this._view.curPos;
+        var hit = pickCircleGeomAtPoint(this._ctx, p);
+        if (hit &&
+            pointLiesOnCircle(this._start, hit.geom) &&
+            !sameCircleGeom(this._geom, hit.geom)) {
+            this._geom = hit.geom;
+            this._baseClockwise = null;
+            this._lastAngle = Math.atan2(this._start.y - hit.geom.cy, this._start.x - hit.geom.cx);
+        }
+        var snapped = snapToCircle(mouse, this._geom);
+        var end = toPoint2(snapped);
+        this._trackSweepDirection(end);
+        this._color = acapGetMeasurementColor(this._db);
         this._indicator.setPosition(snapped);
-        this._indicator.object.visible = true;
-        this._onMove(snapped);
+        this._badge.setColor(this._color);
+        this._badge.setFontSize(acapGetMeasurementFontSize());
+        var lineWidth = acapMeasurementCanvasLineWidth(acapGetMeasurementLineWeight());
+        var sweep = lockedSweep(this._start, end, this._geom, this.clockwise);
+        this._preview.acapSetDraw(function (ctx, view) {
+            strokeMeasureArcOnContext(ctx, view, _this._geom, _this._start, end, _this._color, lineWidth, sweep === null || sweep === void 0 ? void 0 : sweep.through);
+        });
+        if (!sweep) {
+            this._badge.object.visible = false;
+            return;
+        }
+        this._badge.setText(formatMeasurementLength(this._db, sweep.length));
+        this._badge.setPosition(sweep.through);
+        this._badge.object.visible = true;
     };
-    AcApArcEndSnapJig.prototype.end = function () {
+    AcApArcLockedEndJig.prototype.end = function () {
         _super.prototype.end.call(this);
+        this._preview.acapDispose();
         this._htManager.remove(this._indicatorId);
+        this._htManager.remove(this._badgeId);
     };
-    return AcApArcEndSnapJig;
+    return AcApArcLockedEndJig;
 }(AcEdPreviewJig));
 /**
- * Command that measures the length of an arc on an existing circle or arc entity.
- *
- * Uses a two-phase pick flow that mirrors AutoCAD's arc-length measurement:
- *
- * 1. **Phase 1 — entity snap**: The user hovers over a circle or arc in the
- *    drawing. A square snap indicator appears on the circumference and the
- *    entity geometry is captured. Clicking confirms the start point.
+ * Rubber-band jig for picking the through point: solid HTML preview from start
+ * to cursor.
+ */
+var AcApMeasureArcThroughJig = /** @class */ (function (_super) {
+    __extends(AcApMeasureArcThroughJig, _super);
+    function AcApMeasureArcThroughJig(view, start, color) {
+        var _this = _super.call(this, view) || this;
+        _this._start = start;
+        _this._cursor = start;
+        _this._color = color;
+        _this._preview = new AcApHtmlLivePreview(view, "live-arc-through-".concat(Date.now()), MEASUREMENT_LIVE_LAYER);
+        return _this;
+    }
+    Object.defineProperty(AcApMeasureArcThroughJig.prototype, "entity", {
+        /** HTML-only preview — no CAD transient. */
+        get: function () {
+            return null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AcApMeasureArcThroughJig.prototype.update = function (p) {
+        var _this = this;
+        this._cursor = p;
+        var lineWidth = acapMeasurementCanvasLineWidth(acapGetMeasurementLineWeight());
+        this._preview.acapSetDraw(function (ctx, view) {
+            acapStrokeLiveSegment(ctx, view, _this._start, _this._cursor, _this._color, lineWidth);
+        });
+    };
+    AcApMeasureArcThroughJig.prototype.end = function () {
+        _super.prototype.end.call(this);
+        this._preview.acapDispose();
+    };
+    return AcApMeasureArcThroughJig;
+}(AcEdPreviewJig));
+/**
+ * Preview jig for picking the end point: live arc stroke (or polyline fallback
+ * when the three points are collinear) plus a length badge.
+ */
+var AcApMeasureArcEndJig = /** @class */ (function (_super) {
+    __extends(AcApMeasureArcEndJig, _super);
+    function AcApMeasureArcEndJig(view, db, start, through, color) {
+        var _this = _super.call(this, view) || this;
+        _this._view = view;
+        _this._start = toPoint2(start);
+        _this._through = toPoint2(through);
+        _this._end = toPoint2(through);
+        _this._color = color;
+        _this._db = db;
+        _this._badgeId = "live-arc-badge-".concat(Date.now());
+        _this._htManager = _this._view.htmlTransientManager;
+        _this._badge = new AcTrHtmlBadge({
+            id: _this._badgeId,
+            color: color,
+            worldPosition: start,
+            layer: MEASUREMENT_LIVE_LAYER,
+            layoutId: _this._view.activeLayoutBtrId,
+            fontSize: acapGetMeasurementFontSize()
+        });
+        _this._badge.object.visible = false;
+        _this._htManager.add(_this._badge);
+        _this._preview = new AcApHtmlLivePreview(_this._view, "live-arc-end-".concat(Date.now()), MEASUREMENT_LIVE_LAYER);
+        return _this;
+    }
+    Object.defineProperty(AcApMeasureArcEndJig.prototype, "entity", {
+        /** HTML-only preview — no CAD transient. */
+        get: function () {
+            return null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AcApMeasureArcEndJig.prototype.update = function (p) {
+        var _this = this;
+        this._end = toPoint2(p);
+        this._color = acapGetMeasurementColor(this._db);
+        this._badge.setColor(this._color);
+        this._badge.setFontSize(acapGetMeasurementFontSize());
+        var lineWidth = acapMeasurementCanvasLineWidth(acapGetMeasurementLineWeight());
+        var arc = AcGeCircArc2d.tryCreateByThreePoints(this._start, this._through, this._end);
+        var geom = arc ? circleGeomFromArc(arc) : null;
+        this._preview.acapSetDraw(function (ctx, view) {
+            if (!geom) {
+                acapStrokeLivePolyline(ctx, view, [_this._start, _this._through, _this._end], _this._color, lineWidth);
+                return;
+            }
+            strokeMeasureArcOnContext(ctx, view, geom, _this._start, _this._end, _this._color, lineWidth, _this._through);
+        });
+        if (!arc) {
+            this._badge.object.visible = false;
+            return;
+        }
+        this._badge.setText(formatMeasurementLength(this._db, arc.length));
+        this._badge.setPosition(arc.midPoint);
+        this._badge.object.visible = true;
+    };
+    AcApMeasureArcEndJig.prototype.end = function () {
+        _super.prototype.end.call(this);
+        this._preview.acapDispose();
+        this._htManager.remove(this._badgeId);
+    };
+    return AcApMeasureArcEndJig;
+}(AcEdPreviewJig));
+/**
+ * Command that measures arc length.
  *
- * 2. **Phase 2 — end point**: The same square indicator follows the cursor,
- *    always locked to the captured circle. A canvas overlay draws the shorter
- *    arc between the start and current position in real time, together with a
- *    live badge showing the arc length.
+ * If the first pick lands on a CIRCLE, ARC, or polyline bulge, subsequent
+ * picks lock onto that circumference (two-point sweep). Sweep direction
+ * follows the first mouse movement so arcs greater than 180 degrees stay on
+ * the same side; Ctrl flips to the complementary (major/minor) arc. Otherwise
+ * three world points (start, a point on the arc, end) define a free-form arc.
  *
- * Persistent overlays are placed via {@link AcTrHtmlTransientManager} for dots
- * and badge. The arc canvas is managed with a viewChanged listener cleaned up
- * via {@link commitMeasurementGroup}.
+ * Interactive preview is HTML-only. The committed overlay is placed via
+ * {@link placeArcMeasurement}.
  */
 var AcApMeasureArcCmd = /** @class */ (function (_super) {
     __extends(AcApMeasureArcCmd, _super);
@@ -309,7 +533,7 @@ var AcApMeasureArcCmd = /** @class */ (function (_super) {
     }
     AcApMeasureArcCmd.prototype.execute = function (context) {
         return __awaiter(this, void 0, void 0, function () {
-            var editor, db, color, style, canvasLineWidth, liveId, arcOverlay, htManager;
+            var editor, db, color, view;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -317,113 +541,58 @@ var AcApMeasureArcCmd = /** @class */ (function (_super) {
                         editor = context.view.editor;
                         db = context.doc.database;
                         color = acapGetMeasurementColor(db);
-                        style = acapGetCurrentMeasurementStyle(db);
-                        canvasLineWidth = acapMeasurementCanvasLineWidth(style.lineWeight);
-                        liveId = "live-arc-".concat(Date.now());
-                        arcOverlay = new AcTrHtmlCanvasOverlay({
-                            id: "".concat(liveId, "-canvas"),
-                            container: context.view.container,
-                            layer: MEASUREMENT_LIVE_LAYER,
-                            layoutId: context.view.activeLayoutBtrId
-                        });
-                        htManager = context.view.htmlTransientManager;
-                        htManager.add(arcOverlay);
+                        view = context.view;
                         return [4 /*yield*/, context.view.withMode(AcEdViewMode.SELECTION, function () {
                                 return editor.withCursor(AcEdCorsorType.Crosshair, function () { return __awaiter(_this, void 0, void 0, function () {
-                                    var snapGeom, snappedStart, snapJig, p1Prompt, p1Result, _a, geom, start, liveDotId, liveBadgeId, liveBadge, redrawPreview, onViewChangedPreview, cleanupLivePreview, onMove, p2Prompt, p2Raw, p2Result, _b, end;
-                                    return __generator(this, function (_c) {
-                                        switch (_c.label) {
+                                    var startPrompt, startResult, start, lock, startOnLock, throughPrompt, throughResult, through, endPrompt, endResult, end, start2, through2, end2, measured;
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
                                             case 0:
-                                                snapGeom = null;
-                                                snappedStart = null;
-                                                snapJig = new AcApArcSnapJig(context, color, function (geom, snapped) {
-                                                    snapGeom = geom;
-                                                    snappedStart = snapped;
-                                                });
-                                                p1Prompt = new AcEdPromptPointOptions(AcApI18n.t('jig.measureArc.startPoint'));
-                                                p1Prompt.jig = snapJig;
-                                                _c.label = 1;
+                                                editor.resetInputToggles();
+                                                startPrompt = new AcEdPromptPointOptions(AcApI18n.t('jig.measureArc.startPoint'));
+                                                startPrompt.jig = new AcApArcSnapJig(context, color);
+                                                return [4 /*yield*/, editor.getPoint(startPrompt)];
                                             case 1:
-                                                _c.trys.push([1, 3, , 4]);
-                                                return [4 /*yield*/, editor.getPoint(p1Prompt)];
-                                            case 2:
-                                                p1Result = _c.sent();
-                                                if (p1Result.status !== AcEdPromptStatus.OK) {
-                                                    htManager.remove(arcOverlay.id);
+                                                startResult = _a.sent();
+                                                if (startResult.status !== AcEdPromptStatus.OK)
                                                     return [2 /*return*/];
-                                                }
-                                                return [3 /*break*/, 4];
-                                            case 3:
-                                                _a = _c.sent();
-                                                htManager.remove(arcOverlay.id);
+                                                start = startResult.value;
+                                                lock = pickCircleGeomAtPoint(context, start);
+                                                if (!lock) return [3 /*break*/, 3];
+                                                startOnLock = pointLiesOnCircle(toPoint2(start), lock.geom)
+                                                    ? start
+                                                    : lock.snapped;
+                                                return [4 /*yield*/, this.commitLockedArc(context, view, db, color, lock.geom, startOnLock)];
+                                            case 2:
+                                                _a.sent();
                                                 return [2 /*return*/];
+                                            case 3:
+                                                throughPrompt = new AcEdPromptPointOptions(AcApI18n.t('jig.measureArc.throughPoint'));
+                                                throughPrompt.useBasePoint = true;
+                                                throughPrompt.jig = new AcApMeasureArcThroughJig(context.view, start, color);
+                                                return [4 /*yield*/, editor.getPoint(throughPrompt)];
                                             case 4:
-                                                if (!snapGeom || !snappedStart) {
-                                                    htManager.remove(arcOverlay.id);
+                                                throughResult = _a.sent();
+                                                if (throughResult.status !== AcEdPromptStatus.OK)
                                                     return [2 /*return*/];
-                                                }
-                                                geom = snapGeom;
-                                                start = snappedStart;
-                                                liveDotId = "".concat(liveId, "-dot1");
-                                                liveBadgeId = "".concat(liveId, "-badge");
-                                                htManager.add(new AcTrHtmlDot({
-                                                    id: liveDotId,
-                                                    color: color,
-                                                    worldPosition: start,
-                                                    layer: MEASUREMENT_LIVE_LAYER,
-                                                    layoutId: context.view.activeLayoutBtrId
-                                                }));
-                                                liveBadge = new AcTrHtmlBadge({
-                                                    id: liveBadgeId,
-                                                    color: color,
-                                                    worldPosition: start,
-                                                    layer: MEASUREMENT_LIVE_LAYER,
-                                                    layoutId: context.view.activeLayoutBtrId,
-                                                    fontSize: style.fontSize
-                                                });
-                                                liveBadge.object.visible = false;
-                                                htManager.add(liveBadge);
-                                                redrawPreview = function () {
-                                                    return drawArcOnCanvas(arcOverlay.canvas, context.view, geom, start, start, color, canvasLineWidth);
-                                                };
-                                                onViewChangedPreview = function () { return redrawPreview(); };
-                                                context.view.events.viewChanged.addEventListener(onViewChangedPreview);
-                                                cleanupLivePreview = function () {
-                                                    htManager.remove(liveDotId);
-                                                    htManager.remove(liveBadgeId);
-                                                    htManager.remove(arcOverlay.id);
-                                                    context.view.events.viewChanged.removeEventListener(onViewChangedPreview);
-                                                };
-                                                onMove = function (snapped) {
-                                                    drawArcOnCanvas(arcOverlay.canvas, context.view, geom, start, snapped, color, canvasLineWidth);
-                                                    var len = shortArcLength(start, snapped, geom);
-                                                    liveBadge.setText(formatMeasurementLength(db, len));
-                                                    liveBadge.setPosition(shortArcMid(start, snapped, geom));
-                                                    liveBadge.object.visible = true;
-                                                };
-                                                p2Prompt = new AcEdPromptPointOptions(AcApI18n.t('jig.measureArc.endPoint'));
-                                                p2Prompt.jig = new AcApArcEndSnapJig(context.view, geom, color, onMove);
-                                                _c.label = 5;
+                                                through = throughResult.value;
+                                                endPrompt = new AcEdPromptPointOptions(AcApI18n.t('jig.measureArc.endPoint'));
+                                                endPrompt.jig = new AcApMeasureArcEndJig(context.view, db, start, through, color);
+                                                return [4 /*yield*/, editor.getPoint(endPrompt)];
                                             case 5:
-                                                _c.trys.push([5, 7, , 8]);
-                                                return [4 /*yield*/, editor.getPoint(p2Prompt)];
-                                            case 6:
-                                                p2Result = _c.sent();
-                                                if (p2Result.status !== AcEdPromptStatus.OK) {
-                                                    cleanupLivePreview();
+                                                endResult = _a.sent();
+                                                if (endResult.status !== AcEdPromptStatus.OK)
+                                                    return [2 /*return*/];
+                                                end = endResult.value;
+                                                start2 = toPoint2(start);
+                                                through2 = toPoint2(through);
+                                                end2 = toPoint2(end);
+                                                measured = AcGeCircArc2d.tryCreateByThreePoints(start2, through2, end2);
+                                                if (!measured) {
+                                                    this.showMessage(AcApI18n.t('jig.measureArc.invalidPoints'), 'warning');
                                                     return [2 /*return*/];
                                                 }
-                                                p2Raw = p2Result.value;
-                                                return [3 /*break*/, 8];
-                                            case 7:
-                                                _b = _c.sent();
-                                                cleanupLivePreview();
-                                                return [2 /*return*/];
-                                            case 8:
-                                                // Clean up construction-phase elements
-                                                cleanupLivePreview();
-                                                end = snapToCircle(p2Raw, geom);
-                                                placeArcMeasurement(context.view, db, geom, start, end, acapGetCurrentMeasurementStyle(db));
+                                                placeArcMeasurement(view, db, circleGeomFromArc(measured), start2, through2, end2, acapGetCurrentMeasurementStyle(db));
                                                 return [2 /*return*/];
                                         }
                                     });
@@ -436,6 +605,61 @@ var AcApMeasureArcCmd = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Two-point locked-arc flow after the start pick landed on a CIRCLE, ARC,
+     * or polyline bulge.
+     *
+     * Sweep direction follows the cursor; Ctrl toggles the complementary arc.
+     */
+    AcApMeasureArcCmd.prototype.commitLockedArc = function (context, view, db, color, geom, start) {
+        return __awaiter(this, void 0, void 0, function () {
+            var htManager, liveDotId, endPrompt, jig, endRaw, endResult, geomNow, start2, end2, sweep;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        context.view.editor.resetInputToggles();
+                        htManager = view.htmlTransientManager;
+                        liveDotId = "live-arc-locked-dot-".concat(Date.now());
+                        htManager.add(new AcTrHtmlDot({
+                            id: liveDotId,
+                            color: color,
+                            worldPosition: start,
+                            layer: MEASUREMENT_LIVE_LAYER,
+                            layoutId: view.activeLayoutBtrId
+                        }));
+                        endPrompt = new AcEdPromptPointOptions(AcApI18n.t('jig.measureArc.lockedEndPoint'));
+                        jig = new AcApArcLockedEndJig(context, db, geom, start, color);
+                        endPrompt.jig = jig;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 3, 4]);
+                        return [4 /*yield*/, context.view.editor.getPoint(endPrompt)];
+                    case 2:
+                        endResult = _a.sent();
+                        if (endResult.status !== AcEdPromptStatus.OK)
+                            return [2 /*return*/];
+                        endRaw = endResult.value;
+                        return [3 /*break*/, 4];
+                    case 3:
+                        htManager.remove(liveDotId);
+                        return [7 /*endfinally*/];
+                    case 4:
+                        if (!endRaw)
+                            return [2 /*return*/];
+                        geomNow = jig.geom;
+                        start2 = toPoint2(start);
+                        end2 = toPoint2(snapToCircle(endRaw, geomNow));
+                        sweep = lockedSweep(start2, end2, geomNow, jig.clockwise);
+                        if (!sweep) {
+                            this.showMessage(AcApI18n.t('jig.measureArc.invalidPoints'), 'warning');
+                            return [2 /*return*/];
+                        }
+                        placeArcMeasurement(view, db, geomNow, start2, sweep.through, end2, acapGetCurrentMeasurementStyle(db));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     return AcApMeasureArcCmd;
 }(AcEdCommand));
 export { AcApMeasureArcCmd };