@graphitation/supermassive 3.3.0 → 3.4.1

package/lib/executeWithoutSchema.mjs

@@ -40,13 +40,12 @@ var __async = (__this, __arguments, generator) => {
 
 // src/executeWithoutSchema.ts
 import {
-  GraphQLError,
   Kind,
   locatedError
 } from "graphql";
 import {
   collectFields,
-  collectSubfields
+  collectSubfields as _collectSubfields
 } from "./collectFields.mjs";
 import { devAssert } from "./jsutils/devAssert.mjs";
 import { inspect } from "./jsutils/inspect.mjs";
@@ -76,40 +75,15 @@ import {
 } from "./schema/reference.mjs";
 import * as Definitions from "./schema/definition.mjs";
 import * as Resolvers from "./schema/resolvers.mjs";
-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
-    );
-  }
+var collectSubfields = memoize3(
+  (exeContext, returnTypeName, fieldGroup) => _collectSubfields(exeContext, returnTypeName.name, fieldGroup)
 );
 function executeWithoutSchema(args) {
   const exeContext = buildExecutionContext(args);
   if (!("schemaFragment" in exeContext)) {
     return { errors: exeContext };
   } else {
-    return executeImpl(exeContext);
+    return executeOperation(exeContext);
   }
 }
 function assertValidExecutionArguments(document, rawVariableValues) {
@@ -188,126 +162,113 @@ function buildExecutionContext(args) {
     fieldResolver: fieldResolver != null ? fieldResolver : defaultFieldResolver,
     typeResolver: typeResolver != null ? typeResolver : defaultTypeResolver,
     subscribeFieldResolver: subscribeFieldResolver != null ? subscribeFieldResolver : defaultFieldResolver,
+    errors: [],
     fieldExecutionHooks,
-    incrementalPublisher: new IncrementalPublisher()
+    subsequentPayloads: /* @__PURE__ */ new Set()
   };
 }
 function buildPerEventExecutionContext(exeContext, payload) {
   return __spreadProps(__spreadValues({}, exeContext), {
     contextValue: exeContext.buildContextValue ? exeContext.buildContextValue(exeContext.contextValue) : exeContext.contextValue,
-    rootValue: payload
+    rootValue: payload,
+    subsequentPayloads: /* @__PURE__ */ new Set(),
+    errors: []
   });
 }
-function executeImpl(exeContext) {
-  const incrementalPublisher = exeContext.incrementalPublisher;
-  const initialResultRecord = new InitialResultRecord();
+function executeOperation(exeContext) {
   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);
-  if (rootTypeName == null) {
-    throw new GraphQLError(
-      `Schema is not configured to execute ${operation.operation} operation.`,
-      operation
+    const { operation, rootValue } = exeContext;
+    const rootTypeName = getOperationRootTypeName(operation);
+    const { groupedFieldSet, patches } = collectFields(
+      exeContext,
+      rootTypeName
     );
-  }
-  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":
-      result = executeFields(
-        exeContext,
-        rootTypeName,
-        rootValue,
-        path,
-        groupedFieldSet,
-        initialResultRecord,
-        newDeferMap
-      );
-      break;
-    case "mutation":
-      result = executeFieldsSerially(
+    const path = void 0;
+    let result;
+    switch (operation.operation) {
+      case "query":
+        result = executeFields(
+          exeContext,
+          rootTypeName,
+          rootValue,
+          path,
+          groupedFieldSet,
+          void 0
+        );
+        result = buildResponse(exeContext, result);
+        break;
+      case "mutation":
+        result = executeFieldsSerially(
+          exeContext,
+          rootTypeName,
+          rootValue,
+          path,
+          groupedFieldSet
+        );
+        result = buildResponse(exeContext, result);
+        break;
+      case "subscription": {
+        const resultOrStreamOrPromise = createSourceEventStream(exeContext);
+        result = mapResultOrEventStreamOrPromise(
+          resultOrStreamOrPromise,
+          exeContext,
+          rootTypeName,
+          path,
+          groupedFieldSet
+        );
+        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(
         exeContext,
         rootTypeName,
         rootValue,
-        path,
-        groupedFieldSet,
-        initialResultRecord,
-        newDeferMap
+        patchGroupedFieldSet,
+        label,
+        path
       );
-      break;
-    case "subscription": {
-      const resultOrStreamOrPromise = createSourceEventStream(exeContext);
-      result = mapResultOrEventStreamOrPromise(
-        resultOrStreamOrPromise,
-        exeContext,
-        rootTypeName,
-        path,
-        groupedFieldSet,
-        initialResultRecord,
-        newDeferMap
-      );
-      break;
     }
+    return result;
+  } catch (error) {
+    exeContext.errors.push(error);
+    return buildResponse(exeContext, null);
   }
-  if (operation.operation !== "subscription") {
-    executeDeferredGroupedFieldSets(
-      exeContext,
-      rootTypeName,
-      rootValue,
-      path,
-      newDeferredGroupedFieldSetRecords,
-      newDeferMap
+}
+function buildResponse(exeContext, data) {
+  if (isPromise(data)) {
+    return data.then(
+      (resolved) => buildResponse(exeContext, resolved),
+      (error) => {
+        exeContext.errors.push(error);
+        return buildResponse(exeContext, null);
+      }
     );
   }
-  return result;
+  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, incrementalDataRecord, deferMap) {
+function executeFieldsSerially(exeContext, parentTypeName, sourceValue, path, groupedFieldSet) {
   return promiseReduce(
     groupedFieldSet,
     (results, [responseName, fieldGroup]) => {
@@ -318,8 +279,7 @@ function executeFieldsSerially(exeContext, parentTypeName, sourceValue, path, gr
         sourceValue,
         fieldGroup,
         fieldPath,
-        incrementalDataRecord,
-        deferMap
+        void 0
       );
       if (result === void 0) {
         return results;
@@ -336,7 +296,7 @@ function executeFieldsSerially(exeContext, parentTypeName, sourceValue, path, gr
     /* @__PURE__ */ Object.create(null)
   );
 }
-function executeFields(exeContext, parentTypeName, sourceValue, path, groupedFieldSet, incrementalDataRecord, deferMap) {
+function executeFields(exeContext, parentTypeName, sourceValue, path, groupedFieldSet, incrementalDataRecord) {
   const results = /* @__PURE__ */ Object.create(null);
   let containsPromise = false;
   for (const [responseName, fieldGroup] of groupedFieldSet) {
@@ -347,8 +307,7 @@ function executeFields(exeContext, parentTypeName, sourceValue, path, groupedFie
       sourceValue,
       fieldGroup,
       fieldPath,
-      incrementalDataRecord,
-      deferMap
+      incrementalDataRecord
     );
     if (result !== void 0) {
       results[responseName] = result;
@@ -362,9 +321,9 @@ function executeFields(exeContext, parentTypeName, sourceValue, path, groupedFie
   }
   return promiseForObject(results);
 }
-function executeField(exeContext, parentTypeName, source, fieldGroup, path, incrementalDataRecord, deferMap) {
+function executeField(exeContext, parentTypeName, source, fieldGroup, path, incrementalDataRecord) {
   const schemaFragment = exeContext.schemaFragment;
-  const fieldName = fieldGroup.fields[0].node.name.value;
+  const fieldName = fieldGroup[0].name.value;
   const fieldDef = Definitions.getField(
     schemaFragment.definitions,
     parentTypeName,
@@ -378,8 +337,7 @@ function executeField(exeContext, parentTypeName, source, fieldGroup, path, incr
       fieldGroup,
       path,
       source,
-      incrementalDataRecord,
-      deferMap
+      incrementalDataRecord
     );
   }
   const loading = requestSchemaFragment(exeContext, {
@@ -404,8 +362,7 @@ function executeField(exeContext, parentTypeName, source, fieldGroup, path, incr
         fieldGroup,
         path,
         source,
-        incrementalDataRecord,
-        deferMap
+        incrementalDataRecord
       );
     }
     return void 0;
@@ -431,16 +388,24 @@ function requestSchemaFragment(exeContext, request) {
   });
 }
 function createSourceEventStream(exeContext) {
-  return executeSubscriptionImpl(exeContext);
+  try {
+    const eventStream = executeSubscriptionImpl(exeContext);
+    if (isPromise(eventStream)) {
+      return eventStream.then(void 0, (error) => ({ errors: [error] }));
+    }
+    return eventStream;
+  } catch (error) {
+    return { errors: [error] };
+  }
 }
 function executeSubscriptionImpl(exeContext) {
   var _a;
-  const { schemaFragment, operation, rootValue } = exeContext;
+  const { operation, rootValue, schemaFragment } = exeContext;
   const rootTypeName = getOperationRootTypeName(operation);
-  const fields = collectFields(exeContext, rootTypeName);
-  const { groupedFieldSet } = buildFieldPlan(fields);
-  const [responseName, fieldGroup] = groupedFieldSet.entries().next().value;
-  const fieldName = toNodes(fieldGroup)[0].name.value;
+  const { groupedFieldSet } = collectFields(exeContext, rootTypeName);
+  const firstRootField = groupedFieldSet.entries().next().value;
+  const [responseName, fieldGroup] = firstRootField;
+  const fieldName = fieldGroup[0].name.value;
   const fieldDef = Definitions.getField(
     schemaFragment.definitions,
     rootTypeName,
@@ -449,7 +414,7 @@ function executeSubscriptionImpl(exeContext) {
   if (!fieldDef) {
     throw locatedError(
       `The subscription field "${fieldName}" is not defined.`,
-      toNodes(fieldGroup)
+      fieldGroup
     );
   }
   const returnTypeRef = Definitions.getFieldTypeReference(fieldDef);
@@ -468,22 +433,17 @@ function executeSubscriptionImpl(exeContext) {
     path
   );
   try {
-    const args = getArgumentValues(
-      exeContext.schemaFragment,
-      fieldDef,
-      toNodes(fieldGroup)[0],
-      exeContext.variableValues
-    );
+    const args = getArgumentValues(exeContext, fieldDef, fieldGroup[0]);
     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, toNodes(fieldGroup), pathToArray(path));
+        throw locatedError(error, fieldGroup, pathToArray(path));
       });
     }
     return assertEventStream(result);
   } catch (error) {
-    throw locatedError(error, toNodes(fieldGroup), pathToArray(path));
+    throw locatedError(error, fieldGroup, pathToArray(path));
   }
 }
 function assertEventStream(result) {
@@ -498,7 +458,7 @@ function assertEventStream(result) {
   }
   return result;
 }
-function mapResultOrEventStreamOrPromise(resultOrStreamOrPromise, exeContext, parentTypeName, path, groupedFieldSet, initialResultRecord, deferMap) {
+function mapResultOrEventStreamOrPromise(resultOrStreamOrPromise, exeContext, parentTypeName, path, groupedFieldSet) {
   if (isPromise(resultOrStreamOrPromise)) {
     return resultOrStreamOrPromise.then(
       (resultOrStream) => mapResultOrEventStreamOrPromise(
@@ -506,9 +466,7 @@ function mapResultOrEventStreamOrPromise(resultOrStreamOrPromise, exeContext, pa
         exeContext,
         parentTypeName,
         path,
-        groupedFieldSet,
-        initialResultRecord,
-        deferMap
+        groupedFieldSet
       )
     );
   } else {
@@ -520,41 +478,19 @@ function mapResultOrEventStreamOrPromise(resultOrStreamOrPromise, exeContext, pa
           exeContext,
           payload
         );
-        const perEventResultRecord = new InitialResultRecord();
         try {
           const data = executeFields(
-            perEventContext,
+            exeContext,
             parentTypeName,
             payload,
             path,
             groupedFieldSet,
-            perEventResultRecord,
-            deferMap
+            void 0
           );
-          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
-            );
-          }
+          return buildResponse(perEventContext, data);
         } catch (error) {
-          return exeContext.incrementalPublisher.buildErrorResponse(
-            perEventResultRecord,
-            error
-          );
+          perEventContext.errors.push(error);
+          return buildResponse(perEventContext, null);
         }
       };
       return mapAsyncIterator(resultOrStreamOrPromise, mapSourceToResponse);
@@ -564,7 +500,7 @@ function mapResultOrEventStreamOrPromise(resultOrStreamOrPromise, exeContext, pa
 function buildResolveInfo(exeContext, fieldName, fieldGroup, parentTypeName, returnTypeName, path) {
   return {
     fieldName,
-    fieldNodes: toNodes(fieldGroup),
+    fieldNodes: fieldGroup,
     returnTypeName,
     parentTypeName,
     path,
@@ -575,15 +511,17 @@ function buildResolveInfo(exeContext, fieldName, fieldGroup, parentTypeName, ret
   };
 }
 function handleFieldError(rawError, exeContext, returnTypeRef, fieldGroup, path, incrementalDataRecord) {
-  const error = locatedError(rawError, toNodes(fieldGroup), pathToArray(path));
+  var _a;
+  const error = locatedError(rawError, fieldGroup, pathToArray(path));
   if (isNonNullType(returnTypeRef)) {
     throw error;
   }
-  exeContext.incrementalPublisher.addFieldError(incrementalDataRecord, error);
+  const errors = (_a = incrementalDataRecord == null ? void 0 : incrementalDataRecord.errors) != null ? _a : exeContext.errors;
+  errors.push(error);
 }
-function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fieldGroup, path, source, incrementalDataRecord, deferMap) {
+function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fieldGroup, path, source, incrementalDataRecord) {
   var _a;
-  const fieldName = fieldGroup.fields[0].node.name.value;
+  const fieldName = fieldGroup[0].name.value;
   const returnTypeRef = Definitions.getFieldTypeReference(fieldDefinition);
   const resolveFn = (_a = Resolvers.getFieldResolver(
     exeContext.schemaFragment,
@@ -601,15 +539,10 @@ function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fi
   const isDefaultResolverUsed = resolveFn === exeContext.fieldResolver;
   const hooks = exeContext.fieldExecutionHooks;
   try {
-    const args = getArgumentValues(
-      exeContext.schemaFragment,
-      fieldDefinition,
-      fieldGroup.fields[0].node,
-      exeContext.variableValues
-    );
+    const args = getArgumentValues(exeContext, fieldDefinition, fieldGroup[0]);
     const contextValue = exeContext.contextValue;
     if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.beforeFieldResolve)) {
-      invokeBeforeFieldResolveHook(info, exeContext, incrementalDataRecord);
+      invokeBeforeFieldResolveHook(info, exeContext);
     }
     const result = resolveFn(source, args, contextValue, info);
     let completed;
@@ -617,12 +550,7 @@ function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fi
       completed = result.then(
         (resolved) => {
           if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve)) {
-            invokeAfterFieldResolveHook(
-              info,
-              exeContext,
-              incrementalDataRecord,
-              resolved
-            );
+            invokeAfterFieldResolveHook(info, exeContext, resolved);
           }
           return completeValue(
             exeContext,
@@ -631,31 +559,19 @@ function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fi
             info,
             path,
             resolved,
-            incrementalDataRecord,
-            deferMap
+            incrementalDataRecord
           );
         },
         (rawError) => {
           if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve)) {
-            invokeAfterFieldResolveHook(
-              info,
-              exeContext,
-              incrementalDataRecord,
-              void 0,
-              rawError
-            );
+            invokeAfterFieldResolveHook(info, exeContext, void 0, rawError);
           }
           throw rawError;
         }
       );
     } else {
       if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve)) {
-        invokeAfterFieldResolveHook(
-          info,
-          exeContext,
-          incrementalDataRecord,
-          result
-        );
+        invokeAfterFieldResolveHook(info, exeContext, result);
       }
       completed = completeValue(
         exeContext,
@@ -664,37 +580,21 @@ function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fi
         info,
         path,
         result,
-        incrementalDataRecord,
-        deferMap
+        incrementalDataRecord
       );
     }
     if (isPromise(completed)) {
       return completed.then(
         (resolved) => {
           if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldComplete)) {
-            invokeAfterFieldCompleteHook(
-              info,
-              exeContext,
-              incrementalDataRecord,
-              resolved
-            );
+            invokeAfterFieldCompleteHook(info, exeContext, resolved);
           }
           return resolved;
         },
         (rawError) => {
-          const error = locatedError(
-            rawError,
-            toNodes(fieldGroup),
-            pathToArray(path)
-          );
+          const error = locatedError(rawError, fieldGroup, pathToArray(path));
           if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldComplete)) {
-            invokeAfterFieldCompleteHook(
-              info,
-              exeContext,
-              incrementalDataRecord,
-              void 0,
-              error
-            );
+            invokeAfterFieldCompleteHook(info, exeContext, void 0, error);
           }
           handleFieldError(
             rawError,
@@ -709,34 +609,17 @@ function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fi
       );
     }
     if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldComplete)) {
-      invokeAfterFieldCompleteHook(
-        info,
-        exeContext,
-        incrementalDataRecord,
-        completed
-      );
+      invokeAfterFieldCompleteHook(info, exeContext, completed);
     }
     return completed;
   } catch (rawError) {
     const pathArray = pathToArray(path);
-    const error = locatedError(rawError, fieldGroup.fields[0].node, pathArray);
+    const error = locatedError(rawError, fieldGroup, pathArray);
     if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve) && error.path && arraysAreEqual(pathArray, error.path)) {
-      invokeAfterFieldResolveHook(
-        info,
-        exeContext,
-        incrementalDataRecord,
-        void 0,
-        error
-      );
+      invokeAfterFieldResolveHook(info, exeContext, void 0, error);
     }
     if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldComplete)) {
-      invokeAfterFieldCompleteHook(
-        info,
-        exeContext,
-        incrementalDataRecord,
-        void 0,
-        error
-      );
+      invokeAfterFieldCompleteHook(info, exeContext, void 0, error);
     }
     handleFieldError(
       rawError,
@@ -749,7 +632,7 @@ function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fi
     return null;
   }
 }
-function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord, deferMap) {
+function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord) {
   if (result instanceof Error) {
     throw result;
   }
@@ -761,8 +644,7 @@ function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result
       info,
       path,
       result,
-      incrementalDataRecord,
-      deferMap
+      incrementalDataRecord
     );
     if (completed === null) {
       throw new Error(
@@ -782,8 +664,7 @@ function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result
       info,
       path,
       result,
-      incrementalDataRecord,
-      deferMap
+      incrementalDataRecord
     );
   }
   const { schemaFragment } = exeContext;
@@ -800,8 +681,7 @@ function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result
       info,
       path,
       result,
-      incrementalDataRecord,
-      deferMap
+      incrementalDataRecord
     );
   }
   if (Definitions.isObjectType(schemaFragment.definitions, returnTypeRef)) {
@@ -811,8 +691,7 @@ function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result
       fieldGroup,
       path,
       result,
-      incrementalDataRecord,
-      deferMap
+      incrementalDataRecord
     );
   }
   invariant(
@@ -820,7 +699,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, deferMap) {
+function completePromisedValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord) {
   return __async(this, null, function* () {
     try {
       const resolved = yield result;
@@ -831,8 +710,7 @@ function completePromisedValue(exeContext, returnTypeRef, fieldGroup, info, path
         info,
         path,
         resolved,
-        incrementalDataRecord,
-        deferMap
+        incrementalDataRecord
       );
       if (isPromise(completed)) {
         completed = yield completed;
@@ -847,12 +725,12 @@ function completePromisedValue(exeContext, returnTypeRef, fieldGroup, info, path
         path,
         incrementalDataRecord
       );
-      exeContext.incrementalPublisher.filter(path, incrementalDataRecord);
+      filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
       return null;
     }
   });
 }
-function completeListValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord, deferMap) {
+function completeListValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord) {
   const itemTypeRef = unwrap(returnTypeRef);
   if (isAsyncIterable(result)) {
     const asyncIterator = result[Symbol.asyncIterator]();
@@ -863,8 +741,7 @@ function completeListValue(exeContext, returnTypeRef, fieldGroup, info, path, re
       info,
       path,
       asyncIterator,
-      incrementalDataRecord,
-      deferMap
+      incrementalDataRecord
     );
   }
   if (!isIterableObject(result)) {
@@ -873,28 +750,24 @@ function completeListValue(exeContext, returnTypeRef, fieldGroup, info, path, re
       []
     );
   }
-  const streamUsage = getStreamUsage(exeContext, fieldGroup, path);
+  const stream = getStreamValues(exeContext, fieldGroup, path);
   let containsPromise = false;
-  let currentParents = incrementalDataRecord;
+  let previousIncrementalDataRecord = incrementalDataRecord;
   const completedResults = [];
   let index = 0;
-  let streamRecord;
   for (const item of result) {
     const itemPath = addPath(path, index, void 0);
-    if (streamUsage && index >= streamUsage.initialCount) {
-      if (streamRecord === void 0) {
-        streamRecord = new StreamRecord({ label: streamUsage.label, path });
-      }
-      currentParents = executeStreamField(
+    if (stream && typeof stream.initialCount === "number" && index >= stream.initialCount) {
+      previousIncrementalDataRecord = executeStreamField(
         path,
         itemPath,
         item,
         exeContext,
-        streamUsage.fieldGroup,
+        fieldGroup,
         info,
         itemTypeRef,
-        currentParents,
-        streamRecord
+        stream.label,
+        previousIncrementalDataRecord
       );
       index++;
       continue;
@@ -907,8 +780,7 @@ function completeListValue(exeContext, returnTypeRef, fieldGroup, info, path, re
       fieldGroup,
       info,
       itemPath,
-      incrementalDataRecord,
-      deferMap
+      incrementalDataRecord
     )) {
       containsPromise = true;
     }
@@ -916,52 +788,7 @@ function completeListValue(exeContext, returnTypeRef, fieldGroup, info, path, re
   }
   return containsPromise ? Promise.all(completedResults) : completedResults;
 }
-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) {
+function completeListItemValue(item, completedResults, exeContext, itemTypeRef, fieldGroup, info, itemPath, incrementalDataRecord) {
   if (isPromise(item)) {
     completedResults.push(
       completePromisedValue(
@@ -971,8 +798,7 @@ function completeListItemValue(item, completedResults, exeContext, itemTypeRef,
         info,
         itemPath,
         item,
-        incrementalDataRecord,
-        deferMap
+        incrementalDataRecord
       )
     );
     return true;
@@ -985,8 +811,7 @@ function completeListItemValue(item, completedResults, exeContext, itemTypeRef,
       info,
       itemPath,
       item,
-      incrementalDataRecord,
-      deferMap
+      incrementalDataRecord
     );
     if (isPromise(completedItem)) {
       completedResults.push(
@@ -999,10 +824,7 @@ function completeListItemValue(item, completedResults, exeContext, itemTypeRef,
             itemPath,
             incrementalDataRecord
           );
-          exeContext.incrementalPublisher.filter(
-            itemPath,
-            incrementalDataRecord
-          );
+          filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
           return null;
         })
       );
@@ -1018,35 +840,61 @@ function completeListItemValue(item, completedResults, exeContext, itemTypeRef,
       itemPath,
       incrementalDataRecord
     );
-    exeContext.incrementalPublisher.filter(itemPath, incrementalDataRecord);
+    filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
     completedResults.push(null);
   }
   return false;
 }
-function completeAsyncIteratorValue(exeContext, itemTypeRef, fieldGroup, info, path, asyncIterator, incrementalDataRecord, deferMap) {
+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) {
   return __async(this, null, function* () {
-    const streamUsage = getStreamUsage(exeContext, fieldGroup, path);
+    const stream = getStreamValues(exeContext, fieldGroup, path);
     let containsPromise = false;
     const completedResults = [];
     let index = 0;
     while (true) {
-      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)
-        });
+      if (stream && typeof stream.initialCount === "number" && index >= stream.initialCount) {
         executeStreamAsyncIterator(
           index,
           asyncIterator,
           exeContext,
-          streamUsage.fieldGroup,
+          fieldGroup,
           info,
           itemTypeRef,
           path,
-          incrementalDataRecord,
-          streamRecord
+          stream.label,
+          incrementalDataRecord
         );
         break;
       }
@@ -1058,7 +906,7 @@ function completeAsyncIteratorValue(exeContext, itemTypeRef, fieldGroup, info, p
           break;
         }
       } catch (rawError) {
-        throw locatedError(rawError, toNodes(fieldGroup), pathToArray(path));
+        throw locatedError(rawError, fieldGroup, pathToArray(path));
       }
       if (completeListItemValue(
         iteration.value,
@@ -1068,8 +916,7 @@ function completeAsyncIteratorValue(exeContext, itemTypeRef, fieldGroup, info, p
         fieldGroup,
         info,
         itemPath,
-        incrementalDataRecord,
-        deferMap
+        incrementalDataRecord
       )) {
         containsPromise = true;
       }
@@ -1087,7 +934,7 @@ function completeLeafValue(returnType, result) {
   }
   return serializedResult;
 }
-function completeAbstractValue(exeContext, returnTypeName, fieldGroup, info, path, result, incrementalDataRecord, deferMap) {
+function completeAbstractValue(exeContext, returnTypeName, fieldGroup, info, path, result, incrementalDataRecord) {
   var _a;
   const { schemaFragment } = exeContext;
   const resolveTypeFn = (_a = Resolvers.getAbstractTypeResolver(schemaFragment, returnTypeName)) != null ? _a : exeContext.typeResolver;
@@ -1118,8 +965,7 @@ function completeAbstractValue(exeContext, returnTypeName, fieldGroup, info, pat
         fieldGroup,
         path,
         result,
-        incrementalDataRecord,
-        deferMap
+        incrementalDataRecord
       )
     );
   }
@@ -1129,15 +975,14 @@ function completeAbstractValue(exeContext, returnTypeName, fieldGroup, info, pat
     fieldGroup,
     path,
     result,
-    incrementalDataRecord,
-    deferMap
+    incrementalDataRecord
   );
 }
 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.`,
-      toNodes(fieldGroup)
+      fieldGroup
     );
   }
   if (typeof runtimeTypeName !== "string") {
@@ -1179,19 +1024,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.`,
-        toNodes(fieldGroup)
+        fieldGroup
       );
     }
     if (!Definitions.isObjectType(definitions, runtimeTypeName)) {
       throw locatedError(
         `Abstract type "${returnTypeName}" was resolved to a non-object type "${runtimeTypeName}".`,
-        toNodes(fieldGroup)
+        fieldGroup
       );
     }
     if (!Definitions.isSubType(definitions, returnTypeName, runtimeTypeName)) {
       throw locatedError(
         `Runtime Object type "${runtimeTypeName}" is not a possible type for "${returnTypeName}".`,
-        toNodes(fieldGroup)
+        fieldGroup
       );
     }
     return runtimeTypeName;
@@ -1201,7 +1046,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}".`,
-        toNodes(fieldGroup)
+        fieldGroup
       );
     }
     Definitions.addInterfaceImplementation(
@@ -1213,104 +1058,41 @@ function ensureValidRuntimeTypeImpl(runtimeTypeName, exeContext, returnTypeName,
   }
   invariant(false, `${returnTypeName} is not an abstract type`);
 }
-function completeObjectValue(exeContext, returnTypeName, fieldGroup, path, result, incrementalDataRecord, deferMap) {
+function completeObjectValue(exeContext, returnTypeName, fieldGroup, path, result, incrementalDataRecord) {
   return collectAndExecuteSubfields(
     exeContext,
     returnTypeName,
     fieldGroup,
     path,
     result,
-    incrementalDataRecord,
-    deferMap
-  );
-}
-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)
+    incrementalDataRecord
   );
 }
-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
-  );
+function collectAndExecuteSubfields(exeContext, returnTypeName, fieldGroup, path, result, incrementalDataRecord) {
+  const { groupedFieldSet: subGroupedFieldSet, patches: subPatches } = collectSubfields(exeContext, { name: returnTypeName }, fieldGroup);
   const subFields = executeFields(
     exeContext,
-    returnType,
-    result,
-    path,
-    groupedFieldSet,
-    incrementalDataRecord,
-    newDeferMap
-  );
-  executeDeferredGroupedFieldSets(
-    exeContext,
-    returnType,
+    returnTypeName,
     result,
     path,
-    newDeferredGroupedFieldSetRecords,
-    newDeferMap
+    subGroupedFieldSet,
+    incrementalDataRecord
   );
+  for (const subPatch of subPatches) {
+    const { label, groupedFieldSet: subPatchGroupedFieldSet } = subPatch;
+    executeDeferredFragment(
+      exeContext,
+      returnTypeName,
+      result,
+      subPatchGroupedFieldSet,
+      label,
+      path,
+      incrementalDataRecord
+    );
+  }
   return subFields;
 }
-function invokeBeforeFieldResolveHook(resolveInfo, exeContext, incrementalDataRecord) {
+function invokeBeforeFieldResolveHook(resolveInfo, exeContext) {
   var _a;
   const hook = (_a = exeContext.fieldExecutionHooks) == null ? void 0 : _a.beforeFieldResolve;
   if (!hook) {
@@ -1328,15 +1110,12 @@ function invokeBeforeFieldResolveHook(resolveInfo, exeContext, incrementalDataRe
           resolveInfo.path,
           "Unexpected error in beforeFieldResolve hook"
         );
-        exeContext.incrementalPublisher.addFieldError(
-          incrementalDataRecord,
-          error
-        );
+        exeContext.errors.push(error);
       }
     }
   );
 }
-function invokeAfterFieldResolveHook(resolveInfo, exeContext, incrementalDataRecord, result, error) {
+function invokeAfterFieldResolveHook(resolveInfo, exeContext, result, error) {
   var _a;
   const hook = (_a = exeContext.fieldExecutionHooks) == null ? void 0 : _a.afterFieldResolve;
   if (!hook) {
@@ -1356,15 +1135,12 @@ function invokeAfterFieldResolveHook(resolveInfo, exeContext, incrementalDataRec
           resolveInfo.path,
           "Unexpected error in afterFieldResolve hook"
         );
-        exeContext.incrementalPublisher.addFieldError(
-          incrementalDataRecord,
-          error2
-        );
+        exeContext.errors.push(error2);
       }
     }
   );
 }
-function invokeAfterFieldCompleteHook(resolveInfo, exeContext, incrementalDataRecord, result, error) {
+function invokeAfterFieldCompleteHook(resolveInfo, exeContext, result, error) {
   var _a;
   const hook = (_a = exeContext.fieldExecutionHooks) == null ? void 0 : _a.afterFieldComplete;
   if (!hook) {
@@ -1384,10 +1160,7 @@ function invokeAfterFieldCompleteHook(resolveInfo, exeContext, incrementalDataRe
           resolveInfo.path,
           "Unexpected error in afterFieldComplete hook"
         );
-        exeContext.incrementalPublisher.addFieldError(
-          incrementalDataRecord,
-          error2
-        );
+        exeContext.errors.push(error2);
       }
     }
   );
@@ -1441,215 +1214,153 @@ function getOperationRootTypeName(operation) {
       );
   }
 }
-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) {
+function executeDeferredFragment(exeContext, parentTypeName, sourceValue, fields, label, path, parentContext) {
+  const incrementalDataRecord = new DeferredFragmentRecord({
+    label,
+    path,
+    parentContext,
+    exeContext
+  });
+  let promiseOrData;
   try {
-    const incrementalResult = executeFields(
+    promiseOrData = executeFields(
       exeContext,
       parentTypeName,
       sourceValue,
       path,
-      deferredGroupedFieldSetRecord.groupedFieldSet,
-      deferredGroupedFieldSetRecord,
-      deferMap
+      fields,
+      incrementalDataRecord
     );
-    if (isPromise(incrementalResult)) {
-      incrementalResult.then(
-        (resolved) => exeContext.incrementalPublisher.completeDeferredGroupedFieldSet(
-          deferredGroupedFieldSetRecord,
-          resolved
-        ),
-        (error) => exeContext.incrementalPublisher.markErroredDeferredGroupedFieldSet(
-          deferredGroupedFieldSetRecord,
-          error
-        )
-      );
-      return;
+    if (isPromise(promiseOrData)) {
+      promiseOrData = promiseOrData.then(null, (e) => {
+        incrementalDataRecord.errors.push(e);
+        return null;
+      });
     }
-    exeContext.incrementalPublisher.completeDeferredGroupedFieldSet(
-      deferredGroupedFieldSetRecord,
-      incrementalResult
-    );
-  } catch (error) {
-    exeContext.incrementalPublisher.markErroredDeferredGroupedFieldSet(
-      deferredGroupedFieldSetRecord,
-      error
-    );
+  } catch (e) {
+    incrementalDataRecord.errors.push(e);
+    promiseOrData = null;
   }
+  incrementalDataRecord.addData(promiseOrData);
 }
-function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info, returnTypeRef, incrementalDataRecord, streamRecord) {
-  const incrementalPublisher = exeContext.incrementalPublisher;
-  const streamItemsRecord = new StreamItemsRecord({
-    streamRecord,
-    path: itemPath
+function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info, itemTypeRef, label, parentContext) {
+  const incrementalDataRecord = new StreamItemsRecord({
+    label,
+    path: itemPath,
+    parentContext,
+    exeContext
   });
-  incrementalPublisher.reportNewStreamItemsRecord(
-    streamItemsRecord,
-    incrementalDataRecord
-  );
   if (isPromise(item)) {
-    completePromisedValue(
+    const completedItems = completePromisedValue(
       exeContext,
-      returnTypeRef,
+      itemTypeRef,
       fieldGroup,
       info,
       itemPath,
       item,
-      streamItemsRecord,
-      /* @__PURE__ */ new Map()
+      incrementalDataRecord
     ).then(
-      (value) => incrementalPublisher.completeStreamItemsRecord(streamItemsRecord, [
-        value
-      ]),
+      (value) => [value],
       (error) => {
-        incrementalPublisher.filter(path, streamItemsRecord);
-        incrementalPublisher.markErroredStreamItemsRecord(
-          streamItemsRecord,
-          error
-        );
+        incrementalDataRecord.errors.push(error);
+        filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
+        return null;
       }
     );
-    return streamItemsRecord;
+    incrementalDataRecord.addItems(completedItems);
+    return incrementalDataRecord;
   }
   let completedItem;
   try {
     try {
       completedItem = completeValue(
         exeContext,
-        returnTypeRef,
+        itemTypeRef,
         fieldGroup,
         info,
         itemPath,
         item,
-        streamItemsRecord,
-        /* @__PURE__ */ new Map()
+        incrementalDataRecord
       );
     } catch (rawError) {
       handleFieldError(
         rawError,
         exeContext,
-        returnTypeRef,
+        itemTypeRef,
         fieldGroup,
         itemPath,
-        streamItemsRecord
+        incrementalDataRecord
       );
       completedItem = null;
-      incrementalPublisher.filter(itemPath, streamItemsRecord);
+      filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
     }
   } catch (error) {
-    incrementalPublisher.filter(path, streamItemsRecord);
-    incrementalPublisher.markErroredStreamItemsRecord(
-      streamItemsRecord,
-      error
-    );
-    return streamItemsRecord;
+    incrementalDataRecord.errors.push(error);
+    filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
+    incrementalDataRecord.addItems(null);
+    return incrementalDataRecord;
   }
   if (isPromise(completedItem)) {
-    completedItem.then(void 0, (rawError) => {
+    const completedItems = completedItem.then(void 0, (rawError) => {
       handleFieldError(
         rawError,
         exeContext,
-        returnTypeRef,
+        itemTypeRef,
         fieldGroup,
         itemPath,
-        streamItemsRecord
+        incrementalDataRecord
       );
-      incrementalPublisher.filter(itemPath, streamItemsRecord);
+      filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
       return null;
     }).then(
-      (value) => incrementalPublisher.completeStreamItemsRecord(streamItemsRecord, [
-        value
-      ]),
+      (value) => [value],
       (error) => {
-        incrementalPublisher.filter(path, streamItemsRecord);
-        incrementalPublisher.markErroredStreamItemsRecord(
-          streamItemsRecord,
-          error
-        );
+        incrementalDataRecord.errors.push(error);
+        filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
+        return null;
       }
     );
-    return streamItemsRecord;
+    incrementalDataRecord.addItems(completedItems);
+    return incrementalDataRecord;
   }
-  incrementalPublisher.completeStreamItemsRecord(streamItemsRecord, [
-    completedItem
-  ]);
-  return streamItemsRecord;
+  incrementalDataRecord.addItems([completedItem]);
+  return incrementalDataRecord;
 }
-function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, info, itemTypeName, streamItemsRecord, itemPath) {
+function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, info, itemTypeRef, incrementalDataRecord, path, itemPath) {
   return __async(this, null, function* () {
     let item;
     try {
-      const iteration = yield asyncIterator.next();
-      if (streamItemsRecord.streamRecord.errors.length > 0) {
-        return { done: true, value: void 0 };
-      }
-      if (iteration.done) {
-        exeContext.incrementalPublisher.setIsCompletedAsyncIterator(
-          streamItemsRecord
-        );
-        return { done: true, value: void 0 };
+      const { value, done } = yield asyncIterator.next();
+      if (done) {
+        incrementalDataRecord.setIsCompletedAsyncIterator();
+        return { done, value: void 0 };
       }
-      item = iteration.value;
+      item = value;
     } catch (rawError) {
-      throw locatedError(
-        rawError,
-        toNodes(fieldGroup),
-        streamItemsRecord.streamRecord.path
-      );
+      throw locatedError(rawError, fieldGroup, pathToArray(path));
     }
     let completedItem;
     try {
       completedItem = completeValue(
         exeContext,
-        itemTypeName,
+        itemTypeRef,
         fieldGroup,
         info,
         itemPath,
         item,
-        streamItemsRecord,
-        /* @__PURE__ */ new Map()
+        incrementalDataRecord
       );
       if (isPromise(completedItem)) {
         completedItem = completedItem.then(void 0, (rawError) => {
           handleFieldError(
             rawError,
             exeContext,
-            itemTypeName,
+            itemTypeRef,
             fieldGroup,
             itemPath,
-            streamItemsRecord
+            incrementalDataRecord
           );
-          exeContext.incrementalPublisher.filter(itemPath, streamItemsRecord);
+          filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
           return null;
         });
       }
@@ -1658,31 +1369,29 @@ function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, i
       handleFieldError(
         rawError,
         exeContext,
-        itemTypeName,
+        itemTypeRef,
         fieldGroup,
         itemPath,
-        streamItemsRecord
+        incrementalDataRecord
       );
-      exeContext.incrementalPublisher.filter(itemPath, streamItemsRecord);
+      filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
       return { done: false, value: null };
     }
   });
 }
-function executeStreamAsyncIterator(initialIndex, asyncIterator, exeContext, fieldGroup, info, itemTypeName, path, incrementalDataRecord, streamRecord) {
+function executeStreamAsyncIterator(initialIndex, asyncIterator, exeContext, fieldGroup, info, itemTypeRef, path, label, parentContext) {
   return __async(this, null, function* () {
-    const incrementalPublisher = exeContext.incrementalPublisher;
     let index = initialIndex;
-    let currentIncrementalDataRecord = incrementalDataRecord;
+    let previousIncrementalDataRecord = parentContext != null ? parentContext : void 0;
     while (true) {
       const itemPath = addPath(path, index, void 0);
-      const streamItemsRecord = new StreamItemsRecord({
-        streamRecord,
-        path: itemPath
+      const incrementalDataRecord = new StreamItemsRecord({
+        label,
+        path: itemPath,
+        parentContext: previousIncrementalDataRecord,
+        asyncIterator,
+        exeContext
       });
-      incrementalPublisher.reportNewStreamItemsRecord(
-        streamItemsRecord,
-        currentIncrementalDataRecord
-      );
       let iteration;
       try {
         iteration = yield executeStreamAsyncIteratorItem(
@@ -1690,47 +1399,223 @@ function executeStreamAsyncIterator(initialIndex, asyncIterator, exeContext, fie
           exeContext,
           fieldGroup,
           info,
-          itemTypeName,
-          streamItemsRecord,
+          itemTypeRef,
+          incrementalDataRecord,
+          path,
           itemPath
         );
       } catch (error) {
-        incrementalPublisher.filter(path, streamItemsRecord);
-        incrementalPublisher.markErroredStreamItemsRecord(
-          streamItemsRecord,
-          error
-        );
+        incrementalDataRecord.errors.push(error);
+        filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
+        incrementalDataRecord.addItems(null);
+        if (asyncIterator == null ? void 0 : asyncIterator.return) {
+          asyncIterator.return().catch(() => {
+          });
+        }
         return;
       }
       const { done, value: completedItem } = iteration;
+      let completedItems;
       if (isPromise(completedItem)) {
-        completedItem.then(
-          (value) => incrementalPublisher.completeStreamItemsRecord(streamItemsRecord, [
-            value
-          ]),
+        completedItems = completedItem.then(
+          (value) => [value],
           (error) => {
-            incrementalPublisher.filter(path, streamItemsRecord);
-            incrementalPublisher.markErroredStreamItemsRecord(
-              streamItemsRecord,
-              error
-            );
+            incrementalDataRecord.errors.push(error);
+            filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
+            return null;
           }
         );
       } else {
-        incrementalPublisher.completeStreamItemsRecord(streamItemsRecord, [
-          completedItem
-        ]);
+        completedItems = [completedItem];
       }
+      incrementalDataRecord.addItems(completedItems);
       if (done) {
         break;
       }
-      currentIncrementalDataRecord = streamItemsRecord;
+      previousIncrementalDataRecord = incrementalDataRecord;
       index++;
     }
   });
 }
-function toNodes(fieldGroup) {
-  return fieldGroup.fields.map((fieldDetails) => fieldDetails.node);
+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);
 }
 export {
   assertValidExecutionArguments,