@graphitation/supermassive 3.2.7 → 3.3.0

package/lib/executeWithoutSchema.mjs

@@ -40,12 +40,13 @@ var __async = (__this, __arguments, generator) => {
 
 // src/executeWithoutSchema.ts
 import {
+  GraphQLError,
   Kind,
   locatedError
 } from "graphql";
 import {
   collectFields,
-  collectSubfields as _collectSubfields
+  collectSubfields
 } from "./collectFields.mjs";
 import { devAssert } from "./jsutils/devAssert.mjs";
 import { inspect } from "./jsutils/inspect.mjs";
@@ -75,15 +76,40 @@ import {
 } from "./schema/reference.mjs";
 import * as Definitions from "./schema/definition.mjs";
 import * as Resolvers from "./schema/resolvers.mjs";
-var collectSubfields = memoize3(
-  (exeContext, returnTypeName, fieldGroup) => _collectSubfields(exeContext, returnTypeName.name, fieldGroup)
+import {
+  buildFieldPlan
+} from "./buildFieldPlan.mjs";
+import {
+  DeferredFragmentRecord,
+  DeferredGroupedFieldSetRecord,
+  IncrementalPublisher,
+  InitialResultRecord,
+  StreamItemsRecord,
+  StreamRecord
+} from "./IncrementalPublisher.mjs";
+var buildSubFieldPlan = memoize3(
+  (exeContext, returnTypeName, fieldGroup) => {
+    const subFields = collectSubfields(
+      exeContext.schemaFragment,
+      exeContext.fragments,
+      exeContext.variableValues,
+      exeContext.operation,
+      returnTypeName.name,
+      fieldGroup.fields
+    );
+    return buildFieldPlan(
+      subFields,
+      fieldGroup.deferUsages,
+      fieldGroup.knownDeferUsages
+    );
+  }
 );
 function executeWithoutSchema(args) {
   const exeContext = buildExecutionContext(args);
   if (!("schemaFragment" in exeContext)) {
     return { errors: exeContext };
   } else {
-    return executeOperation(exeContext);
+    return executeImpl(exeContext);
   }
 }
 function assertValidExecutionArguments(document, rawVariableValues) {
@@ -162,24 +188,75 @@ function buildExecutionContext(args) {
     fieldResolver: fieldResolver != null ? fieldResolver : defaultFieldResolver,
     typeResolver: typeResolver != null ? typeResolver : defaultTypeResolver,
     subscribeFieldResolver: subscribeFieldResolver != null ? subscribeFieldResolver : defaultFieldResolver,
-    errors: [],
     fieldExecutionHooks,
-    subsequentPayloads: /* @__PURE__ */ new Set()
+    incrementalPublisher: new IncrementalPublisher()
   };
 }
 function buildPerEventExecutionContext(exeContext, payload) {
   return __spreadProps(__spreadValues({}, exeContext), {
     contextValue: exeContext.buildContextValue ? exeContext.buildContextValue(exeContext.contextValue) : exeContext.contextValue,
-    rootValue: payload,
-    subsequentPayloads: /* @__PURE__ */ new Set(),
-    errors: []
+    rootValue: payload
   });
 }
-function executeOperation(exeContext) {
-  const { operation, rootValue } = exeContext;
+function executeImpl(exeContext) {
+  const incrementalPublisher = exeContext.incrementalPublisher;
+  const initialResultRecord = new InitialResultRecord();
+  try {
+    const data = executeOperation(exeContext, initialResultRecord);
+    if (isPromise(data)) {
+      return data.then(
+        (resolved) => {
+          if (isAsyncIterable(resolved)) {
+            return resolved;
+          } else {
+            return incrementalPublisher.buildDataResponse(
+              initialResultRecord,
+              resolved
+            );
+          }
+        },
+        (error) => incrementalPublisher.buildErrorResponse(initialResultRecord, error)
+      );
+    }
+    if (isAsyncIterable(data)) {
+      return data;
+    } else {
+      return incrementalPublisher.buildDataResponse(initialResultRecord, data);
+    }
+  } catch (error) {
+    if (exeContext.operation.operation === "subscription") {
+      return { errors: [error] };
+    } else {
+      return incrementalPublisher.buildErrorResponse(
+        initialResultRecord,
+        error
+      );
+    }
+  }
+}
+function executeOperation(exeContext, initialResultRecord) {
+  const { operation, rootValue, incrementalPublisher } = exeContext;
   const rootTypeName = getOperationRootTypeName(operation);
-  const { groupedFieldSet, patches } = collectFields(exeContext, rootTypeName);
+  if (rootTypeName == null) {
+    throw new GraphQLError(
+      `Schema is not configured to execute ${operation.operation} operation.`,
+      operation
+    );
+  }
+  const fields = collectFields(exeContext, rootTypeName);
+  const { groupedFieldSet, newGroupedFieldSetDetailsMap, newDeferUsages } = buildFieldPlan(fields);
+  const newDeferMap = addNewDeferredFragments(
+    incrementalPublisher,
+    newDeferUsages,
+    initialResultRecord
+  );
   const path = void 0;
+  const newDeferredGroupedFieldSetRecords = addNewDeferredGroupedFieldSets(
+    incrementalPublisher,
+    newGroupedFieldSetDetailsMap,
+    newDeferMap,
+    path
+  );
   let result;
   switch (operation.operation) {
     case "query":
@@ -189,9 +266,9 @@ function executeOperation(exeContext) {
         rootValue,
         path,
         groupedFieldSet,
-        void 0
+        initialResultRecord,
+        newDeferMap
       );
-      result = buildResponse(exeContext, result);
       break;
     case "mutation":
       result = executeFieldsSerially(
@@ -199,9 +276,10 @@ function executeOperation(exeContext) {
         rootTypeName,
         rootValue,
         path,
-        groupedFieldSet
+        groupedFieldSet,
+        initialResultRecord,
+        newDeferMap
       );
-      result = buildResponse(exeContext, result);
       break;
     case "subscription": {
       const resultOrStreamOrPromise = createSourceEventStream(exeContext);
@@ -210,57 +288,26 @@ function executeOperation(exeContext) {
         exeContext,
         rootTypeName,
         path,
-        groupedFieldSet
+        groupedFieldSet,
+        initialResultRecord,
+        newDeferMap
       );
       break;
     }
-    default:
-      invariant(
-        false,
-        `Operation "${operation.operation}" is not a part of GraphQL spec`
-      );
   }
-  for (const patch of patches) {
-    const { label, groupedFieldSet: patchGroupedFieldSet } = patch;
-    executeDeferredFragment(
+  if (operation.operation !== "subscription") {
+    executeDeferredGroupedFieldSets(
       exeContext,
       rootTypeName,
       rootValue,
-      patchGroupedFieldSet,
-      label,
-      path
+      path,
+      newDeferredGroupedFieldSetRecords,
+      newDeferMap
     );
   }
   return result;
 }
-function buildResponse(exeContext, data) {
-  if (isPromise(data)) {
-    return data.then(
-      (resolved) => buildResponse(exeContext, resolved),
-      (error) => {
-        exeContext.errors.push(error);
-        return buildResponse(exeContext, null);
-      }
-    );
-  }
-  try {
-    const initialResult = exeContext.errors.length === 0 ? { data } : { errors: exeContext.errors, data };
-    if (exeContext.subsequentPayloads.size > 0) {
-      return {
-        initialResult: __spreadProps(__spreadValues({}, initialResult), {
-          hasNext: true
-        }),
-        subsequentResults: yieldSubsequentPayloads(exeContext)
-      };
-    } else {
-      return initialResult;
-    }
-  } catch (error) {
-    exeContext.errors.push(error);
-    return buildResponse(exeContext, null);
-  }
-}
-function executeFieldsSerially(exeContext, parentTypeName, sourceValue, path, groupedFieldSet) {
+function executeFieldsSerially(exeContext, parentTypeName, sourceValue, path, groupedFieldSet, incrementalDataRecord, deferMap) {
   return promiseReduce(
     groupedFieldSet,
     (results, [responseName, fieldGroup]) => {
@@ -271,7 +318,8 @@ function executeFieldsSerially(exeContext, parentTypeName, sourceValue, path, gr
         sourceValue,
         fieldGroup,
         fieldPath,
-        void 0
+        incrementalDataRecord,
+        deferMap
       );
       if (result === void 0) {
         return results;
@@ -288,7 +336,7 @@ function executeFieldsSerially(exeContext, parentTypeName, sourceValue, path, gr
     /* @__PURE__ */ Object.create(null)
   );
 }
-function executeFields(exeContext, parentTypeName, sourceValue, path, groupedFieldSet, incrementalDataRecord) {
+function executeFields(exeContext, parentTypeName, sourceValue, path, groupedFieldSet, incrementalDataRecord, deferMap) {
   const results = /* @__PURE__ */ Object.create(null);
   let containsPromise = false;
   for (const [responseName, fieldGroup] of groupedFieldSet) {
@@ -299,7 +347,8 @@ function executeFields(exeContext, parentTypeName, sourceValue, path, groupedFie
       sourceValue,
       fieldGroup,
       fieldPath,
-      incrementalDataRecord
+      incrementalDataRecord,
+      deferMap
     );
     if (result !== void 0) {
       results[responseName] = result;
@@ -313,9 +362,9 @@ function executeFields(exeContext, parentTypeName, sourceValue, path, groupedFie
   }
   return promiseForObject(results);
 }
-function executeField(exeContext, parentTypeName, source, fieldGroup, path, incrementalDataRecord) {
+function executeField(exeContext, parentTypeName, source, fieldGroup, path, incrementalDataRecord, deferMap) {
   const schemaFragment = exeContext.schemaFragment;
-  const fieldName = fieldGroup[0].name.value;
+  const fieldName = fieldGroup.fields[0].node.name.value;
   const fieldDef = Definitions.getField(
     schemaFragment.definitions,
     parentTypeName,
@@ -329,7 +378,8 @@ function executeField(exeContext, parentTypeName, source, fieldGroup, path, incr
       fieldGroup,
       path,
       source,
-      incrementalDataRecord
+      incrementalDataRecord,
+      deferMap
     );
   }
   const loading = requestSchemaFragment(exeContext, {
@@ -354,7 +404,8 @@ function executeField(exeContext, parentTypeName, source, fieldGroup, path, incr
         fieldGroup,
         path,
         source,
-        incrementalDataRecord
+        incrementalDataRecord,
+        deferMap
       );
     }
     return void 0;
@@ -380,24 +431,16 @@ function requestSchemaFragment(exeContext, request) {
   });
 }
 function createSourceEventStream(exeContext) {
-  try {
-    const eventStream = executeSubscriptionImpl(exeContext);
-    if (isPromise(eventStream)) {
-      return eventStream.then(void 0, (error) => ({ errors: [error] }));
-    }
-    return eventStream;
-  } catch (error) {
-    return { errors: [error] };
-  }
+  return executeSubscriptionImpl(exeContext);
 }
 function executeSubscriptionImpl(exeContext) {
   var _a;
-  const { operation, rootValue, schemaFragment } = exeContext;
+  const { schemaFragment, operation, rootValue } = exeContext;
   const rootTypeName = getOperationRootTypeName(operation);
-  const { groupedFieldSet } = collectFields(exeContext, rootTypeName);
-  const firstRootField = groupedFieldSet.entries().next().value;
-  const [responseName, fieldGroup] = firstRootField;
-  const fieldName = fieldGroup[0].name.value;
+  const fields = collectFields(exeContext, rootTypeName);
+  const { groupedFieldSet } = buildFieldPlan(fields);
+  const [responseName, fieldGroup] = groupedFieldSet.entries().next().value;
+  const fieldName = toNodes(fieldGroup)[0].name.value;
   const fieldDef = Definitions.getField(
     schemaFragment.definitions,
     rootTypeName,
@@ -406,7 +449,7 @@ function executeSubscriptionImpl(exeContext) {
   if (!fieldDef) {
     throw locatedError(
       `The subscription field "${fieldName}" is not defined.`,
-      fieldGroup
+      toNodes(fieldGroup)
     );
   }
   const returnTypeRef = Definitions.getFieldTypeReference(fieldDef);
@@ -425,17 +468,22 @@ function executeSubscriptionImpl(exeContext) {
     path
   );
   try {
-    const args = getArgumentValues(exeContext, fieldDef, fieldGroup[0]);
+    const args = getArgumentValues(
+      exeContext.schemaFragment,
+      fieldDef,
+      toNodes(fieldGroup)[0],
+      exeContext.variableValues
+    );
     const contextValue = exeContext.contextValue;
     const result = resolveFn(rootValue, args, contextValue, info);
     if (isPromise(result)) {
       return result.then(assertEventStream).then(void 0, (error) => {
-        throw locatedError(error, fieldGroup, pathToArray(path));
+        throw locatedError(error, toNodes(fieldGroup), pathToArray(path));
       });
     }
     return assertEventStream(result);
   } catch (error) {
-    throw locatedError(error, fieldGroup, pathToArray(path));
+    throw locatedError(error, toNodes(fieldGroup), pathToArray(path));
   }
 }
 function assertEventStream(result) {
@@ -450,7 +498,7 @@ function assertEventStream(result) {
   }
   return result;
 }
-function mapResultOrEventStreamOrPromise(resultOrStreamOrPromise, exeContext, parentTypeName, path, groupedFieldSet) {
+function mapResultOrEventStreamOrPromise(resultOrStreamOrPromise, exeContext, parentTypeName, path, groupedFieldSet, initialResultRecord, deferMap) {
   if (isPromise(resultOrStreamOrPromise)) {
     return resultOrStreamOrPromise.then(
       (resultOrStream) => mapResultOrEventStreamOrPromise(
@@ -458,7 +506,9 @@ function mapResultOrEventStreamOrPromise(resultOrStreamOrPromise, exeContext, pa
         exeContext,
         parentTypeName,
         path,
-        groupedFieldSet
+        groupedFieldSet,
+        initialResultRecord,
+        deferMap
       )
     );
   } else {
@@ -470,15 +520,42 @@ function mapResultOrEventStreamOrPromise(resultOrStreamOrPromise, exeContext, pa
           exeContext,
           payload
         );
-        const data = executeFields(
-          exeContext,
-          parentTypeName,
-          payload,
-          path,
-          groupedFieldSet,
-          void 0
-        );
-        return buildResponse(perEventContext, data);
+        const perEventResultRecord = new InitialResultRecord();
+        try {
+          const data = executeFields(
+            perEventContext,
+            parentTypeName,
+            payload,
+            path,
+            groupedFieldSet,
+            perEventResultRecord,
+            deferMap
+          );
+          if (isPromise(data)) {
+            return data.then(
+              (resolved) => {
+                return exeContext.incrementalPublisher.buildDataResponse(
+                  perEventResultRecord,
+                  resolved
+                );
+              },
+              (error) => exeContext.incrementalPublisher.buildErrorResponse(
+                perEventResultRecord,
+                error
+              )
+            );
+          } else {
+            return exeContext.incrementalPublisher.buildDataResponse(
+              perEventResultRecord,
+              data
+            );
+          }
+        } catch (error) {
+          return exeContext.incrementalPublisher.buildErrorResponse(
+            perEventResultRecord,
+            error
+          );
+        }
       };
       return mapAsyncIterator(resultOrStreamOrPromise, mapSourceToResponse);
     }
@@ -487,7 +564,7 @@ function mapResultOrEventStreamOrPromise(resultOrStreamOrPromise, exeContext, pa
 function buildResolveInfo(exeContext, fieldName, fieldGroup, parentTypeName, returnTypeName, path) {
   return {
     fieldName,
-    fieldNodes: fieldGroup,
+    fieldNodes: toNodes(fieldGroup),
     returnTypeName,
     parentTypeName,
     path,
@@ -498,17 +575,15 @@ function buildResolveInfo(exeContext, fieldName, fieldGroup, parentTypeName, ret
   };
 }
 function handleFieldError(rawError, exeContext, returnTypeRef, fieldGroup, path, incrementalDataRecord) {
-  var _a;
-  const error = locatedError(rawError, fieldGroup, pathToArray(path));
+  const error = locatedError(rawError, toNodes(fieldGroup), pathToArray(path));
   if (isNonNullType(returnTypeRef)) {
     throw error;
   }
-  const errors = (_a = incrementalDataRecord == null ? void 0 : incrementalDataRecord.errors) != null ? _a : exeContext.errors;
-  errors.push(error);
+  exeContext.incrementalPublisher.addFieldError(incrementalDataRecord, error);
 }
-function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fieldGroup, path, source, incrementalDataRecord) {
+function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fieldGroup, path, source, incrementalDataRecord, deferMap) {
   var _a;
-  const fieldName = fieldGroup[0].name.value;
+  const fieldName = fieldGroup.fields[0].node.name.value;
   const returnTypeRef = Definitions.getFieldTypeReference(fieldDefinition);
   const resolveFn = (_a = Resolvers.getFieldResolver(
     exeContext.schemaFragment,
@@ -526,10 +601,15 @@ function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fi
   const isDefaultResolverUsed = resolveFn === exeContext.fieldResolver;
   const hooks = exeContext.fieldExecutionHooks;
   try {
-    const args = getArgumentValues(exeContext, fieldDefinition, fieldGroup[0]);
+    const args = getArgumentValues(
+      exeContext.schemaFragment,
+      fieldDefinition,
+      fieldGroup.fields[0].node,
+      exeContext.variableValues
+    );
     const contextValue = exeContext.contextValue;
     if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.beforeFieldResolve)) {
-      invokeBeforeFieldResolveHook(info, exeContext);
+      invokeBeforeFieldResolveHook(info, exeContext, incrementalDataRecord);
     }
     const result = resolveFn(source, args, contextValue, info);
     let completed;
@@ -537,7 +617,12 @@ function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fi
       completed = result.then(
         (resolved) => {
           if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve)) {
-            invokeAfterFieldResolveHook(info, exeContext, resolved);
+            invokeAfterFieldResolveHook(
+              info,
+              exeContext,
+              incrementalDataRecord,
+              resolved
+            );
           }
           return completeValue(
             exeContext,
@@ -546,19 +631,31 @@ function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fi
             info,
             path,
             resolved,
-            incrementalDataRecord
+            incrementalDataRecord,
+            deferMap
           );
         },
         (rawError) => {
           if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve)) {
-            invokeAfterFieldResolveHook(info, exeContext, void 0, rawError);
+            invokeAfterFieldResolveHook(
+              info,
+              exeContext,
+              incrementalDataRecord,
+              void 0,
+              rawError
+            );
           }
           throw rawError;
         }
       );
     } else {
       if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve)) {
-        invokeAfterFieldResolveHook(info, exeContext, result);
+        invokeAfterFieldResolveHook(
+          info,
+          exeContext,
+          incrementalDataRecord,
+          result
+        );
       }
       completed = completeValue(
         exeContext,
@@ -567,21 +664,37 @@ function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fi
         info,
         path,
         result,
-        incrementalDataRecord
+        incrementalDataRecord,
+        deferMap
       );
     }
     if (isPromise(completed)) {
       return completed.then(
         (resolved) => {
           if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldComplete)) {
-            invokeAfterFieldCompleteHook(info, exeContext, resolved);
+            invokeAfterFieldCompleteHook(
+              info,
+              exeContext,
+              incrementalDataRecord,
+              resolved
+            );
           }
           return resolved;
         },
         (rawError) => {
-          const error = locatedError(rawError, fieldGroup, pathToArray(path));
+          const error = locatedError(
+            rawError,
+            toNodes(fieldGroup),
+            pathToArray(path)
+          );
           if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldComplete)) {
-            invokeAfterFieldCompleteHook(info, exeContext, void 0, error);
+            invokeAfterFieldCompleteHook(
+              info,
+              exeContext,
+              incrementalDataRecord,
+              void 0,
+              error
+            );
           }
           handleFieldError(
             rawError,
@@ -596,17 +709,34 @@ function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fi
       );
     }
     if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldComplete)) {
-      invokeAfterFieldCompleteHook(info, exeContext, completed);
+      invokeAfterFieldCompleteHook(
+        info,
+        exeContext,
+        incrementalDataRecord,
+        completed
+      );
     }
     return completed;
   } catch (rawError) {
     const pathArray = pathToArray(path);
-    const error = locatedError(rawError, fieldGroup, pathArray);
+    const error = locatedError(rawError, fieldGroup.fields[0].node, pathArray);
     if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve) && error.path && arraysAreEqual(pathArray, error.path)) {
-      invokeAfterFieldResolveHook(info, exeContext, void 0, error);
+      invokeAfterFieldResolveHook(
+        info,
+        exeContext,
+        incrementalDataRecord,
+        void 0,
+        error
+      );
     }
     if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldComplete)) {
-      invokeAfterFieldCompleteHook(info, exeContext, void 0, error);
+      invokeAfterFieldCompleteHook(
+        info,
+        exeContext,
+        incrementalDataRecord,
+        void 0,
+        error
+      );
     }
     handleFieldError(
       rawError,
@@ -619,7 +749,7 @@ function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fi
     return null;
   }
 }
-function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord) {
+function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord, deferMap) {
   if (result instanceof Error) {
     throw result;
   }
@@ -631,7 +761,8 @@ function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result
       info,
       path,
       result,
-      incrementalDataRecord
+      incrementalDataRecord,
+      deferMap
     );
     if (completed === null) {
       throw new Error(
@@ -651,7 +782,8 @@ function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result
       info,
       path,
       result,
-      incrementalDataRecord
+      incrementalDataRecord,
+      deferMap
     );
   }
   const { schemaFragment } = exeContext;
@@ -668,7 +800,8 @@ function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result
       info,
       path,
       result,
-      incrementalDataRecord
+      incrementalDataRecord,
+      deferMap
     );
   }
   if (Definitions.isObjectType(schemaFragment.definitions, returnTypeRef)) {
@@ -678,7 +811,8 @@ function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result
       fieldGroup,
       path,
       result,
-      incrementalDataRecord
+      incrementalDataRecord,
+      deferMap
     );
   }
   invariant(
@@ -686,7 +820,7 @@ function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result
     "Cannot complete value of unexpected output type: " + inspectTypeReference(returnTypeRef)
   );
 }
-function completePromisedValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord) {
+function completePromisedValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord, deferMap) {
   return __async(this, null, function* () {
     try {
       const resolved = yield result;
@@ -697,7 +831,8 @@ function completePromisedValue(exeContext, returnTypeRef, fieldGroup, info, path
         info,
         path,
         resolved,
-        incrementalDataRecord
+        incrementalDataRecord,
+        deferMap
       );
       if (isPromise(completed)) {
         completed = yield completed;
@@ -712,12 +847,12 @@ function completePromisedValue(exeContext, returnTypeRef, fieldGroup, info, path
         path,
         incrementalDataRecord
       );
-      filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
+      exeContext.incrementalPublisher.filter(path, incrementalDataRecord);
       return null;
     }
   });
 }
-function completeListValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord) {
+function completeListValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord, deferMap) {
   const itemTypeRef = unwrap(returnTypeRef);
   if (isAsyncIterable(result)) {
     const asyncIterator = result[Symbol.asyncIterator]();
@@ -728,7 +863,8 @@ function completeListValue(exeContext, returnTypeRef, fieldGroup, info, path, re
       info,
       path,
       asyncIterator,
-      incrementalDataRecord
+      incrementalDataRecord,
+      deferMap
     );
   }
   if (!isIterableObject(result)) {
@@ -737,24 +873,28 @@ function completeListValue(exeContext, returnTypeRef, fieldGroup, info, path, re
       []
     );
   }
-  const stream = getStreamValues(exeContext, fieldGroup, path);
+  const streamUsage = getStreamUsage(exeContext, fieldGroup, path);
   let containsPromise = false;
-  let previousIncrementalDataRecord = incrementalDataRecord;
+  let currentParents = incrementalDataRecord;
   const completedResults = [];
   let index = 0;
+  let streamRecord;
   for (const item of result) {
     const itemPath = addPath(path, index, void 0);
-    if (stream && typeof stream.initialCount === "number" && index >= stream.initialCount) {
-      previousIncrementalDataRecord = executeStreamField(
+    if (streamUsage && index >= streamUsage.initialCount) {
+      if (streamRecord === void 0) {
+        streamRecord = new StreamRecord({ label: streamUsage.label, path });
+      }
+      currentParents = executeStreamField(
         path,
         itemPath,
         item,
         exeContext,
-        fieldGroup,
+        streamUsage.fieldGroup,
         info,
         itemTypeRef,
-        stream.label,
-        previousIncrementalDataRecord
+        currentParents,
+        streamRecord
       );
       index++;
       continue;
@@ -767,7 +907,8 @@ function completeListValue(exeContext, returnTypeRef, fieldGroup, info, path, re
       fieldGroup,
       info,
       itemPath,
-      incrementalDataRecord
+      incrementalDataRecord,
+      deferMap
     )) {
       containsPromise = true;
     }
@@ -775,7 +916,52 @@ function completeListValue(exeContext, returnTypeRef, fieldGroup, info, path, re
   }
   return containsPromise ? Promise.all(completedResults) : completedResults;
 }
-function completeListItemValue(item, completedResults, exeContext, itemTypeRef, fieldGroup, info, itemPath, incrementalDataRecord) {
+function getStreamUsage(exeContext, fieldGroup, path) {
+  if (typeof path.key === "number") {
+    return;
+  }
+  if (fieldGroup._streamUsage !== void 0) {
+    return fieldGroup._streamUsage;
+  }
+  const stream = getDirectiveValues(
+    exeContext.schemaFragment,
+    GraphQLStreamDirective,
+    fieldGroup.fields[0].node,
+    exeContext.variableValues
+  );
+  if (!stream) {
+    return;
+  }
+  if (stream.if === false) {
+    return;
+  }
+  invariant(
+    typeof stream.initialCount === "number",
+    "initialCount must be a number"
+  );
+  invariant(
+    stream.initialCount >= 0,
+    "initialCount must be a positive integer"
+  );
+  invariant(
+    exeContext.operation.operation !== "subscription",
+    "`@stream` directive not supported on subscription operations. Disable `@stream` by setting the `if` argument to `false`."
+  );
+  const streamedFieldGroup = {
+    fields: fieldGroup.fields.map((fieldDetails) => ({
+      node: fieldDetails.node,
+      deferUsage: void 0
+    }))
+  };
+  const streamUsage = {
+    initialCount: stream.initialCount,
+    label: typeof stream.label === "string" ? stream.label : void 0,
+    fieldGroup: streamedFieldGroup
+  };
+  fieldGroup._streamUsage = streamUsage;
+  return streamUsage;
+}
+function completeListItemValue(item, completedResults, exeContext, itemTypeRef, fieldGroup, info, itemPath, incrementalDataRecord, deferMap) {
   if (isPromise(item)) {
     completedResults.push(
       completePromisedValue(
@@ -785,7 +971,8 @@ function completeListItemValue(item, completedResults, exeContext, itemTypeRef,
         info,
         itemPath,
         item,
-        incrementalDataRecord
+        incrementalDataRecord,
+        deferMap
       )
     );
     return true;
@@ -798,7 +985,8 @@ function completeListItemValue(item, completedResults, exeContext, itemTypeRef,
       info,
       itemPath,
       item,
-      incrementalDataRecord
+      incrementalDataRecord,
+      deferMap
     );
     if (isPromise(completedItem)) {
       completedResults.push(
@@ -811,7 +999,10 @@ function completeListItemValue(item, completedResults, exeContext, itemTypeRef,
             itemPath,
             incrementalDataRecord
           );
-          filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
+          exeContext.incrementalPublisher.filter(
+            itemPath,
+            incrementalDataRecord
+          );
           return null;
         })
       );
@@ -827,61 +1018,35 @@ function completeListItemValue(item, completedResults, exeContext, itemTypeRef,
       itemPath,
       incrementalDataRecord
     );
-    filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
+    exeContext.incrementalPublisher.filter(itemPath, incrementalDataRecord);
     completedResults.push(null);
   }
   return false;
 }
-function getStreamValues(exeContext, fieldGroup, path) {
-  if (typeof path.key === "number") {
-    return;
-  }
-  const stream = getDirectiveValues(
-    exeContext,
-    GraphQLStreamDirective,
-    fieldGroup[0]
-  );
-  if (!stream) {
-    return;
-  }
-  if (stream.if === false) {
-    return;
-  }
-  invariant(
-    typeof stream.initialCount === "number",
-    "initialCount must be a number"
-  );
-  invariant(
-    stream.initialCount >= 0,
-    "initialCount must be a positive integer"
-  );
-  invariant(
-    exeContext.operation.operation !== "subscription",
-    "`@stream` directive not supported on subscription operations. Disable `@stream` by setting the `if` argument to `false`."
-  );
-  return {
-    initialCount: stream.initialCount,
-    label: typeof stream.label === "string" ? stream.label : void 0
-  };
-}
-function completeAsyncIteratorValue(exeContext, itemTypeRef, fieldGroup, info, path, asyncIterator, incrementalDataRecord) {
+function completeAsyncIteratorValue(exeContext, itemTypeRef, fieldGroup, info, path, asyncIterator, incrementalDataRecord, deferMap) {
   return __async(this, null, function* () {
-    const stream = getStreamValues(exeContext, fieldGroup, path);
+    const streamUsage = getStreamUsage(exeContext, fieldGroup, path);
     let containsPromise = false;
     const completedResults = [];
     let index = 0;
     while (true) {
-      if (stream && typeof stream.initialCount === "number" && index >= stream.initialCount) {
+      if (streamUsage && index >= streamUsage.initialCount) {
+        const earlyReturn = asyncIterator.return;
+        const streamRecord = new StreamRecord({
+          label: streamUsage.label,
+          path,
+          earlyReturn: earlyReturn === void 0 ? void 0 : earlyReturn.bind(asyncIterator)
+        });
         executeStreamAsyncIterator(
           index,
           asyncIterator,
           exeContext,
-          fieldGroup,
+          streamUsage.fieldGroup,
           info,
           itemTypeRef,
           path,
-          stream.label,
-          incrementalDataRecord
+          incrementalDataRecord,
+          streamRecord
         );
         break;
       }
@@ -893,7 +1058,7 @@ function completeAsyncIteratorValue(exeContext, itemTypeRef, fieldGroup, info, p
           break;
         }
       } catch (rawError) {
-        throw locatedError(rawError, fieldGroup, pathToArray(path));
+        throw locatedError(rawError, toNodes(fieldGroup), pathToArray(path));
       }
       if (completeListItemValue(
         iteration.value,
@@ -903,7 +1068,8 @@ function completeAsyncIteratorValue(exeContext, itemTypeRef, fieldGroup, info, p
         fieldGroup,
         info,
         itemPath,
-        incrementalDataRecord
+        incrementalDataRecord,
+        deferMap
       )) {
         containsPromise = true;
       }
@@ -921,7 +1087,7 @@ function completeLeafValue(returnType, result) {
   }
   return serializedResult;
 }
-function completeAbstractValue(exeContext, returnTypeName, fieldGroup, info, path, result, incrementalDataRecord) {
+function completeAbstractValue(exeContext, returnTypeName, fieldGroup, info, path, result, incrementalDataRecord, deferMap) {
   var _a;
   const { schemaFragment } = exeContext;
   const resolveTypeFn = (_a = Resolvers.getAbstractTypeResolver(schemaFragment, returnTypeName)) != null ? _a : exeContext.typeResolver;
@@ -952,7 +1118,8 @@ function completeAbstractValue(exeContext, returnTypeName, fieldGroup, info, pat
         fieldGroup,
         path,
         result,
-        incrementalDataRecord
+        incrementalDataRecord,
+        deferMap
       )
     );
   }
@@ -962,14 +1129,15 @@ function completeAbstractValue(exeContext, returnTypeName, fieldGroup, info, pat
     fieldGroup,
     path,
     result,
-    incrementalDataRecord
+    incrementalDataRecord,
+    deferMap
   );
 }
 function ensureValidRuntimeType(runtimeTypeName, exeContext, returnTypeName, fieldGroup, info, result) {
   if (runtimeTypeName == null) {
     throw locatedError(
       `Abstract type "${returnTypeName}" must resolve to an Object type at runtime for field "${info.parentTypeName}.${info.fieldName}". Either the "${returnTypeName}" should provide a "__resolveType" resolver function or "${info.parentTypeName}.${info.fieldName}" should be an object with "__typename" property.`,
-      fieldGroup
+      toNodes(fieldGroup)
     );
   }
   if (typeof runtimeTypeName !== "string") {
@@ -1011,19 +1179,19 @@ function ensureValidRuntimeTypeImpl(runtimeTypeName, exeContext, returnTypeName,
     if (!Definitions.isDefined(definitions, runtimeTypeName)) {
       throw locatedError(
         `Abstract type "${returnTypeName}" was resolved to a type "${runtimeTypeName}" that does not exist inside the schema.`,
-        fieldGroup
+        toNodes(fieldGroup)
       );
     }
     if (!Definitions.isObjectType(definitions, runtimeTypeName)) {
       throw locatedError(
         `Abstract type "${returnTypeName}" was resolved to a non-object type "${runtimeTypeName}".`,
-        fieldGroup
+        toNodes(fieldGroup)
       );
     }
     if (!Definitions.isSubType(definitions, returnTypeName, runtimeTypeName)) {
       throw locatedError(
         `Runtime Object type "${runtimeTypeName}" is not a possible type for "${returnTypeName}".`,
-        fieldGroup
+        toNodes(fieldGroup)
       );
     }
     return runtimeTypeName;
@@ -1033,7 +1201,7 @@ function ensureValidRuntimeTypeImpl(runtimeTypeName, exeContext, returnTypeName,
     if (Definitions.isDefined(definitions, runtimeTypeName) && !Definitions.isObjectType(definitions, runtimeTypeName)) {
       throw locatedError(
         `Abstract type "${returnTypeName}" was resolved to a non-object type "${runtimeTypeName}".`,
-        fieldGroup
+        toNodes(fieldGroup)
       );
     }
     Definitions.addInterfaceImplementation(
@@ -1045,41 +1213,104 @@ function ensureValidRuntimeTypeImpl(runtimeTypeName, exeContext, returnTypeName,
   }
   invariant(false, `${returnTypeName} is not an abstract type`);
 }
-function completeObjectValue(exeContext, returnTypeName, fieldGroup, path, result, incrementalDataRecord) {
+function completeObjectValue(exeContext, returnTypeName, fieldGroup, path, result, incrementalDataRecord, deferMap) {
   return collectAndExecuteSubfields(
     exeContext,
     returnTypeName,
     fieldGroup,
     path,
     result,
-    incrementalDataRecord
+    incrementalDataRecord,
+    deferMap
   );
 }
-function collectAndExecuteSubfields(exeContext, returnTypeName, fieldGroup, path, result, incrementalDataRecord) {
-  const { groupedFieldSet: subGroupedFieldSet, patches: subPatches } = collectSubfields(exeContext, { name: returnTypeName }, fieldGroup);
+function addNewDeferredFragments(incrementalPublisher, newDeferUsages, incrementalDataRecord, deferMap, path) {
+  if (newDeferUsages.length === 0) {
+    return deferMap != null ? deferMap : /* @__PURE__ */ new Map();
+  }
+  const newDeferMap = deferMap === void 0 ? /* @__PURE__ */ new Map() : new Map(deferMap);
+  for (const newDeferUsage of newDeferUsages) {
+    const parentDeferUsage = newDeferUsage.parentDeferUsage;
+    const parent = parentDeferUsage === void 0 ? incrementalDataRecord : deferredFragmentRecordFromDeferUsage(parentDeferUsage, newDeferMap);
+    const deferredFragmentRecord = new DeferredFragmentRecord({
+      path,
+      label: newDeferUsage.label
+    });
+    incrementalPublisher.reportNewDeferFragmentRecord(
+      deferredFragmentRecord,
+      parent
+    );
+    newDeferMap.set(newDeferUsage, deferredFragmentRecord);
+  }
+  return newDeferMap;
+}
+function deferredFragmentRecordFromDeferUsage(deferUsage, deferMap) {
+  return deferMap.get(deferUsage);
+}
+function addNewDeferredGroupedFieldSets(incrementalPublisher, newGroupedFieldSetDetailsMap, deferMap, path) {
+  const newDeferredGroupedFieldSetRecords = [];
+  for (const [
+    deferUsageSet,
+    { groupedFieldSet, shouldInitiateDefer }
+  ] of newGroupedFieldSetDetailsMap) {
+    const deferredFragmentRecords = getDeferredFragmentRecords(
+      deferUsageSet,
+      deferMap
+    );
+    const deferredGroupedFieldSetRecord = new DeferredGroupedFieldSetRecord({
+      path,
+      deferredFragmentRecords,
+      groupedFieldSet,
+      shouldInitiateDefer
+    });
+    incrementalPublisher.reportNewDeferredGroupedFieldSetRecord(
+      deferredGroupedFieldSetRecord
+    );
+    newDeferredGroupedFieldSetRecords.push(deferredGroupedFieldSetRecord);
+  }
+  return newDeferredGroupedFieldSetRecords;
+}
+function getDeferredFragmentRecords(deferUsages, deferMap) {
+  return Array.from(deferUsages).map(
+    (deferUsage) => deferredFragmentRecordFromDeferUsage(deferUsage, deferMap)
+  );
+}
+function collectAndExecuteSubfields(exeContext, returnType, fieldGroup, path, result, incrementalDataRecord, deferMap) {
+  const { groupedFieldSet, newGroupedFieldSetDetailsMap, newDeferUsages } = buildSubFieldPlan(exeContext, { name: returnType }, fieldGroup);
+  const incrementalPublisher = exeContext.incrementalPublisher;
+  const newDeferMap = addNewDeferredFragments(
+    incrementalPublisher,
+    newDeferUsages,
+    incrementalDataRecord,
+    deferMap,
+    path
+  );
+  const newDeferredGroupedFieldSetRecords = addNewDeferredGroupedFieldSets(
+    incrementalPublisher,
+    newGroupedFieldSetDetailsMap,
+    newDeferMap,
+    path
+  );
   const subFields = executeFields(
     exeContext,
-    returnTypeName,
+    returnType,
     result,
     path,
-    subGroupedFieldSet,
-    incrementalDataRecord
+    groupedFieldSet,
+    incrementalDataRecord,
+    newDeferMap
+  );
+  executeDeferredGroupedFieldSets(
+    exeContext,
+    returnType,
+    result,
+    path,
+    newDeferredGroupedFieldSetRecords,
+    newDeferMap
   );
-  for (const subPatch of subPatches) {
-    const { label, groupedFieldSet: subPatchGroupedFieldSet } = subPatch;
-    executeDeferredFragment(
-      exeContext,
-      returnTypeName,
-      result,
-      subPatchGroupedFieldSet,
-      label,
-      path,
-      incrementalDataRecord
-    );
-  }
   return subFields;
 }
-function invokeBeforeFieldResolveHook(resolveInfo, exeContext) {
+function invokeBeforeFieldResolveHook(resolveInfo, exeContext, incrementalDataRecord) {
   var _a;
   const hook = (_a = exeContext.fieldExecutionHooks) == null ? void 0 : _a.beforeFieldResolve;
   if (!hook) {
@@ -1097,12 +1328,15 @@ function invokeBeforeFieldResolveHook(resolveInfo, exeContext) {
           resolveInfo.path,
           "Unexpected error in beforeFieldResolve hook"
         );
-        exeContext.errors.push(error);
+        exeContext.incrementalPublisher.addFieldError(
+          incrementalDataRecord,
+          error
+        );
       }
     }
   );
 }
-function invokeAfterFieldResolveHook(resolveInfo, exeContext, result, error) {
+function invokeAfterFieldResolveHook(resolveInfo, exeContext, incrementalDataRecord, result, error) {
   var _a;
   const hook = (_a = exeContext.fieldExecutionHooks) == null ? void 0 : _a.afterFieldResolve;
   if (!hook) {
@@ -1122,12 +1356,15 @@ function invokeAfterFieldResolveHook(resolveInfo, exeContext, result, error) {
           resolveInfo.path,
           "Unexpected error in afterFieldResolve hook"
         );
-        exeContext.errors.push(error2);
+        exeContext.incrementalPublisher.addFieldError(
+          incrementalDataRecord,
+          error2
+        );
       }
     }
   );
 }
-function invokeAfterFieldCompleteHook(resolveInfo, exeContext, result, error) {
+function invokeAfterFieldCompleteHook(resolveInfo, exeContext, incrementalDataRecord, result, error) {
   var _a;
   const hook = (_a = exeContext.fieldExecutionHooks) == null ? void 0 : _a.afterFieldComplete;
   if (!hook) {
@@ -1147,7 +1384,10 @@ function invokeAfterFieldCompleteHook(resolveInfo, exeContext, result, error) {
           resolveInfo.path,
           "Unexpected error in afterFieldComplete hook"
         );
-        exeContext.errors.push(error2);
+        exeContext.incrementalPublisher.addFieldError(
+          incrementalDataRecord,
+          error2
+        );
       }
     }
   );
@@ -1201,153 +1441,215 @@ function getOperationRootTypeName(operation) {
       );
   }
 }
-function executeDeferredFragment(exeContext, parentTypeName, sourceValue, fields, label, path, parentContext) {
-  const incrementalDataRecord = new DeferredFragmentRecord({
-    label,
-    path,
-    parentContext,
-    exeContext
-  });
-  let promiseOrData;
+function isIncrementalExecutionResult(result) {
+  return "initialResult" in result;
+}
+function isTotalExecutionResult(result) {
+  return !("initialResult" in result);
+}
+function executeDeferredGroupedFieldSets(exeContext, parentTypeName, sourceValue, path, newDeferredGroupedFieldSetRecords, deferMap) {
+  for (const deferredGroupedFieldSetRecord of newDeferredGroupedFieldSetRecords) {
+    if (deferredGroupedFieldSetRecord.shouldInitiateDefer) {
+      Promise.resolve().then(
+        () => executeDeferredGroupedFieldSet(
+          exeContext,
+          parentTypeName,
+          sourceValue,
+          path,
+          deferredGroupedFieldSetRecord,
+          deferMap
+        )
+      );
+      continue;
+    }
+    executeDeferredGroupedFieldSet(
+      exeContext,
+      parentTypeName,
+      sourceValue,
+      path,
+      deferredGroupedFieldSetRecord,
+      deferMap
+    );
+  }
+}
+function executeDeferredGroupedFieldSet(exeContext, parentTypeName, sourceValue, path, deferredGroupedFieldSetRecord, deferMap) {
   try {
-    promiseOrData = executeFields(
+    const incrementalResult = executeFields(
       exeContext,
       parentTypeName,
       sourceValue,
       path,
-      fields,
-      incrementalDataRecord
+      deferredGroupedFieldSetRecord.groupedFieldSet,
+      deferredGroupedFieldSetRecord,
+      deferMap
     );
-    if (isPromise(promiseOrData)) {
-      promiseOrData = promiseOrData.then(null, (e) => {
-        incrementalDataRecord.errors.push(e);
-        return null;
-      });
+    if (isPromise(incrementalResult)) {
+      incrementalResult.then(
+        (resolved) => exeContext.incrementalPublisher.completeDeferredGroupedFieldSet(
+          deferredGroupedFieldSetRecord,
+          resolved
+        ),
+        (error) => exeContext.incrementalPublisher.markErroredDeferredGroupedFieldSet(
+          deferredGroupedFieldSetRecord,
+          error
+        )
+      );
+      return;
     }
-  } catch (e) {
-    incrementalDataRecord.errors.push(e);
-    promiseOrData = null;
+    exeContext.incrementalPublisher.completeDeferredGroupedFieldSet(
+      deferredGroupedFieldSetRecord,
+      incrementalResult
+    );
+  } catch (error) {
+    exeContext.incrementalPublisher.markErroredDeferredGroupedFieldSet(
+      deferredGroupedFieldSetRecord,
+      error
+    );
   }
-  incrementalDataRecord.addData(promiseOrData);
 }
-function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info, itemTypeRef, label, parentContext) {
-  const incrementalDataRecord = new StreamItemsRecord({
-    label,
-    path: itemPath,
-    parentContext,
-    exeContext
+function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info, returnTypeRef, incrementalDataRecord, streamRecord) {
+  const incrementalPublisher = exeContext.incrementalPublisher;
+  const streamItemsRecord = new StreamItemsRecord({
+    streamRecord,
+    path: itemPath
   });
+  incrementalPublisher.reportNewStreamItemsRecord(
+    streamItemsRecord,
+    incrementalDataRecord
+  );
   if (isPromise(item)) {
-    const completedItems = completePromisedValue(
+    completePromisedValue(
       exeContext,
-      itemTypeRef,
+      returnTypeRef,
       fieldGroup,
       info,
       itemPath,
       item,
-      incrementalDataRecord
+      streamItemsRecord,
+      /* @__PURE__ */ new Map()
     ).then(
-      (value) => [value],
+      (value) => incrementalPublisher.completeStreamItemsRecord(streamItemsRecord, [
+        value
+      ]),
       (error) => {
-        incrementalDataRecord.errors.push(error);
-        filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
-        return null;
+        incrementalPublisher.filter(path, streamItemsRecord);
+        incrementalPublisher.markErroredStreamItemsRecord(
+          streamItemsRecord,
+          error
+        );
       }
     );
-    incrementalDataRecord.addItems(completedItems);
-    return incrementalDataRecord;
+    return streamItemsRecord;
   }
   let completedItem;
   try {
     try {
       completedItem = completeValue(
         exeContext,
-        itemTypeRef,
+        returnTypeRef,
         fieldGroup,
         info,
         itemPath,
         item,
-        incrementalDataRecord
+        streamItemsRecord,
+        /* @__PURE__ */ new Map()
       );
     } catch (rawError) {
       handleFieldError(
         rawError,
         exeContext,
-        itemTypeRef,
+        returnTypeRef,
         fieldGroup,
         itemPath,
-        incrementalDataRecord
+        streamItemsRecord
       );
       completedItem = null;
-      filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
+      incrementalPublisher.filter(itemPath, streamItemsRecord);
     }
   } catch (error) {
-    incrementalDataRecord.errors.push(error);
-    filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
-    incrementalDataRecord.addItems(null);
-    return incrementalDataRecord;
+    incrementalPublisher.filter(path, streamItemsRecord);
+    incrementalPublisher.markErroredStreamItemsRecord(
+      streamItemsRecord,
+      error
+    );
+    return streamItemsRecord;
   }
   if (isPromise(completedItem)) {
-    const completedItems = completedItem.then(void 0, (rawError) => {
+    completedItem.then(void 0, (rawError) => {
       handleFieldError(
         rawError,
         exeContext,
-        itemTypeRef,
+        returnTypeRef,
         fieldGroup,
         itemPath,
-        incrementalDataRecord
+        streamItemsRecord
       );
-      filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
+      incrementalPublisher.filter(itemPath, streamItemsRecord);
       return null;
     }).then(
-      (value) => [value],
+      (value) => incrementalPublisher.completeStreamItemsRecord(streamItemsRecord, [
+        value
+      ]),
       (error) => {
-        incrementalDataRecord.errors.push(error);
-        filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
-        return null;
+        incrementalPublisher.filter(path, streamItemsRecord);
+        incrementalPublisher.markErroredStreamItemsRecord(
+          streamItemsRecord,
+          error
+        );
       }
     );
-    incrementalDataRecord.addItems(completedItems);
-    return incrementalDataRecord;
+    return streamItemsRecord;
   }
-  incrementalDataRecord.addItems([completedItem]);
-  return incrementalDataRecord;
+  incrementalPublisher.completeStreamItemsRecord(streamItemsRecord, [
+    completedItem
+  ]);
+  return streamItemsRecord;
 }
-function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, info, itemTypeRef, incrementalDataRecord, path, itemPath) {
+function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, info, itemTypeName, streamItemsRecord, itemPath) {
   return __async(this, null, function* () {
     let item;
     try {
-      const { value, done } = yield asyncIterator.next();
-      if (done) {
-        incrementalDataRecord.setIsCompletedAsyncIterator();
-        return { done, value: void 0 };
+      const iteration = yield asyncIterator.next();
+      if (streamItemsRecord.streamRecord.errors.length > 0) {
+        return { done: true, value: void 0 };
       }
-      item = value;
+      if (iteration.done) {
+        exeContext.incrementalPublisher.setIsCompletedAsyncIterator(
+          streamItemsRecord
+        );
+        return { done: true, value: void 0 };
+      }
+      item = iteration.value;
     } catch (rawError) {
-      throw locatedError(rawError, fieldGroup, pathToArray(path));
+      throw locatedError(
+        rawError,
+        toNodes(fieldGroup),
+        streamItemsRecord.streamRecord.path
+      );
     }
     let completedItem;
     try {
       completedItem = completeValue(
         exeContext,
-        itemTypeRef,
+        itemTypeName,
         fieldGroup,
         info,
         itemPath,
         item,
-        incrementalDataRecord
+        streamItemsRecord,
+        /* @__PURE__ */ new Map()
       );
       if (isPromise(completedItem)) {
         completedItem = completedItem.then(void 0, (rawError) => {
           handleFieldError(
             rawError,
             exeContext,
-            itemTypeRef,
+            itemTypeName,
             fieldGroup,
             itemPath,
-            incrementalDataRecord
+            streamItemsRecord
           );
-          filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
+          exeContext.incrementalPublisher.filter(itemPath, streamItemsRecord);
           return null;
         });
       }
@@ -1356,29 +1658,31 @@ function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, i
       handleFieldError(
         rawError,
         exeContext,
-        itemTypeRef,
+        itemTypeName,
         fieldGroup,
         itemPath,
-        incrementalDataRecord
+        streamItemsRecord
       );
-      filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
+      exeContext.incrementalPublisher.filter(itemPath, streamItemsRecord);
       return { done: false, value: null };
     }
   });
 }
-function executeStreamAsyncIterator(initialIndex, asyncIterator, exeContext, fieldGroup, info, itemTypeRef, path, label, parentContext) {
+function executeStreamAsyncIterator(initialIndex, asyncIterator, exeContext, fieldGroup, info, itemTypeName, path, incrementalDataRecord, streamRecord) {
   return __async(this, null, function* () {
+    const incrementalPublisher = exeContext.incrementalPublisher;
     let index = initialIndex;
-    let previousIncrementalDataRecord = parentContext != null ? parentContext : void 0;
+    let currentIncrementalDataRecord = incrementalDataRecord;
     while (true) {
       const itemPath = addPath(path, index, void 0);
-      const incrementalDataRecord = new StreamItemsRecord({
-        label,
-        path: itemPath,
-        parentContext: previousIncrementalDataRecord,
-        asyncIterator,
-        exeContext
+      const streamItemsRecord = new StreamItemsRecord({
+        streamRecord,
+        path: itemPath
       });
+      incrementalPublisher.reportNewStreamItemsRecord(
+        streamItemsRecord,
+        currentIncrementalDataRecord
+      );
       let iteration;
       try {
         iteration = yield executeStreamAsyncIteratorItem(
@@ -1386,223 +1690,47 @@ function executeStreamAsyncIterator(initialIndex, asyncIterator, exeContext, fie
           exeContext,
           fieldGroup,
           info,
-          itemTypeRef,
-          incrementalDataRecord,
-          path,
+          itemTypeName,
+          streamItemsRecord,
           itemPath
         );
       } catch (error) {
-        incrementalDataRecord.errors.push(error);
-        filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
-        incrementalDataRecord.addItems(null);
-        if (asyncIterator == null ? void 0 : asyncIterator.return) {
-          asyncIterator.return().catch(() => {
-          });
-        }
+        incrementalPublisher.filter(path, streamItemsRecord);
+        incrementalPublisher.markErroredStreamItemsRecord(
+          streamItemsRecord,
+          error
+        );
         return;
       }
       const { done, value: completedItem } = iteration;
-      let completedItems;
       if (isPromise(completedItem)) {
-        completedItems = completedItem.then(
-          (value) => [value],
+        completedItem.then(
+          (value) => incrementalPublisher.completeStreamItemsRecord(streamItemsRecord, [
+            value
+          ]),
           (error) => {
-            incrementalDataRecord.errors.push(error);
-            filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
-            return null;
+            incrementalPublisher.filter(path, streamItemsRecord);
+            incrementalPublisher.markErroredStreamItemsRecord(
+              streamItemsRecord,
+              error
+            );
           }
         );
       } else {
-        completedItems = [completedItem];
+        incrementalPublisher.completeStreamItemsRecord(streamItemsRecord, [
+          completedItem
+        ]);
       }
-      incrementalDataRecord.addItems(completedItems);
       if (done) {
         break;
       }
-      previousIncrementalDataRecord = incrementalDataRecord;
+      currentIncrementalDataRecord = streamItemsRecord;
       index++;
     }
   });
 }
-function filterSubsequentPayloads(exeContext, nullPath, currentIncrementalDataRecord) {
-  const nullPathArray = pathToArray(nullPath);
-  exeContext.subsequentPayloads.forEach((incrementalDataRecord) => {
-    var _a;
-    if (incrementalDataRecord === currentIncrementalDataRecord) {
-      return;
-    }
-    for (let i = 0; i < nullPathArray.length; i++) {
-      if (incrementalDataRecord.path[i] !== nullPathArray[i]) {
-        return;
-      }
-    }
-    if (isStreamItemsRecord(incrementalDataRecord) && ((_a = incrementalDataRecord.asyncIterator) == null ? void 0 : _a.return)) {
-      incrementalDataRecord.asyncIterator.return().catch(() => {
-      });
-    }
-    exeContext.subsequentPayloads.delete(incrementalDataRecord);
-  });
-}
-function getCompletedIncrementalResults(exeContext) {
-  const incrementalResults = [];
-  for (const incrementalDataRecord of exeContext.subsequentPayloads) {
-    const incrementalResult = {};
-    if (!incrementalDataRecord.isCompleted) {
-      continue;
-    }
-    exeContext.subsequentPayloads.delete(incrementalDataRecord);
-    if (isStreamItemsRecord(incrementalDataRecord)) {
-      const items = incrementalDataRecord.items;
-      if (incrementalDataRecord.isCompletedAsyncIterator) {
-        continue;
-      }
-      incrementalResult.items = items;
-    } else {
-      const data = incrementalDataRecord.data;
-      incrementalResult.data = data != null ? data : null;
-    }
-    incrementalResult.path = incrementalDataRecord.path;
-    if (incrementalDataRecord.label != null) {
-      incrementalResult.label = incrementalDataRecord.label;
-    }
-    if (incrementalDataRecord.errors.length > 0) {
-      incrementalResult.errors = incrementalDataRecord.errors;
-    }
-    incrementalResults.push(incrementalResult);
-  }
-  return incrementalResults;
-}
-function yieldSubsequentPayloads(exeContext) {
-  let isDone = false;
-  function next() {
-    return __async(this, null, function* () {
-      if (isDone) {
-        return { value: void 0, done: true };
-      }
-      yield Promise.race(
-        Array.from(exeContext.subsequentPayloads).map((p) => p.promise)
-      );
-      if (isDone) {
-        return { value: void 0, done: true };
-      }
-      const incremental = getCompletedIncrementalResults(exeContext);
-      const hasNext = exeContext.subsequentPayloads.size > 0;
-      if (!incremental.length && hasNext) {
-        return next();
-      }
-      if (!hasNext) {
-        isDone = true;
-      }
-      return {
-        value: incremental.length ? { incremental, hasNext } : { hasNext },
-        done: false
-      };
-    });
-  }
-  function returnStreamIterators() {
-    const promises = [];
-    exeContext.subsequentPayloads.forEach((incrementalDataRecord) => {
-      var _a2;
-      if (isStreamItemsRecord(incrementalDataRecord) && ((_a2 = incrementalDataRecord.asyncIterator) == null ? void 0 : _a2.return)) {
-        promises.push(incrementalDataRecord.asyncIterator.return());
-      }
-    });
-    return Promise.all(promises);
-  }
-  return {
-    [Symbol.asyncIterator]() {
-      return this;
-    },
-    next,
-    return() {
-      return __async(this, null, function* () {
-        yield returnStreamIterators();
-        isDone = true;
-        return { value: void 0, done: true };
-      });
-    },
-    throw(error) {
-      return __async(this, null, function* () {
-        yield returnStreamIterators();
-        isDone = true;
-        return Promise.reject(error);
-      });
-    }
-  };
-}
-function isStreamItemsRecord(incrementalDataRecord) {
-  return incrementalDataRecord.type === "stream";
-}
-var DeferredFragmentRecord = class {
-  constructor(opts) {
-    this.type = "defer";
-    this.label = opts.label;
-    this.path = pathToArray(opts.path);
-    this.parentContext = opts.parentContext;
-    this.errors = [];
-    this._exeContext = opts.exeContext;
-    this._exeContext.subsequentPayloads.add(this);
-    this.isCompleted = false;
-    this.data = null;
-    this.promise = new Promise((resolve) => {
-      this._resolve = (promiseOrValue) => {
-        resolve(promiseOrValue);
-      };
-    }).then((data) => {
-      this.data = data;
-      this.isCompleted = true;
-    });
-  }
-  addData(data) {
-    var _a, _b, _c;
-    const parentData = (_a = this.parentContext) == null ? void 0 : _a.promise;
-    if (parentData) {
-      (_b = this._resolve) == null ? void 0 : _b.call(this, parentData.then(() => data));
-      return;
-    }
-    (_c = this._resolve) == null ? void 0 : _c.call(this, data);
-  }
-};
-var StreamItemsRecord = class {
-  constructor(opts) {
-    this.type = "stream";
-    this.items = null;
-    this.label = opts.label;
-    this.path = pathToArray(opts.path);
-    this.parentContext = opts.parentContext;
-    this.asyncIterator = opts.asyncIterator;
-    this.errors = [];
-    this._exeContext = opts.exeContext;
-    this._exeContext.subsequentPayloads.add(this);
-    this.isCompleted = false;
-    this.items = null;
-    this.promise = new Promise((resolve) => {
-      this._resolve = (promiseOrValue) => {
-        resolve(promiseOrValue);
-      };
-    }).then((items) => {
-      this.items = items;
-      this.isCompleted = true;
-    });
-  }
-  addItems(items) {
-    var _a, _b, _c;
-    const parentData = (_a = this.parentContext) == null ? void 0 : _a.promise;
-    if (parentData) {
-      (_b = this._resolve) == null ? void 0 : _b.call(this, parentData.then(() => items));
-      return;
-    }
-    (_c = this._resolve) == null ? void 0 : _c.call(this, items);
-  }
-  setIsCompletedAsyncIterator() {
-    this.isCompletedAsyncIterator = true;
-  }
-};
-function isIncrementalExecutionResult(result) {
-  return "initialResult" in result;
-}
-function isTotalExecutionResult(result) {
-  return !("initialResult" in result);
+function toNodes(fieldGroup) {
+  return fieldGroup.fields.map((fieldDetails) => fieldDetails.node);
 }
 export {
   assertValidExecutionArguments,