Method execute

src/choiceExecutor.ts:107–160

(choice: IChoice)

	}

	async execute(choice: IChoice): Promise<void> {
		this.pendingAbort = null;
		// Keep a nested execute() (e.g. a {{MACRO}} in a Template/Capture body that runs
		// another choice through this same executor) transparent to the outcome slot of an
		// enclosing executeWithOutcome(): snapshot and restore pendingResult so the nested
		// choice's recorded result never leaks into the outer choice's reported outcome.
		const savedResult = this.pendingResult;
		this.beginExecutionContext();
		const originLeaf = getOpenFileOriginLeaf(this.app);
		const promptDraftStore = InputPromptDraftStore.getInstance();
		promptDraftStore.beginExecutionScope();
		try {
			await this.runOnePagePreflightIfEnabled(choice);

			switch (choice.type) {
				case "Template": {
					const templateChoice: ITemplateChoice =
						choice as ITemplateChoice;
					await this.onChooseTemplateType(templateChoice, originLeaf);
					break;
				}
				case "Capture": {
					const captureChoice: ICaptureChoice = choice as ICaptureChoice;
					await this.onChooseCaptureType(captureChoice, originLeaf);
					break;
				}
				case "Macro": {
					const macroChoice: IMacroChoice = choice as IMacroChoice;
					await this.onChooseMacroType(macroChoice, originLeaf);
					break;
				}
				case "Multi": {
					const multiChoice: IMultiChoice = choice as IMultiChoice;
					this.onChooseMultiType(multiChoice);
					break;
				}
				default:
					break;
			}

			if (this.pendingAbort) {
				promptDraftStore.rollbackExecutionScope();
				return;
			}

			promptDraftStore.commitExecutionScope();
		} catch (error) {
			promptDraftStore.rollbackExecutionScope();
			throw error;
		} finally {
			this.pendingResult = savedResult;
			this.endExecutionContext();
		}
	}

	async executeWithFocusedProperty(
		choice: IChoice,