@apollo/client 3.11.0-rc.0 → 3.11.0-rc.2

package/apollo-client.cjs

@@ -9,8 +9,8 @@ var caches = require('@wry/caches');
 var graphql = require('graphql');
 var zenObservableTs = require('zen-observable-ts');
 require('symbol-observable');
-var optimism = require('optimism');
 var trie = require('@wry/trie');
+var optimism = require('optimism');
 var graphqlTag = require('graphql-tag');
 var React = require('rehackt');
 
@@ -31,7 +31,7 @@ function _interopNamespace(e) {
 var equal__default = /*#__PURE__*/_interopDefaultLegacy(equal);
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
-var version = "3.11.0-rc.0";
+var version = "3.11.0-rc.2";
 
 function maybe(thunk) {
     try {
@@ -2502,14 +2502,9 @@ var ApolloCache =  (function () {
     };
     ApolloCache.prototype.watchFragment = function (options) {
         var _this = this;
-        var fragment = options.fragment, fragmentName = options.fragmentName, from = options.from, _a = options.optimistic, optimistic = _a === void 0 ? true : _a;
+        var fragment = options.fragment, fragmentName = options.fragmentName, from = options.from, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, otherOptions = tslib.__rest(options, ["fragment", "fragmentName", "from", "optimistic"]);
         var query = this.getFragmentDoc(fragment, fragmentName);
-        var diffOptions = {
-            returnPartialData: true,
-            id: typeof from === "string" ? from : this.identify(from),
-            query: query,
-            optimistic: optimistic,
-        };
+        var diffOptions = tslib.__assign(tslib.__assign({}, otherOptions), { returnPartialData: true, id: typeof from === "string" ? from : this.identify(from), query: query, optimistic: optimistic });
         var latestDiff;
         return new zenObservableTs.Observable(function (observer) {
             return _this.watch(tslib.__assign(tslib.__assign({}, diffOptions), { immediate: true, callback: function (diff) {
@@ -5456,1506 +5451,1506 @@ function skipCacheDataFor(fetchPolicy ) {
         fetchPolicy === "standby");
 }
 
-var LocalState =  (function () {
-    function LocalState(_a) {
-        var cache = _a.cache, client = _a.client, resolvers = _a.resolvers, fragmentMatcher = _a.fragmentMatcher;
-        this.selectionsToResolveCache = new WeakMap();
-        this.cache = cache;
-        if (client) {
-            this.client = client;
+var destructiveMethodCounts = new (canUseWeakMap ? WeakMap : Map)();
+function wrapDestructiveCacheMethod(cache, methodName) {
+    var original = cache[methodName];
+    if (typeof original === "function") {
+        cache[methodName] = function () {
+            destructiveMethodCounts.set(cache,
+            (destructiveMethodCounts.get(cache) + 1) % 1e15);
+            return original.apply(this, arguments);
+        };
+    }
+}
+function cancelNotifyTimeout(info) {
+    if (info["notifyTimeout"]) {
+        clearTimeout(info["notifyTimeout"]);
+        info["notifyTimeout"] = void 0;
+    }
+}
+var QueryInfo =  (function () {
+    function QueryInfo(queryManager, queryId) {
+        if (queryId === void 0) { queryId = queryManager.generateQueryId(); }
+        this.queryId = queryId;
+        this.listeners = new Set();
+        this.document = null;
+        this.lastRequestId = 1;
+        this.stopped = false;
+        this.dirty = false;
+        this.observableQuery = null;
+        var cache = (this.cache = queryManager.cache);
+        if (!destructiveMethodCounts.has(cache)) {
+            destructiveMethodCounts.set(cache, 0);
+            wrapDestructiveCacheMethod(cache, "evict");
+            wrapDestructiveCacheMethod(cache, "modify");
+            wrapDestructiveCacheMethod(cache, "reset");
         }
-        if (resolvers) {
-            this.addResolvers(resolvers);
+    }
+    QueryInfo.prototype.init = function (query) {
+        var networkStatus = query.networkStatus || exports.NetworkStatus.loading;
+        if (this.variables &&
+            this.networkStatus !== exports.NetworkStatus.loading &&
+            !equal.equal(this.variables, query.variables)) {
+            networkStatus = exports.NetworkStatus.setVariables;
         }
-        if (fragmentMatcher) {
-            this.setFragmentMatcher(fragmentMatcher);
+        if (!equal.equal(query.variables, this.variables)) {
+            this.lastDiff = void 0;
         }
-    }
-    LocalState.prototype.addResolvers = function (resolvers) {
-        var _this = this;
-        this.resolvers = this.resolvers || {};
-        if (Array.isArray(resolvers)) {
-            resolvers.forEach(function (resolverGroup) {
-                _this.resolvers = mergeDeep(_this.resolvers, resolverGroup);
-            });
+        Object.assign(this, {
+            document: query.document,
+            variables: query.variables,
+            networkError: null,
+            graphQLErrors: this.graphQLErrors || [],
+            networkStatus: networkStatus,
+        });
+        if (query.observableQuery) {
+            this.setObservableQuery(query.observableQuery);
         }
-        else {
-            this.resolvers = mergeDeep(this.resolvers, resolvers);
+        if (query.lastRequestId) {
+            this.lastRequestId = query.lastRequestId;
         }
+        return this;
     };
-    LocalState.prototype.setResolvers = function (resolvers) {
-        this.resolvers = {};
-        this.addResolvers(resolvers);
+    QueryInfo.prototype.reset = function () {
+        cancelNotifyTimeout(this);
+        this.dirty = false;
     };
-    LocalState.prototype.getResolvers = function () {
-        return this.resolvers || {};
+    QueryInfo.prototype.resetDiff = function () {
+        this.lastDiff = void 0;
     };
-    LocalState.prototype.runResolvers = function (_a) {
-        return tslib.__awaiter(this, arguments, void 0, function (_b) {
-            var document = _b.document, remoteResult = _b.remoteResult, context = _b.context, variables = _b.variables, _c = _b.onlyRunForcedResolvers, onlyRunForcedResolvers = _c === void 0 ? false : _c;
-            return tslib.__generator(this, function (_d) {
-                if (document) {
-                    return [2 , this.resolveDocument(document, remoteResult.data, context, variables, this.fragmentMatcher, onlyRunForcedResolvers).then(function (localResult) { return (tslib.__assign(tslib.__assign({}, remoteResult), { data: localResult.result })); })];
-                }
-                return [2 , remoteResult];
-            });
-        });
+    QueryInfo.prototype.getDiff = function () {
+        var options = this.getDiffOptions();
+        if (this.lastDiff && equal.equal(options, this.lastDiff.options)) {
+            return this.lastDiff.diff;
+        }
+        this.updateWatch(this.variables);
+        var oq = this.observableQuery;
+        if (oq && oq.options.fetchPolicy === "no-cache") {
+            return { complete: false };
+        }
+        var diff = this.cache.diff(options);
+        this.updateLastDiff(diff, options);
+        return diff;
     };
-    LocalState.prototype.setFragmentMatcher = function (fragmentMatcher) {
-        this.fragmentMatcher = fragmentMatcher;
+    QueryInfo.prototype.updateLastDiff = function (diff, options) {
+        this.lastDiff =
+            diff ?
+                {
+                    diff: diff,
+                    options: options || this.getDiffOptions(),
+                }
+                : void 0;
     };
-    LocalState.prototype.getFragmentMatcher = function () {
-        return this.fragmentMatcher;
+    QueryInfo.prototype.getDiffOptions = function (variables) {
+        var _a;
+        if (variables === void 0) { variables = this.variables; }
+        return {
+            query: this.document,
+            variables: variables,
+            returnPartialData: true,
+            optimistic: true,
+            canonizeResults: (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.options.canonizeResults,
+        };
     };
-    LocalState.prototype.clientQuery = function (document) {
-        if (hasDirectives(["client"], document)) {
-            if (this.resolvers) {
-                return document;
+    QueryInfo.prototype.setDiff = function (diff) {
+        var _this = this;
+        var _a;
+        var oldDiff = this.lastDiff && this.lastDiff.diff;
+        if (diff && !diff.complete && ((_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.getLastError())) {
+            return;
+        }
+        this.updateLastDiff(diff);
+        if (!this.dirty && !equal.equal(oldDiff && oldDiff.result, diff && diff.result)) {
+            this.dirty = true;
+            if (!this.notifyTimeout) {
+                this.notifyTimeout = setTimeout(function () { return _this.notify(); }, 0);
             }
         }
-        return null;
-    };
-    LocalState.prototype.serverQuery = function (document) {
-        return removeClientSetsFromDocument(document);
-    };
-    LocalState.prototype.prepareContext = function (context) {
-        var cache = this.cache;
-        return tslib.__assign(tslib.__assign({}, context), { cache: cache,
-            getCacheKey: function (obj) {
-                return cache.identify(obj);
-            } });
     };
-    LocalState.prototype.addExportedVariables = function (document_1) {
-        return tslib.__awaiter(this, arguments, void 0, function (document, variables, context) {
-            if (variables === void 0) { variables = {}; }
-            if (context === void 0) { context = {}; }
-            return tslib.__generator(this, function (_a) {
-                if (document) {
-                    return [2 , this.resolveDocument(document, this.buildRootValueFromCache(document, variables) || {}, this.prepareContext(context), variables).then(function (data) { return (tslib.__assign(tslib.__assign({}, variables), data.exportedVariables)); })];
+    QueryInfo.prototype.setObservableQuery = function (oq) {
+        var _this = this;
+        if (oq === this.observableQuery)
+            return;
+        if (this.oqListener) {
+            this.listeners.delete(this.oqListener);
+        }
+        this.observableQuery = oq;
+        if (oq) {
+            oq["queryInfo"] = this;
+            this.listeners.add((this.oqListener = function () {
+                var diff = _this.getDiff();
+                if (diff.fromOptimisticTransaction) {
+                    oq["observe"]();
                 }
-                return [2 , tslib.__assign({}, variables)];
-            });
-        });
+                else {
+                    reobserveCacheFirst(oq);
+                }
+            }));
+        }
+        else {
+            delete this.oqListener;
+        }
     };
-    LocalState.prototype.shouldForceResolvers = function (document) {
-        var forceResolvers = false;
-        graphql.visit(document, {
-            Directive: {
-                enter: function (node) {
-                    if (node.name.value === "client" && node.arguments) {
-                        forceResolvers = node.arguments.some(function (arg) {
-                            return arg.name.value === "always" &&
-                                arg.value.kind === "BooleanValue" &&
-                                arg.value.value === true;
-                        });
-                        if (forceResolvers) {
-                            return graphql.BREAK;
-                        }
-                    }
-                },
-            },
-        });
-        return forceResolvers;
+    QueryInfo.prototype.notify = function () {
+        var _this = this;
+        cancelNotifyTimeout(this);
+        if (this.shouldNotify()) {
+            this.listeners.forEach(function (listener) { return listener(_this); });
+        }
+        this.dirty = false;
     };
-    LocalState.prototype.buildRootValueFromCache = function (document, variables) {
-        return this.cache.diff({
-            query: buildQueryFromSelectionSet(document),
-            variables: variables,
-            returnPartialData: true,
-            optimistic: false,
-        }).result;
+    QueryInfo.prototype.shouldNotify = function () {
+        if (!this.dirty || !this.listeners.size) {
+            return false;
+        }
+        if (isNetworkRequestInFlight(this.networkStatus) && this.observableQuery) {
+            var fetchPolicy = this.observableQuery.options.fetchPolicy;
+            if (fetchPolicy !== "cache-only" && fetchPolicy !== "cache-and-network") {
+                return false;
+            }
+        }
+        return true;
     };
-    LocalState.prototype.resolveDocument = function (document_1, rootValue_1) {
-        return tslib.__awaiter(this, arguments, void 0, function (document, rootValue, context, variables, fragmentMatcher, onlyRunForcedResolvers) {
-            var mainDefinition, fragments, fragmentMap, selectionsToResolve, definitionOperation, defaultOperationType, _a, cache, client, execContext, isClientFieldDescendant;
-            if (context === void 0) { context = {}; }
-            if (variables === void 0) { variables = {}; }
-            if (fragmentMatcher === void 0) { fragmentMatcher = function () { return true; }; }
-            if (onlyRunForcedResolvers === void 0) { onlyRunForcedResolvers = false; }
-            return tslib.__generator(this, function (_b) {
-                mainDefinition = getMainDefinition(document);
-                fragments = getFragmentDefinitions(document);
-                fragmentMap = createFragmentMap(fragments);
-                selectionsToResolve = this.collectSelectionsToResolve(mainDefinition, fragmentMap);
-                definitionOperation = mainDefinition.operation;
-                defaultOperationType = definitionOperation ?
-                    definitionOperation.charAt(0).toUpperCase() +
-                        definitionOperation.slice(1)
-                    : "Query";
-                _a = this, cache = _a.cache, client = _a.client;
-                execContext = {
-                    fragmentMap: fragmentMap,
-                    context: tslib.__assign(tslib.__assign({}, context), { cache: cache, client: client }),
-                    variables: variables,
-                    fragmentMatcher: fragmentMatcher,
-                    defaultOperationType: defaultOperationType,
-                    exportedVariables: {},
-                    selectionsToResolve: selectionsToResolve,
-                    onlyRunForcedResolvers: onlyRunForcedResolvers,
-                };
-                isClientFieldDescendant = false;
-                return [2 , this.resolveSelectionSet(mainDefinition.selectionSet, isClientFieldDescendant, rootValue, execContext).then(function (result) { return ({
-                        result: result,
-                        exportedVariables: execContext.exportedVariables,
-                    }); })];
-            });
-        });
+    QueryInfo.prototype.stop = function () {
+        if (!this.stopped) {
+            this.stopped = true;
+            this.reset();
+            this.cancel();
+            this.cancel = QueryInfo.prototype.cancel;
+            var oq = this.observableQuery;
+            if (oq)
+                oq.stopPolling();
+        }
     };
-    LocalState.prototype.resolveSelectionSet = function (selectionSet, isClientFieldDescendant, rootValue, execContext) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            var fragmentMap, context, variables, resultsToMerge, execute;
-            var _this = this;
-            return tslib.__generator(this, function (_a) {
-                fragmentMap = execContext.fragmentMap, context = execContext.context, variables = execContext.variables;
-                resultsToMerge = [rootValue];
-                execute = function (selection) { return tslib.__awaiter(_this, void 0, void 0, function () {
-                    var fragment, typeCondition;
-                    return tslib.__generator(this, function (_a) {
-                        if (!isClientFieldDescendant &&
-                            !execContext.selectionsToResolve.has(selection)) {
-                            return [2 ];
-                        }
-                        if (!shouldInclude(selection, variables)) {
-                            return [2 ];
-                        }
-                        if (isField(selection)) {
-                            return [2 , this.resolveField(selection, isClientFieldDescendant, rootValue, execContext).then(function (fieldResult) {
-                                    var _a;
-                                    if (typeof fieldResult !== "undefined") {
-                                        resultsToMerge.push((_a = {},
-                                            _a[resultKeyNameFromField(selection)] = fieldResult,
-                                            _a));
-                                    }
-                                })];
-                        }
-                        if (isInlineFragment(selection)) {
-                            fragment = selection;
-                        }
-                        else {
-                            fragment = fragmentMap[selection.name.value];
-                            invariant(fragment, 18, selection.name.value);
-                        }
-                        if (fragment && fragment.typeCondition) {
-                            typeCondition = fragment.typeCondition.name.value;
-                            if (execContext.fragmentMatcher(rootValue, typeCondition, context)) {
-                                return [2 , this.resolveSelectionSet(fragment.selectionSet, isClientFieldDescendant, rootValue, execContext).then(function (fragmentResult) {
-                                        resultsToMerge.push(fragmentResult);
-                                    })];
-                            }
-                        }
-                        return [2 ];
-                    });
-                }); };
-                return [2 , Promise.all(selectionSet.selections.map(execute)).then(function () {
-                        return mergeDeepArray(resultsToMerge);
-                    })];
-            });
-        });
+    QueryInfo.prototype.cancel = function () { };
+    QueryInfo.prototype.updateWatch = function (variables) {
+        var _this = this;
+        if (variables === void 0) { variables = this.variables; }
+        var oq = this.observableQuery;
+        if (oq && oq.options.fetchPolicy === "no-cache") {
+            return;
+        }
+        var watchOptions = tslib.__assign(tslib.__assign({}, this.getDiffOptions(variables)), { watcher: this, callback: function (diff) { return _this.setDiff(diff); } });
+        if (!this.lastWatch || !equal.equal(watchOptions, this.lastWatch)) {
+            this.cancel();
+            this.cancel = this.cache.watch((this.lastWatch = watchOptions));
+        }
     };
-    LocalState.prototype.resolveField = function (field, isClientFieldDescendant, rootValue, execContext) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            var variables, fieldName, aliasedFieldName, aliasUsed, defaultResult, resultPromise, resolverType, resolverMap, resolve;
-            var _this = this;
-            return tslib.__generator(this, function (_a) {
-                if (!rootValue) {
-                    return [2 , null];
-                }
-                variables = execContext.variables;
-                fieldName = field.name.value;
-                aliasedFieldName = resultKeyNameFromField(field);
-                aliasUsed = fieldName !== aliasedFieldName;
-                defaultResult = rootValue[aliasedFieldName] || rootValue[fieldName];
-                resultPromise = Promise.resolve(defaultResult);
-                if (!execContext.onlyRunForcedResolvers ||
-                    this.shouldForceResolvers(field)) {
-                    resolverType = rootValue.__typename || execContext.defaultOperationType;
-                    resolverMap = this.resolvers && this.resolvers[resolverType];
-                    if (resolverMap) {
-                        resolve = resolverMap[aliasUsed ? fieldName : aliasedFieldName];
-                        if (resolve) {
-                            resultPromise = Promise.resolve(
-                            cacheSlot.withValue(this.cache, resolve, [
-                                rootValue,
-                                argumentsObjectFromField(field, variables),
-                                execContext.context,
-                                { field: field, fragmentMap: execContext.fragmentMap },
-                            ]));
-                        }
-                    }
-                }
-                return [2 , resultPromise.then(function (result) {
-                        var _a, _b;
-                        if (result === void 0) { result = defaultResult; }
-                        if (field.directives) {
-                            field.directives.forEach(function (directive) {
-                                if (directive.name.value === "export" && directive.arguments) {
-                                    directive.arguments.forEach(function (arg) {
-                                        if (arg.name.value === "as" && arg.value.kind === "StringValue") {
-                                            execContext.exportedVariables[arg.value.value] = result;
-                                        }
-                                    });
-                                }
-                            });
-                        }
-                        if (!field.selectionSet) {
-                            return result;
-                        }
-                        if (result == null) {
-                            return result;
-                        }
-                        var isClientField = (_b = (_a = field.directives) === null || _a === void 0 ? void 0 : _a.some(function (d) { return d.name.value === "client"; })) !== null && _b !== void 0 ? _b : false;
-                        if (Array.isArray(result)) {
-                            return _this.resolveSubSelectedArray(field, isClientFieldDescendant || isClientField, result, execContext);
-                        }
-                        if (field.selectionSet) {
-                            return _this.resolveSelectionSet(field.selectionSet, isClientFieldDescendant || isClientField, result, execContext);
-                        }
-                    })];
-            });
-        });
+    QueryInfo.prototype.resetLastWrite = function () {
+        this.lastWrite = void 0;
     };
-    LocalState.prototype.resolveSubSelectedArray = function (field, isClientFieldDescendant, result, execContext) {
-        var _this = this;
-        return Promise.all(result.map(function (item) {
-            if (item === null) {
-                return null;
-            }
-            if (Array.isArray(item)) {
-                return _this.resolveSubSelectedArray(field, isClientFieldDescendant, item, execContext);
-            }
-            if (field.selectionSet) {
-                return _this.resolveSelectionSet(field.selectionSet, isClientFieldDescendant, item, execContext);
-            }
-        }));
+    QueryInfo.prototype.shouldWrite = function (result, variables) {
+        var lastWrite = this.lastWrite;
+        return !(lastWrite &&
+            lastWrite.dmCount === destructiveMethodCounts.get(this.cache) &&
+            equal.equal(variables, lastWrite.variables) &&
+            equal.equal(result.data, lastWrite.result.data));
     };
-    LocalState.prototype.collectSelectionsToResolve = function (mainDefinition, fragmentMap) {
-        var isSingleASTNode = function (node) { return !Array.isArray(node); };
-        var selectionsToResolveCache = this.selectionsToResolveCache;
-        function collectByDefinition(definitionNode) {
-            if (!selectionsToResolveCache.has(definitionNode)) {
-                var matches_1 = new Set();
-                selectionsToResolveCache.set(definitionNode, matches_1);
-                graphql.visit(definitionNode, {
-                    Directive: function (node, _, __, ___, ancestors) {
-                        if (node.name.value === "client") {
-                            ancestors.forEach(function (node) {
-                                if (isSingleASTNode(node) && graphql.isSelectionNode(node)) {
-                                    matches_1.add(node);
-                                }
-                            });
-                        }
-                    },
-                    FragmentSpread: function (spread, _, __, ___, ancestors) {
-                        var fragment = fragmentMap[spread.name.value];
-                        invariant(fragment, 19, spread.name.value);
-                        var fragmentSelections = collectByDefinition(fragment);
-                        if (fragmentSelections.size > 0) {
-                            ancestors.forEach(function (node) {
-                                if (isSingleASTNode(node) && graphql.isSelectionNode(node)) {
-                                    matches_1.add(node);
-                                }
-                            });
-                            matches_1.add(spread);
-                            fragmentSelections.forEach(function (selection) {
-                                matches_1.add(selection);
-                            });
+    QueryInfo.prototype.markResult = function (result, document, options, cacheWriteBehavior) {
+        var _this = this;
+        var merger = new DeepMerger();
+        var graphQLErrors = isNonEmptyArray(result.errors) ? result.errors.slice(0) : [];
+        this.reset();
+        if ("incremental" in result && isNonEmptyArray(result.incremental)) {
+            var mergedData = mergeIncrementalData(this.getDiff().result, result);
+            result.data = mergedData;
+        }
+        else if ("hasNext" in result && result.hasNext) {
+            var diff = this.getDiff();
+            result.data = merger.merge(diff.result, result.data);
+        }
+        this.graphQLErrors = graphQLErrors;
+        if (options.fetchPolicy === "no-cache") {
+            this.updateLastDiff({ result: result.data, complete: true }, this.getDiffOptions(options.variables));
+        }
+        else if (cacheWriteBehavior !== 0 ) {
+            if (shouldWriteResult(result, options.errorPolicy)) {
+                this.cache.performTransaction(function (cache) {
+                    if (_this.shouldWrite(result, options.variables)) {
+                        cache.writeQuery({
+                            query: document,
+                            data: result.data,
+                            variables: options.variables,
+                            overwrite: cacheWriteBehavior === 1 ,
+                        });
+                        _this.lastWrite = {
+                            result: result,
+                            variables: options.variables,
+                            dmCount: destructiveMethodCounts.get(_this.cache),
+                        };
+                    }
+                    else {
+                        if (_this.lastDiff && _this.lastDiff.diff.complete) {
+                            result.data = _this.lastDiff.diff.result;
+                            return;
                         }
-                    },
+                    }
+                    var diffOptions = _this.getDiffOptions(options.variables);
+                    var diff = cache.diff(diffOptions);
+                    if (!_this.stopped && equal.equal(_this.variables, options.variables)) {
+                        _this.updateWatch(options.variables);
+                    }
+                    _this.updateLastDiff(diff, diffOptions);
+                    if (diff.complete) {
+                        result.data = diff.result;
+                    }
                 });
             }
-            return selectionsToResolveCache.get(definitionNode);
+            else {
+                this.lastWrite = void 0;
+            }
         }
-        return collectByDefinition(mainDefinition);
     };
-    return LocalState;
+    QueryInfo.prototype.markReady = function () {
+        this.networkError = null;
+        return (this.networkStatus = exports.NetworkStatus.ready);
+    };
+    QueryInfo.prototype.markError = function (error) {
+        this.networkStatus = exports.NetworkStatus.error;
+        this.lastWrite = void 0;
+        this.reset();
+        if (error.graphQLErrors) {
+            this.graphQLErrors = error.graphQLErrors;
+        }
+        if (error.networkError) {
+            this.networkError = error.networkError;
+        }
+        return error;
+    };
+    return QueryInfo;
 }());
-
-var destructiveMethodCounts = new (canUseWeakMap ? WeakMap : Map)();
-function wrapDestructiveCacheMethod(cache, methodName) {
-    var original = cache[methodName];
-    if (typeof original === "function") {
-        cache[methodName] = function () {
-            destructiveMethodCounts.set(cache,
-            (destructiveMethodCounts.get(cache) + 1) % 1e15);
-            return original.apply(this, arguments);
-        };
-    }
-}
-function cancelNotifyTimeout(info) {
-    if (info["notifyTimeout"]) {
-        clearTimeout(info["notifyTimeout"]);
-        info["notifyTimeout"] = void 0;
+function shouldWriteResult(result, errorPolicy) {
+    if (errorPolicy === void 0) { errorPolicy = "none"; }
+    var ignoreErrors = errorPolicy === "ignore" || errorPolicy === "all";
+    var writeWithErrors = !graphQLResultHasError(result);
+    if (!writeWithErrors && ignoreErrors && result.data) {
+        writeWithErrors = true;
     }
+    return writeWithErrors;
 }
-var QueryInfo =  (function () {
-    function QueryInfo(queryManager, queryId) {
-        if (queryId === void 0) { queryId = queryManager.generateQueryId(); }
-        this.queryId = queryId;
-        this.listeners = new Set();
-        this.document = null;
-        this.lastRequestId = 1;
-        this.stopped = false;
-        this.dirty = false;
-        this.observableQuery = null;
-        var cache = (this.cache = queryManager.cache);
-        if (!destructiveMethodCounts.has(cache)) {
-            destructiveMethodCounts.set(cache, 0);
-            wrapDestructiveCacheMethod(cache, "evict");
-            wrapDestructiveCacheMethod(cache, "modify");
-            wrapDestructiveCacheMethod(cache, "reset");
+
+var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+var IGNORE = Object.create(null);
+var QueryManager =  (function () {
+    function QueryManager(options) {
+        var _this = this;
+        this.clientAwareness = {};
+        this.queries = new Map();
+        this.fetchCancelFns = new Map();
+        this.transformCache = new AutoCleanedWeakCache(cacheSizes["queryManager.getDocumentInfo"] ||
+            2000 );
+        this.queryIdCounter = 1;
+        this.requestIdCounter = 1;
+        this.mutationIdCounter = 1;
+        this.inFlightLinkObservables = new trie.Trie(false);
+        var defaultDocumentTransform = new DocumentTransform(function (document) { return _this.cache.transformDocument(document); },
+        { cache: false });
+        this.cache = options.cache;
+        this.link = options.link;
+        this.defaultOptions = options.defaultOptions;
+        this.queryDeduplication = options.queryDeduplication;
+        this.clientAwareness = options.clientAwareness;
+        this.localState = options.localState;
+        this.ssrMode = options.ssrMode;
+        this.assumeImmutableResults = options.assumeImmutableResults;
+        var documentTransform = options.documentTransform;
+        this.documentTransform =
+            documentTransform ?
+                defaultDocumentTransform
+                    .concat(documentTransform)
+                    .concat(defaultDocumentTransform)
+                : defaultDocumentTransform;
+        this.defaultContext = options.defaultContext || Object.create(null);
+        if ((this.onBroadcast = options.onBroadcast)) {
+            this.mutationStore = Object.create(null);
         }
     }
-    QueryInfo.prototype.init = function (query) {
-        var networkStatus = query.networkStatus || exports.NetworkStatus.loading;
-        if (this.variables &&
-            this.networkStatus !== exports.NetworkStatus.loading &&
-            !equal.equal(this.variables, query.variables)) {
-            networkStatus = exports.NetworkStatus.setVariables;
-        }
-        if (!equal.equal(query.variables, this.variables)) {
-            this.lastDiff = void 0;
-        }
-        Object.assign(this, {
-            document: query.document,
-            variables: query.variables,
-            networkError: null,
-            graphQLErrors: this.graphQLErrors || [],
-            networkStatus: networkStatus,
+    QueryManager.prototype.stop = function () {
+        var _this = this;
+        this.queries.forEach(function (_info, queryId) {
+            _this.stopQueryNoBroadcast(queryId);
         });
-        if (query.observableQuery) {
-            this.setObservableQuery(query.observableQuery);
-        }
-        if (query.lastRequestId) {
-            this.lastRequestId = query.lastRequestId;
-        }
-        return this;
-    };
-    QueryInfo.prototype.reset = function () {
-        cancelNotifyTimeout(this);
-        this.dirty = false;
-    };
-    QueryInfo.prototype.resetDiff = function () {
-        this.lastDiff = void 0;
+        this.cancelPendingFetches(newInvariantError(25));
     };
-    QueryInfo.prototype.getDiff = function () {
-        var options = this.getDiffOptions();
-        if (this.lastDiff && equal.equal(options, this.lastDiff.options)) {
-            return this.lastDiff.diff;
-        }
-        this.updateWatch(this.variables);
-        var oq = this.observableQuery;
-        if (oq && oq.options.fetchPolicy === "no-cache") {
-            return { complete: false };
-        }
-        var diff = this.cache.diff(options);
-        this.updateLastDiff(diff, options);
-        return diff;
+    QueryManager.prototype.cancelPendingFetches = function (error) {
+        this.fetchCancelFns.forEach(function (cancel) { return cancel(error); });
+        this.fetchCancelFns.clear();
     };
-    QueryInfo.prototype.updateLastDiff = function (diff, options) {
-        this.lastDiff =
-            diff ?
-                {
-                    diff: diff,
-                    options: options || this.getDiffOptions(),
+    QueryManager.prototype.mutate = function (_a) {
+        return tslib.__awaiter(this, arguments, void 0, function (_b) {
+            var mutationId, hasClientExports, mutationStoreValue, isOptimistic, self;
+            var _c, _d;
+            var mutation = _b.mutation, variables = _b.variables, optimisticResponse = _b.optimisticResponse, updateQueries = _b.updateQueries, _e = _b.refetchQueries, refetchQueries = _e === void 0 ? [] : _e, _f = _b.awaitRefetchQueries, awaitRefetchQueries = _f === void 0 ? false : _f, updateWithProxyFn = _b.update, onQueryUpdated = _b.onQueryUpdated, _g = _b.fetchPolicy, fetchPolicy = _g === void 0 ? ((_c = this.defaultOptions.mutate) === null || _c === void 0 ? void 0 : _c.fetchPolicy) || "network-only" : _g, _h = _b.errorPolicy, errorPolicy = _h === void 0 ? ((_d = this.defaultOptions.mutate) === null || _d === void 0 ? void 0 : _d.errorPolicy) || "none" : _h, keepRootFields = _b.keepRootFields, context = _b.context;
+            return tslib.__generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0:
+                        invariant(mutation, 26);
+                        invariant(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 27);
+                        mutationId = this.generateMutationId();
+                        mutation = this.cache.transformForLink(this.transform(mutation));
+                        hasClientExports = this.getDocumentInfo(mutation).hasClientExports;
+                        variables = this.getVariables(mutation, variables);
+                        if (!hasClientExports) return [3 , 2];
+                        return [4 , this.localState.addExportedVariables(mutation, variables, context)];
+                    case 1:
+                        variables = (_j.sent());
+                        _j.label = 2;
+                    case 2:
+                        mutationStoreValue = this.mutationStore &&
+                            (this.mutationStore[mutationId] = {
+                                mutation: mutation,
+                                variables: variables,
+                                loading: true,
+                                error: null,
+                            });
+                        isOptimistic = optimisticResponse &&
+                            this.markMutationOptimistic(optimisticResponse, {
+                                mutationId: mutationId,
+                                document: mutation,
+                                variables: variables,
+                                fetchPolicy: fetchPolicy,
+                                errorPolicy: errorPolicy,
+                                context: context,
+                                updateQueries: updateQueries,
+                                update: updateWithProxyFn,
+                                keepRootFields: keepRootFields,
+                            });
+                        this.broadcastQueries();
+                        self = this;
+                        return [2 , new Promise(function (resolve, reject) {
+                                return asyncMap(self.getObservableFromLink(mutation, tslib.__assign(tslib.__assign({}, context), { optimisticResponse: isOptimistic ? optimisticResponse : void 0 }), variables, {}, false), function (result) {
+                                    if (graphQLResultHasError(result) && errorPolicy === "none") {
+                                        throw new ApolloError({
+                                            graphQLErrors: getGraphQLErrorsFromResult(result),
+                                        });
+                                    }
+                                    if (mutationStoreValue) {
+                                        mutationStoreValue.loading = false;
+                                        mutationStoreValue.error = null;
+                                    }
+                                    var storeResult = tslib.__assign({}, result);
+                                    if (typeof refetchQueries === "function") {
+                                        refetchQueries = refetchQueries(storeResult);
+                                    }
+                                    if (errorPolicy === "ignore" && graphQLResultHasError(storeResult)) {
+                                        delete storeResult.errors;
+                                    }
+                                    return self.markMutationResult({
+                                        mutationId: mutationId,
+                                        result: storeResult,
+                                        document: mutation,
+                                        variables: variables,
+                                        fetchPolicy: fetchPolicy,
+                                        errorPolicy: errorPolicy,
+                                        context: context,
+                                        update: updateWithProxyFn,
+                                        updateQueries: updateQueries,
+                                        awaitRefetchQueries: awaitRefetchQueries,
+                                        refetchQueries: refetchQueries,
+                                        removeOptimistic: isOptimistic ? mutationId : void 0,
+                                        onQueryUpdated: onQueryUpdated,
+                                        keepRootFields: keepRootFields,
+                                    });
+                                }).subscribe({
+                                    next: function (storeResult) {
+                                        self.broadcastQueries();
+                                        if (!("hasNext" in storeResult) || storeResult.hasNext === false) {
+                                            resolve(storeResult);
+                                        }
+                                    },
+                                    error: function (err) {
+                                        if (mutationStoreValue) {
+                                            mutationStoreValue.loading = false;
+                                            mutationStoreValue.error = err;
+                                        }
+                                        if (isOptimistic) {
+                                            self.cache.removeOptimistic(mutationId);
+                                        }
+                                        self.broadcastQueries();
+                                        reject(err instanceof ApolloError ? err : (new ApolloError({
+                                            networkError: err,
+                                        })));
+                                    },
+                                });
+                            })];
                 }
-                : void 0;
-    };
-    QueryInfo.prototype.getDiffOptions = function (variables) {
-        var _a;
-        if (variables === void 0) { variables = this.variables; }
-        return {
-            query: this.document,
-            variables: variables,
-            returnPartialData: true,
-            optimistic: true,
-            canonizeResults: (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.options.canonizeResults,
-        };
+            });
+        });
     };
-    QueryInfo.prototype.setDiff = function (diff) {
+    QueryManager.prototype.markMutationResult = function (mutation, cache) {
         var _this = this;
-        var _a;
-        var oldDiff = this.lastDiff && this.lastDiff.diff;
-        if (diff && !diff.complete && ((_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.getLastError())) {
-            return;
-        }
-        this.updateLastDiff(diff);
-        if (!this.dirty && !equal.equal(oldDiff && oldDiff.result, diff && diff.result)) {
-            this.dirty = true;
-            if (!this.notifyTimeout) {
-                this.notifyTimeout = setTimeout(function () { return _this.notify(); }, 0);
+        if (cache === void 0) { cache = this.cache; }
+        var result = mutation.result;
+        var cacheWrites = [];
+        var skipCache = mutation.fetchPolicy === "no-cache";
+        if (!skipCache && shouldWriteResult(result, mutation.errorPolicy)) {
+            if (!isExecutionPatchIncrementalResult(result)) {
+                cacheWrites.push({
+                    result: result.data,
+                    dataId: "ROOT_MUTATION",
+                    query: mutation.document,
+                    variables: mutation.variables,
+                });
             }
-        }
-    };
-    QueryInfo.prototype.setObservableQuery = function (oq) {
-        var _this = this;
-        if (oq === this.observableQuery)
-            return;
-        if (this.oqListener) {
-            this.listeners.delete(this.oqListener);
-        }
-        this.observableQuery = oq;
-        if (oq) {
-            oq["queryInfo"] = this;
-            this.listeners.add((this.oqListener = function () {
-                var diff = _this.getDiff();
-                if (diff.fromOptimisticTransaction) {
-                    oq["observe"]();
+            if (isExecutionPatchIncrementalResult(result) &&
+                isNonEmptyArray(result.incremental)) {
+                var diff = cache.diff({
+                    id: "ROOT_MUTATION",
+                    query: this.getDocumentInfo(mutation.document).asQuery,
+                    variables: mutation.variables,
+                    optimistic: false,
+                    returnPartialData: true,
+                });
+                var mergedData = void 0;
+                if (diff.result) {
+                    mergedData = mergeIncrementalData(diff.result, result);
                 }
-                else {
-                    reobserveCacheFirst(oq);
+                if (typeof mergedData !== "undefined") {
+                    result.data = mergedData;
+                    cacheWrites.push({
+                        result: mergedData,
+                        dataId: "ROOT_MUTATION",
+                        query: mutation.document,
+                        variables: mutation.variables,
+                    });
                 }
-            }));
-        }
-        else {
-            delete this.oqListener;
+            }
+            var updateQueries_1 = mutation.updateQueries;
+            if (updateQueries_1) {
+                this.queries.forEach(function (_a, queryId) {
+                    var observableQuery = _a.observableQuery;
+                    var queryName = observableQuery && observableQuery.queryName;
+                    if (!queryName || !hasOwnProperty$1.call(updateQueries_1, queryName)) {
+                        return;
+                    }
+                    var updater = updateQueries_1[queryName];
+                    var _b = _this.queries.get(queryId), document = _b.document, variables = _b.variables;
+                    var _c = cache.diff({
+                        query: document,
+                        variables: variables,
+                        returnPartialData: true,
+                        optimistic: false,
+                    }), currentQueryResult = _c.result, complete = _c.complete;
+                    if (complete && currentQueryResult) {
+                        var nextQueryResult = updater(currentQueryResult, {
+                            mutationResult: result,
+                            queryName: (document && getOperationName(document)) || void 0,
+                            queryVariables: variables,
+                        });
+                        if (nextQueryResult) {
+                            cacheWrites.push({
+                                result: nextQueryResult,
+                                dataId: "ROOT_QUERY",
+                                query: document,
+                                variables: variables,
+                            });
+                        }
+                    }
+                });
+            }
         }
-    };
-    QueryInfo.prototype.notify = function () {
-        var _this = this;
-        cancelNotifyTimeout(this);
-        if (this.shouldNotify()) {
-            this.listeners.forEach(function (listener) { return listener(_this); });
+        if (cacheWrites.length > 0 ||
+            (mutation.refetchQueries || "").length > 0 ||
+            mutation.update ||
+            mutation.onQueryUpdated ||
+            mutation.removeOptimistic) {
+            var results_1 = [];
+            this.refetchQueries({
+                updateCache: function (cache) {
+                    if (!skipCache) {
+                        cacheWrites.forEach(function (write) { return cache.write(write); });
+                    }
+                    var update = mutation.update;
+                    var isFinalResult = !isExecutionPatchResult(result) ||
+                        (isExecutionPatchIncrementalResult(result) && !result.hasNext);
+                    if (update) {
+                        if (!skipCache) {
+                            var diff = cache.diff({
+                                id: "ROOT_MUTATION",
+                                query: _this.getDocumentInfo(mutation.document).asQuery,
+                                variables: mutation.variables,
+                                optimistic: false,
+                                returnPartialData: true,
+                            });
+                            if (diff.complete) {
+                                result = tslib.__assign(tslib.__assign({}, result), { data: diff.result });
+                                if ("incremental" in result) {
+                                    delete result.incremental;
+                                }
+                                if ("hasNext" in result) {
+                                    delete result.hasNext;
+                                }
+                            }
+                        }
+                        if (isFinalResult) {
+                            update(cache, result, {
+                                context: mutation.context,
+                                variables: mutation.variables,
+                            });
+                        }
+                    }
+                    if (!skipCache && !mutation.keepRootFields && isFinalResult) {
+                        cache.modify({
+                            id: "ROOT_MUTATION",
+                            fields: function (value, _a) {
+                                var fieldName = _a.fieldName, DELETE = _a.DELETE;
+                                return fieldName === "__typename" ? value : DELETE;
+                            },
+                        });
+                    }
+                },
+                include: mutation.refetchQueries,
+                optimistic: false,
+                removeOptimistic: mutation.removeOptimistic,
+                onQueryUpdated: mutation.onQueryUpdated || null,
+            }).forEach(function (result) { return results_1.push(result); });
+            if (mutation.awaitRefetchQueries || mutation.onQueryUpdated) {
+                return Promise.all(results_1).then(function () { return result; });
+            }
         }
-        this.dirty = false;
+        return Promise.resolve(result);
     };
-    QueryInfo.prototype.shouldNotify = function () {
-        if (!this.dirty || !this.listeners.size) {
+    QueryManager.prototype.markMutationOptimistic = function (optimisticResponse, mutation) {
+        var _this = this;
+        var data = typeof optimisticResponse === "function" ?
+            optimisticResponse(mutation.variables, { IGNORE: IGNORE })
+            : optimisticResponse;
+        if (data === IGNORE) {
             return false;
         }
-        if (isNetworkRequestInFlight(this.networkStatus) && this.observableQuery) {
-            var fetchPolicy = this.observableQuery.options.fetchPolicy;
-            if (fetchPolicy !== "cache-only" && fetchPolicy !== "cache-and-network") {
-                return false;
+        this.cache.recordOptimisticTransaction(function (cache) {
+            try {
+                _this.markMutationResult(tslib.__assign(tslib.__assign({}, mutation), { result: { data: data } }), cache);
             }
-        }
+            catch (error) {
+                globalThis.__DEV__ !== false && invariant.error(error);
+            }
+        }, mutation.mutationId);
         return true;
     };
-    QueryInfo.prototype.stop = function () {
-        if (!this.stopped) {
-            this.stopped = true;
-            this.reset();
-            this.cancel();
-            this.cancel = QueryInfo.prototype.cancel;
-            var oq = this.observableQuery;
-            if (oq)
-                oq.stopPolling();
-        }
+    QueryManager.prototype.fetchQuery = function (queryId, options, networkStatus) {
+        return this.fetchConcastWithInfo(queryId, options, networkStatus).concast
+            .promise;
     };
-    QueryInfo.prototype.cancel = function () { };
-    QueryInfo.prototype.updateWatch = function (variables) {
-        var _this = this;
-        if (variables === void 0) { variables = this.variables; }
-        var oq = this.observableQuery;
-        if (oq && oq.options.fetchPolicy === "no-cache") {
-            return;
-        }
-        var watchOptions = tslib.__assign(tslib.__assign({}, this.getDiffOptions(variables)), { watcher: this, callback: function (diff) { return _this.setDiff(diff); } });
-        if (!this.lastWatch || !equal.equal(watchOptions, this.lastWatch)) {
-            this.cancel();
-            this.cancel = this.cache.watch((this.lastWatch = watchOptions));
-        }
+    QueryManager.prototype.getQueryStore = function () {
+        var store = Object.create(null);
+        this.queries.forEach(function (info, queryId) {
+            store[queryId] = {
+                variables: info.variables,
+                networkStatus: info.networkStatus,
+                networkError: info.networkError,
+                graphQLErrors: info.graphQLErrors,
+            };
+        });
+        return store;
     };
-    QueryInfo.prototype.resetLastWrite = function () {
-        this.lastWrite = void 0;
+    QueryManager.prototype.resetErrors = function (queryId) {
+        var queryInfo = this.queries.get(queryId);
+        if (queryInfo) {
+            queryInfo.networkError = undefined;
+            queryInfo.graphQLErrors = [];
+        }
     };
-    QueryInfo.prototype.shouldWrite = function (result, variables) {
-        var lastWrite = this.lastWrite;
-        return !(lastWrite &&
-            lastWrite.dmCount === destructiveMethodCounts.get(this.cache) &&
-            equal.equal(variables, lastWrite.variables) &&
-            equal.equal(result.data, lastWrite.result.data));
+    QueryManager.prototype.transform = function (document) {
+        return this.documentTransform.transformDocument(document);
     };
-    QueryInfo.prototype.markResult = function (result, document, options, cacheWriteBehavior) {
-        var _this = this;
-        var merger = new DeepMerger();
-        var graphQLErrors = isNonEmptyArray(result.errors) ? result.errors.slice(0) : [];
-        this.reset();
-        if ("incremental" in result && isNonEmptyArray(result.incremental)) {
-            var mergedData = mergeIncrementalData(this.getDiff().result, result);
-            result.data = mergedData;
-        }
-        else if ("hasNext" in result && result.hasNext) {
-            var diff = this.getDiff();
-            result.data = merger.merge(diff.result, result.data);
-        }
-        this.graphQLErrors = graphQLErrors;
-        if (options.fetchPolicy === "no-cache") {
-            this.updateLastDiff({ result: result.data, complete: true }, this.getDiffOptions(options.variables));
-        }
-        else if (cacheWriteBehavior !== 0 ) {
-            if (shouldWriteResult(result, options.errorPolicy)) {
-                this.cache.performTransaction(function (cache) {
-                    if (_this.shouldWrite(result, options.variables)) {
-                        cache.writeQuery({
-                            query: document,
-                            data: result.data,
-                            variables: options.variables,
-                            overwrite: cacheWriteBehavior === 1 ,
-                        });
-                        _this.lastWrite = {
-                            result: result,
-                            variables: options.variables,
-                            dmCount: destructiveMethodCounts.get(_this.cache),
-                        };
-                    }
-                    else {
-                        if (_this.lastDiff && _this.lastDiff.diff.complete) {
-                            result.data = _this.lastDiff.diff.result;
-                            return;
+    QueryManager.prototype.getDocumentInfo = function (document) {
+        var transformCache = this.transformCache;
+        if (!transformCache.has(document)) {
+            var cacheEntry = {
+                hasClientExports: hasClientExports(document),
+                hasForcedResolvers: this.localState.shouldForceResolvers(document),
+                hasNonreactiveDirective: hasDirectives(["nonreactive"], document),
+                clientQuery: this.localState.clientQuery(document),
+                serverQuery: removeDirectivesFromDocument([
+                    { name: "client", remove: true },
+                    { name: "connection" },
+                    { name: "nonreactive" },
+                ], document),
+                defaultVars: getDefaultValues(getOperationDefinition(document)),
+                asQuery: tslib.__assign(tslib.__assign({}, document), { definitions: document.definitions.map(function (def) {
+                        if (def.kind === "OperationDefinition" &&
+                            def.operation !== "query") {
+                            return tslib.__assign(tslib.__assign({}, def), { operation: "query" });
                         }
-                    }
-                    var diffOptions = _this.getDiffOptions(options.variables);
-                    var diff = cache.diff(diffOptions);
-                    if (!_this.stopped && equal.equal(_this.variables, options.variables)) {
-                        _this.updateWatch(options.variables);
-                    }
-                    _this.updateLastDiff(diff, diffOptions);
-                    if (diff.complete) {
-                        result.data = diff.result;
-                    }
-                });
-            }
-            else {
-                this.lastWrite = void 0;
-            }
+                        return def;
+                    }) }),
+            };
+            transformCache.set(document, cacheEntry);
         }
+        return transformCache.get(document);
     };
-    QueryInfo.prototype.markReady = function () {
-        this.networkError = null;
-        return (this.networkStatus = exports.NetworkStatus.ready);
+    QueryManager.prototype.getVariables = function (document, variables) {
+        return tslib.__assign(tslib.__assign({}, this.getDocumentInfo(document).defaultVars), variables);
     };
-    QueryInfo.prototype.markError = function (error) {
-        this.networkStatus = exports.NetworkStatus.error;
-        this.lastWrite = void 0;
-        this.reset();
-        if (error.graphQLErrors) {
-            this.graphQLErrors = error.graphQLErrors;
-        }
-        if (error.networkError) {
-            this.networkError = error.networkError;
+    QueryManager.prototype.watchQuery = function (options) {
+        var query = this.transform(options.query);
+        options = tslib.__assign(tslib.__assign({}, options), { variables: this.getVariables(query, options.variables) });
+        if (typeof options.notifyOnNetworkStatusChange === "undefined") {
+            options.notifyOnNetworkStatusChange = false;
         }
-        return error;
+        var queryInfo = new QueryInfo(this);
+        var observable = new ObservableQuery({
+            queryManager: this,
+            queryInfo: queryInfo,
+            options: options,
+        });
+        observable["lastQuery"] = query;
+        this.queries.set(observable.queryId, queryInfo);
+        queryInfo.init({
+            document: query,
+            observableQuery: observable,
+            variables: observable.variables,
+        });
+        return observable;
     };
-    return QueryInfo;
-}());
-function shouldWriteResult(result, errorPolicy) {
-    if (errorPolicy === void 0) { errorPolicy = "none"; }
-    var ignoreErrors = errorPolicy === "ignore" || errorPolicy === "all";
-    var writeWithErrors = !graphQLResultHasError(result);
-    if (!writeWithErrors && ignoreErrors && result.data) {
-        writeWithErrors = true;
-    }
-    return writeWithErrors;
-}
-
-var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
-var IGNORE = Object.create(null);
-var QueryManager =  (function () {
-    function QueryManager(_a) {
-        var cache = _a.cache, link = _a.link, defaultOptions = _a.defaultOptions, documentTransform = _a.documentTransform, _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, defaultContext = _a.defaultContext;
+    QueryManager.prototype.query = function (options, queryId) {
         var _this = this;
-        this.clientAwareness = {};
-        this.queries = new Map();
-        this.fetchCancelFns = new Map();
-        this.transformCache = new AutoCleanedWeakCache(cacheSizes["queryManager.getDocumentInfo"] ||
-            2000 );
-        this.queryIdCounter = 1;
-        this.requestIdCounter = 1;
-        this.mutationIdCounter = 1;
-        this.inFlightLinkObservables = new trie.Trie(false);
-        var defaultDocumentTransform = new DocumentTransform(function (document) { return _this.cache.transformDocument(document); },
-        { cache: false });
-        this.cache = cache;
-        this.link = link;
-        this.defaultOptions = defaultOptions || Object.create(null);
-        this.queryDeduplication = queryDeduplication;
-        this.clientAwareness = clientAwareness;
-        this.localState = localState || new LocalState({ cache: cache });
-        this.ssrMode = ssrMode;
-        this.assumeImmutableResults = assumeImmutableResults;
-        this.documentTransform =
-            documentTransform ?
-                defaultDocumentTransform
-                    .concat(documentTransform)
-                    .concat(defaultDocumentTransform)
-                : defaultDocumentTransform;
-        this.defaultContext = defaultContext || Object.create(null);
-        if ((this.onBroadcast = onBroadcast)) {
+        if (queryId === void 0) { queryId = this.generateQueryId(); }
+        invariant(options.query, 28);
+        invariant(options.query.kind === "Document", 29);
+        invariant(!options.returnPartialData, 30);
+        invariant(!options.pollInterval, 31);
+        return this.fetchQuery(queryId, tslib.__assign(tslib.__assign({}, options), { query: this.transform(options.query) })).finally(function () { return _this.stopQuery(queryId); });
+    };
+    QueryManager.prototype.generateQueryId = function () {
+        return String(this.queryIdCounter++);
+    };
+    QueryManager.prototype.generateRequestId = function () {
+        return this.requestIdCounter++;
+    };
+    QueryManager.prototype.generateMutationId = function () {
+        return String(this.mutationIdCounter++);
+    };
+    QueryManager.prototype.stopQueryInStore = function (queryId) {
+        this.stopQueryInStoreNoBroadcast(queryId);
+        this.broadcastQueries();
+    };
+    QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {
+        var queryInfo = this.queries.get(queryId);
+        if (queryInfo)
+            queryInfo.stop();
+    };
+    QueryManager.prototype.clearStore = function (options) {
+        if (options === void 0) { options = {
+            discardWatches: true,
+        }; }
+        this.cancelPendingFetches(newInvariantError(32));
+        this.queries.forEach(function (queryInfo) {
+            if (queryInfo.observableQuery) {
+                queryInfo.networkStatus = exports.NetworkStatus.loading;
+            }
+            else {
+                queryInfo.stop();
+            }
+        });
+        if (this.mutationStore) {
             this.mutationStore = Object.create(null);
         }
-    }
-    QueryManager.prototype.stop = function () {
-        var _this = this;
-        this.queries.forEach(function (_info, queryId) {
-            _this.stopQueryNoBroadcast(queryId);
-        });
-        this.cancelPendingFetches(newInvariantError(25));
-    };
-    QueryManager.prototype.cancelPendingFetches = function (error) {
-        this.fetchCancelFns.forEach(function (cancel) { return cancel(error); });
-        this.fetchCancelFns.clear();
+        return this.cache.reset(options);
     };
-    QueryManager.prototype.mutate = function (_a) {
-        return tslib.__awaiter(this, arguments, void 0, function (_b) {
-            var mutationId, hasClientExports, mutationStoreValue, isOptimistic, self;
-            var _c, _d;
-            var mutation = _b.mutation, variables = _b.variables, optimisticResponse = _b.optimisticResponse, updateQueries = _b.updateQueries, _e = _b.refetchQueries, refetchQueries = _e === void 0 ? [] : _e, _f = _b.awaitRefetchQueries, awaitRefetchQueries = _f === void 0 ? false : _f, updateWithProxyFn = _b.update, onQueryUpdated = _b.onQueryUpdated, _g = _b.fetchPolicy, fetchPolicy = _g === void 0 ? ((_c = this.defaultOptions.mutate) === null || _c === void 0 ? void 0 : _c.fetchPolicy) || "network-only" : _g, _h = _b.errorPolicy, errorPolicy = _h === void 0 ? ((_d = this.defaultOptions.mutate) === null || _d === void 0 ? void 0 : _d.errorPolicy) || "none" : _h, keepRootFields = _b.keepRootFields, context = _b.context;
-            return tslib.__generator(this, function (_j) {
-                switch (_j.label) {
-                    case 0:
-                        invariant(mutation, 26);
-                        invariant(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 27);
-                        mutationId = this.generateMutationId();
-                        mutation = this.cache.transformForLink(this.transform(mutation));
-                        hasClientExports = this.getDocumentInfo(mutation).hasClientExports;
-                        variables = this.getVariables(mutation, variables);
-                        if (!hasClientExports) return [3 , 2];
-                        return [4 , this.localState.addExportedVariables(mutation, variables, context)];
-                    case 1:
-                        variables = (_j.sent());
-                        _j.label = 2;
-                    case 2:
-                        mutationStoreValue = this.mutationStore &&
-                            (this.mutationStore[mutationId] = {
-                                mutation: mutation,
-                                variables: variables,
-                                loading: true,
-                                error: null,
-                            });
-                        isOptimistic = optimisticResponse &&
-                            this.markMutationOptimistic(optimisticResponse, {
-                                mutationId: mutationId,
-                                document: mutation,
-                                variables: variables,
-                                fetchPolicy: fetchPolicy,
-                                errorPolicy: errorPolicy,
-                                context: context,
-                                updateQueries: updateQueries,
-                                update: updateWithProxyFn,
-                                keepRootFields: keepRootFields,
-                            });
-                        this.broadcastQueries();
-                        self = this;
-                        return [2 , new Promise(function (resolve, reject) {
-                                return asyncMap(self.getObservableFromLink(mutation, tslib.__assign(tslib.__assign({}, context), { optimisticResponse: isOptimistic ? optimisticResponse : void 0 }), variables, {}, false), function (result) {
-                                    if (graphQLResultHasError(result) && errorPolicy === "none") {
-                                        throw new ApolloError({
-                                            graphQLErrors: getGraphQLErrorsFromResult(result),
-                                        });
-                                    }
-                                    if (mutationStoreValue) {
-                                        mutationStoreValue.loading = false;
-                                        mutationStoreValue.error = null;
-                                    }
-                                    var storeResult = tslib.__assign({}, result);
-                                    if (typeof refetchQueries === "function") {
-                                        refetchQueries = refetchQueries(storeResult);
-                                    }
-                                    if (errorPolicy === "ignore" && graphQLResultHasError(storeResult)) {
-                                        delete storeResult.errors;
-                                    }
-                                    return self.markMutationResult({
-                                        mutationId: mutationId,
-                                        result: storeResult,
-                                        document: mutation,
-                                        variables: variables,
-                                        fetchPolicy: fetchPolicy,
-                                        errorPolicy: errorPolicy,
-                                        context: context,
-                                        update: updateWithProxyFn,
-                                        updateQueries: updateQueries,
-                                        awaitRefetchQueries: awaitRefetchQueries,
-                                        refetchQueries: refetchQueries,
-                                        removeOptimistic: isOptimistic ? mutationId : void 0,
-                                        onQueryUpdated: onQueryUpdated,
-                                        keepRootFields: keepRootFields,
-                                    });
-                                }).subscribe({
-                                    next: function (storeResult) {
-                                        self.broadcastQueries();
-                                        if (!("hasNext" in storeResult) || storeResult.hasNext === false) {
-                                            resolve(storeResult);
-                                        }
-                                    },
-                                    error: function (err) {
-                                        if (mutationStoreValue) {
-                                            mutationStoreValue.loading = false;
-                                            mutationStoreValue.error = err;
-                                        }
-                                        if (isOptimistic) {
-                                            self.cache.removeOptimistic(mutationId);
-                                        }
-                                        self.broadcastQueries();
-                                        reject(err instanceof ApolloError ? err : (new ApolloError({
-                                            networkError: err,
-                                        })));
-                                    },
-                                });
-                            })];
+    QueryManager.prototype.getObservableQueries = function (include) {
+        var _this = this;
+        if (include === void 0) { include = "active"; }
+        var queries = new Map();
+        var queryNamesAndDocs = new Map();
+        var legacyQueryOptions = new Set();
+        if (Array.isArray(include)) {
+            include.forEach(function (desc) {
+                if (typeof desc === "string") {
+                    queryNamesAndDocs.set(desc, false);
+                }
+                else if (isDocumentNode(desc)) {
+                    queryNamesAndDocs.set(_this.transform(desc), false);
+                }
+                else if (isNonNullObject(desc) && desc.query) {
+                    legacyQueryOptions.add(desc);
                 }
             });
+        }
+        this.queries.forEach(function (_a, queryId) {
+            var oq = _a.observableQuery, document = _a.document;
+            if (oq) {
+                if (include === "all") {
+                    queries.set(queryId, oq);
+                    return;
+                }
+                var queryName = oq.queryName, fetchPolicy = oq.options.fetchPolicy;
+                if (fetchPolicy === "standby" ||
+                    (include === "active" && !oq.hasObservers())) {
+                    return;
+                }
+                if (include === "active" ||
+                    (queryName && queryNamesAndDocs.has(queryName)) ||
+                    (document && queryNamesAndDocs.has(document))) {
+                    queries.set(queryId, oq);
+                    if (queryName)
+                        queryNamesAndDocs.set(queryName, true);
+                    if (document)
+                        queryNamesAndDocs.set(document, true);
+                }
+            }
         });
-    };
-    QueryManager.prototype.markMutationResult = function (mutation, cache) {
-        var _this = this;
-        if (cache === void 0) { cache = this.cache; }
-        var result = mutation.result;
-        var cacheWrites = [];
-        var skipCache = mutation.fetchPolicy === "no-cache";
-        if (!skipCache && shouldWriteResult(result, mutation.errorPolicy)) {
-            if (!isExecutionPatchIncrementalResult(result)) {
-                cacheWrites.push({
-                    result: result.data,
-                    dataId: "ROOT_MUTATION",
-                    query: mutation.document,
-                    variables: mutation.variables,
+        if (legacyQueryOptions.size) {
+            legacyQueryOptions.forEach(function (options) {
+                var queryId = makeUniqueId("legacyOneTimeQuery");
+                var queryInfo = _this.getQuery(queryId).init({
+                    document: options.query,
+                    variables: options.variables,
                 });
-            }
-            if (isExecutionPatchIncrementalResult(result) &&
-                isNonEmptyArray(result.incremental)) {
-                var diff = cache.diff({
-                    id: "ROOT_MUTATION",
-                    query: this.getDocumentInfo(mutation.document).asQuery,
-                    variables: mutation.variables,
-                    optimistic: false,
-                    returnPartialData: true,
+                var oq = new ObservableQuery({
+                    queryManager: _this,
+                    queryInfo: queryInfo,
+                    options: tslib.__assign(tslib.__assign({}, options), { fetchPolicy: "network-only" }),
                 });
-                var mergedData = void 0;
-                if (diff.result) {
-                    mergedData = mergeIncrementalData(diff.result, result);
-                }
-                if (typeof mergedData !== "undefined") {
-                    result.data = mergedData;
-                    cacheWrites.push({
-                        result: mergedData,
-                        dataId: "ROOT_MUTATION",
-                        query: mutation.document,
-                        variables: mutation.variables,
-                    });
+                invariant(oq.queryId === queryId);
+                queryInfo.setObservableQuery(oq);
+                queries.set(queryId, oq);
+            });
+        }
+        if (globalThis.__DEV__ !== false && queryNamesAndDocs.size) {
+            queryNamesAndDocs.forEach(function (included, nameOrDoc) {
+                if (!included) {
+                    globalThis.__DEV__ !== false && invariant.warn(typeof nameOrDoc === "string" ? 33 : 34, nameOrDoc);
                 }
+            });
+        }
+        return queries;
+    };
+    QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {
+        var _this = this;
+        if (includeStandby === void 0) { includeStandby = false; }
+        var observableQueryPromises = [];
+        this.getObservableQueries(includeStandby ? "all" : "active").forEach(function (observableQuery, queryId) {
+            var fetchPolicy = observableQuery.options.fetchPolicy;
+            observableQuery.resetLastResults();
+            if (includeStandby ||
+                (fetchPolicy !== "standby" && fetchPolicy !== "cache-only")) {
+                observableQueryPromises.push(observableQuery.refetch());
             }
-            var updateQueries_1 = mutation.updateQueries;
-            if (updateQueries_1) {
-                this.queries.forEach(function (_a, queryId) {
-                    var observableQuery = _a.observableQuery;
-                    var queryName = observableQuery && observableQuery.queryName;
-                    if (!queryName || !hasOwnProperty$1.call(updateQueries_1, queryName)) {
-                        return;
-                    }
-                    var updater = updateQueries_1[queryName];
-                    var _b = _this.queries.get(queryId), document = _b.document, variables = _b.variables;
-                    var _c = cache.diff({
-                        query: document,
-                        variables: variables,
-                        returnPartialData: true,
-                        optimistic: false,
-                    }), currentQueryResult = _c.result, complete = _c.complete;
-                    if (complete && currentQueryResult) {
-                        var nextQueryResult = updater(currentQueryResult, {
-                            mutationResult: result,
-                            queryName: (document && getOperationName(document)) || void 0,
-                            queryVariables: variables,
+            _this.getQuery(queryId).setDiff(null);
+        });
+        this.broadcastQueries();
+        return Promise.all(observableQueryPromises);
+    };
+    QueryManager.prototype.setObservableQuery = function (observableQuery) {
+        this.getQuery(observableQuery.queryId).setObservableQuery(observableQuery);
+    };
+    QueryManager.prototype.startGraphQLSubscription = function (_a) {
+        var _this = this;
+        var query = _a.query, fetchPolicy = _a.fetchPolicy, _b = _a.errorPolicy, errorPolicy = _b === void 0 ? "none" : _b, variables = _a.variables, _c = _a.context, context = _c === void 0 ? {} : _c, _d = _a.extensions, extensions = _d === void 0 ? {} : _d;
+        query = this.transform(query);
+        variables = this.getVariables(query, variables);
+        var makeObservable = function (variables) {
+            return _this.getObservableFromLink(query, context, variables, extensions).map(function (result) {
+                if (fetchPolicy !== "no-cache") {
+                    if (shouldWriteResult(result, errorPolicy)) {
+                        _this.cache.write({
+                            query: query,
+                            result: result.data,
+                            dataId: "ROOT_SUBSCRIPTION",
+                            variables: variables,
                         });
-                        if (nextQueryResult) {
-                            cacheWrites.push({
-                                result: nextQueryResult,
-                                dataId: "ROOT_QUERY",
-                                query: document,
-                                variables: variables,
-                            });
-                        }
                     }
-                });
-            }
-        }
-        if (cacheWrites.length > 0 ||
-            (mutation.refetchQueries || "").length > 0 ||
-            mutation.update ||
-            mutation.onQueryUpdated ||
-            mutation.removeOptimistic) {
-            var results_1 = [];
-            this.refetchQueries({
-                updateCache: function (cache) {
-                    if (!skipCache) {
-                        cacheWrites.forEach(function (write) { return cache.write(write); });
+                    _this.broadcastQueries();
+                }
+                var hasErrors = graphQLResultHasError(result);
+                var hasProtocolErrors = graphQLResultHasProtocolErrors(result);
+                if (hasErrors || hasProtocolErrors) {
+                    var errors = {};
+                    if (hasErrors) {
+                        errors.graphQLErrors = result.errors;
                     }
-                    var update = mutation.update;
-                    var isFinalResult = !isExecutionPatchResult(result) ||
-                        (isExecutionPatchIncrementalResult(result) && !result.hasNext);
-                    if (update) {
-                        if (!skipCache) {
-                            var diff = cache.diff({
-                                id: "ROOT_MUTATION",
-                                query: _this.getDocumentInfo(mutation.document).asQuery,
-                                variables: mutation.variables,
-                                optimistic: false,
-                                returnPartialData: true,
-                            });
-                            if (diff.complete) {
-                                result = tslib.__assign(tslib.__assign({}, result), { data: diff.result });
-                                if ("incremental" in result) {
-                                    delete result.incremental;
-                                }
-                                if ("hasNext" in result) {
-                                    delete result.hasNext;
-                                }
-                            }
-                        }
-                        if (isFinalResult) {
-                            update(cache, result, {
-                                context: mutation.context,
-                                variables: mutation.variables,
-                            });
-                        }
+                    if (hasProtocolErrors) {
+                        errors.protocolErrors = result.extensions[PROTOCOL_ERRORS_SYMBOL];
                     }
-                    if (!skipCache && !mutation.keepRootFields && isFinalResult) {
-                        cache.modify({
-                            id: "ROOT_MUTATION",
-                            fields: function (value, _a) {
-                                var fieldName = _a.fieldName, DELETE = _a.DELETE;
-                                return fieldName === "__typename" ? value : DELETE;
-                            },
-                        });
+                    if (errorPolicy === "none" || hasProtocolErrors) {
+                        throw new ApolloError(errors);
                     }
-                },
-                include: mutation.refetchQueries,
-                optimistic: false,
-                removeOptimistic: mutation.removeOptimistic,
-                onQueryUpdated: mutation.onQueryUpdated || null,
-            }).forEach(function (result) { return results_1.push(result); });
-            if (mutation.awaitRefetchQueries || mutation.onQueryUpdated) {
-                return Promise.all(results_1).then(function () { return result; });
-            }
-        }
-        return Promise.resolve(result);
-    };
-    QueryManager.prototype.markMutationOptimistic = function (optimisticResponse, mutation) {
-        var _this = this;
-        var data = typeof optimisticResponse === "function" ?
-            optimisticResponse(mutation.variables, { IGNORE: IGNORE })
-            : optimisticResponse;
-        if (data === IGNORE) {
-            return false;
+                }
+                if (errorPolicy === "ignore") {
+                    delete result.errors;
+                }
+                return result;
+            });
+        };
+        if (this.getDocumentInfo(query).hasClientExports) {
+            var observablePromise_1 = this.localState
+                .addExportedVariables(query, variables, context)
+                .then(makeObservable);
+            return new zenObservableTs.Observable(function (observer) {
+                var sub = null;
+                observablePromise_1.then(function (observable) { return (sub = observable.subscribe(observer)); }, observer.error);
+                return function () { return sub && sub.unsubscribe(); };
+            });
         }
-        this.cache.recordOptimisticTransaction(function (cache) {
-            try {
-                _this.markMutationResult(tslib.__assign(tslib.__assign({}, mutation), { result: { data: data } }), cache);
-            }
-            catch (error) {
-                globalThis.__DEV__ !== false && invariant.error(error);
-            }
-        }, mutation.mutationId);
-        return true;
+        return makeObservable(variables);
     };
-    QueryManager.prototype.fetchQuery = function (queryId, options, networkStatus) {
-        return this.fetchConcastWithInfo(queryId, options, networkStatus).concast
-            .promise;
+    QueryManager.prototype.stopQuery = function (queryId) {
+        this.stopQueryNoBroadcast(queryId);
+        this.broadcastQueries();
     };
-    QueryManager.prototype.getQueryStore = function () {
-        var store = Object.create(null);
-        this.queries.forEach(function (info, queryId) {
-            store[queryId] = {
-                variables: info.variables,
-                networkStatus: info.networkStatus,
-                networkError: info.networkError,
-                graphQLErrors: info.graphQLErrors,
-            };
-        });
-        return store;
+    QueryManager.prototype.stopQueryNoBroadcast = function (queryId) {
+        this.stopQueryInStoreNoBroadcast(queryId);
+        this.removeQuery(queryId);
     };
-    QueryManager.prototype.resetErrors = function (queryId) {
-        var queryInfo = this.queries.get(queryId);
-        if (queryInfo) {
-            queryInfo.networkError = undefined;
-            queryInfo.graphQLErrors = [];
+    QueryManager.prototype.removeQuery = function (queryId) {
+        this.fetchCancelFns.delete(queryId);
+        if (this.queries.has(queryId)) {
+            this.getQuery(queryId).stop();
+            this.queries.delete(queryId);
         }
     };
-    QueryManager.prototype.transform = function (document) {
-        return this.documentTransform.transformDocument(document);
+    QueryManager.prototype.broadcastQueries = function () {
+        if (this.onBroadcast)
+            this.onBroadcast();
+        this.queries.forEach(function (info) { return info.notify(); });
     };
-    QueryManager.prototype.getDocumentInfo = function (document) {
-        var transformCache = this.transformCache;
-        if (!transformCache.has(document)) {
-            var cacheEntry = {
-                hasClientExports: hasClientExports(document),
-                hasForcedResolvers: this.localState.shouldForceResolvers(document),
-                hasNonreactiveDirective: hasDirectives(["nonreactive"], document),
-                clientQuery: this.localState.clientQuery(document),
-                serverQuery: removeDirectivesFromDocument([
-                    { name: "client", remove: true },
-                    { name: "connection" },
-                    { name: "nonreactive" },
-                ], document),
-                defaultVars: getDefaultValues(getOperationDefinition(document)),
-                asQuery: tslib.__assign(tslib.__assign({}, document), { definitions: document.definitions.map(function (def) {
-                        if (def.kind === "OperationDefinition" &&
-                            def.operation !== "query") {
-                            return tslib.__assign(tslib.__assign({}, def), { operation: "query" });
-                        }
-                        return def;
-                    }) }),
+    QueryManager.prototype.getLocalState = function () {
+        return this.localState;
+    };
+    QueryManager.prototype.getObservableFromLink = function (query, context, variables, extensions,
+    deduplication) {
+        var _this = this;
+        var _a;
+        if (deduplication === void 0) { deduplication = (_a = context === null || context === void 0 ? void 0 : context.queryDeduplication) !== null && _a !== void 0 ? _a : this.queryDeduplication; }
+        var observable;
+        var _b = this.getDocumentInfo(query), serverQuery = _b.serverQuery, clientQuery = _b.clientQuery;
+        if (serverQuery) {
+            var _c = this, inFlightLinkObservables_1 = _c.inFlightLinkObservables, link = _c.link;
+            var operation = {
+                query: serverQuery,
+                variables: variables,
+                operationName: getOperationName(serverQuery) || void 0,
+                context: this.prepareContext(tslib.__assign(tslib.__assign({}, context), { forceFetch: !deduplication })),
+                extensions: extensions,
             };
-            transformCache.set(document, cacheEntry);
+            context = operation.context;
+            if (deduplication) {
+                var printedServerQuery_1 = print(serverQuery);
+                var varJson_1 = canonicalStringify(variables);
+                var entry = inFlightLinkObservables_1.lookup(printedServerQuery_1, varJson_1);
+                observable = entry.observable;
+                if (!observable) {
+                    var concast = new Concast([
+                        execute(link, operation),
+                    ]);
+                    observable = entry.observable = concast;
+                    concast.beforeNext(function () {
+                        inFlightLinkObservables_1.remove(printedServerQuery_1, varJson_1);
+                    });
+                }
+            }
+            else {
+                observable = new Concast([
+                    execute(link, operation),
+                ]);
+            }
         }
-        return transformCache.get(document);
-    };
-    QueryManager.prototype.getVariables = function (document, variables) {
-        return tslib.__assign(tslib.__assign({}, this.getDocumentInfo(document).defaultVars), variables);
-    };
-    QueryManager.prototype.watchQuery = function (options) {
-        var query = this.transform(options.query);
-        options = tslib.__assign(tslib.__assign({}, options), { variables: this.getVariables(query, options.variables) });
-        if (typeof options.notifyOnNetworkStatusChange === "undefined") {
-            options.notifyOnNetworkStatusChange = false;
+        else {
+            observable = new Concast([zenObservableTs.Observable.of({ data: {} })]);
+            context = this.prepareContext(context);
         }
-        var queryInfo = new QueryInfo(this);
-        var observable = new ObservableQuery({
-            queryManager: this,
-            queryInfo: queryInfo,
-            options: options,
-        });
-        observable["lastQuery"] = query;
-        this.queries.set(observable.queryId, queryInfo);
-        queryInfo.init({
-            document: query,
-            observableQuery: observable,
-            variables: observable.variables,
+        if (clientQuery) {
+            observable = asyncMap(observable, function (result) {
+                return _this.localState.runResolvers({
+                    document: clientQuery,
+                    remoteResult: result,
+                    context: context,
+                    variables: variables,
+                });
+            });
+        }
+        return observable;
+    };
+    QueryManager.prototype.getResultsFromLink = function (queryInfo, cacheWriteBehavior, options) {
+        var requestId = (queryInfo.lastRequestId = this.generateRequestId());
+        var linkDocument = this.cache.transformForLink(options.query);
+        return asyncMap(this.getObservableFromLink(linkDocument, options.context, options.variables), function (result) {
+            var graphQLErrors = getGraphQLErrorsFromResult(result);
+            var hasErrors = graphQLErrors.length > 0;
+            if (requestId >= queryInfo.lastRequestId) {
+                if (hasErrors && options.errorPolicy === "none") {
+                    throw queryInfo.markError(new ApolloError({
+                        graphQLErrors: graphQLErrors,
+                    }));
+                }
+                queryInfo.markResult(result, linkDocument, options, cacheWriteBehavior);
+                queryInfo.markReady();
+            }
+            var aqr = {
+                data: result.data,
+                loading: false,
+                networkStatus: exports.NetworkStatus.ready,
+            };
+            if (hasErrors && options.errorPolicy !== "ignore") {
+                aqr.errors = graphQLErrors;
+                aqr.networkStatus = exports.NetworkStatus.error;
+            }
+            return aqr;
+        }, function (networkError) {
+            var error = isApolloError(networkError) ? networkError : (new ApolloError({ networkError: networkError }));
+            if (requestId >= queryInfo.lastRequestId) {
+                queryInfo.markError(error);
+            }
+            throw error;
         });
-        return observable;
     };
-    QueryManager.prototype.query = function (options, queryId) {
+    QueryManager.prototype.fetchConcastWithInfo = function (queryId, options,
+    networkStatus, query) {
         var _this = this;
-        if (queryId === void 0) { queryId = this.generateQueryId(); }
-        invariant(options.query, 28);
-        invariant(options.query.kind === "Document", 29);
-        invariant(!options.returnPartialData, 30);
-        invariant(!options.pollInterval, 31);
-        return this.fetchQuery(queryId, tslib.__assign(tslib.__assign({}, options), { query: this.transform(options.query) })).finally(function () { return _this.stopQuery(queryId); });
-    };
-    QueryManager.prototype.generateQueryId = function () {
-        return String(this.queryIdCounter++);
-    };
-    QueryManager.prototype.generateRequestId = function () {
-        return this.requestIdCounter++;
-    };
-    QueryManager.prototype.generateMutationId = function () {
-        return String(this.mutationIdCounter++);
-    };
-    QueryManager.prototype.stopQueryInStore = function (queryId) {
-        this.stopQueryInStoreNoBroadcast(queryId);
-        this.broadcastQueries();
-    };
-    QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {
-        var queryInfo = this.queries.get(queryId);
-        if (queryInfo)
-            queryInfo.stop();
-    };
-    QueryManager.prototype.clearStore = function (options) {
-        if (options === void 0) { options = {
-            discardWatches: true,
-        }; }
-        this.cancelPendingFetches(newInvariantError(32));
-        this.queries.forEach(function (queryInfo) {
-            if (queryInfo.observableQuery) {
-                queryInfo.networkStatus = exports.NetworkStatus.loading;
-            }
-            else {
-                queryInfo.stop();
+        if (networkStatus === void 0) { networkStatus = exports.NetworkStatus.loading; }
+        if (query === void 0) { query = options.query; }
+        var variables = this.getVariables(query, options.variables);
+        var queryInfo = this.getQuery(queryId);
+        var defaults = this.defaultOptions.watchQuery;
+        var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? (defaults && defaults.fetchPolicy) || "cache-first" : _a, _b = options.errorPolicy, errorPolicy = _b === void 0 ? (defaults && defaults.errorPolicy) || "none" : _b, _c = options.returnPartialData, returnPartialData = _c === void 0 ? false : _c, _d = options.notifyOnNetworkStatusChange, notifyOnNetworkStatusChange = _d === void 0 ? false : _d, _e = options.context, context = _e === void 0 ? {} : _e;
+        var normalized = Object.assign({}, options, {
+            query: query,
+            variables: variables,
+            fetchPolicy: fetchPolicy,
+            errorPolicy: errorPolicy,
+            returnPartialData: returnPartialData,
+            notifyOnNetworkStatusChange: notifyOnNetworkStatusChange,
+            context: context,
+        });
+        var fromVariables = function (variables) {
+            normalized.variables = variables;
+            var sourcesWithInfo = _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);
+            if (
+            normalized.fetchPolicy !== "standby" &&
+                sourcesWithInfo.sources.length > 0 &&
+                queryInfo.observableQuery) {
+                queryInfo.observableQuery["applyNextFetchPolicy"]("after-fetch", options);
             }
+            return sourcesWithInfo;
+        };
+        var cleanupCancelFn = function () { return _this.fetchCancelFns.delete(queryId); };
+        this.fetchCancelFns.set(queryId, function (reason) {
+            cleanupCancelFn();
+            setTimeout(function () { return concast.cancel(reason); });
         });
-        if (this.mutationStore) {
-            this.mutationStore = Object.create(null);
+        var concast, containsDataFromLink;
+        if (this.getDocumentInfo(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;
         }
-        return this.cache.reset(options);
+        else {
+            var sourcesWithInfo = fromVariables(normalized.variables);
+            containsDataFromLink = sourcesWithInfo.fromLink;
+            concast = new Concast(sourcesWithInfo.sources);
+        }
+        concast.promise.then(cleanupCancelFn, cleanupCancelFn);
+        return {
+            concast: concast,
+            fromLink: containsDataFromLink,
+        };
     };
-    QueryManager.prototype.getObservableQueries = function (include) {
+    QueryManager.prototype.refetchQueries = function (_a) {
         var _this = this;
-        if (include === void 0) { include = "active"; }
-        var queries = new Map();
-        var queryNamesAndDocs = new Map();
-        var legacyQueryOptions = new Set();
-        if (Array.isArray(include)) {
-            include.forEach(function (desc) {
-                if (typeof desc === "string") {
-                    queryNamesAndDocs.set(desc, false);
+        var updateCache = _a.updateCache, include = _a.include, _b = _a.optimistic, optimistic = _b === void 0 ? false : _b, _c = _a.removeOptimistic, removeOptimistic = _c === void 0 ? optimistic ? makeUniqueId("refetchQueries") : void 0 : _c, onQueryUpdated = _a.onQueryUpdated;
+        var includedQueriesById = new Map();
+        if (include) {
+            this.getObservableQueries(include).forEach(function (oq, queryId) {
+                includedQueriesById.set(queryId, {
+                    oq: oq,
+                    lastDiff: _this.getQuery(queryId).getDiff(),
+                });
+            });
+        }
+        var results = new Map();
+        if (updateCache) {
+            this.cache.batch({
+                update: updateCache,
+                optimistic: (optimistic && removeOptimistic) || false,
+                removeOptimistic: removeOptimistic,
+                onWatchUpdated: function (watch, diff, lastDiff) {
+                    var oq = watch.watcher instanceof QueryInfo && watch.watcher.observableQuery;
+                    if (oq) {
+                        if (onQueryUpdated) {
+                            includedQueriesById.delete(oq.queryId);
+                            var result = onQueryUpdated(oq, diff, lastDiff);
+                            if (result === true) {
+                                result = oq.refetch();
+                            }
+                            if (result !== false) {
+                                results.set(oq, result);
+                            }
+                            return result;
+                        }
+                        if (onQueryUpdated !== null) {
+                            includedQueriesById.set(oq.queryId, { oq: oq, lastDiff: lastDiff, diff: diff });
+                        }
+                    }
+                },
+            });
+        }
+        if (includedQueriesById.size) {
+            includedQueriesById.forEach(function (_a, queryId) {
+                var oq = _a.oq, lastDiff = _a.lastDiff, diff = _a.diff;
+                var result;
+                if (onQueryUpdated) {
+                    if (!diff) {
+                        var info = oq["queryInfo"];
+                        info.reset();
+                        diff = info.getDiff();
+                    }
+                    result = onQueryUpdated(oq, diff, lastDiff);
                 }
-                else if (isDocumentNode(desc)) {
-                    queryNamesAndDocs.set(_this.transform(desc), false);
+                if (!onQueryUpdated || result === true) {
+                    result = oq.refetch();
                 }
-                else if (isNonNullObject(desc) && desc.query) {
-                    legacyQueryOptions.add(desc);
+                if (result !== false) {
+                    results.set(oq, result);
+                }
+                if (queryId.indexOf("legacyOneTimeQuery") >= 0) {
+                    _this.stopQueryNoBroadcast(queryId);
                 }
             });
         }
-        this.queries.forEach(function (_a, queryId) {
-            var oq = _a.observableQuery, document = _a.document;
-            if (oq) {
-                if (include === "all") {
-                    queries.set(queryId, oq);
-                    return;
+        if (removeOptimistic) {
+            this.cache.removeOptimistic(removeOptimistic);
+        }
+        return results;
+    };
+    QueryManager.prototype.fetchQueryByPolicy = function (queryInfo, _a,
+    networkStatus) {
+        var _this = this;
+        var query = _a.query, variables = _a.variables, fetchPolicy = _a.fetchPolicy, refetchWritePolicy = _a.refetchWritePolicy, errorPolicy = _a.errorPolicy, returnPartialData = _a.returnPartialData, context = _a.context, notifyOnNetworkStatusChange = _a.notifyOnNetworkStatusChange;
+        var oldNetworkStatus = queryInfo.networkStatus;
+        queryInfo.init({
+            document: query,
+            variables: variables,
+            networkStatus: networkStatus,
+        });
+        var readCache = function () { return queryInfo.getDiff(); };
+        var resultsFromCache = function (diff, networkStatus) {
+            if (networkStatus === void 0) { networkStatus = queryInfo.networkStatus || exports.NetworkStatus.loading; }
+            var data = diff.result;
+            if (globalThis.__DEV__ !== false && !returnPartialData && !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 })));
+            };
+            if (data && _this.getDocumentInfo(query).hasForcedResolvers) {
+                return _this.localState
+                    .runResolvers({
+                    document: query,
+                    remoteResult: { data: data },
+                    context: context,
+                    variables: variables,
+                    onlyRunForcedResolvers: true,
+                })
+                    .then(function (resolved) { return fromData(resolved.data || void 0); });
+            }
+            if (errorPolicy === "none" &&
+                networkStatus === exports.NetworkStatus.refetch &&
+                Array.isArray(diff.missing)) {
+                return fromData(void 0);
+            }
+            return fromData(data);
+        };
+        var cacheWriteBehavior = fetchPolicy === "no-cache" ? 0
+            : (networkStatus === exports.NetworkStatus.refetch &&
+                refetchWritePolicy !== "merge") ?
+                1
+                : 2 ;
+        var resultsFromLink = function () {
+            return _this.getResultsFromLink(queryInfo, cacheWriteBehavior, {
+                query: query,
+                variables: variables,
+                context: context,
+                fetchPolicy: fetchPolicy,
+                errorPolicy: errorPolicy,
+            });
+        };
+        var shouldNotify = notifyOnNetworkStatusChange &&
+            typeof oldNetworkStatus === "number" &&
+            oldNetworkStatus !== networkStatus &&
+            isNetworkRequestInFlight(networkStatus);
+        switch (fetchPolicy) {
+            default:
+            case "cache-first": {
+                var diff = readCache();
+                if (diff.complete) {
+                    return {
+                        fromLink: false,
+                        sources: [resultsFromCache(diff, queryInfo.markReady())],
+                    };
                 }
-                var queryName = oq.queryName, fetchPolicy = oq.options.fetchPolicy;
-                if (fetchPolicy === "standby" ||
-                    (include === "active" && !oq.hasObservers())) {
-                    return;
+                if (returnPartialData || shouldNotify) {
+                    return {
+                        fromLink: true,
+                        sources: [resultsFromCache(diff), resultsFromLink()],
+                    };
                 }
-                if (include === "active" ||
-                    (queryName && queryNamesAndDocs.has(queryName)) ||
-                    (document && queryNamesAndDocs.has(document))) {
-                    queries.set(queryId, oq);
-                    if (queryName)
-                        queryNamesAndDocs.set(queryName, true);
-                    if (document)
-                        queryNamesAndDocs.set(document, true);
+                return { fromLink: true, sources: [resultsFromLink()] };
+            }
+            case "cache-and-network": {
+                var diff = readCache();
+                if (diff.complete || returnPartialData || shouldNotify) {
+                    return {
+                        fromLink: true,
+                        sources: [resultsFromCache(diff), resultsFromLink()],
+                    };
                 }
+                return { fromLink: true, sources: [resultsFromLink()] };
             }
-        });
-        if (legacyQueryOptions.size) {
-            legacyQueryOptions.forEach(function (options) {
-                var queryId = makeUniqueId("legacyOneTimeQuery");
-                var queryInfo = _this.getQuery(queryId).init({
-                    document: options.query,
-                    variables: options.variables,
-                });
-                var oq = new ObservableQuery({
-                    queryManager: _this,
-                    queryInfo: queryInfo,
-                    options: tslib.__assign(tslib.__assign({}, options), { fetchPolicy: "network-only" }),
-                });
-                invariant(oq.queryId === queryId);
-                queryInfo.setObservableQuery(oq);
-                queries.set(queryId, oq);
-            });
-        }
-        if (globalThis.__DEV__ !== false && queryNamesAndDocs.size) {
-            queryNamesAndDocs.forEach(function (included, nameOrDoc) {
-                if (!included) {
-                    globalThis.__DEV__ !== false && invariant.warn(typeof nameOrDoc === "string" ? 33 : 34, nameOrDoc);
+            case "cache-only":
+                return {
+                    fromLink: false,
+                    sources: [resultsFromCache(readCache(), queryInfo.markReady())],
+                };
+            case "network-only":
+                if (shouldNotify) {
+                    return {
+                        fromLink: true,
+                        sources: [resultsFromCache(readCache()), resultsFromLink()],
+                    };
                 }
-            });
+                return { fromLink: true, sources: [resultsFromLink()] };
+            case "no-cache":
+                if (shouldNotify) {
+                    return {
+                        fromLink: true,
+                        sources: [resultsFromCache(queryInfo.getDiff()), resultsFromLink()],
+                    };
+                }
+                return { fromLink: true, sources: [resultsFromLink()] };
+            case "standby":
+                return { fromLink: false, sources: [] };
         }
-        return queries;
     };
-    QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {
-        var _this = this;
-        if (includeStandby === void 0) { includeStandby = false; }
-        var observableQueryPromises = [];
-        this.getObservableQueries(includeStandby ? "all" : "active").forEach(function (observableQuery, queryId) {
-            var fetchPolicy = observableQuery.options.fetchPolicy;
-            observableQuery.resetLastResults();
-            if (includeStandby ||
-                (fetchPolicy !== "standby" && fetchPolicy !== "cache-only")) {
-                observableQueryPromises.push(observableQuery.refetch());
-            }
-            _this.getQuery(queryId).setDiff(null);
-        });
-        this.broadcastQueries();
-        return Promise.all(observableQueryPromises);
+    QueryManager.prototype.getQuery = function (queryId) {
+        if (queryId && !this.queries.has(queryId)) {
+            this.queries.set(queryId, new QueryInfo(this, queryId));
+        }
+        return this.queries.get(queryId);
     };
-    QueryManager.prototype.setObservableQuery = function (observableQuery) {
-        this.getQuery(observableQuery.queryId).setObservableQuery(observableQuery);
+    QueryManager.prototype.prepareContext = function (context) {
+        if (context === void 0) { context = {}; }
+        var newContext = this.localState.prepareContext(context);
+        return tslib.__assign(tslib.__assign(tslib.__assign({}, this.defaultContext), newContext), { clientAwareness: this.clientAwareness });
     };
-    QueryManager.prototype.startGraphQLSubscription = function (_a) {
+    return QueryManager;
+}());
+
+var LocalState =  (function () {
+    function LocalState(_a) {
+        var cache = _a.cache, client = _a.client, resolvers = _a.resolvers, fragmentMatcher = _a.fragmentMatcher;
+        this.selectionsToResolveCache = new WeakMap();
+        this.cache = cache;
+        if (client) {
+            this.client = client;
+        }
+        if (resolvers) {
+            this.addResolvers(resolvers);
+        }
+        if (fragmentMatcher) {
+            this.setFragmentMatcher(fragmentMatcher);
+        }
+    }
+    LocalState.prototype.addResolvers = function (resolvers) {
         var _this = this;
-        var query = _a.query, fetchPolicy = _a.fetchPolicy, _b = _a.errorPolicy, errorPolicy = _b === void 0 ? "none" : _b, variables = _a.variables, _c = _a.context, context = _c === void 0 ? {} : _c, _d = _a.extensions, extensions = _d === void 0 ? {} : _d;
-        query = this.transform(query);
-        variables = this.getVariables(query, variables);
-        var makeObservable = function (variables) {
-            return _this.getObservableFromLink(query, context, variables, extensions).map(function (result) {
-                if (fetchPolicy !== "no-cache") {
-                    if (shouldWriteResult(result, errorPolicy)) {
-                        _this.cache.write({
-                            query: query,
-                            result: result.data,
-                            dataId: "ROOT_SUBSCRIPTION",
-                            variables: variables,
-                        });
-                    }
-                    _this.broadcastQueries();
-                }
-                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];
-                    }
-                    if (errorPolicy === "none" || hasProtocolErrors) {
-                        throw new ApolloError(errors);
-                    }
-                }
-                if (errorPolicy === "ignore") {
-                    delete result.errors;
-                }
-                return result;
-            });
-        };
-        if (this.getDocumentInfo(query).hasClientExports) {
-            var observablePromise_1 = this.localState
-                .addExportedVariables(query, variables, context)
-                .then(makeObservable);
-            return new zenObservableTs.Observable(function (observer) {
-                var sub = null;
-                observablePromise_1.then(function (observable) { return (sub = observable.subscribe(observer)); }, observer.error);
-                return function () { return sub && sub.unsubscribe(); };
+        this.resolvers = this.resolvers || {};
+        if (Array.isArray(resolvers)) {
+            resolvers.forEach(function (resolverGroup) {
+                _this.resolvers = mergeDeep(_this.resolvers, resolverGroup);
             });
         }
-        return makeObservable(variables);
-    };
-    QueryManager.prototype.stopQuery = function (queryId) {
-        this.stopQueryNoBroadcast(queryId);
-        this.broadcastQueries();
-    };
-    QueryManager.prototype.stopQueryNoBroadcast = function (queryId) {
-        this.stopQueryInStoreNoBroadcast(queryId);
-        this.removeQuery(queryId);
-    };
-    QueryManager.prototype.removeQuery = function (queryId) {
-        this.fetchCancelFns.delete(queryId);
-        if (this.queries.has(queryId)) {
-            this.getQuery(queryId).stop();
-            this.queries.delete(queryId);
+        else {
+            this.resolvers = mergeDeep(this.resolvers, resolvers);
         }
     };
-    QueryManager.prototype.broadcastQueries = function () {
-        if (this.onBroadcast)
-            this.onBroadcast();
-        this.queries.forEach(function (info) { return info.notify(); });
+    LocalState.prototype.setResolvers = function (resolvers) {
+        this.resolvers = {};
+        this.addResolvers(resolvers);
     };
-    QueryManager.prototype.getLocalState = function () {
-        return this.localState;
+    LocalState.prototype.getResolvers = function () {
+        return this.resolvers || {};
     };
-    QueryManager.prototype.getObservableFromLink = function (query, context, variables, extensions,
-    deduplication) {
-        var _this = this;
-        var _a;
-        if (deduplication === void 0) { deduplication = (_a = context === null || context === void 0 ? void 0 : context.queryDeduplication) !== null && _a !== void 0 ? _a : this.queryDeduplication; }
-        var observable;
-        var _b = this.getDocumentInfo(query), serverQuery = _b.serverQuery, clientQuery = _b.clientQuery;
-        if (serverQuery) {
-            var _c = this, inFlightLinkObservables_1 = _c.inFlightLinkObservables, link = _c.link;
-            var operation = {
-                query: serverQuery,
-                variables: variables,
-                operationName: getOperationName(serverQuery) || void 0,
-                context: this.prepareContext(tslib.__assign(tslib.__assign({}, context), { forceFetch: !deduplication })),
-                extensions: extensions,
-            };
-            context = operation.context;
-            if (deduplication) {
-                var printedServerQuery_1 = print(serverQuery);
-                var varJson_1 = canonicalStringify(variables);
-                var entry = inFlightLinkObservables_1.lookup(printedServerQuery_1, varJson_1);
-                observable = entry.observable;
-                if (!observable) {
-                    var concast = new Concast([
-                        execute(link, operation),
-                    ]);
-                    observable = entry.observable = concast;
-                    concast.beforeNext(function () {
-                        inFlightLinkObservables_1.remove(printedServerQuery_1, varJson_1);
-                    });
+    LocalState.prototype.runResolvers = function (_a) {
+        return tslib.__awaiter(this, arguments, void 0, function (_b) {
+            var document = _b.document, remoteResult = _b.remoteResult, context = _b.context, variables = _b.variables, _c = _b.onlyRunForcedResolvers, onlyRunForcedResolvers = _c === void 0 ? false : _c;
+            return tslib.__generator(this, function (_d) {
+                if (document) {
+                    return [2 , this.resolveDocument(document, remoteResult.data, context, variables, this.fragmentMatcher, onlyRunForcedResolvers).then(function (localResult) { return (tslib.__assign(tslib.__assign({}, remoteResult), { data: localResult.result })); })];
                 }
-            }
-            else {
-                observable = new Concast([
-                    execute(link, operation),
-                ]);
-            }
-        }
-        else {
-            observable = new Concast([zenObservableTs.Observable.of({ data: {} })]);
-            context = this.prepareContext(context);
-        }
-        if (clientQuery) {
-            observable = asyncMap(observable, function (result) {
-                return _this.localState.runResolvers({
-                    document: clientQuery,
-                    remoteResult: result,
-                    context: context,
-                    variables: variables,
-                });
+                return [2 , remoteResult];
             });
+        });
+    };
+    LocalState.prototype.setFragmentMatcher = function (fragmentMatcher) {
+        this.fragmentMatcher = fragmentMatcher;
+    };
+    LocalState.prototype.getFragmentMatcher = function () {
+        return this.fragmentMatcher;
+    };
+    LocalState.prototype.clientQuery = function (document) {
+        if (hasDirectives(["client"], document)) {
+            if (this.resolvers) {
+                return document;
+            }
         }
-        return observable;
+        return null;
     };
-    QueryManager.prototype.getResultsFromLink = function (queryInfo, cacheWriteBehavior, options) {
-        var requestId = (queryInfo.lastRequestId = this.generateRequestId());
-        var linkDocument = this.cache.transformForLink(options.query);
-        return asyncMap(this.getObservableFromLink(linkDocument, options.context, options.variables), function (result) {
-            var graphQLErrors = getGraphQLErrorsFromResult(result);
-            var hasErrors = graphQLErrors.length > 0;
-            if (requestId >= queryInfo.lastRequestId) {
-                if (hasErrors && options.errorPolicy === "none") {
-                    throw queryInfo.markError(new ApolloError({
-                        graphQLErrors: graphQLErrors,
-                    }));
+    LocalState.prototype.serverQuery = function (document) {
+        return removeClientSetsFromDocument(document);
+    };
+    LocalState.prototype.prepareContext = function (context) {
+        var cache = this.cache;
+        return tslib.__assign(tslib.__assign({}, context), { cache: cache,
+            getCacheKey: function (obj) {
+                return cache.identify(obj);
+            } });
+    };
+    LocalState.prototype.addExportedVariables = function (document_1) {
+        return tslib.__awaiter(this, arguments, void 0, function (document, variables, context) {
+            if (variables === void 0) { variables = {}; }
+            if (context === void 0) { context = {}; }
+            return tslib.__generator(this, function (_a) {
+                if (document) {
+                    return [2 , this.resolveDocument(document, this.buildRootValueFromCache(document, variables) || {}, this.prepareContext(context), variables).then(function (data) { return (tslib.__assign(tslib.__assign({}, variables), data.exportedVariables)); })];
                 }
-                queryInfo.markResult(result, linkDocument, options, cacheWriteBehavior);
-                queryInfo.markReady();
-            }
-            var aqr = {
-                data: result.data,
-                loading: false,
-                networkStatus: exports.NetworkStatus.ready,
-            };
-            if (hasErrors && options.errorPolicy !== "ignore") {
-                aqr.errors = graphQLErrors;
-                aqr.networkStatus = exports.NetworkStatus.error;
-            }
-            return aqr;
-        }, function (networkError) {
-            var error = isApolloError(networkError) ? networkError : (new ApolloError({ networkError: networkError }));
-            if (requestId >= queryInfo.lastRequestId) {
-                queryInfo.markError(error);
-            }
-            throw error;
+                return [2 , tslib.__assign({}, variables)];
+            });
         });
     };
-    QueryManager.prototype.fetchConcastWithInfo = function (queryId, options,
-    networkStatus, query) {
-        var _this = this;
-        if (networkStatus === void 0) { networkStatus = exports.NetworkStatus.loading; }
-        if (query === void 0) { query = options.query; }
-        var variables = this.getVariables(query, options.variables);
-        var queryInfo = this.getQuery(queryId);
-        var defaults = this.defaultOptions.watchQuery;
-        var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? (defaults && defaults.fetchPolicy) || "cache-first" : _a, _b = options.errorPolicy, errorPolicy = _b === void 0 ? (defaults && defaults.errorPolicy) || "none" : _b, _c = options.returnPartialData, returnPartialData = _c === void 0 ? false : _c, _d = options.notifyOnNetworkStatusChange, notifyOnNetworkStatusChange = _d === void 0 ? false : _d, _e = options.context, context = _e === void 0 ? {} : _e;
-        var normalized = Object.assign({}, options, {
-            query: query,
-            variables: variables,
-            fetchPolicy: fetchPolicy,
-            errorPolicy: errorPolicy,
-            returnPartialData: returnPartialData,
-            notifyOnNetworkStatusChange: notifyOnNetworkStatusChange,
-            context: context,
-        });
-        var fromVariables = function (variables) {
-            normalized.variables = variables;
-            var sourcesWithInfo = _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);
-            if (
-            normalized.fetchPolicy !== "standby" &&
-                sourcesWithInfo.sources.length > 0 &&
-                queryInfo.observableQuery) {
-                queryInfo.observableQuery["applyNextFetchPolicy"]("after-fetch", options);
-            }
-            return sourcesWithInfo;
-        };
-        var cleanupCancelFn = function () { return _this.fetchCancelFns.delete(queryId); };
-        this.fetchCancelFns.set(queryId, function (reason) {
-            cleanupCancelFn();
-            setTimeout(function () { return concast.cancel(reason); });
+    LocalState.prototype.shouldForceResolvers = function (document) {
+        var forceResolvers = false;
+        graphql.visit(document, {
+            Directive: {
+                enter: function (node) {
+                    if (node.name.value === "client" && node.arguments) {
+                        forceResolvers = node.arguments.some(function (arg) {
+                            return arg.name.value === "always" &&
+                                arg.value.kind === "BooleanValue" &&
+                                arg.value.value === true;
+                        });
+                        if (forceResolvers) {
+                            return graphql.BREAK;
+                        }
+                    }
+                },
+            },
         });
-        var concast, containsDataFromLink;
-        if (this.getDocumentInfo(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: concast,
-            fromLink: containsDataFromLink,
-        };
+        return forceResolvers;
     };
-    QueryManager.prototype.refetchQueries = function (_a) {
-        var _this = this;
-        var updateCache = _a.updateCache, include = _a.include, _b = _a.optimistic, optimistic = _b === void 0 ? false : _b, _c = _a.removeOptimistic, removeOptimistic = _c === void 0 ? optimistic ? makeUniqueId("refetchQueries") : void 0 : _c, onQueryUpdated = _a.onQueryUpdated;
-        var includedQueriesById = new Map();
-        if (include) {
-            this.getObservableQueries(include).forEach(function (oq, queryId) {
-                includedQueriesById.set(queryId, {
-                    oq: oq,
-                    lastDiff: _this.getQuery(queryId).getDiff(),
-                });
+    LocalState.prototype.buildRootValueFromCache = function (document, variables) {
+        return this.cache.diff({
+            query: buildQueryFromSelectionSet(document),
+            variables: variables,
+            returnPartialData: true,
+            optimistic: false,
+        }).result;
+    };
+    LocalState.prototype.resolveDocument = function (document_1, rootValue_1) {
+        return tslib.__awaiter(this, arguments, void 0, function (document, rootValue, context, variables, fragmentMatcher, onlyRunForcedResolvers) {
+            var mainDefinition, fragments, fragmentMap, selectionsToResolve, definitionOperation, defaultOperationType, _a, cache, client, execContext, isClientFieldDescendant;
+            if (context === void 0) { context = {}; }
+            if (variables === void 0) { variables = {}; }
+            if (fragmentMatcher === void 0) { fragmentMatcher = function () { return true; }; }
+            if (onlyRunForcedResolvers === void 0) { onlyRunForcedResolvers = false; }
+            return tslib.__generator(this, function (_b) {
+                mainDefinition = getMainDefinition(document);
+                fragments = getFragmentDefinitions(document);
+                fragmentMap = createFragmentMap(fragments);
+                selectionsToResolve = this.collectSelectionsToResolve(mainDefinition, fragmentMap);
+                definitionOperation = mainDefinition.operation;
+                defaultOperationType = definitionOperation ?
+                    definitionOperation.charAt(0).toUpperCase() +
+                        definitionOperation.slice(1)
+                    : "Query";
+                _a = this, cache = _a.cache, client = _a.client;
+                execContext = {
+                    fragmentMap: fragmentMap,
+                    context: tslib.__assign(tslib.__assign({}, context), { cache: cache, client: client }),
+                    variables: variables,
+                    fragmentMatcher: fragmentMatcher,
+                    defaultOperationType: defaultOperationType,
+                    exportedVariables: {},
+                    selectionsToResolve: selectionsToResolve,
+                    onlyRunForcedResolvers: onlyRunForcedResolvers,
+                };
+                isClientFieldDescendant = false;
+                return [2 , this.resolveSelectionSet(mainDefinition.selectionSet, isClientFieldDescendant, rootValue, execContext).then(function (result) { return ({
+                        result: result,
+                        exportedVariables: execContext.exportedVariables,
+                    }); })];
             });
-        }
-        var results = new Map();
-        if (updateCache) {
-            this.cache.batch({
-                update: updateCache,
-                optimistic: (optimistic && removeOptimistic) || false,
-                removeOptimistic: removeOptimistic,
-                onWatchUpdated: function (watch, diff, lastDiff) {
-                    var oq = watch.watcher instanceof QueryInfo && watch.watcher.observableQuery;
-                    if (oq) {
-                        if (onQueryUpdated) {
-                            includedQueriesById.delete(oq.queryId);
-                            var result = onQueryUpdated(oq, diff, lastDiff);
-                            if (result === true) {
-                                result = oq.refetch();
-                            }
-                            if (result !== false) {
-                                results.set(oq, result);
-                            }
-                            return result;
+        });
+    };
+    LocalState.prototype.resolveSelectionSet = function (selectionSet, isClientFieldDescendant, rootValue, execContext) {
+        return tslib.__awaiter(this, void 0, void 0, function () {
+            var fragmentMap, context, variables, resultsToMerge, execute;
+            var _this = this;
+            return tslib.__generator(this, function (_a) {
+                fragmentMap = execContext.fragmentMap, context = execContext.context, variables = execContext.variables;
+                resultsToMerge = [rootValue];
+                execute = function (selection) { return tslib.__awaiter(_this, void 0, void 0, function () {
+                    var fragment, typeCondition;
+                    return tslib.__generator(this, function (_a) {
+                        if (!isClientFieldDescendant &&
+                            !execContext.selectionsToResolve.has(selection)) {
+                            return [2 ];
                         }
-                        if (onQueryUpdated !== null) {
-                            includedQueriesById.set(oq.queryId, { oq: oq, lastDiff: lastDiff, diff: diff });
+                        if (!shouldInclude(selection, variables)) {
+                            return [2 ];
                         }
-                    }
-                },
+                        if (isField(selection)) {
+                            return [2 , this.resolveField(selection, isClientFieldDescendant, rootValue, execContext).then(function (fieldResult) {
+                                    var _a;
+                                    if (typeof fieldResult !== "undefined") {
+                                        resultsToMerge.push((_a = {},
+                                            _a[resultKeyNameFromField(selection)] = fieldResult,
+                                            _a));
+                                    }
+                                })];
+                        }
+                        if (isInlineFragment(selection)) {
+                            fragment = selection;
+                        }
+                        else {
+                            fragment = fragmentMap[selection.name.value];
+                            invariant(fragment, 18, selection.name.value);
+                        }
+                        if (fragment && fragment.typeCondition) {
+                            typeCondition = fragment.typeCondition.name.value;
+                            if (execContext.fragmentMatcher(rootValue, typeCondition, context)) {
+                                return [2 , this.resolveSelectionSet(fragment.selectionSet, isClientFieldDescendant, rootValue, execContext).then(function (fragmentResult) {
+                                        resultsToMerge.push(fragmentResult);
+                                    })];
+                            }
+                        }
+                        return [2 ];
+                    });
+                }); };
+                return [2 , Promise.all(selectionSet.selections.map(execute)).then(function () {
+                        return mergeDeepArray(resultsToMerge);
+                    })];
             });
-        }
-        if (includedQueriesById.size) {
-            includedQueriesById.forEach(function (_a, queryId) {
-                var oq = _a.oq, lastDiff = _a.lastDiff, diff = _a.diff;
-                var result;
-                if (onQueryUpdated) {
-                    if (!diff) {
-                        var info = oq["queryInfo"];
-                        info.reset();
-                        diff = info.getDiff();
-                    }
-                    result = onQueryUpdated(oq, diff, lastDiff);
-                }
-                if (!onQueryUpdated || result === true) {
-                    result = oq.refetch();
-                }
-                if (result !== false) {
-                    results.set(oq, result);
+        });
+    };
+    LocalState.prototype.resolveField = function (field, isClientFieldDescendant, rootValue, execContext) {
+        return tslib.__awaiter(this, void 0, void 0, function () {
+            var variables, fieldName, aliasedFieldName, aliasUsed, defaultResult, resultPromise, resolverType, resolverMap, resolve;
+            var _this = this;
+            return tslib.__generator(this, function (_a) {
+                if (!rootValue) {
+                    return [2 , null];
                 }
-                if (queryId.indexOf("legacyOneTimeQuery") >= 0) {
-                    _this.stopQueryNoBroadcast(queryId);
+                variables = execContext.variables;
+                fieldName = field.name.value;
+                aliasedFieldName = resultKeyNameFromField(field);
+                aliasUsed = fieldName !== aliasedFieldName;
+                defaultResult = rootValue[aliasedFieldName] || rootValue[fieldName];
+                resultPromise = Promise.resolve(defaultResult);
+                if (!execContext.onlyRunForcedResolvers ||
+                    this.shouldForceResolvers(field)) {
+                    resolverType = rootValue.__typename || execContext.defaultOperationType;
+                    resolverMap = this.resolvers && this.resolvers[resolverType];
+                    if (resolverMap) {
+                        resolve = resolverMap[aliasUsed ? fieldName : aliasedFieldName];
+                        if (resolve) {
+                            resultPromise = Promise.resolve(
+                            cacheSlot.withValue(this.cache, resolve, [
+                                rootValue,
+                                argumentsObjectFromField(field, variables),
+                                execContext.context,
+                                { field: field, fragmentMap: execContext.fragmentMap },
+                            ]));
+                        }
+                    }
                 }
+                return [2 , resultPromise.then(function (result) {
+                        var _a, _b;
+                        if (result === void 0) { result = defaultResult; }
+                        if (field.directives) {
+                            field.directives.forEach(function (directive) {
+                                if (directive.name.value === "export" && directive.arguments) {
+                                    directive.arguments.forEach(function (arg) {
+                                        if (arg.name.value === "as" && arg.value.kind === "StringValue") {
+                                            execContext.exportedVariables[arg.value.value] = result;
+                                        }
+                                    });
+                                }
+                            });
+                        }
+                        if (!field.selectionSet) {
+                            return result;
+                        }
+                        if (result == null) {
+                            return result;
+                        }
+                        var isClientField = (_b = (_a = field.directives) === null || _a === void 0 ? void 0 : _a.some(function (d) { return d.name.value === "client"; })) !== null && _b !== void 0 ? _b : false;
+                        if (Array.isArray(result)) {
+                            return _this.resolveSubSelectedArray(field, isClientFieldDescendant || isClientField, result, execContext);
+                        }
+                        if (field.selectionSet) {
+                            return _this.resolveSelectionSet(field.selectionSet, isClientFieldDescendant || isClientField, result, execContext);
+                        }
+                    })];
             });
-        }
-        if (removeOptimistic) {
-            this.cache.removeOptimistic(removeOptimistic);
-        }
-        return results;
+        });
     };
-    QueryManager.prototype.fetchQueryByPolicy = function (queryInfo, _a,
-    networkStatus) {
+    LocalState.prototype.resolveSubSelectedArray = function (field, isClientFieldDescendant, result, execContext) {
         var _this = this;
-        var query = _a.query, variables = _a.variables, fetchPolicy = _a.fetchPolicy, refetchWritePolicy = _a.refetchWritePolicy, errorPolicy = _a.errorPolicy, returnPartialData = _a.returnPartialData, context = _a.context, notifyOnNetworkStatusChange = _a.notifyOnNetworkStatusChange;
-        var oldNetworkStatus = queryInfo.networkStatus;
-        queryInfo.init({
-            document: query,
-            variables: variables,
-            networkStatus: networkStatus,
-        });
-        var readCache = function () { return queryInfo.getDiff(); };
-        var resultsFromCache = function (diff, networkStatus) {
-            if (networkStatus === void 0) { networkStatus = queryInfo.networkStatus || exports.NetworkStatus.loading; }
-            var data = diff.result;
-            if (globalThis.__DEV__ !== false && !returnPartialData && !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 })));
-            };
-            if (data && _this.getDocumentInfo(query).hasForcedResolvers) {
-                return _this.localState
-                    .runResolvers({
-                    document: query,
-                    remoteResult: { data: data },
-                    context: context,
-                    variables: variables,
-                    onlyRunForcedResolvers: true,
-                })
-                    .then(function (resolved) { return fromData(resolved.data || void 0); });
-            }
-            if (errorPolicy === "none" &&
-                networkStatus === exports.NetworkStatus.refetch &&
-                Array.isArray(diff.missing)) {
-                return fromData(void 0);
+        return Promise.all(result.map(function (item) {
+            if (item === null) {
+                return null;
             }
-            return fromData(data);
-        };
-        var cacheWriteBehavior = fetchPolicy === "no-cache" ? 0
-            : (networkStatus === exports.NetworkStatus.refetch &&
-                refetchWritePolicy !== "merge") ?
-                1
-                : 2 ;
-        var resultsFromLink = function () {
-            return _this.getResultsFromLink(queryInfo, cacheWriteBehavior, {
-                query: query,
-                variables: variables,
-                context: context,
-                fetchPolicy: fetchPolicy,
-                errorPolicy: errorPolicy,
-            });
-        };
-        var shouldNotify = notifyOnNetworkStatusChange &&
-            typeof oldNetworkStatus === "number" &&
-            oldNetworkStatus !== networkStatus &&
-            isNetworkRequestInFlight(networkStatus);
-        switch (fetchPolicy) {
-            default:
-            case "cache-first": {
-                var diff = readCache();
-                if (diff.complete) {
-                    return {
-                        fromLink: false,
-                        sources: [resultsFromCache(diff, queryInfo.markReady())],
-                    };
-                }
-                if (returnPartialData || shouldNotify) {
-                    return {
-                        fromLink: true,
-                        sources: [resultsFromCache(diff), resultsFromLink()],
-                    };
-                }
-                return { fromLink: true, sources: [resultsFromLink()] };
+            if (Array.isArray(item)) {
+                return _this.resolveSubSelectedArray(field, isClientFieldDescendant, item, execContext);
             }
-            case "cache-and-network": {
-                var diff = readCache();
-                if (diff.complete || returnPartialData || shouldNotify) {
-                    return {
-                        fromLink: true,
-                        sources: [resultsFromCache(diff), resultsFromLink()],
-                    };
-                }
-                return { fromLink: true, sources: [resultsFromLink()] };
+            if (field.selectionSet) {
+                return _this.resolveSelectionSet(field.selectionSet, isClientFieldDescendant, item, execContext);
             }
-            case "cache-only":
-                return {
-                    fromLink: false,
-                    sources: [resultsFromCache(readCache(), queryInfo.markReady())],
-                };
-            case "network-only":
-                if (shouldNotify) {
-                    return {
-                        fromLink: true,
-                        sources: [resultsFromCache(readCache()), resultsFromLink()],
-                    };
-                }
-                return { fromLink: true, sources: [resultsFromLink()] };
-            case "no-cache":
-                if (shouldNotify) {
-                    return {
-                        fromLink: true,
-                        sources: [resultsFromCache(queryInfo.getDiff()), resultsFromLink()],
-                    };
-                }
-                return { fromLink: true, sources: [resultsFromLink()] };
-            case "standby":
-                return { fromLink: false, sources: [] };
-        }
+        }));
     };
-    QueryManager.prototype.getQuery = function (queryId) {
-        if (queryId && !this.queries.has(queryId)) {
-            this.queries.set(queryId, new QueryInfo(this, queryId));
+    LocalState.prototype.collectSelectionsToResolve = function (mainDefinition, fragmentMap) {
+        var isSingleASTNode = function (node) { return !Array.isArray(node); };
+        var selectionsToResolveCache = this.selectionsToResolveCache;
+        function collectByDefinition(definitionNode) {
+            if (!selectionsToResolveCache.has(definitionNode)) {
+                var matches_1 = new Set();
+                selectionsToResolveCache.set(definitionNode, matches_1);
+                graphql.visit(definitionNode, {
+                    Directive: function (node, _, __, ___, ancestors) {
+                        if (node.name.value === "client") {
+                            ancestors.forEach(function (node) {
+                                if (isSingleASTNode(node) && graphql.isSelectionNode(node)) {
+                                    matches_1.add(node);
+                                }
+                            });
+                        }
+                    },
+                    FragmentSpread: function (spread, _, __, ___, ancestors) {
+                        var fragment = fragmentMap[spread.name.value];
+                        invariant(fragment, 19, spread.name.value);
+                        var fragmentSelections = collectByDefinition(fragment);
+                        if (fragmentSelections.size > 0) {
+                            ancestors.forEach(function (node) {
+                                if (isSingleASTNode(node) && graphql.isSelectionNode(node)) {
+                                    matches_1.add(node);
+                                }
+                            });
+                            matches_1.add(spread);
+                            fragmentSelections.forEach(function (selection) {
+                                matches_1.add(selection);
+                            });
+                        }
+                    },
+                });
+            }
+            return selectionsToResolveCache.get(definitionNode);
         }
-        return this.queries.get(queryId);
-    };
-    QueryManager.prototype.prepareContext = function (context) {
-        if (context === void 0) { context = {}; }
-        var newContext = this.localState.prepareContext(context);
-        return tslib.__assign(tslib.__assign(tslib.__assign({}, this.defaultContext), newContext), { clientAwareness: this.clientAwareness });
+        return collectByDefinition(mainDefinition);
     };
-    return QueryManager;
+    return LocalState;
 }());
 
 var hasSuggestedDevtools = false;
@@ -7017,7 +7012,7 @@ var ApolloClient =  (function () {
             },
             localState: this.localState,
             assumeImmutableResults: assumeImmutableResults,
-            onBroadcast: connectToDevTools ?
+            onBroadcast: this.devtoolsConfig.enabled ?
                 function () {
                     if (_this.devToolsHookCb) {
                         _this.devToolsHookCb({
@@ -7499,7 +7494,6 @@ function wrapHook(hookName, useHook, clientOrObsQuery) {
 }
 
 var hasOwnProperty = Object.prototype.hasOwnProperty;
-var originalResult = Symbol();
 function noop() { }
 var lastWatchOptions = Symbol();
 function useQuery(query, options) {
@@ -7562,10 +7556,8 @@ function useQueryInternals(query, options) {
     observable,
     client, options, watchQueryOptions);
     var obsQueryFields = React__namespace.useMemo(function () { return bindObservableMethods(observable); }, [observable]);
-    useHandleSkip(resultData,
-    observable, client, options, watchQueryOptions, disableNetworkFetches, isSyncSSR);
     useRegisterSSRObservable(observable, renderPromises, ssrAllowed);
-    var result = useObservableSubscriptionResult(resultData, observable, client, disableNetworkFetches, partialRefetch, isSyncSSR, {
+    var result = useObservableSubscriptionResult(resultData, observable, client, options, watchQueryOptions, disableNetworkFetches, partialRefetch, isSyncSSR, {
         onCompleted: options.onCompleted || noop,
         onError: options.onError || noop,
     });
@@ -7578,13 +7570,25 @@ function useQueryInternals(query, options) {
         onQueryExecuted: onQueryExecuted,
     };
 }
-function useObservableSubscriptionResult(resultData, observable, client, disableNetworkFetches, partialRefetch, skipSubscribing, callbacks) {
+function useObservableSubscriptionResult(resultData, observable, client, options, watchQueryOptions, disableNetworkFetches, partialRefetch, isSyncSSR, callbacks) {
     var callbackRef = React__namespace.useRef(callbacks);
     React__namespace.useEffect(function () {
         callbackRef.current = callbacks;
     });
+    var resultOverride = ((isSyncSSR || disableNetworkFetches) &&
+        options.ssr === false &&
+        !options.skip) ?
+        ssrDisabledResult
+        : options.skip || watchQueryOptions.fetchPolicy === "standby" ?
+            skipStandbyResult
+            : void 0;
+    var previousData = resultData.previousData;
+    var currentResultOverride = React__namespace.useMemo(function () {
+        return resultOverride &&
+            toQueryResult(resultOverride, previousData, observable, client);
+    }, [client, observable, resultOverride, previousData]);
     return useSyncExternalStore(React__namespace.useCallback(function (handleStoreChange) {
-        if (skipSubscribing) {
+        if (isSyncSSR) {
             return function () { };
         }
         var onNext = function () {
@@ -7622,15 +7626,17 @@ function useObservableSubscriptionResult(resultData, observable, client, disable
         };
     }, [
         disableNetworkFetches,
-        skipSubscribing,
+        isSyncSSR,
         observable,
         resultData,
         partialRefetch,
         client,
     ]), function () {
-        return getCurrentResult(resultData, observable, callbackRef.current, partialRefetch, client);
+        return currentResultOverride ||
+            getCurrentResult(resultData, observable, callbackRef.current, partialRefetch, client);
     }, function () {
-        return getCurrentResult(resultData, observable, callbackRef.current, partialRefetch, client);
+        return currentResultOverride ||
+            getCurrentResult(resultData, observable, callbackRef.current, partialRefetch, client);
     });
 }
 function useRegisterSSRObservable(observable, renderPromises, ssrAllowed) {
@@ -7641,23 +7647,6 @@ function useRegisterSSRObservable(observable, renderPromises, ssrAllowed) {
         }
     }
 }
-function useHandleSkip(
-resultData, observable, client, options, watchQueryOptions, disableNetworkFetches, isSyncSSR) {
-    if ((isSyncSSR || disableNetworkFetches) &&
-        options.ssr === false &&
-        !options.skip) {
-        resultData.current = toQueryResult(ssrDisabledResult, resultData.previousData, observable, client);
-    }
-    else if (options.skip || watchQueryOptions.fetchPolicy === "standby") {
-        resultData.current = toQueryResult(skipStandbyResult, resultData.previousData, observable, client);
-    }
-    else if (
-    resultData.current &&
-        (resultData.current[originalResult] === ssrDisabledResult ||
-            resultData.current[originalResult] === skipStandbyResult)) {
-        resultData.current = void 0;
-    }
-}
 function useResubscribeIfNecessary(
 resultData,
 observable, client, options, watchQueryOptions) {
@@ -7716,11 +7705,14 @@ function setResult(nextResult, resultData, observable, client, partialRefetch, f
     if (previousResult && previousResult.data) {
         resultData.previousData = previousResult.data;
     }
+    if (!nextResult.error && isNonEmptyArray(nextResult.errors)) {
+        nextResult.error = new ApolloError({ graphQLErrors: nextResult.errors });
+    }
     resultData.current = toQueryResult(unsafeHandlePartialRefetch(nextResult, observable, partialRefetch), resultData.previousData, observable, client);
     forceUpdate();
-    handleErrorOrCompleted(nextResult, previousResult === null || previousResult === void 0 ? void 0 : previousResult[originalResult], callbacks);
+    handleErrorOrCompleted(nextResult, previousResult === null || previousResult === void 0 ? void 0 : previousResult.networkStatus, callbacks);
 }
-function handleErrorOrCompleted(result, previousResult, callbacks) {
+function handleErrorOrCompleted(result, previousNetworkStatus, callbacks) {
     if (!result.loading) {
         var error_1 = toApolloError$1(result);
         Promise.resolve()
@@ -7729,7 +7721,7 @@ function handleErrorOrCompleted(result, previousResult, callbacks) {
                 callbacks.onError(error_1);
             }
             else if (result.data &&
-                (previousResult === null || previousResult === void 0 ? void 0 : previousResult.networkStatus) !== result.networkStatus &&
+                previousNetworkStatus !== result.networkStatus &&
                 result.networkStatus === exports.NetworkStatus.ready) {
                 callbacks.onCompleted(result.data);
             }
@@ -7759,10 +7751,6 @@ function toApolloError$1(result) {
 function toQueryResult(result, previousData, observable, client) {
     var data = result.data; result.partial; var resultWithoutPartial = tslib.__rest(result, ["data", "partial"]);
     var queryResult = tslib.__assign(tslib.__assign({ data: data }, resultWithoutPartial), { client: client, observable: observable, variables: observable.variables, called: result !== ssrDisabledResult && result !== skipStandbyResult, previousData: previousData });
-    Object.defineProperty(queryResult, originalResult, { value: result });
-    if (!queryResult.error && isNonEmptyArray(result.errors)) {
-        queryResult.error = new ApolloError({ graphQLErrors: result.errors });
-    }
     return queryResult;
 }
 function unsafeHandlePartialRefetch(result, observable, partialRefetch) {