@@ -25,6 +25,52 @@ import { addTodoComment } from '../utils/comment-helpers';
 import { RefactorContext } from '../utils/refactor-context';
 import { createViCallExpression } from '../utils/refactor-helpers';
 
+/**
+ * Expression wrappers that do not affect the runtime value of the wrapped expression and
+ * can be looked through when matching Jasmine spy patterns.
+ */
+type TransparentWrapper =
+  | ts.ParenthesizedExpression
+  | ts.AsExpression
+  | ts.NonNullExpression
+  | ts.TypeAssertion
+  | ts.SatisfiesExpression;
+
+function isTransparentWrapper(node: ts.Node): node is TransparentWrapper {
+  return (
+    ts.isParenthesizedExpression(node) ||
+    ts.isAsExpression(node) ||
+    ts.isNonNullExpression(node) ||
+    ts.isTypeAssertionExpression(node) ||
+    ts.isSatisfiesExpression(node)
+  );
+}
+
+/**
+ * Returns the innermost expression after removing any transparent wrappers
+ * (parentheses, non-null assertions, and type assertions).
+ */
+function unwrapExpression(expression: ts.Expression): ts.Expression {
+  let current = expression;
+  while (isTransparentWrapper(current)) {
+    current = current.expression;
+  }
+
+  return current;
+}
+
+/**
+ * Returns the nearest ancestor of a node that is not a transparent wrapper.
+ */
+function getUnwrappedParent(node: ts.Node): ts.Node | undefined {
+  let parent: ts.Node | undefined = node.parent;
+  while (parent && isTransparentWrapper(parent)) {
+    parent = parent.parent;
+  }
+
+  return parent;
+}
+
 function isChainedWithAnd(node: ts.Node): boolean {
   let parent = node.parent;
   while (parent) {
@@ -39,13 +85,7 @@ function isChainedWithAnd(node: ts.Node): boolean {
       ) {
         return true;
       }
-    } else if (
-      ts.isParenthesizedExpression(parent) ||
-      ts.isAsExpression(parent) ||
-      ts.isNonNullExpression(parent) ||
-      ts.isTypeAssertionExpression(parent) ||
-      ts.isSatisfiesExpression(parent)
-    ) {
+    } else if (isTransparentWrapper(parent)) {
       parent = parent.parent;
       continue;
     }
@@ -539,11 +579,12 @@ interface CallInfoAccess {
  * `spy.calls.first()`, `spy.calls.mostRecent()`, or `spy.calls.all()[i]`.
  */
 function getCallInfoAccess(expression: ts.Expression): CallInfoAccess | undefined {
+  const unwrapped = unwrapExpression(expression);
   let indexExpression: ts.Expression | undefined;
-  let callExpression: ts.Expression = expression;
-  if (ts.isElementAccessExpression(expression)) {
-    indexExpression = expression.argumentExpression;
-    callExpression = expression.expression;
+  let callExpression: ts.Expression = unwrapped;
+  if (ts.isElementAccessExpression(unwrapped)) {
+    indexExpression = unwrapped.argumentExpression;
+    callExpression = unwrapExpression(unwrapped.expression);
   }
 
   if (
@@ -625,6 +666,13 @@ function transformCallInfoProperty(
   );
   const mockCollection = createPropertyAccess(mockProperty, mapping.mockProperty);
 
+  // Note: for `args` and `object`, an optional access (`?.`) in the source is intentionally
+  // not carried over. The replacement is a plain element access (e.g. `mock.calls[0]`), which
+  // already evaluates to `undefined` when the spy has not been called, so the result of the
+  // transformed expression itself is unchanged. Only `returnValue` has a trailing `.value`
+  // access that must remain optional to avoid throwing on a missing call.
+  const accessOperator = node.questionDotToken ? '?.' : '.';
+
   let replacement: ts.Expression;
   let replacementText: string;
   if (callInfo.index === 'last') {
@@ -634,7 +682,7 @@ function transformCallInfoProperty(
       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.
+      // so a trailing value access must always be optional.
       replacement = ts.factory.createCallExpression(
         createPropertyAccess(mockCollection, 'at'),
         undefined,
@@ -659,15 +707,21 @@ function transformCallInfoProperty(
     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}`;
+      replacement = node.questionDotToken
+        ? ts.factory.createPropertyAccessChain(
+            replacement,
+            ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+            mapping.valueAccess,
+          )
+        : createPropertyAccess(replacement, mapping.valueAccess);
+      replacementText += `${accessOperator}${mapping.valueAccess}`;
     }
   }
 
   reporter.reportTransformation(
     sourceFile,
     node,
-    `Transformed \`${callInfo.sourceText}.${propertyName}\` to \`${replacementText}\`.`,
+    `Transformed \`${callInfo.sourceText}${accessOperator}${propertyName}\` to \`${replacementText}\`.`,
   );
 
   return replacement;
@@ -775,20 +829,23 @@ export function transformSpyCallInspection(node: ts.Node, refactorCtx: RefactorC
           addTodoComment(node, category);
         }
         break;
-      case 'mostRecent':
+      case 'mostRecent': {
         // Accesses such as `.args`, `.returnValue`, and `.object` are handled by
         // `transformCallInfoProperty`; only a bare `mostRecent()` requires manual migration.
+        const parent = getUnwrappedParent(node);
         if (
-          !ts.isPropertyAccessExpression(node.parent) ||
-          !ts.isIdentifier(node.parent.name) ||
-          !CALL_INFO_PROPERTIES.has(node.parent.name.text)
+          !parent ||
+          !ts.isPropertyAccessExpression(parent) ||
+          !ts.isIdentifier(parent.name) ||
+          !CALL_INFO_PROPERTIES.has(parent.name.text)
         ) {
           const category = 'mostRecent-without-args';
           reporter.recordTodo(category, sourceFile, node);
           addTodoComment(node, category);
         }
 
         return node;
+      }
     }
 
     if (newExpression && message) {
 
@@ -362,6 +362,61 @@ describe('transformSpyCallInspection', () => {
       input: `expect(mySpy.calls.all()[1].object).toBe(service);`,
       expected: `expect(vi.mocked(mySpy).mock.contexts[1]).toBe(service);`,
     },
+    {
+      description: 'should transform CallInfo properties with non-null assertions',
+      input: `
+        const recentArgs = mySpy.calls.mostRecent()!.args;
+        const firstResult = mySpy.calls.first()!.returnValue;
+        const indexedThis = mySpy.calls.all()[1]!.object;
+      `,
+      expected: `
+        const recentArgs = vi.mocked(mySpy).mock.lastCall;
+        const firstResult = vi.mocked(mySpy).mock.results[0].value;
+        const indexedThis = vi.mocked(mySpy).mock.contexts[1];
+      `,
+    },
+    {
+      description: 'should transform CallInfo properties with parenthesized expressions',
+      input: `const firstResult = (mySpy.calls.first()).returnValue;`,
+      expected: `const firstResult = vi.mocked(mySpy).mock.results[0].value;`,
+    },
+    {
+      description: 'should transform CallInfo properties with type assertions',
+      input: `
+        const recentArgs = (mySpy.calls.mostRecent() as jasmine.CallInfo).args;
+        const firstResult = (<jasmine.CallInfo>mySpy.calls.first()).returnValue;
+        const indexedThis = (mySpy.calls.all()[1] satisfies jasmine.CallInfo).object;
+      `,
+      expected: `
+        const recentArgs = vi.mocked(mySpy).mock.lastCall;
+        const firstResult = vi.mocked(mySpy).mock.results[0].value;
+        const indexedThis = vi.mocked(mySpy).mock.contexts[1];
+      `,
+    },
+    {
+      description: 'should transform spy.calls.all()[i] properties when the all() call is wrapped',
+      input: `
+        const parenthesizedArgs = (mySpy.calls.all())[1].args;
+        const assertedArgs = mySpy.calls.all()![1].args;
+      `,
+      expected: `
+        const parenthesizedArgs = vi.mocked(mySpy).mock.calls[1];
+        const assertedArgs = vi.mocked(mySpy).mock.calls[1];
+      `,
+    },
+    {
+      description: 'should preserve optional chaining on CallInfo returnValue accesses',
+      input: `
+        const firstResult = mySpy.calls.first()?.returnValue;
+        const indexedResult = mySpy.calls.all()[1]?.returnValue;
+        const recentResult = mySpy.calls.mostRecent()?.returnValue;
+      `,
+      expected: `
+        const firstResult = vi.mocked(mySpy).mock.results[0]?.value;
+        const indexedResult = vi.mocked(mySpy).mock.results[1]?.value;
+        const recentResult = vi.mocked(mySpy).mock.results.at(-1)?.value;
+      `,
+    },
     {
       description: 'should add a TODO for spy.calls.mostRecent() without .args',
       input: `const mostRecent = mySpy.calls.mostRecent();`,