From 2b9d4b6f5227510dd9f9529f098014f1448fc731 Mon Sep 17 00:00:00 2001
From: Jacob Levernier <j@adunumdatum.org>
Date: Sat, 29 Aug 2026 11:30:39 -0400
Subject: [PATCH] - Added support for aliases when using optionQuery with
 suggester elements. - Added support for specifying link text with suggester
 elements.

---
 .../InlineListSuggesterComponent.svelte       |  17 +-
 .../InlineListSuggesterIPF.ts                 |  33 ++
 .../ListSuggesterComponent.svelte             |  17 +-
 .../fields/ListSuggester/ListSuggesterIPF.ts  |  33 ++
 .../Suggester/SuggesterComponent.svelte       |   6 +
 .../fields/Suggester/SuggesterHelper.ts       |  63 +++
 .../fields/Suggester/SuggesterIPF.ts          |  17 +
 .../core/tests/fields/LinkTextEditing.test.ts | 375 ++++++++++++++++++
 .../parserTests/MarkdownLinkParser.test.ts    |  77 ++++
 .../src/modals/SuggesterModalHelper.ts        |  64 +++
 .../tests/modals/SuggesterModalHelper.test.ts | 146 +++++++
 11 files changed, 846 insertions(+), 2 deletions(-)
 create mode 100644 packages/core/tests/fields/LinkTextEditing.test.ts
 create mode 100644 packages/obsidian/tests/modals/SuggesterModalHelper.test.ts

diff --git a/packages/core/src/fields/inputFields/fields/InlineListSuggester/InlineListSuggesterComponent.svelte b/packages/core/src/fields/inputFields/fields/InlineListSuggester/InlineListSuggesterComponent.svelte
index 5c138218..c4176e24 100644
--- a/packages/core/src/fields/inputFields/fields/InlineListSuggester/InlineListSuggesterComponent.svelte
+++ b/packages/core/src/fields/inputFields/fields/InlineListSuggester/InlineListSuggesterComponent.svelte
@@ -1,5 +1,6 @@
 <script lang="ts">
 	import type { InputFieldSvelteProps } from 'meta-bind-core/src/fields/inputFields/InputFieldSvelteWrapper';
+	import { MDLinkParser } from 'meta-bind-core/src/parsers/MarkdownLinkParser';
 	import Icon from 'meta-bind-core/src/utils/components/Icon.svelte';
 	import LiteralRenderComponent from 'meta-bind-core/src/utils/components/LiteralRenderComponent.svelte';
 	import type { ContextMenuItemDefinition } from 'meta-bind-core/src/utils/IContextMenu';
@@ -8,6 +9,7 @@
 	const props: InputFieldSvelteProps<MBLiteral[]> & {
 		showSuggester: () => void;
 		showTextPrompt: () => void;
+		editLinkText: (index: number, value: MBLiteral) => void;
 		allowOther: boolean;
 	} = $props();
 
@@ -56,6 +58,16 @@
 	function openContextMenuForElement(e: MouseEvent, index: number): void {
 		const menuActions: ContextMenuItemDefinition[] = [];
 
+		const entry = value[index];
+		const isLink = typeof entry === 'string' && MDLinkParser.isLink(entry);
+		if (isLink) {
+			menuActions.push({
+				name: 'Edit link text',
+				icon: 'pencil',
+				onclick: () => props.editLinkText(index, entry),
+			});
+		}
+
 		if (index > 0) {
 			menuActions.push({
 				name: 'Move left',
@@ -97,7 +109,10 @@
 	{#each value as entry, i}
 		<div
 			class="mb-inline-list-item"
-			oncontextmenu={e => openContextMenuForElement(e, i)}
+			oncontextmenu={e => {
+				e.preventDefault();
+				openContextMenuForElement(e, i);
+			}}
 			role="listitem"
 			data-value={stringifyLiteral(entry)}
 		>
diff --git a/packages/core/src/fields/inputFields/fields/InlineListSuggester/InlineListSuggesterIPF.ts b/packages/core/src/fields/inputFields/fields/InlineListSuggester/InlineListSuggesterIPF.ts
index 7b4f09e9..d3aa044a 100644
--- a/packages/core/src/fields/inputFields/fields/InlineListSuggester/InlineListSuggesterIPF.ts
+++ b/packages/core/src/fields/inputFields/fields/InlineListSuggester/InlineListSuggesterIPF.ts
@@ -1,5 +1,6 @@
 import { InputFieldArgumentType } from 'meta-bind-core/src/config/FieldConfigs';
 import { AbstractInputField } from 'meta-bind-core/src/fields/inputFields/AbstractInputField';
+import { openLinkTextEditingModal } from 'meta-bind-core/src/fields/inputFields/fields/Suggester/SuggesterHelper';
 import type { InputFieldSvelteComponent } from 'meta-bind-core/src/fields/inputFields/InputFieldSvelteWrapper';
 import type { MBLiteral } from 'meta-bind-core/src/utils/Literal';
 import { parseUnknownToLiteralArray } from 'meta-bind-core/src/utils/Literal';
@@ -35,6 +36,7 @@ export class InlineListSuggesterIPF extends AbstractInputField<MBLiteral[], MBLi
 		return {
 			showSuggester: () => this.openModal(),
 			showTextPrompt: () => this.openTextModal(),
+			editLinkText: (index: number, value: MBLiteral) => this.openLinkTextEditor(index, value),
 			allowOther: this.mountable.getArgument(InputFieldArgumentType.ALLOW_OTHER)?.value === true,
 		};
 	}
@@ -57,4 +59,35 @@ export class InlineListSuggesterIPF extends AbstractInputField<MBLiteral[], MBLi
 			onCancel: () => {},
 		});
 	}
+
+	openLinkTextEditor(index: number, linkValue: MBLiteral): void {
+		if (typeof linkValue !== 'string') {
+			return;
+		}
+
+		// Validate that the index is within bounds
+		const currentValue = this.getInternalValue();
+		if (!Array.isArray(currentValue) || index < 0 || index >= currentValue.length) {
+			return;
+		}
+
+		const currentLink = linkValue;
+
+		openLinkTextEditingModal(
+			currentLink,
+			params => this.mountable.mb.internal.openTextPromptModal(params),
+			updatedLink => {
+				// Re-check the value, since the list may have changed (e.g. reordered or an
+				// item removed) while the modal was open.
+				const latestValue = this.getInternalValue();
+				if (!Array.isArray(latestValue) || latestValue[index] !== currentLink) {
+					return;
+				}
+
+				const updatedArray = [...latestValue];
+				updatedArray[index] = updatedLink;
+				this.setInternalValue(updatedArray);
+			},
+		);
+	}
 }
diff --git a/packages/core/src/fields/inputFields/fields/ListSuggester/ListSuggesterComponent.svelte b/packages/core/src/fields/inputFields/fields/ListSuggester/ListSuggesterComponent.svelte
index 0c1f3030..ddf8f117 100644
--- a/packages/core/src/fields/inputFields/fields/ListSuggester/ListSuggesterComponent.svelte
+++ b/packages/core/src/fields/inputFields/fields/ListSuggester/ListSuggesterComponent.svelte
@@ -1,6 +1,7 @@
 <script lang="ts">
 	import { ButtonStyleType } from 'meta-bind-core/src/config/ButtonConfig';
 	import type { InputFieldSvelteProps } from 'meta-bind-core/src/fields/inputFields/InputFieldSvelteWrapper';
+	import { MDLinkParser } from 'meta-bind-core/src/parsers/MarkdownLinkParser';
 	import Button from 'meta-bind-core/src/utils/components/Button.svelte';
 	import LiteralRenderComponent from 'meta-bind-core/src/utils/components/LiteralRenderComponent.svelte';
 	import type { ContextMenuItemDefinition } from 'meta-bind-core/src/utils/IContextMenu';
@@ -9,6 +10,7 @@
 	const props: InputFieldSvelteProps<MBLiteral[]> & {
 		showSuggester: () => void;
 		showTextPrompt: () => void;
+		editLinkText: (index: number, value: MBLiteral) => void;
 		allowOther: boolean;
 	} = $props();
 
@@ -31,6 +33,16 @@
 	function openContextMenuForElement(e: MouseEvent, index: number): void {
 		const menuActions: ContextMenuItemDefinition[] = [];
 
+		const entry = value[index];
+		const isLink = typeof entry === 'string' && MDLinkParser.isLink(entry);
+		if (isLink) {
+			menuActions.push({
+				name: 'Edit link text',
+				icon: 'pencil',
+				onclick: () => props.editLinkText(index, entry),
+			});
+		}
+
 		if (index > 0) {
 			menuActions.push({
 				name: 'Move up',
@@ -72,7 +84,10 @@
 	{#each value as entry, i}
 		<div
 			class="mb-list-item"
-			oncontextmenu={e => openContextMenuForElement(e, i)}
+			oncontextmenu={e => {
+				e.preventDefault();
+				openContextMenuForElement(e, i);
+			}}
 			role="listitem"
 			data-value={stringifyLiteral(entry)}
 		>
diff --git a/packages/core/src/fields/inputFields/fields/ListSuggester/ListSuggesterIPF.ts b/packages/core/src/fields/inputFields/fields/ListSuggester/ListSuggesterIPF.ts
index a97dc6ec..7b7f001b 100644
--- a/packages/core/src/fields/inputFields/fields/ListSuggester/ListSuggesterIPF.ts
+++ b/packages/core/src/fields/inputFields/fields/ListSuggester/ListSuggesterIPF.ts
@@ -1,5 +1,6 @@
 import { InputFieldArgumentType } from 'meta-bind-core/src/config/FieldConfigs';
 import { AbstractInputField } from 'meta-bind-core/src/fields/inputFields/AbstractInputField';
+import { openLinkTextEditingModal } from 'meta-bind-core/src/fields/inputFields/fields/Suggester/SuggesterHelper';
 import type { InputFieldSvelteComponent } from 'meta-bind-core/src/fields/inputFields/InputFieldSvelteWrapper';
 import type { MBLiteral } from 'meta-bind-core/src/utils/Literal';
 import { parseUnknownToLiteralArray } from 'meta-bind-core/src/utils/Literal';
@@ -35,6 +36,7 @@ export class ListSuggesterIPF extends AbstractInputField<MBLiteral[], MBLiteral[
 		return {
 			showSuggester: () => this.openModal(),
 			showTextPrompt: () => this.openTextModal(),
+			editLinkText: (index: number, value: MBLiteral) => this.openLinkTextEditor(index, value),
 			allowOther: this.mountable.getArgument(InputFieldArgumentType.ALLOW_OTHER)?.value === true,
 		};
 	}
@@ -57,4 +59,35 @@ export class ListSuggesterIPF extends AbstractInputField<MBLiteral[], MBLiteral[
 			onCancel: () => {},
 		});
 	}
+
+	openLinkTextEditor(index: number, linkValue: MBLiteral): void {
+		if (typeof linkValue !== 'string') {
+			return;
+		}
+
+		// Validate that the index is within bounds
+		const currentValue = this.getInternalValue();
+		if (!Array.isArray(currentValue) || index < 0 || index >= currentValue.length) {
+			return;
+		}
+
+		const currentLink = linkValue;
+
+		openLinkTextEditingModal(
+			currentLink,
+			params => this.mountable.mb.internal.openTextPromptModal(params),
+			updatedLink => {
+				// Re-check the value, since the list may have changed (e.g. reordered or an
+				// item removed) while the modal was open.
+				const latestValue = this.getInternalValue();
+				if (!Array.isArray(latestValue) || latestValue[index] !== currentLink) {
+					return;
+				}
+
+				const updatedArray = [...latestValue];
+				updatedArray[index] = updatedLink;
+				this.setInternalValue(updatedArray);
+			},
+		);
+	}
 }
diff --git a/packages/core/src/fields/inputFields/fields/Suggester/SuggesterComponent.svelte b/packages/core/src/fields/inputFields/fields/Suggester/SuggesterComponent.svelte
index f2519800..4a2fe790 100644
--- a/packages/core/src/fields/inputFields/fields/Suggester/SuggesterComponent.svelte
+++ b/packages/core/src/fields/inputFields/fields/Suggester/SuggesterComponent.svelte
@@ -10,6 +10,7 @@
 	const props: InputFieldSvelteProps<MBLiteral> & {
 		showSuggester: () => void;
 		showTextPrompt: () => void;
+		editLinkText: () => void;
 		allowOther: boolean;
 	} = $props();
 
@@ -44,6 +45,11 @@
 	<Button variant={ButtonStyleType.PLAIN} onclick={props.showSuggester}>
 		<Icon mb={props.mb} iconName="list" />
 	</Button>
+	{#if mdLink !== undefined}
+		<Button variant={ButtonStyleType.PLAIN} onclick={props.editLinkText} tooltip="Edit link text">
+			<Icon mb={props.mb} iconName="pencil" />
+		</Button>
+	{/if}
 	{#if props.allowOther}
 		<Button variant={ButtonStyleType.PLAIN} onclick={props.showTextPrompt}>
 			<Icon mb={props.mb} iconName="pencil" />
diff --git a/packages/core/src/fields/inputFields/fields/Suggester/SuggesterHelper.ts b/packages/core/src/fields/inputFields/fields/Suggester/SuggesterHelper.ts
index f37355ae..c8af6f2f 100644
--- a/packages/core/src/fields/inputFields/fields/Suggester/SuggesterHelper.ts
+++ b/packages/core/src/fields/inputFields/fields/Suggester/SuggesterHelper.ts
@@ -3,11 +3,25 @@ import type { ImageSuggesterIPF } from 'meta-bind-core/src/fields/inputFields/fi
 import type { InlineListSuggesterIPF } from 'meta-bind-core/src/fields/inputFields/fields/InlineListSuggester/InlineListSuggesterIPF';
 import type { ListSuggesterIPF } from 'meta-bind-core/src/fields/inputFields/fields/ListSuggester/ListSuggesterIPF';
 import type { SuggesterIPF } from 'meta-bind-core/src/fields/inputFields/fields/Suggester/SuggesterIPF';
+import { MDLinkParser } from 'meta-bind-core/src/parsers/MarkdownLinkParser';
+import type { MBLiteral } from 'meta-bind-core/src/utils/Literal';
 
 export type SuggesterLikeIFP = SuggesterIPF | ListSuggesterIPF | InlineListSuggesterIPF;
 
 export type ImageSuggesterLikeIPF = ImageSuggesterIPF | ImageListSuggesterIPF;
 
+/**
+ * Callback signature for opening a text prompt modal.
+ */
+export type TextPromptModalCallback = (params: {
+	title: string;
+	subTitle: string;
+	value: string;
+	multiline: boolean;
+	onSubmit: (value: MBLiteral) => void;
+	onCancel: () => void;
+}) => void;
+
 export class SuggesterOption<T> {
 	value: T;
 	displayValue: string;
@@ -23,3 +37,52 @@ export class SuggesterOption<T> {
 		return this.value?.toString() ?? 'null';
 	}
 }
+
+/**
+ * Opens a modal for editing the display text (alias) of a markdown/wiki link.
+ *
+ * @param currentLinkValue - The current link string to edit
+ * @param openTextModal - Callback to open the text prompt modal
+ * @param onLinkUpdated - Callback invoked with the updated link string when the user submits
+ */
+export function openLinkTextEditingModal(
+	currentLinkValue: string,
+	openTextModal: TextPromptModalCallback,
+	onLinkUpdated: (updatedLink: string) => void,
+): void {
+	let linkText = '';
+	try {
+		if (MDLinkParser.isLink(currentLinkValue)) {
+			const link = MDLinkParser.parseLink(currentLinkValue);
+			linkText = link.alias ?? link.target;
+		} else {
+			linkText = currentLinkValue;
+		}
+	} catch (e) {
+		console.warn('meta-bind | failed to parse link for editing', e);
+		linkText = currentLinkValue;
+	}
+
+	openTextModal({
+		title: 'Edit Link Text',
+		subTitle: 'Modify the link display text.',
+		value: linkText,
+		multiline: false,
+		onSubmit: (newLinkText: MBLiteral) => {
+			if (typeof newLinkText !== 'string') {
+				return;
+			}
+
+			try {
+				if (MDLinkParser.isLink(currentLinkValue)) {
+					const link = MDLinkParser.parseLink(currentLinkValue);
+					link.alias = newLinkText;
+					onLinkUpdated(link.toString());
+				}
+			} catch (e) {
+				console.warn('meta-bind | failed to update link text', e);
+			}
+		},
+		onCancel: () => {},
+	});
+}
diff --git a/packages/core/src/fields/inputFields/fields/Suggester/SuggesterIPF.ts b/packages/core/src/fields/inputFields/fields/Suggester/SuggesterIPF.ts
index c8aa7482..95a799be 100644
--- a/packages/core/src/fields/inputFields/fields/Suggester/SuggesterIPF.ts
+++ b/packages/core/src/fields/inputFields/fields/Suggester/SuggesterIPF.ts
@@ -1,5 +1,6 @@
 import { InputFieldArgumentType } from 'meta-bind-core/src/config/FieldConfigs';
 import { AbstractInputField } from 'meta-bind-core/src/fields/inputFields/AbstractInputField';
+import { openLinkTextEditingModal } from 'meta-bind-core/src/fields/inputFields/fields/Suggester/SuggesterHelper';
 import type { InputFieldSvelteComponent } from 'meta-bind-core/src/fields/inputFields/InputFieldSvelteWrapper';
 import type { MBLiteral } from 'meta-bind-core/src/utils/Literal';
 import { parseUnknownToLiteral } from 'meta-bind-core/src/utils/Literal';
@@ -31,6 +32,7 @@ export class SuggesterIPF extends AbstractInputField<MBLiteral, MBLiteral> {
 		return {
 			showSuggester: () => this.openModal(),
 			showTextPrompt: () => this.openTextModal(),
+			editLinkText: () => this.openLinkTextEditor(),
 			allowOther: this.mountable.getArgument(InputFieldArgumentType.ALLOW_OTHER)?.value === true,
 		};
 	}
@@ -51,4 +53,19 @@ export class SuggesterIPF extends AbstractInputField<MBLiteral, MBLiteral> {
 			onCancel: () => {},
 		});
 	}
+
+	openLinkTextEditor(): void {
+		const currentValue = this.getInternalValue();
+		if (!currentValue || typeof currentValue !== 'string') {
+			return;
+		}
+
+		openLinkTextEditingModal(
+			currentValue,
+			params => this.mountable.mb.internal.openTextPromptModal(params),
+			updatedLink => {
+				this.setInternalValue(updatedLink);
+			},
+		);
+	}
 }
diff --git a/packages/core/tests/fields/LinkTextEditing.test.ts b/packages/core/tests/fields/LinkTextEditing.test.ts
new file mode 100644
index 00000000..877438c1
--- /dev/null
+++ b/packages/core/tests/fields/LinkTextEditing.test.ts
@@ -0,0 +1,375 @@
+import { beforeEach, describe, expect, test, spyOn } from 'bun:test';
+import { InputFieldType } from 'meta-bind-core/src/config/FieldConfigs';
+import type { ListSuggesterIPF } from 'meta-bind-core/src/fields/inputFields/fields/ListSuggester/ListSuggesterIPF';
+import type { InlineListSuggesterIPF } from 'meta-bind-core/src/fields/inputFields/fields/InlineListSuggester/InlineListSuggesterIPF';
+import { MDLinkParser } from 'meta-bind-core/src/parsers/MarkdownLinkParser';
+import { DEFAULT_VALUE_INDICATOR, TestMetaBind } from '../__mocks__/TestPlugin';
+
+const TEST_FILE_PATH = 'testFile';
+const TEST_PROP = 'testProp';
+
+describe('Link Text Editing', () => {
+	let testPlugin: TestMetaBind;
+
+	beforeEach(() => {
+		testPlugin = new TestMetaBind();
+	});
+
+	describe('Suggester IPF link text editing', () => {
+		test('should extract alias from link when opening editor', () => {
+			const index = testPlugin.addTestInputField(
+				`INPUT[${InputFieldType.SUGGESTER}(option([[file|myAlias]]), option(plain)):${TEST_PROP}]`,
+			);
+
+			testPlugin.initializeTest();
+			testPlugin.createInitialCache({ [TEST_PROP]: '[[file|myAlias]]' });
+			testPlugin.initializeAllTestInputFields();
+
+			// Verify the field loaded the link correctly
+			expect(testPlugin.getTestInputFieldValue(index)).toBe('[[file|myAlias]]');
+
+			// Verify we can parse the link from the current value
+			const currentValue = testPlugin.getTestInputFieldValue(index);
+			if (typeof currentValue === 'string' && MDLinkParser.isLink(currentValue)) {
+				const link = MDLinkParser.parseLink(currentValue);
+				expect(link.alias).toBe('myAlias');
+			}
+		});
+
+		test('should extract target when link has no alias', () => {
+			const index = testPlugin.addTestInputField(
+				`INPUT[${InputFieldType.SUGGESTER}(option([[file]]), option(plain)):${TEST_PROP}]`,
+			);
+
+			testPlugin.initializeTest();
+			testPlugin.createInitialCache({ [TEST_PROP]: '[[file]]' });
+			testPlugin.initializeAllTestInputFields();
+
+			const currentValue = testPlugin.getTestInputFieldValue(index);
+			if (typeof currentValue === 'string' && MDLinkParser.isLink(currentValue)) {
+				const link = MDLinkParser.parseLink(currentValue);
+				// Should fall back to target when no alias
+				const displayText = link.alias ?? link.target;
+				expect(displayText).toBe('file');
+			}
+		});
+
+		test('should update link alias when modified', () => {
+			const index = testPlugin.addTestInputField(
+				`INPUT[${InputFieldType.SUGGESTER}(option([[file|old]]), option(plain)):${TEST_PROP}]`,
+			);
+
+			testPlugin.initializeTest();
+			testPlugin.createInitialCache({ [TEST_PROP]: '[[file|old]]' });
+			testPlugin.initializeAllTestInputFields();
+
+			// Simulate modifying the link's alias
+			const currentValue = testPlugin.getTestInputFieldValue(index) as string;
+			const link = MDLinkParser.parseLink(currentValue);
+			link.alias = 'new';
+			testPlugin.setTestInputFieldValue(index, link.toString());
+
+			// Verify the change persisted
+			expect(testPlugin.getTestInputFieldValue(index)).toBe('[[file|new]]');
+			expect(testPlugin.getCacheMetadata()?.[TEST_PROP]).toBe('[[file|new]]');
+		});
+
+		test('should handle adding alias to link without one', () => {
+			const index = testPlugin.addTestInputField(
+				`INPUT[${InputFieldType.SUGGESTER}(option([[file]]), option(plain)):${TEST_PROP}]`,
+			);
+
+			testPlugin.initializeTest();
+			testPlugin.createInitialCache({ [TEST_PROP]: '[[file]]' });
+			testPlugin.initializeAllTestInputFields();
+
+			// Simulate adding an alias to a link
+			const currentValue = testPlugin.getTestInputFieldValue(index) as string;
+			const link = MDLinkParser.parseLink(currentValue);
+			link.alias = 'New Display';
+			testPlugin.setTestInputFieldValue(index, link.toString());
+
+			expect(testPlugin.getTestInputFieldValue(index)).toBe('[[file|New Display]]');
+		});
+
+		test('should preserve markdown link format during alias modification', () => {
+			const index = testPlugin.addTestInputField(
+				`INPUT[${InputFieldType.SUGGESTER}(option(plain text), option(other)):${TEST_PROP}]`,
+			);
+
+			testPlugin.initializeTest();
+			testPlugin.createInitialCache({ [TEST_PROP]: '[Display](https://example.com)' });
+			testPlugin.initializeAllTestInputFields();
+
+			const currentValue = testPlugin.getTestInputFieldValue(index) as string;
+			const link = MDLinkParser.parseLink(currentValue);
+			link.alias = 'New Display';
+			testPlugin.setTestInputFieldValue(index, link.toString());
+
+			expect(testPlugin.getTestInputFieldValue(index)).toBe('[New Display](https://example.com)');
+		});
+
+		test('should handle non-link values gracefully', () => {
+			const index = testPlugin.addTestInputField(
+				`INPUT[${InputFieldType.SUGGESTER}(option(plain text), option(other)):${TEST_PROP}]`,
+			);
+
+			testPlugin.initializeTest();
+			testPlugin.createInitialCache({ [TEST_PROP]: 'plain text' });
+			testPlugin.initializeAllTestInputFields();
+
+			// Plain text should remain unchanged
+			expect(testPlugin.getTestInputFieldValue(index)).toBe('plain text');
+
+			// Verify it's not a valid link
+			const value = testPlugin.getTestInputFieldValue(index);
+			if (typeof value === 'string') {
+				expect(() => MDLinkParser.isLink(value)).not.toThrow();
+				expect(MDLinkParser.isLink(value)).toBe(false);
+			}
+		});
+	});
+
+	describe('ListSuggester IPF link text editing', () => {
+		test('should allow editing individual link aliases in list', () => {
+			const index = testPlugin.addTestInputField(
+				`INPUT[${InputFieldType.LIST_SUGGESTER}(option([[file1|alias1]]), option([[file2]])):${TEST_PROP}]`,
+			);
+
+			testPlugin.initializeTest();
+			testPlugin.createInitialCache({ [TEST_PROP]: ['[[file1|alias1]]', '[[file2]]'] });
+			testPlugin.initializeAllTestInputFields();
+
+			// Simulate modifying the first link's alias
+			const currentValues = testPlugin.getTestInputFieldValue(index) as string[];
+			const link = MDLinkParser.parseLink(currentValues[0]);
+			link.alias = 'modified';
+
+			const updatedValues = [...currentValues];
+			updatedValues[0] = link.toString();
+			testPlugin.setTestInputFieldValue(index, updatedValues);
+
+			const result = testPlugin.getTestInputFieldValue(index) as string[];
+			expect(result[0]).toBe('[[file1|modified]]');
+			expect(result[1]).toBe('[[file2]]');
+		});
+
+		test('should preserve list order when editing links', () => {
+			const index = testPlugin.addTestInputField(
+				`INPUT[${InputFieldType.LIST_SUGGESTER}(option([[a]]), option([[b]]), option([[c]])):${TEST_PROP}]`,
+			);
+
+			testPlugin.initializeTest();
+			testPlugin.createInitialCache({ [TEST_PROP]: ['[[a]]', '[[b]]', '[[c]]'] });
+			testPlugin.initializeAllTestInputFields();
+
+			// Edit the middle item
+			const currentValues = testPlugin.getTestInputFieldValue(index) as string[];
+			const link = MDLinkParser.parseLink(currentValues[1]);
+			link.alias = 'B';
+
+			const updatedValues = [...currentValues];
+			updatedValues[1] = link.toString();
+			testPlugin.setTestInputFieldValue(index, updatedValues);
+
+			const result = testPlugin.getTestInputFieldValue(index) as string[];
+			expect(result).toEqual(['[[a]]', '[[b|B]]', '[[c]]']);
+		});
+
+		test('should handle mix of links and non-links in list', () => {
+			const index = testPlugin.addTestInputField(
+				`INPUT[${InputFieldType.LIST_SUGGESTER}(option([[file]]), option(text)):${TEST_PROP}]`,
+			);
+
+			testPlugin.initializeTest();
+			testPlugin.createInitialCache({ [TEST_PROP]: ['[[file]]', 'plain text', '[[other]]'] });
+			testPlugin.initializeAllTestInputFields();
+
+			const currentValues = testPlugin.getTestInputFieldValue(index) as string[];
+			expect(currentValues).toEqual(['[[file]]', 'plain text', '[[other]]']);
+
+			// Edit only the first link, leave plain text and last link alone
+			const link1 = MDLinkParser.parseLink(currentValues[0]);
+			link1.alias = 'File';
+
+			const updatedValues = [...currentValues];
+			updatedValues[0] = link1.toString();
+			testPlugin.setTestInputFieldValue(index, updatedValues);
+
+			const result = testPlugin.getTestInputFieldValue(index) as string[];
+			expect(result).toEqual(['[[file|File]]', 'plain text', '[[other]]']);
+		});
+
+		test('openLinkTextEditor should ignore an out-of-bounds index without throwing', () => {
+			const index = testPlugin.addTestInputField(
+				`INPUT[${InputFieldType.LIST_SUGGESTER}(option([[file]])):${TEST_PROP}]`,
+			);
+
+			testPlugin.initializeTest();
+			testPlugin.createInitialCache({ [TEST_PROP]: ['[[file]]'] });
+			testPlugin.initializeAllTestInputFields();
+
+			const field = testPlugin.getTestInputField(index).field as ListSuggesterIPF;
+			const openTextPromptModalSpy = spyOn(testPlugin.internal, 'openTextPromptModal').mockImplementation(
+				() => {},
+			);
+
+			expect(() => field.openLinkTextEditor(5, '[[file]]')).not.toThrow();
+			expect(openTextPromptModalSpy).not.toHaveBeenCalled();
+
+			openTextPromptModalSpy.mockRestore();
+		});
+
+		test('should not apply an edit if the list changed while the editor modal was open', () => {
+			const index = testPlugin.addTestInputField(
+				`INPUT[${InputFieldType.LIST_SUGGESTER}(option([[file1|alias1]]), option([[file2]])):${TEST_PROP}]`,
+			);
+
+			testPlugin.initializeTest();
+			testPlugin.createInitialCache({ [TEST_PROP]: ['[[file1|alias1]]', '[[file2]]'] });
+			testPlugin.initializeAllTestInputFields();
+
+			const field = testPlugin.getTestInputField(index).field as ListSuggesterIPF;
+			const openTextPromptModalSpy = spyOn(testPlugin.internal, 'openTextPromptModal').mockImplementation(
+				() => {},
+			);
+
+			field.openLinkTextEditor(0, '[[file1|alias1]]');
+			const { onSubmit } = openTextPromptModalSpy.mock.calls[0][0];
+
+			// Simulate the list changing (e.g. the item being removed) while the modal was still open.
+			testPlugin.setTestInputFieldValue(index, ['[[file2]]']);
+		});
+	});
+
+	describe('InlineListSuggester IPF link text editing', () => {
+		test('should allow editing individual link aliases in inline list', () => {
+			const index = testPlugin.addTestInputField(
+				`INPUT[${InputFieldType.INLINE_LIST_SUGGESTER}(option([[file1]]), option([[file2]])):${TEST_PROP}]`,
+			);
+
+			testPlugin.initializeTest();
+			testPlugin.createInitialCache({ [TEST_PROP]: ['[[file1]]', '[[file2]]'] });
+			testPlugin.initializeAllTestInputFields();
+
+			// Simulate modifying the first link's alias
+			const currentValues = testPlugin.getTestInputFieldValue(index) as string[];
+			const link = MDLinkParser.parseLink(currentValues[0]);
+			link.alias = 'File One';
+
+			const updatedValues = [...currentValues];
+			updatedValues[0] = link.toString();
+			testPlugin.setTestInputFieldValue(index, updatedValues);
+
+			const result = testPlugin.getTestInputFieldValue(index) as string[];
+			expect(result[0]).toBe('[[file1|File One]]');
+			expect(result[1]).toBe('[[file2]]');
+		});
+
+		test('should preserve inline list structure when editing', () => {
+			const index = testPlugin.addTestInputField(
+				`INPUT[${InputFieldType.INLINE_LIST_SUGGESTER}(option([[a]]), option([[b]]), option([[c]]), option([[d]])):${TEST_PROP}]`,
+			);
+
+			testPlugin.initializeTest();
+			testPlugin.createInitialCache({ [TEST_PROP]: ['[[a]]', '[[b]]', '[[c]]', '[[d]]'] });
+			testPlugin.initializeAllTestInputFields();
+
+			// Edit multiple items
+			const currentValues = testPlugin.getTestInputFieldValue(index) as string[];
+
+			const updatedValues = [...currentValues];
+			for (let i = 0; i < updatedValues.length; i++) {
+				if (MDLinkParser.isLink(updatedValues[i])) {
+					const link = MDLinkParser.parseLink(updatedValues[i]);
+					link.alias = `Item ${i + 1}`;
+					updatedValues[i] = link.toString();
+				}
+			}
+
+			testPlugin.setTestInputFieldValue(index, updatedValues);
+
+			const result = testPlugin.getTestInputFieldValue(index) as string[];
+			expect(result).toEqual(['[[a|Item 1]]', '[[b|Item 2]]', '[[c|Item 3]]', '[[d|Item 4]]']);
+		});
+
+		test('should not apply an edit if the list changed while the editor modal was open', () => {
+			const index = testPlugin.addTestInputField(
+				`INPUT[${InputFieldType.INLINE_LIST_SUGGESTER}(option([[file1|alias1]]), option([[file2]])):${TEST_PROP}]`,
+			);
+
+			testPlugin.initializeTest();
+			testPlugin.createInitialCache({ [TEST_PROP]: ['[[file1|alias1]]', '[[file2]]'] });
+			testPlugin.initializeAllTestInputFields();
+
+			const field = testPlugin.getTestInputField(index).field as InlineListSuggesterIPF;
+			const openTextPromptModalSpy = spyOn(testPlugin.internal, 'openTextPromptModal').mockImplementation(
+				() => {},
+			);
+
+			field.openLinkTextEditor(0, '[[file1|alias1]]');
+			const { onSubmit } = openTextPromptModalSpy.mock.calls[0][0];
+
+			// Simulate the list changing (e.g. the item being reordered) while the modal was still open.
+			testPlugin.setTestInputFieldValue(index, ['[[file2]]', '[[file1|alias1]]']);
+
+			onSubmit('should not be applied');
+
+			expect(testPlugin.getTestInputFieldValue(index)).toEqual(['[[file2]]', '[[file1|alias1]]']);
+
+			openTextPromptModalSpy.mockRestore();
+		});
+
+		test('should handle empty inline list', () => {
+			const index = testPlugin.addTestInputField(
+				`INPUT[${InputFieldType.INLINE_LIST_SUGGESTER}(option([[a]])):${TEST_PROP}]`,
+			);
+
+			testPlugin.initializeTest();
+			testPlugin.createInitialCache({ [TEST_PROP]: [] });
+			testPlugin.initializeAllTestInputFields();
+
+			expect(testPlugin.getTestInputFieldValue(index)).toEqual([]);
+		});
+	});
+
+	describe('Link text preservation', () => {
+		test('should preserve link target when editing alias', () => {
+			const originalLink = '[[path/to/myfile|oldAlias]]';
+			const link = MDLinkParser.parseLink(originalLink);
+
+			// Edit the alias
+			link.alias = 'newAlias';
+			const result = link.toString();
+
+			// Target should remain unchanged
+			expect(result).toBe('[[path/to/myfile|newAlias]]');
+			expect(MDLinkParser.parseLink(result).target).toBe('path/to/myfile');
+		});
+
+		test('should preserve block reference when editing alias', () => {
+			const originalLink = '[[file#section|old]]';
+			const link = MDLinkParser.parseLink(originalLink);
+
+			link.alias = 'new';
+			const result = link.toString();
+
+			const modified = MDLinkParser.parseLink(result);
+			expect(modified.target).toBe('file');
+			expect(modified.block).toBe('section');
+			expect(modified.alias).toBe('new');
+		});
+
+		test('should preserve embed status when editing alias', () => {
+			const originalLink = '![[file|old]]';
+			const link = MDLinkParser.parseLink(originalLink);
+
+			link.alias = 'new';
+			const result = link.toString();
+
+			const modified = MDLinkParser.parseLink(result);
+			expect(modified.isEmbed).toBe(true);
+			expect(modified.alias).toBe('new');
+		});
+	});
+});
diff --git a/packages/core/tests/parserTests/MarkdownLinkParser.test.ts b/packages/core/tests/parserTests/MarkdownLinkParser.test.ts
index 0cb42cc5..216d8acf 100644
--- a/packages/core/tests/parserTests/MarkdownLinkParser.test.ts
+++ b/packages/core/tests/parserTests/MarkdownLinkParser.test.ts
@@ -201,4 +201,81 @@ describe('markdown link parser', () => {
 			).toThrow();
 		});
 	});
+
+	describe('serialize link with toString', () => {
+		test('should serialize wiki link without alias', () => {
+			const link = MDLinkParser.parseLink('[[test]]');
+			expect(link.toString()).toBe('[[test]]');
+		});
+
+		test('should serialize wiki link with alias', () => {
+			const link = MDLinkParser.parseLink('[[test|display]]');
+			expect(link.toString()).toBe('[[test|display]]');
+		});
+
+		test('should serialize wiki link with block', () => {
+			const link = MDLinkParser.parseLink('[[test#123]]');
+			expect(link.toString()).toBe('[[test#123]]');
+		});
+
+		test('should serialize wiki link with block and alias', () => {
+			const link = MDLinkParser.parseLink('[[test#123|display]]');
+			expect(link.toString()).toBe('[[test#123|display]]');
+		});
+
+		test('should serialize external markdown link', () => {
+			const link = MDLinkParser.parseLink('[github](https://github.com)');
+			expect(link.toString()).toBe('[github](https://github.com)');
+		});
+
+		test('should serialize external markdown image link', () => {
+			const link = MDLinkParser.parseLink('![alt](https://example.com/image.png)');
+			expect(link.toString()).toBe('![alt](https://example.com/image.png)');
+		});
+	});
+
+	describe('modify link alias and serialize', () => {
+		test('should add alias to wiki link without alias', () => {
+			const link = MDLinkParser.parseLink('[[test]]');
+			link.alias = 'custom text';
+			expect(link.toString()).toBe('[[test|custom text]]');
+		});
+
+		test('should change existing alias on wiki link', () => {
+			const link = MDLinkParser.parseLink('[[test|old alias]]');
+			link.alias = 'new alias';
+			expect(link.toString()).toBe('[[test|new alias]]');
+		});
+
+		test('should change alias while preserving block reference', () => {
+			const link = MDLinkParser.parseLink('[[test#123|old alias]]');
+			link.alias = 'new alias';
+			expect(link.toString()).toBe('[[test#123|new alias]]');
+		});
+
+		test('should change alias on external markdown link', () => {
+			const link = MDLinkParser.parseLink('[old](https://github.com)');
+			link.alias = 'GitHub';
+			expect(link.toString()).toBe('[GitHub](https://github.com)');
+		});
+
+		test('should change alias on external markdown image link', () => {
+			const link = MDLinkParser.parseLink('![old alt](https://example.com/image.png)');
+			link.alias = 'new alt';
+			expect(link.toString()).toBe('![new alt](https://example.com/image.png)');
+		});
+
+		test('should handle empty alias string', () => {
+			const link = MDLinkParser.parseLink('[[test|original]]');
+			link.alias = '';
+			// Empty string is falsy, so it won't render the alias in toString
+			expect(link.toString()).toBe('[[test]]');
+		});
+
+		test('should clear alias by setting to undefined', () => {
+			const link = MDLinkParser.parseLink('[[test|alias]]');
+			link.alias = undefined;
+			expect(link.toString()).toBe('[[test]]');
+		});
+	});
 });
diff --git a/packages/obsidian/src/modals/SuggesterModalHelper.ts b/packages/obsidian/src/modals/SuggesterModalHelper.ts
index f34ad868..0c9eb5d0 100644
--- a/packages/obsidian/src/modals/SuggesterModalHelper.ts
+++ b/packages/obsidian/src/modals/SuggesterModalHelper.ts
@@ -6,6 +6,7 @@ import { applyUseLinksArgument } from 'meta-bind-core/src/fields/fieldArguments/
 import type { SuggesterLikeIFP } from 'meta-bind-core/src/fields/inputFields/fields/Suggester/SuggesterHelper';
 import { SuggesterOption } from 'meta-bind-core/src/fields/inputFields/fields/Suggester/SuggesterHelper';
 import { deduplicateOptions } from 'meta-bind-core/src/fields/inputFields/optionSource/OptionSourceUtils';
+import { MDLinkParser } from 'meta-bind-core/src/parsers/MarkdownLinkParser';
 import type { MBLiteral } from 'meta-bind-core/src/utils/Literal';
 import type { ObsMetaBind } from 'meta-bind-obsidian/src/ObsMB';
 import { getDataViewPluginAPI } from 'meta-bind-obsidian/src/ObsUtils';
@@ -13,6 +14,66 @@ import { Notice } from 'obsidian';
 import type { DataArray, DataviewApi, Literal } from 'obsidian-dataview';
 import { z } from 'zod';
 
+/**
+ * Creates a new link string with the given alias as the display text.
+ * If the input is not a link, returns it unchanged.
+ */
+export function createLinkWithAlias(linkStr: string, alias: string): string {
+	try {
+		if (MDLinkParser.isLink(linkStr)) {
+			const link = MDLinkParser.parseLink(linkStr);
+			link.alias = alias;
+			return link.toString();
+		}
+	} catch (e) {
+		console.warn('meta-bind | failed to create link with alias', e);
+	}
+	return linkStr;
+}
+
+/**
+ * Builds the additional suggester options for a file's aliases (Dataview's `file.aliases`).
+ *
+ * - Skips aliases that are identical to the file name, since they would just duplicate the
+ *   file option already added for `link` (case-sensitive but whitespace-trimmed comparison).
+ * - Logs a warning instead of throwing if `aliases` is present but not an array, since Dataview
+ *   does not guarantee the shape of frontmatter values.
+ */
+export function getAliasSuggesterOptions(
+	link: string,
+	dvFileName: string,
+	dvFilePath: string,
+	aliases: unknown,
+): SuggesterOption<MBLiteral>[] {
+	if (aliases === undefined || aliases === null) {
+		return [];
+	}
+
+	if (!Array.isArray(aliases)) {
+		console.warn(`meta-bind | expected "aliases" on "${dvFilePath}" to be an array, got "${typeof aliases}"`);
+		return [];
+	}
+
+	const options: SuggesterOption<MBLiteral>[] = [];
+	const normalizedFileName = dvFileName.trim();
+
+	for (const alias of aliases) {
+		if (typeof alias !== 'string') {
+			continue;
+		}
+
+		const trimmedAlias = alias.trim();
+		if (!trimmedAlias || trimmedAlias === normalizedFileName) {
+			continue;
+		}
+
+		const linkWithAlias = createLinkWithAlias(link, trimmedAlias);
+		options.push(new SuggesterOption<MBLiteral>(linkWithAlias, trimmedAlias, `alias of: ${dvFilePath}`));
+	}
+
+	return options;
+}
+
 export function getSuggesterOptions(
 	mb: ObsMetaBind,
 	filePath: string,
@@ -60,6 +121,9 @@ export function getSuggesterOptions(
 
 					const link = applyUseLinksArgument(dvFile.path, dvFile.name, useLinks);
 					options.push(new SuggesterOption<MBLiteral>(link, dvFile.name, `file: ${dvFile.path}`));
+
+					// Add aliases as additional selectable options with the alias as the link text
+					options.push(...getAliasSuggesterOptions(link, dvFile.name, dvFile.path, file.aliases));
 				} catch (e) {
 					console.warn('meta-bind | error while computing suggest options', e);
 				}
diff --git a/packages/obsidian/tests/modals/SuggesterModalHelper.test.ts b/packages/obsidian/tests/modals/SuggesterModalHelper.test.ts
new file mode 100644
index 00000000..e4bcd997
--- /dev/null
+++ b/packages/obsidian/tests/modals/SuggesterModalHelper.test.ts
@@ -0,0 +1,146 @@
+import { describe, expect, spyOn, test } from 'bun:test';
+import { createLinkWithAlias, getAliasSuggesterOptions } from 'meta-bind-obsidian/src/modals/SuggesterModalHelper';
+
+describe('createLinkWithAlias', () => {
+	describe('wiki links', () => {
+		test('should create link with alias from plain wiki link', () => {
+			const result = createLinkWithAlias('[[myfile]]', 'My Alias');
+			expect(result).toBe('[[myfile|My Alias]]');
+		});
+
+		test('should replace existing alias on wiki link', () => {
+			const result = createLinkWithAlias('[[myfile|oldAlias]]', 'newAlias');
+			expect(result).toBe('[[myfile|newAlias]]');
+		});
+
+		test('should preserve block reference when adding alias', () => {
+			const result = createLinkWithAlias('[[myfile#section]]', 'Display Text');
+			expect(result).toBe('[[myfile#section|Display Text]]');
+		});
+
+		test('should preserve block reference when replacing alias', () => {
+			const result = createLinkWithAlias('[[myfile#section|old]]', 'new');
+			expect(result).toBe('[[myfile#section|new]]');
+		});
+
+		test('should handle embedded links', () => {
+			const result = createLinkWithAlias('![[myfile]]', 'Alt Text');
+			expect(result).toBe('![[myfile|Alt Text]]');
+		});
+
+		test('should handle spaces in alias', () => {
+			const result = createLinkWithAlias('[[myfile]]', 'Multi Word Alias');
+			expect(result).toBe('[[myfile|Multi Word Alias]]');
+		});
+	});
+
+	describe('markdown links', () => {
+		test('should replace alias on markdown link', () => {
+			const result = createLinkWithAlias('[old text](path/to/file)', 'new text');
+			expect(result).toBe('[new text](path/to/file)');
+		});
+
+		test('should replace alias on markdown image link', () => {
+			const result = createLinkWithAlias('![old alt](path/to/image)', 'new alt');
+			expect(result).toBe('![new alt](path/to/image)');
+		});
+
+		test('should replace alias on external markdown link', () => {
+			const result = createLinkWithAlias('[old](https://example.com)', 'new');
+			expect(result).toBe('[new](https://example.com)');
+		});
+	});
+
+	describe('non-link inputs', () => {
+		test('should return plain text unchanged', () => {
+			const result = createLinkWithAlias('plain text', 'alias');
+			expect(result).toBe('plain text');
+		});
+
+		test('should return empty string unchanged', () => {
+			const result = createLinkWithAlias('', 'alias');
+			expect(result).toBe('');
+		});
+
+		test('should return malformed link unchanged', () => {
+			const result = createLinkWithAlias('[incomplete link', 'alias');
+			expect(result).toBe('[incomplete link');
+		});
+
+		test('should handle null-like string gracefully', () => {
+			const result = createLinkWithAlias('null', 'alias');
+			expect(result).toBe('null');
+		});
+	});
+
+	describe('edge cases', () => {
+		test('should handle empty alias string', () => {
+			const result = createLinkWithAlias('[[file]]', '');
+			expect(result).toBe('[[file|]]');
+		});
+
+		test('should handle alias with special characters', () => {
+			const result = createLinkWithAlias('[[file]]', '@#$%^&*()');
+			expect(result).toBe('[[file|@#$%^&*()]]');
+		});
+
+		test('should handle unicode in alias', () => {
+			const result = createLinkWithAlias('[[file]]', '文件 (File)');
+			expect(result).toBe('[[file|文件 (File)]]');
+		});
+
+		test('should handle pipe character in alias', () => {
+			const result = createLinkWithAlias('[[file]]', 'text | with | pipes');
+			expect(result).toBe('[[file|text | with | pipes]]');
+		});
+	});
+});
+
+describe('getAliasSuggesterOptions', () => {
+	test('should create an option for each alias', () => {
+		const options = getAliasSuggesterOptions('[[file]]', 'file', 'folder/file.md', ['Alias One', 'Alias Two']);
+
+		expect(options.map(o => o.value)).toEqual(['[[file|Alias One]]', '[[file|Alias Two]]']);
+		expect(options.map(o => o.displayValue)).toEqual(['Alias One', 'Alias Two']);
+	});
+
+	test('should skip an alias that is identical to the file name', () => {
+		const options = getAliasSuggesterOptions('[[file]]', 'file', 'folder/file.md', ['file', 'Real Alias']);
+
+		expect(options.map(o => o.displayValue)).toEqual(['Real Alias']);
+	});
+
+	test('should skip a file-name-matching alias case-insensitively and ignoring whitespace', () => {
+		const options = getAliasSuggesterOptions('[[file]]', 'file', 'folder/file.md', [' File ', 'FILE']);
+
+		expect(options).toEqual([]);
+	});
+
+	test('should skip empty or whitespace-only aliases', () => {
+		const options = getAliasSuggesterOptions('[[file]]', 'file', 'folder/file.md', ['', '   ']);
+
+		expect(options).toEqual([]);
+	});
+
+	test('should ignore non-string entries in the aliases array', () => {
+		const options = getAliasSuggesterOptions('[[file]]', 'file', 'folder/file.md', [123, null, 'Valid Alias']);
+
+		expect(options.map(o => o.displayValue)).toEqual(['Valid Alias']);
+	});
+
+	test('should return no options and not throw when aliases is undefined or null', () => {
+		expect(getAliasSuggesterOptions('[[file]]', 'file', 'folder/file.md', undefined)).toEqual([]);
+		expect(getAliasSuggesterOptions('[[file]]', 'file', 'folder/file.md', null)).toEqual([]);
+	});
+
+	test('should warn and return no options when aliases is present but not an array', () => {
+		const warnSpy = spyOn(console, 'warn').mockImplementation(() => {});
+
+		const options = getAliasSuggesterOptions('[[file]]', 'file', 'folder/file.md', 'Not An Array');
+
+		expect(options).toEqual([]);
+		expect(warnSpy).toHaveBeenCalled();
+
+		warnSpy.mockRestore();
+	});
+});