@mlightcad/cad-simple-viewer 1.4.13 → 1.5.0

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

@@ -50,9 +50,9 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 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';
+import { AcApDocManager } from '../../app';
+import { AcEdCommand, AcEdOpenMode, AcEdPreviewJig, AcEdPromptAngleOptions, AcEdPromptDistanceOptions, AcEdPromptDoubleOptions, AcEdPromptPointOptions, AcEdPromptStatus, eventBus } from '../../editor';
+import { AcApI18n } from '../../i18n';
 var TAU = Math.PI * 2;
 var EPSILON = 1e-9;
 var POSITIVE_NORMAL = { x: 0, y: 0, z: 1 };
@@ -77,6 +77,16 @@ 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.
  *
@@ -514,6 +524,99 @@ var AcApArcJig = /** @class */ (function (_super) {
     };
     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;
+        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 +645,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 +830,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.
      *