diff --git a/CHANGELOG.md b/CHANGELOG.md
index 54ef5f5a..c6f9a40f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 ### New Features
 
 - `codegraph status --json` now also reports the running CLI `version`, the index directory (`indexPath`), and a `lastIndexed` timestamp (ISO-8601, or null when nothing's indexed yet), so CI and scripts can pin the CLI version and check index freshness from a single command. A matching `CodeGraph.getLastIndexedAt()` library method exposes the same freshness check without shelling out. Thanks @12122J and @eddieran. (#329)
+- MyBatis `<resultMap>` elements are now indexed, and statements that declare `resultMap="..."` link to them — so you can ask which statements use a given result map (callers / impact), not just which use a `<sql>` fragment. (#592)
 
 ### Fixes
 
diff --git a/__tests__/frameworks-integration.test.ts b/__tests__/frameworks-integration.test.ts
index 344a0f6c..0a81e369 100644
--- a/__tests__/frameworks-integration.test.ts
+++ b/__tests__/frameworks-integration.test.ts
@@ -464,6 +464,77 @@ describe('Java end-to-end — field-injected bean trace (issue #389)', () => {
     cg.close();
   });
 
+  it('indexes MyBatis <resultMap> and links statements that reference it (#592)', async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-mybatis-rm-'));
+    const javaDir = path.join(tmpDir, 'src/main/java/com/example/dao');
+    const xmlDir = path.join(tmpDir, 'src/main/resources/mappers');
+    fs.mkdirSync(javaDir, { recursive: true });
+    fs.mkdirSync(xmlDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, 'pom.xml'),
+      '<project><dependencies><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId></dependency></dependencies></project>\n'
+    );
+    // Java method `userResult` deliberately collides with the resultMap id,
+    // to prove the Java↔XML bridge does NOT wrongly link to the result map.
+    fs.writeFileSync(
+      path.join(javaDir, 'UserMapper.java'),
+      'package com.example.dao;\n' +
+        'public interface UserMapper {\n' +
+        '  Object findById(int id);\n' +
+        '  Object userResult();\n' +
+        '}\n'
+    );
+    fs.writeFileSync(
+      path.join(xmlDir, 'UserMapper.xml'),
+      '<?xml version="1.0" encoding="UTF-8"?>\n' +
+        '<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">\n' +
+        '<mapper namespace="com.example.dao.UserMapper">\n' +
+        '  <resultMap id="userResult" type="User">\n' +
+        '    <id column="id" property="id"/>\n' +
+        '    <result column="email" property="email"/>\n' +
+        '  </resultMap>\n' +
+        '  <select id="findById" resultMap="userResult">\n' +
+        '    SELECT id, email FROM users WHERE id = #{id}\n' +
+        '  </select>\n' +
+        '</mapper>\n'
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    await cg.indexAll();
+
+    const methods = cg.getNodesByKind('method');
+    const resultMap = methods.find((n) => n.name === 'userResult' && n.language === 'xml');
+    const findById = methods.find((n) => n.name === 'findById' && n.language === 'xml');
+    expect(resultMap, '<resultMap id="userResult"> should be indexed').toBeDefined();
+    expect(resultMap!.qualifiedName).toBe('com.example.dao.UserMapper::userResult');
+    expect(resultMap!.signature).toBe('<resultMap> type=User');
+    expect(findById).toBeDefined();
+
+    // <select resultMap="userResult"> -> <resultMap id="userResult"> edge.
+    const rmEdge = cg.getOutgoingEdges(findById!.id).find((e) => e.target === resultMap!.id);
+    expect(rmEdge, 'statement should reference the result map it uses').toBeDefined();
+
+    // The guard must not over-match: the real <select id="findById"> still
+    // bridges to its Java mapper method.
+    const javaFindById = methods.find((n) => n.name === 'findById' && n.language === 'java');
+    expect(javaFindById).toBeDefined();
+    const realBridge = cg
+      .getOutgoingEdges(javaFindById!.id)
+      .find((e) => e.target === findById!.id);
+    expect(realBridge, 'Java findById should still bridge to its XML <select>').toBeDefined();
+
+    // The Java↔XML bridge must NOT link the same-named Java method to the
+    // result map (result maps are not mapper methods).
+    const javaUserResult = methods.find((n) => n.name === 'userResult' && n.language === 'java');
+    expect(javaUserResult).toBeDefined();
+    const bogusBridge = cg
+      .getOutgoingEdges(javaUserResult!.id)
+      .find((e) => e.target === resultMap!.id);
+    expect(bogusBridge, 'Java method must not bridge to a result map').toBeUndefined();
+
+    cg.close();
+  });
+
   it('binds @Value / @ConfigurationProperties to YAML + .properties keys (incl. relaxed binding)', async () => {
     tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-spring-config-'));
     const javaDir = path.join(tmpDir, 'src/main/java/com/example');
diff --git a/src/extraction/mybatis-extractor.ts b/src/extraction/mybatis-extractor.ts
index fc873e1d..763b8f7b 100644
--- a/src/extraction/mybatis-extractor.ts
+++ b/src/extraction/mybatis-extractor.ts
@@ -109,7 +109,7 @@ export class MyBatisExtractor {
     // tags (`<if>`, `<foreach>`, `<include>`), so we scan with a regex that
     // pairs an opening tag to its matching close — the simple form below works
     // because MyBatis statement elements are not themselves nested.
-    const stmtRegex = /<(select|insert|update|delete|sql)\b([^>]*)>([\s\S]*?)<\/\1>/g;
+    const stmtRegex = /<(select|insert|update|delete|sql|resultMap)\b([^>]*)>([\s\S]*?)<\/\1>/g;
     let m: RegExpExecArray | null;
     while ((m = stmtRegex.exec(body)) !== null) {
       const elemType = m[1]!;
@@ -123,6 +123,7 @@ export class MyBatisExtractor {
       const endLine = this.getLineNumber(absoluteIndex + m[0].length);
       const qualified = `${namespace}::${id}`;
       const isSqlFragment = elemType === 'sql';
+      const isResultMap = elemType === 'resultMap';
       const nodeId = generateNodeId(this.filePath, 'method', qualified, startLine);
       const node: Node = {
         id: nodeId,
@@ -159,11 +160,36 @@ export class MyBatisExtractor {
           column: 0,
         });
       }
+
+      // resultMap="X" on a statement → reference to the <resultMap id="X">
+      // node, so callers/impact can answer "which statements use this result
+      // map" (mirrors the <include refid> link above). A qualified `ns.X`
+      // points at another mapper's result map.
+      if (!isResultMap && !isSqlFragment) {
+        const rmId = /\bresultMap\s*=\s*"([^"]+)"/.exec(attrs)?.[1]?.trim();
+        if (rmId) {
+          const rmQualified = rmId.includes('.') ? rmId.replace(/\./g, '::') : `${namespace}::${rmId}`;
+          this.unresolvedReferences.push({
+            fromNodeId: nodeId,
+            referenceName: rmQualified,
+            referenceKind: 'references',
+            line: startLine,
+            column: 0,
+          });
+        }
+      }
     }
   }
 
+  // NOTE: the `<sql>` and `<resultMap>` signature prefixes are load-bearing —
+  // the Java↔XML bridge (`mybatisJavaXmlEdges`) uses them to skip non-statement
+  // nodes. Keep them in sync if this changes.
   private buildSignature(elemType: string, attrs: string, isSqlFragment: boolean): string {
     if (isSqlFragment) return '<sql>';
+    if (elemType === 'resultMap') {
+      const type = /\btype\s*=\s*"([^"]+)"/.exec(attrs)?.[1];
+      return type ? `<resultMap> type=${type}` : '<resultMap>';
+    }
     const verb = elemType.toUpperCase();
     const result = /\bresultType\s*=\s*"([^"]+)"/.exec(attrs)?.[1];
     const param = /\bparameterType\s*=\s*"([^"]+)"/.exec(attrs)?.[1];
diff --git a/src/resolution/callback-synthesizer.ts b/src/resolution/callback-synthesizer.ts
index 80294672..67745b9c 100644
--- a/src/resolution/callback-synthesizer.ts
+++ b/src/resolution/callback-synthesizer.ts
@@ -1031,6 +1031,11 @@ function mybatisJavaXmlEdges(queries: QueryBuilder): Edge[] {
 
   for (const xml of queries.iterateNodesByKind('method')) {
     if (xml.language !== 'xml') continue;
+    // Only real mapper statements (<select|insert|update|delete>) map to a Java
+    // interface method. `<sql>` fragments and `<resultMap>`s share the method-node
+    // shape but are not mapper methods, so an `id` that happens to match a Java
+    // method name must NOT be bridged to them.
+    if (xml.signature === '<sql>' || xml.signature?.startsWith('<resultMap>')) continue;
     // Qualified name: `<namespace>::<id>`. Extract the simple class name.
     const colonIdx = xml.qualifiedName.lastIndexOf('::');
     if (colonIdx < 0) continue;