houdini 1.0.0-next.1 → 1.0.0-next.2

package/build/test-esm/index.js

@@ -9520,18 +9520,18 @@ var require_execute = __commonJS({
       }
       var returnType = fieldDef.type;
       var resolveFn = (_fieldDef$resolve = fieldDef.resolve) !== null && _fieldDef$resolve !== void 0 ? _fieldDef$resolve : exeContext.fieldResolver;
-      var info2 = buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path2);
+      var info = buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path2);
       try {
         var args = (0, _values.getArgumentValues)(fieldDef, fieldNodes[0], exeContext.variableValues);
         var _contextValue = exeContext.contextValue;
-        var result = resolveFn(source, args, _contextValue, info2);
+        var result = resolveFn(source, args, _contextValue, info);
         var completed;
         if ((0, _isPromise.default)(result)) {
           completed = result.then(function(resolved) {
-            return completeValue(exeContext, returnType, fieldNodes, info2, path2, resolved);
+            return completeValue(exeContext, returnType, fieldNodes, info, path2, resolved);
           });
         } else {
-          completed = completeValue(exeContext, returnType, fieldNodes, info2, path2, result);
+          completed = completeValue(exeContext, returnType, fieldNodes, info, path2, result);
         }
         if ((0, _isPromise.default)(completed)) {
           return completed.then(void 0, function(rawError) {
@@ -9566,14 +9566,14 @@ var require_execute = __commonJS({
       exeContext.errors.push(error);
       return null;
     }
-    function completeValue(exeContext, returnType, fieldNodes, info2, path2, result) {
+    function completeValue(exeContext, returnType, fieldNodes, info, path2, result) {
       if (result instanceof Error) {
         throw result;
       }
       if ((0, _definition.isNonNullType)(returnType)) {
-        var completed = completeValue(exeContext, returnType.ofType, fieldNodes, info2, path2, result);
+        var completed = completeValue(exeContext, returnType.ofType, fieldNodes, info, path2, result);
         if (completed === null) {
-          throw new Error("Cannot return null for non-nullable field ".concat(info2.parentType.name, ".").concat(info2.fieldName, "."));
+          throw new Error("Cannot return null for non-nullable field ".concat(info.parentType.name, ".").concat(info.fieldName, "."));
         }
         return completed;
       }
@@ -9581,20 +9581,20 @@ var require_execute = __commonJS({
         return null;
       }
       if ((0, _definition.isListType)(returnType)) {
-        return completeListValue(exeContext, returnType, fieldNodes, info2, path2, result);
+        return completeListValue(exeContext, returnType, fieldNodes, info, path2, result);
       }
       if ((0, _definition.isLeafType)(returnType)) {
         return completeLeafValue(returnType, result);
       }
       if ((0, _definition.isAbstractType)(returnType)) {
-        return completeAbstractValue(exeContext, returnType, fieldNodes, info2, path2, result);
+        return completeAbstractValue(exeContext, returnType, fieldNodes, info, path2, result);
       }
       if ((0, _definition.isObjectType)(returnType)) {
-        return completeObjectValue(exeContext, returnType, fieldNodes, info2, path2, result);
+        return completeObjectValue(exeContext, returnType, fieldNodes, info, path2, result);
       }
       (0, _invariant.default)(0, "Cannot complete value of unexpected output type: " + (0, _inspect.default)(returnType));
     }
-    function completeListValue(exeContext, returnType, fieldNodes, info2, path2, result) {
+    function completeListValue(exeContext, returnType, fieldNodes, info, path2, result) {
       var itemType = returnType.ofType;
       var containsPromise = false;
       var completedResults = (0, _safeArrayFrom.default)(result, function(item, index) {
@@ -9603,10 +9603,10 @@ var require_execute = __commonJS({
           var completedItem;
           if ((0, _isPromise.default)(item)) {
             completedItem = item.then(function(resolved) {
-              return completeValue(exeContext, itemType, fieldNodes, info2, itemPath, resolved);
+              return completeValue(exeContext, itemType, fieldNodes, info, itemPath, resolved);
             });
           } else {
-            completedItem = completeValue(exeContext, itemType, fieldNodes, info2, itemPath, item);
+            completedItem = completeValue(exeContext, itemType, fieldNodes, info, itemPath, item);
           }
           if ((0, _isPromise.default)(completedItem)) {
             containsPromise = true;
@@ -9622,7 +9622,7 @@ var require_execute = __commonJS({
         }
       });
       if (completedResults == null) {
-        throw new _GraphQLError.GraphQLError('Expected Iterable, but did not find one for field "'.concat(info2.parentType.name, ".").concat(info2.fieldName, '".'));
+        throw new _GraphQLError.GraphQLError('Expected Iterable, but did not find one for field "'.concat(info.parentType.name, ".").concat(info.fieldName, '".'));
       }
       return containsPromise ? Promise.all(completedResults) : completedResults;
     }
@@ -9633,25 +9633,25 @@ var require_execute = __commonJS({
       }
       return serializedResult;
     }
-    function completeAbstractValue(exeContext, returnType, fieldNodes, info2, path2, result) {
+    function completeAbstractValue(exeContext, returnType, fieldNodes, info, path2, result) {
       var _returnType$resolveTy;
       var resolveTypeFn = (_returnType$resolveTy = returnType.resolveType) !== null && _returnType$resolveTy !== void 0 ? _returnType$resolveTy : exeContext.typeResolver;
       var contextValue = exeContext.contextValue;
-      var runtimeType = resolveTypeFn(result, contextValue, info2, returnType);
+      var runtimeType = resolveTypeFn(result, contextValue, info, returnType);
       if ((0, _isPromise.default)(runtimeType)) {
         return runtimeType.then(function(resolvedRuntimeType) {
-          return completeObjectValue(exeContext, ensureValidRuntimeType(resolvedRuntimeType, exeContext, returnType, fieldNodes, info2, result), fieldNodes, info2, path2, result);
+          return completeObjectValue(exeContext, ensureValidRuntimeType(resolvedRuntimeType, exeContext, returnType, fieldNodes, info, result), fieldNodes, info, path2, result);
         });
       }
-      return completeObjectValue(exeContext, ensureValidRuntimeType(runtimeType, exeContext, returnType, fieldNodes, info2, result), fieldNodes, info2, path2, result);
+      return completeObjectValue(exeContext, ensureValidRuntimeType(runtimeType, exeContext, returnType, fieldNodes, info, result), fieldNodes, info, path2, result);
     }
-    function ensureValidRuntimeType(runtimeTypeOrName, exeContext, returnType, fieldNodes, info2, result) {
+    function ensureValidRuntimeType(runtimeTypeOrName, exeContext, returnType, fieldNodes, info, result) {
       if (runtimeTypeOrName == null) {
-        throw new _GraphQLError.GraphQLError('Abstract type "'.concat(returnType.name, '" must resolve to an Object type at runtime for field "').concat(info2.parentType.name, ".").concat(info2.fieldName, '". Either the "').concat(returnType.name, '" type should provide a "resolveType" function or each possible type should provide an "isTypeOf" function.'), fieldNodes);
+        throw new _GraphQLError.GraphQLError('Abstract type "'.concat(returnType.name, '" must resolve to an Object type at runtime for field "').concat(info.parentType.name, ".").concat(info.fieldName, '". Either the "').concat(returnType.name, '" type should provide a "resolveType" function or each possible type should provide an "isTypeOf" function.'), fieldNodes);
       }
       var runtimeTypeName = (0, _definition.isNamedType)(runtimeTypeOrName) ? runtimeTypeOrName.name : runtimeTypeOrName;
       if (typeof runtimeTypeName !== "string") {
-        throw new _GraphQLError.GraphQLError('Abstract type "'.concat(returnType.name, '" must resolve to an Object type at runtime for field "').concat(info2.parentType.name, ".").concat(info2.fieldName, '" with ') + "value ".concat((0, _inspect.default)(result), ', received "').concat((0, _inspect.default)(runtimeTypeOrName), '".'));
+        throw new _GraphQLError.GraphQLError('Abstract type "'.concat(returnType.name, '" must resolve to an Object type at runtime for field "').concat(info.parentType.name, ".").concat(info.fieldName, '" with ') + "value ".concat((0, _inspect.default)(result), ', received "').concat((0, _inspect.default)(runtimeTypeOrName), '".'));
       }
       var runtimeType = exeContext.schema.getType(runtimeTypeName);
       if (runtimeType == null) {
@@ -9665,9 +9665,9 @@ var require_execute = __commonJS({
       }
       return runtimeType;
     }
-    function completeObjectValue(exeContext, returnType, fieldNodes, info2, path2, result) {
+    function completeObjectValue(exeContext, returnType, fieldNodes, info, path2, result) {
       if (returnType.isTypeOf) {
-        var isTypeOf = returnType.isTypeOf(result, exeContext.contextValue, info2);
+        var isTypeOf = returnType.isTypeOf(result, exeContext.contextValue, info);
         if ((0, _isPromise.default)(isTypeOf)) {
           return isTypeOf.then(function(resolvedIsTypeOf) {
             if (!resolvedIsTypeOf) {
@@ -9701,16 +9701,16 @@ var require_execute = __commonJS({
       }
       return subFieldNodes;
     }
-    var defaultTypeResolver = function defaultTypeResolver2(value, contextValue, info2, abstractType) {
+    var defaultTypeResolver = function defaultTypeResolver2(value, contextValue, info, abstractType) {
       if ((0, _isObjectLike.default)(value) && typeof value.__typename === "string") {
         return value.__typename;
       }
-      var possibleTypes = info2.schema.getPossibleTypes(abstractType);
+      var possibleTypes = info.schema.getPossibleTypes(abstractType);
       var promisedIsTypeOfResults = [];
       for (var i = 0; i < possibleTypes.length; i++) {
         var type = possibleTypes[i];
         if (type.isTypeOf) {
-          var isTypeOfResult = type.isTypeOf(value, contextValue, info2);
+          var isTypeOfResult = type.isTypeOf(value, contextValue, info);
           if ((0, _isPromise.default)(isTypeOfResult)) {
             promisedIsTypeOfResults[i] = isTypeOfResult;
           } else if (isTypeOfResult) {
@@ -9729,11 +9729,11 @@ var require_execute = __commonJS({
       }
     };
     exports.defaultTypeResolver = defaultTypeResolver;
-    var defaultFieldResolver = function defaultFieldResolver2(source, args, contextValue, info2) {
+    var defaultFieldResolver = function defaultFieldResolver2(source, args, contextValue, info) {
       if ((0, _isObjectLike.default)(source) || typeof source === "function") {
-        var property = source[info2.fieldName];
+        var property = source[info.fieldName];
         if (typeof property === "function") {
-          return source[info2.fieldName](args, contextValue, info2);
+          return source[info.fieldName](args, contextValue, info);
         }
         return property;
       }
@@ -9759,7 +9759,7 @@ var require_graphql = __commonJS({
     Object.defineProperty(exports, "__esModule", {
       value: true
     });
-    exports.graphql = graphql27;
+    exports.graphql = graphql26;
     exports.graphqlSync = graphqlSync;
     var _isPromise = _interopRequireDefault(require_isPromise());
     var _parser = require_parser();
@@ -9769,7 +9769,7 @@ var require_graphql = __commonJS({
     function _interopRequireDefault(obj) {
       return obj && obj.__esModule ? obj : { default: obj };
     }
-    function graphql27(argsOrSchema, source, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) {
+    function graphql26(argsOrSchema, source, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) {
       var _arguments = arguments;
       return new Promise(function(resolve2) {
         return resolve2(
@@ -10753,13 +10753,13 @@ var require_subscribe = __commonJS({
         throw new _GraphQLError.GraphQLError('The subscription field "'.concat(fieldName, '" is not defined.'), fieldNodes);
       }
       var path2 = (0, _Path.addPath)(void 0, responseName, type.name);
-      var info2 = (0, _execute.buildResolveInfo)(exeContext, fieldDef, fieldNodes, type, path2);
+      var info = (0, _execute.buildResolveInfo)(exeContext, fieldDef, fieldNodes, type, path2);
       return new Promise(function(resolveResult) {
         var _fieldDef$subscribe;
         var args = (0, _values.getArgumentValues)(fieldDef, fieldNodes[0], variableValues);
         var contextValue = exeContext.contextValue;
         var resolveFn = (_fieldDef$subscribe = fieldDef.subscribe) !== null && _fieldDef$subscribe !== void 0 ? _fieldDef$subscribe : exeContext.fieldResolver;
-        resolveResult(resolveFn(rootValue, args, contextValue, info2));
+        resolveResult(resolveFn(rootValue, args, contextValue, info));
       }).then(function(eventStream) {
         if (eventStream instanceof Error) {
           throw (0, _locatedError.locatedError)(eventStream, fieldNodes, (0, _Path.pathToArray)(path2));
@@ -15650,42 +15650,42 @@ var require_node = __commonJS({
       return Link2;
     }(events_1.EventEmitter);
     exports.Link = Link;
-    var File2 = function() {
-      function File3(link, node, flags, fd) {
+    var File = function() {
+      function File2(link, node, flags, fd) {
         this.position = 0;
         this.link = link;
         this.node = node;
         this.flags = flags;
         this.fd = fd;
       }
-      File3.prototype.getString = function(encoding) {
+      File2.prototype.getString = function(encoding) {
         if (encoding === void 0) {
           encoding = "utf8";
         }
         return this.node.getString();
       };
-      File3.prototype.setString = function(str) {
+      File2.prototype.setString = function(str) {
         this.node.setString(str);
       };
-      File3.prototype.getBuffer = function() {
+      File2.prototype.getBuffer = function() {
         return this.node.getBuffer();
       };
-      File3.prototype.setBuffer = function(buf) {
+      File2.prototype.setBuffer = function(buf) {
         this.node.setBuffer(buf);
       };
-      File3.prototype.getSize = function() {
+      File2.prototype.getSize = function() {
         return this.node.getSize();
       };
-      File3.prototype.truncate = function(len) {
+      File2.prototype.truncate = function(len) {
         this.node.truncate(len);
       };
-      File3.prototype.seekTo = function(position) {
+      File2.prototype.seekTo = function(position) {
         this.position = position;
       };
-      File3.prototype.stats = function() {
+      File2.prototype.stats = function() {
         return Stats_1.default.build(this.node);
       };
-      File3.prototype.write = function(buf, offset, length, position) {
+      File2.prototype.write = function(buf, offset, length, position) {
         if (offset === void 0) {
           offset = 0;
         }
@@ -15700,7 +15700,7 @@ var require_node = __commonJS({
         this.position = position + bytes;
         return bytes;
       };
-      File3.prototype.read = function(buf, offset, length, position) {
+      File2.prototype.read = function(buf, offset, length, position) {
         if (offset === void 0) {
           offset = 0;
         }
@@ -15713,15 +15713,15 @@ var require_node = __commonJS({
         this.position = position + bytes;
         return bytes;
       };
-      File3.prototype.chmod = function(perm) {
+      File2.prototype.chmod = function(perm) {
         this.node.chmod(perm);
       };
-      File3.prototype.chown = function(uid, gid) {
+      File2.prototype.chown = function(uid, gid) {
         this.node.chown(uid, gid);
       };
-      return File3;
+      return File2;
     }();
-    exports.File = File2;
+    exports.File = File;
   }
 });
 
@@ -50026,18 +50026,18 @@ var require_lines = __commonJS({
         assert_1.default.strictEqual(typeof pos, "object");
         assert_1.default.strictEqual(typeof pos.line, "number");
         assert_1.default.strictEqual(typeof pos.column, "number");
-        var line = pos.line, column = pos.column, secret = this, infos = secret.infos, info2 = infos[line - 1], c = column;
-        if (typeof info2 === "undefined" || c < 0)
+        var line = pos.line, column = pos.column, secret = this, infos = secret.infos, info = infos[line - 1], c = column;
+        if (typeof info === "undefined" || c < 0)
           return "";
         var indent = this.getIndentAt(line);
         if (c < indent)
           return " ";
-        c += info2.sliceStart - indent;
-        if (c === info2.sliceEnd && line < this.length)
+        c += info.sliceStart - indent;
+        if (c === info.sliceEnd && line < this.length)
           return "\n";
-        if (c >= info2.sliceEnd)
+        if (c >= info.sliceEnd)
           return "";
-        return info2.line.charAt(c);
+        return info.line.charAt(c);
       };
       Lines2.prototype.stripMargin = function(width, skipFirstLine) {
         if (width === 0)
@@ -50045,11 +50045,11 @@ var require_lines = __commonJS({
         assert_1.default.ok(width > 0, "negative margin: " + width);
         if (skipFirstLine && this.length === 1)
           return this;
-        var lines = new Lines2(this.infos.map(function(info2, i) {
-          if (info2.line && (i > 0 || !skipFirstLine)) {
-            info2 = tslib_1.__assign(tslib_1.__assign({}, info2), { indent: Math.max(0, info2.indent - width) });
+        var lines = new Lines2(this.infos.map(function(info, i) {
+          if (info.line && (i > 0 || !skipFirstLine)) {
+            info = tslib_1.__assign(tslib_1.__assign({}, info), { indent: Math.max(0, info.indent - width) });
           }
-          return info2;
+          return info;
         }));
         if (this.mappings.length > 0) {
           var newMappings_1 = lines.mappings;
@@ -50064,11 +50064,11 @@ var require_lines = __commonJS({
         if (by === 0) {
           return this;
         }
-        var lines = new Lines2(this.infos.map(function(info2) {
-          if (info2.line && !info2.locked) {
-            info2 = tslib_1.__assign(tslib_1.__assign({}, info2), { indent: info2.indent + by });
+        var lines = new Lines2(this.infos.map(function(info) {
+          if (info.line && !info.locked) {
+            info = tslib_1.__assign(tslib_1.__assign({}, info), { indent: info.indent + by });
           }
-          return info2;
+          return info;
         }));
         if (this.mappings.length > 0) {
           var newMappings_2 = lines.mappings;
@@ -50086,11 +50086,11 @@ var require_lines = __commonJS({
         if (this.length < 2) {
           return this;
         }
-        var lines = new Lines2(this.infos.map(function(info2, i) {
-          if (i > 0 && info2.line && !info2.locked) {
-            info2 = tslib_1.__assign(tslib_1.__assign({}, info2), { indent: info2.indent + by });
+        var lines = new Lines2(this.infos.map(function(info, i) {
+          if (i > 0 && info.line && !info.locked) {
+            info = tslib_1.__assign(tslib_1.__assign({}, info), { indent: info.indent + by });
           }
-          return info2;
+          return info;
         }));
         if (this.mappings.length > 0) {
           var newMappings_3 = lines.mappings;
@@ -50105,8 +50105,8 @@ var require_lines = __commonJS({
         if (this.length < 2) {
           return this;
         }
-        return new Lines2(this.infos.map(function(info2, i) {
-          return tslib_1.__assign(tslib_1.__assign({}, info2), { locked: i > 0 });
+        return new Lines2(this.infos.map(function(info, i) {
+          return tslib_1.__assign(tslib_1.__assign({}, info), { locked: i > 0 });
         }));
       };
       Lines2.prototype.getIndentAt = function(line) {
@@ -50120,14 +50120,14 @@ var require_lines = __commonJS({
         var counts = [];
         var lastIndent = 0;
         for (var line = 1, last = this.length; line <= last; ++line) {
-          var info2 = this.infos[line - 1];
-          var sliced = info2.line.slice(info2.sliceStart, info2.sliceEnd);
+          var info = this.infos[line - 1];
+          var sliced = info.line.slice(info.sliceStart, info.sliceEnd);
           if (isOnlyWhitespace(sliced)) {
             continue;
           }
-          var diff = Math.abs(info2.indent - lastIndent);
+          var diff = Math.abs(info.indent - lastIndent);
           counts[diff] = ~~counts[diff] + 1;
-          lastIndent = info2.indent;
+          lastIndent = info.indent;
         }
         var maxCount = -1;
         var result = 2;
@@ -50150,20 +50150,20 @@ var require_lines = __commonJS({
         return isOnlyWhitespace(this.toString());
       };
       Lines2.prototype.isPrecededOnlyByWhitespace = function(pos) {
-        var info2 = this.infos[pos.line - 1];
-        var indent = Math.max(info2.indent, 0);
+        var info = this.infos[pos.line - 1];
+        var indent = Math.max(info.indent, 0);
         var diff = pos.column - indent;
         if (diff <= 0) {
           return true;
         }
-        var start = info2.sliceStart;
-        var end = Math.min(start + diff, info2.sliceEnd);
-        var prefix = info2.line.slice(start, end);
+        var start = info.sliceStart;
+        var end = Math.min(start + diff, info.sliceEnd);
+        var prefix = info.line.slice(start, end);
         return isOnlyWhitespace(prefix);
       };
       Lines2.prototype.getLineLength = function(line) {
-        var info2 = this.infos[line - 1];
-        return this.getIndentAt(line) + info2.sliceEnd - info2.sliceStart;
+        var info = this.infos[line - 1];
+        return this.getIndentAt(line) + info.sliceEnd - info.sliceStart;
       };
       Lines2.prototype.nextPos = function(pos, skipSpaces) {
         if (skipSpaces === void 0) {
@@ -50329,20 +50329,20 @@ var require_lines = __commonJS({
         var _a = (0, options_1.normalize)(options), tabWidth = _a.tabWidth, useTabs = _a.useTabs, reuseWhitespace = _a.reuseWhitespace, lineTerminator = _a.lineTerminator;
         var parts = [];
         for (var line = start.line; line <= end.line; ++line) {
-          var info2 = this.infos[line - 1];
+          var info = this.infos[line - 1];
           if (line === start.line) {
             if (line === end.line) {
-              info2 = sliceInfo(info2, start.column, end.column);
+              info = sliceInfo(info, start.column, end.column);
             } else {
-              info2 = sliceInfo(info2, start.column);
+              info = sliceInfo(info, start.column);
             }
           } else if (line === end.line) {
-            info2 = sliceInfo(info2, 0, end.column);
+            info = sliceInfo(info, 0, end.column);
           }
-          var indent = Math.max(info2.indent, 0);
-          var before_1 = info2.line.slice(0, info2.sliceStart);
+          var indent = Math.max(info.indent, 0);
+          var before_1 = info.line.slice(0, info.sliceStart);
           if (reuseWhitespace && isOnlyWhitespace(before_1) && countSpaces(before_1, tabWidth) === indent) {
-            parts.push(info2.line.slice(0, info2.sliceEnd));
+            parts.push(info.line.slice(0, info.sliceEnd));
             continue;
           }
           var tabs = 0;
@@ -50358,7 +50358,7 @@ var require_lines = __commonJS({
           if (spaces > 0) {
             result += new Array(spaces + 1).join(" ");
           }
-          result += info2.line.slice(info2.sliceStart, info2.sliceEnd);
+          result += info.line.slice(info.sliceStart, info.sliceEnd);
           parts.push(result);
         }
         return parts.join(lineTerminator);
@@ -50376,12 +50376,12 @@ var require_lines = __commonJS({
             return;
           }
           if (prevInfo) {
-            var info2 = linesOrNull.infos[0];
-            var indent = new Array(info2.indent + 1).join(" ");
+            var info = linesOrNull.infos[0];
+            var indent = new Array(info.indent + 1).join(" ");
             var prevLine_1 = infos.length;
             var prevColumn_1 = Math.max(prevInfo.indent, 0) + prevInfo.sliceEnd - prevInfo.sliceStart;
-            prevInfo.line = prevInfo.line.slice(0, prevInfo.sliceEnd) + indent + info2.line.slice(info2.sliceStart, info2.sliceEnd);
-            prevInfo.locked = prevInfo.locked || info2.locked;
+            prevInfo.line = prevInfo.line.slice(0, prevInfo.sliceEnd) + indent + info.line.slice(info.sliceStart, info.sliceEnd);
+            prevInfo.locked = prevInfo.locked || info.locked;
             prevInfo.sliceEnd = prevInfo.line.length;
             if (linesOrNull.mappings.length > 0) {
               linesOrNull.mappings.forEach(function(mapping) {
@@ -50391,9 +50391,9 @@ var require_lines = __commonJS({
           } else if (linesOrNull.mappings.length > 0) {
             mappings.push.apply(mappings, linesOrNull.mappings);
           }
-          linesOrNull.infos.forEach(function(info3, i) {
+          linesOrNull.infos.forEach(function(info2, i) {
             if (!prevInfo || i > 0) {
-              prevInfo = tslib_1.__assign({}, info3);
+              prevInfo = tslib_1.__assign({}, info2);
               infos.push(prevInfo);
             }
           });
@@ -50497,10 +50497,10 @@ var require_lines = __commonJS({
     function isOnlyWhitespace(string) {
       return !/\S/.test(string);
     }
-    function sliceInfo(info2, startCol, endCol) {
-      var sliceStart = info2.sliceStart;
-      var sliceEnd = info2.sliceEnd;
-      var indent = Math.max(info2.indent, 0);
+    function sliceInfo(info, startCol, endCol) {
+      var sliceStart = info.sliceStart;
+      var sliceEnd = info.sliceEnd;
+      var indent = Math.max(info.indent, 0);
       var lineLength = indent + sliceEnd - sliceStart;
       if (typeof endCol === "undefined") {
         endCol = lineLength;
@@ -50526,11 +50526,11 @@ var require_lines = __commonJS({
       assert_1.default.ok(indent >= 0);
       assert_1.default.ok(sliceStart <= sliceEnd);
       assert_1.default.strictEqual(lineLength, indent + sliceEnd - sliceStart);
-      if (info2.indent === indent && info2.sliceStart === sliceStart && info2.sliceEnd === sliceEnd) {
-        return info2;
+      if (info.indent === indent && info.sliceStart === sliceStart && info.sliceEnd === sliceEnd) {
+        return info;
       }
       return {
-        line: info2.line,
+        line: info.line,
         indent,
         locked: false,
         sliceStart,
@@ -53537,9 +53537,9 @@ var require_printer2 = __commonJS({
       var prevTrailingSpace = null;
       var len = filtered.length;
       var parts = [];
-      filtered.forEach(function(info2, i) {
-        var printed = info2.printed;
-        var stmt = info2.node;
+      filtered.forEach(function(info, i) {
+        var printed = info.printed;
+        var stmt = info.node;
         var multiLine = printed.length > 1;
         var notFirst = i > 0;
         var notLast = i < len - 1;
@@ -53938,7 +53938,7 @@ var require_main2 = __commonJS({
 });
 
 // src/test/index.ts
-var graphql26 = __toESM(require_graphql2(), 1);
+var graphql25 = __toESM(require_graphql2(), 1);
 var import_memfs2 = __toESM(require_lib(), 1);
 
 // src/lib/pipeline.ts
@@ -53982,1719 +53982,6 @@ function computeID(configFile, type, data) {
   return id.slice(0, -2);
 }
 
-// src/runtime/lib/deepEquals.ts
-function deepEquals(objA, objB, map = /* @__PURE__ */ new WeakMap()) {
-  if (Object.is(objA, objB))
-    return true;
-  if (objA instanceof Date && objB instanceof Date) {
-    return objA.getTime() === objB.getTime();
-  }
-  if (objA instanceof RegExp && objB instanceof RegExp) {
-    return objA.toString() === objB.toString();
-  }
-  if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
-    return false;
-  }
-  if (map.get(objA) === objB)
-    return true;
-  map.set(objA, objB);
-  const keysA = Reflect.ownKeys(objA);
-  const keysB = Reflect.ownKeys(objB);
-  if (keysA.length !== keysB.length) {
-    return false;
-  }
-  for (let i = 0; i < keysA.length; i++) {
-    if (!Reflect.has(objB, keysA[i]) || !deepEquals(objA[keysA[i]], objB[keysA[i]], map)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-// src/runtime/lib/selection.ts
-function getFieldsForType(selection2, __typename) {
-  let targetSelection = selection2.fields || {};
-  if (selection2.abstractFields && __typename) {
-    const mappedType = selection2.abstractFields.typeMap[__typename];
-    if (mappedType) {
-      targetSelection = selection2.abstractFields.fields[mappedType];
-    } else if (selection2.abstractFields.fields[__typename]) {
-      targetSelection = selection2.abstractFields.fields[__typename];
-    }
-  }
-  return targetSelection;
-}
-
-// src/runtime/cache/gc.ts
-var GarbageCollector = class {
-  cache;
-  lifetimes = /* @__PURE__ */ new Map();
-  get cacheBufferSize() {
-    return this.cache._internal_unstable.config.cacheBufferSize ?? 10;
-  }
-  constructor(cache) {
-    this.cache = cache;
-  }
-  resetLifetime(id, field) {
-    if (!this.lifetimes.get(id)) {
-      this.lifetimes.set(id, /* @__PURE__ */ new Map());
-    }
-    this.lifetimes.get(id).set(field, 0);
-  }
-  tick() {
-    for (const [id, fieldMap] of this.lifetimes.entries()) {
-      for (const [field, lifetime] of fieldMap.entries()) {
-        if (this.cache._internal_unstable.subscriptions.get(id, field).length > 0) {
-          continue;
-        }
-        fieldMap.set(field, lifetime + 1);
-        if (fieldMap.get(field) > this.cacheBufferSize) {
-          this.cache._internal_unstable.storage.deleteField(id, field);
-          this.cache._internal_unstable.lists.deleteField(id, field);
-          fieldMap.delete(field);
-          if ([...fieldMap.keys()].length === 0) {
-            this.lifetimes.delete(id);
-          }
-        }
-      }
-    }
-  }
-};
-
-// src/runtime/cache/stuff.ts
-function flattenList(source) {
-  const flat = [];
-  const unvisited = [source || []];
-  while (unvisited.length > 0) {
-    const target = unvisited.shift();
-    for (const id of target) {
-      if (Array.isArray(id)) {
-        unvisited.push(id);
-        continue;
-      }
-      flat.push(id);
-    }
-  }
-  return flat;
-}
-function evaluateKey(key, variables = {}) {
-  let evaluated = "";
-  let varName = "";
-  let inString = false;
-  for (const char of key) {
-    if (varName) {
-      if (varChars.includes(char)) {
-        varName += char;
-        continue;
-      }
-      const value = variables[varName.slice(1)];
-      evaluated += typeof value !== "undefined" ? JSON.stringify(value) : "undefined";
-      varName = "";
-    }
-    if (char === "$" && !inString) {
-      varName = "$";
-      continue;
-    }
-    if (char === '"') {
-      inString = !inString;
-    }
-    evaluated += char;
-  }
-  return evaluated;
-}
-var varChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789";
-
-// src/runtime/cache/lists.ts
-var ListManager = class {
-  rootID;
-  cache;
-  constructor(cache, rootID2) {
-    this.rootID = rootID2;
-    this.cache = cache;
-  }
-  lists = /* @__PURE__ */ new Map();
-  listsByField = /* @__PURE__ */ new Map();
-  get(listName, id, allLists) {
-    const matches = this.lists.get(listName);
-    if (!matches || matches.size === 0) {
-      return null;
-    }
-    if (allLists) {
-      return new ListCollection(
-        Array.from(matches, ([key, value]) => [...value.lists]).flat()
-      );
-    }
-    const head = [...matches.values()][0];
-    const { recordType } = head.lists[0];
-    const parentID = id ? this.cache._internal_unstable.id(recordType || "", id) : this.rootID;
-    if (matches?.size === 1) {
-      if (!id) {
-        return head;
-      }
-      return parentID === Array.from(matches.keys())[0] ? head : null;
-    }
-    if (!id) {
-      console.error(
-        `Found multiple instances of "${listName}". Please provide one of @parentID or @allLists directives to help identify which list you want modify. For more information, visit this guide: https://www.houdinigraphql.com/api/graphql#parentidvalue-string `
-      );
-      return null;
-    }
-    return this.lists.get(listName)?.get(parentID);
-  }
-  remove(listName, id) {
-    this.lists.get(listName)?.delete(id || this.rootID);
-  }
-  add(list) {
-    if (!this.lists.has(list.name)) {
-      this.lists.set(list.name, /* @__PURE__ */ new Map());
-    }
-    const name2 = list.name;
-    const parentID = list.recordID || this.rootID;
-    if (this.lists.get(name2)?.get(parentID)?.includes(list.key)) {
-      return;
-    }
-    if (!this.lists.has(name2)) {
-      this.lists.set(name2, /* @__PURE__ */ new Map());
-    }
-    if (!this.lists.get(name2).has(parentID)) {
-      this.lists.get(name2).set(parentID, new ListCollection([]));
-    }
-    if (!this.listsByField.has(parentID)) {
-      this.listsByField.set(parentID, /* @__PURE__ */ new Map());
-    }
-    if (!this.listsByField.get(parentID).has(list.key)) {
-      this.listsByField.get(parentID)?.set(list.key, []);
-    }
-    const handler = new List({ ...list, manager: this });
-    this.lists.get(list.name).get(parentID).lists.push(handler);
-    this.listsByField.get(parentID).get(list.key).push(handler);
-  }
-  removeIDFromAllLists(id) {
-    for (const fieldMap of this.lists.values()) {
-      for (const list of fieldMap.values()) {
-        list.removeID(id);
-      }
-    }
-  }
-  deleteField(parentID, field) {
-    if (!this.listsByField.get(parentID)?.has(field)) {
-      return;
-    }
-    for (const list of this.listsByField.get(parentID).get(field)) {
-      this.lists.get(list.name)?.get(list.recordID)?.deleteListWithKey(field);
-      if (this.lists.get(list.name)?.get(list.recordID)?.lists.length === 0) {
-        this.lists.get(list.name)?.delete(list.recordID);
-      }
-    }
-    this.listsByField.get(parentID).delete(field);
-  }
-};
-var List = class {
-  recordID;
-  recordType;
-  key;
-  type;
-  cache;
-  selection;
-  _when;
-  filters;
-  name;
-  connection;
-  manager;
-  abstract;
-  constructor({
-    name: name2,
-    recordID,
-    recordType,
-    key,
-    listType,
-    selection: selection2,
-    when,
-    filters,
-    connection,
-    manager,
-    abstract
-  }) {
-    this.recordID = recordID || rootID;
-    this.recordType = recordType;
-    this.key = key;
-    this.type = listType;
-    this.cache = manager.cache;
-    this.selection = selection2;
-    this._when = when;
-    this.filters = filters;
-    this.name = name2;
-    this.connection = connection;
-    this.manager = manager;
-    this.abstract = abstract;
-  }
-  when(when) {
-    return this.manager.lists.get(this.name).get(this.recordID).when(when);
-  }
-  append(selection2, data, variables = {}) {
-    return this.addToList(selection2, data, variables, "last");
-  }
-  prepend(selection2, data, variables = {}) {
-    return this.addToList(selection2, data, variables, "first");
-  }
-  addToList(selection2, data, variables = {}, where) {
-    const listType = this.listType(data);
-    const dataID = this.cache._internal_unstable.id(listType, data);
-    if (!this.validateWhen() || !dataID) {
-      return;
-    }
-    let insertSelection = selection2;
-    let insertData = data;
-    if (this.connection) {
-      insertSelection = {
-        fields: {
-          newEntry: {
-            keyRaw: this.key,
-            type: "Connection",
-            selection: {
-              fields: {
-                edges: {
-                  keyRaw: "edges",
-                  type: "ConnectionEdge",
-                  update: where === "first" ? "prepend" : "append",
-                  selection: {
-                    fields: {
-                      node: {
-                        type: listType,
-                        keyRaw: "node",
-                        selection: {
-                          ...selection2,
-                          fields: {
-                            ...selection2.fields,
-                            __typename: {
-                              keyRaw: "__typename",
-                              type: "String"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      };
-      insertData = {
-        newEntry: {
-          edges: [{ node: { ...data, __typename: listType } }]
-        }
-      };
-    } else {
-      insertSelection = {
-        fields: {
-          newEntries: {
-            keyRaw: this.key,
-            type: listType,
-            update: where === "first" ? "prepend" : "append",
-            selection: {
-              ...selection2,
-              fields: {
-                ...selection2.fields,
-                __typename: {
-                  keyRaw: "__typename",
-                  type: "String"
-                }
-              }
-            }
-          }
-        }
-      };
-      insertData = {
-        newEntries: [{ ...data, __typename: listType }]
-      };
-    }
-    this.cache.write({
-      selection: insertSelection,
-      data: insertData,
-      variables,
-      parent: this.recordID,
-      applyUpdates: true
-    });
-  }
-  removeID(id, variables = {}) {
-    if (!this.validateWhen()) {
-      return;
-    }
-    let parentID = this.recordID;
-    let targetID = id;
-    let targetKey = this.key;
-    if (this.connection) {
-      const { value: embeddedConnection } = this.cache._internal_unstable.storage.get(
-        this.recordID,
-        this.key
-      );
-      if (!embeddedConnection) {
-        return;
-      }
-      const embeddedConnectionID = embeddedConnection;
-      const { value: edges } = this.cache._internal_unstable.storage.get(
-        embeddedConnectionID,
-        "edges"
-      );
-      for (const edge of flattenList(edges) || []) {
-        if (!edge) {
-          continue;
-        }
-        const edgeID = edge;
-        const { value: nodeID } = this.cache._internal_unstable.storage.get(edgeID, "node");
-        if (!nodeID) {
-          continue;
-        }
-        if (nodeID === id) {
-          targetID = edgeID;
-        }
-      }
-      parentID = embeddedConnectionID;
-      targetKey = "edges";
-    }
-    let value = this.cache._internal_unstable.storage.get(parentID, targetKey).value;
-    if (!value || !value.includes(targetID)) {
-      return;
-    }
-    const subscribers = this.cache._internal_unstable.subscriptions.get(this.recordID, this.key);
-    this.cache._internal_unstable.subscriptions.remove(
-      targetID,
-      this.connection ? this.selection.fields.edges.selection : this.selection,
-      subscribers,
-      variables
-    );
-    this.cache._internal_unstable.storage.remove(parentID, targetKey, targetID);
-    for (const spec of subscribers) {
-      spec.set(
-        this.cache._internal_unstable.getSelection({
-          parent: spec.parentID || this.manager.rootID,
-          selection: spec.selection,
-          variables: spec.variables?.() || {}
-        }).data
-      );
-    }
-    return true;
-  }
-  remove(data, variables = {}) {
-    const targetID = this.cache._internal_unstable.id(this.listType(data), data);
-    if (!targetID) {
-      return;
-    }
-    return this.removeID(targetID, variables);
-  }
-  listType(data) {
-    return data.__typename || this.type;
-  }
-  validateWhen(when) {
-    let filters = when || this._when;
-    let ok = true;
-    if (filters) {
-      const targets = this.filters;
-      if (filters.must && targets) {
-        ok = Object.entries(filters.must).reduce(
-          (prev, [key, value]) => Boolean(prev && targets[key] == value),
-          ok
-        );
-      }
-      if (filters.must_not) {
-        ok = !targets || Object.entries(filters.must_not).reduce(
-          (prev, [key, value]) => Boolean(prev && targets[key] != value),
-          ok
-        );
-      }
-    }
-    return ok;
-  }
-  toggleElement(selection2, data, variables = {}, where) {
-    if (!this.remove(data, variables)) {
-      this.addToList(selection2, data, variables, where);
-    }
-  }
-  *[Symbol.iterator]() {
-    let entries = [];
-    let value = this.cache._internal_unstable.storage.get(this.recordID, this.key).value;
-    if (!this.connection) {
-      entries = flattenList(value);
-    } else {
-      entries = this.cache._internal_unstable.storage.get(value, "edges").value;
-    }
-    for (let record2 of entries) {
-      yield record2;
-    }
-  }
-};
-var ListCollection = class {
-  lists = [];
-  constructor(lists) {
-    this.lists = lists;
-  }
-  append(...args) {
-    this.lists.forEach((list) => list.append(...args));
-  }
-  prepend(...args) {
-    this.lists.forEach((list) => list.prepend(...args));
-  }
-  addToList(...args) {
-    this.lists.forEach((list) => list.addToList(...args));
-  }
-  removeID(...args) {
-    this.lists.forEach((list) => list.removeID(...args));
-  }
-  remove(...args) {
-    this.lists.forEach((list) => list.remove(...args));
-  }
-  toggleElement(...args) {
-    this.lists.forEach((list) => list.toggleElement(...args));
-  }
-  when(when) {
-    return new ListCollection(
-      this.lists.filter((list) => {
-        return list.validateWhen(when);
-      })
-    );
-  }
-  includes(key) {
-    return !!this.lists.find((list) => list.key === key);
-  }
-  deleteListWithKey(key) {
-    return this.lists = this.lists.filter((list) => list.key !== key);
-  }
-  *[Symbol.iterator]() {
-    for (let list of this.lists) {
-      for (const entry of list) {
-        yield entry;
-      }
-    }
-  }
-};
-
-// src/runtime/cache/schema.ts
-var SchemaManager = class {
-  cache;
-  fieldTypes = {};
-  constructor(cache) {
-    this.cache = cache;
-  }
-  setFieldType({
-    parent,
-    key,
-    type,
-    nullable = false,
-    link
-  }) {
-    let parensIndex = key.indexOf("(");
-    if (parensIndex !== -1) {
-      key = key.substring(0, parensIndex);
-    }
-    if (parent === rootID) {
-      parent = "Query";
-    } else if (parent.includes(":")) {
-      parent = parent.substring(0, parent.indexOf(":"));
-    }
-    if (!this.fieldTypes[parent]) {
-      this.fieldTypes[parent] = {};
-    }
-    this.fieldTypes[parent][key] = {
-      type,
-      nullable,
-      link: !!link
-    };
-  }
-  fieldType(type, field) {
-    return this.fieldTypes[type]?.[field] || null;
-  }
-  get config() {
-    return this.cache._internal_unstable.config;
-  }
-};
-
-// src/runtime/cache/storage.ts
-var InMemoryStorage = class {
-  data;
-  idCount = 0;
-  rank = 0;
-  constructor() {
-    this.data = [];
-  }
-  get layerCount() {
-    return this.data.length;
-  }
-  get nextRank() {
-    return this.rank++;
-  }
-  createLayer(optimistic = false) {
-    const layer = new Layer(this.idCount++);
-    layer.optimistic = optimistic;
-    this.data.push(layer);
-    return layer;
-  }
-  insert(id, field, location, target) {
-    return this.topLayer.insert(id, field, location, target);
-  }
-  remove(id, field, target) {
-    return this.topLayer.remove(id, field, target);
-  }
-  delete(id) {
-    return this.topLayer.delete(id);
-  }
-  deleteField(id, field) {
-    return this.topLayer.deleteField(id, field);
-  }
-  getLayer(id) {
-    for (const layer of this.data) {
-      if (layer.id === id) {
-        return layer;
-      }
-    }
-    throw new Error("Could not find layer with id: " + id);
-  }
-  replaceID(replacement) {
-    for (const layer of this.data) {
-      layer.replaceID(replacement);
-    }
-  }
-  get(id, field) {
-    const operations = {
-      [OperationKind.insert]: {
-        [OperationLocation.start]: [],
-        [OperationLocation.end]: []
-      },
-      [OperationKind.remove]: /* @__PURE__ */ new Set()
-    };
-    const layerIDs = [];
-    for (let i = this.data.length - 1; i >= 0; i--) {
-      const layer = this.data[i];
-      const [layerValue, kind] = layer.get(id, field);
-      const layerOperations = layer.getOperations(id, field) || [];
-      layer.deletedIDs.forEach((v) => {
-        if (layer.operations[v]?.undoDeletesInList?.includes(field)) {
-          return;
-        }
-        operations.remove.add(v);
-      });
-      if (typeof layerValue === "undefined" && layerOperations.length === 0) {
-        if (layer.deletedIDs.size > 0) {
-          layerIDs.push(layer.id);
-        }
-        continue;
-      }
-      if (typeof layerValue !== "undefined" && !Array.isArray(layerValue)) {
-        return {
-          value: layerValue,
-          kind,
-          displayLayers: [layer.id]
-        };
-      }
-      layerIDs.push(layer.id);
-      if (layerOperations.length > 0) {
-        for (const op of layerOperations) {
-          if (isRemoveOperation(op)) {
-            operations.remove.add(op.id);
-          }
-          if (isInsertOperation(op)) {
-            operations.insert[op.location].unshift(op.id);
-          }
-          if (isDeleteOperation(op)) {
-            return {
-              value: void 0,
-              kind: "unknown",
-              displayLayers: []
-            };
-          }
-        }
-      }
-      if (typeof layerValue === "undefined") {
-        continue;
-      }
-      if (!operations.remove.size && !operations.insert.start.length && !operations.insert.end.length) {
-        return { value: layerValue, displayLayers: layerIDs, kind: "link" };
-      }
-      return {
-        value: [...operations.insert.start, ...layerValue, ...operations.insert.end].filter(
-          (value) => !operations.remove.has(value)
-        ),
-        displayLayers: layerIDs,
-        kind
-      };
-    }
-    return {
-      value: void 0,
-      kind: "unknown",
-      displayLayers: []
-    };
-  }
-  writeLink(id, field, value) {
-    return this.topLayer.writeLink(id, field, value);
-  }
-  writeField(id, field, value) {
-    return this.topLayer.writeField(id, field, value);
-  }
-  resolveLayer(id) {
-    let startingIndex = null;
-    for (const [index, layer] of this.data.entries()) {
-      if (layer.id !== id) {
-        continue;
-      }
-      startingIndex = index - 1;
-      this.data[index].optimistic = false;
-      break;
-    }
-    if (startingIndex === null) {
-      throw new Error("could not find layer with id: " + id);
-    }
-    if (startingIndex === -1) {
-      startingIndex = 0;
-    }
-    if (this.data[startingIndex].optimistic) {
-      startingIndex++;
-    }
-    const baseLayer = this.data[startingIndex];
-    let layerIndex = startingIndex;
-    while (layerIndex < this.data.length) {
-      const layer = this.data[layerIndex++];
-      if (layer.optimistic) {
-        layerIndex--;
-        break;
-      }
-      baseLayer.writeLayer(layer);
-    }
-    this.data.splice(startingIndex + 1, layerIndex - startingIndex - 1);
-  }
-  get topLayer() {
-    if (this.data.length === 0) {
-      this.createLayer();
-    }
-    if (this.data[this.data.length - 1]?.optimistic) {
-      this.createLayer();
-    }
-    return this.data[this.data.length - 1];
-  }
-};
-var Layer = class {
-  id;
-  optimistic = false;
-  fields = {};
-  links = {};
-  operations = {};
-  deletedIDs = /* @__PURE__ */ new Set();
-  constructor(id) {
-    this.id = id;
-  }
-  get(id, field) {
-    if (typeof this.links[id]?.[field] !== "undefined") {
-      return [this.links[id][field], "link"];
-    }
-    return [this.fields[id]?.[field], "scalar"];
-  }
-  getOperations(id, field) {
-    if (this.operations[id]?.deleted) {
-      return [
-        {
-          kind: OperationKind.delete,
-          target: id
-        }
-      ];
-    }
-    if (this.operations[id]?.fields?.[field]) {
-      return this.operations[id].fields[field];
-    }
-  }
-  writeField(id, field, value) {
-    this.fields[id] = {
-      ...this.fields[id],
-      [field]: value
-    };
-    return this.id;
-  }
-  writeLink(id, field, value) {
-    const valueList = Array.isArray(value) ? value : [value];
-    for (const value2 of flattenList(valueList)) {
-      if (!value2) {
-        continue;
-      }
-      const fieldOperations = this.operations[id]?.fields[field];
-      if (this.operations[value2]?.deleted || this.deletedIDs.has(value2)) {
-        this.operations[value2] = {
-          ...this.operations[value2],
-          undoDeletesInList: [...this.operations[id]?.undoDeletesInList || [], field]
-        };
-      } else if (value2 && fieldOperations?.length > 0) {
-        this.operations[id].fields[field] = fieldOperations.filter(
-          (op) => op.kind !== "remove" || op.id !== value2
-        );
-      }
-    }
-    this.links[id] = {
-      ...this.links[id],
-      [field]: value
-    };
-    return this.id;
-  }
-  isDisplayLayer(displayLayers) {
-    return displayLayers.length === 0 || displayLayers.includes(this.id) || Math.max(...displayLayers) < this.id;
-  }
-  clear() {
-    this.links = {};
-    this.fields = {};
-    this.operations = {};
-    this.deletedIDs = /* @__PURE__ */ new Set();
-  }
-  replaceID({ from, to }) {
-    this.fields[to] = this.fields[from];
-    this.links[to] = this.links[from];
-    this.operations[to] = this.operations[from] || { fields: {} };
-    if (this.deletedIDs.has(from)) {
-      this.deletedIDs.add(to);
-    }
-  }
-  removeUndefinedFields() {
-    for (const [id, fields] of Object.entries(this.fields)) {
-      for (const [field, value] of Object.entries(fields)) {
-        if (typeof value === "undefined") {
-          try {
-            delete this.fields[id][field];
-          } catch {
-          }
-          try {
-            delete this.links[id][field];
-          } catch {
-          }
-        }
-      }
-      if (Object.keys(fields || {}).length === 0) {
-        delete this.fields[id];
-      }
-      if (Object.keys(this.links[id] || {}).length === 0) {
-        delete this.links[id];
-      }
-    }
-  }
-  delete(id) {
-    this.operations = {
-      ...this.operations,
-      [id]: {
-        ...this.operations[id],
-        deleted: true,
-        undoDeletesInList: []
-      }
-    };
-    this.deletedIDs.add(id);
-  }
-  deleteField(id, field) {
-    this.fields[id] = {
-      ...this.fields[id],
-      [field]: void 0
-    };
-  }
-  insert(id, field, where, target) {
-    this.addFieldOperation(id, field, {
-      kind: OperationKind.insert,
-      id: target,
-      location: where
-    });
-  }
-  remove(id, field, target) {
-    this.addFieldOperation(id, field, {
-      kind: OperationKind.remove,
-      id: target
-    });
-  }
-  writeLayer(layer) {
-    if (layer.id === this.id) {
-      return;
-    }
-    for (const [id, ops] of Object.entries(layer.operations)) {
-      const fields = {};
-      for (const opMap of [this.operations[id], layer.operations[id]].filter(Boolean)) {
-        for (const [fieldName, operations] of Object.entries(opMap.fields || {})) {
-          fields[fieldName] = [...fields[fieldName] || [], ...operations];
-        }
-      }
-      if (Object.keys(fields).length > 0) {
-        this.operations[id] = {
-          ...this.operations[id],
-          fields
-        };
-      }
-      if (ops?.deleted) {
-        delete this.fields[id];
-        delete this.links[id];
-      }
-    }
-    for (const [id, values] of Object.entries(layer.fields)) {
-      if (!values) {
-        continue;
-      }
-      for (const [field, value] of Object.entries(values)) {
-        this.writeField(id, field, value);
-      }
-    }
-    for (const [id, values] of Object.entries(layer.links)) {
-      if (!values) {
-        continue;
-      }
-      for (const [field, value] of Object.entries(values)) {
-        this.writeLink(id, field, value);
-      }
-    }
-    layer.deletedIDs.forEach((v) => this.deletedIDs.add(v));
-  }
-  addFieldOperation(id, field, operation) {
-    this.operations = {
-      ...this.operations,
-      [id]: {
-        ...this.operations[id],
-        fields: {
-          [field]: [...this.operations[id]?.fields[field] || [], operation]
-        }
-      }
-    };
-  }
-};
-function isDeleteOperation(value) {
-  return !!value && value.kind === OperationKind.delete;
-}
-function isInsertOperation(value) {
-  return !!value && value.kind === OperationKind.insert;
-}
-function isRemoveOperation(value) {
-  return !!value && value.kind === OperationKind.remove;
-}
-var OperationLocation = /* @__PURE__ */ ((OperationLocation2) => {
-  OperationLocation2["start"] = "start";
-  OperationLocation2["end"] = "end";
-  return OperationLocation2;
-})(OperationLocation || {});
-var OperationKind = /* @__PURE__ */ ((OperationKind2) => {
-  OperationKind2["delete"] = "delete";
-  OperationKind2["insert"] = "insert";
-  OperationKind2["remove"] = "remove";
-  return OperationKind2;
-})(OperationKind || {});
-
-// src/runtime/cache/subscription.ts
-var InMemorySubscriptions = class {
-  cache;
-  constructor(cache) {
-    this.cache = cache;
-  }
-  subscribers = {};
-  referenceCounts = {};
-  keyVersions = {};
-  add({
-    parent,
-    spec,
-    selection: selection2,
-    variables,
-    parentType
-  }) {
-    const __typename = this.cache._internal_unstable.storage.get(parent, "__typename").value;
-    let targetSelection = getFieldsForType(selection2, __typename);
-    for (const fieldSelection of Object.values(targetSelection || {})) {
-      const { keyRaw, selection: innerSelection, type } = fieldSelection;
-      const key = evaluateKey(keyRaw, variables);
-      this.addFieldSubscription({
-        id: parent,
-        key,
-        field: fieldSelection,
-        spec,
-        parentType: parentType || spec.rootType,
-        variables
-      });
-      if (innerSelection) {
-        const { value: linkedRecord } = this.cache._internal_unstable.storage.get(
-          parent,
-          key
-        );
-        let children = !Array.isArray(linkedRecord) ? [linkedRecord] : flattenList(linkedRecord) || [];
-        for (const child of children) {
-          if (!child) {
-            continue;
-          }
-          this.add({
-            parent: child,
-            spec,
-            selection: innerSelection,
-            variables,
-            parentType: type
-          });
-        }
-      }
-    }
-  }
-  addFieldSubscription({
-    id,
-    key,
-    field,
-    spec,
-    parentType,
-    variables
-  }) {
-    if (!this.subscribers[id]) {
-      this.subscribers[id] = {};
-    }
-    if (!this.subscribers[id][key]) {
-      this.subscribers[id][key] = [];
-    }
-    if (!this.keyVersions[key]) {
-      this.keyVersions[key] = /* @__PURE__ */ new Set();
-    }
-    this.keyVersions[key].add(key);
-    if (!this.subscribers[id][key].map(({ set }) => set).includes(spec.set)) {
-      this.subscribers[id][key].push(spec);
-    }
-    if (!this.referenceCounts[id]) {
-      this.referenceCounts[id] = {};
-    }
-    if (!this.referenceCounts[id][key]) {
-      this.referenceCounts[id][key] = /* @__PURE__ */ new Map();
-    }
-    const counts = this.referenceCounts[id][key];
-    counts.set(spec.set, (counts.get(spec.set) || 0) + 1);
-    this.cache._internal_unstable.lifetimes.resetLifetime(id, key);
-    const { selection: selection2, list, filters } = field;
-    if (selection2 && list) {
-      this.cache._internal_unstable.lists.add({
-        name: list.name,
-        connection: list.connection,
-        recordID: id,
-        recordType: this.cache._internal_unstable.storage.get(id, "__typename")?.value || parentType,
-        listType: list.type,
-        key,
-        selection: selection2,
-        filters: Object.entries(filters || {}).reduce((acc, [key2, { kind, value }]) => {
-          return {
-            ...acc,
-            [key2]: kind !== "Variable" ? value : variables[value]
-          };
-        }, {})
-      });
-    }
-  }
-  addMany({
-    parent,
-    selection: selection2,
-    variables,
-    subscribers,
-    parentType
-  }) {
-    let targetSelection = getFieldsForType(selection2, parentType);
-    for (const fieldSelection of Object.values(targetSelection)) {
-      const { type: linkedType, keyRaw, selection: innerSelection } = fieldSelection;
-      const key = evaluateKey(keyRaw, variables);
-      for (const spec of subscribers) {
-        this.addFieldSubscription({
-          id: parent,
-          key,
-          field: fieldSelection,
-          spec,
-          parentType,
-          variables
-        });
-      }
-      if (innerSelection) {
-        const { value: link } = this.cache._internal_unstable.storage.get(parent, key);
-        const children = !Array.isArray(link) ? [link] : flattenList(link);
-        for (const linkedRecord of children) {
-          if (!linkedRecord) {
-            continue;
-          }
-          this.addMany({
-            parent: linkedRecord,
-            selection: innerSelection,
-            variables,
-            subscribers,
-            parentType: linkedType
-          });
-        }
-      }
-    }
-  }
-  get(id, field) {
-    return this.subscribers[id]?.[field] || [];
-  }
-  remove(id, selection2, targets, variables, visited = []) {
-    visited.push(id);
-    const linkedIDs = [];
-    for (const fieldSelection of Object.values(selection2.fields || {})) {
-      const key = evaluateKey(fieldSelection.keyRaw, variables);
-      this.removeSubscribers(id, key, targets);
-      if (!fieldSelection.selection?.fields) {
-        continue;
-      }
-      const { value: previousValue } = this.cache._internal_unstable.storage.get(id, key);
-      const links = !Array.isArray(previousValue) ? [previousValue] : flattenList(previousValue);
-      for (const link of links) {
-        if (link !== null) {
-          linkedIDs.push([link, fieldSelection.selection || {}]);
-        }
-      }
-    }
-    for (const [linkedRecordID, linkFields] of linkedIDs) {
-      this.remove(linkedRecordID, linkFields, targets, visited);
-    }
-  }
-  removeSubscribers(id, fieldName, specs) {
-    let targets = [];
-    for (const spec of specs) {
-      if (!this.referenceCounts[id]?.[fieldName]?.has(spec.set)) {
-        continue;
-      }
-      const counts = this.referenceCounts[id][fieldName];
-      const newVal = (counts.get(spec.set) || 0) - 1;
-      counts.set(spec.set, newVal);
-      if (newVal <= 0) {
-        targets.push(spec.set);
-        counts.delete(spec.set);
-      }
-    }
-    if (this.subscribers[id]) {
-      this.subscribers[id][fieldName] = this.get(id, fieldName).filter(
-        ({ set }) => !targets.includes(set)
-      );
-    }
-  }
-  removeAllSubscribers(id, targets, visited = []) {
-    visited.push(id);
-    for (const field of Object.keys(this.subscribers[id] || [])) {
-      const subscribers = targets || this.subscribers[id][field];
-      this.removeSubscribers(id, field, subscribers);
-      const { value, kind } = this.cache._internal_unstable.storage.get(id, field);
-      if (kind === "scalar") {
-        continue;
-      }
-      const nextTargets = Array.isArray(value) ? flattenList(value) : [value];
-      for (const id2 of nextTargets) {
-        if (visited.includes(id2)) {
-          continue;
-        }
-        this.removeAllSubscribers(id2, subscribers, visited);
-      }
-    }
-  }
-};
-
-// src/runtime/cache/cache.ts
-var Cache3 = class {
-  _internal_unstable;
-  constructor(config2) {
-    this._internal_unstable = new CacheInternal({
-      cache: this,
-      storage: new InMemoryStorage(),
-      subscriptions: new InMemorySubscriptions(this),
-      lists: new ListManager(this, rootID),
-      lifetimes: new GarbageCollector(this),
-      schema: new SchemaManager(this)
-    });
-    if (config2) {
-      this.setConfig(defaultConfigValues(config2));
-    }
-  }
-  write({
-    layer: layerID,
-    notifySubscribers = [],
-    ...args
-  }) {
-    const layer = layerID ? this._internal_unstable.storage.getLayer(layerID) : this._internal_unstable.storage.topLayer;
-    const subscribers = this._internal_unstable.writeSelection({ ...args, layer });
-    const notified = [];
-    for (const spec of subscribers.concat(notifySubscribers)) {
-      if (!notified.includes(spec.set)) {
-        notified.push(spec.set);
-        spec.set(
-          this._internal_unstable.getSelection({
-            parent: spec.parentID || rootID,
-            selection: spec.selection,
-            variables: spec.variables?.() || {}
-          }).data
-        );
-      }
-    }
-    return subscribers;
-  }
-  read(...args) {
-    const { data, partial, hasData } = this._internal_unstable.getSelection(...args);
-    if (!hasData) {
-      return { data: null, partial: false };
-    }
-    return {
-      data,
-      partial
-    };
-  }
-  subscribe(spec, variables = {}) {
-    return this._internal_unstable.subscriptions.add({
-      parent: spec.parentID || rootID,
-      spec,
-      selection: spec.selection,
-      variables
-    });
-  }
-  unsubscribe(spec, variables = {}) {
-    return this._internal_unstable.subscriptions.remove(
-      spec.parentID || rootID,
-      spec.selection,
-      [spec],
-      variables
-    );
-  }
-  list(name2, parentID, allLists) {
-    const handler = this._internal_unstable.lists.get(name2, parentID, allLists);
-    if (!handler) {
-      throw new Error(
-        `Cannot find list with name: ${name2}${parentID ? " under parent " + parentID : ""}. Is it possible that the query is not mounted?`
-      );
-    }
-    return handler;
-  }
-  delete(id) {
-    this._internal_unstable.subscriptions.removeAllSubscribers(id);
-    this._internal_unstable.lists.removeIDFromAllLists(id);
-    this._internal_unstable.storage.delete(id);
-  }
-  setConfig(config2) {
-    this._internal_unstable.setConfig(config2);
-  }
-};
-var CacheInternal = class {
-  _disabled = false;
-  config = defaultConfigValues({
-    plugins: {
-      "houdini-svelte": {
-        client: ""
-      }
-    }
-  });
-  storage;
-  subscriptions;
-  lists;
-  cache;
-  lifetimes;
-  schema;
-  constructor({
-    storage,
-    subscriptions,
-    lists,
-    cache,
-    lifetimes,
-    schema
-  }) {
-    this.storage = storage;
-    this.subscriptions = subscriptions;
-    this.lists = lists;
-    this.cache = cache;
-    this.lifetimes = lifetimes;
-    this.schema = schema;
-    this._disabled = typeof globalThis.window === "undefined";
-    try {
-      if (process.env.HOUDINI_TEST === "true") {
-        this._disabled = false;
-      }
-    } catch {
-    }
-  }
-  setConfig(config2) {
-    this.config = config2;
-  }
-  writeSelection({
-    data,
-    selection: selection2,
-    variables = {},
-    parent = rootID,
-    applyUpdates = false,
-    layer,
-    toNotify = [],
-    forceNotify
-  }) {
-    if (this._disabled) {
-      return [];
-    }
-    let targetSelection = getFieldsForType(selection2, data["__typename"]);
-    for (const [field, value] of Object.entries(data)) {
-      if (!selection2 || !targetSelection[field]) {
-        throw new Error(
-          "Could not find field listing in selection for " + field + " @ " + JSON.stringify(selection2)
-        );
-      }
-      let {
-        type: linkedType,
-        keyRaw,
-        selection: fieldSelection,
-        operations,
-        abstract: isAbstract,
-        update,
-        nullable
-      } = targetSelection[field];
-      const key = evaluateKey(keyRaw, variables);
-      this.schema.setFieldType({
-        parent,
-        key: keyRaw,
-        type: linkedType,
-        nullable,
-        link: !!fieldSelection
-      });
-      const currentSubscribers = this.subscriptions.get(parent, key);
-      const { value: previousValue, displayLayers } = this.storage.get(parent, key);
-      const displayLayer = layer.isDisplayLayer(displayLayers);
-      if (displayLayer) {
-        this.lifetimes.resetLifetime(parent, key);
-      }
-      if (!fieldSelection) {
-        let newValue = value;
-        if (Array.isArray(value) && applyUpdates && update) {
-          if (update === "append") {
-            newValue = (previousValue || []).concat(value);
-          } else if (update === "prepend") {
-            newValue = value.concat(previousValue || []);
-          }
-        }
-        const valueChanged = !deepEquals(newValue, previousValue);
-        if (displayLayer && (valueChanged || forceNotify)) {
-          toNotify.push(...currentSubscribers);
-        }
-        layer.writeField(parent, key, newValue);
-      } else if (value === null) {
-        if (previousValue === null) {
-          continue;
-        }
-        const previousLinks = flattenList([previousValue]);
-        for (const link of previousLinks) {
-          this.subscriptions.remove(link, fieldSelection, currentSubscribers, variables);
-        }
-        layer.writeLink(parent, key, null);
-        toNotify.push(...currentSubscribers);
-      } else if (value instanceof Object && !Array.isArray(value)) {
-        if (isAbstract) {
-          if (!value.__typename) {
-            throw new Error(
-              "Encountered interface type without __typename in the payload"
-            );
-          }
-          linkedType = value.__typename;
-        }
-        const embedded = this.idFields(linkedType)?.filter(
-          (field2) => typeof value[field2] === "undefined"
-        ).length > 0;
-        let linkedID = null;
-        if (value !== null) {
-          linkedID = !embedded ? this.id(linkedType, value) : `${parent}.${key}`;
-        }
-        let linkChange = linkedID !== previousValue;
-        layer.writeLink(parent, key, linkedID);
-        if (linkedID && displayLayer && (linkChange || forceNotify)) {
-          if (previousValue && typeof previousValue === "string") {
-            this.subscriptions.remove(
-              previousValue,
-              fieldSelection,
-              currentSubscribers,
-              variables
-            );
-          }
-          this.subscriptions.addMany({
-            parent: linkedID,
-            selection: fieldSelection,
-            subscribers: currentSubscribers,
-            variables,
-            parentType: linkedType
-          });
-          toNotify.push(...currentSubscribers);
-        }
-        if (linkedID) {
-          this.writeSelection({
-            selection: fieldSelection,
-            parent: linkedID,
-            data: value,
-            variables,
-            toNotify,
-            applyUpdates,
-            layer,
-            forceNotify
-          });
-        }
-      } else if (Array.isArray(value) && (typeof previousValue === "undefined" || Array.isArray(previousValue))) {
-        let oldIDs = [...previousValue || []];
-        const emptyEdges = !update ? [] : oldIDs.map((id) => {
-          if (!id) {
-            return "";
-          }
-          const { value: cursorField } = this.storage.get(id, "cursor");
-          if (cursorField) {
-            return "";
-          }
-          const { value: node } = this.storage.get(id, "node");
-          if (!node) {
-            return "";
-          }
-          return node;
-        });
-        let linkedIDs = [];
-        const { newIDs, nestedIDs } = this.extractNestedListIDs({
-          value,
-          abstract: Boolean(isAbstract),
-          specs: toNotify,
-          applyUpdates,
-          recordID: parent,
-          key,
-          linkedType,
-          variables,
-          fields: fieldSelection,
-          layer,
-          forceNotify
-        });
-        if (applyUpdates && update) {
-          if (key === "edges") {
-            const newNodeIDs = [];
-            for (const id of newIDs) {
-              if (!id) {
-                continue;
-              }
-              const { value: node } = this.storage.get(id, "node");
-              if (typeof node !== "string") {
-                continue;
-              }
-              if (!node || !this.storage.get(node, "__typename")) {
-                continue;
-              }
-              newNodeIDs.push(node);
-            }
-            oldIDs = oldIDs.filter((id) => {
-              if (!id) {
-                return true;
-              }
-              const { value: value2 } = this.storage.get(id, "node");
-              const node = value2;
-              if (newNodeIDs.includes(node) && emptyEdges.includes(node)) {
-                return false;
-              }
-              return true;
-            });
-          }
-          if (update === "prepend") {
-            linkedIDs = newIDs.concat(oldIDs);
-          } else if (update === "append") {
-            linkedIDs = oldIDs.concat(newIDs);
-          } else if (update === "replace") {
-            linkedIDs = newIDs;
-          }
-        } else {
-          linkedIDs = nestedIDs;
-        }
-        const contentChanged = !deepEquals(linkedIDs, oldIDs);
-        if (contentChanged || forceNotify) {
-          toNotify.push(...currentSubscribers);
-        }
-        for (const lostID of oldIDs) {
-          if (linkedIDs.includes(lostID) || !lostID) {
-            continue;
-          }
-          this.subscriptions.remove(lostID, fieldSelection, currentSubscribers, variables);
-        }
-        if (contentChanged || oldIDs.length === 0 && newIDs.length === 0) {
-          layer.writeLink(parent, key, linkedIDs);
-        }
-        for (const id of newIDs.filter((id2) => !oldIDs.includes(id2))) {
-          if (id == null) {
-            continue;
-          }
-          this.subscriptions.addMany({
-            parent: id,
-            selection: fieldSelection,
-            subscribers: currentSubscribers,
-            variables,
-            parentType: linkedType
-          });
-        }
-      }
-      for (const operation of operations || []) {
-        let parentID;
-        if (operation.parentID) {
-          if (operation.parentID.kind !== "Variable") {
-            parentID = operation.parentID.value;
-          } else {
-            const id = variables[operation.parentID.value];
-            if (typeof id !== "string") {
-              throw new Error("parentID value must be a string");
-            }
-            parentID = id;
-          }
-        }
-        if (operation.list && !this.lists.get(operation.list, parentID, operation.target === "all")) {
-          continue;
-        }
-        const targets = Array.isArray(value) ? value : [value];
-        for (const target of targets) {
-          if (operation.action === "insert" && target instanceof Object && fieldSelection && operation.list) {
-            this.cache.list(operation.list, parentID, operation.target === "all").when(operation.when).addToList(
-              fieldSelection,
-              target,
-              variables,
-              operation.position || "last"
-            );
-          } else if (operation.action === "remove" && target instanceof Object && fieldSelection && operation.list) {
-            this.cache.list(operation.list, parentID, operation.target === "all").when(operation.when).remove(target, variables);
-          } else if (operation.action === "delete" && operation.type) {
-            if (typeof target !== "string") {
-              throw new Error("Cannot delete a record with a non-string ID");
-            }
-            const targetID = this.id(operation.type, target);
-            if (!targetID) {
-              continue;
-            }
-            this.cache.delete(targetID);
-          } else if (operation.action === "toggle" && target instanceof Object && fieldSelection && operation.list) {
-            this.cache.list(operation.list, parentID, operation.target === "all").when(operation.when).toggleElement(
-              fieldSelection,
-              target,
-              variables,
-              operation.position || "last"
-            );
-          }
-        }
-      }
-    }
-    return toNotify;
-  }
-  getSelection({
-    selection: selection2,
-    parent = rootID,
-    variables,
-    stepsFromConnection = null
-  }) {
-    if (parent === null) {
-      return { data: null, partial: false, hasData: true };
-    }
-    const target = {};
-    let hasData = false;
-    let partial = false;
-    let cascadeNull = false;
-    const typename = this.storage.get(parent, "__typename").value;
-    let targetSelection = getFieldsForType(selection2, typename);
-    for (const [
-      attributeName,
-      { type, keyRaw, selection: fieldSelection, nullable, list }
-    ] of Object.entries(targetSelection)) {
-      const key = evaluateKey(keyRaw, variables);
-      const { value } = this.storage.get(parent, key);
-      let nextStep = stepsFromConnection;
-      if (nextStep !== null) {
-        if (nextStep >= 2) {
-          nextStep = null;
-        } else {
-          nextStep += 1;
-        }
-      }
-      if (list?.connection) {
-        nextStep = 0;
-      }
-      const embeddedCursor = key === "cursor" && stepsFromConnection === 1;
-      if (typeof value === "undefined" && !embeddedCursor) {
-        partial = true;
-      }
-      if (typeof value === "undefined" || value === null) {
-        target[attributeName] = null;
-        if (typeof value !== "undefined") {
-          hasData = true;
-        }
-      } else if (!fieldSelection) {
-        const fnUnmarshal = this.config?.scalars?.[type]?.unmarshal;
-        if (fnUnmarshal) {
-          target[attributeName] = fnUnmarshal(value);
-        } else {
-          target[attributeName] = value;
-        }
-        hasData = true;
-      } else if (Array.isArray(value)) {
-        const listValue = this.hydrateNestedList({
-          fields: fieldSelection,
-          variables,
-          linkedList: value,
-          stepsFromConnection: nextStep
-        });
-        target[attributeName] = listValue.data;
-        if (listValue.partial) {
-          partial = true;
-        }
-        if (listValue.hasData || value.length === 0) {
-          hasData = true;
-        }
-      } else {
-        const objectFields = this.getSelection({
-          parent: value,
-          selection: fieldSelection,
-          variables,
-          stepsFromConnection: nextStep
-        });
-        target[attributeName] = objectFields.data;
-        if (objectFields.partial) {
-          partial = true;
-        }
-        if (objectFields.hasData) {
-          hasData = true;
-        }
-      }
-      if (target[attributeName] === null && !nullable && !embeddedCursor) {
-        cascadeNull = true;
-      }
-    }
-    return {
-      data: cascadeNull ? null : target,
-      partial: hasData && partial,
-      hasData
-    };
-  }
-  id(type, data) {
-    const id = typeof data === "string" ? data : this.computeID(type, data);
-    if (!id) {
-      return null;
-    }
-    if (!type) {
-      return id;
-    }
-    return type + ":" + id;
-  }
-  idFields(type) {
-    return keyFieldsForType(this.config, type);
-  }
-  computeID(type, data) {
-    return computeID(this.config, type, data);
-  }
-  hydrateNestedList({
-    fields,
-    variables,
-    linkedList,
-    stepsFromConnection
-  }) {
-    const result = [];
-    let partialData = false;
-    let hasValues = false;
-    for (const entry of linkedList) {
-      if (Array.isArray(entry)) {
-        const nestedValue = this.hydrateNestedList({
-          fields,
-          variables,
-          linkedList: entry,
-          stepsFromConnection
-        });
-        result.push(nestedValue.data);
-        if (nestedValue.partial) {
-          partialData = true;
-        }
-        continue;
-      }
-      if (entry === null) {
-        result.push(entry);
-        continue;
-      }
-      const { data, partial, hasData } = this.getSelection({
-        parent: entry,
-        selection: fields,
-        variables,
-        stepsFromConnection
-      });
-      result.push(data);
-      if (partial) {
-        partialData = true;
-      }
-      if (hasData) {
-        hasValues = true;
-      }
-    }
-    return {
-      data: result,
-      partial: partialData,
-      hasData: hasValues
-    };
-  }
-  extractNestedListIDs({
-    value,
-    abstract,
-    recordID,
-    key,
-    linkedType,
-    fields,
-    variables,
-    applyUpdates,
-    specs,
-    layer,
-    forceNotify
-  }) {
-    const nestedIDs = [];
-    const newIDs = [];
-    for (const [i, entry] of value.entries()) {
-      if (Array.isArray(entry)) {
-        const inner = this.extractNestedListIDs({
-          value: entry,
-          abstract,
-          recordID,
-          key,
-          linkedType,
-          fields,
-          variables,
-          applyUpdates,
-          specs,
-          layer,
-          forceNotify
-        });
-        newIDs.push(...inner.newIDs);
-        nestedIDs[i] = inner.nestedIDs;
-        continue;
-      }
-      if (entry === null || typeof entry === "undefined") {
-        newIDs.push(null);
-        nestedIDs[i] = null;
-        continue;
-      }
-      const entryObj = entry;
-      let linkedID = `${recordID}.${key}[${this.storage.nextRank}]`;
-      const embedded = this.idFields(linkedType)?.filter(
-        (field) => typeof entry[field] === "undefined"
-      ).length > 0;
-      const typename = entryObj.__typename;
-      let innerType = linkedType;
-      if (abstract) {
-        if (!typename) {
-          throw new Error("Encountered interface type without __typename in the payload");
-        }
-        innerType = typename;
-      }
-      if (!embedded) {
-        const id = this.id(innerType, entry);
-        if (id) {
-          linkedID = id;
-        } else {
-          continue;
-        }
-      }
-      this.writeSelection({
-        root: rootID,
-        selection: fields,
-        parent: linkedID,
-        data: entryObj,
-        variables,
-        toNotify: specs,
-        applyUpdates,
-        layer,
-        forceNotify
-      });
-      newIDs.push(linkedID);
-      nestedIDs[i] = linkedID;
-    }
-    return { newIDs, nestedIDs };
-  }
-  collectGarbage() {
-    this.lifetimes.tick();
-    if (this.storage.layerCount === 1) {
-      this.storage.topLayer.removeUndefinedFields();
-    }
-  }
-};
-var rootID = "_ROOT_";
-
-// src/runtime/cache/index.ts
-var cache_default = new Cache3();
-
 // src/lib/constants.ts
 var siteURL = "https://houdinigraphql.com";
 var houdini_mode = {
@@ -55986,7 +54273,7 @@ async function recursiveCopy(source, target, transforms, notRoot) {
           const targetPath = join(parentDir, child);
           let original = await readFile(childPath) || "";
           if (transforms?.[childPath]) {
-            original = transforms[childPath](original);
+            original = await transforms[childPath](original, childPath);
           }
           await writeFile(targetPath, original);
         }
@@ -56307,8 +54594,11 @@ var Config = class {
   pluginRuntimeDirectory(name2) {
     return join(this.pluginDirectory(name2), "runtime");
   }
+  get pluginRootDirectory() {
+    return houdini_mode.is_testing ? "../../../" : join(this.rootDir, "plugins");
+  }
   pluginDirectory(name2) {
-    return houdini_mode.is_testing ? resolve("../../../", name2) : join(this.rootDir, "plugins", name2);
+    return join(this.pluginRootDirectory, name2);
   }
   get manualLoadDirective() {
     return "manual_load";
@@ -56358,6 +54648,9 @@ var Config = class {
   get whenNotDirective() {
     return this.whenDirective + "_not";
   }
+  get liveDirective() {
+    return "live";
+  }
   get argumentsDirective() {
     return "arguments";
   }
@@ -56720,7 +55013,13 @@ function exportStarFrom(where) {
 }
 function exportDefaultFrom(where, as) {
   return `var ${as} = require("${where}");
-Object.defineProperty(exports, "${as}", { enumerable: true, get: function () { return __importDefault(${as}).default; } });`;
+${exportDefault(as)}`;
+}
+function exportDefault(as) {
+  return `Object.defineProperty(exports, "${as}", { enumerable: true, get: function () { return __importDefault(${as}).default; } });`;
+}
+function importDefaultFrom(where, as) {
+  return `var ${as} = require("${where}")`;
 }
 
 // src/codegen/utils/flattenSelections.ts
@@ -56764,6 +55063,9 @@ var FieldCollection = class {
       this.add(selection2);
     }
   }
+  get size() {
+    return Object.keys(this.fields).length + Object.keys(this.inlineFragments).length + Object.keys(this.fragmentSpreads).length;
+  }
   add(selection2) {
     if (selection2.kind === "Field") {
       const key = selection2.alias?.value || selection2.name.value;
@@ -56832,9 +55134,12 @@ var FieldCollection = class {
     }
   }
   toSelectionSet() {
-    return Object.values(this.inlineFragments).map((fragment) => {
+    return Object.values(this.inlineFragments).flatMap((fragment) => {
+      if (fragment.selection.size === 0) {
+        return [];
+      }
       fragment.astNode.selectionSet.selections = fragment.selection.toSelectionSet();
-      return fragment.astNode;
+      return [fragment.astNode];
     }).concat(
       Object.values(this.fields).map((field) => {
         if (field.astNode.selectionSet) {
@@ -57017,7 +55322,7 @@ function serializeValue(value) {
   if (typeof value === "object" && value !== null) {
     return AST4.objectExpression(
       Object.entries(value).filter(([, value2]) => typeof value2 !== "undefined").map(
-        ([key, value2]) => AST4.objectProperty(AST4.identifier(key), serializeValue(value2))
+        ([key, value2]) => AST4.objectProperty(AST4.stringLiteral(key), serializeValue(value2))
       )
     );
   }
@@ -58571,6 +56876,23 @@ function artifactGenerator(stats) {
               document: doc
             })
           };
+          const pluginsData = config2.plugins.reduce(
+            (prev, plugin) => {
+              if (!plugin.artifact_data) {
+                return prev;
+              }
+              const result = { ...prev };
+              const dataToAdd = plugin.artifact_data(config2, doc) ?? {};
+              if (Object.keys(dataToAdd).length > 0) {
+                result[plugin.name] = dataToAdd;
+              }
+              return result;
+            },
+            {}
+          );
+          if (Object.keys(pluginsData).length > 0) {
+            artifact.pluginsData = pluginsData;
+          }
           if (inputs && inputs.length > 0) {
             artifact.input = inputObject(config2, inputs);
           }
@@ -58634,77 +56956,132 @@ function artifactGenerator(stats) {
   };
 }
 
-// src/codegen/generators/runtime/index.ts
+// src/codegen/generators/runtime/graphqlFunction.ts
 var recast6 = __toESM(require_main2(), 1);
 var AST6 = recast6.types.builders;
-async function runtimeGenerator(config2, docs) {
-  await Promise.all([
-    fs_exports.recursiveCopy(config2.runtimeSource, config2.runtimeDirectory, {
-      [path_exports.join(config2.runtimeSource, "lib", "config.js")]: (content) => {
-        const configFilePath = path_exports.join(config2.runtimeDirectory, "lib", "config.js");
-        const relativePath = path_exports.relative(path_exports.dirname(configFilePath), config2.filepath);
-        return content.replace("HOUDINI_CONFIG_PATH", relativePath);
-      },
-      [path_exports.join(config2.runtimeSource, "lib", "constants.js")]: (content) => {
-        return content.replace("SITE_URL", siteURL);
-      }
-    }),
-    ...config2.plugins.filter((plugin) => plugin.include_runtime).map((plugin) => generatePluginRuntime(config2, plugin))
-  ]);
+async function generateGraphqlReturnTypes(config2, docs) {
   const indexPath = path_exports.join(config2.runtimeDirectory, "index.d.ts");
-  const contents = await parseJS(await fs_exports.readFile(indexPath) || "");
+  const fileContent = await fs_exports.readFile(indexPath) || "";
+  const contents = await parseJS(fileContent);
   const graphql_tag_return = config2.plugins.find(
     (plugin) => plugin.graphql_tag_return
   )?.graphql_tag_return;
-  if (graphql_tag_return && contents) {
-    const overloaded_returns = {};
-    for (const doc of docs) {
-      const return_value = graphql_tag_return({
-        config: config2,
-        doc,
-        ensure_import({ identifier, module }) {
-          ensureImports({
-            config: config2,
-            body: contents.script.body,
-            sourceModule: module,
-            import: [identifier]
-          });
-        }
-      });
-      if (return_value) {
-        overloaded_returns[doc.originalString] = return_value;
+  if (!graphql_tag_return || !contents) {
+    return fileContent;
+  }
+  const overloaded_returns = {};
+  for (const doc of docs) {
+    const return_value = graphql_tag_return({
+      config: config2,
+      doc,
+      ensure_import({ identifier, module }) {
+        ensureImports({
+          config: config2,
+          body: contents.script.body,
+          sourceModule: module,
+          import: [identifier]
+        });
       }
+    });
+    if (return_value) {
+      overloaded_returns[doc.originalString] = return_value;
     }
-    if (Object.keys(overloaded_returns).length > 0) {
-      for (const [i, expression] of (contents?.script.body ?? []).entries()) {
-        if (expression.type !== "ExportNamedDeclaration" || expression.declaration?.type !== "TSDeclareFunction" || expression.declaration.id?.name !== "graphql") {
-          continue;
-        }
-        for (const [queryString, returnValue] of Object.entries(overloaded_returns)) {
-          const input = AST6.identifier("str");
-          input.typeAnnotation = AST6.tsTypeAnnotation(
-            AST6.tsLiteralType(AST6.stringLiteral(queryString))
-          );
-          contents?.script.body.splice(
-            i,
-            0,
-            AST6.exportNamedDeclaration(
-              AST6.tsDeclareFunction(
-                AST6.identifier("graphql"),
-                [input],
-                AST6.tsTypeAnnotation(
-                  AST6.tsTypeReference(AST6.identifier(returnValue))
-                )
-              )
+  }
+  if (Object.keys(overloaded_returns).length > 0) {
+    for (const [i, expression] of (contents?.script.body ?? []).entries()) {
+      if (expression.type !== "ExportNamedDeclaration" || expression.declaration?.type !== "TSDeclareFunction" || expression.declaration.id?.name !== "graphql") {
+        continue;
+      }
+      for (const [queryString, returnValue] of Object.entries(overloaded_returns)) {
+        const input = AST6.identifier("str");
+        input.typeAnnotation = AST6.tsTypeAnnotation(
+          AST6.tsLiteralType(AST6.stringLiteral(queryString))
+        );
+        contents?.script.body.splice(
+          i,
+          0,
+          AST6.exportNamedDeclaration(
+            AST6.tsDeclareFunction(
+              AST6.identifier("graphql"),
+              [input],
+              AST6.tsTypeAnnotation(AST6.tsTypeReference(AST6.identifier(returnValue)))
             )
-          );
-        }
-        break;
+          )
+        );
       }
-      await fs_exports.writeFile(indexPath, recast6.prettyPrint(contents.script).code);
+      break;
     }
+    await fs_exports.writeFile(indexPath, recast6.prettyPrint(contents.script).code);
   }
 }
+
+// src/codegen/generators/runtime/injectPlugins.ts
+async function injectPlugins({
+  config: config2,
+  content,
+  importStatement,
+  exportStatement
+}) {
+  const client_plugins = config2.plugins.filter((plugin) => plugin.client_plugins).reduce((acc, plugin) => {
+    let plugins = plugin.client_plugins;
+    if (typeof plugins === "function") {
+      plugins = plugins(config2, config2.pluginConfig(plugin.name));
+    }
+    return [...acc, ...Object.entries(plugins)];
+  }, []);
+  return client_plugins.length > 0 ? `
+${client_plugins.map((plugin, i) => importStatement(plugin[0], `plugin${i}`))}
+
+const plugins = [
+	${client_plugins.map((plugin, i) => {
+    const suffix = plugin[1] !== null ? `(${JSON.stringify(plugin[1])})` : "";
+    return `plugin${i}${suffix}`;
+  }).join(",\n")}
+]
+
+${exportStatement("plugins")}
+				` : content;
+}
+
+// src/codegen/generators/runtime/pluginIndex.ts
+async function generatePluginIndex({
+  config: config2,
+  exportStatement
+}) {
+  const indexFile = `${exportStatement("../runtime/client/plugins/index.js")}
+`;
+  const typedefs = `export * from '../runtime/client/plugins'`;
+  await fs_exports.mkdirp(config2.pluginRootDirectory);
+  await Promise.all([
+    fs_exports.writeFile(path_exports.join(config2.pluginRootDirectory, "index.js"), indexFile),
+    fs_exports.writeFile(path_exports.join(config2.pluginRootDirectory, "index.d.ts"), typedefs)
+  ]);
+}
+
+// src/codegen/generators/runtime/index.ts
+async function runtimeGenerator(config2, docs) {
+  const importStatement = config2.module === "commonjs" ? importDefaultFrom : (where, as) => `import ${as} from '${where}'`;
+  const exportStatement = config2.module === "commonjs" ? exportDefault : (as) => `export default ${as}`;
+  const exportStar = config2.module === "commonjs" ? exportStarFrom : (where) => `export * from '${where}'`;
+  await Promise.all([
+    fs_exports.recursiveCopy(config2.runtimeSource, config2.runtimeDirectory, {
+      [path_exports.join(config2.runtimeSource, "lib", "constants.js")]: (content) => {
+        return content.replace("SITE_URL", siteURL);
+      },
+      [path_exports.join(config2.runtimeSource, "imports", "config.js")]: (content) => {
+        const configFilePath = path_exports.join(config2.runtimeDirectory, "imports", "config.js");
+        const relativePath = path_exports.relative(path_exports.dirname(configFilePath), config2.filepath);
+        return `${importStatement(relativePath, "config")}
+${exportStatement("config")}
+`;
+      },
+      [path_exports.join(config2.runtimeSource, "client", "plugins", "injectedPlugins.js")]: (content) => injectPlugins({ config: config2, content, importStatement, exportStatement })
+    }),
+    ...config2.plugins.filter((plugin) => plugin.include_runtime).map((plugin) => generatePluginRuntime(config2, plugin)),
+    generatePluginIndex({ config: config2, exportStatement: exportStar })
+  ]);
+  await generateGraphqlReturnTypes(config2, docs);
+}
 async function generatePluginRuntime(config2, plugin) {
   if (houdini_mode.is_testing) {
     return;
@@ -59770,6 +58147,7 @@ async function writeIndexFile2(config2, docs) {
   const export_star_from = ({ module }) => "\n" + (cjs ? exportStarFrom(module) : `export * from "${module}"`) + "\n";
   const export_default_as = ({ module, as }) => "\n" + (cjs ? exportDefaultFrom(module, as) : `export { default as ${as} } from "${module}"`) + "\n";
   body += [
+    export_star_from({ module: "./" + path_exports.join(runtimeDir, "client") }),
     export_star_from({ module: runtimeDir }),
     export_star_from({ module: artifactDir }),
     export_star_from({ module: definitionsDir })
@@ -59882,7 +58260,7 @@ function flattenFragments(filepath, operation, fragments) {
 }
 
 // src/codegen/transforms/schema.ts
-var graphql20 = __toESM(require_graphql2(), 1);
+var graphql19 = __toESM(require_graphql2(), 1);
 async function graphqlExtensions(config2, documents) {
   const internalSchema = `
 enum CachePolicy {
@@ -59960,19 +58338,19 @@ directive @${config2.maskEnableDirective} on FRAGMENT_SPREAD
 """
 directive @${config2.maskDisableDirective} on FRAGMENT_SPREAD
 `;
-  let currentSchema = graphql20.printSchema(config2.schema);
+  let currentSchema = graphql19.printSchema(config2.schema);
   if (!currentSchema.includes(`directive @${config2.listDirective}`)) {
     currentSchema += internalSchema;
   }
   config2.newSchema += internalSchema;
-  config2.schema = graphql20.buildSchema(currentSchema);
+  config2.schema = graphql19.buildSchema(currentSchema);
 }
 
 // src/codegen/transforms/typename.ts
-var graphql21 = __toESM(require_graphql2(), 1);
+var graphql20 = __toESM(require_graphql2(), 1);
 async function addTypename(config2, documents) {
   for (const doc of documents) {
-    doc.document = graphql21.visit(doc.document, {
+    doc.document = graphql20.visit(doc.document, {
       Field(node, key, parent, path2, ancestors) {
         if (!node.selectionSet) {
           return;
@@ -59984,7 +58362,7 @@ async function addTypename(config2, documents) {
         );
         const field = type.getFields()[node.name.value];
         const fieldType = unwrapType(config2, field.type).type;
-        if (graphql21.isInterfaceType(fieldType) || graphql21.isUnionType(fieldType)) {
+        if (graphql20.isInterfaceType(fieldType) || graphql20.isUnionType(fieldType)) {
           return {
             ...node,
             selectionSet: {
@@ -59992,9 +58370,9 @@ async function addTypename(config2, documents) {
               selections: [
                 ...node.selectionSet.selections,
                 {
-                  kind: graphql21.Kind.FIELD,
+                  kind: graphql20.Kind.FIELD,
                   name: {
-                    kind: graphql21.Kind.NAME,
+                    kind: graphql20.Kind.NAME,
                     value: "__typename"
                   }
                 }
@@ -60008,10 +58386,10 @@ async function addTypename(config2, documents) {
 }
 
 // src/codegen/transforms/addID.ts
-var graphql22 = __toESM(require_graphql2(), 1);
+var graphql21 = __toESM(require_graphql2(), 1);
 async function addID(config2, documents) {
   for (const doc of documents) {
-    doc.document = graphql22.visit(doc.document, {
+    doc.document = graphql21.visit(doc.document, {
       Field(node, key, parent, path2, ancestors) {
         if (!node.selectionSet) {
           return;
@@ -60024,7 +58402,7 @@ async function addID(config2, documents) {
         const field = type.getFields()[node.name.value];
         const fieldType = unwrapType(config2, field.type).type;
         if (node.selectionSet?.selections.length > 0) {
-          if (!graphql22.isObjectType(fieldType) && !graphql22.isInterfaceType(fieldType)) {
+          if (!graphql21.isObjectType(fieldType) && !graphql21.isInterfaceType(fieldType)) {
             return;
           }
           const keyFields = config2.keyFieldsForType(fieldType.name);
@@ -60039,9 +58417,9 @@ async function addID(config2, documents) {
               continue;
             }
             selections.push({
-              kind: graphql22.Kind.FIELD,
+              kind: graphql21.Kind.FIELD,
               name: {
-                kind: graphql22.Kind.NAME,
+                kind: graphql21.Kind.NAME,
                 value: keyField
               }
             });
@@ -60060,8 +58438,8 @@ async function addID(config2, documents) {
 }
 
 // src/codegen/transforms/fragmentVariables.ts
-var graphql23 = __toESM(require_graphql2(), 1);
-var GraphqlKinds2 = graphql23.Kind;
+var graphql22 = __toESM(require_graphql2(), 1);
+var GraphqlKinds2 = graphql22.Kind;
 async function fragmentVariables(config2, documents) {
   const fragments = collectFragments(config2, documents);
   const generatedFragments = {};
@@ -60084,7 +58462,7 @@ async function fragmentVariables(config2, documents) {
     });
   }
   const doc = {
-    kind: graphql23.Kind.DOCUMENT,
+    kind: graphql22.Kind.DOCUMENT,
     definitions: Object.values(generatedFragments)
   };
   documents.push({
@@ -60120,7 +58498,7 @@ function inlineFragmentArgs({
     filepath,
     document
   ).reduce((acc, arg) => ({ ...acc, [arg.name]: arg }), {});
-  const result = graphql23.visit(document, {
+  const result = graphql22.visit(document, {
     FragmentSpread(node) {
       const { definition } = fragmentDefinitions[node.name.value];
       let { args, hash } = collectWithArguments(config2, filepath, node, scope);
@@ -60208,7 +58586,7 @@ function inlineFragmentArgs({
   });
   if (newName) {
     result.name = {
-      kind: graphql23.Kind.NAME,
+      kind: graphql22.Kind.NAME,
       value: newName
     };
   }
@@ -60320,7 +58698,7 @@ function operationScope(operation) {
 }
 
 // src/codegen/validators/typeCheck.ts
-var graphql24 = __toESM(require_graphql2(), 1);
+var graphql23 = __toESM(require_graphql2(), 1);
 async function typeCheck(config2, docs) {
   const errors = [];
   const freeLists = [];
@@ -60328,11 +58706,11 @@ async function typeCheck(config2, docs) {
   const listTypes = [];
   const fragments = {};
   for (const { document: parsed, filename } of docs) {
-    graphql24.visit(parsed, {
-      [graphql24.Kind.FRAGMENT_DEFINITION](definition) {
+    graphql23.visit(parsed, {
+      [graphql23.Kind.FRAGMENT_DEFINITION](definition) {
         fragments[definition.name.value] = definition;
       },
-      [graphql24.Kind.DIRECTIVE](directive, _, parent, __, ancestors) {
+      [graphql23.Kind.DIRECTIVE](directive, _, parent, __, ancestors) {
         if (![config2.listDirective, config2.paginateDirective].includes(directive.name.value)) {
           return;
         }
@@ -60378,14 +58756,14 @@ async function typeCheck(config2, docs) {
             );
             return;
           }
-          if (graphql24.isListType(rootType) || graphql24.isNonNullType(rootType) && graphql24.isListType(rootType.ofType)) {
+          if (graphql23.isListType(rootType) || graphql23.isNonNullType(rootType) && graphql23.isListType(rootType.ofType)) {
             needsParent = true;
             break;
           }
-          if (graphql24.isNonNullType(rootType) && "ofType" in rootType) {
+          if (graphql23.isNonNullType(rootType) && "ofType" in rootType) {
             rootType = rootType.ofType;
           }
-          if (graphql24.isScalarType(rootType)) {
+          if (graphql23.isScalarType(rootType)) {
             break;
           }
           rootType = rootType?.getFields()[parent2.name.value]?.type;
@@ -60461,9 +58839,9 @@ async function typeCheck(config2, docs) {
           );
         }
         let targetTypes = [type];
-        if (graphql24.isUnionType(type)) {
+        if (graphql23.isUnionType(type)) {
           targetTypes = config2.schema.getPossibleTypes(type);
-        } else if (graphql24.isInterfaceType(type)) {
+        } else if (graphql23.isInterfaceType(type)) {
           try {
             for (const key of config2.keyFieldsForType(type.name)) {
               if (!type.getFields()[key]) {
@@ -60501,13 +58879,13 @@ async function typeCheck(config2, docs) {
   if (errors.length > 0) {
     throw errors;
   }
-  const rules = (filepath) => [...graphql24.specifiedRules].filter(
+  const rules = (filepath) => [...graphql23.specifiedRules].filter(
     (rule) => ![
-      graphql24.NoUnusedFragmentsRule,
-      graphql24.KnownFragmentNamesRule,
-      graphql24.ExecutableDefinitionsRule,
-      graphql24.KnownDirectivesRule,
-      graphql24.KnownArgumentNamesRule
+      graphql23.NoUnusedFragmentsRule,
+      graphql23.KnownFragmentNamesRule,
+      graphql23.ExecutableDefinitionsRule,
+      graphql23.KnownDirectivesRule,
+      graphql23.KnownArgumentNamesRule
     ].includes(rule)
   ).concat(
     validateLists({
@@ -60526,7 +58904,7 @@ async function typeCheck(config2, docs) {
     noUnusedFragmentArguments(config2)
   );
   for (const { filename, document: parsed } of docs) {
-    for (const error of graphql24.validate(config2.schema, parsed, rules(filename))) {
+    for (const error of graphql23.validate(config2.schema, parsed, rules(filename))) {
       errors.push(
         new HoudiniError({
           filepath: filename,
@@ -60552,7 +58930,7 @@ var validateLists = ({
       if (!config2.isListFragment(node.name.value)) {
         if (!fragments[node.name.value]) {
           ctx.reportError(
-            new graphql24.GraphQLError(
+            new graphql23.GraphQLError(
               "Encountered unknown fragment: " + node.name.value
             )
           );
@@ -60562,7 +58940,7 @@ var validateLists = ({
       const listName = config2.listNameFromFragment(node.name.value);
       if (!lists.includes(listName)) {
         ctx.reportError(
-          new graphql24.GraphQLError(
+          new graphql23.GraphQLError(
             "Encountered fragment referencing unknown list: " + listName
           )
         );
@@ -60587,7 +58965,7 @@ var validateLists = ({
         );
         if (parentArg) {
           ctx.reportError(
-            new graphql24.GraphQLError(
+            new graphql23.GraphQLError(
               `@${config2.deprecatedlistDirectiveParentIDArg} should be defined only in it's own directive now`
             )
           );
@@ -60603,7 +58981,7 @@ var validateLists = ({
         return;
       }
       ctx.reportError(
-        new graphql24.GraphQLError(
+        new graphql23.GraphQLError(
           `For this list fragment, you need to add or @${config2.listParentDirective} or @${config2.listAllListsDirective} directive to specify the behavior`
         )
       );
@@ -60613,7 +58991,7 @@ var validateLists = ({
       const directiveName = node.name.value;
       if (directiveName === "connection") {
         ctx.reportError(
-          new graphql24.GraphQLError(
+          new graphql23.GraphQLError(
             "@connection was renamed to @list. Please change your components. If you were using `cache.connection` in your components, you will need to update that to `cache.list` too."
           )
         );
@@ -60622,7 +59000,7 @@ var validateLists = ({
       if (!config2.isInternalDirective(node)) {
         if (!config2.schema.getDirective(directiveName)) {
           ctx.reportError(
-            new graphql24.GraphQLError(
+            new graphql23.GraphQLError(
               "Encountered unknown directive: " + directiveName
             )
           );
@@ -60631,7 +59009,7 @@ var validateLists = ({
       }
       if (config2.isListOperationDirective(directiveName) && !listTypes.includes(config2.listNameFromDirective(directiveName))) {
         ctx.reportError(
-          new graphql24.GraphQLError(
+          new graphql23.GraphQLError(
             "Encountered directive referencing unknown list: " + directiveName
           )
         );
@@ -60642,7 +59020,7 @@ var validateLists = ({
 };
 function knownArguments(config2) {
   return function(ctx) {
-    const nativeValidator = graphql24.KnownArgumentNamesRule(ctx);
+    const nativeValidator = graphql23.KnownArgumentNamesRule(ctx);
     return {
       ...nativeValidator,
       Directive(directiveNode) {
@@ -60675,7 +59053,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
         for (const arg of node.arguments || []) {
           if (arg.value.kind !== "ObjectValue") {
             ctx.reportError(
-              new graphql24.GraphQLError("values in @arguments must be an object")
+              new graphql23.GraphQLError("values in @arguments must be an object")
             );
             return;
           }
@@ -60685,13 +59063,13 @@ function validateFragmentArguments(config2, filepath, fragments) {
           );
           if (!typeArg) {
             ctx.reportError(
-              new graphql24.GraphQLError("missing type field for @arguments directive")
+              new graphql23.GraphQLError("missing type field for @arguments directive")
             );
             return;
           }
-          if (typeArg.value.kind !== graphql24.Kind.STRING) {
+          if (typeArg.value.kind !== graphql23.Kind.STRING) {
             ctx.reportError(
-              new graphql24.GraphQLError("type field to @arguments must be a string")
+              new graphql23.GraphQLError("type field to @arguments must be a string")
             );
             return;
           }
@@ -60704,7 +59082,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
           );
           if (typeArg.value.value !== defaultValueType) {
             ctx.reportError(
-              new graphql24.GraphQLError(
+              new graphql23.GraphQLError(
                 `Invalid default value provided for ${arg.name.value}. Expected ${typeArg.value.value}, found ${defaultValueType}`
               )
             );
@@ -60722,7 +59100,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
           try {
             args = fragmentArguments(config2, filepath, fragments[fragmentName]);
           } catch (e) {
-            ctx.reportError(new graphql24.GraphQLError(e.message));
+            ctx.reportError(new graphql23.GraphQLError(e.message));
             return;
           }
           fragmentArguments2[fragmentName] = args;
@@ -60745,7 +59123,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
         );
         if (missing.length > 0) {
           ctx.reportError(
-            new graphql24.GraphQLError(
+            new graphql23.GraphQLError(
               "The following arguments are missing from this fragment: " + JSON.stringify(missing)
             )
           );
@@ -60756,7 +59134,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
         );
         if (unknown.length > 0) {
           ctx.reportError(
-            new graphql24.GraphQLError(
+            new graphql23.GraphQLError(
               "Encountered unknown arguments: " + JSON.stringify(unknown)
             )
           );
@@ -60768,7 +59146,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
             ]
           );
           for (const [applied, target] of zipped) {
-            if (applied.value.kind === graphql24.Kind.VARIABLE || applied.value.kind === graphql24.Kind.LIST || applied.value.kind === graphql24.Kind.OBJECT) {
+            if (applied.value.kind === graphql23.Kind.VARIABLE || applied.value.kind === graphql23.Kind.LIST || applied.value.kind === graphql23.Kind.OBJECT) {
               continue;
             }
             const appliedType = applied.value.kind.substring(
@@ -60777,7 +59155,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
             );
             if (appliedType !== target) {
               ctx.reportError(
-                new graphql24.GraphQLError(
+                new graphql23.GraphQLError(
                   `Invalid argument type. Expected ${target}, found ${appliedType}`
                 )
               );
@@ -60798,7 +59176,7 @@ function paginateArgs(config2, filepath) {
         }
         if (alreadyPaginated) {
           ctx.reportError(
-            new graphql24.GraphQLError(
+            new graphql23.GraphQLError(
               `@${config2.paginateDirective} can only appear in a document once.`
             )
           );
@@ -60813,7 +59191,7 @@ function paginateArgs(config2, filepath) {
         const hasRequiredArgs = definitionArgs.find((arg) => arg.required);
         if (hasRequiredArgs) {
           ctx.reportError(
-            new graphql24.GraphQLError(
+            new graphql23.GraphQLError(
               "@paginate cannot appear on a document with required args"
             )
           );
@@ -60845,14 +59223,14 @@ function paginateArgs(config2, filepath) {
           const backwards = appliedArgs.has("last");
           if (!forward && !backwards) {
             ctx.reportError(
-              new graphql24.GraphQLError(
+              new graphql23.GraphQLError(
                 "A field with cursor-based pagination must have a first or last argument"
               )
             );
           }
           if (forward && backwards) {
             ctx.reportError(
-              new graphql24.GraphQLError(
+              new graphql23.GraphQLError(
                 `A field with cursor pagination cannot go forwards an backwards simultaneously`
               )
             );
@@ -60866,7 +59244,7 @@ function paginateArgs(config2, filepath) {
           );
           if (!appliedLimitArg) {
             ctx.reportError(
-              new graphql24.GraphQLError(
+              new graphql23.GraphQLError(
                 "A field with offset-based pagination must have a limit argument"
               )
             );
@@ -60882,20 +59260,20 @@ function noUnusedFragmentArguments(config2) {
     const args = /* @__PURE__ */ new Set();
     return {
       enter(node) {
-        if (node.kind === graphql24.Kind.FRAGMENT_DEFINITION) {
+        if (node.kind === graphql23.Kind.FRAGMENT_DEFINITION) {
           const definitionArguments = node.directives?.filter((directive) => directive.name.value === config2.argumentsDirective).flatMap((directive) => directive.arguments);
           for (const arg of definitionArguments?.map((arg2) => arg2?.name.value) || []) {
             args.add(arg);
           }
-        } else if (node.kind === graphql24.Kind.VARIABLE) {
+        } else if (node.kind === graphql23.Kind.VARIABLE) {
           args.delete(node.name.value);
         }
       },
       leave(node) {
-        if (node.kind === graphql24.Kind.FRAGMENT_DEFINITION) {
+        if (node.kind === graphql23.Kind.FRAGMENT_DEFINITION) {
           if (args.size > 0) {
             ctx.reportError(
-              new graphql24.GraphQLError(
+              new graphql23.GraphQLError(
                 "Encountered unused fragment arguments: " + [...args].join(",")
               )
             );
@@ -60931,7 +59309,7 @@ function nodeDirectives(config2, directives) {
         if (definition.kind === "OperationDefinition") {
           if (definition.operation !== "query") {
             ctx.reportError(
-              new graphql24.GraphQLError(
+              new graphql23.GraphQLError(
                 `@${node.name.value} must fall on a fragment or query document`
               )
             );
@@ -60943,7 +59321,7 @@ function nodeDirectives(config2, directives) {
         }
         if (!possibleNodes.includes(definitionType)) {
           ctx.reportError(
-            new graphql24.GraphQLError(paginateOnNonNodeMessage(config2, node.name.value))
+            new graphql23.GraphQLError(paginateOnNonNodeMessage(config2, node.name.value))
           );
         }
       }
@@ -60962,7 +59340,7 @@ function checkMutationOperation(config2) {
         );
         if (append && prepend) {
           ctx.reportError(
-            new graphql24.GraphQLError(
+            new graphql23.GraphQLError(
               `You can't apply both @${config2.listPrependDirective} and @${config2.listAppendDirective} at the same time`
             )
           );
@@ -60976,7 +59354,7 @@ function checkMutationOperation(config2) {
         );
         if (parentId && allLists) {
           ctx.reportError(
-            new graphql24.GraphQLError(
+            new graphql23.GraphQLError(
               `You can't apply both @${config2.listParentDirective} and @${config2.listAllListsDirective} at the same time`
             )
           );
@@ -60998,7 +59376,7 @@ function checkMaskDirective(config2) {
         );
         if (maskEnableDirective && maskDisableDirective) {
           ctx.reportError(
-            new graphql24.GraphQLError(
+            new graphql23.GraphQLError(
               `You can't apply both @${config2.maskEnableDirective} and @${config2.maskDisableDirective} at the same time`
             )
           );
@@ -61014,7 +59392,7 @@ function getAndVerifyNodeInterface(config2) {
   if (!nodeInterface) {
     return null;
   }
-  if (!graphql24.isInterfaceType(nodeInterface)) {
+  if (!graphql23.isInterfaceType(nodeInterface)) {
     displayInvalidNodeFieldMessage(config2.logLevel);
     return null;
   }
@@ -61112,11 +59490,11 @@ async function uniqueDocumentNames(config2, docs) {
 }
 
 // src/codegen/validators/noIDAlias.ts
-var graphql25 = __toESM(require_graphql2(), 1);
+var graphql24 = __toESM(require_graphql2(), 1);
 async function noIDAlias(config2, docs) {
   const errors = [];
   for (const { filename, document } of docs) {
-    graphql25.visit(document, {
+    graphql24.visit(document, {
       Field(node, _, __, ___, ancestors) {
         const fieldType = parentTypeFromAncestors(config2.schema, filename, ancestors).name;
         if (config2.keyFieldsForType(fieldType).includes(node.alias?.value || "")) {
@@ -61280,12 +59658,14 @@ function logStyled(kind, stat2, logLevel, plugin) {
 }
 
 // src/test/index.ts
-function testConfigFile(config2 = {}) {
+function testConfigFile({ plugins, ...config2 } = {}) {
   return {
     schema: `
 			scalar Cursor
 			scalar DateTime
 
+			directive @live on QUERY
+
 			type User implements Node & Friend & CatOwner {
 				id: ID!
 				name: String!
@@ -61419,7 +59799,7 @@ function testConfigFile(config2 = {}) {
 				cats: [Cat!]!
 			}
 
-			interface IsGhost { 
+			interface IsGhost {
 				aka: String!
 			}
 
@@ -61512,7 +59892,8 @@ function testConfigFile(config2 = {}) {
     plugins: {
       "houdini-svelte": {
         client: "./my/client/path"
-      }
+      },
+      ...plugins
     },
     acceptImperativeInstability: true,
     ...config2
@@ -61546,7 +59927,7 @@ function pipelineTest(config2, documents, shouldPass, testBody) {
   };
 }
 function mockCollectedDoc(query) {
-  const parsed = graphql26.parse(query);
+  const parsed = graphql25.parse(query);
   const name2 = parsed.definitions[0].name.value;
   const operations = parsed.definitions;
   let kind = "HoudiniFragment" /* Fragment */;