@apollo/client 3.8.0-alpha.10 → 3.8.0-alpha.12

package/apollo-client.cjs

@@ -6,7 +6,7 @@ var tslib = require('tslib');
 var tsInvariant = require('ts-invariant');
 var process$1 = require('ts-invariant/process');
 var graphql = require('graphql');
-var equality = require('@wry/equality');
+var equal = require('@wry/equality');
 var zenObservableTs = require('zen-observable-ts');
 require('symbol-observable');
 var optimism = require('optimism');
@@ -15,6 +15,8 @@ var trie = require('@wry/trie');
 var graphqlTag = require('graphql-tag');
 var React = require('react');
 
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
+
 function _interopNamespace(e) {
     if (e && e.__esModule) return e;
     var n = Object.create(null);
@@ -27,7 +29,9 @@ function _interopNamespace(e) {
     return Object.freeze(n);
 }
 
+var equal__default = /*#__PURE__*/_interopDefaultLegacy(equal);
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 
 function maybe(thunk) {
     try {
@@ -63,7 +67,7 @@ function shouldInclude(_a, variables) {
         var evaledValue = false;
         if (ifArgument.value.kind === 'Variable') {
             evaledValue = variables && variables[ifArgument.value.name.value];
-            __DEV__ ? tsInvariant.invariant(evaledValue !== void 0, "Invalid variable referenced in @".concat(directive.name.value, " directive.")) : tsInvariant.invariant(evaledValue !== void 0, 41);
+            __DEV__ ? tsInvariant.invariant(evaledValue !== void 0, "Invalid variable referenced in @".concat(directive.name.value, " directive.")) : tsInvariant.invariant(evaledValue !== void 0, 42);
         }
         else {
             evaledValue = ifArgument.value.value;
@@ -71,6 +75,7 @@ function shouldInclude(_a, variables) {
         return directive.name.value === 'skip' ? !evaledValue : evaledValue;
     });
 }
+var hasAnyDirectives = function (names, root) { return hasDirectives(names, root, false); };
 function hasDirectives(names, root, all) {
     var nameSet = new Set(names);
     var uniqueCount = nameSet.size;
@@ -99,13 +104,13 @@ function getInclusionDirectives(directives) {
                 return;
             var directiveArguments = directive.arguments;
             var directiveName = directive.name.value;
-            __DEV__ ? tsInvariant.invariant(directiveArguments && directiveArguments.length === 1, "Incorrect number of arguments for the @".concat(directiveName, " directive.")) : tsInvariant.invariant(directiveArguments && directiveArguments.length === 1, 42);
+            __DEV__ ? tsInvariant.invariant(directiveArguments && directiveArguments.length === 1, "Incorrect number of arguments for the @".concat(directiveName, " directive.")) : tsInvariant.invariant(directiveArguments && directiveArguments.length === 1, 43);
             var ifArgument = directiveArguments[0];
-            __DEV__ ? tsInvariant.invariant(ifArgument.name && ifArgument.name.value === 'if', "Invalid argument for the @".concat(directiveName, " directive.")) : tsInvariant.invariant(ifArgument.name && ifArgument.name.value === 'if', 43);
+            __DEV__ ? tsInvariant.invariant(ifArgument.name && ifArgument.name.value === 'if', "Invalid argument for the @".concat(directiveName, " directive.")) : tsInvariant.invariant(ifArgument.name && ifArgument.name.value === 'if', 44);
             var ifValue = ifArgument.value;
             __DEV__ ? tsInvariant.invariant(ifValue &&
                 (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), "Argument for the @".concat(directiveName, " directive must be a variable or a boolean value.")) : tsInvariant.invariant(ifValue &&
-                (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), 44);
+                (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), 45);
             result.push({ directive: directive, ifArgument: ifArgument });
         });
     }
@@ -118,14 +123,14 @@ function getFragmentQueryDocument(document, fragmentName) {
     document.definitions.forEach(function (definition) {
         if (definition.kind === 'OperationDefinition') {
             throw __DEV__ ? new tsInvariant.InvariantError("Found a ".concat(definition.operation, " operation").concat(definition.name ? " named '".concat(definition.name.value, "'") : '', ". ") +
-                'No operations are allowed when using a fragment as a query. Only fragments are allowed.') : new tsInvariant.InvariantError(45);
+                'No operations are allowed when using a fragment as a query. Only fragments are allowed.') : new tsInvariant.InvariantError(46);
         }
         if (definition.kind === 'FragmentDefinition') {
             fragments.push(definition);
         }
     });
     if (typeof actualFragmentName === 'undefined') {
-        __DEV__ ? tsInvariant.invariant(fragments.length === 1, "Found ".concat(fragments.length, " fragments. `fragmentName` must be provided when there is not exactly 1 fragment.")) : tsInvariant.invariant(fragments.length === 1, 46);
+        __DEV__ ? tsInvariant.invariant(fragments.length === 1, "Found ".concat(fragments.length, " fragments. `fragmentName` must be provided when there is not exactly 1 fragment.")) : tsInvariant.invariant(fragments.length === 1, 47);
         actualFragmentName = fragments[0].name.value;
     }
     var query = tslib.__assign(tslib.__assign({}, document), { definitions: tslib.__spreadArray([
@@ -166,7 +171,7 @@ function getFragmentFromSelection(selection, fragmentMap) {
                 return fragmentMap(fragmentName);
             }
             var fragment = fragmentMap && fragmentMap[fragmentName];
-            __DEV__ ? tsInvariant.invariant(fragment, "No fragment named ".concat(fragmentName)) : tsInvariant.invariant(fragment, 47);
+            __DEV__ ? tsInvariant.invariant(fragment, "No fragment named ".concat(fragmentName)) : tsInvariant.invariant(fragment, 48);
             return fragment || null;
         }
         default:
@@ -177,6 +182,12 @@ function getFragmentFromSelection(selection, fragmentMap) {
 function isNonNullObject(obj) {
     return obj !== null && typeof obj === 'object';
 }
+function isPlainObject(obj) {
+    return (obj !== null &&
+        typeof obj === 'object' &&
+        (Object.getPrototypeOf(obj) === Object.prototype ||
+            Object.getPrototypeOf(obj) === null));
+}
 
 function makeReference(id) {
     return { __ref: String(id) };
@@ -250,7 +261,7 @@ function valueToObjectRepresentation(argObj, name, value, variables) {
     else {
         throw __DEV__ ? new tsInvariant.InvariantError("The inline argument \"".concat(name.value, "\" of kind \"").concat(value.kind, "\"") +
             'is not supported. Use variables instead of inline arguments to ' +
-            'overcome this limitation.') : new tsInvariant.InvariantError(56);
+            'overcome this limitation.') : new tsInvariant.InvariantError(57);
     }
 }
 function storeKeyNameFromField(field, variables) {
@@ -284,6 +295,7 @@ var KNOWN_DIRECTIVES = [
     'client',
     'rest',
     'export',
+    'nonreactive',
 ];
 var getStoreKeyName = Object.assign(function (fieldName, args, directives) {
     if (args &&
@@ -384,16 +396,16 @@ function isInlineFragment(selection) {
 }
 
 function checkDocument(doc) {
-    __DEV__ ? tsInvariant.invariant(doc && doc.kind === 'Document', "Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \"gql\" tag? http://docs.apollostack.com/apollo-client/core.html#gql") : tsInvariant.invariant(doc && doc.kind === 'Document', 48);
+    __DEV__ ? tsInvariant.invariant(doc && doc.kind === 'Document', "Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \"gql\" tag? http://docs.apollostack.com/apollo-client/core.html#gql") : tsInvariant.invariant(doc && doc.kind === 'Document', 49);
     var operations = doc.definitions
         .filter(function (d) { return d.kind !== 'FragmentDefinition'; })
         .map(function (definition) {
         if (definition.kind !== 'OperationDefinition') {
-            throw __DEV__ ? new tsInvariant.InvariantError("Schema type definitions not allowed in queries. Found: \"".concat(definition.kind, "\"")) : new tsInvariant.InvariantError(49);
+            throw __DEV__ ? new tsInvariant.InvariantError("Schema type definitions not allowed in queries. Found: \"".concat(definition.kind, "\"")) : new tsInvariant.InvariantError(50);
         }
         return definition;
     });
-    __DEV__ ? tsInvariant.invariant(operations.length <= 1, "Ambiguous GraphQL document: contains ".concat(operations.length, " operations")) : tsInvariant.invariant(operations.length <= 1, 50);
+    __DEV__ ? tsInvariant.invariant(operations.length <= 1, "Ambiguous GraphQL document: contains ".concat(operations.length, " operations")) : tsInvariant.invariant(operations.length <= 1, 51);
     return doc;
 }
 function getOperationDefinition(doc) {
@@ -416,14 +428,14 @@ function getFragmentDefinitions(doc) {
 }
 function getQueryDefinition(doc) {
     var queryDef = getOperationDefinition(doc);
-    __DEV__ ? tsInvariant.invariant(queryDef && queryDef.operation === 'query', 'Must contain a query definition.') : tsInvariant.invariant(queryDef && queryDef.operation === 'query', 51);
+    __DEV__ ? tsInvariant.invariant(queryDef && queryDef.operation === 'query', 'Must contain a query definition.') : tsInvariant.invariant(queryDef && queryDef.operation === 'query', 52);
     return queryDef;
 }
 function getFragmentDefinition(doc) {
-    __DEV__ ? tsInvariant.invariant(doc.kind === 'Document', "Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \"gql\" tag? http://docs.apollostack.com/apollo-client/core.html#gql") : tsInvariant.invariant(doc.kind === 'Document', 52);
-    __DEV__ ? tsInvariant.invariant(doc.definitions.length <= 1, 'Fragment must have exactly one definition.') : tsInvariant.invariant(doc.definitions.length <= 1, 53);
+    __DEV__ ? tsInvariant.invariant(doc.kind === 'Document', "Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \"gql\" tag? http://docs.apollostack.com/apollo-client/core.html#gql") : tsInvariant.invariant(doc.kind === 'Document', 53);
+    __DEV__ ? tsInvariant.invariant(doc.definitions.length <= 1, 'Fragment must have exactly one definition.') : tsInvariant.invariant(doc.definitions.length <= 1, 54);
     var fragmentDef = doc.definitions[0];
-    __DEV__ ? tsInvariant.invariant(fragmentDef.kind === 'FragmentDefinition', 'Must be a fragment definition.') : tsInvariant.invariant(fragmentDef.kind === 'FragmentDefinition', 54);
+    __DEV__ ? tsInvariant.invariant(fragmentDef.kind === 'FragmentDefinition', 'Must be a fragment definition.') : tsInvariant.invariant(fragmentDef.kind === 'FragmentDefinition', 55);
     return fragmentDef;
 }
 function getMainDefinition(queryDoc) {
@@ -446,7 +458,7 @@ function getMainDefinition(queryDoc) {
     if (fragmentDefinition) {
         return fragmentDefinition;
     }
-    throw __DEV__ ? new tsInvariant.InvariantError('Expected a parsed GraphQL query with a query, mutation, subscription, or a fragment.') : new tsInvariant.InvariantError(55);
+    throw __DEV__ ? new tsInvariant.InvariantError('Expected a parsed GraphQL query with a query, mutation, subscription, or a fragment.') : new tsInvariant.InvariantError(56);
 }
 function getDefaultValues(definition) {
     var defaultValues = Object.create(null);
@@ -482,19 +494,30 @@ function nullIfDocIsEmpty(doc) {
         ? null
         : doc;
 }
-function getDirectiveMatcher(directives) {
-    var nameSet = new Set();
-    var tests = [];
-    directives.forEach(function (directive) {
-        if (directive.name) {
-            nameSet.add(directive.name);
-        }
-        else if (directive.test) {
-            tests.push(directive.test);
+function getDirectiveMatcher(configs) {
+    var names = new Map();
+    var tests = new Map();
+    configs.forEach(function (directive) {
+        if (directive) {
+            if (directive.name) {
+                names.set(directive.name, directive);
+            }
+            else if (directive.test) {
+                tests.set(directive.test, directive);
+            }
         }
     });
-    return function (directive) { return (nameSet.has(directive.name.value) ||
-        tests.some(function (test) { return test(directive); })); };
+    return function (directive) {
+        var config = names.get(directive.name.value);
+        if (!config && tests.size) {
+            tests.forEach(function (testConfig, test) {
+                if (test(directive)) {
+                    config = testConfig;
+                }
+            });
+        }
+        return config;
+    };
 }
 function makeInUseGetterFunction(defaultKey) {
     var map = new Map();
@@ -511,6 +534,7 @@ function makeInUseGetterFunction(defaultKey) {
     };
 }
 function removeDirectivesFromDocument(directives, doc) {
+    checkDocument(doc);
     var getInUseByOperationName = makeInUseGetterFunction("");
     var getInUseByFragmentName = makeInUseGetterFunction("");
     var getInUse = function (ancestors) {
@@ -534,10 +558,8 @@ function removeDirectivesFromDocument(directives, doc) {
         }
     }
     var directiveMatcher = getDirectiveMatcher(directives);
-    var hasRemoveDirective = directives.some(function (directive) { return directive.remove; });
-    var shouldRemoveField = function (nodeDirectives) { return (hasRemoveDirective &&
-        nodeDirectives &&
-        nodeDirectives.some(directiveMatcher)); };
+    var shouldRemoveField = function (nodeDirectives) { return (isNonEmptyArray(nodeDirectives) &&
+        nodeDirectives.map(directiveMatcher).some(function (config) { return config && config.remove; })); };
     var originalFragmentDefsByPath = new Map();
     var firstVisitMadeChanges = false;
     var fieldOrInlineFragmentVisitor = {
@@ -696,22 +718,6 @@ var addTypenameToDocument = Object.assign(function (doc) {
         return field === TYPENAME_FIELD;
     },
 });
-var connectionRemoveConfig = {
-    test: function (directive) {
-        var willRemove = directive.name.value === 'connection';
-        if (willRemove) {
-            if (!directive.arguments ||
-                !directive.arguments.some(function (arg) { return arg.name.value === 'key'; })) {
-                __DEV__ && tsInvariant.invariant.warn('Removing an @connection directive even though it does not have a key. ' +
-                    'You may want to use the key parameter to specify a store key.');
-            }
-        }
-        return willRemove;
-    },
-};
-function removeConnectionDirectiveFromDocument(doc) {
-    return removeDirectivesFromDocument([connectionRemoveConfig], checkDocument(doc));
-}
 function buildQueryFromSelectionSet(document) {
     var definition = getMainDefinition(document);
     var definitionOperation = definition.operation;
@@ -811,6 +817,31 @@ var DeepMerger = (function () {
     return DeepMerger;
 }());
 
+function isStatefulPromise(promise) {
+    return 'status' in promise;
+}
+function wrapPromiseWithState(promise) {
+    if (isStatefulPromise(promise)) {
+        return promise;
+    }
+    var pendingPromise = promise;
+    pendingPromise.status = 'pending';
+    pendingPromise.then(function (value) {
+        if (pendingPromise.status === 'pending') {
+            var fulfilledPromise = pendingPromise;
+            fulfilledPromise.status = 'fulfilled';
+            fulfilledPromise.value = value;
+        }
+    }, function (reason) {
+        if (pendingPromise.status === 'pending') {
+            var rejectedPromise = pendingPromise;
+            rejectedPromise.status = 'rejected';
+            rejectedPromise.reason = reason;
+        }
+    });
+    return promise;
+}
+
 var toString = Object.prototype.toString;
 function cloneDeep(value) {
     return cloneDeepHelper(value);
@@ -1093,6 +1124,9 @@ function isExecutionPatchResult(value) {
     return (isExecutionPatchIncrementalResult(value) ||
         isExecutionPatchInitialResult(value));
 }
+function isApolloPayloadResult(value) {
+    return isNonNullObject(value) && "payload" in value;
+}
 function mergeIncrementalData(prevResult, result) {
     var mergedData = prevResult;
     var merger = new DeepMerger();
@@ -1167,7 +1201,7 @@ function stringifyForDisplay(value) {
 
 function mergeOptions(defaults, options) {
     return compact(defaults, options, options.variables && {
-        variables: tslib.__assign(tslib.__assign({}, (defaults && defaults.variables)), options.variables),
+        variables: compact(tslib.__assign(tslib.__assign({}, (defaults && defaults.variables)), options.variables)),
     });
 }
 
@@ -1191,6 +1225,51 @@ function isNodeReadableStream(value) {
     return !!value.pipe;
 }
 
+function omitDeep(value, key) {
+    return __omitDeep(value, key);
+}
+function __omitDeep(value, key, known) {
+    if (known === void 0) { known = new Map(); }
+    if (known.has(value)) {
+        return known.get(value);
+    }
+    var modified = false;
+    if (Array.isArray(value)) {
+        var array_1 = [];
+        known.set(value, array_1);
+        value.forEach(function (value, index) {
+            var result = __omitDeep(value, key, known);
+            modified || (modified = result !== value);
+            array_1[index] = result;
+        });
+        if (modified) {
+            return array_1;
+        }
+    }
+    else if (isPlainObject(value)) {
+        var obj_1 = Object.create(Object.getPrototypeOf(value));
+        known.set(value, obj_1);
+        Object.keys(value).forEach(function (k) {
+            if (k === key) {
+                modified = true;
+            }
+            else {
+                var result = __omitDeep(value[k], key, known);
+                modified || (modified = result !== value[k]);
+                obj_1[k] = result;
+            }
+        });
+        if (modified) {
+            return obj_1;
+        }
+    }
+    return value;
+}
+
+function stripTypename(value) {
+    return omitDeep(value, '__typename');
+}
+
 function fromError(errorValue) {
     return new zenObservableTs.Observable(function (observer) {
         observer.error(errorValue);
@@ -1290,6 +1369,22 @@ function transformOperation(operation) {
     return transformedOperation;
 }
 
+function filterOperationVariables(variables, operation) {
+    var result = tslib.__assign({}, variables);
+    var unusedNames = new Set(Object.keys(variables));
+    graphql.visit(operation.query, {
+        Variable: function (node, _key, parent) {
+            if (parent && parent.kind !== 'VariableDefinition') {
+                unusedNames.delete(node.name.value);
+            }
+        },
+    });
+    unusedNames.forEach(function (name) {
+        delete result[name];
+    });
+    return result;
+}
+
 function passthrough(op, forward) {
     return (forward ? forward(op) : zenObservableTs.Observable.of());
 }
@@ -1395,7 +1490,7 @@ var concat = ApolloLink.concat;
 
 var execute = ApolloLink.execute;
 
-var version = '3.8.0-alpha.10';
+var version = '3.8.0-alpha.12';
 
 function asyncIterator(source) {
     var _a;
@@ -1540,20 +1635,56 @@ function responseIterator(response) {
     throw new Error("Unknown body type for responseIterator. Please pass a streamable response.");
 }
 
+var PROTOCOL_ERRORS_SYMBOL = Symbol();
+function graphQLResultHasProtocolErrors(result) {
+    if (result.extensions) {
+        return Array.isArray(result.extensions[PROTOCOL_ERRORS_SYMBOL]);
+    }
+    return false;
+}
+function isApolloError(err) {
+    return err.hasOwnProperty('graphQLErrors');
+}
+var generateErrorMessage = function (err) {
+    var errors = tslib.__spreadArray(tslib.__spreadArray(tslib.__spreadArray([], err.graphQLErrors, true), err.clientErrors, true), err.protocolErrors, true);
+    if (err.networkError)
+        errors.push(err.networkError);
+    return errors
+        .map(function (err) { return isNonNullObject(err) && err.message || 'Error message not found.'; })
+        .join('\n');
+};
+var ApolloError = (function (_super) {
+    tslib.__extends(ApolloError, _super);
+    function ApolloError(_a) {
+        var graphQLErrors = _a.graphQLErrors, protocolErrors = _a.protocolErrors, clientErrors = _a.clientErrors, networkError = _a.networkError, errorMessage = _a.errorMessage, extraInfo = _a.extraInfo;
+        var _this = _super.call(this, errorMessage) || this;
+        _this.name = 'ApolloError';
+        _this.graphQLErrors = graphQLErrors || [];
+        _this.protocolErrors = protocolErrors || [];
+        _this.clientErrors = clientErrors || [];
+        _this.networkError = networkError || null;
+        _this.message = errorMessage || generateErrorMessage(_this);
+        _this.extraInfo = extraInfo;
+        _this.__proto__ = ApolloError.prototype;
+        return _this;
+    }
+    return ApolloError;
+}(Error));
+
 var hasOwnProperty$3 = Object.prototype.hasOwnProperty;
 function readMultipartBody(response, observer) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     return tslib.__awaiter(this, void 0, void 0, function () {
-        var decoder, contentType, delimiter, boundaryVal, boundary, buffer, iterator, running, _d, value, done, chunk, bi, message, i, headers, contentType_1, body, result;
-        var _e;
-        return tslib.__generator(this, function (_f) {
-            switch (_f.label) {
+        var decoder, contentType, delimiter, boundaryVal, boundary, buffer, iterator, running, _f, value, done, chunk, bi, message, i, headers, contentType_1, body, result, next;
+        var _g, _h;
+        return tslib.__generator(this, function (_j) {
+            switch (_j.label) {
                 case 0:
                     if (TextDecoder === undefined) {
                         throw new Error("TextDecoder must be defined in the environment: please import a polyfill.");
                     }
                     decoder = new TextDecoder("utf-8");
-                    contentType = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get('content-type');
+                    contentType = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get("content-type");
                     delimiter = "boundary=";
                     boundaryVal = (contentType === null || contentType === void 0 ? void 0 : contentType.includes(delimiter))
                         ? contentType === null || contentType === void 0 ? void 0 : contentType.substring((contentType === null || contentType === void 0 ? void 0 : contentType.indexOf(delimiter)) + delimiter.length).replace(/['"]/g, "").replace(/\;(.*)/gm, "").trim()
@@ -1562,22 +1693,22 @@ function readMultipartBody(response, observer) {
                     buffer = "";
                     iterator = responseIterator(response);
                     running = true;
-                    _f.label = 1;
+                    _j.label = 1;
                 case 1:
                     if (!running) return [3, 3];
                     return [4, iterator.next()];
                 case 2:
-                    _d = _f.sent(), value = _d.value, done = _d.done;
+                    _f = _j.sent(), value = _f.value, done = _f.done;
                     chunk = typeof value === "string" ? value : decoder.decode(value);
                     running = !done;
                     buffer += chunk;
                     bi = buffer.indexOf(boundary);
                     while (bi > -1) {
                         message = void 0;
-                        _e = [
+                        _g = [
                             buffer.slice(0, bi),
                             buffer.slice(bi + boundary.length),
-                        ], message = _e[0], buffer = _e[1];
+                        ], message = _g[0], buffer = _g[1];
                         if (message.trim()) {
                             i = message.indexOf("\r\n\r\n");
                             headers = parseHeaders(message.slice(0, i));
@@ -1592,8 +1723,26 @@ function readMultipartBody(response, observer) {
                                 if (Object.keys(result).length > 1 ||
                                     "data" in result ||
                                     "incremental" in result ||
-                                    "errors" in result) {
-                                    (_b = observer.next) === null || _b === void 0 ? void 0 : _b.call(observer, result);
+                                    "errors" in result ||
+                                    "payload" in result) {
+                                    if (isApolloPayloadResult(result)) {
+                                        next = {};
+                                        if ("payload" in result) {
+                                            next = tslib.__assign({}, result.payload);
+                                        }
+                                        if ("errors" in result) {
+                                            next = tslib.__assign(tslib.__assign({}, next), { extensions: tslib.__assign(tslib.__assign({}, ("extensions" in next ? next.extensions : null)), (_h = {}, _h[PROTOCOL_ERRORS_SYMBOL] = result.errors, _h)) });
+                                        }
+                                        (_b = observer.next) === null || _b === void 0 ? void 0 : _b.call(observer, next);
+                                    }
+                                    else {
+                                        (_c = observer.next) === null || _c === void 0 ? void 0 : _c.call(observer, result);
+                                    }
+                                }
+                                else if (Object.keys(result).length === 1 &&
+                                    "hasNext" in result &&
+                                    !result.hasNext) {
+                                    (_d = observer.complete) === null || _d === void 0 ? void 0 : _d.call(observer);
                                 }
                             }
                             catch (err) {
@@ -1604,7 +1753,7 @@ function readMultipartBody(response, observer) {
                     }
                     return [3, 1];
                 case 3:
-                    (_c = observer.complete) === null || _c === void 0 ? void 0 : _c.call(observer);
+                    (_e = observer.complete) === null || _e === void 0 ? void 0 : _e.call(observer);
                     return [2];
             }
         });
@@ -1743,7 +1892,7 @@ function selectHttpOptionsAndBodyInternal(operation, printer) {
         options.headers = removeDuplicateHeaders(options.headers, http.preserveHeaderCase);
     }
     var operationName = operation.operationName, extensions = operation.extensions, variables = operation.variables, query = operation.query;
-    var body = { operationName: operationName, variables: variables };
+    var body = { operationName: operationName, variables: stripTypename(variables) };
     if (http.includeExtensions)
         body.extensions = extensions;
     if (http.includeQuery)
@@ -1884,20 +2033,7 @@ var createHttpLink = function (linkOptions) {
         }
         var _b = selectHttpOptionsAndBodyInternal(operation, print, fallbackHttpConfig, linkConfig, contextConfig), options = _b.options, body = _b.body;
         if (body.variables && !includeUnusedVariables) {
-            var unusedNames_1 = new Set(Object.keys(body.variables));
-            graphql.visit(operation.query, {
-                Variable: function (node, _key, parent) {
-                    if (parent && parent.kind !== 'VariableDefinition') {
-                        unusedNames_1.delete(node.name.value);
-                    }
-                },
-            });
-            if (unusedNames_1.size) {
-                body.variables = tslib.__assign({}, body.variables);
-                unusedNames_1.forEach(function (name) {
-                    delete body.variables[name];
-                });
-            }
+            body.variables = filterOperationVariables(body.variables, operation);
         }
         var controller;
         if (!options.signal) {
@@ -1909,13 +2045,28 @@ var createHttpLink = function (linkOptions) {
         var definitionIsMutation = function (d) {
             return d.kind === 'OperationDefinition' && d.operation === 'mutation';
         };
+        var definitionIsSubscription = function (d) {
+            return d.kind === 'OperationDefinition' && d.operation === 'subscription';
+        };
+        var isSubscription = definitionIsSubscription(getMainDefinition(operation.query));
+        var hasDefer = hasDirectives(['defer'], operation.query);
         if (useGETForQueries &&
             !operation.query.definitions.some(definitionIsMutation)) {
             options.method = 'GET';
         }
-        if (hasDirectives(['defer'], operation.query)) {
+        if (hasDefer || isSubscription) {
             options.headers = options.headers || {};
-            options.headers.accept = "multipart/mixed; deferSpec=20220824, application/json";
+            var acceptHeader = "multipart/mixed;";
+            if (isSubscription && hasDefer) {
+                __DEV__ && tsInvariant.invariant.warn("Multipart-subscriptions do not support @defer");
+            }
+            if (isSubscription) {
+                acceptHeader += 'boundary=graphql;subscriptionSpec=1.0,application/json';
+            }
+            else if (hasDefer) {
+                acceptHeader += 'deferSpec=20220824,application/json';
+            }
+            options.headers.accept = acceptHeader;
         }
         if (options.method === 'GET') {
             var _d = rewriteURIForGET(chosenURI, body), newURI = _d.newURI, parseError = _d.parseError;
@@ -1968,6 +2119,7 @@ var HttpLink = (function (_super) {
 
 var ApolloCache = (function () {
     function ApolloCache() {
+        this.assumeImmutableResults = false;
         this.getFragmentDoc = optimism.wrap(getFragmentQueryDocument);
     }
     ApolloCache.prototype.batch = function (options) {
@@ -2566,7 +2718,7 @@ var Layer = (function (_super) {
                     }
                     else if (ownStoreObject !== parentStoreObject) {
                         Object.keys(ownStoreObject).forEach(function (storeFieldName) {
-                            if (!equality.equal(ownStoreObject[storeFieldName], parentStoreObject[storeFieldName])) {
+                            if (!equal.equal(ownStoreObject[storeFieldName], parentStoreObject[storeFieldName])) {
                                 _this.group.dirty(dataId, storeFieldName);
                             }
                         });
@@ -2610,7 +2762,7 @@ var Stump = (function (_super) {
 function storeObjectReconciler(existingObject, incomingObject, property) {
     var existingValue = existingObject[property];
     var incomingValue = incomingObject[property];
-    return equality.equal(existingValue, incomingValue) ? existingValue : incomingValue;
+    return equal.equal(existingValue, incomingValue) ? existingValue : incomingValue;
 }
 function supportsResultCaching(store) {
     return !!(store instanceof EntityStore && store.group.caching);
@@ -3937,7 +4089,7 @@ function warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {
         return;
     if (isReference(existing))
         return;
-    if (equality.equal(existing, incoming))
+    if (equal.equal(existing, incoming))
         return;
     if (Object.keys(existing).every(function (key) { return store.getFieldValue(incoming, key) !== void 0; })) {
         return;
@@ -3973,6 +4125,7 @@ var InMemoryCache = (function (_super) {
         var _this = _super.call(this) || this;
         _this.watches = new Set();
         _this.typenameDocumentCache = new Map();
+        _this.assumeImmutableResults = true;
         _this.makeVar = makeVar;
         _this.txCount = 0;
         _this.config = normalizeConfig(config);
@@ -4259,51 +4412,13 @@ var InMemoryCache = (function (_super) {
                 return;
             }
         }
-        if (!lastDiff || !equality.equal(lastDiff.result, diff.result)) {
+        if (!lastDiff || !equal.equal(lastDiff.result, diff.result)) {
             c.callback(c.lastDiff = diff, lastDiff);
         }
     };
     return InMemoryCache;
 }(ApolloCache));
 
-function isApolloError(err) {
-    return err.hasOwnProperty('graphQLErrors');
-}
-var generateErrorMessage = function (err) {
-    var message = '';
-    if (isNonEmptyArray(err.graphQLErrors) || isNonEmptyArray(err.clientErrors)) {
-        var errors = (err.graphQLErrors || [])
-            .concat(err.clientErrors || []);
-        errors.forEach(function (error) {
-            var errorMessage = error
-                ? error.message
-                : 'Error message not found.';
-            message += "".concat(errorMessage, "\n");
-        });
-    }
-    if (err.networkError) {
-        message += "".concat(err.networkError.message, "\n");
-    }
-    message = message.replace(/\n$/, '');
-    return message;
-};
-var ApolloError = (function (_super) {
-    tslib.__extends(ApolloError, _super);
-    function ApolloError(_a) {
-        var graphQLErrors = _a.graphQLErrors, clientErrors = _a.clientErrors, networkError = _a.networkError, errorMessage = _a.errorMessage, extraInfo = _a.extraInfo;
-        var _this = _super.call(this, errorMessage) || this;
-        _this.name = 'ApolloError';
-        _this.graphQLErrors = graphQLErrors || [];
-        _this.clientErrors = clientErrors || [];
-        _this.networkError = networkError || null;
-        _this.message = errorMessage || generateErrorMessage(_this);
-        _this.extraInfo = extraInfo;
-        _this.__proto__ = ApolloError.prototype;
-        return _this;
-    }
-    return ApolloError;
-}(Error));
-
 exports.NetworkStatus = void 0;
 (function (NetworkStatus) {
     NetworkStatus[NetworkStatus["loading"] = 1] = "loading";
@@ -4317,6 +4432,73 @@ exports.NetworkStatus = void 0;
 function isNetworkRequestInFlight(networkStatus) {
     return networkStatus ? networkStatus < 7 : false;
 }
+function isNetworkRequestSettled(networkStatus) {
+    return networkStatus === 7 || networkStatus === 8;
+}
+
+function equalByQuery(query, _a, _b, variables) {
+    var aData = _a.data, aRest = tslib.__rest(_a, ["data"]);
+    var bData = _b.data, bRest = tslib.__rest(_b, ["data"]);
+    return equal__default(aRest, bRest) && equalBySelectionSet(getMainDefinition(query).selectionSet, aData, bData, {
+        fragmentMap: createFragmentMap(getFragmentDefinitions(query)),
+        variables: variables,
+    });
+}
+function equalBySelectionSet(selectionSet, aResult, bResult, context) {
+    if (aResult === bResult) {
+        return true;
+    }
+    var seenSelections = new Set();
+    return selectionSet.selections.every(function (selection) {
+        if (seenSelections.has(selection))
+            return true;
+        seenSelections.add(selection);
+        if (!shouldInclude(selection, context.variables))
+            return true;
+        if (selectionHasNonreactiveDirective(selection))
+            return true;
+        if (isField(selection)) {
+            var resultKey = resultKeyNameFromField(selection);
+            var aResultChild = aResult && aResult[resultKey];
+            var bResultChild = bResult && bResult[resultKey];
+            var childSelectionSet = selection.selectionSet;
+            if (!childSelectionSet) {
+                return equal__default(aResultChild, bResultChild);
+            }
+            var aChildIsArray = Array.isArray(aResultChild);
+            var bChildIsArray = Array.isArray(bResultChild);
+            if (aChildIsArray !== bChildIsArray)
+                return false;
+            if (aChildIsArray && bChildIsArray) {
+                var length_1 = aResultChild.length;
+                if (bResultChild.length !== length_1) {
+                    return false;
+                }
+                for (var i = 0; i < length_1; ++i) {
+                    if (!equalBySelectionSet(childSelectionSet, aResultChild[i], bResultChild[i], context)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            return equalBySelectionSet(childSelectionSet, aResultChild, bResultChild, context);
+        }
+        else {
+            var fragment = getFragmentFromSelection(selection, context.fragmentMap);
+            if (fragment) {
+                if (selectionHasNonreactiveDirective(fragment))
+                    return true;
+                return equalBySelectionSet(fragment.selectionSet, aResult, bResult, context);
+            }
+        }
+    });
+}
+function selectionHasNonreactiveDirective(selection) {
+    return !!selection.directives && selection.directives.some(directiveIsNonreactive);
+}
+function directiveIsNonreactive(dir) {
+    return dir.name.value === "nonreactive";
+}
 
 var assign = Object.assign, hasOwnProperty$2 = Object.hasOwnProperty;
 var ObservableQuery = (function (_super) {
@@ -4324,14 +4506,13 @@ var ObservableQuery = (function (_super) {
     function ObservableQuery(_a) {
         var queryManager = _a.queryManager, queryInfo = _a.queryInfo, options = _a.options;
         var _this = _super.call(this, function (observer) {
-            var _a = options.fetchOnFirstSubscribe, fetchOnFirstSubscribe = _a === void 0 ? true : _a;
             try {
                 var subObserver = observer._subscription._observer;
                 if (subObserver && !subObserver.error) {
                     subObserver.error = defaultSubscriptionObserverErrorCallback;
                 }
             }
-            catch (_b) { }
+            catch (_a) { }
             var first = !_this.observers.size;
             _this.observers.add(observer);
             var last = _this.last;
@@ -4341,7 +4522,7 @@ var ObservableQuery = (function (_super) {
             else if (last && last.result) {
                 observer.next && observer.next(last.result);
             }
-            if (first && fetchOnFirstSubscribe) {
+            if (first) {
                 _this.reobserve().catch(function () { });
             }
             return function () {
@@ -4413,7 +4594,7 @@ var ObservableQuery = (function (_super) {
             if (diff.complete || this.options.returnPartialData) {
                 result.data = diff.result;
             }
-            if (equality.equal(result.data, {})) {
+            if (equal.equal(result.data, {})) {
                 result.data = void 0;
             }
             if (diff.complete) {
@@ -4444,15 +4625,21 @@ var ObservableQuery = (function (_super) {
         return result;
     };
     ObservableQuery.prototype.isDifferentFromLastResult = function (newResult, variables) {
-        return (!this.last ||
-            !equality.equal(this.last.result, newResult) ||
-            (variables && !equality.equal(this.last.variables, variables)));
+        if (!this.last) {
+            return true;
+        }
+        var query = this.options.query;
+        var resultIsDifferent = this.queryManager.transform(query).hasNonreactiveDirective
+            ? !equalByQuery(query, this.last.result, newResult, this.variables)
+            : !equal.equal(this.last.result, newResult);
+        return (resultIsDifferent ||
+            (variables && !equal.equal(this.last.variables, variables)));
     };
     ObservableQuery.prototype.getLast = function (key, variablesMustMatch) {
         var last = this.last;
         if (last &&
             last[key] &&
-            (!variablesMustMatch || equality.equal(last.variables, this.variables))) {
+            (!variablesMustMatch || equal.equal(last.variables, this.variables))) {
             return last[key];
         }
     };
@@ -4491,7 +4678,7 @@ var ObservableQuery = (function (_super) {
                 __DEV__ && tsInvariant.invariant.warn("Called refetch(".concat(JSON.stringify(variables), ") for query ").concat(((_a = queryDef.name) === null || _a === void 0 ? void 0 : _a.value) || JSON.stringify(queryDef), ", which does not declare a $variables variable.\nDid you mean to call refetch(variables) instead of refetch({ variables })?"));
             }
         }
-        if (variables && !equality.equal(this.options.variables, variables)) {
+        if (variables && !equal.equal(this.options.variables, variables)) {
             reobserveOptions.variables = this.options.variables = tslib.__assign(tslib.__assign({}, this.options.variables), variables);
         }
         this.queryInfo.resetLastWrite();
@@ -4586,7 +4773,7 @@ var ObservableQuery = (function (_super) {
         return this.reobserve(newOptions);
     };
     ObservableQuery.prototype.setVariables = function (variables) {
-        if (equality.equal(this.variables, variables)) {
+        if (equal.equal(this.variables, variables)) {
             return this.observers.size
                 ? this.result()
                 : Promise.resolve();
@@ -4651,7 +4838,7 @@ var ObservableQuery = (function (_super) {
     };
     ObservableQuery.prototype.fetch = function (options, newNetworkStatus) {
         this.queryManager.setObservableQuery(this);
-        return this.queryManager.fetchQueryObservable(this.queryId, options, newNetworkStatus);
+        return this.queryManager['fetchConcastWithInfo'](this.queryId, options, newNetworkStatus);
     };
     ObservableQuery.prototype.updatePolling = function () {
         var _this = this;
@@ -4696,13 +4883,13 @@ var ObservableQuery = (function (_super) {
     };
     ObservableQuery.prototype.updateLastResult = function (newResult, variables) {
         if (variables === void 0) { variables = this.variables; }
-        this.last = tslib.__assign(tslib.__assign({}, this.last), { result: this.queryManager.assumeImmutableResults
-                ? newResult
-                : cloneDeep(newResult), variables: variables });
-        if (!isNonEmptyArray(newResult.errors)) {
-            delete this.last.error;
+        var error = this.getLastError();
+        if (error && this.last && !equal.equal(variables, this.last.variables)) {
+            error = void 0;
         }
-        return this.last;
+        return this.last = tslib.__assign({ result: this.queryManager.assumeImmutableResults
+                ? newResult
+                : cloneDeep(newResult), variables: variables }, (error ? { error: error } : null));
     };
     ObservableQuery.prototype.reobserveAsConcast = function (newOptions, newNetworkStatus) {
         var _this = this;
@@ -4720,7 +4907,7 @@ var ObservableQuery = (function (_super) {
             this.updatePolling();
             if (newOptions &&
                 newOptions.variables &&
-                !equality.equal(newOptions.variables, oldVariables) &&
+                !equal.equal(newOptions.variables, oldVariables) &&
                 options.fetchPolicy !== "standby" &&
                 options.fetchPolicy === oldFetchPolicy) {
                 this.applyNextFetchPolicy("variables-changed", options);
@@ -4730,7 +4917,7 @@ var ObservableQuery = (function (_super) {
             }
         }
         var variables = options.variables && tslib.__assign({}, options.variables);
-        var concast = this.fetch(options, newNetworkStatus);
+        var _a = this.fetch(options, newNetworkStatus), concast = _a.concast, fromLink = _a.fromLink;
         var observer = {
             next: function (result) {
                 _this.reportResult(result, variables);
@@ -4739,7 +4926,7 @@ var ObservableQuery = (function (_super) {
                 _this.reportError(error, variables);
             },
         };
-        if (!useDisposableConcast) {
+        if (!useDisposableConcast && (fromLink || !this.concast)) {
             if (this.concast && this.observer) {
                 this.concast.removeObserver(this.observer);
             }
@@ -4757,11 +4944,12 @@ var ObservableQuery = (function (_super) {
     };
     ObservableQuery.prototype.reportResult = function (result, variables) {
         var lastError = this.getLastError();
-        if (lastError || this.isDifferentFromLastResult(result, variables)) {
-            if (lastError || !result.partial || this.options.returnPartialData) {
-                this.updateLastResult(result, variables);
-            }
-            iterateObserversSafely(this.observers, 'next', result);
+        var isDifferent = this.isDifferentFromLastResult(result, variables);
+        if (lastError || !result.partial || this.options.returnPartialData) {
+            this.updateLastResult(result, variables);
+        }
+        if (lastError || isDifferent) {
+            iterateObserversSafely(this.observers, "next", result);
         }
     };
     ObservableQuery.prototype.reportError = function (error, variables) {
@@ -5170,10 +5358,10 @@ var QueryInfo = (function () {
         var networkStatus = query.networkStatus || exports.NetworkStatus.loading;
         if (this.variables &&
             this.networkStatus !== exports.NetworkStatus.loading &&
-            !equality.equal(this.variables, query.variables)) {
+            !equal.equal(this.variables, query.variables)) {
             networkStatus = exports.NetworkStatus.setVariables;
         }
-        if (!equality.equal(query.variables, this.variables)) {
+        if (!equal.equal(query.variables, this.variables)) {
             this.lastDiff = void 0;
         }
         Object.assign(this, {
@@ -5198,7 +5386,7 @@ var QueryInfo = (function () {
     QueryInfo.prototype.getDiff = function (variables) {
         if (variables === void 0) { variables = this.variables; }
         var options = this.getDiffOptions(variables);
-        if (this.lastDiff && equality.equal(options, this.lastDiff.options)) {
+        if (this.lastDiff && equal.equal(options, this.lastDiff.options)) {
             return this.lastDiff.diff;
         }
         this.updateWatch(this.variables = variables);
@@ -5232,7 +5420,7 @@ var QueryInfo = (function () {
         var oldDiff = this.lastDiff && this.lastDiff.diff;
         this.updateLastDiff(diff);
         if (!this.dirty &&
-            !equality.equal(oldDiff && oldDiff.result, diff && diff.result)) {
+            !equal.equal(oldDiff && oldDiff.result, diff && diff.result)) {
             this.dirty = true;
             if (!this.notifyTimeout) {
                 this.notifyTimeout = setTimeout(function () { return _this.notify(); }, 0);
@@ -5307,7 +5495,7 @@ var QueryInfo = (function () {
         }
         var watchOptions = tslib.__assign(tslib.__assign({}, this.getDiffOptions(variables)), { watcher: this, callback: function (diff) { return _this.setDiff(diff); } });
         if (!this.lastWatch ||
-            !equality.equal(watchOptions, this.lastWatch)) {
+            !equal.equal(watchOptions, this.lastWatch)) {
             this.cancel();
             this.cancel = this.cache.watch(this.lastWatch = watchOptions);
         }
@@ -5319,8 +5507,8 @@ var QueryInfo = (function () {
         var lastWrite = this.lastWrite;
         return !(lastWrite &&
             lastWrite.dmCount === destructiveMethodCounts.get(this.cache) &&
-            equality.equal(variables, lastWrite.variables) &&
-            equality.equal(result.data, lastWrite.result.data));
+            equal.equal(variables, lastWrite.variables) &&
+            equal.equal(result.data, lastWrite.result.data));
     };
     QueryInfo.prototype.markResult = function (result, document, options, cacheWriteBehavior) {
         var _this = this;
@@ -5412,7 +5600,7 @@ function shouldWriteResult(result, errorPolicy) {
 var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
 var QueryManager = (function () {
     function QueryManager(_a) {
-        var cache = _a.cache, link = _a.link, defaultOptions = _a.defaultOptions, _b = _a.queryDeduplication, queryDeduplication = _b === void 0 ? false : _b, onBroadcast = _a.onBroadcast, _c = _a.ssrMode, ssrMode = _c === void 0 ? false : _c, _d = _a.clientAwareness, clientAwareness = _d === void 0 ? {} : _d, localState = _a.localState, assumeImmutableResults = _a.assumeImmutableResults;
+        var cache = _a.cache, link = _a.link, defaultOptions = _a.defaultOptions, _b = _a.queryDeduplication, queryDeduplication = _b === void 0 ? false : _b, onBroadcast = _a.onBroadcast, _c = _a.ssrMode, ssrMode = _c === void 0 ? false : _c, _d = _a.clientAwareness, clientAwareness = _d === void 0 ? {} : _d, localState = _a.localState, _e = _a.assumeImmutableResults, assumeImmutableResults = _e === void 0 ? !!cache.assumeImmutableResults : _e;
         this.clientAwareness = {};
         this.queries = new Map();
         this.fetchCancelFns = new Map();
@@ -5428,7 +5616,7 @@ var QueryManager = (function () {
         this.clientAwareness = clientAwareness;
         this.localState = localState || new LocalState({ cache: cache });
         this.ssrMode = ssrMode;
-        this.assumeImmutableResults = !!assumeImmutableResults;
+        this.assumeImmutableResults = assumeImmutableResults;
         if ((this.onBroadcast = onBroadcast)) {
             this.mutationStore = Object.create(null);
         }
@@ -5722,14 +5910,17 @@ var QueryManager = (function () {
         var _a = (this.defaultOptions.transformQuery || Object.create(null)).removeClientFields, removeClientFields = _a === void 0 ? true : _a;
         if (!transformCache.has(document)) {
             var transformed = this.cache.transformDocument(document);
-            var noConnection = removeConnectionDirectiveFromDocument(transformed);
+            var serverQuery = removeDirectivesFromDocument([
+                removeClientFields ? { name: 'client', remove: true } : {},
+                { name: 'connection' },
+                { name: 'nonreactive' },
+            ], transformed);
             var clientQuery = this.localState.clientQuery(transformed);
-            var serverQuery = noConnection &&
-                this.localState.serverQuery(noConnection, { removeClientFields: removeClientFields });
             var cacheEntry_1 = {
                 document: transformed,
                 hasClientExports: hasClientExports(transformed),
                 hasForcedResolvers: this.localState.shouldForceResolvers(transformed),
+                hasNonreactiveDirective: hasDirectives(['nonreactive'], transformed),
                 clientQuery: clientQuery,
                 serverQuery: serverQuery,
                 defaultVars: getDefaultValues(getOperationDefinition(transformed)),
@@ -5927,10 +6118,17 @@ var QueryManager = (function () {
                     }
                     _this.broadcastQueries();
                 }
-                if (graphQLResultHasError(result)) {
-                    throw new ApolloError({
-                        graphQLErrors: result.errors,
-                    });
+                var hasErrors = graphQLResultHasError(result);
+                var hasProtocolErrors = graphQLResultHasProtocolErrors(result);
+                if (hasErrors || hasProtocolErrors) {
+                    var errors = {};
+                    if (hasErrors) {
+                        errors.graphQLErrors = result.errors;
+                    }
+                    if (hasProtocolErrors) {
+                        errors.protocolErrors = result.extensions[PROTOCOL_ERRORS_SYMBOL];
+                    }
+                    throw new ApolloError(errors);
                 }
                 return result;
             });
@@ -6062,6 +6260,9 @@ var QueryManager = (function () {
         });
     };
     QueryManager.prototype.fetchQueryObservable = function (queryId, options, networkStatus) {
+        return this.fetchConcastWithInfo(queryId, options, networkStatus).concast;
+    };
+    QueryManager.prototype.fetchConcastWithInfo = function (queryId, options, networkStatus) {
         var _this = this;
         if (networkStatus === void 0) { networkStatus = exports.NetworkStatus.loading; }
         var query = this.transform(options.query).document;
@@ -6080,24 +6281,36 @@ var QueryManager = (function () {
         });
         var fromVariables = function (variables) {
             normalized.variables = variables;
-            var concastSources = _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);
+            var sourcesWithInfo = _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);
             if (normalized.fetchPolicy !== "standby" &&
-                concastSources.length > 0 &&
+                sourcesWithInfo.sources.length > 0 &&
                 queryInfo.observableQuery) {
                 queryInfo.observableQuery["applyNextFetchPolicy"]("after-fetch", options);
             }
-            return concastSources;
+            return sourcesWithInfo;
         };
         var cleanupCancelFn = function () { return _this.fetchCancelFns.delete(queryId); };
         this.fetchCancelFns.set(queryId, function (reason) {
             cleanupCancelFn();
             setTimeout(function () { return concast.cancel(reason); });
         });
-        var concast = new Concast(this.transform(normalized.query).hasClientExports
-            ? this.localState.addExportedVariables(normalized.query, normalized.variables, normalized.context).then(fromVariables)
-            : fromVariables(normalized.variables));
+        var concast, containsDataFromLink;
+        if (this.transform(normalized.query).hasClientExports) {
+            concast = new Concast(this.localState
+                .addExportedVariables(normalized.query, normalized.variables, normalized.context)
+                .then(fromVariables).then(function (sourcesWithInfo) { return sourcesWithInfo.sources; }));
+            containsDataFromLink = true;
+        }
+        else {
+            var sourcesWithInfo = fromVariables(normalized.variables);
+            containsDataFromLink = sourcesWithInfo.fromLink;
+            concast = new Concast(sourcesWithInfo.sources);
+        }
         concast.promise.then(cleanupCancelFn, cleanupCancelFn);
-        return concast;
+        return {
+            concast: concast,
+            fromLink: containsDataFromLink,
+        };
     };
     QueryManager.prototype.refetchQueries = function (_a) {
         var _this = this;
@@ -6182,7 +6395,7 @@ var QueryManager = (function () {
             var data = diff.result;
             if (__DEV__ &&
                 !returnPartialData &&
-                !equality.equal(data, {})) {
+                !equal.equal(data, {})) {
                 logMissingFieldErrors(diff.missing);
             }
             var fromData = function (data) { return zenObservableTs.Observable.of(tslib.__assign({ data: data, loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus }, (diff.complete ? null : { partial: true }))); };
@@ -6221,54 +6434,40 @@ var QueryManager = (function () {
             case "cache-first": {
                 var diff = readCache();
                 if (diff.complete) {
-                    return [
-                        resultsFromCache(diff, queryInfo.markReady()),
-                    ];
+                    return { fromLink: false, sources: [resultsFromCache(diff, queryInfo.markReady())] };
                 }
                 if (returnPartialData || shouldNotify) {
-                    return [
-                        resultsFromCache(diff),
-                        resultsFromLink(),
-                    ];
+                    return { fromLink: true, sources: [resultsFromCache(diff), resultsFromLink()] };
                 }
-                return [
-                    resultsFromLink(),
-                ];
+                return { fromLink: true, sources: [resultsFromLink()] };
             }
             case "cache-and-network": {
                 var diff = readCache();
                 if (diff.complete || returnPartialData || shouldNotify) {
-                    return [
-                        resultsFromCache(diff),
-                        resultsFromLink(),
-                    ];
+                    return { fromLink: true, sources: [resultsFromCache(diff), resultsFromLink()] };
                 }
-                return [
-                    resultsFromLink(),
-                ];
+                return { fromLink: true, sources: [resultsFromLink()] };
             }
             case "cache-only":
-                return [
-                    resultsFromCache(readCache(), queryInfo.markReady()),
-                ];
+                return { fromLink: false, sources: [resultsFromCache(readCache(), queryInfo.markReady())] };
             case "network-only":
                 if (shouldNotify) {
-                    return [
-                        resultsFromCache(readCache()),
-                        resultsFromLink(),
-                    ];
+                    return { fromLink: true, sources: [resultsFromCache(readCache()), resultsFromLink()] };
                 }
-                return [resultsFromLink()];
+                return { fromLink: true, sources: [resultsFromLink()] };
             case "no-cache":
                 if (shouldNotify) {
-                    return [
-                        resultsFromCache(queryInfo.getDiff()),
-                        resultsFromLink(),
-                    ];
+                    return {
+                        fromLink: true,
+                        sources: [
+                            resultsFromCache(queryInfo.getDiff()),
+                            resultsFromLink(),
+                        ],
+                    };
                 }
-                return [resultsFromLink()];
+                return { fromLink: true, sources: [resultsFromLink()] };
             case "standby":
-                return [];
+                return { fromLink: false, sources: [] };
         }
     };
     QueryManager.prototype.getQuery = function (queryId) {
@@ -6291,20 +6490,20 @@ var ApolloClient = (function () {
         var _this = this;
         this.resetStoreCallbacks = [];
         this.clearStoreCallbacks = [];
+        if (!options.cache) {
+            throw __DEV__ ? new tsInvariant.InvariantError("To initialize Apollo Client, you must specify a 'cache' property " +
+                "in the options object. \n" +
+                "For more information, please visit: https://go.apollo.dev/c/docs") : new tsInvariant.InvariantError(9);
+        }
         var uri = options.uri, credentials = options.credentials, headers = options.headers, cache = options.cache, _a = options.ssrMode, ssrMode = _a === void 0 ? false : _a, _b = options.ssrForceFetchDelay, ssrForceFetchDelay = _b === void 0 ? 0 : _b, _c = options.connectToDevTools, connectToDevTools = _c === void 0 ? typeof window === 'object' &&
             !window.__APOLLO_CLIENT__ &&
-            __DEV__ : _c, _d = options.queryDeduplication, queryDeduplication = _d === void 0 ? true : _d, defaultOptions = options.defaultOptions, _e = options.assumeImmutableResults, assumeImmutableResults = _e === void 0 ? false : _e, resolvers = options.resolvers, typeDefs = options.typeDefs, fragmentMatcher = options.fragmentMatcher, clientAwarenessName = options.name, clientAwarenessVersion = options.version;
+            __DEV__ : _c, _d = options.queryDeduplication, queryDeduplication = _d === void 0 ? true : _d, defaultOptions = options.defaultOptions, _e = options.assumeImmutableResults, assumeImmutableResults = _e === void 0 ? cache.assumeImmutableResults : _e, resolvers = options.resolvers, typeDefs = options.typeDefs, fragmentMatcher = options.fragmentMatcher, clientAwarenessName = options.name, clientAwarenessVersion = options.version;
         var link = options.link;
         if (!link) {
             link = uri
                 ? new HttpLink({ uri: uri, credentials: credentials, headers: headers })
                 : ApolloLink.empty();
         }
-        if (!cache) {
-            throw __DEV__ ? new tsInvariant.InvariantError("To initialize Apollo Client, you must specify a 'cache' property " +
-                "in the options object. \n" +
-                "For more information, please visit: https://go.apollo.dev/c/docs") : new tsInvariant.InvariantError(9);
-        }
         this.link = link;
         this.cache = cache;
         this.disableNetworkFetches = ssrMode || ssrForceFetchDelay > 0;
@@ -6542,7 +6741,7 @@ var ApolloConsumer = function (props) {
     var ApolloContext = getApolloContext();
     return (React__namespace.createElement(ApolloContext.Consumer, null, function (context) {
         __DEV__ ? tsInvariant.invariant(context && context.client, 'Could not find "client" in the context of ApolloConsumer. ' +
-            'Wrap the root component in an <ApolloProvider>.') : tsInvariant.invariant(context && context.client, 28);
+            'Wrap the root component in an <ApolloProvider>.') : tsInvariant.invariant(context && context.client, 29);
         return props.children(context.client);
     }));
 };
@@ -6559,7 +6758,7 @@ var ApolloProvider = function (_a) {
             context = Object.assign({}, context, { suspenseCache: suspenseCache });
         }
         __DEV__ ? tsInvariant.invariant(context.client, 'ApolloProvider was not passed a client instance. Make ' +
-            'sure you pass in your client via the "client" prop.') : tsInvariant.invariant(context.client, 29);
+            'sure you pass in your client via the "client" prop.') : tsInvariant.invariant(context.client, 30);
         return (React__namespace.createElement(ApolloContext.Provider, { value: context }, children));
     }));
 };
@@ -6569,14 +6768,14 @@ function useApolloClient(override) {
     var client = override || context.client;
     __DEV__ ? tsInvariant.invariant(!!client, 'Could not find "client" in the context or passed in as an option. ' +
         'Wrap the root component in an <ApolloProvider>, or pass an ApolloClient ' +
-        'instance in via options.') : tsInvariant.invariant(!!client, 32);
+        'instance in via options.') : tsInvariant.invariant(!!client, 33);
     return client;
 }
 
 var didWarnUncachedGetSnapshot = false;
 var uSESKey = "useSyncExternalStore";
-var realHook = React__namespace[uSESKey];
-var useSyncExternalStore = realHook || (function (subscribe, getSnapshot, getServerSnapshot) {
+var realHook$1 = React__namespace[uSESKey];
+var useSyncExternalStore = realHook$1 || (function (subscribe, getSnapshot, getServerSnapshot) {
     var value = getSnapshot();
     if (__DEV__ &&
         !didWarnUncachedGetSnapshot &&
@@ -6647,7 +6846,7 @@ function parser(document) {
     var variables, type, name;
     __DEV__ ? tsInvariant.invariant(!!document && !!document.kind, "Argument of ".concat(document, " passed to parser was not a valid GraphQL ") +
         "DocumentNode. You may need to use 'graphql-tag' or another method " +
-        "to convert your operation into a document") : tsInvariant.invariant(!!document && !!document.kind, 35);
+        "to convert your operation into a document") : tsInvariant.invariant(!!document && !!document.kind, 36);
     var fragments = [];
     var queries = [];
     var mutations = [];
@@ -6675,11 +6874,11 @@ function parser(document) {
     __DEV__ ? tsInvariant.invariant(!fragments.length ||
         (queries.length || mutations.length || subscriptions.length), "Passing only a fragment to 'graphql' is not yet supported. " +
         "You must include a query, subscription or mutation as well") : tsInvariant.invariant(!fragments.length ||
-        (queries.length || mutations.length || subscriptions.length), 36);
+        (queries.length || mutations.length || subscriptions.length), 37);
     __DEV__ ? tsInvariant.invariant(queries.length + mutations.length + subscriptions.length <= 1, "react-apollo only supports a query, subscription, or a mutation per HOC. " +
         "".concat(document, " had ").concat(queries.length, " queries, ").concat(subscriptions.length, " ") +
         "subscriptions and ".concat(mutations.length, " mutations. ") +
-        "You can use 'compose' to join multiple operation types to a component") : tsInvariant.invariant(queries.length + mutations.length + subscriptions.length <= 1, 37);
+        "You can use 'compose' to join multiple operation types to a component") : tsInvariant.invariant(queries.length + mutations.length + subscriptions.length <= 1, 38);
     type = queries.length ? exports.DocumentType.Query : exports.DocumentType.Mutation;
     if (!queries.length && !mutations.length)
         type = exports.DocumentType.Subscription;
@@ -6690,7 +6889,7 @@ function parser(document) {
             : subscriptions;
     __DEV__ ? tsInvariant.invariant(definitions.length === 1, "react-apollo only supports one definition per HOC. ".concat(document, " had ") +
         "".concat(definitions.length, " definitions. ") +
-        "You can use 'compose' to join multiple operation types to a component") : tsInvariant.invariant(definitions.length === 1, 38);
+        "You can use 'compose' to join multiple operation types to a component") : tsInvariant.invariant(definitions.length === 1, 39);
     var definition = definitions[0];
     variables = definition.variableDefinitions || [];
     if (definition.name && definition.name.kind === 'Name') {
@@ -6708,7 +6907,7 @@ function verifyDocumentType(document, type) {
     var requiredOperationName = operationName(type);
     var usedOperationName = operationName(operation.type);
     __DEV__ ? tsInvariant.invariant(operation.type === type, "Running a ".concat(requiredOperationName, " requires a graphql ") +
-        "".concat(requiredOperationName, ", but a ").concat(usedOperationName, " was used instead.")) : tsInvariant.invariant(operation.type === type, 39);
+        "".concat(requiredOperationName, ", but a ").concat(usedOperationName, " was used instead.")) : tsInvariant.invariant(operation.type === type, 40);
 }
 
 var hasOwnProperty = Object.prototype.hasOwnProperty;
@@ -6734,8 +6933,6 @@ var InternalState = (function () {
     function InternalState(client, query, previous) {
         this.client = client;
         this.query = query;
-        this.asyncResolveFns = new Set();
-        this.optionsToIgnoreOnce = new (canUseWeakSet ? WeakSet : Set)();
         this.ssrDisabledResult = maybeDeepFreeze({
             loading: true,
             data: void 0,
@@ -6759,20 +6956,30 @@ var InternalState = (function () {
     InternalState.prototype.forceUpdate = function () {
         __DEV__ && tsInvariant.invariant.warn("Calling default no-op implementation of InternalState#forceUpdate");
     };
-    InternalState.prototype.asyncUpdate = function (signal) {
+    InternalState.prototype.executeQuery = function (options) {
         var _this = this;
-        return new Promise(function (resolve, reject) {
-            var watchQueryOptions = _this.watchQueryOptions;
-            var handleAborted = function () {
-                _this.asyncResolveFns.delete(resolve);
-                _this.optionsToIgnoreOnce.delete(watchQueryOptions);
-                signal.removeEventListener('abort', handleAborted);
-                reject(signal.reason);
-            };
-            _this.asyncResolveFns.add(resolve);
-            _this.optionsToIgnoreOnce.add(watchQueryOptions);
-            signal.addEventListener('abort', handleAborted);
-            _this.forceUpdate();
+        var _a;
+        if (options.query) {
+            Object.assign(this, { query: options.query });
+        }
+        this.watchQueryOptions = this.createWatchQueryOptions(this.queryHookOptions = options);
+        var concast = this.observable.reobserveAsConcast(this.getObsQueryOptions());
+        this.previousData = ((_a = this.result) === null || _a === void 0 ? void 0 : _a.data) || this.previousData;
+        this.result = void 0;
+        this.forceUpdate();
+        return new Promise(function (resolve) {
+            var result;
+            concast.subscribe({
+                next: function (value) {
+                    result = value;
+                },
+                error: function () {
+                    resolve(_this.toQueryResult(_this.observable.getCurrentResult()));
+                },
+                complete: function () {
+                    resolve(_this.toQueryResult(result));
+                }
+            });
         });
     };
     InternalState.prototype.useQuery = function (options) {
@@ -6790,7 +6997,7 @@ var InternalState = (function () {
                 if (previousResult &&
                     previousResult.loading === result.loading &&
                     previousResult.networkStatus === result.networkStatus &&
-                    equality.equal(previousResult.data, result.data)) {
+                    equal.equal(previousResult.data, result.data)) {
                     return;
                 }
                 _this.setResult(result);
@@ -6811,7 +7018,7 @@ var InternalState = (function () {
                 var previousResult = _this.result;
                 if (!previousResult ||
                     (previousResult && previousResult.loading) ||
-                    !equality.equal(error, previousResult.error)) {
+                    !equal.equal(error, previousResult.error)) {
                     _this.setResult({
                         data: (previousResult && previousResult.data),
                         error: error,
@@ -6828,22 +7035,15 @@ var InternalState = (function () {
             this.client.disableNetworkFetches,
         ]), function () { return _this.getCurrentResult(); }, function () { return _this.getCurrentResult(); });
         this.unsafeHandlePartialRefetch(result);
-        var queryResult = this.toQueryResult(result);
-        if (!queryResult.loading && this.asyncResolveFns.size) {
-            this.asyncResolveFns.forEach(function (resolve) { return resolve(queryResult); });
-            this.asyncResolveFns.clear();
-        }
-        return queryResult;
+        return this.toQueryResult(result);
     };
     InternalState.prototype.useOptions = function (options) {
         var _a;
         var watchQueryOptions = this.createWatchQueryOptions(this.queryHookOptions = options);
         var currentWatchQueryOptions = this.watchQueryOptions;
-        if (this.optionsToIgnoreOnce.has(currentWatchQueryOptions) ||
-            !equality.equal(watchQueryOptions, currentWatchQueryOptions)) {
+        if (!equal.equal(watchQueryOptions, currentWatchQueryOptions)) {
             this.watchQueryOptions = watchQueryOptions;
             if (currentWatchQueryOptions && this.observable) {
-                this.optionsToIgnoreOnce.delete(currentWatchQueryOptions);
                 this.observable.reobserve(this.getObsQueryOptions());
                 this.previousData = ((_a = this.result) === null || _a === void 0 ? void 0 : _a.data) || this.previousData;
                 this.result = void 0;
@@ -7010,11 +7210,15 @@ var EAGER_METHODS = [
     'subscribeToMore',
 ];
 function useLazyQuery(query, options) {
-    var _a, _b;
-    var abortControllersRef = React.useRef(new Set());
+    var _a;
     var execOptionsRef = React.useRef();
-    var merged = execOptionsRef.current ? mergeOptions(options, execOptionsRef.current) : options;
-    var internalState = useInternalState(useApolloClient(options && options.client), (_b = (_a = execOptionsRef.current) === null || _a === void 0 ? void 0 : _a.query) !== null && _b !== void 0 ? _b : query);
+    var optionsRef = React.useRef();
+    var queryRef = React.useRef();
+    var merged = mergeOptions(options, execOptionsRef.current || {});
+    var document = (_a = merged === null || merged === void 0 ? void 0 : merged.query) !== null && _a !== void 0 ? _a : query;
+    optionsRef.current = merged;
+    queryRef.current = document;
+    var internalState = useInternalState(useApolloClient(options && options.client), document);
     var useQueryResult = internalState.useQuery(tslib.__assign(tslib.__assign({}, merged), { skip: !execOptionsRef.current }));
     var initialFetchPolicy = useQueryResult.observable.options.initialFetchPolicy ||
         internalState.getDefaultFetchPolicy();
@@ -7040,28 +7244,15 @@ function useLazyQuery(query, options) {
         return eagerMethods;
     }, []);
     Object.assign(result, eagerMethods);
-    React.useEffect(function () {
-        return function () {
-            abortControllersRef.current.forEach(function (controller) {
-                controller.abort();
-            });
-        };
-    }, []);
     var execute = React.useCallback(function (executeOptions) {
-        var controller = new AbortController();
-        abortControllersRef.current.add(controller);
         execOptionsRef.current = executeOptions ? tslib.__assign(tslib.__assign({}, executeOptions), { fetchPolicy: executeOptions.fetchPolicy || initialFetchPolicy }) : {
             fetchPolicy: initialFetchPolicy,
         };
+        var options = mergeOptions(optionsRef.current, tslib.__assign({ query: queryRef.current }, execOptionsRef.current));
         var promise = internalState
-            .asyncUpdate(controller.signal)
-            .then(function (queryResult) {
-            abortControllersRef.current.delete(controller);
-            return Object.assign(queryResult, eagerMethods);
-        });
-        promise.catch(function () {
-            abortControllersRef.current.delete(controller);
-        });
+            .executeQuery(tslib.__assign(tslib.__assign({}, options), { skip: false }))
+            .then(function (queryResult) { return Object.assign(queryResult, eagerMethods); });
+        promise.catch(function () { });
         return promise;
     }, []);
     return [execute, result];
@@ -7117,7 +7308,7 @@ function useMutation(mutation, options) {
                     error: error,
                     client: client,
                 };
-                if (ref.current.isMounted && !equality.equal(ref.current.result, result_1)) {
+                if (ref.current.isMounted && !equal.equal(ref.current.result, result_1)) {
                     setResult(ref.current.result = result_1);
                 }
             }
@@ -7135,7 +7326,7 @@ function useMutation(mutation, options) {
                     called: true,
                     client: client,
                 };
-                if (!equality.equal(ref.current.result, result_2)) {
+                if (!equal.equal(ref.current.result, result_2)) {
                     setResult(ref.current.result = result_2);
                 }
             }
@@ -7225,7 +7416,7 @@ function useSubscription(subscription, options) {
                 subscription !== ref.current.subscription ||
                 (options === null || options === void 0 ? void 0 : options.fetchPolicy) !== ((_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.fetchPolicy) ||
                 !(options === null || options === void 0 ? void 0 : options.skip) !== !((_c = ref.current.options) === null || _c === void 0 ? void 0 : _c.skip) ||
-                !equality.equal(options === null || options === void 0 ? void 0 : options.variables, (_d = ref.current.options) === null || _d === void 0 ? void 0 : _d.variables))) ||
+                !equal.equal(options === null || options === void 0 ? void 0 : options.variables, (_d = ref.current.options) === null || _d === void 0 ? void 0 : _d.variables))) ||
             canResetObservableRef.current) {
             setResult({
                 loading: true,
@@ -7321,13 +7512,13 @@ function useFragment_experimental(options) {
     var getSnapshot = function () {
         var latestDiffToResult = diffToResult(latestDiff);
         return resultRef.current &&
-            equality.equal(resultRef.current.data, latestDiffToResult.data)
+            equal.equal(resultRef.current.data, latestDiffToResult.data)
             ? resultRef.current
             : (resultRef.current = latestDiffToResult);
     };
     return useSyncExternalStore(function (forceUpdate) {
         return cache.watch(tslib.__assign(tslib.__assign({}, diffOptions), { immediate: true, callback: function (diff) {
-                if (!equality.equal(diff, latestDiff)) {
+                if (!equal.equal(diff, latestDiff)) {
                     resultRef.current = diffToResult((latestDiff = diff));
                     forceUpdate();
                 }
@@ -7347,130 +7538,110 @@ function diffToResult(diff) {
 
 function useDeepMemo(memoFn, deps) {
     var ref = React.useRef();
-    if (!ref.current || !equality.equal(ref.current.deps, deps)) {
+    if (!ref.current || !equal.equal(ref.current.deps, deps)) {
         ref.current = { value: memoFn(), deps: deps };
     }
     return ref.current.value;
 }
 
-var useIsomorphicLayoutEffect = canUseLayoutEffect
-    ? React.useLayoutEffect
-    : React.useEffect;
+function useStrictModeSafeCleanupEffect(cleanup) {
+    var timeout;
+    React.useEffect(function () {
+        clearTimeout(timeout);
+        return function () {
+            timeout = setTimeout(cleanup);
+        };
+    }, []);
+}
+
+var useKey = 'use';
+var realHook = React__default[useKey];
+var __use = realHook ||
+    function __use(promise) {
+        var statefulPromise = wrapPromiseWithState(promise);
+        switch (statefulPromise.status) {
+            case 'pending':
+                throw statefulPromise;
+            case 'rejected':
+                throw statefulPromise.reason;
+            case 'fulfilled':
+                return statefulPromise.value;
+        }
+    };
 
 function useSuspenseCache(override) {
     var context = React.useContext(getApolloContext());
     var suspenseCache = override || context.suspenseCache;
     __DEV__ ? tsInvariant.invariant(suspenseCache, 'Could not find a "suspenseCache" in the context or passed in as an option. ' +
         'Wrap the root component in an <ApolloProvider> and provide a suspenseCache, ' +
-        'or pass a SuspenseCache instance in via options.') : tsInvariant.invariant(suspenseCache, 33);
+        'or pass a SuspenseCache instance in via options.') : tsInvariant.invariant(suspenseCache, 34);
     return suspenseCache;
 }
 
-var SUPPORTED_FETCH_POLICIES = [
-    'cache-first',
-    'network-only',
-    'no-cache',
-    'cache-and-network',
-];
-var DEFAULT_FETCH_POLICY = 'cache-first';
-var DEFAULT_SUSPENSE_POLICY = 'always';
-var DEFAULT_ERROR_POLICY = 'none';
 function useSuspenseQuery_experimental(query, options) {
     if (options === void 0) { options = Object.create(null); }
-    var suspenseCache = useSuspenseCache(options.suspenseCache);
+    var didPreviouslySuspend = React.useRef(false);
     var client = useApolloClient(options.client);
-    var watchQueryOptions = useWatchQueryOptions({ query: query, options: options, client: client });
-    var previousWatchQueryOptionsRef = React.useRef(watchQueryOptions);
-    var deferred = useIsDeferred(query);
-    var fetchPolicy = watchQueryOptions.fetchPolicy, errorPolicy = watchQueryOptions.errorPolicy, returnPartialData = watchQueryOptions.returnPartialData, variables = watchQueryOptions.variables;
-    var cacheEntry = suspenseCache.lookup(query, variables);
-    var observable = React.useState(function () {
-        return (cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.observable) || client.watchQuery(watchQueryOptions);
-    })[0];
-    var result = useObservableQueryResult(observable);
-    var hasFullResult = result.data && !result.partial;
-    var hasPartialResult = result.data && result.partial;
-    var usePartialResult = returnPartialData && hasPartialResult;
-    var allowsThrownErrors = errorPolicy === 'none' && (!deferred || !hasPartialResult);
-    if (result.error &&
-        (result.error.networkError || allowsThrownErrors)) {
-        throw result.error;
-    }
-    if (result.loading) {
-        if (!cacheEntry) {
-            cacheEntry = suspenseCache.add(query, variables, {
-                promise: maybeWrapConcastWithCustomPromise(observable.reobserveAsConcast(watchQueryOptions), { deferred: deferred }),
-                observable: observable,
-            });
-        }
-        var hasUsableResult = usePartialResult ||
-            (fetchPolicy === 'cache-and-network' && hasFullResult);
-        if (!hasUsableResult && !cacheEntry.fulfilled) {
-            throw cacheEntry.promise;
-        }
-    }
-    React.useEffect(function () {
-        var variables = watchQueryOptions.variables, query = watchQueryOptions.query;
-        var previousOpts = previousWatchQueryOptionsRef.current;
-        if (variables !== previousOpts.variables || query !== previousOpts.query) {
-            suspenseCache.remove(previousOpts.query, previousOpts.variables);
-            suspenseCache.add(query, variables, {
-                promise: observable.reobserve({ query: query, variables: variables }),
-                observable: observable,
-            });
-            previousWatchQueryOptionsRef.current = watchQueryOptions;
-        }
-    }, [watchQueryOptions]);
-    React.useEffect(function () {
-        return function () {
-            suspenseCache.remove(query, variables);
-        };
-    }, []);
-    var fetchMore = React.useCallback(function (options) {
-        var promise = observable.fetchMore(options);
-        suspenseCache.add(query, watchQueryOptions.variables, {
-            promise: promise,
-            observable: observable,
-        });
-        return promise;
-    }, [observable]);
-    var refetch = React.useCallback(function (variables) {
-        var promise = observable.refetch(variables);
-        suspenseCache.add(query, watchQueryOptions.variables, {
-            promise: promise,
-            observable: observable,
-        });
-        return promise;
-    }, [observable]);
-    var subscribeToMore = React.useCallback(function (options) { return observable.subscribeToMore(options); }, [observable]);
+    var suspenseCache = useSuspenseCache(options.suspenseCache);
+    var watchQueryOptions = useWatchQueryOptions({ query: query, options: options });
+    var _a = watchQueryOptions.returnPartialData, returnPartialData = _a === void 0 ? false : _a, variables = watchQueryOptions.variables;
+    var _b = options.suspensePolicy, suspensePolicy = _b === void 0 ? 'always' : _b, _c = options.queryKey, queryKey = _c === void 0 ? [] : _c;
+    var shouldSuspend = suspensePolicy === 'always' || !didPreviouslySuspend.current;
+    var cacheKey = [client, query, canonicalStringify(variables)].concat(queryKey);
+    var subscription = suspenseCache.getSubscription(cacheKey, function () {
+        return client.watchQuery(watchQueryOptions);
+    });
+    var dispose = useTrackedSubscriptions(subscription);
+    useStrictModeSafeCleanupEffect(dispose);
+    var result = useSyncExternalStore(subscription.listen, function () { return subscription.result; }, function () { return subscription.result; });
+    var previousVariables = React.useRef(variables);
+    var previousData = React.useRef(result.data);
+    if (!equal.equal(variables, previousVariables.current)) {
+        if (result.networkStatus !== exports.NetworkStatus.ready) {
+            result = tslib.__assign(tslib.__assign({}, result), { data: previousData.current, networkStatus: exports.NetworkStatus.setVariables });
+        }
+        previousVariables.current = variables;
+        previousData.current = result.data;
+    }
+    if (result.networkStatus === exports.NetworkStatus.error ||
+        (shouldSuspend &&
+            !shouldUseCachedResult(subscription.result, {
+                returnPartialData: returnPartialData,
+                fetchPolicy: options.fetchPolicy,
+            }))) {
+        __use(subscription.promise);
+    }
+    didPreviouslySuspend.current = true;
+    var fetchMore = React.useCallback(function (options) { return subscription.fetchMore(options); }, [subscription]);
+    var refetch = React.useCallback(function (variables) { return subscription.refetch(variables); }, [subscription]);
+    var subscribeToMore = React.useCallback(function (options) { return subscription.observable.subscribeToMore(options); }, [subscription]);
     return React.useMemo(function () {
         return {
             client: client,
             data: result.data,
-            error: errorPolicy === 'ignore' ? void 0 : toApolloError(result),
+            error: toApolloError(result),
             networkStatus: result.networkStatus,
             fetchMore: fetchMore,
             refetch: refetch,
             subscribeToMore: subscribeToMore,
         };
-    }, [
-        client,
-        fetchMore,
-        refetch,
-        result,
-        observable,
-        errorPolicy,
-        subscribeToMore,
-    ]);
+    }, [client, fetchMore, refetch, result, subscribeToMore]);
 }
 function validateOptions(options) {
-    var query = options.query, _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? DEFAULT_FETCH_POLICY : _a, returnPartialData = options.returnPartialData;
+    var query = options.query, fetchPolicy = options.fetchPolicy, returnPartialData = options.returnPartialData;
     verifyDocumentType(query, exports.DocumentType.Query);
     validateFetchPolicy(fetchPolicy);
     validatePartialDataReturn(fetchPolicy, returnPartialData);
 }
 function validateFetchPolicy(fetchPolicy) {
-    __DEV__ ? tsInvariant.invariant(SUPPORTED_FETCH_POLICIES.includes(fetchPolicy), "The fetch policy `".concat(fetchPolicy, "` is not supported with suspense.")) : tsInvariant.invariant(SUPPORTED_FETCH_POLICIES.includes(fetchPolicy), 34);
+    if (fetchPolicy === void 0) { fetchPolicy = 'cache-first'; }
+    var supportedFetchPolicies = [
+        'cache-first',
+        'network-only',
+        'no-cache',
+        'cache-and-network',
+    ];
+    __DEV__ ? tsInvariant.invariant(supportedFetchPolicies.includes(fetchPolicy), "The fetch policy `".concat(fetchPolicy, "` is not supported with suspense.")) : tsInvariant.invariant(supportedFetchPolicies.includes(fetchPolicy), 35);
 }
 function validatePartialDataReturn(fetchPolicy, returnPartialData) {
     if (fetchPolicy === 'no-cache' && returnPartialData) {
@@ -7482,125 +7653,137 @@ function toApolloError(result) {
         ? new ApolloError({ graphQLErrors: result.errors })
         : result.error;
 }
-function maybeWrapConcastWithCustomPromise(concast, _a) {
-    var deferred = _a.deferred;
-    if (deferred) {
-        return new Promise(function (resolve, reject) {
-            var subscription = concast.subscribe({
-                next: function (value) {
-                    resolve(value);
-                    subscription.unsubscribe();
-                },
-                error: reject,
-            });
-        });
-    }
-    return concast.promise;
+function useTrackedSubscriptions(subscription) {
+    var trackedSubscriptions = React.useRef(new Set());
+    trackedSubscriptions.current.add(subscription);
+    return function dispose() {
+        trackedSubscriptions.current.forEach(function (sub) { return sub.dispose(); });
+    };
 }
 function useWatchQueryOptions(_a) {
-    var query = _a.query, options = _a.options, client = _a.client;
-    var defaultOptions = client.defaultOptions.watchQuery;
-    var watchQueryOptions = useDeepMemo(function () {
-        var errorPolicy = options.errorPolicy, fetchPolicy = options.fetchPolicy, _a = options.suspensePolicy, suspensePolicy = _a === void 0 ? DEFAULT_SUSPENSE_POLICY : _a, variables = options.variables, watchQueryOptions = tslib.__rest(options, ["errorPolicy", "fetchPolicy", "suspensePolicy", "variables"]);
-        return tslib.__assign(tslib.__assign({}, watchQueryOptions), { query: query, errorPolicy: errorPolicy || (defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.errorPolicy) || DEFAULT_ERROR_POLICY, fetchPolicy: fetchPolicy || (defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.fetchPolicy) || DEFAULT_FETCH_POLICY, notifyOnNetworkStatusChange: suspensePolicy === 'always', fetchOnFirstSubscribe: false, variables: compact(tslib.__assign(tslib.__assign({}, defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.variables), variables)) });
-    }, [options, query, defaultOptions]);
+    var query = _a.query, options = _a.options;
+    var watchQueryOptions = useDeepMemo(function () { return (tslib.__assign(tslib.__assign({}, options), { query: query, notifyOnNetworkStatusChange: true, nextFetchPolicy: void 0 })); }, [options, query]);
     if (__DEV__) {
         validateOptions(watchQueryOptions);
     }
     return watchQueryOptions;
 }
-function useIsDeferred(query) {
-    return React.useMemo(function () { return hasDirectives(['defer'], query); }, [query]);
-}
-function useObservableQueryResult(observable) {
-    var resultRef = React.useRef();
-    var isMountedRef = React.useRef(false);
-    var subscribeTimeoutRef = React.useRef();
-    if (!resultRef.current) {
-        resultRef.current = observable.getCurrentResult();
+function shouldUseCachedResult(result, _a) {
+    var returnPartialData = _a.returnPartialData, fetchPolicy = _a.fetchPolicy;
+    if (result.networkStatus === exports.NetworkStatus.refetch ||
+        result.networkStatus === exports.NetworkStatus.fetchMore ||
+        result.networkStatus === exports.NetworkStatus.error) {
+        return false;
     }
-    useIsomorphicLayoutEffect(function () {
-        isMountedRef.current = true;
-        return function () {
-            isMountedRef.current = false;
-        };
-    }, []);
-    return useSyncExternalStore(React.useCallback(function (forceUpdate) {
-        clearTimeout(subscribeTimeoutRef.current);
-        function handleUpdate() {
-            var previousResult = resultRef.current;
-            var result = observable.getCurrentResult();
-            if (previousResult.loading === result.loading &&
-                previousResult.networkStatus === result.networkStatus &&
-                equality.equal(previousResult.data, result.data)) {
-                return;
-            }
-            resultRef.current = result;
-            if (isMountedRef.current) {
-                forceUpdate();
-            }
+    switch (fetchPolicy) {
+        case void 0:
+        case 'cache-first':
+        case 'cache-and-network': {
+            return Boolean(result.data && (!result.partial || returnPartialData));
         }
-        var subscription;
-        subscribeTimeoutRef.current = setTimeout(function () {
-            subscription = observable.subscribe({
-                next: handleUpdate,
-                error: handleUpdate,
-            });
-            var result = resultRef.current;
-            if (result.networkStatus !== observable['queryInfo'].networkStatus &&
-                result.networkStatus === exports.NetworkStatus.ready) {
-                observable['queryInfo'].markReady();
-            }
-        });
-        return function () {
-            subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
-        };
-    }, [observable]), function () { return resultRef.current; }, function () { return resultRef.current; });
+        default:
+            return false;
+    }
 }
 
-var SuspenseCache = (function () {
-    function SuspenseCache() {
-        this.queries = new Map();
-    }
-    SuspenseCache.prototype.add = function (query, variables, _a) {
-        var promise = _a.promise, observable = _a.observable;
-        var variablesKey = this.getVariablesKey(variables);
-        var map = this.queries.get(query) || new Map();
-        var entry = {
-            observable: observable,
-            fulfilled: false,
-            promise: promise
-                .catch(function () {
-            })
-                .finally(function () {
-                entry.fulfilled = true;
-            }),
+function wrapWithCustomPromise(concast) {
+    return new Promise(function (resolve, reject) {
+        var subscription = concast.subscribe({
+            next: function (value) {
+                resolve(value);
+                subscription.unsubscribe();
+            },
+            error: reject,
+        });
+    });
+}
+var isMultipartQuery = optimism.wrap(function (query) {
+    return hasAnyDirectives(['defer', 'stream'], query);
+});
+var QuerySubscription = (function () {
+    function QuerySubscription(observable, options) {
+        if (options === void 0) { options = Object.create(null); }
+        var _a;
+        this.listeners = new Set();
+        this.listen = this.listen.bind(this);
+        this.handleNext = this.handleNext.bind(this);
+        this.handleError = this.handleError.bind(this);
+        this.dispose = this.dispose.bind(this);
+        this.observable = observable;
+        this.result = observable.getCurrentResult();
+        if (options.onDispose) {
+            this.onDispose = options.onDispose;
+        }
+        this.subscription = observable.subscribe({
+            next: this.handleNext,
+            error: this.handleError,
+        });
+        __DEV__ ? tsInvariant.invariant(observable['concast'], 'Unexpected error: A concast was not found on the observable.') : tsInvariant.invariant(observable['concast'], 28);
+        var concast = observable['concast'];
+        this.promise = isMultipartQuery(observable.query)
+            ? wrapWithCustomPromise(concast)
+            : concast.promise;
+        this.autoDisposeTimeoutId = setTimeout(this.dispose, (_a = options.autoDisposeTimeoutMs) !== null && _a !== void 0 ? _a : 30000);
+    }
+    QuerySubscription.prototype.listen = function (listener) {
+        var _this = this;
+        clearTimeout(this.autoDisposeTimeoutId);
+        this.listeners.add(listener);
+        return function () {
+            _this.listeners.delete(listener);
         };
-        map.set(variablesKey, entry);
-        this.queries.set(query, map);
-        return entry;
     };
-    SuspenseCache.prototype.lookup = function (query, variables) {
-        var _a;
-        return (_a = this.queries
-            .get(query)) === null || _a === void 0 ? void 0 : _a.get(this.getVariablesKey(variables));
+    QuerySubscription.prototype.refetch = function (variables) {
+        this.promise = this.observable.refetch(variables);
+        return this.promise;
     };
-    SuspenseCache.prototype.remove = function (query, variables) {
-        var map = this.queries.get(query);
-        if (!map) {
-            return;
-        }
-        var key = this.getVariablesKey(variables);
-        var entry = map.get(key);
-        if (entry && !entry.observable.hasObservers()) {
-            map.delete(key);
-        }
-        if (map.size === 0) {
-            this.queries.delete(query);
+    QuerySubscription.prototype.fetchMore = function (options) {
+        this.promise = this.observable.fetchMore(options);
+        return this.promise;
+    };
+    QuerySubscription.prototype.dispose = function () {
+        this.subscription.unsubscribe();
+        this.onDispose();
+    };
+    QuerySubscription.prototype.onDispose = function () {
+    };
+    QuerySubscription.prototype.handleNext = function (result) {
+        if (isNetworkRequestSettled(result.networkStatus) &&
+            this.result.data &&
+            result.data === void 0) {
+            result.data = this.result.data;
         }
+        this.result = result;
+        this.deliver(result);
+    };
+    QuerySubscription.prototype.handleError = function (error) {
+        var result = tslib.__assign(tslib.__assign({}, this.result), { error: error, networkStatus: exports.NetworkStatus.error });
+        this.result = result;
+        this.deliver(result);
+    };
+    QuerySubscription.prototype.deliver = function (result) {
+        this.listeners.forEach(function (listener) { return listener(result); });
     };
-    SuspenseCache.prototype.getVariablesKey = function (variables) {
-        return canonicalStringify(variables || Object.create(null));
+    return QuerySubscription;
+}());
+
+var SuspenseCache = (function () {
+    function SuspenseCache(options) {
+        if (options === void 0) { options = Object.create(null); }
+        this.cacheKeys = new trie.Trie(canUseWeakMap, function (cacheKey) { return cacheKey; });
+        this.subscriptions = new Map();
+        this.options = options;
+    }
+    SuspenseCache.prototype.getSubscription = function (cacheKey, createObservable) {
+        var _this = this;
+        var stableCacheKey = this.cacheKeys.lookupArray(cacheKey);
+        if (!this.subscriptions.has(stableCacheKey)) {
+            this.subscriptions.set(stableCacheKey, new QuerySubscription(createObservable(), {
+                autoDisposeTimeoutMs: this.options.autoDisposeTimeoutMs,
+                onDispose: function () { return _this.subscriptions.delete(stableCacheKey); },
+            }));
+        }
+        return this.subscriptions.get(stableCacheKey);
     };
     return SuspenseCache;
 }());
@@ -7637,6 +7820,7 @@ exports.fromError = fromError;
 exports.fromPromise = fromPromise;
 exports.getApolloContext = getApolloContext;
 exports.isApolloError = isApolloError;
+exports.isNetworkRequestSettled = isNetworkRequestSettled;
 exports.isReference = isReference;
 exports.makeReference = makeReference;
 exports.makeVar = makeVar;