ref(perf): keep executeField inlinable by extracting traced path

Hoist the resolve tracing decision once per `executeFields` /
`executeFieldsSerially` call instead of re-checking
`shouldTrace(resolveChannel)` per field, and move the traced branch's
`traceMixed` call + ctx closure into a module-scope helper
`invokeResolverWithTracing`. The latter is the load-bearing change:
once `executeField`'s body referenced `traceMixed` and the
`() => resolveFn(...)` closure, V8 stopped inlining `executeField` into
`executeFields`, paying a real call frame per field. Extracting the
two-function tail keeps `executeField`'s bytecode small enough to
inline again.

Effect on the introspection benchmark (the worst-case fan-out shape,
~1000 resolver calls per iteration, no subscribers attached):

- with the inline ternary: -5.94% vs upstream
- with this refactor:     -2.05% / -2.30% across two paired runs

Other benchmarks (list-sync, list-async, list-asyncIterable,
object-async) sit at the noise floor with 95% CIs that cross zero.

Adds a serial-mutation case to resolve-diagnostics-test to cover the
`executeFieldsSerially` branch the hoisted snapshot now lives in.

Author: logaretm

src/execution/Executor.ts

@@ -44,6 +44,7 @@ import {
 } from '../type/definition.js';
 import type { GraphQLSchema } from '../type/schema.js';
 
+import type { MinimalTracingChannel } from '../diagnostics.js';
 import { resolveChannel, shouldTrace, traceMixed } from '../diagnostics.js';
 
 import { AbortedGraphQLExecutionError } from './AbortedGraphQLExecutionError.js';
@@ -480,6 +481,9 @@ export class Executor<
     groupedFieldSet: GroupedFieldSet,
     positionContext: TPositionContext | undefined,
   ): PromiseOrValue<ObjMap<unknown>> {
+    const tracingChannel = shouldTrace(resolveChannel)
+      ? resolveChannel
+      : undefined;
     return promiseReduce(
       groupedFieldSet,
       (results, [responseName, fieldDetailsList]) => {
@@ -493,6 +497,7 @@ export class Executor<
           fieldDetailsList,
           fieldPath,
           positionContext,
+          tracingChannel,
         );
         if (result === undefined) {
           return results;
@@ -523,6 +528,9 @@ export class Executor<
   ): PromiseOrValue<ObjMap<unknown>> {
     const results = Object.create(null);
     let containsPromise = false;
+    const tracingChannel = shouldTrace(resolveChannel)
+      ? resolveChannel
+      : undefined;
 
     try {
       for (const [responseName, fieldDetailsList] of groupedFieldSet) {
@@ -533,6 +541,7 @@ export class Executor<
           fieldDetailsList,
           fieldPath,
           positionContext,
+          tracingChannel,
         );
 
         if (result !== undefined) {
@@ -574,6 +583,7 @@ export class Executor<
     fieldDetailsList: FieldDetailsList,
     path: Path,
     positionContext: TPositionContext | undefined,
+    tracingChannel: MinimalTracingChannel | undefined,
   ): PromiseOrValue<unknown> {
     const validatedExecutionArgs = this.validatedExecutionArgs;
     const { schema, contextValue, variableValues, hideSuggestions } =
@@ -615,11 +625,15 @@ export class Executor<
       // The resolve function's optional third argument is a context value that
       // is provided to every resolve function within an execution. It is commonly
       // used to represent an authenticated user, or request-specific caches.
-      const result = shouldTrace(resolveChannel)
-        ? traceMixed(
-            resolveChannel,
-            buildResolveCtx(info, args, fieldDef.resolve === undefined),
-            () => resolveFn(source, args, contextValue, info),
+      const result = tracingChannel
+        ? invokeResolverWithTracing(
+            tracingChannel,
+            resolveFn,
+            source,
+            args,
+            contextValue,
+            info,
+            fieldDef.resolve === undefined,
           )
         : resolveFn(source, args, contextValue, info);
 
@@ -1430,3 +1444,24 @@ function buildResolveCtx(
     },
   };
 }
+
+/**
+ * Traced path for a single resolver call. Extracted as a module-scope function to increase likelihood of inlining.
+ *
+ * @internal
+ */
+function invokeResolverWithTracing(
+  tracingChannel: MinimalTracingChannel,
+  resolveFn: GraphQLFieldResolver<unknown, unknown>,
+  source: unknown,
+  args: { readonly [argument: string]: unknown },
+  contextValue: unknown,
+  info: GraphQLResolveInfo,
+  isTrivialResolver: boolean,
+): PromiseOrValue<unknown> {
+  return traceMixed(
+    tracingChannel,
+    buildResolveCtx(info, args, isTrivialResolver),
+    () => resolveFn(source, args, contextValue, info),
+  );
+}

src/execution/__tests__/resolve-diagnostics-test.ts

@@ -178,6 +178,35 @@ describe('resolve diagnostics channel', () => {
     expect(endsSync.length).to.equal(4);
   });
 
+  it('emits per-field for serial mutation execution', async () => {
+    const mutationSchema = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: { dummy: { type: GraphQLString } },
+      }),
+      mutation: new GraphQLObjectType({
+        name: 'Mutation',
+        fields: {
+          first: { type: GraphQLString, resolve: () => 'one' },
+          second: { type: GraphQLString, resolve: () => 'two' },
+        },
+      }),
+    });
+
+    active = collectEvents(resolveChannel);
+
+    await execute({
+      schema: mutationSchema,
+      document: parse('mutation M { first second }'),
+    });
+
+    const starts = active.events.filter((e) => e.kind === 'start');
+    expect(starts.map((e) => e.ctx.fieldName)).to.deep.equal([
+      'first',
+      'second',
+    ]);
+  });
+
   it('does nothing when no subscribers are attached', () => {
     const result = execute({
       schema,