@@ -2043,6 +2043,65 @@ index dfd00ce2e9..a6b14ba3d9 100644
      }
      catch (err) {
          // Ensure cache is reset if operation is cancelled
+diff --git a/src/services/goToDefinition.ts b/src/services/goToDefinition.ts
+index 0a45cc3e3e..d296a01666 100644
+--- a/src/services/goToDefinition.ts
++++ b/src/services/goToDefinition.ts
+@@ -316,7 +316,7 @@ function getDefinitionFromObjectLiteralElement(typeChecker: TypeChecker, node: N
+         const contextualType = element && typeChecker.getContextualType(element.parent);
+         if (contextualType) {
+             let properties = getPropertySymbolsFromContextualType(element, typeChecker, contextualType, /*unionSymbolOk*/ false);
+-            if (some(properties, p => !!(p.valueDeclaration && isObjectLiteralExpression(p.valueDeclaration.parent) && isObjectLiteralElementLike(p.valueDeclaration) && p.valueDeclaration.name === node))) {
++            if (some(properties, p => isSelfReferentialContextualProperty(p, node))) {
+                 const withoutNodeInferencesType = typeChecker.getContextualType(element.parent, ContextFlags.IgnoreNodeInferences);
+                 if (withoutNodeInferencesType) {
+                     const withoutNodeInferencesProperties = getPropertySymbolsFromContextualType(element, typeChecker, withoutNodeInferencesType, /*unionSymbolOk*/ false);
+@@ -331,6 +331,45 @@ function getDefinitionFromObjectLiteralElement(typeChecker: TypeChecker, node: N
+     return emptyArray;
+ }
+ 
++/**
++ * TNB (issue #5): the stock form of this test is
++ * `p.valueDeclaration && isObjectLiteralExpression(p.valueDeclaration.parent)
++ * && isObjectLiteralElementLike(p.valueDeclaration) && p.valueDeclaration.name === node`.
++ * tsgo-side property symbols carry declarations as NodeHandles — no `.parent`
++ * or `.name` links — so the identity test never detects the object literal's
++ * own properties as self-referential and the IgnoreNodeInferences re-query
++ * never runs (the self declaration then leaks into the definition list).
++ * Keep the stock test as the fast path; for handle-shaped declarations,
++ * resolve and compare name positions across ASTs.
++ */
++function isSelfReferentialContextualProperty(p: Symbol, node: Node): boolean {
++    const valueDeclaration = (p.valueDeclaration ?? p.declarations?.[0]) as Declaration | undefined;
++    if (!valueDeclaration) return false;
++    if (
++        isObjectLiteralExpression(valueDeclaration.parent)
++        && isObjectLiteralElementLike(valueDeclaration)
++        && (valueDeclaration as any).name === node
++    ) {
++        return true;
++    }
++    const anyDecl = valueDeclaration as any;
++    // Cross-AST path: tsgo-side declarations (NodeHandles) can never be === the
++    // host node, so the identity test above failed even though the declaration
++    // IS the element's own name. Resolve the handle and compare name positions.
++    if (typeof anyDecl.resolve !== "function") return false;
++    let rn: any;
++    try { rn = anyDecl._resolvedNode ?? anyDecl.resolve(); } catch { rn = undefined; }
++    if (!rn || !isObjectLiteralExpression(rn.parent) || !isObjectLiteralElementLike(rn)) return false;
++    const rnName = rn.name;
++    if (!rnName) return false;
++    const rnSf = typeof rn.getSourceFile === "function" ? rn.getSourceFile() : (rn as any).sourceFile;
++    const nodeSf = node.getSourceFile();
++    if (!rnSf || rnSf.fileName !== nodeSf.fileName) return false;
++    const rnStart = typeof rnName.getStart === "function" ? rnName.getStart() : rnName.pos;
++    const rnEnd = typeof rnName.getEnd === "function" ? rnName.getEnd() : rnName.end;
++    return rnStart === node.getStart() && rnEnd === node.getEnd();
++}
++
+ function getDefinitionFromOverriddenMember(typeChecker: TypeChecker, node: Node) {
+     const classElement = findAncestor(node, isClassElement);
+     if (!(classElement && classElement.name)) return;
 diff --git a/src/services/services.ts b/src/services/services.ts
 index 9885093ed6..0cbb4021a3 100644
 --- a/src/services/services.ts
 
@@ -17,7 +17,7 @@
 import * as ts from "./_namespaces/ts.js";
 import { bindSourceFile } from "./binder.js";
 import { createSourceFile } from "./parser.js";
-import { SyntaxKind, SymbolFlags, SymbolFormatFlags, NodeFlags, ModifierFlags, JSDocParsingMode, ModuleKind, StructureIsReused, EmitHint, EmitFlags, type Path, type Program, type TypeChecker } from "./types.js";
+import { SyntaxKind, SymbolFlags, SymbolFormatFlags, NodeFlags, ModifierFlags, JSDocParsingMode, ModuleKind, StructureIsReused, EmitHint, EmitFlags, ContextFlags, type Path, type Program, type TypeChecker } from "./types.js";
 import { getBuildInfoText, getTsBuildInfoEmitOutputFilePath, createPrinterWithRemoveComments } from "./emitter.js";
 import { usingSingleLineStringWriter } from "./utilities.js";
 import { getParseTreeNode, isFunctionLike } from "./utilitiesPublic.js";
@@ -7649,6 +7649,94 @@ export function createTsgoChecker(program: any): any {
         }
     }
 
+    /**
+     * ContextFlags.IgnoreNodeInferences emulation: drop union constituents that
+     * are the queried node's own inferred type (their declarations all live
+     * inside the node's span). See getContextualType in the checker shim.
+     */
+    function filterNodeInferredConstituents(t: any, node: any): any {
+        if (!t?.isUnion?.()) return t;
+        const members: any[] = t.types ?? [];
+        const kept = members.filter(m => !typeDeclaredWithin(m, node));
+        if (_traceSymEnabled) {
+            traceSym(`filterNodeInferred file=${node.getSourceFile?.()?.fileName} nodePos=${node.pos} members=${members.length} kept=${kept.length} within=[${members.map(m => typeDeclaredWithin(m, node) ? 1 : 0).join("")}]`);
+        }
+        if (kept.length === members.length) return t;
+        if (kept.length === 0) return undefined;
+        return unionDelegate(t, kept);
+    }
+
+    /** Union view over a filtered member list; delegates everything else to the original. */
+    function unionDelegate(original: any, members: any[]): any {
+        if (members.length === 1) return members[0];
+        const nonNullable = members.filter(m => !isNullableTypeShim(m));
+        // getNonNullableType must be overridden too: stock consumers
+        // (getPropertySymbolsFromContextualType) call it first, and plain
+        // delegation would hand back the UNfiltered original union.
+        const delegate = Object.create(original, {
+            isUnion: { value: () => true },
+            types: { value: members },
+            getNonNullableType: {
+                value: () => nonNullable.length === members.length ? delegate
+                    : nonNullable.length === 0 ? undefined
+                    : unionDelegate(original, nonNullable),
+            },
+        });
+        return delegate;
+    }
+
+    function isNullableTypeShim(m: any): boolean {
+        if (typeof m?.isNullableType === "function") {
+            try { if (m.isNullableType()) return true; } catch { /* fall through */ }
+        }
+        return m?.intrinsicName === "null" || m?.intrinsicName === "undefined";
+    }
+
+    function typeDeclaredWithin(t: any, node: any): boolean {
+        const sym = t.symbol ?? (typeof t.getSymbol === "function" ? (() => { try { return t.getSymbol(); } catch { return undefined; } })() : undefined);
+        const decls = sym?.declarations ?? [];
+        if (!decls.length) return false;
+        return decls.every((d: any) => nodeContainsPosition(node, d));
+    }
+
+    function declFileName(d: any): string | undefined {
+        // Host nodes expose getSourceFile(); tsgo checker symbol declarations
+        // arrive as NodeHandles with a `sourceFile` getter instead.
+        if (typeof d.getSourceFile === "function") {
+            try { return d.getSourceFile()?.fileName; } catch { /* fall through */ }
+        }
+        return d.sourceFile?.fileName;
+    }
+
+    function declSpan(d: any): { start: number; end: number; } | undefined {
+        if (typeof d.getStart === "function" && typeof d.getEnd === "function") {
+            return { start: d.getStart(), end: d.getEnd() };
+        }
+        // NodeHandle: resolve to the RemoteNode for positions.
+        if (typeof d.resolve === "function") {
+            let rn: any;
+            try { rn = d.resolve(); } catch { rn = undefined; }
+            if (rn) {
+                if (typeof rn.getStart === "function" && typeof rn.getEnd === "function") {
+                    return { start: rn.getStart(), end: rn.getEnd() };
+                }
+                if (typeof rn.pos === "number" && typeof rn.end === "number") {
+                    return { start: rn.pos, end: rn.end };
+                }
+            }
+        }
+        return undefined;
+    }
+
+    function nodeContainsPosition(node: any, d: any): boolean {
+        const sf = node.getSourceFile?.();
+        const dFile = declFileName(d);
+        if (!sf || !dFile || sf.fileName !== dFile) return false;
+        const span = declSpan(d);
+        if (!span || span.start < 0) return false;
+        return span.start >= node.pos && span.end <= node.end;
+    }
+
     function fixupType(t: any): any {
         if (Array.isArray(t)) { for (const i of t) fixupType(i); return t; }
         if (t && typeof t === "object") {
@@ -7669,6 +7757,7 @@ export function createTsgoChecker(program: any): any {
                 }
                 resolveRawTypeProps(obj);
                 // tsgo may expose `aliasTypeArguments: []` on reference/array
+
                 // types. Rule helpers (no-unnecessary-type-assertion's
                 // containsAny) use `type.aliasTypeArguments ??
                 // checker.getTypeArguments(type)` — an empty array is
@@ -8524,7 +8613,7 @@ export function createTsgoChecker(program: any): any {
             }
             return errorOrAny();
         },
-        getContextualType(node: any): any {
+        getContextualType(node: any, contextFlags?: number): any {
             ensureProject();
             const sf = node.getSourceFile?.();
             if (!sf) return undefined;
@@ -8553,6 +8642,16 @@ export function createTsgoChecker(program: any): any {
                     _objCompletionPending = { hostNode: node, tsgoNode, results: [t] };
                 }
             }
+            // ContextFlags.IgnoreNodeInferences: stock re-queries the contextual
+            // type excluding inference derived from the queried node itself
+            // (goToDefinition's object-literal path relies on this to drop the
+            // literal's own properties from the result). tsgo's RPC takes no
+            // flags and its union can include the node's own inferred type —
+            // emulate by dropping union constituents whose declarations all
+            // live inside the queried node (issue #5).
+            if (t && contextFlags !== undefined && (contextFlags & ContextFlags.IgnoreNodeInferences)) {
+                return filterNodeInferredConstituents(t, node);
+            }
             return t;
         },
         getResolvedSignature(node: any): any {