diff --git a/src/LanguageServer.spec.ts b/src/LanguageServer.spec.ts
index 48535c302..3283c51fb 100644
--- a/src/LanguageServer.spec.ts
+++ b/src/LanguageServer.spec.ts
@@ -1554,7 +1554,7 @@ describe('LanguageServer', () => {
             });
 
             expect(locations.length).to.equal(1);
-            const location: Location = locations[0];
+            const location: Location = locations[0] as Location;
             expect(location.uri).to.equal(functionDocument.uri);
             expect(location.range.start.line).to.equal(5);
             expect(location.range.start.character).to.equal(16);
@@ -1569,7 +1569,7 @@ describe('LanguageServer', () => {
             });
 
             expect(locations.length).to.equal(1);
-            const location: Location = locations[0];
+            const location: Location = locations[0] as Location;
             expect(location.uri).to.equal(functionDocument.uri);
             expect(location.range.start.line).to.equal(5);
             expect(location.range.start.character).to.equal(16);
@@ -1594,7 +1594,7 @@ describe('LanguageServer', () => {
                 position: util.createPosition(3, 36)
             });
             expect(locations.length).to.equal(1);
-            const location: Location = locations[0];
+            const location: Location = locations[0] as Location;
             expect(location.uri).to.equal(referenceDocument.uri);
             expect(location.range.start.line).to.equal(2);
             expect(location.range.start.character).to.equal(20);
@@ -1629,7 +1629,7 @@ describe('LanguageServer', () => {
                 position: util.createPosition(3, 30)
             });
             expect(locations.length).to.equal(1);
-            const location: Location = locations[0];
+            const location: Location = locations[0] as Location;
             expect(location.uri).to.equal(functionDocument.uri);
             expect(location.range.start.line).to.equal(2);
             expect(location.range.start.character).to.equal(20);
diff --git a/src/LanguageServer.ts b/src/LanguageServer.ts
index 2a77f1d48..9be8ca54a 100644
--- a/src/LanguageServer.ts
+++ b/src/LanguageServer.ts
@@ -578,7 +578,7 @@ export class LanguageServer {
 
         const srcPath = util.uriToPath(params.textDocument.uri);
 
-        const result = this.projectManager.getDefinition({ srcPath: srcPath, position: params.position });
+        const result = await this.projectManager.getDefinition({ srcPath: srcPath, position: params.position });
         return result;
     }
 
diff --git a/src/Program.ts b/src/Program.ts
index 33158af17..d6c97cf55 100644
--- a/src/Program.ts
+++ b/src/Program.ts
@@ -1,7 +1,7 @@
 import * as assert from 'assert';
 import * as fsExtra from 'fs-extra';
 import * as path from 'path';
-import type { CodeAction, CompletionItem, Position, Range, SignatureInformation, Location, DocumentSymbol, CancellationToken } from 'vscode-languageserver';
+import type { CodeAction, CompletionItem, Position, Range, SignatureInformation, Location, LocationLink, DocumentSymbol, CancellationToken } from 'vscode-languageserver';
 import { CancellationTokenSource, CompletionItemKind } from 'vscode-languageserver';
 import type { BsConfig, FinalizedBsConfig } from './BsConfig';
 import { Scope } from './Scope';
@@ -1001,7 +1001,7 @@ export class Program {
      * Given a position in a file, if the position is sitting on some type of identifier,
      * go to the definition of that identifier (where this thing was first defined)
      */
-    public getDefinition(srcPath: string, position: Position): Location[] {
+    public getDefinition(srcPath: string, position: Position): Array<Location | LocationLink> {
         let file = this.getFile(srcPath);
         if (!file) {
             return [];
@@ -1017,12 +1017,10 @@ export class Program {
         this.plugins.emit('beforeProvideDefinition', event);
         this.plugins.emit('provideDefinition', event);
         this.plugins.emit('afterProvideDefinition', event);
+
         return event.definitions;
     }
 
-    /**
-     * Get hover information for a file and position
-     */
     public getHover(srcPath: string, position: Position): Hover[] {
         let file = this.getFile(srcPath);
         let result: Hover[];
diff --git a/src/Scope.ts b/src/Scope.ts
index be25f0033..22182b159 100644
--- a/src/Scope.ts
+++ b/src/Scope.ts
@@ -1,4 +1,4 @@
-import type { CompletionItem, Position, Range, Location } from 'vscode-languageserver';
+import type { CompletionItem, Position, Range, Location, LocationLink } from 'vscode-languageserver';
 import * as path from 'path';
 import { CompletionItemKind } from 'vscode-languageserver';
 import chalk from 'chalk';
@@ -1261,7 +1261,7 @@ export class Scope {
      * Get the definition (where was this thing first defined) of the symbol under the position
      * @deprecated use `DefinitionProvider.process()`
      */
-    public getDefinition(file: BscFile, position: Position): Location[] {
+    public getDefinition(file: BscFile, position: Position): Array<Location | LocationLink> {
         // Overridden in XMLScope. Brs files use implementation in BrsFile
         return [];
     }
diff --git a/src/XmlScope.spec.ts b/src/XmlScope.spec.ts
index 885cbf79b..4097cc411 100644
--- a/src/XmlScope.spec.ts
+++ b/src/XmlScope.spec.ts
@@ -73,7 +73,7 @@ describe('XmlScope', () => {
             `);
             const definition = program.getDefinition(childXmlFile.srcPath, Position.create(1, 48));
             expect(definition).to.be.lengthOf(1);
-            expect(definition[0].uri).to.equal(util.pathToUri(parentXmlFile.srcPath));
+            expect((definition[0] as any).uri).to.equal(util.pathToUri(parentXmlFile.srcPath));
         });
     });
 
diff --git a/src/XmlScope.ts b/src/XmlScope.ts
index 81180ba40..435b16311 100644
--- a/src/XmlScope.ts
+++ b/src/XmlScope.ts
@@ -1,4 +1,4 @@
-import type { Location, Position } from 'vscode-languageserver';
+import type { Location, LocationLink, Position } from 'vscode-languageserver';
 import { Scope } from './Scope';
 import { DiagnosticMessages } from './DiagnosticMessages';
 import type { XmlFile } from './files/XmlFile';
@@ -169,7 +169,7 @@ export class XmlScope extends Scope {
      * Get the definition (where was this thing first defined) of the symbol under the position
      * @deprecated use `DefinitionProvider.process()`
      */
-    public getDefinition(file: BscFile, position: Position): Location[] {
+    public getDefinition(file: BscFile, position: Position): Array<Location | LocationLink> {
         return new DefinitionProvider({
             program: this.program,
             file: file,
diff --git a/src/bscPlugin/definition/DefinitionProvider.spec.ts b/src/bscPlugin/definition/DefinitionProvider.spec.ts
index ae43ef351..302abfadc 100644
--- a/src/bscPlugin/definition/DefinitionProvider.spec.ts
+++ b/src/bscPlugin/definition/DefinitionProvider.spec.ts
@@ -6,6 +6,8 @@ import { createSandbox } from 'sinon';
 import { DefinitionProvider } from './DefinitionProvider';
 import { URI } from 'vscode-uri';
 import { tempDir } from '../../testHelpers.spec';
+import * as fsExtra from 'fs-extra';
+import * as path from 'path';
 const sinon = createSandbox();
 
 describe('DefinitionProvider', () => {
@@ -194,4 +196,396 @@ describe('DefinitionProvider', () => {
             range: util.createRange(1, 0, 1, 0)
         }]);
     });
+
+    it('handles script tag uri go-to-definition', () => {
+        const brsFile = program.setFile('components/MainScene.brs', `
+            sub main()
+            end sub
+        `);
+        const xmlFile = program.setFile('components/MainScene.xml', `
+            <component name="MainScene" extends="Scene">
+                <script type="text/brightscript" uri="pkg:/components/MainScene.brs" />
+            </component>
+        `);
+        // Line 2 (0-indexed): `                <script type="text/brightscript" uri="pkg:/components/MainScene.brs" />`
+        // The uri value range starts at the opening `"` for `pkg:/components/MainScene.brs`
+        const result = program.getDefinition(xmlFile.srcPath, util.createPosition(2, 60));
+        expect(result).to.be.lengthOf(1);
+        expect(result[0]).to.include({
+            targetUri: URI.file(brsFile.srcPath).toString()
+        });
+        // originSelectionRange should cover the full URI value (the entire filePathRange)
+        expect((result[0] as any).originSelectionRange).to.exist;
+    });
+
+    it('handles script tag uri go-to-definition with relative path', () => {
+        const brsFile = program.setFile('components/MainScene.brs', `
+            sub main()
+            end sub
+        `);
+        const xmlFile = program.setFile('components/MainScene.xml', `
+            <component name="MainScene" extends="Scene">
+                <script type="text/brightscript" uri="MainScene.brs" />
+            </component>
+        `);
+        // Line 2 (0-indexed): `                <script type="text/brightscript" uri="MainScene.brs" />`
+        // The uri value range starts at the opening `"` for `MainScene.brs`
+        const result = program.getDefinition(xmlFile.srcPath, util.createPosition(2, 54));
+        expect(result).to.be.lengthOf(1);
+        expect(result[0]).to.include({
+            targetUri: URI.file(brsFile.srcPath).toString()
+        });
+        expect((result[0] as any).originSelectionRange).to.exist;
+    });
+
+    it('returns empty array when script tag uri file is not found', () => {
+        const xmlFile = program.setFile('components/MainScene.xml', `
+            <component name="MainScene" extends="Scene">
+                <script type="text/brightscript" uri="pkg:/components/NotFound.brs" />
+            </component>
+        `);
+        // click within "pkg:/components/NotFound.brs" uri value
+        expect(
+            program.getDefinition(xmlFile.srcPath, util.createPosition(2, 60))
+        ).to.eql([]);
+    });
+
+    it('handles pkg:/ string literal in brs assignment (e.g. poster.uri)', () => {
+        const targetFile = program.setFile('source/assets.brs', `
+            function getAsset()
+            end function
+        `);
+        const main = program.setFile('source/main.brs', `
+            sub main()
+                poster = CreateObject("roSGNode", "Poster")
+                poster.uri = "pkg:/source/assets.brs"
+            end sub
+        `);
+        // Line 3 (0-indexed): `                poster.uri = "pkg:/source/assets.brs"`
+        // "pkg:/source/assets.brs" starts at col 29 (opening ") + content at col 30
+        const result = program.getDefinition(main.srcPath, util.createPosition(3, 35));
+        expect(result).to.be.lengthOf(1);
+        expect(result[0]).to.include({
+            targetUri: URI.file(targetFile.srcPath).toString()
+        });
+        expect((result[0] as any).originSelectionRange).to.exist;
+    });
+
+    it('handles relative (./) string literal in brs assignment', () => {
+        const targetFile = program.setFile('source/utils.brs', `
+            function helper()
+            end function
+        `);
+        const main = program.setFile('source/main.brs', `
+            sub main()
+                m.uri = "./utils.brs"
+            end sub
+        `);
+        // Line 2 (0-indexed): `                m.uri = "./utils.brs"`
+        // "./utils.brs" starts at col 24 (opening ") + content at col 25
+        const result = program.getDefinition(main.srcPath, util.createPosition(2, 27));
+        expect(result).to.be.lengthOf(1);
+        expect(result[0]).to.include({
+            targetUri: URI.file(targetFile.srcPath).toString()
+        });
+        expect((result[0] as any).originSelectionRange).to.exist;
+    });
+
+    it('handles relative (../) string literal in brs assignment', () => {
+        const targetFile = program.setFile('source/shared.brs', `
+            function shared()
+            end function
+        `);
+        const main = program.setFile('source/sub/main.brs', `
+            sub main()
+                m.uri = "../shared.brs"
+            end sub
+        `);
+        // Line 2 (0-indexed): `                m.uri = "../shared.brs"`
+        // "../shared.brs" starts at col 24 (opening ") + content at col 25
+        const result = program.getDefinition(main.srcPath, util.createPosition(2, 27));
+        expect(result).to.be.lengthOf(1);
+        expect(result[0]).to.include({
+            targetUri: URI.file(targetFile.srcPath).toString()
+        });
+        expect((result[0] as any).originSelectionRange).to.exist;
+    });
+
+    it('does not navigate to non-existent files for arbitrary brs string literals', () => {
+        const main = program.setFile('source/main.brs', `
+            sub main()
+                print "hello world"
+            end sub
+        `);
+        // "hello world" does not match any file in the program
+        // Line 2: `                print "hello world"`
+        // "hello world" starts at col 22 (opening ") + content at col 23
+        const result = program.getDefinition(main.srcPath, util.createPosition(2, 25));
+        expect(result).to.eql([]);
+    });
+
+    it('handles xml child node uri attribute go-to-definition', () => {
+        const targetFile = program.setFile('components/utils.brs', `
+            function helper()
+            end function
+        `);
+        const xmlFile = program.setFile('components/MainScene.xml', `
+            <component name="MainScene" extends="Scene">
+                <children>
+                    <Poster uri="pkg:/components/utils.brs" />
+                </children>
+            </component>
+        `);
+        // Line 3 (0-indexed): `                    <Poster uri="pkg:/components/utils.brs" />`
+        // Attribute value "pkg:/components/utils.brs" starts (after opening ") at col 33
+        const result = program.getDefinition(xmlFile.srcPath, util.createPosition(3, 36));
+        expect(result).to.be.lengthOf(1);
+        expect(result[0]).to.include({
+            targetUri: URI.file(targetFile.srcPath).toString()
+        });
+        expect((result[0] as any).originSelectionRange).to.exist;
+    });
+
+    it('handles xml child node backgroundURI attribute go-to-definition', () => {
+        const targetFile = program.setFile('components/bg.brs', `
+            function getBg()
+            end function
+        `);
+        const xmlFile = program.setFile('components/MainScene.xml', `
+            <component name="MainScene" extends="Scene">
+                <children>
+                    <Scene backgroundURI="pkg:/components/bg.brs" />
+                </children>
+            </component>
+        `);
+        // Line 3 (0-indexed): `                    <Scene backgroundURI="pkg:/components/bg.brs" />`
+        // backgroundURI value starts (after opening ") at col 42
+        const result = program.getDefinition(xmlFile.srcPath, util.createPosition(3, 45));
+        expect(result).to.be.lengthOf(1);
+        expect(result[0]).to.include({
+            targetUri: URI.file(targetFile.srcPath).toString()
+        });
+        expect((result[0] as any).originSelectionRange).to.exist;
+    });
+
+    it('handles xml child node relative uri attribute go-to-definition', () => {
+        const targetFile = program.setFile('components/utils.brs', `
+            function helper()
+            end function
+        `);
+        const xmlFile = program.setFile('components/MainScene.xml', `
+            <component name="MainScene" extends="Scene">
+                <children>
+                    <Poster uri="./utils.brs" />
+                </children>
+            </component>
+        `);
+        // Line 3 (0-indexed): `                    <Poster uri="./utils.brs" />`
+        // Attribute value "./utils.brs" starts (after opening ") at col 33
+        const result = program.getDefinition(xmlFile.srcPath, util.createPosition(3, 35));
+        expect(result).to.be.lengthOf(1);
+        expect(result[0]).to.include({
+            targetUri: URI.file(targetFile.srcPath).toString()
+        });
+        expect((result[0] as any).originSelectionRange).to.exist;
+    });
+
+    it('handles bare filename (no prefix) string literal in brs assignment', () => {
+        const targetFile = program.setFile('source/utils.brs', `
+            function helper()
+            end function
+        `);
+        const main = program.setFile('source/main.brs', `
+            sub main()
+                m.uri = "utils.brs"
+            end sub
+        `);
+        // "utils.brs" is a bare name that resolves relative to current file's directory
+        // Line 2 (0-indexed): `                m.uri = "utils.brs"`
+        // "utils.brs" starts at col 24 (opening ") + content at col 25
+        const result = program.getDefinition(main.srcPath, util.createPosition(2, 27));
+        expect(result).to.be.lengthOf(1);
+        expect(result[0]).to.include({
+            targetUri: URI.file(targetFile.srcPath).toString()
+        });
+        expect((result[0] as any).originSelectionRange).to.exist;
+    });
+
+    it('handles bare filename with extension in brs assignment', () => {
+        const targetFile = program.setFile('source/myAsset.brs', `
+            function helper()
+            end function
+        `);
+        const main = program.setFile('source/main.brs', `
+            sub main()
+                m.uri = "myAsset.brs"
+            end sub
+        `);
+        // "myAsset.brs" is a bare name that resolves relative to current file's directory
+        // Line 2 (0-indexed): `                m.uri = "myAsset.brs"`
+        // "myAsset.brs" starts at col 24 (opening ") + content at col 25
+        const result = program.getDefinition(main.srcPath, util.createPosition(2, 27));
+        expect(result).to.be.lengthOf(1);
+        expect(result[0]).to.include({
+            targetUri: URI.file(targetFile.srcPath).toString()
+        });
+        expect((result[0] as any).originSelectionRange).to.exist;
+    });
+
+    it('handles mangled AST without throwing', () => {
+        // Set up a file and corrupt its parser's AST to simulate a mangled parse result
+        const main = program.setFile('source/main.brs', `
+            sub main()
+                print "hello"
+            end sub
+        `);
+        const parserRef = (main as any)._parser;
+        const originalAst = parserRef?.ast;
+        // Corrupt the parser's AST so AST walks throw
+        if (parserRef) {
+            parserRef.ast = null;
+        }
+        let result: any[];
+        expect(() => {
+            result = program.getDefinition(main.srcPath, util.createPosition(2, 25));
+        }).not.to.throw();
+        expect(result).to.eql([]);
+        // Restore
+        if (parserRef) {
+            parserRef.ast = originalAst;
+        }
+    });
+
+    it('handles mangled XML AST without throwing', () => {
+        const xmlFile = program.setFile('components/MainScene.xml', `
+            <component name="MainScene" extends="Scene">
+                <script type="text/brightscript" uri="pkg:/components/MainScene.brs" />
+            </component>
+        `);
+        // Corrupt the XML parser's AST to simulate a mangled parse result
+        const parserRef = (xmlFile as any).parser;
+        const originalAst = parserRef?.ast;
+        if (parserRef) {
+            parserRef.ast = null;
+        }
+        let result: any[];
+        expect(() => {
+            result = program.getDefinition(xmlFile.srcPath, util.createPosition(2, 60));
+        }).not.to.throw();
+        expect(result).to.eql([]);
+        // Restore
+        if (parserRef) {
+            parserRef.ast = originalAst;
+        }
+    });
+
+    describe('disk-based file lookup for non-program files', () => {
+        let diskProgram: Program;
+        const diskRootDir = s`${tempDir}/definitionProviderDiskTest`;
+
+        beforeEach(() => {
+            fsExtra.emptyDirSync(diskRootDir);
+            diskProgram = new Program({
+                rootDir: diskRootDir,
+                // Use default files array so images match
+                files: ['**/*']
+            });
+        });
+
+        afterEach(() => {
+            diskProgram.dispose();
+            fsExtra.removeSync(diskRootDir);
+        });
+
+        it('navigates to an image asset that exists on disk and matches the files array', () => {
+            // Create a real image file on disk
+            const imgRelPath = path.join('images', 'hero.png');
+            const imgSrcPath = s`${diskRootDir}/${imgRelPath}`;
+            fsExtra.outputFileSync(imgSrcPath, 'PNG_DUMMY');
+
+            const main = diskProgram.setFile('source/main.brs', `
+                sub main()
+                    m.uri = "pkg:/images/hero.png"
+                end sub
+            `);
+            // Line 2 (0-indexed): `                    m.uri = "pkg:/images/hero.png"`
+            const result = diskProgram.getDefinition(main.srcPath, util.createPosition(2, 32));
+            expect(result).to.be.lengthOf(1);
+            expect(result[0]).to.include({
+                targetUri: URI.file(imgSrcPath).toString()
+            });
+            expect((result[0] as any).originSelectionRange).to.exist;
+        });
+
+        it('does not navigate to an image asset that does not exist on disk', () => {
+            const main = diskProgram.setFile('source/main.brs', `
+                sub main()
+                    m.uri = "pkg:/images/missing.png"
+                end sub
+            `);
+            const result = diskProgram.getDefinition(main.srcPath, util.createPosition(2, 32));
+            expect(result).to.eql([]);
+        });
+
+        it('navigates to an image asset via XML attribute that exists on disk', () => {
+            // Create a real image file on disk
+            const imgRelPath = path.join('images', 'poster.png');
+            const imgSrcPath = s`${diskRootDir}/${imgRelPath}`;
+            fsExtra.outputFileSync(imgSrcPath, 'PNG_DUMMY');
+
+            const xmlFile = diskProgram.setFile('components/MainScene.xml', `
+                <component name="MainScene" extends="Scene">
+                    <children>
+                        <Poster uri="pkg:/images/poster.png" />
+                    </children>
+                </component>
+            `);
+            // Line 3 (0-indexed): `                        <Poster uri="pkg:/images/poster.png" />`
+            // uri value starts after opening " at col ~37
+            const result = diskProgram.getDefinition(xmlFile.srcPath, util.createPosition(3, 40));
+            expect(result).to.be.lengthOf(1);
+            expect(result[0]).to.include({
+                targetUri: URI.file(imgSrcPath).toString()
+            });
+            expect((result[0] as any).originSelectionRange).to.exist;
+        });
+
+        it('does not navigate to an image asset via XML attribute when file is not on disk', () => {
+            const xmlFile = diskProgram.setFile('components/MainScene.xml', `
+                <component name="MainScene" extends="Scene">
+                    <children>
+                        <Poster uri="pkg:/images/nonexistent.png" />
+                    </children>
+                </component>
+            `);
+            const result = diskProgram.getDefinition(xmlFile.srcPath, util.createPosition(3, 40));
+            expect(result).to.eql([]);
+        });
+
+        it('navigates to a dest-remapped image asset using src→dest pattern', () => {
+            // Create the file at the SOURCE location (assets/), not at the dest location (images/)
+            const imgSrcPath = s`${diskRootDir}/assets/hero.png`;
+            fsExtra.outputFileSync(imgSrcPath, 'PNG_DUMMY');
+
+            // The program is configured to map assets/** → images in the package
+            const remapProgram = new Program({
+                rootDir: diskRootDir,
+                files: [{ src: 'assets/**', dest: 'images' }]
+            });
+
+            const main = remapProgram.setFile('source/main.brs', `
+                sub main()
+                    m.uri = "pkg:/images/hero.png"
+                end sub
+            `);
+            // Line 2 (0-indexed): `                    m.uri = "pkg:/images/hero.png"`
+            const result = remapProgram.getDefinition(main.srcPath, util.createPosition(2, 32));
+            remapProgram.dispose();
+            expect(result).to.be.lengthOf(1);
+            expect(result[0]).to.include({
+                targetUri: URI.file(imgSrcPath).toString()
+            });
+            expect((result[0] as any).originSelectionRange).to.exist;
+        });
+    });
 });
diff --git a/src/bscPlugin/definition/DefinitionProvider.ts b/src/bscPlugin/definition/DefinitionProvider.ts
index 69b6a8318..d857f28a7 100644
--- a/src/bscPlugin/definition/DefinitionProvider.ts
+++ b/src/bscPlugin/definition/DefinitionProvider.ts
@@ -1,8 +1,12 @@
+import * as path from 'path';
+import * as fsExtra from 'fs-extra';
+import { rokuDeploy } from 'roku-deploy';
+import type { StandardizedFileEntry, FileEntry } from 'roku-deploy';
 import { isBrsFile, isClassStatement, isDottedGetExpression, isImportStatement, isNamespaceStatement, isXmlFile, isXmlScope } from '../../astUtils/reflection';
 import type { BrsFile } from '../../files/BrsFile';
 import type { ProvideDefinitionEvent } from '../../interfaces';
 import { TokenKind } from '../../lexer/TokenKind';
-import type { Location } from 'vscode-languageserver-protocol';
+import type { Location, LocationLink, Range } from 'vscode-languageserver-protocol';
 import type { ClassStatement, FunctionStatement, NamespaceStatement } from '../../parser/Statement';
 import { ParseMode } from '../../parser/Parser';
 import util from '../../util';
@@ -10,21 +14,153 @@ import { URI } from 'vscode-uri';
 import { WalkMode, createVisitor } from '../../astUtils/visitors';
 import type { Token } from '../../lexer/Token';
 import type { XmlFile } from '../../files/XmlFile';
+import type { SGAttribute, SGNode } from '../../parser/SGTypes';
 
 export class DefinitionProvider {
     constructor(
         private event: ProvideDefinitionEvent
     ) { }
 
-    public process(): Location[] {
-        if (isBrsFile(this.event.file)) {
-            this.brsFileGetDefinition(this.event.file);
-        } else if (isXmlFile(this.event.file)) {
-            this.xmlFileGetDefinition(this.event.file);
+    public process(): Array<Location | LocationLink> {
+        try {
+            if (isBrsFile(this.event.file)) {
+                this.brsFileGetDefinition(this.event.file);
+            } else if (isXmlFile(this.event.file)) {
+                this.xmlFileGetDefinition(this.event.file);
+            }
+        } catch (e) {
+            // swallow errors caused by mangled/partially-parsed ASTs so the LSP request
+            // never surfaces an unhandled exception to the client
         }
         return this.event.definitions;
     }
 
+    /**
+     * Given a string that may be a file path and an origin range, try to resolve the path to a
+     * file in the program. Returns a LocationLink (with originSelectionRange set so VS Code
+     * underlines the whole path as one unit on Ctrl+hover) when the file is found, or null.
+     * Any non-empty string is tried:
+     *   1. First checks the program's loaded files (covers .brs/.bs/.xml).
+     *   2. If not found in the program (e.g. image assets), reverse-maps the dest path back to
+     *      candidate src paths via the project's `files` deploy entries, verifies each candidate
+     *      via `rokuDeploy.getDestPath` (no disk I/O), and only then checks disk with `existsSync`.
+     *      Returns a LocationLink pointing to the physical file if found.
+     *   3. If neither condition holds, returns null so no link is contributed and VS Code
+     *      does not show a (segmented) hover for the path.
+     */
+    private tryGetFilePathLocationLink(pathStr: string, containingFilePkgPath: string, originRange: Range): LocationLink | null {
+        if (!pathStr) {
+            return null;
+        }
+        const pkgPath = util.getPkgPathFromTarget(containingFilePkgPath, pathStr);
+        if (!pkgPath) {
+            return null;
+        }
+        // 1. Check if the file is loaded in the program (covers .brs/.bs/.xml)
+        const targetFile = this.event.program.getFile(pkgPath);
+        if (targetFile) {
+            return {
+                originSelectionRange: originRange,
+                targetUri: util.pathToUri(targetFile.srcPath),
+                targetRange: util.createRange(0, 0, 0, 0),
+                targetSelectionRange: util.createRange(0, 0, 0, 0)
+            };
+        }
+        // 2. File is not in the program (e.g. image assets).
+        //    Reverse-map pkgPath (destPath) → candidate srcPath, verify mapping, then check disk.
+        const srcPath = this.findSrcPathForPkgPath(pkgPath);
+        if (srcPath) {
+            return {
+                originSelectionRange: originRange,
+                targetUri: util.pathToUri(srcPath),
+                targetRange: util.createRange(0, 0, 0, 0),
+                targetSelectionRange: util.createRange(0, 0, 0, 0)
+            };
+        }
+        return null;
+    }
+
+    /**
+     * Given a pkgPath (the dest-relative path inside the Roku package, e.g. `images/hero.png`),
+     * find the absolute srcPath of the file on disk by reverse-mapping through every entry in the
+     * project's `files` deploy array.
+     *
+     * For each entry we compute a *candidate* srcPath without touching the disk, then:
+     *   1. Verify the candidate with `rokuDeploy.getDestPath` (cheap — pure path computation).
+     *   2. Only call `fsExtra.existsSync` (expensive — disk I/O) when verification passes.
+     *
+     * Returns the first matching absolute srcPath, or null.
+     */
+    private findSrcPathForPkgPath(pkgPath: string): string | null {
+        const { rootDir, files } = this.event.program.options;
+        if (!rootDir || !files?.length) {
+            return null;
+        }
+        const normalizedPkgPath = path.normalize(pkgPath).replace(/\\/g, '/');
+        const entries = rokuDeploy.normalizeFilesArray(files as FileEntry[]);
+
+        for (const entry of entries) {
+            const candidateSrcPath = this.reverseLookupSrcPath(normalizedPkgPath, entry, rootDir);
+            if (!candidateSrcPath) {
+                continue;
+            }
+            // Verify: the candidate srcPath must deploy to exactly our pkgPath (no disk I/O)
+            const destPath = rokuDeploy.getDestPath(candidateSrcPath, files as FileEntry[], rootDir);
+            if (!destPath) {
+                continue;
+            }
+            if (path.normalize(destPath).replace(/\\/g, '/') !== normalizedPkgPath) {
+                continue;
+            }
+            // Only after pattern verification do we access the disk
+            if (fsExtra.existsSync(candidateSrcPath)) {
+                return candidateSrcPath;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * For a single normalized files entry, compute the candidate srcPath that would produce
+     * `pkgPath` as its deploy dest path.  Returns null when the entry could not produce that dest.
+     *
+     * `pkgPath` is already normalized (forward slashes, no leading slash).
+     */
+    private reverseLookupSrcPath(
+        pkgPath: string,
+        entry: string | StandardizedFileEntry,
+        rootDir: string
+    ): string | null {
+        if (typeof entry === 'string') {
+            // String entry: files are relative to rootDir, dest mirrors src structure under rootDir
+            return path.join(rootDir, pkgPath);
+        }
+
+        // Object entry: check whether pkgPath is under this entry's dest subtree
+        const dest = entry.dest ? path.normalize(entry.dest).replace(/\\/g, '/') : '';
+        let pathWithinDest: string;
+        if (!dest) {
+            // No dest remap — dest path mirrors the src structure relative to the glob base
+            pathWithinDest = pkgPath;
+        } else if (pkgPath === dest) {
+            pathWithinDest = '';
+        } else if (pkgPath.startsWith(dest + '/')) {
+            pathWithinDest = pkgPath.substring(dest.length + 1);
+        } else {
+            // pkgPath is not under this entry's dest — skip
+            return null;
+        }
+
+        // For globstar patterns, the src base is everything before '**'
+        const globstarIdx = entry.src.indexOf('**');
+        if (globstarIdx > -1) {
+            const srcBase = path.resolve(rootDir, entry.src.substring(0, globstarIdx));
+            return path.join(srcBase, pathWithinDest);
+        }
+        // No globstar: fall back to rootDir + pkgPath (covers simple exact-file entries)
+        return path.join(rootDir, pkgPath);
+    }
+
     /**
      * For a position in a BrsFile, get the location where the token at that position was defined
      */
@@ -142,6 +278,24 @@ export class DefinitionProvider {
                 }
             }
 
+            // Generic file path detection: if the string literal looks like a file path
+            // (pkg:/, libpkg:/, ./, ../) resolve it and navigate to that file.
+            const pathValue = token.text.replace(/^"|"$/g, '');
+            const link = this.tryGetFilePathLocationLink(
+                pathValue,
+                file.pkgPath,
+                util.createRange(
+                    token.range.start.line,
+                    token.range.start.character + 1,
+                    token.range.end.line,
+                    token.range.end.character - 1
+                )
+            );
+            if (link) {
+                this.event.definitions.push(link);
+                return;
+            }
+
             // We need to strip off the quotes but only if present
             const startIndex = textToSearchFor.startsWith('"') ? 1 : 0;
 
@@ -257,6 +411,77 @@ export class DefinitionProvider {
                 range: util.createRange(0, 0, 0, 0),
                 uri: util.pathToUri(file.parentComponent.srcPath)
             });
+            return;
+        }
+
+        // Generic XML attribute value path resolution.
+        // Walk the entire component tree (component attributes, script tags, children nodes,
+        // customization nodes) and return a definition for the first attribute value that
+        // looks like a file path and resolves to a known file.
+        const component = file.ast?.component;
+        if (!component) {
+            return;
+        }
+
+        // Component-level attributes (e.g. extends="...")
+        if (this.xmlGetFilePathDefinitionFromAttributes(component.attributes, file.pkgPath)) {
+            return;
+        }
+        // <script> tags (uri="...")
+        for (const script of component.scripts ?? []) {
+            if (this.xmlGetFilePathDefinitionFromAttributes(script.attributes, file.pkgPath)) {
+                return;
+            }
+        }
+        // Nodes inside <children>
+        if (component.children && this.xmlWalkNodeForFilePath(component.children, file.pkgPath)) {
+            return;
+        }
+        // <Customization> nodes
+        for (const custom of component.customizations ?? []) {
+            if (this.xmlWalkNodeForFilePath(custom, file.pkgPath)) {
+                return;
+            }
+        }
+    }
+
+    /**
+     * Check all attributes on an XML element for an attribute value that looks like a file path
+     * and whose range contains the cursor position.  Returns true and pushes a definition when a
+     * match is found.
+     * For XML, we attempt to resolve every attribute value (no prefix requirement) since most
+     * non-path values (e.g. name="MainScene") will simply not resolve to a known file.
+     */
+    private xmlGetFilePathDefinitionFromAttributes(attributes: SGAttribute[] | undefined, pkgPath: string): boolean {
+        for (const attr of attributes ?? []) {
+            if (attr.value?.range && util.rangeContains(attr.value.range, this.event.position)) {
+                const attrValue = attr.value.text;
+                if (!attrValue) {
+                    continue;
+                }
+                const link = this.tryGetFilePathLocationLink(attrValue, pkgPath, attr.value.range);
+                if (link) {
+                    this.event.definitions.push(link);
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Recursively walk an SGNode and its children looking for an attribute value that looks like a
+     * file path at the cursor position.  Returns true and pushes a definition on first match.
+     */
+    private xmlWalkNodeForFilePath(node: SGNode, pkgPath: string): boolean {
+        if (this.xmlGetFilePathDefinitionFromAttributes(node.attributes, pkgPath)) {
+            return true;
+        }
+        for (const child of node.children ?? []) {
+            if (this.xmlWalkNodeForFilePath(child, pkgPath)) {
+                return true;
+            }
         }
+        return false;
     }
 }
diff --git a/src/files/BrsFile.ts b/src/files/BrsFile.ts
index d8b86cf45..4efc38082 100644
--- a/src/files/BrsFile.ts
+++ b/src/files/BrsFile.ts
@@ -1,6 +1,6 @@
 import type { CodeWithSourceMap } from 'source-map';
 import { SourceNode } from 'source-map';
-import type { CompletionItem, Position, Location, Diagnostic } from 'vscode-languageserver';
+import type { CompletionItem, Position, Location, LocationLink, Diagnostic } from 'vscode-languageserver';
 import { CancellationTokenSource } from 'vscode-languageserver';
 import { CompletionItemKind, TextEdit } from 'vscode-languageserver';
 import chalk from 'chalk';
@@ -1309,7 +1309,7 @@ export class BrsFile {
      * go to the definition of that identifier (where this thing was first defined)
      * @deprecated use `DefinitionProvider.process()` instead
      */
-    public getDefinition(position: Position): Location[] {
+    public getDefinition(position: Position): Array<Location | LocationLink> {
         return new DefinitionProvider({
             program: this.program,
             file: this,
diff --git a/src/interfaces.ts b/src/interfaces.ts
index 79137bb1d..e773fbe62 100644
--- a/src/interfaces.ts
+++ b/src/interfaces.ts
@@ -1,4 +1,4 @@
-import type { Range, Diagnostic, CodeAction, Position, CompletionItem, Location, DocumentSymbol, WorkspaceSymbol, Disposable, FileChangeType } from 'vscode-languageserver-protocol';
+import type { Range, Diagnostic, CodeAction, Position, CompletionItem, Location, LocationLink, DocumentSymbol, WorkspaceSymbol, Disposable, FileChangeType } from 'vscode-languageserver-protocol';
 import type { Scope } from './Scope';
 import type { BrsFile } from './files/BrsFile';
 import type { XmlFile } from './files/XmlFile';
@@ -394,9 +394,12 @@ export interface ProvideDefinitionEvent<TFile = BscFile> {
      */
     position: Position;
     /**
-     * The list of locations for where the item at the file and position was defined
+     * The list of locations for where the item at the file and position was defined.
+     * Plugins may push either `Location` or `LocationLink` objects.
+     * When a `LocationLink` is pushed, VS Code will use `originSelectionRange` to highlight
+     * the source range of the link (e.g. the full URI of a script tag attribute).
      */
-    definitions: Location[];
+    definitions: Array<Location | LocationLink>;
 }
 export type BeforeProvideDefinitionEvent<TFile = BscFile> = ProvideDefinitionEvent<TFile>;
 export type AfterProvideDefinitionEvent<TFile = BscFile> = ProvideDefinitionEvent<TFile>;
diff --git a/src/lsp/LspProject.ts b/src/lsp/LspProject.ts
index 34fc6926a..6bc6d633f 100644
--- a/src/lsp/LspProject.ts
+++ b/src/lsp/LspProject.ts
@@ -1,4 +1,4 @@
-import type { Diagnostic, Position, Range, Location, DocumentSymbol, WorkspaceSymbol, CodeAction, CompletionList } from 'vscode-languageserver-protocol';
+import type { Diagnostic, Position, Range, Location, LocationLink, DocumentSymbol, WorkspaceSymbol, CodeAction, CompletionList } from 'vscode-languageserver-protocol';
 import type { Hover, MaybePromise, SemanticToken } from '../interfaces';
 import type { DocumentAction, DocumentActionWithStatus } from './DocumentManager';
 import type { FileTranspileResult, SignatureInfoObj } from '../Program';
@@ -114,7 +114,7 @@ export interface LspProject {
      * Get the locations where the symbol at the specified position is defined
      * @param options the file path and position to get the definition for
      */
-    getDefinition(options: { srcPath: string; position: Position }): MaybePromise<Location[]>;
+    getDefinition(options: { srcPath: string; position: Position }): MaybePromise<Array<Location | LocationLink>>;
 
     /**
      * Get the locations where the symbol at the specified position is defined
diff --git a/src/lsp/Project.ts b/src/lsp/Project.ts
index c4b6b7ce8..1cd6663a6 100644
--- a/src/lsp/Project.ts
+++ b/src/lsp/Project.ts
@@ -9,7 +9,7 @@ import { URI } from 'vscode-uri';
 import { Deferred } from '../deferred';
 import type { StandardizedFileEntry } from 'roku-deploy';
 import { rokuDeploy } from 'roku-deploy';
-import type { DocumentSymbol, Position, Range, Location, WorkspaceSymbol } from 'vscode-languageserver-protocol';
+import type { DocumentSymbol, Position, Range, Location, LocationLink, WorkspaceSymbol } from 'vscode-languageserver-protocol';
 import { CompletionList } from 'vscode-languageserver-protocol';
 import { CancellationTokenSource } from 'vscode-languageserver-protocol';
 import type { DocumentAction, DocumentActionWithStatus } from './DocumentManager';
@@ -383,7 +383,7 @@ export class Project implements LspProject {
         }
     }
 
-    public async getDefinition(options: { srcPath: string; position: Position }): Promise<Location[]> {
+    public async getDefinition(options: { srcPath: string; position: Position }): Promise<Array<Location | LocationLink>> {
         await this.onIdle();
         if (this.builder.program.hasFile(options.srcPath)) {
             return this.builder.program.getDefinition(options.srcPath, options.position);
diff --git a/src/lsp/ProjectManager.ts b/src/lsp/ProjectManager.ts
index db94a733c..14ea11a34 100644
--- a/src/lsp/ProjectManager.ts
+++ b/src/lsp/ProjectManager.ts
@@ -6,7 +6,7 @@ import type { LspDiagnostic, LspProject, ProjectConfig } from './LspProject';
 import { Project } from './Project';
 import { WorkerThreadProject } from './worker/WorkerThreadProject';
 import { FileChangeType } from 'vscode-languageserver-protocol';
-import type { Hover, Position, Range, Location, SignatureHelp, DocumentSymbol, SymbolInformation, WorkspaceSymbol, CompletionList, CancellationToken } from 'vscode-languageserver-protocol';
+import type { Hover, Position, Range, Location, LocationLink, SignatureHelp, DocumentSymbol, SymbolInformation, WorkspaceSymbol, CompletionList, CancellationToken } from 'vscode-languageserver-protocol';
 import { Deferred } from '../deferred';
 import type { DocumentActionWithStatus, FlushEvent } from './DocumentManager';
 import { DocumentManager } from './DocumentManager';
@@ -554,7 +554,7 @@ export class ProjectManager {
      * @returns a list of locations where the symbol under the position is defined in the project
      */
     @TrackBusyStatus
-    public async getDefinition(options: { srcPath: string; position: Position }): Promise<Location[]> {
+    public async getDefinition(options: { srcPath: string; position: Position }): Promise<Array<Location | LocationLink>> {
         //wait for all pending syncs to finish
         await this.onIdle();
 
diff --git a/src/lsp/worker/WorkerThreadProject.ts b/src/lsp/worker/WorkerThreadProject.ts
index 55e152e23..675d0559f 100644
--- a/src/lsp/worker/WorkerThreadProject.ts
+++ b/src/lsp/worker/WorkerThreadProject.ts
@@ -10,7 +10,7 @@ import type { Hover, MaybePromise, SemanticToken } from '../../interfaces';
 import type { DocumentAction, DocumentActionWithStatus } from '../DocumentManager';
 import { Deferred } from '../../deferred';
 import type { FileTranspileResult, SignatureInfoObj } from '../../Program';
-import type { Position, Range, Location, DocumentSymbol, WorkspaceSymbol, CodeAction, CompletionList } from 'vscode-languageserver-protocol';
+import type { Position, Range, Location, LocationLink, DocumentSymbol, WorkspaceSymbol, CodeAction, CompletionList } from 'vscode-languageserver-protocol';
 import type { Logger } from '../../logging';
 import { createLogger } from '../../logging';
 import * as fsExtra from 'fs-extra';
@@ -220,8 +220,8 @@ export class WorkerThreadProject implements LspProject {
         return this.sendStandardRequest<Hover[]>('getHover', options);
     }
 
-    public async getDefinition(options: { srcPath: string; position: Position }): Promise<Location[]> {
-        return this.sendStandardRequest<Location[]>('getDefinition', options);
+    public async getDefinition(options: { srcPath: string; position: Position }): Promise<Array<Location | LocationLink>> {
+        return this.sendStandardRequest<Array<Location | LocationLink>>('getDefinition', options);
     }
 
     public async getSignatureHelp(options: { srcPath: string; position: Position }): Promise<SignatureInfoObj[]> {