@mlightcad/cad-simple-viewer 1.4.13 → 1.5.1

package/lib/command/{AcApArcCmd.js → draw/AcApArcCmd.js}

@@ -49,12 +49,10 @@ 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 };
     }
 };
-import { AcDbArc, AcGePoint3d } from '@mlightcad/data-model';
-import { AcApDocManager } from '../app';
-import { AcEdCommand, AcEdOpenMode, AcEdPreviewJig, AcEdPromptDistanceOptions, AcEdPromptDoubleOptions, AcEdPromptPointOptions, AcEdPromptStatus, eventBus } from '../editor';
-import { AcApI18n } from '../i18n';
-var TAU = Math.PI * 2;
-var EPSILON = 1e-9;
+import { AcDbArc, AcGePoint3d, AcGeTol, FLOAT_TOL, TAU } from '@mlightcad/data-model';
+import { AcApDocManager } from '../../app';
+import { AcEdCommand, AcEdOpenMode, AcEdPreviewJig, AcEdPromptAngleOptions, AcEdPromptDistanceOptions, AcEdPromptDoubleOptions, AcEdPromptPointOptions, AcEdPromptStatus, eventBus } from '../../editor';
+import { AcApI18n } from '../../i18n';
 var POSITIVE_NORMAL = { x: 0, y: 0, z: 1 };
 var NEGATIVE_NORMAL = { x: 0, y: 0, z: -1 };
 /**
@@ -77,10 +75,20 @@ function normalizeAngle(angle) {
 function distance2d(p1, p2) {
     return Math.hypot(p2.x - p1.x, p2.y - p1.y);
 }
+/**
+ * Computes the absolute direction angle from one point to another in degrees.
+ *
+ * @param from - Origin point.
+ * @param to - Target point.
+ * @returns Direction angle in degrees.
+ */
+function directionAngleDeg(from, to) {
+    return (Math.atan2(to.y - from.y, to.x - from.x) * 180) / Math.PI;
+}
 /**
  * Computes point angle around a center under a given arc orientation.
  *
- * For `normalSign = -1` (clockwise), the Y component is mirrored so that
+ * For `normalSign = -1` (clockwise), the X component is mirrored so that
  * angle growth still follows the selected arc direction convention.
  *
  * @param center - Arc center.
@@ -89,10 +97,11 @@ function distance2d(p1, p2) {
  * @returns Direction-aware normalized angle in radians.
  */
 function angleByNormalSign(center, point, normalSign) {
-    // For -Z arcs, mirror Y so the angle still increases in the arc direction.
+    // AcDbArc stores start/end in OCS. For a -Z extrusion, data-model chooses
+    // OCS X = -WCS X and OCS Y = WCS Y, so mirror X rather than Y.
     var dx = point.x - center.x;
     var dy = point.y - center.y;
-    var raw = normalSign === 1 ? Math.atan2(dy, dx) : Math.atan2(-dy, dx);
+    var raw = normalSign === 1 ? Math.atan2(dy, dx) : Math.atan2(dy, -dx);
     return normalizeAngle(raw);
 }
 /**
@@ -104,6 +113,9 @@ function angleByNormalSign(center, point, normalSign) {
 function toNormal(sign) {
     return sign === 1 ? POSITIVE_NORMAL : NEGATIVE_NORMAL;
 }
+function normalSignOf(entity) {
+    return entity.normal.z >= 0 ? 1 : -1;
+}
 /**
  * Creates one `AcDbArc` entity from normalized arc definition data.
  *
@@ -156,7 +168,7 @@ function projectPointToCircle(center, radius, point) {
     var dx = point.x - center.x;
     var dy = point.y - center.y;
     var distance = Math.hypot(dx, dy);
-    if (distance <= EPSILON)
+    if (AcGeTol.isNonPositive(distance))
         return undefined;
     var scale = radius / distance;
     return {
@@ -230,7 +242,7 @@ function createArcFromThreePoints(start, second, end, reverseDirection) {
     var x3 = end.x;
     var y3 = end.y;
     var d = 2 * (x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2));
-    if (Math.abs(d) <= EPSILON)
+    if (AcGeTol.equalToZero(d))
         return undefined;
     var ux = ((x1 * x1 + y1 * y1) * (y2 - y3) +
         (x2 * x2 + y2 * y2) * (y3 - y1) +
@@ -242,7 +254,7 @@ function createArcFromThreePoints(start, second, end, reverseDirection) {
         d;
     var center = { x: ux, y: uy, z: 0 };
     var radius = distance2d(center, start);
-    if (!Number.isFinite(radius) || radius <= EPSILON)
+    if (!Number.isFinite(radius) || AcGeTol.isNonPositive(radius))
         return undefined;
     // By default, choose the arc that actually passes through the second point.
     // Ctrl toggle can reverse this selection to the complementary direction.
@@ -270,11 +282,11 @@ function createArcFromThreePoints(start, second, end, reverseDirection) {
 function createArcFromCenterStartEnd(center, start, end, normalSign) {
     var radiusFromStart = distance2d(center, start);
     var radiusFromEnd = distance2d(center, end);
-    if (radiusFromStart <= EPSILON || radiusFromEnd <= EPSILON) {
+    if (AcGeTol.isNonPositive(radiusFromStart) || AcGeTol.isNonPositive(radiusFromEnd)) {
         return undefined;
     }
     // Start/end must lie on the same circle (small tolerance for picked input).
-    var tolerance = Math.max(EPSILON, radiusFromStart * 1e-6);
+    var tolerance = Math.max(FLOAT_TOL, radiusFromStart * FLOAT_TOL);
     if (Math.abs(radiusFromStart - radiusFromEnd) > tolerance) {
         return undefined;
     }
@@ -300,7 +312,7 @@ function createArcFromCenterStartEnd(center, start, end, normalSign) {
  */
 function createArcFromCenterStartProjectedEnd(center, start, rawEnd, normalSign) {
     var radius = distance2d(center, start);
-    if (radius <= EPSILON)
+    if (AcGeTol.isNonPositive(radius))
         return undefined;
     var end = projectPointToCircle(center, radius, rawEnd);
     if (!end)
@@ -320,7 +332,9 @@ function createArcFromCenterStartProjectedEnd(center, start, rawEnd, normalSign)
 function createArcFromCenterStartSweep(center, start, sweepRad) {
     var radius = distance2d(center, start);
     var sweep = Math.abs(sweepRad);
-    if (radius <= EPSILON || sweep <= EPSILON || sweep >= TAU - EPSILON) {
+    if (AcGeTol.isNonPositive(radius) ||
+        AcGeTol.isNonPositive(sweep) ||
+        !AcGeTol.great(TAU - sweep, 0)) {
         return undefined;
     }
     var normalSign = sweepRad >= 0 ? 1 : -1;
@@ -347,7 +361,9 @@ function createArcFromCenterStartSweep(center, start, sweepRad) {
 function createArcFromCenterStartChord(center, start, chordLength) {
     var radius = distance2d(center, start);
     var chord = Math.abs(chordLength);
-    if (radius <= EPSILON || chord <= EPSILON || chord > 2 * radius + EPSILON) {
+    if (AcGeTol.isNonPositive(radius) ||
+        AcGeTol.isNonPositive(chord) ||
+        AcGeTol.great(chord, 2 * radius)) {
         return undefined;
     }
     var ratio = Math.max(-1, Math.min(1, chord / (2 * radius)));
@@ -366,16 +382,18 @@ function createArcFromCenterStartChord(center, start, chordLength) {
 function createArcFromStartEndAngle(start, end, sweepRad) {
     var chord = distance2d(start, end);
     var sweep = Math.abs(sweepRad);
-    if (chord <= EPSILON || sweep <= EPSILON || sweep >= TAU - EPSILON) {
+    if (AcGeTol.isNonPositive(chord) ||
+        AcGeTol.isNonPositive(sweep) ||
+        !AcGeTol.great(TAU - sweep, 0)) {
         return undefined;
     }
     // chord = 2 * r * sin(theta/2)  ->  r = chord / (2 * sin(theta/2))
     var sinHalf = Math.sin(sweep / 2);
-    if (Math.abs(sinHalf) <= EPSILON)
+    if (AcGeTol.equalToZero(sinHalf))
         return undefined;
     var radius = chord / (2 * sinHalf);
     var offsetSquared = radius * radius - (chord * chord) / 4;
-    if (offsetSquared < -EPSILON)
+    if (AcGeTol.less(offsetSquared, 0))
         return undefined;
     var offset = Math.sqrt(Math.max(0, offsetSquared));
     var midX = (start.x + end.x) / 2;
@@ -416,7 +434,7 @@ function createArcFromStartEndDirection(start, end, directionRad) {
     var nx = -ty;
     var ny = tx;
     var denominator = 2 * (dx * nx + dy * ny);
-    if (Math.abs(denominator) <= EPSILON)
+    if (AcGeTol.equalToZero(denominator))
         return undefined;
     // Solve center = start + lambda * n so that |center-start| = |center-end|.
     var lambda = (dx * dx + dy * dy) / denominator;
@@ -430,7 +448,7 @@ function createArcFromStartEndDirection(start, end, directionRad) {
     var radiusVectorX = start.x - center.x;
     var radiusVectorY = start.y - center.y;
     var cross = radiusVectorX * ty - radiusVectorY * tx;
-    if (Math.abs(cross) <= EPSILON)
+    if (AcGeTol.equalToZero(cross))
         return undefined;
     var normalSign = cross >= 0 ? 1 : -1;
     return createArcFromCenterStartEnd(center, start, end, normalSign);
@@ -448,7 +466,9 @@ function createArcFromStartEndDirection(start, end, directionRad) {
 function createArcFromStartEndRadius(start, end, radiusInput) {
     var radius = Math.abs(radiusInput);
     var chord = distance2d(start, end);
-    if (radius <= EPSILON || chord <= EPSILON || chord > 2 * radius + EPSILON) {
+    if (AcGeTol.isNonPositive(radius) ||
+        AcGeTol.isNonPositive(chord) ||
+        AcGeTol.great(chord, 2 * radius)) {
         return undefined;
     }
     var midX = (start.x + end.x) / 2;
@@ -510,10 +530,113 @@ var AcApArcJig = /** @class */ (function (_super) {
         var definition = this._builder(point);
         if (!definition)
             return;
+        if (definition.normalSign !== normalSignOf(this._arc)) {
+            this.end();
+            this._arc = createArcEntity(definition);
+            return;
+        }
         applyArcDefinition(this._arc, definition);
     };
     return AcApArcJig;
 }(AcEdPreviewJig));
+/**
+ * Numeric preview jig for ARC command.
+ *
+ * This jig is used by angle, chord-length, and radius prompts where the user
+ * is no longer selecting a point directly, but we still want the transient arc
+ * to update from the current numeric value.
+ *
+ * @typeParam T - Numeric prompt value type that drives the preview.
+ */
+var AcApArcValueJig = /** @class */ (function (_super) {
+    __extends(AcApArcValueJig, _super);
+    /**
+     * Creates a numeric preview jig.
+     *
+     * @param view - Active editor view.
+     * @param builder - Prompt-value-to-arc definition resolver.
+     * @param fallback - Initial valid fallback definition.
+     */
+    function AcApArcValueJig(view, builder, fallback) {
+        var _this = _super.call(this, view) || this;
+        _this._builder = builder;
+        _this._arc = createArcEntity(fallback);
+        return _this;
+    }
+    Object.defineProperty(AcApArcValueJig.prototype, "entity", {
+        /**
+         * Gets transient arc entity.
+         */
+        get: function () {
+            return this._arc;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Updates transient arc for the current numeric input value.
+     *
+     * @param value - Current prompt value.
+     */
+    AcApArcValueJig.prototype.update = function (value) {
+        var definition = this._builder(value);
+        if (!definition)
+            return;
+        if (definition.normalSign !== normalSignOf(this._arc)) {
+            this.end();
+            this._arc = createArcEntity(definition);
+            return;
+        }
+        applyArcDefinition(this._arc, definition);
+    };
+    return AcApArcValueJig;
+}(AcEdPreviewJig));
+/**
+ * Normalized scripted ARC entry tokens mapped to an internal entry mode.
+ *
+ * Tokens are normalized by lowercasing and stripping non-alphanumeric
+ * characters before lookup. This lets the command accept a few equivalent
+ * spellings for the same branch, for example:
+ * - documentation-style phrases such as `Start Center End`
+ * - compact aliases such as `SCE`
+ * - historical shorthand such as `3P`
+ *
+ * The table is intentionally centralized so supported scripted spellings remain
+ * easy to audit and extend without touching the main execution logic.
+ */
+var ARC_ENTRY_MODE_BY_TOKEN = {
+    '3p': 'threePoint',
+    '3point': 'threePoint',
+    threepoint: 'threePoint',
+    startcenter: 'startCenter',
+    sc: 'startCenter',
+    startcenterend: 'startCenterEnd',
+    sce: 'startCenterEnd',
+    startcenterangle: 'startCenterAngle',
+    sca: 'startCenterAngle',
+    startcenterlength: 'startCenterLength',
+    startcenterchordlength: 'startCenterLength',
+    scl: 'startCenterLength',
+    startend: 'startEnd',
+    se: 'startEnd',
+    startendangle: 'startEndAngle',
+    sea: 'startEndAngle',
+    startenddirection: 'startEndDirection',
+    sed: 'startEndDirection',
+    startendradius: 'startEndRadius',
+    ser: 'startEndRadius',
+    center: 'centerStart',
+    c: 'centerStart',
+    centerstart: 'centerStart',
+    cs: 'centerStart',
+    centerstartend: 'centerStartEnd',
+    cse: 'centerStartEnd',
+    centerstartangle: 'centerStartAngle',
+    csa: 'centerStartAngle',
+    centerstartlength: 'centerStartLength',
+    centerstartchordlength: 'centerStartLength',
+    csl: 'centerStartLength'
+};
 /**
  * Command to create one arc.
  *
@@ -542,35 +665,162 @@ var AcApArcCmd = /** @class */ (function (_super) {
      */
     AcApArcCmd.prototype.execute = function (context) {
         return __awaiter(this, void 0, void 0, function () {
-            var prompt, result;
+            var entryMode, prompt, result;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         // Keep ARC behavior deterministic for each run (same as PLINE flow).
                         AcApDocManager.instance.editor.resetInputToggles();
+                        entryMode = this.consumeEntryMode();
+                        if (!(entryMode !== 'default')) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.executeEntryMode(context, entryMode)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 2:
                         prompt = new AcEdPromptPointOptions(AcApI18n.t('jig.arc.startPointOrCenter'));
                         this.addKeyword(prompt, 'center');
                         return [4 /*yield*/, AcApDocManager.instance.editor.getPoint(prompt)];
-                    case 1:
+                    case 3:
                         result = _a.sent();
-                        if (!(result.status === AcEdPromptStatus.Keyword)) return [3 /*break*/, 4];
-                        if (!(result.stringResult === 'Center')) return [3 /*break*/, 3];
+                        if (!(result.status === AcEdPromptStatus.Keyword)) return [3 /*break*/, 6];
+                        if (!(result.stringResult === 'Center')) return [3 /*break*/, 5];
                         return [4 /*yield*/, this.runCenterStartFlow(context)];
-                    case 2:
-                        _a.sent();
-                        _a.label = 3;
-                    case 3: return [2 /*return*/];
                     case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5: return [2 /*return*/];
+                    case 6:
                         if (result.status !== AcEdPromptStatus.OK)
                             return [2 /*return*/];
                         return [4 /*yield*/, this.runStartFlow(context, result.value)];
-                    case 5:
+                    case 7:
                         _a.sent();
                         return [2 /*return*/];
                 }
             });
         });
     };
+    /**
+     * Executes one preselected ARC branch.
+     *
+     * This method is used only when a scripted caller queued an entry token
+     * before invoking `ARC`. Instead of starting at the standard root prompt, the
+     * command jumps directly into the requested option family so the user still
+     * interacts with a single `ARC` command while shortcuts can open a more
+     * specific workflow.
+     *
+     * @param context - Current app context.
+     * @param entryMode - Resolved scripted branch to execute.
+     */
+    AcApArcCmd.prototype.executeEntryMode = function (context, entryMode) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = entryMode;
+                        switch (_a) {
+                            case 'threePoint': return [3 /*break*/, 1];
+                            case 'startCenter': return [3 /*break*/, 3];
+                            case 'startCenterEnd': return [3 /*break*/, 5];
+                            case 'startCenterAngle': return [3 /*break*/, 7];
+                            case 'startCenterLength': return [3 /*break*/, 9];
+                            case 'startEnd': return [3 /*break*/, 11];
+                            case 'startEndAngle': return [3 /*break*/, 13];
+                            case 'startEndDirection': return [3 /*break*/, 15];
+                            case 'startEndRadius': return [3 /*break*/, 17];
+                            case 'centerStart': return [3 /*break*/, 19];
+                            case 'centerStartEnd': return [3 /*break*/, 21];
+                            case 'centerStartAngle': return [3 /*break*/, 23];
+                            case 'centerStartLength': return [3 /*break*/, 25];
+                        }
+                        return [3 /*break*/, 27];
+                    case 1: return [4 /*yield*/, this.runExactThreePointFlow(context)];
+                    case 2:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 3: return [4 /*yield*/, this.runStartCenterFlowFromEntry(context)];
+                    case 4:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 5: return [4 /*yield*/, this.runExactStartCenterFlow(context, 'end')];
+                    case 6:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 7: return [4 /*yield*/, this.runExactStartCenterFlow(context, 'angle')];
+                    case 8:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 9: return [4 /*yield*/, this.runExactStartCenterFlow(context, 'chordLength')];
+                    case 10:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 11: return [4 /*yield*/, this.runStartEndFlowFromEntry(context)];
+                    case 12:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 13: return [4 /*yield*/, this.runExactStartEndFlow(context, 'angle')];
+                    case 14:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 15: return [4 /*yield*/, this.runExactStartEndFlow(context, 'direction')];
+                    case 16:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 17: return [4 /*yield*/, this.runExactStartEndFlow(context, 'radius')];
+                    case 18:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 19: return [4 /*yield*/, this.runCenterStartFlow(context)];
+                    case 20:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 21: return [4 /*yield*/, this.runExactCenterStartFlow(context, 'end')];
+                    case 22:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 23: return [4 /*yield*/, this.runExactCenterStartFlow(context, 'angle')];
+                    case 24:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 25: return [4 /*yield*/, this.runExactCenterStartFlow(context, 'chordLength')];
+                    case 26:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 27: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Consumes one optional scripted ARC entry token when present.
+     *
+     * This keeps `ARC` as a single command while still allowing ribbon shortcuts
+     * to preselect a specific option family or exact branch.
+     *
+     * The next queued scripted token is treated as an ARC entry selector only
+     * when it matches a known token in {@link ARC_ENTRY_MODE_BY_TOKEN}. Unknown
+     * input is left untouched so the ordinary command prompts can consume it as
+     * regular scripted input.
+     *
+     * @returns Resolved entry mode, or `'default'` when no special entry token is
+     * queued.
+     */
+    AcApArcCmd.prototype.consumeEntryMode = function () {
+        var token = AcApDocManager.instance.editor.peekScriptInput();
+        if (token == null)
+            return 'default';
+        var normalized = token
+            .trim()
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '');
+        var entryMode = ARC_ENTRY_MODE_BY_TOKEN[normalized];
+        if (!entryMode)
+            return 'default';
+        AcApDocManager.instance.editor.consumeScriptInput();
+        return entryMode;
+    };
     /**
      * Adds one localized keyword to a prompt options object.
      *
@@ -600,6 +850,557 @@ var AcApArcCmd = /** @class */ (function (_super) {
             type: 'warning'
         });
     };
+    /**
+     * Prompts one start point.
+     *
+     * This helper is shared by several scripted entry branches that need to begin
+     * directly at a known Start-point step instead of the normal ARC root prompt.
+     *
+     * @returns Selected start point, or `undefined` when the user cancels or the
+     * prompt does not complete successfully.
+     */
+    AcApArcCmd.prototype.promptStartPoint = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var prompt, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        prompt = new AcEdPromptPointOptions(AcApI18n.t('jig.arc.startPoint'));
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getPoint(prompt)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.status === AcEdPromptStatus.OK ? result.value : undefined];
+                }
+            });
+        });
+    };
+    /**
+     * Prompts one center point, optionally using a base point for feedback.
+     *
+     * When a base point is provided, the prompt mirrors the standard ARC UX by
+     * enabling dashed reference feedback from the previously chosen point.
+     *
+     * @param basePoint - Optional reference point.
+     * @returns Selected center point, or `undefined` when the prompt is aborted.
+     */
+    AcApArcCmd.prototype.promptCenterPoint = function (basePoint) {
+        return __awaiter(this, void 0, void 0, function () {
+            var prompt, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        prompt = new AcEdPromptPointOptions(AcApI18n.t('jig.arc.centerPoint'));
+                        if (basePoint) {
+                            prompt.useBasePoint = true;
+                            prompt.useDashedLine = true;
+                            prompt.basePoint = new AcGePoint3d(basePoint);
+                        }
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getPoint(prompt)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.status === AcEdPromptStatus.OK ? result.value : undefined];
+                }
+            });
+        });
+    };
+    /**
+     * Prompts one end point, optionally using a base point for feedback.
+     *
+     * This helper is used by the scripted entry paths that need a plain End-point
+     * acquisition step before resuming the standard ARC family logic.
+     *
+     * @param basePoint - Optional reference point.
+     * @returns Selected end point, or `undefined` when the prompt is aborted.
+     */
+    AcApArcCmd.prototype.promptEndPoint = function (basePoint) {
+        return __awaiter(this, void 0, void 0, function () {
+            var prompt, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        prompt = new AcEdPromptPointOptions(AcApI18n.t('jig.arc.endPoint'));
+                        if (basePoint) {
+                            prompt.useBasePoint = true;
+                            prompt.useDashedLine = true;
+                            prompt.basePoint = new AcGePoint3d(basePoint);
+                        }
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getPoint(prompt)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.status === AcEdPromptStatus.OK ? result.value : undefined];
+                }
+            });
+        });
+    };
+    /**
+     * Prompts the second point on the arc in the 3-point workflow.
+     *
+     * This is distinct from {@link promptEndPoint} because the 3-point ARC flow
+     * uses a different prompt message and semantic meaning: the second point lies
+     * somewhere on the arc, not necessarily at its final endpoint.
+     *
+     * @param start - Arc start point.
+     * @returns Selected second point, or `undefined` when the prompt is aborted.
+     */
+    AcApArcCmd.prototype.promptSecondPoint = function (start) {
+        return __awaiter(this, void 0, void 0, function () {
+            var prompt, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        prompt = new AcEdPromptPointOptions(AcApI18n.t('jig.arc.secondPoint'));
+                        prompt.useBasePoint = true;
+                        prompt.useDashedLine = true;
+                        prompt.basePoint = new AcGePoint3d(start);
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getPoint(prompt)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.status === AcEdPromptStatus.OK ? result.value : undefined];
+                }
+            });
+        });
+    };
+    /**
+     * Runs the exact 3-point flow selected by a scripted entry token.
+     *
+     * This bypasses the ordinary ARC root prompt and immediately acquires the
+     * Start and Second points required for the 3-point construction, then reuses
+     * the existing shared finalization logic.
+     *
+     * @param context - Current app context.
+     */
+    AcApArcCmd.prototype.runExactThreePointFlow = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var start, second;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.promptStartPoint()];
+                    case 1:
+                        start = _a.sent();
+                        if (!start)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, this.promptSecondPoint(start)];
+                    case 2:
+                        second = _a.sent();
+                        if (!second)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, this.finishThreePointArc(context, start, second)];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Runs the Start-Center option family from an explicit entry token.
+     *
+     * This mode corresponds to the AutoCAD-style branch where the command is
+     * already committed to the Start/Center family, but the final sub-option
+     * (End, Angle, or Chord Length) is still chosen interactively.
+     *
+     * @param context - Current app context.
+     */
+    AcApArcCmd.prototype.runStartCenterFlowFromEntry = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var start;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.promptStartPoint()];
+                    case 1:
+                        start = _a.sent();
+                        if (!start)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, this.runStartCenterFlow(context, start)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Runs one exact Start-Center-* flow selected by a scripted entry token.
+     *
+     * Unlike {@link runStartCenterFlowFromEntry}, this method locks both the
+     * option family and the terminal construction variant up front. It is used by
+     * ribbon dropdown items that represent a fully specified ARC recipe.
+     *
+     * @param context - Current app context.
+     * @param variant - Terminal Start-Center variant to execute after Start and
+     * Center are collected.
+     */
+    AcApArcCmd.prototype.runExactStartCenterFlow = function (context, variant) {
+        return __awaiter(this, void 0, void 0, function () {
+            var start, center, anglePrompt, angleResult, angle, arc_1, chordPrompt, chordResult, chordLength, arc;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.promptStartPoint()];
+                    case 1:
+                        start = _a.sent();
+                        if (!start)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, this.promptCenterPoint(start)];
+                    case 2:
+                        center = _a.sent();
+                        if (!center)
+                            return [2 /*return*/];
+                        if (!(variant === 'end')) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.finishExactCenterStartEnd(context, center, start)];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 4:
+                        if (!(variant === 'angle')) return [3 /*break*/, 6];
+                        anglePrompt = new AcEdPromptAngleOptions(AcApI18n.t('jig.arc.includedAngle'));
+                        anglePrompt.allowNegative = true;
+                        anglePrompt.allowZero = false;
+                        anglePrompt.useBasePoint = true;
+                        anglePrompt.useDashedLine = true;
+                        anglePrompt.basePoint = new AcGePoint3d(center);
+                        anglePrompt.baseAngle = directionAngleDeg(center, start);
+                        anglePrompt.jig = new AcApArcValueJig(context.view, function (degreeValue) {
+                            return createArcFromCenterStartSweep(center, start, _this.applyCtrlDirectionValue(_this.degToRad(degreeValue)));
+                        }, createFallbackArc(start));
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getAngle(anglePrompt)];
+                    case 5:
+                        angleResult = _a.sent();
+                        angle = angleResult.status === AcEdPromptStatus.OK
+                            ? angleResult.value
+                            : undefined;
+                        if (angle == null)
+                            return [2 /*return*/];
+                        arc_1 = createArcFromCenterStartSweep(center, start, this.applyCtrlDirectionValue(this.degToRad(angle)));
+                        if (arc_1) {
+                            this.appendArc(context, arc_1);
+                        }
+                        else {
+                            this.warnInvalidGeometry('angle');
+                        }
+                        return [2 /*return*/];
+                    case 6:
+                        chordPrompt = new AcEdPromptDistanceOptions(AcApI18n.t('jig.arc.chordLength'));
+                        chordPrompt.allowNegative = true;
+                        chordPrompt.allowZero = false;
+                        chordPrompt.useBasePoint = true;
+                        chordPrompt.useDashedLine = true;
+                        chordPrompt.basePoint = new AcGePoint3d(start);
+                        chordPrompt.jig = new AcApArcValueJig(context.view, function (chordValue) {
+                            return createArcFromCenterStartChord(center, start, _this.applyCtrlDirectionValue(chordValue));
+                        }, createFallbackArc(start));
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getDistance(chordPrompt)];
+                    case 7:
+                        chordResult = _a.sent();
+                        chordLength = chordResult.status === AcEdPromptStatus.OK ? chordResult.value : undefined;
+                        if (chordLength == null)
+                            return [2 /*return*/];
+                        arc = createArcFromCenterStartChord(center, start, this.applyCtrlDirectionValue(chordLength));
+                        if (arc) {
+                            this.appendArc(context, arc);
+                        }
+                        else {
+                            this.warnInvalidGeometry('chordLength');
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Runs one exact Center-Start-* flow selected by a scripted entry token.
+     *
+     * This mirrors {@link runExactStartCenterFlow} for the Center-first ARC
+     * family, allowing a shortcut to bypass the default root prompt and enter one
+     * fully specified Center/Start branch directly.
+     *
+     * @param context - Current app context.
+     * @param variant - Terminal Center-Start variant to execute after Center and
+     * Start are collected.
+     */
+    AcApArcCmd.prototype.runExactCenterStartFlow = function (context, variant) {
+        return __awaiter(this, void 0, void 0, function () {
+            var center, start, anglePrompt, angleResult, angle, arc_2, chordPrompt, chordResult, chordLength, arc;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.promptCenterPoint()];
+                    case 1:
+                        center = _a.sent();
+                        if (!center)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, this.promptStartPointFromCenter(center)];
+                    case 2:
+                        start = _a.sent();
+                        if (!start)
+                            return [2 /*return*/];
+                        if (!(variant === 'end')) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.finishExactCenterStartEnd(context, center, start)];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 4:
+                        if (!(variant === 'angle')) return [3 /*break*/, 6];
+                        anglePrompt = new AcEdPromptAngleOptions(AcApI18n.t('jig.arc.includedAngle'));
+                        anglePrompt.allowNegative = true;
+                        anglePrompt.allowZero = false;
+                        anglePrompt.useBasePoint = true;
+                        anglePrompt.useDashedLine = true;
+                        anglePrompt.basePoint = new AcGePoint3d(center);
+                        anglePrompt.baseAngle = directionAngleDeg(center, start);
+                        anglePrompt.jig = new AcApArcValueJig(context.view, function (degreeValue) {
+                            return createArcFromCenterStartSweep(center, start, _this.applyCtrlDirectionValue(_this.degToRad(degreeValue)));
+                        }, createFallbackArc(start));
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getAngle(anglePrompt)];
+                    case 5:
+                        angleResult = _a.sent();
+                        angle = angleResult.status === AcEdPromptStatus.OK
+                            ? angleResult.value
+                            : undefined;
+                        if (angle == null)
+                            return [2 /*return*/];
+                        arc_2 = createArcFromCenterStartSweep(center, start, this.applyCtrlDirectionValue(this.degToRad(angle)));
+                        if (arc_2) {
+                            this.appendArc(context, arc_2);
+                        }
+                        else {
+                            this.warnInvalidGeometry('angle');
+                        }
+                        return [2 /*return*/];
+                    case 6:
+                        chordPrompt = new AcEdPromptDistanceOptions(AcApI18n.t('jig.arc.chordLength'));
+                        chordPrompt.allowNegative = true;
+                        chordPrompt.allowZero = false;
+                        chordPrompt.useBasePoint = true;
+                        chordPrompt.useDashedLine = true;
+                        chordPrompt.basePoint = new AcGePoint3d(start);
+                        chordPrompt.jig = new AcApArcValueJig(context.view, function (chordValue) {
+                            return createArcFromCenterStartChord(center, start, _this.applyCtrlDirectionValue(chordValue));
+                        }, createFallbackArc(start));
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getDistance(chordPrompt)];
+                    case 7:
+                        chordResult = _a.sent();
+                        chordLength = chordResult.status === AcEdPromptStatus.OK ? chordResult.value : undefined;
+                        if (chordLength == null)
+                            return [2 /*return*/];
+                        arc = createArcFromCenterStartChord(center, start, this.applyCtrlDirectionValue(chordLength));
+                        if (arc) {
+                            this.appendArc(context, arc);
+                        }
+                        else {
+                            this.warnInvalidGeometry('chordLength');
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Runs one exact Start-End-* flow selected by a scripted entry token.
+     *
+     * This path is used when a shortcut already knows that the Start-End family
+     * should be used and only needs the command to perform the exact terminal
+     * construction indicated by `variant`.
+     *
+     * @param context - Current app context.
+     * @param variant - Terminal Start-End variant to execute after Start and End
+     * are collected.
+     */
+    AcApArcCmd.prototype.runExactStartEndFlow = function (context, variant) {
+        return __awaiter(this, void 0, void 0, function () {
+            var start, end, anglePrompt, angleResult, angle, arc_3, directionPrompt, directionResult, directionPoint, direction, arc_4, radiusPrompt, radiusResult, radius, arc;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.promptStartPoint()];
+                    case 1:
+                        start = _a.sent();
+                        if (!start)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, this.promptEndPoint(start)];
+                    case 2:
+                        end = _a.sent();
+                        if (!end)
+                            return [2 /*return*/];
+                        if (!(variant === 'angle')) return [3 /*break*/, 4];
+                        anglePrompt = new AcEdPromptAngleOptions(AcApI18n.t('jig.arc.includedAngle'));
+                        anglePrompt.allowNegative = true;
+                        anglePrompt.allowZero = false;
+                        anglePrompt.useBasePoint = true;
+                        anglePrompt.useDashedLine = true;
+                        anglePrompt.basePoint = new AcGePoint3d(start);
+                        anglePrompt.baseAngle = directionAngleDeg(start, end);
+                        anglePrompt.jig = new AcApArcValueJig(context.view, function (degreeValue) {
+                            return createArcFromStartEndAngle(start, end, _this.applyCtrlDirectionValue(_this.degToRad(degreeValue)));
+                        }, createFallbackArc(start));
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getAngle(anglePrompt)];
+                    case 3:
+                        angleResult = _a.sent();
+                        angle = angleResult.status === AcEdPromptStatus.OK
+                            ? angleResult.value
+                            : undefined;
+                        if (angle == null)
+                            return [2 /*return*/];
+                        arc_3 = createArcFromStartEndAngle(start, end, this.applyCtrlDirectionValue(this.degToRad(angle)));
+                        if (arc_3) {
+                            this.appendArc(context, arc_3);
+                        }
+                        else {
+                            this.warnInvalidGeometry('angle');
+                        }
+                        return [2 /*return*/];
+                    case 4:
+                        if (!(variant === 'direction')) return [3 /*break*/, 6];
+                        directionPrompt = new AcEdPromptPointOptions(AcApI18n.t('jig.arc.tangentDirection'));
+                        directionPrompt.useBasePoint = true;
+                        directionPrompt.useDashedLine = true;
+                        directionPrompt.basePoint = new AcGePoint3d(start);
+                        directionPrompt.jig = new AcApArcJig(context.view, function (point) {
+                            return createArcFromStartEndDirection(start, end, Math.atan2(point.y - start.y, point.x - start.x));
+                        }, createFallbackArc(start));
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getPoint(directionPrompt)];
+                    case 5:
+                        directionResult = _a.sent();
+                        directionPoint = directionResult.status === AcEdPromptStatus.OK
+                            ? directionResult.value
+                            : undefined;
+                        if (!directionPoint)
+                            return [2 /*return*/];
+                        direction = Math.atan2(directionPoint.y - start.y, directionPoint.x - start.x);
+                        arc_4 = createArcFromStartEndDirection(start, end, direction);
+                        if (arc_4) {
+                            this.appendArc(context, arc_4);
+                        }
+                        else {
+                            this.warnInvalidGeometry('direction');
+                        }
+                        return [2 /*return*/];
+                    case 6:
+                        radiusPrompt = new AcEdPromptDistanceOptions(AcApI18n.t('jig.arc.radius'));
+                        radiusPrompt.allowNegative = true;
+                        radiusPrompt.allowZero = false;
+                        radiusPrompt.useBasePoint = true;
+                        radiusPrompt.useDashedLine = true;
+                        radiusPrompt.basePoint = new AcGePoint3d(start);
+                        radiusPrompt.jig = new AcApArcValueJig(context.view, function (radiusValue) {
+                            return createArcFromStartEndRadius(start, end, _this.applyCtrlDirectionValue(radiusValue));
+                        }, createFallbackArc(start));
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getDistance(radiusPrompt)];
+                    case 7:
+                        radiusResult = _a.sent();
+                        radius = radiusResult.status === AcEdPromptStatus.OK
+                            ? radiusResult.value
+                            : undefined;
+                        if (radius == null)
+                            return [2 /*return*/];
+                        arc = createArcFromStartEndRadius(start, end, this.applyCtrlDirectionValue(radius));
+                        if (arc) {
+                            this.appendArc(context, arc);
+                        }
+                        else {
+                            this.warnInvalidGeometry('radius');
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Runs the Start-End option family from an explicit entry token.
+     *
+     * This mode corresponds to the AutoCAD-style Start/End branch where the
+     * family is preselected, but the final option (Center, Angle, Direction, or
+     * Radius) is still chosen through the usual interactive prompts.
+     *
+     * @param context - Current app context.
+     */
+    AcApArcCmd.prototype.runStartEndFlowFromEntry = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var start;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.promptStartPoint()];
+                    case 1:
+                        start = _a.sent();
+                        if (!start)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, this.runStartEndFlow(context, start)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Prompts one start point using the given center point as reference.
+     *
+     * The supplied center point is used as the base point so the visual feedback
+     * matches the standard Center/Start ARC family experience.
+     *
+     * @param center - Arc center point.
+     * @returns Selected start point, or `undefined` when the prompt is aborted.
+     */
+    AcApArcCmd.prototype.promptStartPointFromCenter = function (center) {
+        return __awaiter(this, void 0, void 0, function () {
+            var prompt, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        prompt = new AcEdPromptPointOptions(AcApI18n.t('jig.arc.startPoint'));
+                        prompt.useBasePoint = true;
+                        prompt.useDashedLine = true;
+                        prompt.basePoint = new AcGePoint3d(center);
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getPoint(prompt)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.status === AcEdPromptStatus.OK ? result.value : undefined];
+                }
+            });
+        });
+    };
+    /**
+     * Finishes one exact Center-Start-End style flow with end-point preview.
+     *
+     * This helper exists because the exact scripted branch needs the same live
+     * preview behavior as the interactive Center/Start/End path, but without the
+     * intermediate option-selection prompt used by the generic family handler.
+     *
+     * @param context - Current app context.
+     * @param center - Arc center point.
+     * @param start - Arc start point.
+     */
+    AcApArcCmd.prototype.finishExactCenterStartEnd = function (context, center, start) {
+        return __awaiter(this, void 0, void 0, function () {
+            var endPrompt, endResult, arc;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        endPrompt = new AcEdPromptPointOptions(AcApI18n.t('jig.arc.endPoint'));
+                        endPrompt.useBasePoint = true;
+                        endPrompt.useDashedLine = true;
+                        endPrompt.basePoint = new AcGePoint3d(start);
+                        endPrompt.jig = new AcApArcJig(context.view, function (point) {
+                            return createArcFromCenterStartProjectedEnd(center, start, point, _this.applyCtrlDirectionSign(1));
+                        }, createFallbackArc(start));
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getPoint(endPrompt)];
+                    case 1:
+                        endResult = _a.sent();
+                        if (endResult.status !== AcEdPromptStatus.OK)
+                            return [2 /*return*/];
+                        arc = createArcFromCenterStartProjectedEnd(center, start, endResult.value, this.applyCtrlDirectionSign(1));
+                        if (arc) {
+                            this.appendArc(context, arc);
+                        }
+                        else {
+                            this.warnInvalidGeometry('center');
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Gets direction factor from Ctrl-toggle state.
      *
@@ -861,6 +1662,9 @@ var AcApArcCmd = /** @class */ (function (_super) {
                         chordPrompt = new AcEdPromptDistanceOptions(AcApI18n.t('jig.arc.chordLength'));
                         chordPrompt.allowZero = false;
                         chordPrompt.allowNegative = true;
+                        chordPrompt.useBasePoint = true;
+                        chordPrompt.useDashedLine = true;
+                        chordPrompt.basePoint = new AcGePoint3d(start);
                         return [4 /*yield*/, AcApDocManager.instance.editor.getDistance(chordPrompt)];
                     case 4:
                         chordResult = _a.sent();
@@ -976,6 +1780,9 @@ var AcApArcCmd = /** @class */ (function (_super) {
                         radiusPrompt = new AcEdPromptDistanceOptions(AcApI18n.t('jig.arc.radius'));
                         radiusPrompt.allowZero = false;
                         radiusPrompt.allowNegative = true;
+                        radiusPrompt.useBasePoint = true;
+                        radiusPrompt.useDashedLine = true;
+                        radiusPrompt.basePoint = new AcGePoint3d(start);
                         return [4 /*yield*/, AcApDocManager.instance.editor.getDistance(radiusPrompt)];
                     case 7:
                         radiusResult = _a.sent();