houdini 1.0.0-next.9 → 1.0.0

package/build/test-esm/index.js

@@ -15650,42 +15650,42 @@ var require_node = __commonJS({
       return Link2;
     }(events_1.EventEmitter);
     exports.Link = Link;
-    var File = function() {
-      function File2(link, node, flags, fd) {
+    var File2 = function() {
+      function File3(link, node, flags, fd) {
         this.position = 0;
         this.link = link;
         this.node = node;
         this.flags = flags;
         this.fd = fd;
       }
-      File2.prototype.getString = function(encoding) {
+      File3.prototype.getString = function(encoding) {
         if (encoding === void 0) {
           encoding = "utf8";
         }
         return this.node.getString();
       };
-      File2.prototype.setString = function(str) {
+      File3.prototype.setString = function(str) {
         this.node.setString(str);
       };
-      File2.prototype.getBuffer = function() {
+      File3.prototype.getBuffer = function() {
         return this.node.getBuffer();
       };
-      File2.prototype.setBuffer = function(buf) {
+      File3.prototype.setBuffer = function(buf) {
         this.node.setBuffer(buf);
       };
-      File2.prototype.getSize = function() {
+      File3.prototype.getSize = function() {
         return this.node.getSize();
       };
-      File2.prototype.truncate = function(len) {
+      File3.prototype.truncate = function(len) {
         this.node.truncate(len);
       };
-      File2.prototype.seekTo = function(position) {
+      File3.prototype.seekTo = function(position) {
         this.position = position;
       };
-      File2.prototype.stats = function() {
+      File3.prototype.stats = function() {
         return Stats_1.default.build(this.node);
       };
-      File2.prototype.write = function(buf, offset, length, position) {
+      File3.prototype.write = function(buf, offset, length, position) {
         if (offset === void 0) {
           offset = 0;
         }
@@ -15700,7 +15700,7 @@ var require_node = __commonJS({
         this.position = position + bytes;
         return bytes;
       };
-      File2.prototype.read = function(buf, offset, length, position) {
+      File3.prototype.read = function(buf, offset, length, position) {
         if (offset === void 0) {
           offset = 0;
         }
@@ -15713,15 +15713,15 @@ var require_node = __commonJS({
         this.position = position + bytes;
         return bytes;
       };
-      File2.prototype.chmod = function(perm) {
+      File3.prototype.chmod = function(perm) {
         this.node.chmod(perm);
       };
-      File2.prototype.chown = function(uid, gid) {
+      File3.prototype.chown = function(uid, gid) {
         this.node.chown(uid, gid);
       };
-      return File2;
+      return File3;
     }();
-    exports.File = File;
+    exports.File = File2;
   }
 });
 
@@ -16407,20 +16407,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 = join2(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() {
@@ -54056,7 +54056,18 @@ var graphql = __toESM(require_graphql2(), 1);
 var import_minimatch = __toESM(require_minimatch(), 1);
 import { fileURLToPath, pathToFileURL } from "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() {
+  return mockConfig;
+}
 function defaultConfigValues(file) {
   return {
     defaultKeys: ["id"],
@@ -54084,6 +54095,150 @@ function computeID(configFile, type, data) {
   }
   return id.slice(0, -2);
 }
+var _configFile = null;
+function getCurrentConfig() {
+  const mockConfig2 = getMockConfig();
+  if (mockConfig2) {
+    return mockConfig2;
+  }
+  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 i = 0; i < keysA.length; i++) {
+    if (!Reflect.has(objB, keysA[i]) || !deepEquals(objA[keysA[i]], objB[keysA[i]], map)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/runtime/lib/selection.ts
+function getFieldsForType(selection2, __typename) {
+  let targetSelection = selection2.fields || {};
+  if (selection2.abstractFields && __typename) {
+    const mappedType = selection2.abstractFields.typeMap[__typename];
+    if (mappedType) {
+      targetSelection = selection2.abstractFields.fields[mappedType];
+    } else if (selection2.abstractFields.fields[__typename]) {
+      targetSelection = selection2.abstractFields.fields[__typename];
+    }
+  }
+  return targetSelection;
+}
+
+// src/runtime/lib/scalars.ts
+async function marshalSelection({
+  selection: selection2,
+  data
+}) {
+  const config2 = getCurrentConfig();
+  if (data === null || typeof data === "undefined") {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return await Promise.all(data.map((val) => marshalSelection({ selection: selection2, data: val })));
+  }
+  const targetSelection = getFieldsForType(selection2, data["__typename"]);
+  return Object.fromEntries(
+    await Promise.all(
+      Object.entries(data).map(async ([fieldName, value]) => {
+        const { type, selection: selection3 } = targetSelection[fieldName];
+        if (!type) {
+          return [fieldName, value];
+        }
+        if (selection3) {
+          return [fieldName, await marshalSelection({ selection: selection3, data: value })];
+        }
+        if (config2.scalars?.[type]) {
+          const marshalFn = config2.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];
+      })
+    )
+  );
+}
+
+// src/runtime/lib/types.ts
+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/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";
@@ -54406,14 +54561,2002 @@ async function glob(pattern) {
 }
 glob.hasMagic = import_glob.glob.hasMagic;
 
+// 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/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: selection2,
+    when,
+    filters,
+    connection,
+    manager,
+    abstract
+  }) {
+    this.recordID = recordID || rootID;
+    this.recordType = recordType;
+    this.key = key;
+    this.type = listType;
+    this.cache = manager.cache;
+    this.selection = selection2;
+    this._when = when;
+    this.filters = filters;
+    this.name = 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(selection2, data, variables = {}) {
+    return this.addToList(selection2, data, variables, "last");
+  }
+  prepend(selection2, data, variables = {}) {
+    return this.addToList(selection2, data, variables, "first");
+  }
+  addToList(selection2, data, variables = {}, where) {
+    const listType = this.listType(data);
+    const dataID = this.cache._internal_unstable.id(listType, data);
+    if (!this.validateWhen() || !dataID) {
+      return;
+    }
+    let insertSelection = selection2;
+    let insertData = data;
+    if (this.connection) {
+      insertSelection = {
+        fields: {
+          newEntry: {
+            keyRaw: this.key,
+            type: "Connection",
+            selection: {
+              fields: {
+                edges: {
+                  keyRaw: "edges",
+                  type: "ConnectionEdge",
+                  updates: ["append", "prepend"],
+                  selection: {
+                    fields: {
+                      node: {
+                        type: listType,
+                        keyRaw: "node",
+                        selection: {
+                          ...selection2,
+                          fields: {
+                            ...selection2.fields,
+                            __typename: {
+                              keyRaw: "__typename",
+                              type: "String"
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+      insertData = {
+        newEntry: {
+          edges: [{ node: { ...data, __typename: listType } }]
+        }
+      };
+    } else {
+      insertSelection = {
+        fields: {
+          newEntries: {
+            keyRaw: this.key,
+            type: listType,
+            updates: ["append", "prepend"],
+            selection: {
+              ...selection2,
+              fields: {
+                ...selection2.fields,
+                __typename: {
+                  keyRaw: "__typename",
+                  type: "String"
+                }
+              }
+            }
+          }
+        }
+      };
+      insertData = {
+        newEntries: [{ ...data, __typename: listType }]
+      };
+    }
+    this.cache.write({
+      selection: insertSelection,
+      data: insertData,
+      variables,
+      parent: this.recordID,
+      applyUpdates: [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(selection2, data, variables = {}, where) {
+    if (!this.remove(data, variables)) {
+      this.addToList(selection2, data, variables, where);
+    }
+  }
+  *[Symbol.iterator]() {
+    let entries = [];
+    let value = this.cache._internal_unstable.storage.get(this.recordID, this.key).value;
+    if (!this.connection) {
+      entries = flatten(value);
+    } else {
+      entries = this.cache._internal_unstable.storage.get(value, "edges").value;
+    }
+    for (let record2 of entries) {
+      yield record2;
+    }
+  }
+};
+var ListCollection = class {
+  lists = [];
+  constructor(lists) {
+    this.lists = lists;
+  }
+  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 i = this.data.length - 1; i >= 0; i--) {
+      const layer = this.data[i];
+      const [layerValue, kind] = layer.get(id, field);
+      const layerOperations = layer.getOperations(id, field) || [];
+      layer.deletedIDs.forEach((v) => {
+        if (layer.operations[v]?.undoDeletesInList?.includes(field)) {
+          return;
+        }
+        operations.remove.add(v);
+      });
+      if (typeof layerValue === "undefined" && layerOperations.length === 0) {
+        if (layer.deletedIDs.size > 0) {
+          layerIDs.push(layer.id);
+        }
+        continue;
+      }
+      if (typeof layerValue !== "undefined" && !Array.isArray(layerValue)) {
+        return {
+          value: layerValue,
+          kind,
+          displayLayers: [layer.id]
+        };
+      }
+      layerIDs.push(layer.id);
+      if (layerOperations.length > 0) {
+        for (const op of layerOperations) {
+          if (isRemoveOperation(op)) {
+            operations.remove.add(op.id);
+          }
+          if (isInsertOperation(op)) {
+            operations.insert[op.location].unshift(op.id);
+          }
+          if (isDeleteOperation(op)) {
+            return {
+              value: void 0,
+              kind: "unknown",
+              displayLayers: []
+            };
+          }
+        }
+      }
+      if (typeof layerValue === "undefined") {
+        continue;
+      }
+      if (!operations.remove.size && !operations.insert.start.length && !operations.insert.end.length) {
+        return { value: layerValue, displayLayers: layerIDs, kind: "link" };
+      }
+      return {
+        value: [...operations.insert.start, ...layerValue, ...operations.insert.end].filter(
+          (value) => !operations.remove.has(value)
+        ),
+        displayLayers: layerIDs,
+        kind
+      };
+    }
+    return {
+      value: void 0,
+      kind: "unknown",
+      displayLayers: []
+    };
+  }
+  writeLink(id, field, value) {
+    return this.topLayer.writeLink(id, field, value);
+  }
+  writeField(id, field, value) {
+    return this.topLayer.writeField(id, field, value);
+  }
+  resolveLayer(id) {
+    let startingIndex = null;
+    for (const [index, layer] of this.data.entries()) {
+      if (layer.id !== id) {
+        continue;
+      }
+      startingIndex = index - 1;
+      this.data[index].optimistic = false;
+      break;
+    }
+    if (startingIndex === null) {
+      throw new Error("could not find layer with id: " + id);
+    }
+    if (startingIndex === -1) {
+      startingIndex = 0;
+    }
+    if (this.data[startingIndex].optimistic) {
+      startingIndex++;
+    }
+    const baseLayer = this.data[startingIndex];
+    let layerIndex = startingIndex;
+    while (layerIndex < this.data.length) {
+      const layer = this.data[layerIndex++];
+      if (layer.optimistic) {
+        layerIndex--;
+        break;
+      }
+      baseLayer.writeLayer(layer);
+    }
+    this.data.splice(startingIndex + 1, layerIndex - startingIndex - 1);
+  }
+  get topLayer() {
+    if (this.data.length === 0) {
+      this.createLayer();
+    }
+    if (this.data[this.data.length - 1]?.optimistic) {
+      this.createLayer();
+    }
+    return this.data[this.data.length - 1];
+  }
+};
+var Layer = class {
+  id;
+  optimistic = false;
+  fields = {};
+  links = {};
+  operations = {};
+  deletedIDs = /* @__PURE__ */ new Set();
+  constructor(id) {
+    this.id = id;
+  }
+  get(id, field) {
+    if (typeof this.links[id]?.[field] !== "undefined") {
+      return [this.links[id][field], "link"];
+    }
+    return [this.fields[id]?.[field], "scalar"];
+  }
+  getOperations(id, field) {
+    if (this.operations[id]?.deleted) {
+      return [
+        {
+          kind: OperationKind.delete,
+          target: id
+        }
+      ];
+    }
+    if (this.operations[id]?.fields?.[field]) {
+      return this.operations[id].fields[field];
+    }
+  }
+  writeField(id, field, value) {
+    this.fields[id] = {
+      ...this.fields[id],
+      [field]: value
+    };
+    return this.id;
+  }
+  writeLink(id, field, value) {
+    const valueList = Array.isArray(value) ? value : [value];
+    for (const value2 of 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: selection2,
+    variables,
+    parentType
+  }) {
+    const __typename = this.cache._internal_unstable.storage.get(parent, "__typename").value;
+    let targetSelection = getFieldsForType(selection2, __typename);
+    for (const fieldSelection of Object.values(targetSelection || {})) {
+      const { keyRaw, selection: innerSelection, type, 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: selection2,
+    type
+  }) {
+    const spec = selection2[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, selection2[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 } = selection2[1]?.[key] ?? {};
+  }
+  registerList({
+    list,
+    id,
+    key,
+    parentType,
+    selection: selection2,
+    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: selection2,
+      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 selection2 of Object.values(targetSelection ?? {})) {
+        const {
+          type: linkedType,
+          keyRaw,
+          selection: innerSelection,
+          list,
+          filters
+        } = selection2;
+        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 = selection2.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, selection2, targets, variables, visited = []) {
+    visited.push(id);
+    const linkedIDs = [];
+    const __typename = this.cache._internal_unstable.storage.get(id, "__typename").value;
+    let targetSelection = getFieldsForType(selection2, __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(config2) {
+    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 (config2) {
+      this.setConfig(defaultConfigValues(config2));
+    }
+  }
+  write({
+    layer: layerID,
+    notifySubscribers = [],
+    ...args
+  }) {
+    const layer = layerID ? this._internal_unstable.storage.getLayer(layerID) : this._internal_unstable.storage.topLayer;
+    const subscribers = this._internal_unstable.writeSelection({ ...args, layer }).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(config2) {
+    this._internal_unstable.setConfig(config2);
+  }
+  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(config2) {
+    this.config = config2;
+  }
+  writeSelection({
+    data,
+    selection: selection2,
+    variables = {},
+    parent = rootID,
+    applyUpdates,
+    layer,
+    toNotify = [],
+    forceNotify,
+    forceStale
+  }) {
+    if (this._disabled) {
+      return [];
+    }
+    let targetSelection = getFieldsForType(selection2, data["__typename"]);
+    for (const [field, value] of Object.entries(data)) {
+      if (!selection2 || !targetSelection[field]) {
+        throw new Error(
+          "Could not find field listing in selection for " + field + " @ " + JSON.stringify(selection2)
+        );
+      }
+      let {
+        type: linkedType,
+        keyRaw,
+        selection: fieldSelection,
+        operations,
+        abstract: isAbstract,
+        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: selection2,
+    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(selection2, typename);
+    for (const [
+      attributeName,
+      { type, keyRaw, selection: fieldSelection, nullable, list }
+    ] of Object.entries(targetSelection)) {
+      const key = evaluateKey(keyRaw, variables);
+      const { value } = this.storage.get(parent, key);
+      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 [i, entry] of value.entries()) {
+      if (Array.isArray(entry)) {
+        const inner = this.extractNestedListIDs({
+          value: entry,
+          abstract,
+          recordID,
+          key,
+          linkedType,
+          fields,
+          variables,
+          applyUpdates,
+          specs,
+          layer,
+          forceNotify
+        });
+        newIDs.push(...inner.newIDs);
+        nestedIDs[i] = inner.nestedIDs;
+        continue;
+      }
+      if (entry === null || typeof entry === "undefined") {
+        newIDs.push(null);
+        nestedIDs[i] = null;
+        continue;
+      }
+      const entryObj = entry;
+      let linkedID = `${recordID}.${key}[${this.storage.nextRank}]`;
+      const embedded = this.idFields(linkedType)?.filter(
+        (field) => typeof entry[field] === "undefined"
+      ).length > 0;
+      const typename = entryObj.__typename;
+      let innerType = linkedType;
+      if (abstract) {
+        if (!typename) {
+          throw new Error("Encountered interface type without __typename in the payload");
+        }
+        innerType = typename;
+      }
+      if (!embedded) {
+        const id = this.id(innerType, entry);
+        if (id) {
+          linkedID = id;
+        } else {
+          continue;
+        }
+      }
+      this.writeSelection({
+        root: rootID,
+        selection: fields,
+        parent: linkedID,
+        data: entryObj,
+        variables,
+        toNotify: specs,
+        applyUpdates,
+        layer,
+        forceNotify
+      });
+      newIDs.push(linkedID);
+      nestedIDs[i] = linkedID;
+    }
+    return { newIDs, nestedIDs };
+  }
+  collectGarbage() {
+    this.lifetimes.tick();
+    if (this.storage.layerCount === 1) {
+      this.storage.topLayer.removeUndefinedFields();
+    }
+  }
+};
+var rootID = "_ROOT_";
+
+// src/runtime/cache/index.ts
+var cache_default = new Cache();
+
+// 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, variablesChanged }) {
+      if (variablesChanged(ctx)) {
+        artifactName = ctx.artifact.name;
+        if (subscriptionSpec) {
+          cache_default.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() || {});
+        }
+        lastVariables = { ...marshalVariables(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 }) {
+      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: marshalVariables(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/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 currentDir = global.__dirname || dirname(fileURLToPath(import.meta.url));
@@ -54464,7 +56607,7 @@ var Config = class {
       scalars,
       cacheBufferSize,
       definitionsPath,
-      defaultCachePolicy = "CacheOrNetwork" /* CacheOrNetwork */,
+      defaultCachePolicy = CachePolicy.CacheOrNetwork,
       defaultPartial = false,
       defaultListPosition = "append",
       defaultListTarget = null,
@@ -54486,7 +56629,7 @@ var Config = class {
           Object.values(LogLevel)
         )}`
       );
-      logLevel = "summary" /* Summary */;
+      logLevel = LogLevel.Summary;
     }
     this.schemaPath = schemaPath;
     this.filepath = filepath;
@@ -54502,7 +56645,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 = join(this.projectRoot, "src", "routes");
     this.schemaPollInterval = watchSchema?.interval ?? 2e3;
@@ -54843,8 +56986,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);
@@ -54917,6 +57062,8 @@ function findModule(pkg = "houdini", currentLocation) {
   }
   return locationFound;
 }
+var emptySchema = graphql.buildSchema("type Query { hello: String }");
+var defaultDirectives = emptySchema.getDirectives().map((dir) => dir.name);
 
 // src/lib/graphql.ts
 var graphql2 = __toESM(require_graphql2(), 1);
@@ -54933,7 +57080,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 crypto.createHash("sha256").update(docString ?? "").digest("hex");
 }
 function parentTypeFromAncestors(schema, filepath, ancestors) {
@@ -55271,7 +57418,13 @@ var FieldCollection = class {
       if (fragment.selection.size === 0) {
         return [];
       }
-      fragment.astNode.selectionSet.selections = fragment.selection.toSelectionSet();
+      fragment.astNode = {
+        ...fragment.astNode,
+        selectionSet: {
+          ...fragment.astNode.selectionSet,
+          selections: fragment.selection.toSelectionSet()
+        }
+      };
       return [fragment.astNode];
     }).concat(
       Object.values(this.fields).map((field) => {
@@ -55495,7 +57648,7 @@ async function fragmentVariables(config2, documents) {
   };
   documents.push({
     name: "generated::fragmentVariables",
-    kind: "HoudiniFragment" /* Fragment */,
+    kind: ArtifactKind.Fragment,
     document: doc,
     originalParsed: doc,
     generateStore: false,
@@ -56416,7 +58569,7 @@ async function paginate(config2, documents) {
         ]
       };
       newDocs.push({
-        kind: "HoudiniQuery" /* Query */,
+        kind: ArtifactKind.Query,
         filename: doc.filename,
         name: refetchQueryName,
         document: queryDoc,
@@ -56836,7 +58989,7 @@ async function addListFragments(config2, documents) {
   config2.newDocuments += "\n" + generatedDoc.definitions.filter((c) => c.kind === "FragmentDefinition").map(graphql9.print).join("\n\n");
   documents.push({
     name: "generated::lists",
-    kind: "HoudiniFragment" /* Fragment */,
+    kind: ArtifactKind.Fragment,
     generateArtifact: false,
     generateStore: false,
     document: generatedDoc,
@@ -57103,7 +59256,7 @@ function selection({
         (directive) => directive.name.value === config2.paginateDirective
       );
       if (paginated && document.refetch && document.refetch.method === "offset") {
-        fieldObj.updates = ["append" /* append */];
+        fieldObj.updates = [RefetchUpdateMode.append];
       }
       let continueConnection = inConnection;
       if ([
@@ -57113,7 +59266,7 @@ function selection({
         "hasNextPage",
         "hasPreviousPage"
       ].includes(attributeName) && inConnection && document.refetch) {
-        fieldObj.updates = ["append" /* append */, "prepend" /* prepend */];
+        fieldObj.updates = [RefetchUpdateMode.append, RefetchUpdateMode.prepend];
       }
       if (attributeName === "node" && inConnection) {
         continueConnection = false;
@@ -57292,7 +59445,7 @@ function artifactGenerator(stats) {
           );
           let rootType = "";
           let selectionSet;
-          if (docKind !== "HoudiniFragment" /* Fragment */) {
+          if (docKind !== ArtifactKind.Fragment) {
             const operation = operations[0];
             if (operation.operation === "query") {
               rootType = config2.schema.getQueryType()?.name;
@@ -57325,7 +59478,7 @@ function artifactGenerator(stats) {
           let directive = fragments[0]?.directives?.find(
             (directive2) => directive2.name.value === config2.argumentsDirective
           );
-          if (docKind === "HoudiniFragment" /* Fragment */ && directive) {
+          if (docKind === ArtifactKind.Fragment && directive) {
             inputs = fragmentArgumentsDefinitions(config2, doc.filename, fragments[0]);
           }
           const mergedSelection = flattenSelections({
@@ -57366,22 +59519,12 @@ function artifactGenerator(stats) {
               document: doc
             })
           };
-          const plugin_data = config2.plugins.reduce(
-            (prev, plugin2) => {
-              if (!plugin2.artifactData) {
-                return prev;
-              }
-              const result = { ...prev };
-              const dataToAdd = plugin2.artifactData({ config: config2, document: doc }) ?? {};
-              if (Object.keys(dataToAdd).length > 0) {
-                result[plugin2.name] = dataToAdd;
-              }
-              return result;
-            },
-            {}
-          );
-          if (Object.keys(plugin_data).length > 0) {
-            artifact.plugin_data = plugin_data;
+          artifact.pluginData = {};
+          for (const plugin2 of config2.plugins) {
+            if (!plugin2.artifactData) {
+              continue;
+            }
+            artifact.pluginData[plugin2.name] = plugin2.artifactData({ config: config2, document: doc }) ?? {};
           }
           if (inputs && inputs.length > 0) {
             artifact.input = inputObject(config2, inputs);
@@ -57442,7 +59585,7 @@ function artifactGenerator(stats) {
             return;
           }
           const match = existingArtifact && existingArtifact.match(/"HoudiniHash=(\w+)"/);
-          if (match && match[1] !== hash({ config: config2, document: doc })) {
+          if (match && match[1] !== artifact.hash) {
             stats.changed.push(artifact.name);
           }
           stats.total.push(artifact.name);
@@ -57555,6 +59698,30 @@ async function generatePluginIndex({
   ]);
 }
 
+// src/codegen/generators/runtime/runtimeConfig.ts
+async function injectConfig({
+  config: config2,
+  content,
+  importStatement,
+  exportStatement
+}) {
+  const extraConfigs = config2.plugins.reduce((acc, plugin2) => {
+    if (!plugin2.config) {
+      return acc;
+    }
+    return [...acc, plugin2.config];
+  }, []);
+  return extraConfigs.length > 0 ? `
+${extraConfigs.map((plugin2, i) => importStatement(plugin2, `plugin${i}`))}
+
+const plugins = [
+	${extraConfigs.map((_, i) => `plugin${i}`).join(",\n")}
+]
+
+${exportStatement("plugins")}
+				` : content;
+}
+
 // src/codegen/generators/runtime/index.ts
 async function runtimeGenerator(config2, docs) {
   const importStatement = config2.module === "commonjs" ? importDefaultFrom : (where, as) => `import ${as} from '${where}'`;
@@ -57565,6 +59732,9 @@ async function runtimeGenerator(config2, docs) {
       [path_exports.join(config2.runtimeSource, "lib", "constants.js")]: (content) => {
         return content.replace("SITE_URL", siteURL);
       },
+      [path_exports.join(config2.runtimeSource, "imports", "pluginConfig.js")]: (content) => {
+        return injectConfig({ config: config2, importStatement, exportStatement, content });
+      },
       [path_exports.join(config2.runtimeSource, "imports", "config.js")]: (content) => {
         const configFilePath = path_exports.join(config2.runtimeDirectory, "imports", "config.js");
         const relativePath = path_exports.relative(path_exports.dirname(configFilePath), config2.filepath);
@@ -58622,7 +60792,7 @@ function listDefinitions(config2, body, docs) {
 function queryDefinitions(config2, body, docs, returnType) {
   return AST12.tsTupleType(
     docs.reduce((prev, doc) => {
-      if (doc.kind !== "HoudiniQuery" /* Query */ || !doc.generateStore) {
+      if (doc.kind !== ArtifactKind.Query || !doc.generateStore) {
         return prev;
       }
       const definition = doc.document.definitions.find(
@@ -58653,7 +60823,7 @@ function queryDefinitions(config2, body, docs, returnType) {
 }
 function fragmentListMap(config2, concreteTypes, body, docs, return_type) {
   return docs.reduce((prev, doc) => {
-    if (doc.kind !== "HoudiniFragment" /* Fragment */) {
+    if (doc.kind !== ArtifactKind.Fragment) {
       return prev;
     }
     const definition = doc.document.definitions.find(
@@ -58792,13 +60962,19 @@ async function definitionsGenerator(config2) {
       })
     )
   ).code;
-  const typeDefinitions2 = enums.sort((a, b) => a.name.value.localeCompare(b.name.value)).map(
-    (definition) => `
-export const ${definition.name.value} = {
-${definition.values?.map((value) => `    ${value.name.value}: "${value.name.value}"`).join(",\n")}
-} as const
- `
-  ).join("");
+  const typeDefinitions2 = `
+type ValuesOf<T> = T[keyof T]
+	` + enums.sort((a, b) => a.name.value.localeCompare(b.name.value)).map((definition) => {
+    const name = definition.name.value;
+    const values = definition.values;
+    return `
+export declare const ${name}: {
+${values?.map((value) => `    readonly ${value.name.value}: "${value.name.value}";`).join("\n")}
+}
+
+export type ${name}$options = ValuesOf<typeof ${name}>
+ `;
+  }).join("");
   const definitionsIndex = `
 export * from './enums.js'
 	`;
@@ -58864,10 +61040,10 @@ var graphql20 = __toESM(require_graphql2(), 1);
 async function graphqlExtensions(config2, documents) {
   let internalSchema = `
 enum CachePolicy {
-	${"CacheAndNetwork" /* CacheAndNetwork */}
-	${"CacheOnly" /* CacheOnly */}
-	${"CacheOrNetwork" /* CacheOrNetwork */}
-	${"NetworkOnly" /* NetworkOnly */}
+	${CachePolicy.CacheAndNetwork}
+	${CachePolicy.CacheOnly}
+	${CachePolicy.CacheOrNetwork}
+	${CachePolicy.NetworkOnly}
 }
 
 """
@@ -59783,7 +61959,7 @@ function getAndVerifyNodeInterface(config2) {
 var nbInvalidNodeFieldMessageDisplayed = 0;
 function displayInvalidNodeFieldMessage(logLevel) {
   if (nbInvalidNodeFieldMessageDisplayed === 0) {
-    if (logLevel === "full" /* Full */) {
+    if (logLevel === LogLevel.Full) {
       console.warn(invalidNodeFieldMessage);
     } else {
       console.warn(invalidNodeFieldMessageLight);
@@ -59947,7 +62123,7 @@ async function runPipeline2(config2, docs) {
   }
   const unchanged = artifactStats.total.length - artifactStats.changed.length - artifactStats.new.length - artifactStats.deleted.length;
   const printMessage = !config2.pluginMode || unchanged !== artifactStats.total.length;
-  if (!printMessage || config2.logLevel === "quiet" /* Quiet */) {
+  if (!printMessage || config2.logLevel === LogLevel.Quiet) {
     if (error) {
       throw error;
     }
@@ -59961,14 +62137,14 @@ async function runPipeline2(config2, docs) {
   }
   if (artifactStats.total.length === 0) {
     console.log(`\u{1F4A1} No operation found. If that's unexpected, please check your config.`);
-  } else if (["summary" /* Summary */, "short-summary" /* ShortSummary */].includes(config2.logLevel)) {
+  } else if (config2.logLevel == LogLevel.Summary || config2.logLevel == LogLevel.ShortSummary) {
     if (unchanged > 0 && printMessage && !config2.pluginMode) {
       console.log(`\u{1F4C3} Unchanged: ${unchanged}`);
     }
     logStyled("CREATED", artifactStats.new, config2.logLevel, config2.pluginMode);
     logStyled("UPDATED", artifactStats.changed, config2.logLevel, config2.pluginMode);
     logStyled("DELETED", artifactStats.deleted, config2.logLevel, config2.pluginMode);
-  } else if (config2.logLevel === "full" /* Full */) {
+  } else if (config2.logLevel === LogLevel.Full) {
     for (const artifact of artifactStats.total) {
       let emoji = "\u{1F4C3}";
       if (artifactStats.changed.includes(artifact)) {
@@ -60012,7 +62188,7 @@ function logStyled(kind, stat2, logLevel, plugin2) {
       }
     }
     console.log(msg.join(""));
-    if (!plugin2 && logLevel === "summary" /* Summary */) {
+    if (!plugin2 && logLevel === LogLevel.Summary) {
       for (const artifact of stat2.slice(0, nbToDisplay)) {
         console.log(`    ${artifact}`);
       }
@@ -60291,18 +62467,18 @@ function pipelineTest(config2, documents, shouldPass, testBody) {
     }
   };
 }
-function mockCollectedDoc(query) {
-  const parsed = graphql25.parse(query);
+function mockCollectedDoc(query2) {
+  const parsed = graphql25.parse(query2);
   const name = parsed.definitions[0].name.value;
   const operations = parsed.definitions;
-  let kind = "HoudiniFragment" /* Fragment */;
+  let kind = ArtifactKind.Fragment;
   if (operations.length === 1) {
     if (operations[0].kind === "OperationDefinition" && operations[0].operation === "query") {
-      kind = "HoudiniQuery" /* Query */;
+      kind = ArtifactKind.Query;
     } else if (operations[0].kind === "OperationDefinition" && operations[0].operation === "mutation") {
-      kind = "HoudiniMutation" /* Mutation */;
+      kind = ArtifactKind.Mutation;
     } else if (operations[0].kind === "OperationDefinition" && operations[0].operation === "subscription") {
-      kind = "HoudiniSubscription" /* Subscription */;
+      kind = ArtifactKind.Subscription;
     }
   }
   return {
@@ -60313,7 +62489,7 @@ function mockCollectedDoc(query) {
     filename: `${name}.ts`,
     generateArtifact: true,
     generateStore: true,
-    originalString: query,
+    originalString: query2,
     artifact: null
   };
 }