houdini 1.0.0-next.9 → 1.0.0

package/build/lib-cjs/index.js

@@ -16064,7 +16064,7 @@ var require_graceful_fs = __commonJS({
       gracefulQueue = "___graceful-fs.queue";
       previousSymbol = "___graceful-fs.previous";
     }
-    function noop2() {
+    function noop3() {
     }
     function publishQueue(context, queue2) {
       Object.defineProperty(context, gracefulQueue, {
@@ -16073,7 +16073,7 @@ var require_graceful_fs = __commonJS({
         }
       });
     }
-    var debug = noop2;
+    var debug = noop3;
     if (util.debuglog)
       debug = util.debuglog("gfs4");
     else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
@@ -20420,8 +20420,8 @@ var require_node = __commonJS({
       Node2.prototype.isSymlink = function() {
         return (this.mode & S_IFMT) === S_IFLNK;
       };
-      Node2.prototype.makeSymlink = function(steps) {
-        this.symlink = steps;
+      Node2.prototype.makeSymlink = function(steps2) {
+        this.symlink = steps2;
         this.setIsSymlink();
       };
       Node2.prototype.write = function(buf, off, len, pos) {
@@ -20638,22 +20638,22 @@ var require_node = __commonJS({
       Link2.prototype.getName = function() {
         return this.steps[this.steps.length - 1];
       };
-      Link2.prototype.walk = function(steps, stop, i2) {
+      Link2.prototype.walk = function(steps2, stop, i2) {
         if (stop === void 0) {
-          stop = steps.length;
+          stop = steps2.length;
         }
         if (i2 === void 0) {
           i2 = 0;
         }
-        if (i2 >= steps.length)
+        if (i2 >= steps2.length)
           return this;
         if (i2 >= stop)
           return this;
-        var step = steps[i2];
+        var step = steps2[i2];
         var link = this.getChild(step);
         if (!link)
           return null;
-        return link.walk(steps, stop, i2 + 1);
+        return link.walk(steps2, stop, i2 + 1);
       };
       Link2.prototype.toJSON = function() {
         return {
@@ -20668,42 +20668,42 @@ var require_node = __commonJS({
       return Link2;
     }(events_1.EventEmitter);
     exports.Link = Link;
-    var File3 = function() {
-      function File4(link, node, flags, fd) {
+    var File4 = function() {
+      function File5(link, node, flags, fd) {
         this.position = 0;
         this.link = link;
         this.node = node;
         this.flags = flags;
         this.fd = fd;
       }
-      File4.prototype.getString = function(encoding) {
+      File5.prototype.getString = function(encoding) {
         if (encoding === void 0) {
           encoding = "utf8";
         }
         return this.node.getString();
       };
-      File4.prototype.setString = function(str) {
+      File5.prototype.setString = function(str) {
         this.node.setString(str);
       };
-      File4.prototype.getBuffer = function() {
+      File5.prototype.getBuffer = function() {
         return this.node.getBuffer();
       };
-      File4.prototype.setBuffer = function(buf) {
+      File5.prototype.setBuffer = function(buf) {
         this.node.setBuffer(buf);
       };
-      File4.prototype.getSize = function() {
+      File5.prototype.getSize = function() {
         return this.node.getSize();
       };
-      File4.prototype.truncate = function(len) {
+      File5.prototype.truncate = function(len) {
         this.node.truncate(len);
       };
-      File4.prototype.seekTo = function(position) {
+      File5.prototype.seekTo = function(position) {
         this.position = position;
       };
-      File4.prototype.stats = function() {
+      File5.prototype.stats = function() {
         return Stats_1.default.build(this.node);
       };
-      File4.prototype.write = function(buf, offset, length, position) {
+      File5.prototype.write = function(buf, offset, length, position) {
         if (offset === void 0) {
           offset = 0;
         }
@@ -20718,7 +20718,7 @@ var require_node = __commonJS({
         this.position = position + bytes;
         return bytes;
       };
-      File4.prototype.read = function(buf, offset, length, position) {
+      File5.prototype.read = function(buf, offset, length, position) {
         if (offset === void 0) {
           offset = 0;
         }
@@ -20731,15 +20731,15 @@ var require_node = __commonJS({
         this.position = position + bytes;
         return bytes;
       };
-      File4.prototype.chmod = function(perm) {
+      File5.prototype.chmod = function(perm) {
         this.node.chmod(perm);
       };
-      File4.prototype.chown = function(uid, gid) {
+      File5.prototype.chown = function(uid, gid) {
         this.node.chown(uid, gid);
       };
-      return File4;
+      return File5;
     }();
-    exports.File = File3;
+    exports.File = File4;
   }
 });
 
@@ -21425,20 +21425,20 @@ var require_volume = __commonJS({
     }
     function flattenJSON(nestedJSON) {
       var flatJSON = {};
-      function flatten(pathPrefix, node) {
+      function flatten2(pathPrefix, node) {
         for (var path2 in node) {
           var contentOrNode = node[path2];
           var joinedPath = join3(pathPrefix, path2);
           if (typeof contentOrNode === "string") {
             flatJSON[joinedPath] = contentOrNode;
           } else if (typeof contentOrNode === "object" && contentOrNode !== null && Object.keys(contentOrNode).length > 0) {
-            flatten(joinedPath, contentOrNode);
+            flatten2(joinedPath, contentOrNode);
           } else {
             flatJSON[joinedPath] = null;
           }
         }
       }
-      flatten("", nestedJSON);
+      flatten2("", nestedJSON);
       return flatJSON;
     }
     var Volume = function() {
@@ -21576,28 +21576,28 @@ var require_volume = __commonJS({
         else
           return this.genRndStr();
       };
-      Volume2.prototype.getLink = function(steps) {
-        return this.root.walk(steps);
+      Volume2.prototype.getLink = function(steps2) {
+        return this.root.walk(steps2);
       };
       Volume2.prototype.getLinkOrThrow = function(filename, funcName) {
-        var steps = filenameToSteps(filename);
-        var link = this.getLink(steps);
+        var steps2 = filenameToSteps(filename);
+        var link = this.getLink(steps2);
         if (!link)
           throw createError(ENOENT, funcName, filename);
         return link;
       };
       Volume2.prototype.getResolvedLink = function(filenameOrSteps) {
-        var steps = typeof filenameOrSteps === "string" ? filenameToSteps(filenameOrSteps) : filenameOrSteps;
+        var steps2 = typeof filenameOrSteps === "string" ? filenameToSteps(filenameOrSteps) : filenameOrSteps;
         var link = this.root;
         var i2 = 0;
-        while (i2 < steps.length) {
-          var step = steps[i2];
+        while (i2 < steps2.length) {
+          var step = steps2[i2];
           link = link.getChild(step);
           if (!link)
             return null;
           var node = link.getNode();
           if (node.isSymlink()) {
-            steps = node.symlink.concat(steps.slice(i2 + 1));
+            steps2 = node.symlink.concat(steps2.slice(i2 + 1));
             link = this.root;
             i2 = 0;
             continue;
@@ -21621,16 +21621,16 @@ var require_volume = __commonJS({
           throw createError(ENOTDIR, funcName, filename);
         return link;
       };
-      Volume2.prototype.getLinkParent = function(steps) {
-        return this.root.walk(steps, steps.length - 1);
+      Volume2.prototype.getLinkParent = function(steps2) {
+        return this.root.walk(steps2, steps2.length - 1);
       };
       Volume2.prototype.getLinkParentAsDirOrThrow = function(filenameOrSteps, funcName) {
-        var steps = filenameOrSteps instanceof Array ? filenameOrSteps : filenameToSteps(filenameOrSteps);
-        var link = this.getLinkParent(steps);
+        var steps2 = filenameOrSteps instanceof Array ? filenameOrSteps : filenameToSteps(filenameOrSteps);
+        var link = this.getLinkParent(steps2);
         if (!link)
-          throw createError(ENOENT, funcName, sep2 + steps.join(sep2));
+          throw createError(ENOENT, funcName, sep2 + steps2.join(sep2));
         if (!link.getNode().isDirectory())
-          throw createError(ENOTDIR, funcName, sep2 + steps.join(sep2));
+          throw createError(ENOTDIR, funcName, sep2 + steps2.join(sep2));
         return link;
       };
       Volume2.prototype.getFileByFd = function(fd) {
@@ -21796,16 +21796,16 @@ var require_volume = __commonJS({
         if (resolveSymlinks === void 0) {
           resolveSymlinks = true;
         }
-        var steps = filenameToSteps(filename);
-        var link = resolveSymlinks ? this.getResolvedLink(steps) : this.getLink(steps);
+        var steps2 = filenameToSteps(filename);
+        var link = resolveSymlinks ? this.getResolvedLink(steps2) : this.getLink(steps2);
         if (link && flagsNum & O_EXCL)
           throw createError(EEXIST, "open", filename);
         if (!link && flagsNum & O_CREAT) {
-          var dirLink = this.getResolvedLink(steps.slice(0, steps.length - 1));
+          var dirLink = this.getResolvedLink(steps2.slice(0, steps2.length - 1));
           if (!dirLink)
-            throw createError(ENOENT, "open", sep2 + steps.join(sep2));
+            throw createError(ENOENT, "open", sep2 + steps2.join(sep2));
           if (flagsNum & O_CREAT && typeof modeNum === "number") {
-            link = this.createLink(dirLink, steps[steps.length - 1], false, modeNum);
+            link = this.createLink(dirLink, steps2[steps2.length - 1], false, modeNum);
           }
         }
         if (link)
@@ -21904,8 +21904,8 @@ var require_volume = __commonJS({
           fd = id;
         else {
           var filename = pathToFilename(id);
-          var steps = filenameToSteps(filename);
-          var link = this.getResolvedLink(steps);
+          var steps2 = filenameToSteps(filename);
+          var link = this.getResolvedLink(steps2);
           if (link) {
             var node = link.getNode();
             if (node.isDirectory())
@@ -22128,8 +22128,8 @@ var require_volume = __commonJS({
         this.wrapAsync(this.linkBase, [existingPathFilename, newPathFilename], callback);
       };
       Volume2.prototype.unlinkBase = function(filename) {
-        var steps = filenameToSteps(filename);
-        var link = this.getLink(steps);
+        var steps2 = filenameToSteps(filename);
+        var link = this.getLink(steps2);
         if (!link)
           throw createError(ENOENT, "unlink", filename);
         if (link.length)
@@ -22173,8 +22173,8 @@ var require_volume = __commonJS({
         this.wrapAsync(this.symlinkBase, [targetFilename, pathFilename], callback);
       };
       Volume2.prototype.realpathBase = function(filename, encoding) {
-        var steps = filenameToSteps(filename);
-        var realLink = this.getResolvedLink(steps);
+        var steps2 = filenameToSteps(filename);
+        var realLink = this.getResolvedLink(steps2);
         if (!realLink)
           throw createError(ENOENT, "realpath", filename);
         return (0, encoding_1.strToEncoding)(realLink.getPath() || "/", encoding);
@@ -22340,8 +22340,8 @@ var require_volume = __commonJS({
         this.writeFile(id, data, opts, callback);
       };
       Volume2.prototype.readdirBase = function(filename, options) {
-        var steps = filenameToSteps(filename);
-        var link = this.getResolvedLink(steps);
+        var steps2 = filenameToSteps(filename);
+        var link = this.getResolvedLink(steps2);
         if (!link)
           throw createError(ENOENT, "readdir", filename);
         var node = link.getNode();
@@ -22479,12 +22479,12 @@ var require_volume = __commonJS({
         this.wrapAsync(this.utimesBase, [pathToFilename(path2), toUnixTimestamp(atime), toUnixTimestamp(mtime)], callback);
       };
       Volume2.prototype.mkdirBase = function(filename, modeNum) {
-        var steps = filenameToSteps(filename);
-        if (!steps.length) {
+        var steps2 = filenameToSteps(filename);
+        if (!steps2.length) {
           throw createError(EEXIST, "mkdir", filename);
         }
         var dir = this.getLinkParentAsDirOrThrow(filename, "mkdir");
-        var name = steps[steps.length - 1];
+        var name = steps2[steps2.length - 1];
         if (dir.getChild(name))
           throw createError(EEXIST, "mkdir", filename);
         dir.createChild(name, this.createNode(true, modeNum));
@@ -22492,11 +22492,11 @@ var require_volume = __commonJS({
       Volume2.prototype.mkdirpBase = function(filename, modeNum) {
         var fullPath = resolve2(filename);
         var fullPathSansSlash = fullPath.substring(1);
-        var steps = !fullPathSansSlash ? [] : fullPathSansSlash.split(sep2);
+        var steps2 = !fullPathSansSlash ? [] : fullPathSansSlash.split(sep2);
         var link = this.root;
         var created = false;
-        for (var i2 = 0; i2 < steps.length; i2++) {
-          var step = steps[i2];
+        for (var i2 = 0; i2 < steps2.length; i2++) {
+          var step = steps2[i2];
           if (!link.getNode().isDirectory())
             throw createError(ENOTDIR, "mkdir", link.getPath());
           var child = link.getChild(step);
@@ -23243,7 +23243,7 @@ var require_ponyfill_es2018 = __commonJS({
     })(exports, function(exports2) {
       "use strict";
       const SymbolPolyfill = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? Symbol : (description) => `Symbol(${description})`;
-      function noop2() {
+      function noop3() {
         return void 0;
       }
       function getGlobals() {
@@ -23260,7 +23260,7 @@ var require_ponyfill_es2018 = __commonJS({
       function typeIsObject(x2) {
         return typeof x2 === "object" && x2 !== null || typeof x2 === "function";
       }
-      const rethrowAssertionErrorRejection = noop2;
+      const rethrowAssertionErrorRejection = noop3;
       const originalPromise = Promise;
       const originalPromiseThen = Promise.prototype.then;
       const originalPromiseResolve = Promise.resolve.bind(originalPromise);
@@ -25469,7 +25469,7 @@ var require_ponyfill_es2018 = __commonJS({
               return newPromise((resolveRead, rejectRead) => {
                 ReadableStreamDefaultReaderRead(reader, {
                   _chunkSteps: (chunk) => {
-                    currentWrite = PerformPromiseThen(WritableStreamDefaultWriterWrite(writer, chunk), void 0, noop2);
+                    currentWrite = PerformPromiseThen(WritableStreamDefaultWriterWrite(writer, chunk), void 0, noop3);
                     resolveRead(false);
                   },
                   _closeSteps: () => resolveRead(true),
@@ -26364,7 +26364,7 @@ var require_ponyfill_es2018 = __commonJS({
           reader._readIntoRequests = new SimpleQueue();
         }
         const sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);
-        return transformPromiseWith(sourceCancelPromise, noop2);
+        return transformPromiseWith(sourceCancelPromise, noop3);
       }
       function ReadableStreamClose(stream) {
         stream._state = "closed";
@@ -26848,9 +26848,9 @@ var require_streams = __commonJS({
       }
     }
     try {
-      const { Blob: Blob3 } = require("buffer");
-      if (Blob3 && !Blob3.prototype.stream) {
-        Blob3.prototype.stream = function name(params) {
+      const { Blob: Blob4 } = require("buffer");
+      if (Blob4 && !Blob4.prototype.stream) {
+        Blob4.prototype.stream = function name(params) {
           let position = 0;
           const blob = this;
           return new ReadableStream({
@@ -26901,12 +26901,12 @@ async function* toIterator(parts, clone2 = true) {
     }
   }
 }
-var import_streams, POOL_SIZE, _Blob, Blob2, fetch_blob_default;
+var import_streams, POOL_SIZE, _Blob, Blob3, fetch_blob_default;
 var init_fetch_blob = __esm({
   "../../node_modules/.pnpm/fetch-blob@3.2.0/node_modules/fetch-blob/index.js"() {
     import_streams = __toESM(require_streams(), 1);
     POOL_SIZE = 65536;
-    _Blob = class Blob {
+    _Blob = class Blob2 {
       #parts = [];
       #type = "";
       #size = 0;
@@ -26930,7 +26930,7 @@ var init_fetch_blob = __esm({
             part = new Uint8Array(element.buffer.slice(element.byteOffset, element.byteOffset + element.byteLength));
           } else if (element instanceof ArrayBuffer) {
             part = new Uint8Array(element.slice(0));
-          } else if (element instanceof Blob) {
+          } else if (element instanceof Blob2) {
             part = element;
           } else {
             part = encoder.encode(`${element}`);
@@ -27009,7 +27009,7 @@ var init_fetch_blob = __esm({
             relativeStart = 0;
           }
         }
-        const blob = new Blob([], { type: String(type).toLowerCase() });
+        const blob = new Blob2([], { type: String(type).toLowerCase() });
         blob.#size = span;
         blob.#parts = blobParts;
         return blob;
@@ -27026,17 +27026,17 @@ var init_fetch_blob = __esm({
       type: { enumerable: true },
       slice: { enumerable: true }
     });
-    Blob2 = _Blob;
-    fetch_blob_default = Blob2;
+    Blob3 = _Blob;
+    fetch_blob_default = Blob3;
   }
 });
 
 // ../../node_modules/.pnpm/fetch-blob@3.2.0/node_modules/fetch-blob/file.js
-var _File, File2, file_default;
+var _File, File3, file_default;
 var init_file = __esm({
   "../../node_modules/.pnpm/fetch-blob@3.2.0/node_modules/fetch-blob/file.js"() {
     init_fetch_blob();
-    _File = class File extends fetch_blob_default {
+    _File = class File2 extends fetch_blob_default {
       #lastModified = 0;
       #name = "";
       constructor(fileBits, fileName, options = {}) {
@@ -27065,8 +27065,8 @@ var init_file = __esm({
         return !!object && object instanceof fetch_blob_default && /^(File)$/.test(object[Symbol.toStringTag]);
       }
     };
-    File2 = _File;
-    file_default = File2;
+    File3 = _File;
+    file_default = File3;
   }
 });
 
@@ -27084,7 +27084,7 @@ Content-Type: ${v.type || "application/octet-stream"}\r
   c.push(`--${b}--`);
   return new B(c, { type: "multipart/form-data; boundary=" + b });
 }
-var t, i, h, r, m, f, e, x, FormData;
+var t, i, h, r, m, f, e, x, FormData2;
 var init_esm_min = __esm({
   "../../node_modules/.pnpm/formdata-polyfill@4.0.10/node_modules/formdata-polyfill/esm.min.js"() {
     init_fetch_blob();
@@ -27099,7 +27099,7 @@ var init_esm_min = __esm({
         throw new TypeError(`Failed to execute '${n}' on 'FormData': ${e2} arguments required, but only ${a.length} present.`);
       }
     };
-    FormData = class FormData2 {
+    FormData2 = class FormData3 {
       #d = [];
       constructor(...a) {
         if (a.length)
@@ -27265,7 +27265,7 @@ async function toFormData(Body2, ct) {
   let contentType;
   let filename;
   const entryChunks = [];
-  const formData = new FormData();
+  const formData = new FormData2();
   const onPartData = (ui8a) => {
     entryValue += decoder.decode(ui8a, { stream: true });
   };
@@ -27323,7 +27323,7 @@ async function toFormData(Body2, ct) {
   parser.end();
   return formData;
 }
-var s, S, f2, F, LF, CR, SPACE, HYPHEN, COLON, A, Z, lower, noop, MultipartParser;
+var s, S, f2, F, LF, CR, SPACE, HYPHEN, COLON, A, Z, lower, noop2, MultipartParser;
 var init_multipart_parser = __esm({
   "../../node_modules/.pnpm/node-fetch@3.3.0/node_modules/node-fetch/src/utils/multipart-parser.js"() {
     init_from();
@@ -27354,19 +27354,19 @@ var init_multipart_parser = __esm({
     A = 97;
     Z = 122;
     lower = (c) => c | 32;
-    noop = () => {
+    noop2 = () => {
     };
     MultipartParser = class {
       constructor(boundary) {
         this.index = 0;
         this.flags = 0;
-        this.onHeaderEnd = noop;
-        this.onHeaderField = noop;
-        this.onHeadersEnd = noop;
-        this.onHeaderValue = noop;
-        this.onPartBegin = noop;
-        this.onPartData = noop;
-        this.onPartEnd = noop;
+        this.onHeaderEnd = noop2;
+        this.onHeaderField = noop2;
+        this.onHeadersEnd = noop2;
+        this.onHeaderValue = noop2;
+        this.onPartBegin = noop2;
+        this.onPartData = noop2;
+        this.onPartEnd = noop2;
         this.boundaryChars = {};
         boundary = "\r\n--" + boundary;
         const ui8a = new Uint8Array(boundary.length);
@@ -37679,11 +37679,11 @@ var require_lib3 = __commonJS({
         return this.parseV8Intrinsic() || super.parseExprAtom(refExpressionErrors);
       }
     };
-    function hasPlugin(plugins, expectedConfig) {
+    function hasPlugin(plugins2, expectedConfig) {
       const [expectedName, expectedOptions] = typeof expectedConfig === "string" ? [expectedConfig, {}] : expectedConfig;
       const expectedKeys = Object.keys(expectedOptions);
       const expectedOptionsIsEmpty = expectedKeys.length === 0;
-      return plugins.some((p) => {
+      return plugins2.some((p) => {
         if (typeof p === "string") {
           return expectedOptionsIsEmpty && p === expectedName;
         } else {
@@ -37700,8 +37700,8 @@ var require_lib3 = __commonJS({
         }
       });
     }
-    function getPluginOption(plugins, name, option) {
-      const plugin2 = plugins.find((plugin3) => {
+    function getPluginOption(plugins2, name, option) {
+      const plugin2 = plugins2.find((plugin3) => {
         if (Array.isArray(plugin3)) {
           return plugin3[0] === name;
         } else {
@@ -37716,43 +37716,43 @@ var require_lib3 = __commonJS({
     var PIPELINE_PROPOSALS = ["minimal", "fsharp", "hack", "smart"];
     var TOPIC_TOKENS = ["^^", "@@", "^", "%", "#"];
     var RECORD_AND_TUPLE_SYNTAX_TYPES = ["hash", "bar"];
-    function validatePlugins(plugins) {
-      if (hasPlugin(plugins, "decorators")) {
-        if (hasPlugin(plugins, "decorators-legacy")) {
+    function validatePlugins(plugins2) {
+      if (hasPlugin(plugins2, "decorators")) {
+        if (hasPlugin(plugins2, "decorators-legacy")) {
           throw new Error("Cannot use the decorators and decorators-legacy plugin together");
         }
-        const decoratorsBeforeExport = getPluginOption(plugins, "decorators", "decoratorsBeforeExport");
+        const decoratorsBeforeExport = getPluginOption(plugins2, "decorators", "decoratorsBeforeExport");
         if (decoratorsBeforeExport != null && typeof decoratorsBeforeExport !== "boolean") {
           throw new Error("'decoratorsBeforeExport' must be a boolean.");
         }
-        const allowCallParenthesized = getPluginOption(plugins, "decorators", "allowCallParenthesized");
+        const allowCallParenthesized = getPluginOption(plugins2, "decorators", "allowCallParenthesized");
         if (allowCallParenthesized != null && typeof allowCallParenthesized !== "boolean") {
           throw new Error("'allowCallParenthesized' must be a boolean.");
         }
       }
-      if (hasPlugin(plugins, "flow") && hasPlugin(plugins, "typescript")) {
+      if (hasPlugin(plugins2, "flow") && hasPlugin(plugins2, "typescript")) {
         throw new Error("Cannot combine flow and typescript plugins.");
       }
-      if (hasPlugin(plugins, "placeholders") && hasPlugin(plugins, "v8intrinsic")) {
+      if (hasPlugin(plugins2, "placeholders") && hasPlugin(plugins2, "v8intrinsic")) {
         throw new Error("Cannot combine placeholders and v8intrinsic plugins.");
       }
-      if (hasPlugin(plugins, "pipelineOperator")) {
-        const proposal = getPluginOption(plugins, "pipelineOperator", "proposal");
+      if (hasPlugin(plugins2, "pipelineOperator")) {
+        const proposal = getPluginOption(plugins2, "pipelineOperator", "proposal");
         if (!PIPELINE_PROPOSALS.includes(proposal)) {
           const proposalList = PIPELINE_PROPOSALS.map((p) => `"${p}"`).join(", ");
           throw new Error(`"pipelineOperator" requires "proposal" option whose value must be one of: ${proposalList}.`);
         }
-        const tupleSyntaxIsHash = hasPlugin(plugins, ["recordAndTuple", {
+        const tupleSyntaxIsHash = hasPlugin(plugins2, ["recordAndTuple", {
           syntaxType: "hash"
         }]);
         if (proposal === "hack") {
-          if (hasPlugin(plugins, "placeholders")) {
+          if (hasPlugin(plugins2, "placeholders")) {
             throw new Error("Cannot combine placeholders plugin and Hack-style pipes.");
           }
-          if (hasPlugin(plugins, "v8intrinsic")) {
+          if (hasPlugin(plugins2, "v8intrinsic")) {
             throw new Error("Cannot combine v8intrinsic plugin and Hack-style pipes.");
           }
-          const topicToken = getPluginOption(plugins, "pipelineOperator", "topicToken");
+          const topicToken = getPluginOption(plugins2, "pipelineOperator", "topicToken");
           if (!TOPIC_TOKENS.includes(topicToken)) {
             const tokenList = TOPIC_TOKENS.map((t2) => `"${t2}"`).join(", ");
             throw new Error(`"pipelineOperator" in "proposal": "hack" mode also requires a "topicToken" option whose value must be one of: ${tokenList}.`);
@@ -37764,21 +37764,21 @@ var require_lib3 = __commonJS({
           throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "smart" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.');
         }
       }
-      if (hasPlugin(plugins, "moduleAttributes")) {
+      if (hasPlugin(plugins2, "moduleAttributes")) {
         {
-          if (hasPlugin(plugins, "importAssertions")) {
+          if (hasPlugin(plugins2, "importAssertions")) {
             throw new Error("Cannot combine importAssertions and moduleAttributes plugins.");
           }
-          const moduleAttributesVersionPluginOption = getPluginOption(plugins, "moduleAttributes", "version");
+          const moduleAttributesVersionPluginOption = getPluginOption(plugins2, "moduleAttributes", "version");
           if (moduleAttributesVersionPluginOption !== "may-2020") {
             throw new Error("The 'moduleAttributes' plugin requires a 'version' option, representing the last proposal update. Currently, the only supported value is 'may-2020'.");
           }
         }
       }
-      if (hasPlugin(plugins, "recordAndTuple") && getPluginOption(plugins, "recordAndTuple", "syntaxType") != null && !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(getPluginOption(plugins, "recordAndTuple", "syntaxType"))) {
+      if (hasPlugin(plugins2, "recordAndTuple") && getPluginOption(plugins2, "recordAndTuple", "syntaxType") != null && !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(getPluginOption(plugins2, "recordAndTuple", "syntaxType"))) {
         throw new Error("The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.map((p) => `'${p}'`).join(", "));
       }
-      if (hasPlugin(plugins, "asyncDoExpressions") && !hasPlugin(plugins, "doExpressions")) {
+      if (hasPlugin(plugins2, "asyncDoExpressions") && !hasPlugin(plugins2, "doExpressions")) {
         const error = new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.");
         error.missingPlugins = "doExpressions";
         throw error;
@@ -42037,9 +42037,9 @@ var require_lib3 = __commonJS({
         return file;
       }
     };
-    function pluginsMap(plugins) {
+    function pluginsMap(plugins2) {
       const pluginMap = /* @__PURE__ */ new Map();
-      for (const plugin2 of plugins) {
+      for (const plugin2 of plugins2) {
         const [name, options] = Array.isArray(plugin2) ? plugin2 : [plugin2, {}];
         if (!pluginMap.has(name))
           pluginMap.set(name, options || {});
@@ -44710,10 +44710,10 @@ var require_fork = __commonJS({
     var path_1 = tslib_1.__importDefault(require_path2());
     var node_path_1 = tslib_1.__importDefault(require_node_path());
     var shared_1 = require_shared();
-    function default_1(plugins) {
+    function default_1(plugins2) {
       var fork = createFork();
       var types4 = fork.use(types_1.default);
-      plugins.forEach(fork.use);
+      plugins2.forEach(fork.use);
       types4.finalize();
       var PathVisitor = fork.use(path_visitor_1.default);
       return {
@@ -58398,17 +58398,21 @@ __export(lib_exports, {
   CompiledSubscriptionKind: () => CompiledSubscriptionKind,
   Config: () => Config,
   DataSource: () => DataSource,
+  DocumentStore: () => DocumentStore,
+  HoudiniClient: () => HoudiniClient,
   HoudiniError: () => HoudiniError,
   LogLevel: () => LogLevel,
   RefetchUpdateMode: () => RefetchUpdateMode,
   TypeWrapper: () => TypeWrapper,
   cleanupFiles: () => cleanupFiles,
   computeID: () => computeID,
+  createPluginHooks: () => createPluginHooks,
   deepMerge: () => deepMerge,
   defaultConfigValues: () => defaultConfigValues,
   definitionFromAncestors: () => definitionFromAncestors,
   ensureArtifactImport: () => ensureArtifactImport,
   ensureImports: () => ensureImports,
+  fetch: () => fetch2,
   find_graphql: () => find_graphql,
   formatErrors: () => formatErrors,
   fs: () => fs_exports,
@@ -58419,6 +58423,7 @@ __export(lib_exports, {
   hashDocument: () => hashDocument,
   houdini_mode: () => houdini_mode,
   keyFieldsForType: () => keyFieldsForType,
+  mutation: () => mutation,
   operation_requires_variables: () => operation_requires_variables,
   orderedPlugins: () => orderedPlugins,
   parentTypeFromAncestors: () => parentTypeFromAncestors,
@@ -58427,10 +58432,12 @@ __export(lib_exports, {
   path: () => path_exports,
   plugin: () => plugin,
   pullSchema: () => pullSchema,
+  query: () => query,
   readConfigFile: () => readConfigFile,
   runPipeline: () => runPipeline,
   setMockConfig: () => setMockConfig,
   siteURL: () => siteURL,
+  subscription: () => subscription,
   unwrapType: () => unwrapType,
   wrapType: () => wrapType
 });
@@ -61567,6 +61574,10 @@ var import_node_url2 = require("node:url");
 // src/runtime/imports/config.ts
 var config_default = {};
 
+// src/runtime/imports/pluginConfig.ts
+var configs = [];
+var pluginConfig_default = configs;
+
 // src/runtime/lib/config.ts
 var mockConfig = null;
 function getMockConfig() {
@@ -61602,45 +61613,284 @@ function computeID(configFile, type, data) {
   }
   return id.slice(0, -2);
 }
+var _configFile = null;
 function getCurrentConfig() {
   const mockConfig2 = getMockConfig();
   if (mockConfig2) {
     return mockConfig2;
   }
-  return defaultConfigValues(config_default);
+  if (_configFile) {
+    return _configFile;
+  }
+  let configFile = defaultConfigValues(config_default);
+  for (const pluginConfig of pluginConfig_default) {
+    configFile = pluginConfig(configFile);
+  }
+  _configFile = configFile;
+  return configFile;
+}
+
+// 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 i2 = 0; i2 < keysA.length; i2++) {
+    if (!Reflect.has(objB, keysA[i2]) || !deepEquals(objA[keysA[i2]], objB[keysA[i2]], map)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/runtime/lib/selection.ts
+function getFieldsForType(selection, __typename) {
+  let targetSelection = selection.fields || {};
+  if (selection.abstractFields && __typename) {
+    const mappedType = selection.abstractFields.typeMap[__typename];
+    if (mappedType) {
+      targetSelection = selection.abstractFields.fields[mappedType];
+    } else if (selection.abstractFields.fields[__typename]) {
+      targetSelection = selection.abstractFields.fields[__typename];
+    }
+  }
+  return targetSelection;
+}
+
+// src/runtime/lib/scalars.ts
+async function marshalSelection({
+  selection,
+  data
+}) {
+  const config = getCurrentConfig();
+  if (data === null || typeof data === "undefined") {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return await Promise.all(data.map((val) => marshalSelection({ selection, data: val })));
+  }
+  const targetSelection = getFieldsForType(selection, data["__typename"]);
+  return Object.fromEntries(
+    await Promise.all(
+      Object.entries(data).map(async ([fieldName, value]) => {
+        const { type, selection: selection2 } = targetSelection[fieldName];
+        if (!type) {
+          return [fieldName, value];
+        }
+        if (selection2) {
+          return [fieldName, await marshalSelection({ selection: selection2, data: value })];
+        }
+        if (config.scalars?.[type]) {
+          const marshalFn = config.scalars[type].marshal;
+          if (!marshalFn) {
+            throw new Error(
+              `scalar type ${type} is missing a \`marshal\` function. see https://github.com/AlecAivazis/houdini#%EF%B8%8Fcustom-scalars`
+            );
+          }
+          if (Array.isArray(value)) {
+            return [fieldName, value.map(marshalFn)];
+          }
+          return [fieldName, marshalFn(value)];
+        }
+        return [fieldName, value];
+      })
+    )
+  );
+}
+function marshalInputs({
+  artifact,
+  input,
+  config,
+  rootType = "@root"
+}) {
+  if (input === null || typeof input === "undefined") {
+    return input;
+  }
+  if (!artifact.input) {
+    return input;
+  }
+  const fields = rootType === "@root" ? artifact.input.fields : artifact.input.types[rootType];
+  if (Array.isArray(input)) {
+    return input.map((val) => marshalInputs({ artifact, input: val, rootType, config }));
+  }
+  return Object.fromEntries(
+    Object.entries(input).map(([fieldName, value]) => {
+      const type = fields?.[fieldName];
+      if (!type) {
+        return [fieldName, value];
+      }
+      const marshalFn = config.scalars?.[type]?.marshal;
+      if (marshalFn) {
+        if (Array.isArray(value)) {
+          return [fieldName, value.map(marshalFn)];
+        }
+        return [fieldName, marshalFn(value)];
+      }
+      if (isScalar(config, type) || !artifact.input.types[type]) {
+        return [fieldName, value];
+      }
+      return [fieldName, marshalInputs({ artifact, input: value, rootType: type, config })];
+    })
+  );
+}
+function unmarshalSelection(config, selection, data) {
+  if (data === null || typeof data === "undefined") {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.map((val) => unmarshalSelection(config, selection, val));
+  }
+  const targetSelection = getFieldsForType(selection, data["__typename"]);
+  return Object.fromEntries(
+    Object.entries(data).map(([fieldName, value]) => {
+      const { type, selection: selection2 } = targetSelection[fieldName];
+      if (!type) {
+        return [fieldName, value];
+      }
+      if (selection2) {
+        return [
+          fieldName,
+          unmarshalSelection(config, selection2, value)
+        ];
+      }
+      if (value === null) {
+        return [fieldName, value];
+      }
+      if (config.scalars?.[type]?.marshal) {
+        const unmarshalFn = config.scalars[type]?.unmarshal;
+        if (!unmarshalFn) {
+          throw new Error(
+            `scalar type ${type} is missing an \`unmarshal\` function. see https://github.com/AlecAivazis/houdini#%EF%B8%8Fcustom-scalars`
+          );
+        }
+        if (Array.isArray(value)) {
+          return [fieldName, value.map(unmarshalFn)];
+        }
+        return [fieldName, unmarshalFn(value)];
+      }
+      return [fieldName, value];
+    })
+  );
+}
+function isScalar(config, type) {
+  return ["String", "Boolean", "Float", "ID", "Int"].concat(Object.keys(config.scalars || {})).includes(type);
 }
 
 // src/runtime/lib/types.ts
-var CachePolicy = /* @__PURE__ */ ((CachePolicy2) => {
-  CachePolicy2["CacheOrNetwork"] = "CacheOrNetwork";
-  CachePolicy2["CacheOnly"] = "CacheOnly";
-  CachePolicy2["NetworkOnly"] = "NetworkOnly";
-  CachePolicy2["CacheAndNetwork"] = "CacheAndNetwork";
-  return CachePolicy2;
-})(CachePolicy || {});
-var ArtifactKind = /* @__PURE__ */ ((ArtifactKind2) => {
-  ArtifactKind2["Query"] = "HoudiniQuery";
-  ArtifactKind2["Subscription"] = "HoudiniSubscription";
-  ArtifactKind2["Mutation"] = "HoudiniMutation";
-  ArtifactKind2["Fragment"] = "HoudiniFragment";
-  return ArtifactKind2;
-})(ArtifactKind || {});
-var CompiledFragmentKind = "HoudiniFragment" /* Fragment */;
-var CompiledMutationKind = "HoudiniMutation" /* Mutation */;
-var CompiledQueryKind = "HoudiniQuery" /* Query */;
-var CompiledSubscriptionKind = "HoudiniSubscription" /* Subscription */;
-var RefetchUpdateMode = /* @__PURE__ */ ((RefetchUpdateMode2) => {
-  RefetchUpdateMode2["append"] = "append";
-  RefetchUpdateMode2["prepend"] = "prepend";
-  RefetchUpdateMode2["replace"] = "replace";
-  return RefetchUpdateMode2;
-})(RefetchUpdateMode || {});
-var DataSource = /* @__PURE__ */ ((DataSource2) => {
-  DataSource2["Cache"] = "cache";
-  DataSource2["Network"] = "network";
-  DataSource2["Ssr"] = "ssr";
-  return DataSource2;
-})(DataSource || {});
+var CachePolicy = {
+  CacheOrNetwork: "CacheOrNetwork",
+  CacheOnly: "CacheOnly",
+  NetworkOnly: "NetworkOnly",
+  CacheAndNetwork: "CacheAndNetwork"
+};
+var ArtifactKind = {
+  Query: "HoudiniQuery",
+  Subscription: "HoudiniSubscription",
+  Mutation: "HoudiniMutation",
+  Fragment: "HoudiniFragment"
+};
+var CompiledFragmentKind = ArtifactKind.Fragment;
+var CompiledMutationKind = ArtifactKind.Mutation;
+var CompiledQueryKind = ArtifactKind.Query;
+var CompiledSubscriptionKind = ArtifactKind.Subscription;
+var RefetchUpdateMode = {
+  append: "append",
+  prepend: "prepend",
+  replace: "replace"
+};
+var DataSource = {
+  Cache: "cache",
+  Network: "network",
+  Ssr: "ssr"
+};
+
+// src/runtime/lib/store.ts
+var subscriber_queue = [];
+var noop = () => {
+};
+var Writable = class {
+  state;
+  #subscribers;
+  #stop;
+  #start;
+  constructor(value, start = noop) {
+    this.state = value;
+    this.#subscribers = /* @__PURE__ */ new Set();
+    this.#stop = null;
+    this.#start = start;
+  }
+  set(new_value) {
+    if (safe_not_equal(this.state, new_value)) {
+      this.state = new_value;
+      if (this.#stop) {
+        const run_queue = !subscriber_queue.length;
+        for (const subscriber of this.#subscribers) {
+          subscriber[1]();
+          subscriber_queue.push(subscriber, this.state);
+        }
+        if (run_queue) {
+          for (let i2 = 0; i2 < subscriber_queue.length; i2 += 2) {
+            subscriber_queue[i2][0](subscriber_queue[i2 + 1]);
+          }
+          subscriber_queue.length = 0;
+        }
+      }
+    }
+  }
+  update(fn) {
+    this.set(fn(this.state));
+  }
+  subscribe(run, invalidate = noop) {
+    const subscriber = [run, invalidate];
+    this.#subscribers.add(subscriber);
+    if (this.#subscribers.size === 1) {
+      this.#stop = this.#start(this.set) || noop;
+    }
+    run(this.state);
+    return () => {
+      this.#subscribers.delete(subscriber);
+      if (this.#subscribers.size === 0) {
+        this.#stop?.();
+        this.#stop = null;
+      }
+    };
+  }
+};
+function safe_not_equal(a, b) {
+  return a != a ? b == b : a !== b || a && typeof a === "object" || typeof a === "function";
+}
+
+// src/runtime/lib/key.ts
+var computeKey = ({ field, args }) => {
+  const keys = Object.keys(args ?? {});
+  keys.sort();
+  return args && keys.length > 0 ? `${field}(${keys.map((key) => `${key}: ${stringifyObjectWithNoQuotesOnKeys(args[key])}`).join(", ")})` : field;
+};
+var stringifyObjectWithNoQuotesOnKeys = (obj_from_json) => {
+  if (Array.isArray(obj_from_json)) {
+    return `[${obj_from_json.map((obj) => `${stringifyObjectWithNoQuotesOnKeys(obj)}`).join(", ")}]`;
+  }
+  if (typeof obj_from_json !== "object" || obj_from_json instanceof Date || obj_from_json === null) {
+    return JSON.stringify(obj_from_json).replace(/"([^"]+)":/g, "$1: ");
+  }
+  return `{${Object.keys(obj_from_json).map((key) => `${key}: ${stringifyObjectWithNoQuotesOnKeys(obj_from_json[key])}`).join(", ")}}`;
+};
 
 // src/lib/constants.ts
 var siteURL = "https://houdinigraphql.com";
@@ -62086,7 +62336,7 @@ var Body = class {
     } else if (ArrayBuffer.isView(body)) {
       body = import_node_buffer.Buffer.from(body.buffer, body.byteOffset, body.byteLength);
     } else if (body instanceof import_node_stream.default) {
-    } else if (body instanceof FormData) {
+    } else if (body instanceof FormData2) {
       body = formDataToBlob(body);
       boundary = body.type.split("=")[1];
     } else {
@@ -62126,7 +62376,7 @@ var Body = class {
   async formData() {
     const ct = this.headers.get("content-type");
     if (ct.startsWith("application/x-www-form-urlencoded")) {
-      const formData = new FormData();
+      const formData = new FormData2();
       const parameters = new URLSearchParams(await this.text());
       for (const [name, value] of parameters) {
         formData.append(name, value);
@@ -62252,7 +62502,7 @@ var extractContentType = (body, request) => {
   if (import_node_buffer.Buffer.isBuffer(body) || import_node_util2.types.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
     return null;
   }
-  if (body instanceof FormData) {
+  if (body instanceof FormData2) {
     return `multipart/form-data; boundary=${request[INTERNALS].boundary}`;
   }
   if (body && typeof body.getBoundary === "function") {
@@ -63219,14 +63469,2735 @@ function plugin(name, hooks) {
   return data;
 }
 
+// src/runtime/lib/flatten.ts
+function flatten(source) {
+  if (!source) {
+    return [];
+  }
+  return source.reduce((acc, element) => {
+    if (!element) {
+      return acc;
+    }
+    if (Array.isArray(element)) {
+      return acc.concat(flatten(element));
+    }
+    return acc.concat(element);
+  }, []);
+}
+
+// src/runtime/client/plugins/fetch.ts
+var fetch2 = (target) => {
+  return () => {
+    return {
+      async network(ctx, { client, resolve: resolve2, marshalVariables: marshalVariables2 }) {
+        const fetch3 = ctx.fetch ?? globalThis.fetch;
+        const fetchParams2 = {
+          text: ctx.text,
+          hash: ctx.hash,
+          variables: marshalVariables2(ctx)
+        };
+        let fetchFn = defaultFetch(client.url, ctx.fetchParams);
+        if (target) {
+          if (typeof target === "string") {
+            fetchFn = defaultFetch(target, ctx.fetchParams);
+          } else {
+            fetchFn = target;
+          }
+        }
+        const result = await fetchFn({
+          fetch: (url, args) => {
+            const newArgs = handleMultipart(fetchParams2, args) ?? args;
+            return fetch3(url, newArgs);
+          },
+          metadata: ctx.metadata,
+          session: ctx.session || {},
+          ...fetchParams2
+        });
+        resolve2(ctx, {
+          fetching: false,
+          variables: ctx.variables ?? {},
+          data: result.data,
+          errors: !result.errors || result.errors.length === 0 ? null : result.errors,
+          partial: false,
+          stale: false,
+          source: DataSource.Network
+        });
+      }
+    };
+  };
+};
+var defaultFetch = (url, params) => {
+  if (!url) {
+    throw new Error(
+      "Could not find configured client url. Please specify one in your HoudiniClient constructor."
+    );
+  }
+  return async ({ fetch: fetch3, text, variables }) => {
+    const result = await fetch3(url, {
+      method: "POST",
+      body: JSON.stringify({ query: text, variables }),
+      ...params,
+      headers: {
+        Accept: "application/graphql+json, application/json",
+        "Content-Type": "application/json",
+        ...params?.headers
+      }
+    });
+    return await result.json();
+  };
+};
+function handleMultipart(params, args) {
+  const { clone: clone2, files } = extractFiles({
+    query: params.text,
+    variables: params.variables
+  });
+  if (files.size) {
+    const req = args;
+    let headers = {};
+    if (req?.headers) {
+      const filtered = Object.entries(req?.headers).filter(([key, value]) => {
+        return !(key.toLowerCase() == "content-type" && value.toLowerCase() == "application/json");
+      });
+      headers = Object.fromEntries(filtered);
+    }
+    const form = new FormData();
+    const operationJSON = JSON.stringify(clone2);
+    form.set("operations", operationJSON);
+    const map = {};
+    let i2 = 0;
+    files.forEach((paths) => {
+      map[++i2] = paths;
+    });
+    form.set("map", JSON.stringify(map));
+    i2 = 0;
+    files.forEach((paths, file) => {
+      form.set(`${++i2}`, file, file.name);
+    });
+    return { ...req, headers, body: form };
+  }
+}
+function isExtractableFile(value) {
+  return typeof File !== "undefined" && value instanceof File || typeof Blob !== "undefined" && value instanceof Blob;
+}
+function extractFiles(value) {
+  if (!arguments.length)
+    throw new TypeError("Argument 1 `value` is required.");
+  const clones = /* @__PURE__ */ new Map();
+  const files = /* @__PURE__ */ new Map();
+  function recurse(value2, path2, recursed) {
+    if (isExtractableFile(value2)) {
+      const filePaths = files.get(value2);
+      filePaths ? filePaths.push(path2) : files.set(value2, [path2]);
+      return null;
+    }
+    const valueIsList = Array.isArray(value2) || typeof FileList !== "undefined" && value2 instanceof FileList;
+    const valueIsPlainObject = isPlainObject(value2);
+    if (valueIsList || valueIsPlainObject) {
+      let clone2 = clones.get(value2);
+      const uncloned = !clone2;
+      if (uncloned) {
+        clone2 = valueIsList ? [] : value2 instanceof Object ? {} : /* @__PURE__ */ Object.create(null);
+        clones.set(value2, clone2);
+      }
+      if (!recursed.has(value2)) {
+        const pathPrefix = path2 ? `${path2}.` : "";
+        const recursedDeeper = new Set(recursed).add(value2);
+        if (valueIsList) {
+          let index = 0;
+          for (const item of value2) {
+            const itemClone = recurse(item, pathPrefix + index++, recursedDeeper);
+            if (uncloned)
+              clone2.push(itemClone);
+          }
+        } else
+          for (const key in value2) {
+            const propertyClone = recurse(value2[key], pathPrefix + key, recursedDeeper);
+            if (uncloned)
+              clone2[key] = propertyClone;
+          }
+      }
+      return clone2;
+    }
+    return value2;
+  }
+  return {
+    clone: recurse(value, "", /* @__PURE__ */ new Set()),
+    files
+  };
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+
+// 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() {
+    const dt_tick = Date.now().valueOf();
+    const config_max_time = this.cache._internal_unstable.config.defaultLifetime;
+    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);
+          }
+          this.cache._internal_unstable.staleManager.delete(id, field);
+        }
+        if (config_max_time && config_max_time > 0) {
+          const dt_valueOf = this.cache.getFieldTime(id, field);
+          if (dt_valueOf && dt_tick - dt_valueOf > config_max_time) {
+            this.cache._internal_unstable.staleManager.markFieldStale(id, field);
+          }
+        }
+      }
+    }
+  }
+};
+
+// 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 name = list.name;
+    const parentID = list.recordID || this.rootID;
+    if (this.lists.get(name)?.get(parentID)?.includes(list.key)) {
+      return;
+    }
+    if (!this.lists.has(name)) {
+      this.lists.set(name, /* @__PURE__ */ new Map());
+    }
+    if (!this.lists.get(name).has(parentID)) {
+      this.lists.get(name).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,
+    recordID,
+    recordType,
+    key,
+    listType,
+    selection,
+    when,
+    filters,
+    connection,
+    manager,
+    abstract
+  }) {
+    this.recordID = recordID || rootID;
+    this.recordType = recordType;
+    this.key = key;
+    this.type = listType;
+    this.cache = manager.cache;
+    this.selection = selection;
+    this._when = when;
+    this.filters = filters;
+    this.name = name;
+    this.connection = connection;
+    this.manager = manager;
+    this.abstract = abstract;
+  }
+  when(when) {
+    return this.manager.lists.get(this.name).get(this.recordID).when(when);
+  }
+  append(selection, data, variables = {}) {
+    return this.addToList(selection, data, variables, "last");
+  }
+  prepend(selection, data, variables = {}) {
+    return this.addToList(selection, data, variables, "first");
+  }
+  addToList(selection, data, variables = {}, where) {
+    const listType = this.listType(data);
+    const dataID = this.cache._internal_unstable.id(listType, data);
+    if (!this.validateWhen() || !dataID) {
+      return;
+    }
+    let insertSelection = selection;
+    let insertData = data;
+    if (this.connection) {
+      insertSelection = {
+        fields: {
+          newEntry: {
+            keyRaw: this.key,
+            type: "Connection",
+            selection: {
+              fields: {
+                edges: {
+                  keyRaw: "edges",
+                  type: "ConnectionEdge",
+                  updates: ["append", "prepend"],
+                  selection: {
+                    fields: {
+                      node: {
+                        type: listType,
+                        keyRaw: "node",
+                        selection: {
+                          ...selection,
+                          fields: {
+                            ...selection.fields,
+                            __typename: {
+                              keyRaw: "__typename",
+                              type: "String"
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+      insertData = {
+        newEntry: {
+          edges: [{ node: { ...data, __typename: listType } }]
+        }
+      };
+    } else {
+      insertSelection = {
+        fields: {
+          newEntries: {
+            keyRaw: this.key,
+            type: listType,
+            updates: ["append", "prepend"],
+            selection: {
+              ...selection,
+              fields: {
+                ...selection.fields,
+                __typename: {
+                  keyRaw: "__typename",
+                  type: "String"
+                }
+              }
+            }
+          }
+        }
+      };
+      insertData = {
+        newEntries: [{ ...data, __typename: listType }]
+      };
+    }
+    this.cache.write({
+      selection: insertSelection,
+      data: insertData,
+      variables,
+      parent: this.recordID,
+      applyUpdates: [where === "first" ? "prepend" : "append"]
+    });
+  }
+  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 flatten(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.map((sub) => sub[0]),
+      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(selection, data, variables = {}, where) {
+    if (!this.remove(data, variables)) {
+      this.addToList(selection, data, variables, where);
+    }
+  }
+  *[Symbol.iterator]() {
+    let entries = [];
+    let value = this.cache._internal_unstable.storage.get(this.recordID, this.key).value;
+    if (!this.connection) {
+      entries = flatten(value);
+    } else {
+      entries = this.cache._internal_unstable.storage.get(value, "edges").value;
+    }
+    for (let record of entries) {
+      yield record;
+    }
+  }
+};
+var ListCollection = class {
+  lists = [];
+  constructor(lists) {
+    this.lists = lists;
+  }
+  get selection() {
+    return this.lists[0].selection;
+  }
+  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/staleManager.ts
+var StaleManager = class {
+  cache;
+  fieldsTime = /* @__PURE__ */ new Map();
+  constructor(cache) {
+    this.cache = cache;
+  }
+  #initMapId = (id) => {
+    if (!this.fieldsTime.get(id)) {
+      this.fieldsTime.set(id, /* @__PURE__ */ new Map());
+    }
+  };
+  getFieldTime(id, field) {
+    return this.fieldsTime.get(id)?.get(field);
+  }
+  setFieldTimeToNow(id, field) {
+    this.#initMapId(id);
+    this.fieldsTime.get(id)?.set(field, new Date().valueOf());
+  }
+  markFieldStale(id, field) {
+    this.#initMapId(id);
+    this.fieldsTime.get(id)?.set(field, null);
+  }
+  markAllStale() {
+    for (const [id, fieldMap] of this.fieldsTime.entries()) {
+      for (const [field] of fieldMap.entries()) {
+        this.markFieldStale(id, field);
+      }
+    }
+  }
+  markRecordStale(id) {
+    const fieldsTimeOfType = this.fieldsTime.get(id);
+    if (fieldsTimeOfType) {
+      for (const [field] of fieldsTimeOfType.entries()) {
+        this.markFieldStale(id, field);
+      }
+    }
+  }
+  markTypeStale(type) {
+    for (const [id, fieldMap] of this.fieldsTime.entries()) {
+      if (id.startsWith(`${type}:`)) {
+        for (const [field] of fieldMap.entries()) {
+          this.markFieldStale(id, field);
+        }
+      }
+    }
+  }
+  markTypeFieldStale(type, field, when) {
+    const key = computeKey({ field, args: when });
+    for (const [id, fieldMap] of this.fieldsTime.entries()) {
+      if (id.startsWith(`${type}:`)) {
+        for (const local_field of fieldMap.keys()) {
+          if (local_field === key) {
+            this.markFieldStale(id, field);
+          }
+        }
+      }
+    }
+  }
+  delete(id, field) {
+    if (this.fieldsTime.has(id)) {
+      this.fieldsTime.get(id)?.delete(field);
+      if (this.fieldsTime.get(id)?.size === 0) {
+        this.fieldsTime.delete(id);
+      }
+    }
+  }
+};
+
+// 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 i2 = this.data.length - 1; i2 >= 0; i2--) {
+      const layer = this.data[i2];
+      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 flatten(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 = {
+  start: "start",
+  end: "end"
+};
+var OperationKind = {
+  delete: "delete",
+  insert: "insert",
+  remove: "remove"
+};
+
+// src/runtime/cache/stuff.ts
+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/subscription.ts
+var InMemorySubscriptions = class {
+  cache;
+  constructor(cache) {
+    this.cache = cache;
+  }
+  subscribers = {};
+  referenceCounts = {};
+  keyVersions = {};
+  add({
+    parent,
+    spec,
+    selection,
+    variables,
+    parentType
+  }) {
+    const __typename = this.cache._internal_unstable.storage.get(parent, "__typename").value;
+    let targetSelection = getFieldsForType(selection, __typename);
+    for (const fieldSelection of Object.values(targetSelection || {})) {
+      const { keyRaw, selection: innerSelection, type, list, filters } = fieldSelection;
+      const key = evaluateKey(keyRaw, variables);
+      let targetSelection2;
+      if (innerSelection) {
+        const __typename2 = this.cache._internal_unstable.storage.get(parent, "__typename").value;
+        targetSelection2 = getFieldsForType(innerSelection, __typename2);
+      }
+      this.addFieldSubscription({
+        id: parent,
+        key,
+        selection: [spec, targetSelection2],
+        type
+      });
+      if (list) {
+        this.registerList({
+          list,
+          filters,
+          id: parent,
+          key,
+          variables,
+          selection: innerSelection,
+          parentType: parentType || spec.rootType
+        });
+      }
+      if (innerSelection) {
+        const { value: linkedRecord } = this.cache._internal_unstable.storage.get(
+          parent,
+          key
+        );
+        let children = !Array.isArray(linkedRecord) ? [linkedRecord] : flatten(linkedRecord) || [];
+        for (const child of children) {
+          if (!child) {
+            continue;
+          }
+          this.add({
+            parent: child,
+            spec,
+            selection: innerSelection,
+            variables,
+            parentType: type
+          });
+        }
+      }
+    }
+  }
+  addFieldSubscription({
+    id,
+    key,
+    selection,
+    type
+  }) {
+    const spec = selection[0];
+    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, selection[1]]);
+    }
+    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: innerSelection } = selection[1]?.[key] ?? {};
+  }
+  registerList({
+    list,
+    id,
+    key,
+    parentType,
+    selection,
+    filters,
+    variables
+  }) {
+    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,
+      filters: Object.entries(filters || {}).reduce((acc, [key2, { kind, value }]) => {
+        return {
+          ...acc,
+          [key2]: kind !== "Variable" ? value : variables[value]
+        };
+      }, {})
+    });
+  }
+  addMany({
+    parent,
+    variables,
+    subscribers,
+    parentType
+  }) {
+    for (const [spec, targetSelection] of subscribers) {
+      for (const selection of Object.values(targetSelection ?? {})) {
+        const {
+          type: linkedType,
+          keyRaw,
+          selection: innerSelection,
+          list,
+          filters
+        } = selection;
+        const key = evaluateKey(keyRaw, variables);
+        const fieldSelection = innerSelection ? getFieldsForType(innerSelection, parentType) : void 0;
+        this.addFieldSubscription({
+          id: parent,
+          key,
+          selection: [spec, fieldSelection],
+          type: linkedType
+        });
+        if (list) {
+          this.registerList({
+            list,
+            filters,
+            id: parent,
+            key,
+            variables,
+            selection: innerSelection,
+            parentType: parentType || spec.rootType
+          });
+        }
+        const childSelection = selection.selection;
+        if (childSelection) {
+          const { value: link } = this.cache._internal_unstable.storage.get(parent, key);
+          const children = !Array.isArray(link) ? [link] : flatten(link);
+          for (const linkedRecord of children) {
+            if (!linkedRecord) {
+              continue;
+            }
+            const __typename = this.cache._internal_unstable.storage.get(
+              linkedRecord,
+              "__typename"
+            ).value;
+            let targetSelection2 = getFieldsForType(childSelection, __typename);
+            this.addMany({
+              parent: linkedRecord,
+              variables,
+              subscribers: subscribers.map(([sub]) => [sub, targetSelection2]),
+              parentType: linkedType
+            });
+          }
+        }
+      }
+    }
+  }
+  get(id, field) {
+    return this.subscribers[id]?.[field] || [];
+  }
+  remove(id, selection, targets, variables, visited = []) {
+    visited.push(id);
+    const linkedIDs = [];
+    const __typename = this.cache._internal_unstable.storage.get(id, "__typename").value;
+    let targetSelection = getFieldsForType(selection, __typename);
+    for (const fieldSelection of Object.values(targetSelection || {})) {
+      const key = evaluateKey(fieldSelection.keyRaw, variables);
+      this.removeSubscribers(id, key, targets);
+      if (!fieldSelection.selection) {
+        continue;
+      }
+      const { value: previousValue } = this.cache._internal_unstable.storage.get(id, key);
+      const links = !Array.isArray(previousValue) ? [previousValue] : flatten(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].map(([spec]) => spec);
+      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) ? flatten(value) : [value];
+      for (const id2 of nextTargets) {
+        if (visited.includes(id2)) {
+          continue;
+        }
+        this.removeAllSubscribers(id2, subscribers, visited);
+      }
+    }
+  }
+};
+
+// src/runtime/cache/cache.ts
+var Cache = class {
+  _internal_unstable;
+  constructor(config) {
+    this._internal_unstable = new CacheInternal({
+      cache: this,
+      storage: new InMemoryStorage(),
+      subscriptions: new InMemorySubscriptions(this),
+      lists: new ListManager(this, rootID),
+      lifetimes: new GarbageCollector(this),
+      staleManager: new StaleManager(this),
+      schema: new SchemaManager(this)
+    });
+    if (config) {
+      this.setConfig(defaultConfigValues(config));
+    }
+  }
+  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 }).map((sub) => sub[0]);
+    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, stale, hasData } = this._internal_unstable.getSelection(...args);
+    if (!hasData) {
+      return { data: null, partial: false, stale: false };
+    }
+    return {
+      data,
+      partial,
+      stale
+    };
+  }
+  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(name, parentID, allLists) {
+    const handler = this._internal_unstable.lists.get(name, parentID, allLists);
+    if (!handler) {
+      throw new Error(
+        `Cannot find list with name: ${name}${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(config) {
+    this._internal_unstable.setConfig(config);
+  }
+  markTypeStale(options) {
+    if (!options) {
+      this._internal_unstable.staleManager.markAllStale();
+    } else if (!options.field) {
+      this._internal_unstable.staleManager.markTypeStale(options.type);
+    } else {
+      this._internal_unstable.staleManager.markTypeFieldStale(
+        options.type,
+        options.field,
+        options.when
+      );
+    }
+  }
+  markRecordStale(id, options) {
+    if (options.field) {
+      const key = computeKey({ field: options.field, args: options.when ?? {} });
+      this._internal_unstable.staleManager.markFieldStale(id, key);
+    } else {
+      this._internal_unstable.staleManager.markRecordStale(id);
+    }
+  }
+  getFieldTime(id, field) {
+    return this._internal_unstable.staleManager.getFieldTime(id, field);
+  }
+};
+var CacheInternal = class {
+  _disabled = false;
+  config = defaultConfigValues({
+    plugins: {
+      "houdini-svelte": {
+        client: ""
+      }
+    }
+  });
+  storage;
+  subscriptions;
+  lists;
+  cache;
+  lifetimes;
+  staleManager;
+  schema;
+  constructor({
+    storage,
+    subscriptions,
+    lists,
+    cache,
+    lifetimes,
+    staleManager,
+    schema
+  }) {
+    this.storage = storage;
+    this.subscriptions = subscriptions;
+    this.lists = lists;
+    this.cache = cache;
+    this.lifetimes = lifetimes;
+    this.staleManager = staleManager;
+    this.schema = schema;
+    this._disabled = typeof globalThis.window === "undefined";
+    try {
+      if (process.env.HOUDINI_TEST === "true") {
+        this._disabled = false;
+      }
+    } catch {
+    }
+  }
+  setConfig(config) {
+    this.config = config;
+  }
+  writeSelection({
+    data,
+    selection,
+    variables = {},
+    parent = rootID,
+    applyUpdates,
+    layer,
+    toNotify = [],
+    forceNotify,
+    forceStale
+  }) {
+    if (this._disabled) {
+      return [];
+    }
+    let targetSelection = getFieldsForType(selection, data["__typename"]);
+    for (const [field, value] of Object.entries(data)) {
+      if (!selection || !targetSelection[field]) {
+        throw new Error(
+          "Could not find field listing in selection for " + field + " @ " + JSON.stringify(selection)
+        );
+      }
+      let {
+        type: linkedType,
+        keyRaw,
+        selection: fieldSelection,
+        operations,
+        abstract: isAbstract,
+        updates,
+        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 specs = currentSubscribers.map((sub) => sub[0]);
+      const { value: previousValue, displayLayers } = this.storage.get(parent, key);
+      const displayLayer = layer.isDisplayLayer(displayLayers);
+      if (displayLayer) {
+        this.lifetimes.resetLifetime(parent, key);
+        if (forceStale) {
+          this.staleManager.markFieldStale(parent, key);
+        } else {
+          this.staleManager.setFieldTimeToNow(parent, key);
+        }
+      }
+      if (!fieldSelection) {
+        let newValue = value;
+        if (updates && applyUpdates && Array.isArray(value)) {
+          for (const update of applyUpdates) {
+            if (!updates.includes(update)) {
+              continue;
+            }
+            if (update === "append") {
+              newValue = (previousValue || []).concat(value);
+            } else if (update === "prepend") {
+              newValue = value.concat(previousValue || []);
+            }
+          }
+        }
+        if (updates && applyUpdates?.includes("prepend") && ["endCursor", "hasNextPage"].includes(key)) {
+          newValue = previousValue;
+        } else if (updates && applyUpdates?.includes("append") && ["startCursor", "hasPreviousPage"].includes(key)) {
+          newValue = 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 = flatten([previousValue]);
+        for (const link of previousLinks) {
+          this.subscriptions.remove(link, fieldSelection, specs, 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, specs, variables);
+          }
+          this.subscriptions.addMany({
+            parent: linkedID,
+            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 = !updates ? [] : 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 && updates) {
+          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;
+            });
+          }
+          for (const update of applyUpdates) {
+            if (update !== "replace" && !updates.includes(update)) {
+              continue;
+            }
+            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, specs, 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,
+            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,
+    parent = rootID,
+    variables,
+    stepsFromConnection = null
+  }) {
+    if (parent === null) {
+      return { data: null, partial: false, stale: false, hasData: true };
+    }
+    const target = {};
+    let hasData = false;
+    let partial = false;
+    let cascadeNull = false;
+    let stale = false;
+    const typename = this.storage.get(parent, "__typename").value;
+    let targetSelection = getFieldsForType(selection, 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);
+      const dt_field = this.staleManager.getFieldTime(parent, key);
+      if (dt_field === null) {
+        stale = true;
+      }
+      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.stale) {
+          stale = 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.stale) {
+          stale = true;
+        }
+        if (objectFields.hasData) {
+          hasData = true;
+        }
+      }
+      if (target[attributeName] === null && !nullable && !embeddedCursor) {
+        cascadeNull = true;
+      }
+    }
+    return {
+      data: cascadeNull ? null : target,
+      partial: hasData && partial,
+      stale: hasData && stale,
+      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 stale = 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,
+        stale: local_stale,
+        hasData
+      } = this.getSelection({
+        parent: entry,
+        selection: fields,
+        variables,
+        stepsFromConnection
+      });
+      result.push(data);
+      if (partial) {
+        partialData = true;
+      }
+      if (local_stale) {
+        stale = true;
+      }
+      if (hasData) {
+        hasValues = true;
+      }
+    }
+    return {
+      data: result,
+      partial: partialData,
+      stale,
+      hasData: hasValues
+    };
+  }
+  extractNestedListIDs({
+    value,
+    abstract,
+    recordID,
+    key,
+    linkedType,
+    fields,
+    variables,
+    applyUpdates,
+    specs,
+    layer,
+    forceNotify
+  }) {
+    const nestedIDs = [];
+    const newIDs = [];
+    for (const [i2, 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[i2] = inner.nestedIDs;
+        continue;
+      }
+      if (entry === null || typeof entry === "undefined") {
+        newIDs.push(null);
+        nestedIDs[i2] = 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[i2] = 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 Cache();
+
+// src/runtime/client/plugins/cache.ts
+var cachePolicy = ({
+  enabled,
+  setFetching,
+  cache: localCache = cache_default
+}) => () => {
+  return {
+    network(ctx, { initialValue, next, resolve: resolve2, marshalVariables: marshalVariables2 }) {
+      const { policy, artifact } = ctx;
+      let useCache = false;
+      if (enabled && artifact.kind === ArtifactKind.Query && !ctx.cacheParams?.disableRead) {
+        if (policy !== CachePolicy.NetworkOnly) {
+          const value = localCache.read({
+            selection: artifact.selection,
+            variables: marshalVariables2(ctx)
+          });
+          const allowed = !value.partial || artifact.kind === ArtifactKind.Query && artifact.partial;
+          if (policy === CachePolicy.CacheOnly) {
+            return resolve2(ctx, {
+              fetching: false,
+              variables: ctx.variables ?? null,
+              data: allowed ? value.data : initialValue.data,
+              errors: null,
+              source: DataSource.Cache,
+              partial: allowed ? value.partial : false,
+              stale: value.stale
+            });
+          }
+          useCache = !!(value.data !== null && allowed);
+          if (useCache) {
+            resolve2(ctx, {
+              fetching: false,
+              variables: ctx.variables ?? null,
+              data: value.data,
+              errors: null,
+              source: DataSource.Cache,
+              partial: value.partial,
+              stale: value.stale
+            });
+          }
+          if (useCache && !value.partial && !value.stale) {
+            return;
+          }
+        }
+      }
+      if (enabled) {
+        setTimeout(() => {
+          localCache._internal_unstable.collectGarbage();
+        }, 0);
+      }
+      setFetching(!useCache);
+      return next(ctx);
+    },
+    afterNetwork(ctx, { resolve: resolve2, value, marshalVariables: marshalVariables2 }) {
+      if (value.source !== DataSource.Cache && enabled && value.data && !ctx.cacheParams?.disableWrite) {
+        localCache.write({
+          ...ctx.cacheParams,
+          layer: ctx.cacheParams?.layer?.id,
+          selection: ctx.artifact.selection,
+          data: value.data,
+          variables: marshalVariables2(ctx)
+        });
+      }
+      resolve2(ctx, value);
+    }
+  };
+};
+
+// src/runtime/client/utils/documentPlugins.ts
+var documentPlugin = (kind, source) => {
+  return () => {
+    const sourceHandlers = source();
+    const enterWrapper = (handler) => {
+      return !handler ? void 0 : (ctx, handlers) => {
+        if (ctx.artifact.kind !== kind) {
+          return handlers.next(ctx);
+        }
+        return handler(ctx, handlers);
+      };
+    };
+    const exitWrapper = (handler) => {
+      return !handler ? void 0 : (ctx, handlers) => {
+        if (ctx.artifact.kind !== kind) {
+          return handlers.resolve(ctx);
+        }
+        return handler(ctx, handlers);
+      };
+    };
+    return {
+      start: enterWrapper(sourceHandlers.start),
+      network: enterWrapper(sourceHandlers.network),
+      afterNetwork: exitWrapper(sourceHandlers.afterNetwork),
+      end: exitWrapper(sourceHandlers.end),
+      catch: sourceHandlers.catch ? (ctx, handlers) => sourceHandlers.catch(ctx, handlers) : void 0,
+      cleanup: (...args) => sourceHandlers.cleanup?.(...args)
+    };
+  };
+};
+
+// src/runtime/client/plugins/query.ts
+var query = documentPlugin(ArtifactKind.Query, function() {
+  let subscriptionSpec = null;
+  let lastVariables = null;
+  let artifactName = "";
+  return {
+    start(ctx, { next }) {
+      ctx.variables = {
+        ...lastVariables,
+        ...ctx.variables
+      };
+      next(ctx);
+    },
+    end(ctx, { resolve: resolve2, marshalVariables: marshalVariables2, variablesChanged: variablesChanged2 }) {
+      if (variablesChanged2(ctx)) {
+        artifactName = ctx.artifact.name;
+        if (subscriptionSpec) {
+          cache_default.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() || {});
+        }
+        lastVariables = { ...marshalVariables2(ctx) };
+        subscriptionSpec = {
+          rootType: ctx.artifact.rootType,
+          selection: ctx.artifact.selection,
+          variables: () => lastVariables,
+          set: (newValue) => {
+            resolve2(ctx, {
+              data: newValue,
+              errors: null,
+              fetching: false,
+              partial: false,
+              stale: false,
+              source: DataSource.Cache,
+              variables: ctx.variables ?? {}
+            });
+          }
+        };
+        cache_default.subscribe(subscriptionSpec, lastVariables ?? {});
+      }
+      resolve2(ctx);
+    },
+    cleanup() {
+      if (subscriptionSpec) {
+        cache_default.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() ?? {});
+        lastVariables = null;
+      }
+    }
+  };
+});
+
+// src/runtime/client/plugins/mutation.ts
+var mutation = documentPlugin(ArtifactKind.Mutation, () => {
+  return {
+    async start(ctx, { next, marshalVariables: marshalVariables2 }) {
+      const layer = cache_default._internal_unstable.storage.createLayer(true);
+      const optimisticResponse = ctx.stuff.optimisticResponse;
+      let toNotify = [];
+      if (optimisticResponse) {
+        toNotify = cache_default.write({
+          selection: ctx.artifact.selection,
+          data: await marshalSelection({
+            selection: ctx.artifact.selection,
+            data: optimisticResponse
+          }),
+          variables: marshalVariables2(ctx),
+          layer: layer.id
+        });
+      }
+      ctx.cacheParams = {
+        ...ctx.cacheParams,
+        layer,
+        notifySubscribers: toNotify,
+        forceNotify: true
+      };
+      next(ctx);
+    },
+    afterNetwork(ctx, { resolve: resolve2 }) {
+      ctx.cacheParams?.layer?.clear();
+      resolve2(ctx);
+    },
+    end(ctx, { resolve: resolve2, value }) {
+      const hasErrors = value.errors && value.errors.length > 0;
+      if (hasErrors) {
+        ctx.cacheParams?.layer?.clear();
+      }
+      if (ctx.cacheParams?.layer) {
+        cache_default._internal_unstable.storage.resolveLayer(ctx.cacheParams.layer.id);
+      }
+      resolve2(ctx);
+    },
+    catch(ctx, { error }) {
+      if (ctx.cacheParams?.layer) {
+        const { layer } = ctx.cacheParams;
+        layer.clear();
+        cache_default._internal_unstable.storage.resolveLayer(layer.id);
+      }
+      throw error;
+    }
+  };
+});
+
+// src/runtime/client/plugins/subscription.ts
+function subscription(factory) {
+  return documentPlugin(ArtifactKind.Subscription, () => {
+    let clearSubscription = null;
+    let socketClient = null;
+    let check = null;
+    return {
+      start(ctx, { resolve: resolve2, next, initialValue }) {
+        if (typeof globalThis.window === "undefined") {
+          resolve2(ctx, initialValue);
+          return;
+        }
+        next(ctx);
+      },
+      network(ctx, { resolve: resolve2, initialValue, variablesChanged: variablesChanged2, marshalVariables: marshalVariables2 }) {
+        const checkValue = {
+          fetchParams: ctx.fetchParams ?? {},
+          session: ctx.session ?? {},
+          metadata: ctx.metadata ?? {}
+        };
+        const changed = variablesChanged2(ctx);
+        const sessionChange = !deepEquals(check, checkValue);
+        if (!changed && !sessionChange) {
+          resolve2(ctx, initialValue);
+          return;
+        }
+        check = checkValue;
+        clearSubscription?.();
+        if (!socketClient || sessionChange) {
+          socketClient = factory(ctx);
+        }
+        clearSubscription = socketClient.subscribe(
+          {
+            query: ctx.artifact.raw,
+            variables: marshalVariables2(ctx)
+          },
+          {
+            next: ({ data, errors }) => {
+              resolve2(ctx, {
+                data: data ?? null,
+                errors: [...errors ?? []],
+                fetching: false,
+                partial: true,
+                stale: false,
+                source: DataSource.Network,
+                variables: ctx.variables ?? {}
+              });
+            },
+            error(data) {
+              clearSubscription?.();
+              resolve2(ctx, {
+                partial: true,
+                stale: false,
+                source: DataSource.Network,
+                data: null,
+                errors: [data],
+                fetching: false,
+                variables: ctx.variables ?? {}
+              });
+            },
+            complete() {
+            }
+          }
+        );
+      },
+      cleanup() {
+        clearSubscription?.();
+      }
+    };
+  });
+}
+
+// src/runtime/client/plugins/throwOnError.ts
+var throwOnError = ({ operations, error }) => () => {
+  const all = operations.includes("all");
+  const throwOnKind = (kind) => all || {
+    [ArtifactKind.Query]: operations.includes("query"),
+    [ArtifactKind.Mutation]: operations.includes("mutation"),
+    [ArtifactKind.Fragment]: false,
+    [ArtifactKind.Subscription]: operations.includes("subscription")
+  }[kind];
+  return {
+    async end(ctx, { value, resolve: resolve2 }) {
+      if (value.errors && value.errors.length > 0 && throwOnKind(ctx.artifact.kind)) {
+        const result = await (error ?? defaultErrorFn)(value.errors);
+        throw result;
+      }
+      resolve2(ctx);
+    }
+  };
+};
+var defaultErrorFn = async (errors) => new Error(errors.map((error) => error.message).join(". ") + ".");
+
+// src/runtime/client/plugins/fetchParams.ts
+var fetchParams = (fn = () => ({})) => () => ({
+  beforeNetwork(ctx, { next, marshalVariables: marshalVariables2 }) {
+    next({
+      ...ctx,
+      fetchParams: fn({
+        config: ctx.config,
+        policy: ctx.policy,
+        metadata: ctx.metadata,
+        session: ctx.session,
+        stuff: ctx.stuff,
+        document: ctx.artifact,
+        variables: marshalVariables2(ctx),
+        text: ctx.artifact.raw,
+        hash: ctx.artifact.hash
+      })
+    });
+  }
+});
+
+// src/runtime/client/documentStore.ts
+var steps = {
+  forward: ["start", "beforeNetwork", "network"],
+  backwards: ["end", "afterNetwork"]
+};
+var DocumentStore = class extends Writable {
+  #artifact;
+  #client;
+  #configFile;
+  #plugins;
+  #lastVariables;
+  #lastContext = null;
+  constructor({
+    artifact,
+    plugins: plugins2,
+    pipeline: pipeline2,
+    client,
+    cache = true,
+    initialValue,
+    fetching
+  }) {
+    fetching ??= artifact.kind === ArtifactKind.Query;
+    const initialState = {
+      data: initialValue ?? null,
+      errors: null,
+      partial: false,
+      stale: false,
+      source: null,
+      fetching,
+      variables: null
+    };
+    super(initialState, () => {
+      return () => {
+        this.#lastVariables = null;
+        for (const plugin2 of this.#plugins) {
+          plugin2.cleanup?.(this.#lastContext);
+        }
+      };
+    });
+    this.#artifact = artifact;
+    this.#client = client;
+    this.#lastVariables = null;
+    this.#configFile = getCurrentConfig();
+    this.#plugins = pipeline2 ?? [
+      cachePolicy({
+        enabled: cache,
+        setFetching: (fetching2) => this.update((state) => ({ ...state, fetching: fetching2 }))
+      })(),
+      ...plugins2 ?? []
+    ];
+  }
+  async send({
+    metadata,
+    session,
+    fetch: fetch3 = globalThis.fetch,
+    variables,
+    policy,
+    stuff,
+    cacheParams,
+    setup = false,
+    silenceEcho = false
+  } = {}) {
+    let context = new ClientPluginContextWrapper({
+      config: this.#configFile,
+      text: this.#artifact.raw,
+      hash: this.#artifact.hash,
+      policy: policy ?? this.#artifact.policy,
+      variables: null,
+      metadata,
+      session,
+      fetch: fetch3,
+      stuff: {
+        inputs: {
+          changed: false,
+          init: false,
+          marshaled: {}
+        },
+        ...stuff
+      },
+      artifact: this.#artifact,
+      lastVariables: this.#lastVariables,
+      cacheParams
+    });
+    const draft = context.draft();
+    draft.variables = variables ?? null;
+    context = context.apply(draft, false);
+    return await new Promise((resolve2, reject) => {
+      const state = {
+        setup,
+        currentStep: 0,
+        index: 0,
+        silenceEcho,
+        promise: {
+          resolved: false,
+          resolve: resolve2,
+          reject
+        },
+        context
+      };
+      this.#step("forward", state);
+    });
+  }
+  #step(direction, ctx, value) {
+    const hook = direction === "error" ? "catch" : steps[direction][ctx.currentStep];
+    let valid = (i2) => i2 <= this.#plugins.length;
+    let step = (i2) => i2 + 1;
+    if (["backwards", "error"].includes(direction)) {
+      valid = (i2) => i2 >= 0;
+      step = (i2) => i2 - 1;
+    }
+    for (let index = ctx.index; valid(index); index = step(index)) {
+      let target = this.#plugins[index]?.[hook];
+      if (!target) {
+        continue;
+      }
+      const draft = ctx.context.draft();
+      let variablesRefChanged = (newContext) => newContext.variables !== draft.variables;
+      const common = {
+        initialValue: this.state,
+        client: this.#client,
+        variablesChanged,
+        marshalVariables,
+        updateState: this.update.bind(this),
+        next: (newContext) => {
+          const nextIndex = ["forward", "error"].includes(direction) ? index + 1 : index;
+          const nextStep = ["backwards", "error"].includes(direction) ? 0 : ctx.currentStep;
+          this.#step("forward", {
+            ...ctx,
+            index: nextIndex,
+            currentStep: nextStep,
+            context: ctx.context.apply(newContext, variablesRefChanged(newContext))
+          });
+        },
+        resolve: (newContext, value2) => {
+          const nextIndex = direction === "backwards" ? index - 1 : index;
+          this.#step(
+            "backwards",
+            {
+              ...ctx,
+              index: nextIndex,
+              context: ctx.context.apply(newContext, variablesRefChanged(newContext))
+            },
+            value2
+          );
+        }
+      };
+      let handlers;
+      if (direction === "forward") {
+        handlers = common;
+      } else if (direction === "backwards") {
+        handlers = {
+          ...common,
+          value,
+          resolve: (ctx2, data2) => {
+            return common.resolve(ctx2, data2 ?? value);
+          }
+        };
+      } else if (direction === "error") {
+        handlers = {
+          ...common,
+          error: value
+        };
+      }
+      try {
+        const result = target(draft, handlers);
+        result?.catch((err) => {
+          this.#step("error", { ...ctx, index: index - 1 }, err);
+        });
+      } catch (err) {
+        this.#step("error", { ...ctx, index: index - 1 }, err);
+      }
+      return;
+    }
+    if (direction === "forward") {
+      if (ctx.setup) {
+        return this.#step(
+          "backwards",
+          {
+            ...ctx,
+            currentStep: 0,
+            index: this.#plugins.length
+          },
+          this.state
+        );
+      }
+      if (ctx.currentStep <= steps.forward.length - 2) {
+        return this.#step("forward", {
+          ...ctx,
+          currentStep: ctx.currentStep + 1,
+          index: 0
+        });
+      }
+      throw new Error(
+        "Called next() on last possible plugin. Your chain is missing a plugin that calls resolve()."
+      );
+    }
+    if (direction === "error") {
+      if (!ctx.promise.resolved) {
+        ctx.promise.reject(value);
+        ctx.promise.resolved = true;
+      }
+      return;
+    }
+    if (ctx.currentStep > 0) {
+      return this.#step(
+        "backwards",
+        {
+          ...ctx,
+          currentStep: ctx.currentStep - 1,
+          index: this.#plugins.length - 1
+        },
+        value
+      );
+    }
+    let data = value.data;
+    try {
+      data = unmarshalSelection(this.#configFile, this.#artifact.selection, data) ?? null;
+    } catch {
+    }
+    const finalValue = {
+      ...value,
+      data
+    };
+    if (!ctx.promise.resolved) {
+      ctx.promise.resolve(finalValue);
+      ctx.promise.resolved = true;
+    }
+    this.#lastContext = ctx.context.draft();
+    this.#lastVariables = this.#lastContext.stuff.inputs.marshaled;
+    if (ctx.silenceEcho && finalValue.data === this.state.data) {
+      return;
+    }
+    this.set(finalValue);
+  }
+};
+var ClientPluginContextWrapper = class {
+  #context;
+  #lastVariables;
+  constructor({
+    lastVariables,
+    ...values
+  }) {
+    this.#context = values;
+    this.#lastVariables = lastVariables;
+  }
+  get variables() {
+    return this.#context.variables;
+  }
+  draft() {
+    const ctx = {
+      ...this.#context
+    };
+    const applyVariables = this.applyVariables.bind(this);
+    return {
+      ...ctx,
+      get stuff() {
+        return ctx.stuff;
+      },
+      set stuff(val) {
+        ctx.stuff = val;
+      },
+      get variables() {
+        return ctx.variables ?? null;
+      },
+      set variables(val) {
+        Object.assign(ctx, applyVariables(ctx, { variables: val }));
+      }
+    };
+  }
+  applyVariables(source, values) {
+    const artifact = source.artifact;
+    const ctx = {
+      ...source,
+      ...values
+    };
+    const val = values.variables;
+    let changed = {};
+    for (const [name, value] of Object.entries(val ?? {})) {
+      if (value !== source.variables?.[name]) {
+        changed[name] = value;
+      }
+    }
+    ctx.stuff = {
+      ...ctx.stuff,
+      inputs: {
+        ...ctx.stuff.inputs
+      }
+    };
+    const firstInit = !ctx.stuff.inputs || !ctx.stuff.inputs.init;
+    const hasChanged = Object.keys(changed).length > 0 || firstInit;
+    if (artifact.kind !== ArtifactKind.Fragment && hasChanged) {
+      const newVariables = {
+        ...ctx.stuff.inputs?.marshaled,
+        ...marshalInputs({
+          artifact,
+          input: changed,
+          config: source.config
+        })
+      };
+      ctx.stuff.inputs = {
+        init: true,
+        marshaled: newVariables,
+        changed: true
+      };
+      ctx.variables = val;
+    }
+    ctx.stuff = {
+      ...ctx.stuff,
+      inputs: {
+        ...ctx.stuff.inputs,
+        changed: !deepEquals(ctx.stuff.inputs.marshaled, this.#lastVariables)
+      }
+    };
+    return ctx;
+  }
+  apply(values, newVariables) {
+    if (newVariables) {
+      values = this.applyVariables(this.#context, values);
+    }
+    const wrapper = new ClientPluginContextWrapper({
+      ...values,
+      lastVariables: this.#lastVariables
+    });
+    return wrapper;
+  }
+};
+function marshalVariables(ctx) {
+  return ctx.stuff.inputs?.marshaled ?? {};
+}
+function variablesChanged(ctx) {
+  return ctx.stuff.inputs?.changed;
+}
+
+// src/runtime/client/plugins/injectedPlugins.ts
+var plugins = [];
+var injectedPlugins_default = plugins;
+
+// src/runtime/client/index.ts
+var HoudiniClient = class {
+  url;
+  #plugins;
+  constructor({ url, fetchParams: fetchParams2, plugins: plugins2, pipeline: pipeline2, throwOnError: throwOnError2 }) {
+    if (plugins2 && pipeline2) {
+      throw new Error(
+        "A client cannot be given a pipeline and a list of plugins at the same time."
+      );
+    }
+    this.#plugins = flatten(
+      [].concat(
+        throwOnError2 ? [throwOnError(throwOnError2)] : [],
+        fetchParams(fetchParams2),
+        pipeline2 ?? [
+          query,
+          mutation
+        ].concat(
+          plugins2 ?? [],
+          injectedPlugins_default,
+          fetch2()
+        )
+      )
+    );
+    this.url = url;
+  }
+  observe({
+    artifact,
+    cache = true,
+    initialValue,
+    fetching = false
+  }) {
+    return new DocumentStore({
+      client: this,
+      artifact,
+      plugins: createPluginHooks(this.#plugins),
+      cache,
+      initialValue,
+      fetching
+    });
+  }
+};
+function createPluginHooks(plugins2) {
+  return plugins2.reduce((hooks, plugin2) => {
+    if (typeof plugin2 !== "function") {
+      throw new Error("Encountered client plugin that's not a function");
+    }
+    const result = plugin2();
+    if (!result) {
+      return hooks;
+    }
+    if (!Array.isArray(result)) {
+      return hooks.concat(result);
+    }
+    for (const value of result) {
+      if (!value) {
+        continue;
+      }
+      if (typeof value === "function") {
+        return hooks.concat(createPluginHooks([value]));
+      }
+      hooks.push(value);
+    }
+    return hooks;
+  }, []);
+}
+
 // src/lib/types.ts
-var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
-  LogLevel2["Full"] = "full";
-  LogLevel2["Summary"] = "summary";
-  LogLevel2["ShortSummary"] = "short-summary";
-  LogLevel2["Quiet"] = "quiet";
-  return LogLevel2;
-})(LogLevel || {});
+var LogLevel = {
+  Full: "full",
+  Summary: "summary",
+  ShortSummary: "short-summary",
+  Quiet: "quiet"
+};
 
 // src/lib/config.ts
 var import_meta = {};
@@ -63278,7 +66249,7 @@ var Config = class {
       scalars,
       cacheBufferSize,
       definitionsPath,
-      defaultCachePolicy = "CacheOrNetwork" /* CacheOrNetwork */,
+      defaultCachePolicy = CachePolicy.CacheOrNetwork,
       defaultPartial = false,
       defaultListPosition = "append",
       defaultListTarget = null,
@@ -63300,7 +66271,7 @@ var Config = class {
           Object.values(LogLevel)
         )}`
       );
-      logLevel = "summary" /* Summary */;
+      logLevel = LogLevel.Summary;
     }
     this.schemaPath = schemaPath;
     this.filepath = filepath;
@@ -63316,7 +66287,7 @@ var Config = class {
     this.internalListPosition = defaultListPosition === "append" ? "last" : "first";
     this.defaultListTarget = defaultListTarget;
     this.definitionsFolder = definitionsPath;
-    this.logLevel = (logLevel || "summary" /* Summary */).toLowerCase();
+    this.logLevel = (logLevel || LogLevel.Summary).toLowerCase();
     this.defaultFragmentMasking = defaultFragmentMasking;
     this.routesDir = join2(this.projectRoot, "src", "routes");
     this.schemaPollInterval = watchSchema?.interval ?? 2e3;
@@ -63657,8 +66628,10 @@ var Config = class {
     return node.name.value === "CachePolicy";
   }
   isInternalDirective(name) {
-    const internalDirectives = this.#newSchemaInstance?.getDirectives().map((directive) => directive.name) ?? [];
-    return internalDirectives.includes(name) || this.isDeleteDirective(name);
+    const internalDirectives = this.#newSchemaInstance?.getDirectives().reduce((list, directive) => {
+      return list.concat(directive.name);
+    }, []) ?? [];
+    return !defaultDirectives.includes(name) && (internalDirectives.includes(name) || this.isDeleteDirective(name));
   }
   isListFragment(name) {
     return name.endsWith(this.insertFragmentSuffix) || name.endsWith(this.removeFragmentSuffix) || name.endsWith(this.toggleFragmentSuffix);
@@ -63762,10 +66735,16 @@ async function getConfig({
         await flattenPluginList(configPath, hooksList, pluginName, pluginFile)
       );
     }
-    const plugins = pluginsNested.flat();
-    for (const plugin2 of plugins) {
+    const plugins2 = pluginsNested.flat();
+    for (const plugin2 of plugins2) {
       if (plugin2.config) {
-        configFile = deepMerge(configPath, configFile, await plugin2.config(configFile));
+        try {
+          const configFactory = await import(plugin2.config);
+          const newValue = typeof configFactory === "function" ? configFactory(configFile) : configFactory;
+          configFile = deepMerge(configPath, configFile, newValue);
+        } catch {
+          console.log("could not load config file" + plugin2.config);
+        }
       }
     }
     _config = new Config({
@@ -63791,7 +66770,7 @@ async function getConfig({
         _config.schema = await loadSchemaFile(_config.schemaPath);
       }
     }
-    _config.plugins = orderedPlugins(plugins);
+    _config.plugins = orderedPlugins(plugins2);
     await Promise.all(_config.plugins.map((plugin2) => plugin2.afterLoad?.({ config: _config })));
     resolve2(_config);
     return _config;
@@ -63845,13 +66824,13 @@ ${e2.message}`);
   const config = imported.default || imported;
   return config;
 }
-var orderedPlugins = (plugins) => {
-  const ordered = plugins.filter(
+var orderedPlugins = (plugins2) => {
+  const ordered = plugins2.filter(
     (plugin2) => plugin2.order === "before" || plugin2.order === void 0
   );
   ordered.push(
-    ...plugins.filter((plugin2) => plugin2.order === "core"),
-    ...plugins.filter((plugin2) => plugin2.order === "after")
+    ...plugins2.filter((plugin2) => plugin2.order === "core"),
+    ...plugins2.filter((plugin2) => plugin2.order === "after")
   );
   return ordered;
 };
@@ -63923,6 +66902,8 @@ async function loadSchemaFile(schemaPath) {
   }
   return graphql2.buildClientSchema(jsonContents);
 }
+var emptySchema = graphql2.buildSchema("type Query { hello: String }");
+var defaultDirectives = emptySchema.getDirectives().map((dir) => dir.name);
 
 // src/lib/graphql.ts
 var graphql3 = __toESM(require_graphql2(), 1);
@@ -63939,7 +66920,7 @@ function getRootType(type) {
 function hashDocument({
   document
 }) {
-  const docString = typeof document === "string" ? document : document.artifact?.raw;
+  const docString = typeof document === "string" ? document : document.originalString;
   return import_node_crypto.default.createHash("sha256").update(docString ?? "").digest("hex");
 }
 function parentTypeFromAncestors(schema, filepath, ancestors) {
@@ -64363,17 +67344,21 @@ async function find_graphql(config, parsedScript, walker) {
   CompiledSubscriptionKind,
   Config,
   DataSource,
+  DocumentStore,
+  HoudiniClient,
   HoudiniError,
   LogLevel,
   RefetchUpdateMode,
   TypeWrapper,
   cleanupFiles,
   computeID,
+  createPluginHooks,
   deepMerge,
   defaultConfigValues,
   definitionFromAncestors,
   ensureArtifactImport,
   ensureImports,
+  fetch,
   find_graphql,
   formatErrors,
   fs,
@@ -64384,6 +67369,7 @@ async function find_graphql(config, parsedScript, walker) {
   hashDocument,
   houdini_mode,
   keyFieldsForType,
+  mutation,
   operation_requires_variables,
   orderedPlugins,
   parentTypeFromAncestors,
@@ -64392,10 +67378,12 @@ async function find_graphql(config, parsedScript, walker) {
   path,
   plugin,
   pullSchema,
+  query,
   readConfigFile,
   runPipeline,
   setMockConfig,
   siteURL,
+  subscription,
   unwrapType,
   wrapType
 });