@@ -10,7 +10,8 @@
  * @fileoverview This file contains transformers dedicated to converting Jasmine's spying
  * functionality to Vitest's mocking APIs. It handles the creation of spies (`spyOn`,
  * `createSpy`, `createSpyObj`), spy strategies (`and.returnValue`, `and.callFake`),
- * and the inspection of spy calls (`spy.calls.reset`, `spy.calls.mostRecent`).
+ * and the inspection of spy calls (`spy.calls.reset`, `spy.calls.first`, `spy.calls.mostRecent`,
+ * `spy.calls.all`, and the `args`, `returnValue`, and `object` properties of their results).
  */
 
 import ts from 'typescript';
@@ -505,64 +506,171 @@ function createMockedSpyMockProperty(
   return createPropertyAccess(mockedSpy, 'mock');
 }
 
-function transformMostRecentArgs(
-  node: ts.Node,
-  { sourceFile, reporter, pendingVitestValueImports }: RefactorContext,
-): ts.Node {
-  // Check 1: Is it a property access for `.args`?
-  if (
-    !ts.isPropertyAccessExpression(node) ||
-    !ts.isIdentifier(node.name) ||
-    node.name.text !== 'args'
-  ) {
-    return node;
+/**
+ * Maps the properties of a Jasmine `CallInfo` object to the corresponding property on
+ * Vitest's `MockContext`. The optional `valueAccess` is a trailing property that must be
+ * accessed on the resulting element (e.g. `mock.results[i].value`).
+ */
+const CALL_INFO_PROPERTIES = new Map<string, { mockProperty: string; valueAccess?: string }>([
+  ['args', { mockProperty: 'calls' }],
+  ['returnValue', { mockProperty: 'results', valueAccess: 'value' }],
+  ['object', { mockProperty: 'contexts' }],
+]);
+
+/**
+ * Describes a matched expression that evaluates to a Jasmine `CallInfo` object.
+ */
+interface CallInfoAccess {
+  /** The expression representing the spy (e.g. `mySpy` in `mySpy.calls.first()`). */
+  spyIdentifier: ts.Expression;
+
+  /** The index of the call, or `'last'` when referring to the most recent call. */
+  index: ts.Expression | 'last';
+
+  /** A human-readable representation of the matched Jasmine source, for reporting. */
+  sourceText: string;
+
+  /** A human-readable representation of the index used in the replacement, for reporting. */
+  indexText: string;
+}
+
+/**
+ * Attempts to match an expression that yields a Jasmine `CallInfo` object:
+ * `spy.calls.first()`, `spy.calls.mostRecent()`, or `spy.calls.all()[i]`.
+ */
+function getCallInfoAccess(expression: ts.Expression): CallInfoAccess | undefined {
+  let indexExpression: ts.Expression | undefined;
+  let callExpression: ts.Expression = expression;
+  if (ts.isElementAccessExpression(expression)) {
+    indexExpression = expression.argumentExpression;
+    callExpression = expression.expression;
   }
 
-  // Check 2: Is the preceding expression a call expression?
-  const mostRecentCall = node.expression;
   if (
-    !ts.isCallExpression(mostRecentCall) ||
-    !ts.isPropertyAccessExpression(mostRecentCall.expression)
+    !ts.isCallExpression(callExpression) ||
+    !ts.isPropertyAccessExpression(callExpression.expression)
   ) {
-    return node;
+    return undefined;
   }
 
-  // Check 3: Is it a call to `.mostRecent` or `.first`?
-  const mostRecentPae = mostRecentCall.expression;
-  if (
-    !ts.isIdentifier(mostRecentPae.name) ||
-    (mostRecentPae.name.text !== 'mostRecent' && mostRecentPae.name.text !== 'first') ||
-    !ts.isPropertyAccessExpression(mostRecentPae.expression)
-  ) {
-    return node;
+  const methodPae = callExpression.expression;
+  if (!ts.isIdentifier(methodPae.name) || !ts.isPropertyAccessExpression(methodPae.expression)) {
+    return undefined;
   }
 
-  // Check 4: Can we get the spy identifier from `spy.calls`?
-  const spyIdentifier = getSpyIdentifierFromCalls(mostRecentPae.expression);
+  const spyIdentifier = getSpyIdentifierFromCalls(methodPae.expression);
   if (!spyIdentifier) {
+    return undefined;
+  }
+
+  const methodName = methodPae.name.text;
+  if (indexExpression) {
+    // Only `spy.calls.all()[i]` is supported when an element access is present.
+    return methodName === 'all'
+      ? { spyIdentifier, index: indexExpression, sourceText: 'spy.calls.all()[i]', indexText: 'i' }
+      : undefined;
+  }
+
+  switch (methodName) {
+    case 'first':
+      return {
+        spyIdentifier,
+        index: ts.factory.createNumericLiteral(0),
+        sourceText: 'spy.calls.first()',
+        indexText: '0',
+      };
+    case 'mostRecent':
+      return { spyIdentifier, index: 'last', sourceText: 'spy.calls.mostRecent()', indexText: '' };
+  }
+
+  return undefined;
+}
+
+/**
+ * Transforms property accesses on a Jasmine `CallInfo` object (`.args`, `.returnValue`,
+ * `.object`) obtained via `spy.calls.first()`, `spy.calls.mostRecent()`, or `spy.calls.all()[i]`
+ * into the equivalent Vitest `MockContext` access.
+ *
+ * @example
+ * spy.calls.first().args              -> vi.mocked(spy).mock.calls[0]
+ * spy.calls.mostRecent().args         -> vi.mocked(spy).mock.lastCall
+ * spy.calls.all()[i].args             -> vi.mocked(spy).mock.calls[i]
+ * spy.calls.first().returnValue       -> vi.mocked(spy).mock.results[0].value
+ * spy.calls.mostRecent().returnValue  -> vi.mocked(spy).mock.results.at(-1)?.value
+ * spy.calls.all()[i].object           -> vi.mocked(spy).mock.contexts[i]
+ * spy.calls.mostRecent().object       -> vi.mocked(spy).mock.contexts.at(-1)
+ */
+function transformCallInfoProperty(
+  node: ts.Node,
+  { sourceFile, reporter, pendingVitestValueImports }: RefactorContext,
+): ts.Node {
+  if (!ts.isPropertyAccessExpression(node) || !ts.isIdentifier(node.name)) {
     return node;
   }
 
-  if (mostRecentPae.name.text === 'first') {
-    reporter.reportTransformation(
-      sourceFile,
-      node,
-      'Transformed `spy.calls.first().args` to `vi.mocked(spy).mock.calls[0]`.',
-    );
-    const mockProperty = createMockedSpyMockProperty(spyIdentifier, pendingVitestValueImports);
+  const propertyName = node.name.text;
+  const mapping = CALL_INFO_PROPERTIES.get(propertyName);
+  if (!mapping) {
+    return node;
+  }
 
-    return ts.factory.createElementAccessExpression(createPropertyAccess(mockProperty, 'calls'), 0);
+  const callInfo = getCallInfoAccess(node.expression);
+  if (!callInfo) {
+    return node;
+  }
+
+  const mockProperty = createMockedSpyMockProperty(
+    callInfo.spyIdentifier,
+    pendingVitestValueImports,
+  );
+  const mockCollection = createPropertyAccess(mockProperty, mapping.mockProperty);
+
+  let replacement: ts.Expression;
+  let replacementText: string;
+  if (callInfo.index === 'last') {
+    if (propertyName === 'args') {
+      // Vitest provides a dedicated shorthand for the arguments of the last call.
+      replacement = createPropertyAccess(mockProperty, 'lastCall');
+      replacementText = 'vi.mocked(spy).mock.lastCall';
+    } else {
+      // `mock.<collection>.at(-1)`; the result may be `undefined` if the spy was never called,
+      // so a trailing value access must be optional.
+      replacement = ts.factory.createCallExpression(
+        createPropertyAccess(mockCollection, 'at'),
+        undefined,
+        [
+          ts.factory.createPrefixUnaryExpression(
+            ts.SyntaxKind.MinusToken,
+            ts.factory.createNumericLiteral(1),
+          ),
+        ],
+      );
+      replacementText = `vi.mocked(spy).mock.${mapping.mockProperty}.at(-1)`;
+      if (mapping.valueAccess) {
+        replacement = ts.factory.createPropertyAccessChain(
+          replacement,
+          ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+          mapping.valueAccess,
+        );
+        replacementText += `?.${mapping.valueAccess}`;
+      }
+    }
+  } else {
+    replacement = ts.factory.createElementAccessExpression(mockCollection, callInfo.index);
+    replacementText = `vi.mocked(spy).mock.${mapping.mockProperty}[${callInfo.indexText}]`;
+    if (mapping.valueAccess) {
+      replacement = createPropertyAccess(replacement, mapping.valueAccess);
+      replacementText += `.${mapping.valueAccess}`;
+    }
   }
 
-  // If all checks pass, perform the transformation.
   reporter.reportTransformation(
     sourceFile,
     node,
-    'Transformed `spy.calls.mostRecent().args` to `vi.mocked(spy).mock.lastCall`.',
+    `Transformed \`${callInfo.sourceText}.${propertyName}\` to \`${replacementText}\`.`,
   );
-  const mockProperty = createMockedSpyMockProperty(spyIdentifier, pendingVitestValueImports);
 
-  return createPropertyAccess(mockProperty, 'lastCall');
+  return replacement;
 }
 
 function transformThisFor(
@@ -604,69 +712,17 @@ function transformThisFor(
   );
 }
 
-function transformAllCallsArgs(
-  node: ts.Node,
-  { sourceFile, reporter, pendingVitestValueImports }: RefactorContext,
-): ts.Node {
-  if (
-    !ts.isPropertyAccessExpression(node) ||
-    !ts.isIdentifier(node.name) ||
-    node.name.text !== 'args'
-  ) {
-    return node;
-  }
-
-  const elementAccess = node.expression;
-  if (!ts.isElementAccessExpression(elementAccess)) {
-    return node;
-  }
-
-  const allCall = elementAccess.expression;
-  if (!ts.isCallExpression(allCall) || !ts.isPropertyAccessExpression(allCall.expression)) {
-    return node;
-  }
-
-  const allPae = allCall.expression;
-  if (!ts.isIdentifier(allPae.name) || allPae.name.text !== 'all') {
-    return node;
-  }
-
-  if (!ts.isPropertyAccessExpression(allPae.expression)) {
-    return node;
-  }
-
-  const spyIdentifier = getSpyIdentifierFromCalls(allPae.expression);
-  if (!spyIdentifier) {
-    return node;
-  }
-
-  reporter.reportTransformation(
-    sourceFile,
-    node,
-    'Transformed `spy.calls.all()[i].args` to `vi.mocked(spy).mock.calls[i]`.',
-  );
-  const mockProperty = createMockedSpyMockProperty(spyIdentifier, pendingVitestValueImports);
-  const callsProperty = createPropertyAccess(mockProperty, 'calls');
-
-  return ts.factory.createElementAccessExpression(callsProperty, elementAccess.argumentExpression);
-}
-
 export function transformSpyCallInspection(node: ts.Node, refactorCtx: RefactorContext): ts.Node {
-  const mostRecentArgsTransformed = transformMostRecentArgs(node, refactorCtx);
-  if (mostRecentArgsTransformed !== node) {
-    return mostRecentArgsTransformed;
+  const callInfoPropertyTransformed = transformCallInfoProperty(node, refactorCtx);
+  if (callInfoPropertyTransformed !== node) {
+    return callInfoPropertyTransformed;
   }
 
   const thisForTransformed = transformThisFor(node, refactorCtx);
   if (thisForTransformed !== node) {
     return thisForTransformed;
   }
 
-  const allCallsArgsTransformed = transformAllCallsArgs(node, refactorCtx);
-  if (allCallsArgsTransformed !== node) {
-    return allCallsArgsTransformed;
-  }
-
   if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression)) {
     return node;
   }
@@ -720,10 +776,12 @@ export function transformSpyCallInspection(node: ts.Node, refactorCtx: RefactorC
         }
         break;
       case 'mostRecent':
+        // Accesses such as `.args`, `.returnValue`, and `.object` are handled by
+        // `transformCallInfoProperty`; only a bare `mostRecent()` requires manual migration.
         if (
           !ts.isPropertyAccessExpression(node.parent) ||
           !ts.isIdentifier(node.parent.name) ||
-          node.parent.name.text !== 'args'
+          !CALL_INFO_PROPERTIES.has(node.parent.name.text)
         ) {
           const category = 'mostRecent-without-args';
           reporter.recordTodo(category, sourceFile, node);
 
@@ -332,10 +332,40 @@ describe('transformSpyCallInspection', () => {
       input: `expect(mySpy.calls.first().args[0]).toBe(1);`,
       expected: `expect(vi.mocked(mySpy).mock.calls[0][0]).toBe(1);`,
     },
+    {
+      description: 'should transform spy.calls.first().returnValue',
+      input: `const firstResult = mySpy.calls.first().returnValue;`,
+      expected: `const firstResult = vi.mocked(mySpy).mock.results[0].value;`,
+    },
+    {
+      description: 'should transform spy.calls.first().object',
+      input: `const firstThis = mySpy.calls.first().object;`,
+      expected: `const firstThis = vi.mocked(mySpy).mock.contexts[0];`,
+    },
+    {
+      description: 'should transform spy.calls.mostRecent().returnValue',
+      input: `const recentResult = mySpy.calls.mostRecent().returnValue;`,
+      expected: `const recentResult = vi.mocked(mySpy).mock.results.at(-1)?.value;`,
+    },
+    {
+      description: 'should transform spy.calls.mostRecent().object',
+      input: `const recentThis = mySpy.calls.mostRecent().object;`,
+      expected: `const recentThis = vi.mocked(mySpy).mock.contexts.at(-1);`,
+    },
+    {
+      description: 'should transform spy.calls.all()[i].returnValue',
+      input: `expect(mySpy.calls.all()[1].returnValue).toBe(42);`,
+      expected: `expect(vi.mocked(mySpy).mock.results[1].value).toBe(42);`,
+    },
+    {
+      description: 'should transform spy.calls.all()[i].object',
+      input: `expect(mySpy.calls.all()[1].object).toBe(service);`,
+      expected: `expect(vi.mocked(mySpy).mock.contexts[1]).toBe(service);`,
+    },
     {
       description: 'should add a TODO for spy.calls.mostRecent() without .args',
       input: `const mostRecent = mySpy.calls.mostRecent();`,
-      expected: `// TODO: vitest-migration: Direct usage of mostRecent() is not supported. Please refactor to access .args directly or use vi.mocked(spy).mock.lastCall. See: https://vitest.dev/api/mocked.html#mock-lastcall
+      expected: `// TODO: vitest-migration: Direct usage of mostRecent() is not supported. Please refactor to access .args, .returnValue, or .object directly or use vi.mocked(spy).mock.lastCall. See: https://vitest.dev/api/mocked.html#mock-lastcall
 const mostRecent = mySpy.calls.mostRecent();`,
     },
     {
 
@@ -161,7 +161,8 @@ export const TODO_NOTES = {
   'mostRecent-without-args': {
     message:
       'Direct usage of mostRecent() is not supported.' +
-      ' Please refactor to access .args directly or use vi.mocked(spy).mock.lastCall.',
+      ' Please refactor to access .args, .returnValue, or .object directly' +
+      ' or use vi.mocked(spy).mock.lastCall.',
     url: 'https://vitest.dev/api/mocked.html#mock-lastcall',
   },
   'saveArgumentsByValue': {