houdini 1.0.0-next.2 → 1.0.0-next.4

package/build/vite-cjs/index.js

@@ -66722,8 +66722,7 @@ var Config = class {
       types: types17 = {},
       logLevel,
       defaultFragmentMasking = "enable",
-      schemaPollInterval = 2e3,
-      schemaPollHeaders = {},
+      watchSchema,
       projectDir
     } = this.configFile;
     if (typeof schema === "string") {
@@ -66756,8 +66755,8 @@ var Config = class {
     this.logLevel = (logLevel || LogLevel.Summary).toLowerCase();
     this.defaultFragmentMasking = defaultFragmentMasking;
     this.routesDir = join2(this.projectRoot, "src", "routes");
-    this.schemaPollInterval = schemaPollInterval;
-    this.schemaPollHeaders = schemaPollHeaders;
+    this.schemaPollInterval = watchSchema?.interval ?? 2e3;
+    this.schemaPollHeaders = watchSchema?.headers ?? {};
     this.rootDir = join2(this.projectRoot, "$houdini");
     if (defaultKeys) {
       this.defaultKeys = defaultKeys;
@@ -66770,11 +66769,12 @@ var Config = class {
     }
   }
   async apiURL() {
-    if (!this.configFile.apiUrl) {
+    const apiURL = this.configFile.watchSchema?.url;
+    if (!apiURL) {
       return "";
     }
     const env = await this.getEnv();
-    return this.processEnvValues(env, this.configFile.apiUrl);
+    return this.processEnvValues(env, apiURL);
   }
   get include() {
     if (this.configFile.include) {
@@ -66978,8 +66978,8 @@ var Config = class {
   pluginDirectory(name2) {
     return join2(this.pluginRootDirectory, name2);
   }
-  get manualLoadDirective() {
-    return "manual_load";
+  get loadDirective() {
+    return "load";
   }
   get maskEnableDirective() {
     return "mask_enable";
@@ -67096,7 +67096,7 @@ var Config = class {
       this.withDirective,
       this.paginateDirective,
       this.cacheDirective,
-      this.manualLoadDirective,
+      this.loadDirective,
       this.maskEnableDirective,
       this.maskDisableDirective
     ].includes(name2.value) || this.isDeleteDirective(name2.value);
@@ -67681,7 +67681,7 @@ async function find_graphql(config4, parsedScript, walker) {
         return;
       }
       const parsedTag = graphql4.parse(documentString);
-      if (walker.where && !walker.where(parsedTag)) {
+      if (walker.where && !walker.where(parsedTag, { node, parent })) {
         return;
       }
       const definition = config4.extractDefinition(parsedTag);
@@ -67722,7 +67722,7 @@ async function find_graphql(config4, parsedScript, walker) {
 }
 
 // src/codegen/generators/artifacts/index.ts
-var graphql13 = __toESM(require_graphql2(), 1);
+var graphql14 = __toESM(require_graphql2(), 1);
 var recast5 = __toESM(require_main2(), 1);
 
 // src/codegen/utils/commonjs.ts
@@ -67980,159 +67980,534 @@ function murmurHash(str) {
   return s2;
 }
 
-// src/codegen/generators/artifacts/indexFile.ts
-async function writeIndexFile(config4, docs) {
-  const docsToGenerate = docs.filter((doc) => doc.generateArtifact).sort((a, b) => a.name.localeCompare(b.name));
-  let body = config4.module === "esm" ? docsToGenerate.reduce(
-    (content, doc) => content + `
- export { default as ${doc.name}} from './${doc.name}'`,
-    ""
-  ) : docsToGenerate.reduce(
-    (content, doc) => content + `
-${exportDefaultFrom(`./${doc.name}`, doc.name)}`,
-    cjsIndexFilePreamble
-  );
-  await fs_exports.writeFile(path_exports.join(config4.artifactDirectory, "index.js"), body);
-}
-
-// src/codegen/generators/artifacts/inputs.ts
+// src/codegen/transforms/fragmentVariables.ts
 var graphql5 = __toESM(require_graphql2(), 1);
-var recast3 = __toESM(require_main2(), 1);
-var AST3 = recast3.types.builders;
-function inputObject(config4, inputs) {
-  const visitedTypes = /* @__PURE__ */ new Set();
-  const inputObj = {
-    fields: inputs.reduce((fields, input) => {
-      const { type } = unwrapType(config4, input.type);
-      return {
-        ...fields,
-        [input.variable.name.value]: type.name
-      };
-    }, {}),
-    types: {}
-  };
-  for (const input of inputs) {
-    walkInputs(config4, visitedTypes, inputObj, input.type);
-  }
-  return inputObj;
-}
-function walkInputs(config4, visitedTypes, inputObj, rootType) {
-  const { type } = unwrapType(config4, rootType);
-  if (visitedTypes.has(type.name)) {
-    return;
-  }
-  if (graphql5.isEnumType(type) || graphql5.isScalarType(type)) {
-    return;
-  }
-  if (graphql5.isUnionType(type)) {
-    return;
-  }
-  visitedTypes.add(type.name);
-  inputObj.types[type.name] = Object.values(type.getFields()).reduce(
-    (typeFields, field) => {
-      const { type: fieldType } = unwrapType(config4, field.type);
-      walkInputs(config4, visitedTypes, inputObj, fieldType);
-      return {
-        ...typeFields,
-        [field.name]: fieldType.toString()
-      };
-    },
-    {}
-  );
-}
 
-// src/codegen/generators/artifacts/operations.ts
-var graphql7 = __toESM(require_graphql2(), 1);
-
-// src/codegen/generators/artifacts/utils.ts
-var graphql6 = __toESM(require_graphql2(), 1);
-var recast4 = __toESM(require_main2(), 1);
-var AST4 = recast4.types.builders;
-function serializeValue(value) {
-  if (Array.isArray(value)) {
-    return AST4.arrayExpression(value.map(serializeValue));
+// src/codegen/transforms/composeQueries.ts
+var import_graphql30 = __toESM(require_graphql2(), 1);
+async function includeFragmentDefinitions(config4, documents) {
+  const fragments = collectFragments(config4, documents);
+  for (const [index, { name: name2, document, filename }] of documents.entries()) {
+    const operation = document.definitions.find(
+      ({ kind }) => kind === import_graphql30.Kind.OPERATION_DEFINITION
+    );
+    if (!operation) {
+      continue;
+    }
+    const allFragments = flattenFragments(
+      filename,
+      { requiredFragments: findRequiredFragments(operation.selectionSet) },
+      fragments
+    );
+    documents[index].document = {
+      ...document,
+      definitions: [
+        operation,
+        ...allFragments.map((fragmentName) => fragments[fragmentName].definition)
+      ]
+    };
   }
-  if (typeof value === "object" && value !== null) {
-    return AST4.objectExpression(
-      Object.entries(value).filter(([, value2]) => typeof value2 !== "undefined").map(
-        ([key, value2]) => AST4.objectProperty(AST4.stringLiteral(key), serializeValue(value2))
-      )
+}
+function collectFragments(config4, docs) {
+  return docs.reduce((acc, doc) => {
+    const definitions = doc.document.definitions.reduce(
+      (prev, definition) => definition.kind !== "FragmentDefinition" ? prev : {
+        ...prev,
+        [definition.name.value]: {
+          definition,
+          requiredFragments: findRequiredFragments(definition.selectionSet),
+          document: doc
+        }
+      },
+      {}
     );
+    return {
+      ...acc,
+      ...definitions
+    };
+  }, {});
+}
+function findRequiredFragments(selectionSet) {
+  if (selectionSet.selections.length === 0) {
+    return [];
   }
-  if (typeof value === "string") {
-    if (value.indexOf("\n") !== -1) {
-      return AST4.templateLiteral(
-        [AST4.templateElement({ raw: value, cooked: value }, true)],
-        []
-      );
+  const referencedFragments = [];
+  for (const selection2 of selectionSet.selections) {
+    if (selection2.kind === import_graphql30.Kind.FRAGMENT_SPREAD) {
+      referencedFragments.push(selection2.name.value);
+    } else if (selection2.selectionSet) {
+      referencedFragments.push(...findRequiredFragments(selection2.selectionSet));
     }
-    return AST4.stringLiteral(value);
   }
-  return AST4.literal(value);
+  return referencedFragments;
 }
-function deepMerge(filepath, ...targets) {
-  if (typeof targets[0] !== "object") {
-    const matches = targets.filter((val) => val !== targets[0]).length === 0;
-    if (!matches) {
-      throw new HoudiniError({ filepath, message: "could not merge: " + targets });
+function flattenFragments(filepath, operation, fragments) {
+  const frags = /* @__PURE__ */ new Set();
+  const remaining = [...operation.requiredFragments];
+  while (remaining.length > 0) {
+    const nextFragment = remaining.shift();
+    if (!nextFragment) {
+      continue;
     }
-    return targets[0];
-  }
-  if (Array.isArray(targets[0])) {
-    return targets[0].concat(...targets.slice(1));
-  }
-  const fields = {};
-  for (const target of targets) {
-    for (const [key, value] of Object.entries(target)) {
-      if (!fields[key]) {
-        fields[key] = [];
-      }
-      fields[key].push(value);
+    if (!frags.has(nextFragment)) {
+      frags.add(nextFragment);
+    } else {
+      continue;
+    }
+    const targetFragment = fragments[nextFragment];
+    if (!targetFragment) {
+      throw new HoudiniError({
+        filepath,
+        message: "compose: could not find definition for fragment " + nextFragment
+      });
     }
+    remaining.push(...targetFragment.requiredFragments);
   }
-  return Object.fromEntries(
-    Object.entries(fields).map(([key, value]) => [key, deepMerge(filepath, ...value)])
-  );
+  return [...frags];
 }
-function convertValue(config4, val) {
-  let value;
-  let kind;
-  if (val.kind === graphql6.Kind.INT) {
-    value = parseInt(val.value, 10);
-    kind = "Int";
-  } else if (val.kind === graphql6.Kind.FLOAT) {
-    value = parseFloat(val.value);
-    kind = "Float";
-  } else if (val.kind === graphql6.Kind.BOOLEAN) {
-    value = val.value;
-    kind = "Boolean";
-  } else if (val.kind === graphql6.Kind.VARIABLE) {
-    value = val.name.value;
-    kind = "Variable";
-  } else if (val.kind === graphql6.Kind.STRING) {
-    value = val.value;
-    kind = "String";
+
+// src/codegen/transforms/fragmentVariables.ts
+var GraphqlKinds2 = graphql5.Kind;
+async function fragmentVariables(config4, documents) {
+  const fragments = collectFragments(config4, documents);
+  const generatedFragments = {};
+  const visitedFragments = /* @__PURE__ */ new Set();
+  for (const doc2 of documents) {
+    const operation = doc2.document.definitions.find(
+      ({ kind }) => kind === GraphqlKinds2.OPERATION_DEFINITION
+    );
+    if (!operation) {
+      continue;
+    }
+    doc2.document = inlineFragmentArgs({
+      config: config4,
+      filepath: doc2.filename,
+      fragmentDefinitions: fragments,
+      document: doc2.document,
+      generatedFragments,
+      visitedFragments,
+      scope: null
+    });
   }
-  return { kind, value };
+  const doc = {
+    kind: graphql5.Kind.DOCUMENT,
+    definitions: Object.values(generatedFragments)
+  };
+  documents.push({
+    name: "generated::fragmentVariables",
+    kind: "HoudiniFragment" /* Fragment */,
+    document: doc,
+    originalDocument: doc,
+    generateStore: false,
+    generateArtifact: false,
+    filename: "generated::fragmentVariables",
+    originalString: ""
+  });
 }
-
-// src/codegen/generators/artifacts/operations.ts
-function operationsByPath(config4, filepath, definition, filterTypes) {
-  if (!definition) {
-    return {};
+function inlineFragmentArgs({
+  config: config4,
+  filepath,
+  fragmentDefinitions,
+  document,
+  generatedFragments,
+  visitedFragments,
+  scope,
+  newName
+}) {
+  if (!scope) {
+    scope = operationScope(
+      document.definitions.find(
+        ({ kind }) => kind === GraphqlKinds2.OPERATION_DEFINITION
+      )
+    );
   }
-  const pathOperations = {};
-  graphql7.visit(definition, {
-    FragmentSpread(node, _, __, ___, ancestors) {
-      if (!config4.isListFragment(node.name.value)) {
-        return;
-      }
-      const path2 = ancestorKey(ancestors);
-      if (!pathOperations[path2]) {
-        pathOperations[path2] = [];
-      }
-      pathOperations[path2].push(
-        operationObject({
+  const definitionArgs = fragmentArguments(
+    config4,
+    filepath,
+    document
+  ).reduce((acc, arg) => ({ ...acc, [arg.name]: arg }), {});
+  const result = graphql5.visit(document, {
+    FragmentSpread(node) {
+      const { definition } = fragmentDefinitions[node.name.value];
+      let { args, hash } = collectWithArguments(config4, filepath, node, scope);
+      const newFragmentName = `${node.name.value}${hash}`;
+      if (!visitedFragments.has(newFragmentName)) {
+        visitedFragments.add(newFragmentName);
+        const defaultArguments = collectDefaultArgumentValues(config4, filepath, definition);
+        if (args) {
+          for (const [field, value] of Object.entries(defaultArguments || {})) {
+            if (!args[field]) {
+              args[field] = value;
+            }
+          }
+          generatedFragments[newFragmentName] = inlineFragmentArgs({
+            config: config4,
+            filepath,
+            fragmentDefinitions,
+            document: fragmentDefinitions[node.name.value].definition,
+            generatedFragments,
+            visitedFragments,
+            scope: args,
+            newName: newFragmentName
+          });
+        } else {
+          const doc = fragmentDefinitions[node.name.value].document;
+          const definitionIndex = doc.document.definitions.findIndex(
+            (definition2) => definition2.kind === "FragmentDefinition" && definition2.name.value === node.name.value
+          );
+          const localDefinitions = [...doc.document.definitions];
+          localDefinitions.splice(definitionIndex, 1);
+          localDefinitions.push(
+            inlineFragmentArgs({
+              config: config4,
+              filepath,
+              fragmentDefinitions,
+              document: fragmentDefinitions[node.name.value].definition,
+              generatedFragments,
+              visitedFragments,
+              scope: defaultArguments,
+              newName: ""
+            })
+          );
+          doc.document = {
+            ...doc.document,
+            definitions: localDefinitions
+          };
+        }
+        if (node.name.value !== newFragmentName) {
+          return {
+            ...node,
+            name: {
+              kind: "Name",
+              value: newFragmentName
+            }
+          };
+        }
+      }
+    },
+    Argument(node) {
+      const value = node.value;
+      if (value.kind !== "Variable") {
+        return;
+      }
+      if (!scope) {
+        throw new HoudiniError({
+          filepath,
+          message: node.name.value + " is not defined in the current scope: " + JSON.stringify(scope)
+        });
+      }
+      const newValue = scope[value.name.value];
+      if (newValue) {
+        return {
+          ...node,
+          value: newValue
+        };
+      }
+      if (definitionArgs[value.name.value] && definitionArgs[value.name.value].required) {
+        throw new HoudiniError({
+          filepath,
+          message: "Missing value for required arg: " + value.name.value
+        });
+      }
+      return null;
+    }
+  });
+  if (newName) {
+    result.name = {
+      kind: graphql5.Kind.NAME,
+      value: newName
+    };
+  }
+  return result;
+}
+function withArguments(config4, node) {
+  const withDirectives = node.directives?.filter(
+    (directive) => directive.name.value === config4.withDirective
+  );
+  if (!withDirectives || withDirectives.length === 0) {
+    return [];
+  }
+  return withDirectives.flatMap((directive) => directive.arguments || []);
+}
+function fragmentArguments(config4, filepath, definition) {
+  const directives = definition.directives?.filter(
+    (directive) => directive.name.value === config4.argumentsDirective
+  );
+  if (!directives || directives.length === 0) {
+    return [];
+  }
+  return directives.flatMap(
+    (directive) => directive.arguments?.flatMap((arg) => {
+      if (arg.value.kind !== "ObjectValue") {
+        throw new HoudiniError({
+          filepath,
+          message: "values of @argument must be objects"
+        });
+      }
+      const typeArg = arg.value.fields?.find((arg2) => arg2.name.value === "type")?.value;
+      if (!typeArg || typeArg.kind !== "StringValue") {
+        return [];
+      }
+      let type = typeArg.value;
+      let name2 = arg.name.value;
+      let required = false;
+      let defaultValue = arg.value.fields?.find((arg2) => arg2.name.value === "default")?.value || null;
+      if (type[type.length - 1] === "!") {
+        type = type.slice(0, -1);
+        required = true;
+        defaultValue = null;
+      }
+      return [
+        {
+          name: name2,
+          type,
+          required,
+          defaultValue
+        }
+      ];
+    }) || []
+  );
+}
+function collectDefaultArgumentValues(config4, filepath, definition) {
+  let result = {};
+  for (const { name: name2, required, defaultValue } of fragmentArguments(
+    config4,
+    filepath,
+    definition
+  )) {
+    if (required || !defaultValue) {
+      continue;
+    }
+    result[name2] = defaultValue;
+  }
+  return result;
+}
+function collectWithArguments(config4, filepath, node, scope = {}) {
+  const withArgs = withArguments(config4, node);
+  if (withArgs.length === 0) {
+    return { args: null, hash: "" };
+  }
+  let args = {};
+  for (const arg of withArgs) {
+    let value = arg.value;
+    if (value.kind === GraphqlKinds2.VARIABLE) {
+      if (!scope || !scope[value.name.value]) {
+        throw new HoudiniError({
+          filepath,
+          message: "Encountered undefined variable: " + value.name.value
+        });
+      }
+      value = scope[value.name.value];
+    }
+    args[arg.name.value] = {
+      ...value,
+      loc: void 0
+    };
+  }
+  return {
+    args,
+    hash: "_" + murmurHash(JSON.stringify(args))
+  };
+}
+function operationScope(operation) {
+  return operation.variableDefinitions?.reduce(
+    (scope, definition) => ({
+      ...scope,
+      [definition.variable.name.value]: {
+        kind: "Variable",
+        name: {
+          kind: "Name",
+          value: definition.variable.name.value
+        }
+      }
+    }),
+    {}
+  ) || {};
+}
+function fragmentArgumentsDefinitions(config4, filepath, definition) {
+  const args = fragmentArguments(config4, filepath, definition);
+  if (args.length === 0) {
+    return [];
+  }
+  return args.map((arg) => {
+    const innerType = {
+      kind: "NamedType",
+      name: {
+        kind: "Name",
+        value: arg.type
+      }
+    };
+    return {
+      kind: "VariableDefinition",
+      type: arg.required ? innerType : {
+        kind: "NonNullType",
+        type: innerType
+      },
+      variable: {
+        kind: "Variable",
+        name: {
+          kind: "Name",
+          value: arg.name
+        }
+      },
+      defaultValue: arg.defaultValue ?? void 0
+    };
+  });
+}
+
+// src/codegen/generators/artifacts/indexFile.ts
+async function writeIndexFile(config4, docs) {
+  const docsToGenerate = docs.filter((doc) => doc.generateArtifact).sort((a, b) => a.name.localeCompare(b.name));
+  let body = config4.module === "esm" ? docsToGenerate.reduce(
+    (content, doc) => content + `
+ export { default as ${doc.name}} from './${doc.name}'`,
+    ""
+  ) : docsToGenerate.reduce(
+    (content, doc) => content + `
+${exportDefaultFrom(`./${doc.name}`, doc.name)}`,
+    cjsIndexFilePreamble
+  );
+  await fs_exports.writeFile(path_exports.join(config4.artifactDirectory, "index.js"), body);
+}
+
+// src/codegen/generators/artifacts/inputs.ts
+var graphql6 = __toESM(require_graphql2(), 1);
+var recast3 = __toESM(require_main2(), 1);
+var AST3 = recast3.types.builders;
+function inputObject(config4, inputs) {
+  const visitedTypes = /* @__PURE__ */ new Set();
+  const inputObj = {
+    fields: inputs.reduce((fields, input) => {
+      const { type } = unwrapType(config4, input.type);
+      return {
+        ...fields,
+        [input.variable.name.value]: type.name
+      };
+    }, {}),
+    types: {}
+  };
+  for (const input of inputs) {
+    walkInputs(config4, visitedTypes, inputObj, input.type);
+  }
+  return inputObj;
+}
+function walkInputs(config4, visitedTypes, inputObj, rootType) {
+  const { type } = unwrapType(config4, rootType);
+  if (visitedTypes.has(type.name)) {
+    return;
+  }
+  if (graphql6.isEnumType(type) || graphql6.isScalarType(type)) {
+    return;
+  }
+  if (graphql6.isUnionType(type)) {
+    return;
+  }
+  visitedTypes.add(type.name);
+  inputObj.types[type.name] = Object.values(type.getFields()).reduce(
+    (typeFields, field) => {
+      const { type: fieldType } = unwrapType(config4, field.type);
+      walkInputs(config4, visitedTypes, inputObj, fieldType);
+      return {
+        ...typeFields,
+        [field.name]: fieldType.toString()
+      };
+    },
+    {}
+  );
+}
+
+// src/codegen/generators/artifacts/operations.ts
+var graphql8 = __toESM(require_graphql2(), 1);
+
+// src/codegen/generators/artifacts/utils.ts
+var graphql7 = __toESM(require_graphql2(), 1);
+var recast4 = __toESM(require_main2(), 1);
+var AST4 = recast4.types.builders;
+function serializeValue(value) {
+  if (Array.isArray(value)) {
+    return AST4.arrayExpression(value.map(serializeValue));
+  }
+  if (typeof value === "object" && value !== null) {
+    return AST4.objectExpression(
+      Object.entries(value).filter(([, value2]) => typeof value2 !== "undefined").map(
+        ([key, value2]) => AST4.objectProperty(AST4.stringLiteral(key), serializeValue(value2))
+      )
+    );
+  }
+  if (typeof value === "string") {
+    if (value.indexOf("\n") !== -1) {
+      return AST4.templateLiteral(
+        [AST4.templateElement({ raw: value, cooked: value }, true)],
+        []
+      );
+    }
+    return AST4.stringLiteral(value);
+  }
+  return AST4.literal(value);
+}
+function deepMerge(filepath, ...targets) {
+  if (typeof targets[0] !== "object") {
+    const matches = targets.filter((val) => val !== targets[0]).length === 0;
+    if (!matches) {
+      throw new HoudiniError({ filepath, message: "could not merge: " + targets });
+    }
+    return targets[0];
+  }
+  if (Array.isArray(targets[0])) {
+    return targets[0].concat(...targets.slice(1));
+  }
+  const fields = {};
+  for (const target of targets) {
+    for (const [key, value] of Object.entries(target)) {
+      if (!fields[key]) {
+        fields[key] = [];
+      }
+      fields[key].push(value);
+    }
+  }
+  return Object.fromEntries(
+    Object.entries(fields).map(([key, value]) => [key, deepMerge(filepath, ...value)])
+  );
+}
+function convertValue(config4, val) {
+  let value;
+  let kind;
+  if (val.kind === graphql7.Kind.INT) {
+    value = parseInt(val.value, 10);
+    kind = "Int";
+  } else if (val.kind === graphql7.Kind.FLOAT) {
+    value = parseFloat(val.value);
+    kind = "Float";
+  } else if (val.kind === graphql7.Kind.BOOLEAN) {
+    value = val.value;
+    kind = "Boolean";
+  } else if (val.kind === graphql7.Kind.VARIABLE) {
+    value = val.name.value;
+    kind = "Variable";
+  } else if (val.kind === graphql7.Kind.STRING) {
+    value = val.value;
+    kind = "String";
+  }
+  return { kind, value };
+}
+
+// src/codegen/generators/artifacts/operations.ts
+function operationsByPath(config4, filepath, definition, filterTypes) {
+  if (!definition) {
+    return {};
+  }
+  const pathOperations = {};
+  graphql8.visit(definition, {
+    FragmentSpread(node, _, __, ___, ancestors) {
+      if (!config4.isListFragment(node.name.value)) {
+        return;
+      }
+      const path2 = ancestorKey(ancestors);
+      if (!pathOperations[path2]) {
+        pathOperations[path2] = [];
+      }
+      pathOperations[path2].push(
+        operationObject({
           config: config4,
           filepath,
           listName: config4.listNameFromFragment(node.name.value),
@@ -68281,7 +68656,7 @@ function ancestorKey(ancestors) {
 }
 
 // src/codegen/generators/artifacts/selection.ts
-var graphql12 = __toESM(require_graphql2(), 1);
+var graphql13 = __toESM(require_graphql2(), 1);
 
 // ../../node_modules/.pnpm/@kitql+helper@0.5.0/node_modules/@kitql/helper/index.mjs
 var config2 = {
@@ -68327,16 +68702,16 @@ async function sleep2(ms) {
 }
 
 // src/codegen/transforms/list.ts
-var graphql10 = __toESM(require_graphql2(), 1);
+var graphql11 = __toESM(require_graphql2(), 1);
 
 // src/codegen/utils/objectIdentificationSelection.ts
-var graphql8 = __toESM(require_graphql2(), 1);
+var graphql9 = __toESM(require_graphql2(), 1);
 var objectIdentificationSelection = (config4, type) => {
   return config4.keyFieldsForType(type.name).map((key) => {
     return {
-      kind: graphql8.Kind.FIELD,
+      kind: graphql9.Kind.FIELD,
       name: {
-        kind: graphql8.Kind.NAME,
+        kind: graphql9.Kind.NAME,
         value: key
       }
     };
@@ -68344,7 +68719,7 @@ var objectIdentificationSelection = (config4, type) => {
 };
 
 // src/codegen/transforms/paginate.ts
-var graphql9 = __toESM(require_graphql2(), 1);
+var graphql10 = __toESM(require_graphql2(), 1);
 async function paginate(config4, documents) {
   const newDocs = [];
   for (const doc of documents) {
@@ -68377,7 +68752,7 @@ async function paginate(config4, documents) {
     };
     let cursorType = "String";
     let paginationPath = [];
-    doc.document = graphql9.visit(doc.document, {
+    doc.document = graphql10.visit(doc.document, {
       Field(node, _, __, ___, ancestors) {
         const paginateDirective = node.directives?.find(
           (directive) => directive.name.value === config4.paginateDirective
@@ -68388,23 +68763,22 @@ async function paginate(config4, documents) {
         paginated = true;
         const fieldTypeFields = parentTypeFromAncestors(config4.schema, doc.filename, ancestors).getFields()[node.name.value];
         const args = new Set(fieldTypeFields.args.map((arg) => arg.name));
-        const passedArgs = new Set(node.arguments?.map((arg) => arg.name.value));
-        const specifiedForwards = passedArgs.has("first");
-        const specifiedBackwards = passedArgs.has("last");
         cursorType = fieldTypeFields.args?.find((arg) => ["before", "after"].includes(arg.name))?.type?.name || "String";
         flags.after.type = cursorType;
         flags.before.type = cursorType;
-        const forwardPagination = !specifiedBackwards && args.has("first") && args.has("after");
-        const backwardsPagination = !specifiedForwards && args.has("last") && args.has("before");
-        const offsetPagination = !forwardPagination && !backwardsPagination && args.has("offset") && args.has("limit");
-        flags.first.enabled = forwardPagination;
-        flags.after.enabled = forwardPagination;
-        flags.last.enabled = backwardsPagination;
-        flags.before.enabled = backwardsPagination;
+        const passedArgs = new Set(node.arguments?.map((arg) => arg.name.value));
+        const forwards = args.has("first") && args.has("after");
+        const backwards = args.has("last") && args.has("after");
+        const cursorPagination = passedArgs.has("last") || passedArgs.has("first");
+        const offsetPagination = !cursorPagination && args.has("offset") && args.has("limit");
+        flags.first.enabled = forwards;
+        flags.after.enabled = forwards;
+        flags.last.enabled = backwards;
+        flags.before.enabled = backwards;
         flags.offset.enabled = offsetPagination;
         flags.limit.enabled = offsetPagination;
         paginationPath = ancestors.filter(
-          (ancestor) => !Array.isArray(ancestor) && ancestor.kind === graphql9.Kind.FIELD
+          (ancestor) => !Array.isArray(ancestor) && ancestor.kind === graphql10.Kind.FIELD
         ).concat(node).map((field) => field.alias?.value || field.name.value);
         return {
           ...node,
@@ -68420,12 +68794,8 @@ async function paginate(config4, documents) {
       let fragmentName = "";
       let refetchQueryName = "";
       let nodeQuery = false;
-      let refetchUpdate = "append" /* append */;
-      if (flags.last.enabled) {
-        refetchUpdate = "prepend" /* prepend */;
-      }
       let fragment = "";
-      doc.document = graphql9.visit(doc.document, {
+      doc.document = graphql10.visit(doc.document, {
         OperationDefinition(node) {
           if (node.operation !== "query") {
             throw new HoudiniError({
@@ -68479,9 +68849,9 @@ async function paginate(config4, documents) {
               directives: [
                 ...node.directives || [],
                 {
-                  kind: graphql9.Kind.DIRECTIVE,
+                  kind: graphql10.Kind.DIRECTIVE,
                   name: {
-                    kind: graphql9.Kind.NAME,
+                    kind: graphql10.Kind.NAME,
                     value: config4.argumentsDirective
                   }
                 }
@@ -68518,42 +68888,40 @@ async function paginate(config4, documents) {
           targetType = fragment;
         }
       }
+      const pageSize = flags.first.defaultValue ?? flags.last.defaultValue ?? flags.limit.defaultValue;
+      const start = flags.after.defaultValue ?? flags.before.defaultValue ?? flags.offset.defaultValue;
+      let direction = "forward";
+      if (flags.before.enabled && flags.after.enabled) {
+        direction = "both";
+      } else if (flags.before.enabled) {
+        direction = "backward";
+      }
       doc.refetch = {
-        update: refetchUpdate,
         path: paginationPath,
         method: flags.first.enabled || flags.last.enabled ? "cursor" : "offset",
-        pageSize: 0,
+        pageSize,
         embedded: nodeQuery,
         targetType,
         paginated: true,
-        direction: flags.last.enabled ? "backwards" : "forward"
-      };
-      if (flags.first.enabled) {
-        doc.refetch.pageSize = flags.first.defaultValue;
-        doc.refetch.start = flags.after.defaultValue;
-      } else if (flags.last.enabled) {
-        doc.refetch.pageSize = flags.last.defaultValue;
-        doc.refetch.start = flags.before.defaultValue;
-      } else if (flags.limit.enabled) {
-        doc.refetch.pageSize = flags.limit.defaultValue;
-        doc.refetch.start = flags.offset.defaultValue;
-      }
+        direction,
+        start
+      };
       if (!fragment) {
         continue;
       }
       const paginationArgs = Object.entries(flags).filter(([_, { enabled }]) => enabled).map(([key, value]) => ({ name: key, ...value }));
       const fragmentSpreadSelection = [
         {
-          kind: graphql9.Kind.FRAGMENT_SPREAD,
+          kind: graphql10.Kind.FRAGMENT_SPREAD,
           name: {
-            kind: graphql9.Kind.NAME,
+            kind: graphql10.Kind.NAME,
             value: fragmentName
           },
           directives: [
             {
-              kind: graphql9.Kind.DIRECTIVE,
+              kind: graphql10.Kind.DIRECTIVE,
               name: {
-                kind: graphql9.Kind.NAME,
+                kind: graphql10.Kind.NAME,
                 value: config4.withDirective
               },
               ["arguments"]: paginationArgs.map(
@@ -68581,29 +68949,29 @@ async function paginate(config4, documents) {
       });
       const typeConfig = config4.typeConfig?.[fragment];
       const queryDoc = {
-        kind: graphql9.Kind.DOCUMENT,
+        kind: graphql10.Kind.DOCUMENT,
         definitions: [
           {
-            kind: graphql9.Kind.OPERATION_DEFINITION,
+            kind: graphql10.Kind.OPERATION_DEFINITION,
             name: {
-              kind: graphql9.Kind.NAME,
+              kind: graphql10.Kind.NAME,
               value: refetchQueryName
             },
             operation: "query",
             variableDefinitions: paginationArgs.map(
               (arg) => ({
-                kind: graphql9.Kind.VARIABLE_DEFINITION,
+                kind: graphql10.Kind.VARIABLE_DEFINITION,
                 type: {
-                  kind: graphql9.Kind.NAMED_TYPE,
+                  kind: graphql10.Kind.NAMED_TYPE,
                   name: {
-                    kind: graphql9.Kind.NAME,
+                    kind: graphql10.Kind.NAME,
                     value: arg.type
                   }
                 },
                 variable: {
-                  kind: graphql9.Kind.VARIABLE,
+                  kind: graphql10.Kind.VARIABLE,
                   name: {
-                    kind: graphql9.Kind.NAME,
+                    kind: graphql10.Kind.NAME,
                     value: arg.name
                   }
                 },
@@ -68615,12 +68983,12 @@ async function paginate(config4, documents) {
             ).concat(
               !nodeQuery ? [] : keys.map(
                 (key) => ({
-                  kind: graphql9.Kind.VARIABLE_DEFINITION,
+                  kind: graphql10.Kind.VARIABLE_DEFINITION,
                   type: key.type,
                   variable: {
-                    kind: graphql9.Kind.VARIABLE,
+                    kind: graphql10.Kind.VARIABLE,
                     name: {
-                      kind: graphql9.Kind.NAME,
+                      kind: graphql10.Kind.NAME,
                       value: key.name
                     }
                   }
@@ -68628,42 +68996,42 @@ async function paginate(config4, documents) {
               )
             ),
             selectionSet: {
-              kind: graphql9.Kind.SELECTION_SET,
+              kind: graphql10.Kind.SELECTION_SET,
               selections: !nodeQuery ? fragmentSpreadSelection : [
                 {
-                  kind: graphql9.Kind.FIELD,
+                  kind: graphql10.Kind.FIELD,
                   name: {
-                    kind: graphql9.Kind.NAME,
+                    kind: graphql10.Kind.NAME,
                     value: typeConfig?.resolve?.queryField || "node"
                   },
                   ["arguments"]: keys.map((key) => ({
-                    kind: graphql9.Kind.ARGUMENT,
+                    kind: graphql10.Kind.ARGUMENT,
                     name: {
-                      kind: graphql9.Kind.NAME,
+                      kind: graphql10.Kind.NAME,
                       value: key.name
                     },
                     value: {
-                      kind: graphql9.Kind.VARIABLE,
+                      kind: graphql10.Kind.VARIABLE,
                       name: {
-                        kind: graphql9.Kind.NAME,
+                        kind: graphql10.Kind.NAME,
                         value: key.name
                       }
                     }
                   })),
                   selectionSet: {
-                    kind: graphql9.Kind.SELECTION_SET,
+                    kind: graphql10.Kind.SELECTION_SET,
                     selections: [
                       {
-                        kind: graphql9.Kind.FIELD,
+                        kind: graphql10.Kind.FIELD,
                         name: {
-                          kind: graphql9.Kind.NAME,
+                          kind: graphql10.Kind.NAME,
                           value: "__typename"
                         }
                       },
                       ...(typeConfig?.keys || ["id"]).map((key) => ({
-                        kind: graphql9.Kind.FIELD,
+                        kind: graphql10.Kind.FIELD,
                         name: {
-                          kind: graphql9.Kind.NAME,
+                          kind: graphql10.Kind.NAME,
                           value: key
                         }
                       })),
@@ -68713,27 +69081,21 @@ function replaceArgumentsWithVariables(args, flags) {
     if (flags[name2].defaultValue || !spec.enabled || seenArgs[name2]) {
       continue;
     }
-    if (["first", "after"].includes(name2) && flags["before"].enabled) {
-      continue;
-    }
-    if (["last", "before"].includes(name2) && flags["first"].enabled) {
-      continue;
-    }
     newArgs.push(variableAsArgument(name2));
   }
   return newArgs;
 }
 function variableAsArgument(name2, variable) {
   return {
-    kind: graphql9.Kind.ARGUMENT,
+    kind: graphql10.Kind.ARGUMENT,
     name: {
-      kind: graphql9.Kind.NAME,
+      kind: graphql10.Kind.NAME,
       value: name2
     },
     value: {
-      kind: graphql9.Kind.VARIABLE,
+      kind: graphql10.Kind.VARIABLE,
       name: {
-        kind: graphql9.Kind.NAME,
+        kind: graphql10.Kind.NAME,
         value: variable ?? name2
       }
     }
@@ -68741,18 +69103,18 @@ function variableAsArgument(name2, variable) {
 }
 function staticVariableDefinition(name2, type, defaultValue, variableName) {
   return {
-    kind: graphql9.Kind.VARIABLE_DEFINITION,
+    kind: graphql10.Kind.VARIABLE_DEFINITION,
     type: {
-      kind: graphql9.Kind.NAMED_TYPE,
+      kind: graphql10.Kind.NAMED_TYPE,
       name: {
-        kind: graphql9.Kind.NAME,
+        kind: graphql10.Kind.NAME,
         value: type
       }
     },
     variable: {
-      kind: graphql9.Kind.VARIABLE,
+      kind: graphql10.Kind.VARIABLE,
       name: {
-        kind: graphql9.Kind.NAME,
+        kind: graphql10.Kind.NAME,
         value: variableName ?? name2
       }
     },
@@ -68764,9 +69126,9 @@ function staticVariableDefinition(name2, type, defaultValue, variableName) {
 }
 function argumentNode(name2, value) {
   return {
-    kind: graphql9.Kind.ARGUMENT,
+    kind: graphql10.Kind.ARGUMENT,
     name: {
-      kind: graphql9.Kind.NAME,
+      kind: graphql10.Kind.NAME,
       value: name2
     },
     value: objectNode(value)
@@ -68774,16 +69136,16 @@ function argumentNode(name2, value) {
 }
 function objectNode([type, defaultValue]) {
   const node = {
-    kind: graphql9.Kind.OBJECT,
+    kind: graphql10.Kind.OBJECT,
     fields: [
       {
-        kind: graphql9.Kind.OBJECT_FIELD,
+        kind: graphql10.Kind.OBJECT_FIELD,
         name: {
-          kind: graphql9.Kind.NAME,
+          kind: graphql10.Kind.NAME,
           value: "type"
         },
         value: {
-          kind: graphql9.Kind.STRING,
+          kind: graphql10.Kind.STRING,
           value: type
         }
       }
@@ -68791,8 +69153,8 @@ function objectNode([type, defaultValue]) {
   };
   if (defaultValue) {
     node.fields.push({
-      kind: graphql9.Kind.OBJECT_FIELD,
-      name: { kind: graphql9.Kind.NAME, value: "default" },
+      kind: graphql10.Kind.OBJECT_FIELD,
+      name: { kind: graphql10.Kind.NAME, value: "default" },
       value: {
         kind: typeof defaultValue === "number" ? "IntValue" : "StringValue",
         value: defaultValue.toString()
@@ -68803,34 +69165,34 @@ function objectNode([type, defaultValue]) {
 }
 var pageInfoSelection = [
   {
-    kind: graphql9.Kind.FIELD,
+    kind: graphql10.Kind.FIELD,
     name: {
-      kind: graphql9.Kind.NAME,
+      kind: graphql10.Kind.NAME,
       value: "edges"
     },
     selectionSet: {
-      kind: graphql9.Kind.SELECTION_SET,
+      kind: graphql10.Kind.SELECTION_SET,
       selections: [
         {
-          kind: graphql9.Kind.FIELD,
+          kind: graphql10.Kind.FIELD,
           name: {
-            kind: graphql9.Kind.NAME,
+            kind: graphql10.Kind.NAME,
             value: "cursor"
           }
         },
         {
-          kind: graphql9.Kind.FIELD,
+          kind: graphql10.Kind.FIELD,
           name: {
-            kind: graphql9.Kind.NAME,
+            kind: graphql10.Kind.NAME,
             value: "node"
           },
           selectionSet: {
-            kind: graphql9.Kind.SELECTION_SET,
+            kind: graphql10.Kind.SELECTION_SET,
             selections: [
               {
-                kind: graphql9.Kind.FIELD,
+                kind: graphql10.Kind.FIELD,
                 name: {
-                  kind: graphql9.Kind.NAME,
+                  kind: graphql10.Kind.NAME,
                   value: "__typename"
                 }
               }
@@ -68841,39 +69203,39 @@ var pageInfoSelection = [
     }
   },
   {
-    kind: graphql9.Kind.FIELD,
+    kind: graphql10.Kind.FIELD,
     name: {
-      kind: graphql9.Kind.NAME,
+      kind: graphql10.Kind.NAME,
       value: "pageInfo"
     },
     selectionSet: {
-      kind: graphql9.Kind.SELECTION_SET,
+      kind: graphql10.Kind.SELECTION_SET,
       selections: [
         {
-          kind: graphql9.Kind.FIELD,
+          kind: graphql10.Kind.FIELD,
           name: {
-            kind: graphql9.Kind.NAME,
+            kind: graphql10.Kind.NAME,
             value: "hasPreviousPage"
           }
         },
         {
-          kind: graphql9.Kind.FIELD,
+          kind: graphql10.Kind.FIELD,
           name: {
-            kind: graphql9.Kind.NAME,
+            kind: graphql10.Kind.NAME,
             value: "hasNextPage"
           }
         },
         {
-          kind: graphql9.Kind.FIELD,
+          kind: graphql10.Kind.FIELD,
           name: {
-            kind: graphql9.Kind.NAME,
+            kind: graphql10.Kind.NAME,
             value: "startCursor"
           }
         },
         {
-          kind: graphql9.Kind.FIELD,
+          kind: graphql10.Kind.FIELD,
           name: {
-            kind: graphql9.Kind.NAME,
+            kind: graphql10.Kind.NAME,
             value: "endCursor"
           }
         }
@@ -68887,15 +69249,15 @@ async function addListFragments(config4, documents) {
   const lists = {};
   const errors = [];
   for (const doc of documents) {
-    doc.document = graphql10.visit(doc.document, {
+    doc.document = graphql11.visit(doc.document, {
       Directive(node, key, parent, path2, ancestors) {
         if ([config4.listDirective, config4.paginateDirective].includes(node.name.value)) {
           const nameArg = node.arguments?.find((arg) => arg.name.value === "name");
           let error = {
-            ...new graphql10.GraphQLError(
+            ...new graphql11.GraphQLError(
               "",
               node,
-              new graphql10.Source(""),
+              new graphql11.Source(""),
               node.loc ? [node.loc.start, node.loc.end] : null,
               path2
             ),
@@ -68947,7 +69309,7 @@ async function addListFragments(config4, documents) {
                 {
                   kind: "Argument",
                   name: {
-                    kind: graphql10.Kind.NAME,
+                    kind: graphql11.Kind.NAME,
                     value: "connection"
                   },
                   value: {
@@ -68997,7 +69359,7 @@ async function addListFragments(config4, documents) {
   const validDeletes = [
     ...new Set(
       Object.values(lists).map(({ type }) => {
-        if (!(type instanceof graphql10.GraphQLObjectType)) {
+        if (!(type instanceof graphql11.GraphQLObjectType)) {
           return "";
         }
         if (config4.keyFieldsForType(type.name).length !== 1) {
@@ -69011,7 +69373,7 @@ async function addListFragments(config4, documents) {
     return;
   }
   const generatedDoc = {
-    kind: graphql10.Kind.DOCUMENT,
+    kind: graphql11.Kind.DOCUMENT,
     definitions: Object.entries(lists).flatMap(
       ([name2, { selection: selection2, type }]) => {
         const schemaType = config4.schema.getType(type.name);
@@ -69019,7 +69381,7 @@ async function addListFragments(config4, documents) {
           throw new HoudiniError({ message: "Lists must have a selection" });
         }
         const fragmentSelection = {
-          kind: graphql10.Kind.SELECTION_SET,
+          kind: graphql11.Kind.SELECTION_SET,
           selections: [...selection2.selections]
         };
         if (schemaType && fragmentSelection && !fragmentSelection?.selections.find(
@@ -69034,14 +69396,14 @@ async function addListFragments(config4, documents) {
           {
             name: {
               value: config4.listInsertFragment(name2),
-              kind: graphql10.Kind.NAME
+              kind: graphql11.Kind.NAME
             },
-            kind: graphql10.Kind.FRAGMENT_DEFINITION,
+            kind: graphql11.Kind.FRAGMENT_DEFINITION,
             selectionSet: fragmentSelection,
             typeCondition: {
-              kind: graphql10.Kind.NAMED_TYPE,
+              kind: graphql11.Kind.NAMED_TYPE,
               name: {
-                kind: graphql10.Kind.NAME,
+                kind: graphql11.Kind.NAME,
                 value: type.name
               }
             }
@@ -69049,32 +69411,32 @@ async function addListFragments(config4, documents) {
           {
             name: {
               value: config4.listToggleFragment(name2),
-              kind: graphql10.Kind.NAME
+              kind: graphql11.Kind.NAME
             },
-            kind: graphql10.Kind.FRAGMENT_DEFINITION,
+            kind: graphql11.Kind.FRAGMENT_DEFINITION,
             selectionSet: fragmentSelection,
             typeCondition: {
-              kind: graphql10.Kind.NAMED_TYPE,
+              kind: graphql11.Kind.NAMED_TYPE,
               name: {
-                kind: graphql10.Kind.NAME,
+                kind: graphql11.Kind.NAME,
                 value: type.name
               }
             }
           },
           {
-            kind: graphql10.Kind.FRAGMENT_DEFINITION,
+            kind: graphql11.Kind.FRAGMENT_DEFINITION,
             name: {
               value: config4.listRemoveFragment(name2),
-              kind: graphql10.Kind.NAME
+              kind: graphql11.Kind.NAME
             },
             selectionSet: {
-              kind: graphql10.Kind.SELECTION_SET,
+              kind: graphql11.Kind.SELECTION_SET,
               selections: [...objectIdentificationSelection(config4, type)]
             },
             typeCondition: {
-              kind: graphql10.Kind.NAMED_TYPE,
+              kind: graphql11.Kind.NAMED_TYPE,
               name: {
-                kind: graphql10.Kind.NAME,
+                kind: graphql11.Kind.NAME,
                 value: type.name
               }
             }
@@ -69083,14 +69445,14 @@ async function addListFragments(config4, documents) {
       }
     ).concat(
       ...validDeletes.map((typeName) => ({
-        kind: graphql10.Kind.DIRECTIVE_DEFINITION,
+        kind: graphql11.Kind.DIRECTIVE_DEFINITION,
         name: {
-          kind: graphql10.Kind.NAME,
+          kind: graphql11.Kind.NAME,
           value: config4.listDeleteDirective(typeName)
         },
         locations: [
           {
-            kind: graphql10.Kind.NAME,
+            kind: graphql11.Kind.NAME,
             value: "FIELD"
           }
         ],
@@ -69098,8 +69460,8 @@ async function addListFragments(config4, documents) {
       }))
     )
   };
-  config4.newSchema += "\n" + generatedDoc.definitions.filter((c) => c.kind !== "FragmentDefinition").map(graphql10.print).join("\n\n");
-  config4.newDocuments += "\n" + generatedDoc.definitions.filter((c) => c.kind === "FragmentDefinition").map(graphql10.print).join("\n\n");
+  config4.newSchema += "\n" + generatedDoc.definitions.filter((c) => c.kind !== "FragmentDefinition").map(graphql11.print).join("\n\n");
+  config4.newDocuments += "\n" + generatedDoc.definitions.filter((c) => c.kind === "FragmentDefinition").map(graphql11.print).join("\n\n");
   documents.push({
     name: "generated::lists",
     kind: "HoudiniFragment" /* Fragment */,
@@ -69184,11 +69546,11 @@ var nodeNotDefinedMessage = (config4) => `Looks like you are trying to use the $
 For more information, visit this link: ${siteURL}/guides/pagination`;
 
 // src/codegen/generators/artifacts/fieldKey.ts
-var graphql11 = __toESM(require_graphql2(), 1);
+var graphql12 = __toESM(require_graphql2(), 1);
 function fieldKey(config4, field) {
   const attributeName = field.alias?.value || field.name.value;
-  const printed = graphql11.print(field);
-  const secondParse = graphql11.parse(`{${printed}}`).definitions[0].selectionSet.selections[0];
+  const printed = graphql12.print(field);
+  const secondParse = graphql12.parse(`{${printed}}`).definitions[0].selectionSet.selections[0];
   const paginated = !!field.directives?.find(
     (directive) => directive.name.value === config4.paginateDirective
   );
@@ -69226,7 +69588,7 @@ function selection({
   path: path2 = [],
   includeFragments,
   document,
-  markEdges
+  inConnection
 }) {
   let object = {};
   const typeMap = {};
@@ -69283,8 +69645,8 @@ function selection({
         const typeConditionName = field.typeCondition.name.value;
         const typeCondition = config4.schema.getType(typeConditionName);
         const possibleTypes = [];
-        if (!graphql12.isAbstractType(typeCondition)) {
-        } else if (graphql12.isAbstractType(parentType)) {
+        if (!graphql13.isAbstractType(typeCondition)) {
+        } else if (graphql13.isAbstractType(parentType)) {
           const possibleParentTypes = config4.schema.getPossibleTypes(parentType).map((type) => type.name);
           for (const possible of config4.schema.getPossibleTypes(typeCondition)) {
             if (possibleParentTypes.includes(possible.name)) {
@@ -69332,7 +69694,7 @@ function selection({
       } else {
         let typeRef = type.getFields()[field.name.value].type;
         fieldType = getRootType(typeRef);
-        nullable = !graphql12.isNonNullType(typeRef);
+        nullable = !graphql13.isNonNullType(typeRef);
       }
       const typeName = fieldType.toString();
       const pathSoFar = path2.concat(attributeName);
@@ -69368,14 +69730,23 @@ function selection({
         (directive) => directive.name.value === config4.paginateDirective
       );
       if (paginated && document.refetch && document.refetch.method === "offset") {
-        fieldObj.update = document.refetch.update;
+        fieldObj.updates = ["append" /* append */];
       }
-      if (attributeName === "edges" && markEdges && document.refetch) {
-        fieldObj.update = document.refetch.update;
-        markEdges = "";
+      let continueConnection = inConnection;
+      if ([
+        "edges",
+        "endCursor",
+        "startCursor",
+        "hasNextPage",
+        "hasPreviousPage"
+      ].includes(attributeName) && inConnection && document.refetch) {
+        fieldObj.updates = ["append" /* append */, "prepend" /* prepend */];
+      }
+      if (attributeName === "node" && inConnection) {
+        continueConnection = false;
       }
       if (field.selectionSet) {
-        const edgesMark = paginated && document.refetch?.method === "cursor" ? document.refetch.update : markEdges;
+        const connectionState = paginated && document.refetch?.method === "cursor" || continueConnection;
         fieldObj.selection = selection({
           config: config4,
           filepath,
@@ -69385,7 +69756,7 @@ function selection({
           path: pathSoFar,
           includeFragments,
           document,
-          markEdges: edgesMark
+          inConnection: connectionState
         });
       }
       if (field.arguments?.length && fieldObj.list) {
@@ -69397,7 +69768,7 @@ function selection({
           {}
         );
       }
-      if (graphql12.isInterfaceType(fieldType) || graphql12.isUnionType(fieldType)) {
+      if (graphql13.isInterfaceType(fieldType) || graphql13.isUnionType(fieldType)) {
         fieldObj.abstract = true;
       }
       object.fields = {
@@ -69454,7 +69825,7 @@ function artifactGenerator(stats) {
   return async function(config4, docs) {
     const filterTypes = {};
     for (const doc of docs) {
-      graphql13.visit(doc.document, {
+      graphql14.visit(doc.document, {
         Directive(node, _, __, ___, ancestors) {
           if (node.name.value !== config4.listDirective) {
             return;
@@ -69513,7 +69884,7 @@ function artifactGenerator(stats) {
             return;
           }
           const usedVariableNames = /* @__PURE__ */ new Set();
-          let documentWithoutInternalDirectives = graphql13.visit(document, {
+          let documentWithoutInternalDirectives = graphql14.visit(document, {
             Directive(node) {
               if (config4.isInternalDirective(node)) {
                 return null;
@@ -69526,7 +69897,7 @@ function artifactGenerator(stats) {
               }
             }
           });
-          let documentWithoutExtraVariables = graphql13.visit(
+          let documentWithoutExtraVariables = graphql14.visit(
             documentWithoutInternalDirectives,
             {
               VariableDefinition(variableDefinitionNode) {
@@ -69537,13 +69908,13 @@ function artifactGenerator(stats) {
               }
             }
           );
-          let rawString = graphql13.print(documentWithoutExtraVariables);
+          let rawString = graphql14.print(documentWithoutExtraVariables);
           let docKind = doc.kind;
           const operations = document.definitions.filter(
-            ({ kind }) => kind === graphql13.Kind.OPERATION_DEFINITION
+            ({ kind }) => kind === graphql14.Kind.OPERATION_DEFINITION
           );
           const fragments = document.definitions.filter(
-            ({ kind }) => kind === graphql13.Kind.FRAGMENT_DEFINITION
+            ({ kind }) => kind === graphql14.Kind.FRAGMENT_DEFINITION
           );
           let rootType = "";
           let selectionSet;
@@ -69576,7 +69947,13 @@ function artifactGenerator(stats) {
             rootType = matchingFragment.typeCondition.name.value;
             selectionSet = matchingFragment.selectionSet;
           }
-          const inputs = operations[0]?.variableDefinitions;
+          let inputs = operations[0]?.variableDefinitions;
+          let directive = fragments[0]?.directives?.find(
+            (directive2) => directive2.name.value === config4.argumentsDirective
+          );
+          if (docKind === "HoudiniFragment" /* Fragment */ && directive) {
+            inputs = fragmentArgumentsDefinitions(config4, doc.filename, fragments[0]);
+          }
           const mergedSelection = flattenSelections({
             config: config4,
             filepath: doc.filename,
@@ -69637,7 +70014,7 @@ function artifactGenerator(stats) {
           }
           if (docKind === "HoudiniQuery") {
             const cacheDirective = operations[0].directives?.find(
-              (directive) => directive.name.value === config4.cacheDirective
+              (directive2) => directive2.name.value === config4.cacheDirective
             );
             if (cacheDirective) {
               const args = cacheDirective.arguments?.reduce(
@@ -69853,19 +70230,19 @@ async function generatePluginRuntime(config4, plugin) {
   );
 }
 
-// src/codegen/generators/typescript/index.ts
-var recast12 = __toESM(require_main2(), 1);
+// src/codegen/generators/typescript/documentTypes.ts
+var recast11 = __toESM(require_main2(), 1);
 
 // src/codegen/generators/typescript/addReferencedInputTypes.ts
-var graphql16 = __toESM(require_graphql2(), 1);
+var graphql17 = __toESM(require_graphql2(), 1);
 var recast9 = __toESM(require_main2(), 1);
 
 // src/codegen/generators/typescript/typeReference.ts
-var graphql15 = __toESM(require_graphql2(), 1);
+var graphql16 = __toESM(require_graphql2(), 1);
 var recast8 = __toESM(require_main2(), 1);
 
 // src/codegen/generators/typescript/types.ts
-var graphql14 = __toESM(require_graphql2(), 1);
+var graphql15 = __toESM(require_graphql2(), 1);
 var recast7 = __toESM(require_main2(), 1);
 var AST7 = recast7.types.builders;
 function readonlyProperty(prop, enable = true) {
@@ -69896,336 +70273,89 @@ function scalarPropertyValue(config4, missingScalars, target) {
       return AST7.tsBooleanKeyword();
     }
     case "ID": {
-      return AST7.tsStringKeyword();
-    }
-    default: {
-      if (graphql14.isNonNullType(target) && "ofType" in target) {
-        return scalarPropertyValue(
-          config4,
-          missingScalars,
-          target.ofType
-        );
-      }
-      if (config4.scalars?.[target.name]) {
-        return AST7.tsTypeReference(AST7.identifier(config4.scalars?.[target.name].type));
-      }
-      missingScalars.add(target.name);
-      return AST7.tsAnyKeyword();
-    }
-  }
-}
-
-// src/codegen/generators/typescript/typeReference.ts
-var AST8 = recast8.types.builders;
-function tsTypeReference(config4, missingScalars, definition) {
-  const { type, wrappers } = unwrapType(config4, definition.type);
-  let result;
-  if (graphql15.isScalarType(type)) {
-    result = scalarPropertyValue(config4, missingScalars, type);
-  } else {
-    result = AST8.tsTypeReference(AST8.identifier(type.name));
-  }
-  for (const toWrap of wrappers) {
-    if (toWrap === "NonNull" /* NonNull */) {
-      continue;
-    } else if (toWrap === "Nullable" /* Nullable */) {
-      result = nullableField(result, true);
-    } else if (toWrap === "List" /* List */) {
-      result = AST8.tsArrayType(AST8.tsParenthesizedType(result));
-    }
-  }
-  return result;
-}
-
-// src/codegen/generators/typescript/addReferencedInputTypes.ts
-var AST9 = recast9.types.builders;
-function addReferencedInputTypes(config4, filepath, body, visitedTypes, missingScalars, rootType) {
-  const { type } = unwrapType(config4, rootType);
-  if (graphql16.isScalarType(type)) {
-    return;
-  }
-  if (visitedTypes.has(type.name)) {
-    return;
-  }
-  if (graphql16.isUnionType(type)) {
-    throw new HoudiniError({ filepath, message: "Input Unions are not supported yet. Sorry!" });
-  }
-  visitedTypes.add(type.name);
-  if (graphql16.isEnumType(type)) {
-    ensureImports({
-      config: config4,
-      body,
-      import: [type.name],
-      sourceModule: "$houdini/graphql/enums",
-      importKind: "type"
-    });
-    return;
-  }
-  const members = [];
-  for (const field of Object.values(type.getFields())) {
-    addReferencedInputTypes(config4, filepath, body, visitedTypes, missingScalars, field.type);
-    members.push(
-      AST9.tsPropertySignature(
-        AST9.identifier(field.name),
-        AST9.tsTypeAnnotation(tsTypeReference(config4, missingScalars, field)),
-        graphql16.isNullableType(field.type)
-      )
-    );
-  }
-  body.push(AST9.tsTypeAliasDeclaration(AST9.identifier(type.name), AST9.tsTypeLiteral(members)));
-}
-
-// src/codegen/generators/typescript/imperativeCache.ts
-var graphql17 = __toESM(require_graphql2(), 1);
-var recast10 = __toESM(require_main2(), 1);
-var AST10 = recast10.types.builders;
-async function imperativeCacheTypef(config4, docs) {
-  const target = path_exports.join(config4.runtimeDirectory, "generated.d.ts");
-  const body = [];
-  const declaration = AST10.tsTypeAliasDeclaration(
-    AST10.identifier(CacheTypeDefName),
-    AST10.tsTypeLiteral([
-      AST10.tsPropertySignature(
-        AST10.identifier("types"),
-        AST10.tsTypeAnnotation(typeDefinitions(config4, body))
-      ),
-      AST10.tsPropertySignature(
-        AST10.identifier("lists"),
-        AST10.tsTypeAnnotation(listDefinitions(config4, docs))
-      )
-    ])
-  );
-  declaration.declare = true;
-  const importRecord = AST10.importDeclaration(
-    [AST10.importSpecifier(AST10.identifier("Record"))],
-    AST10.stringLiteral("./public/record")
-  );
-  importRecord.importKind = "type";
-  await fs_exports.writeFile(
-    target,
-    recast10.prettyPrint(
-      AST10.program([importRecord, ...body, AST10.exportNamedDeclaration(declaration)])
-    ).code
-  );
-}
-function typeDefinitions(config4, body) {
-  const operationTypes = [config4.schema.getMutationType(), config4.schema.getSubscriptionType()].filter(Boolean).map((type) => type?.name);
-  const visitedTypes = /* @__PURE__ */ new Set();
-  const types17 = Object.values(config4.schema.getTypeMap()).filter(
-    (type) => !graphql17.isAbstractType(type) && !graphql17.isScalarType(type) && !graphql17.isEnumType(type) && !graphql17.isInputObjectType(type) && !type.name.startsWith("__") && !operationTypes.includes(type.name)
-  );
-  return AST10.tsTypeLiteral(
-    types17.map((type) => {
-      let typeName = type.name;
-      if (config4.schema.getQueryType() && config4.schema.getQueryType()?.name === type.name) {
-        typeName = "__ROOT__";
-      }
-      let idFields = AST10.tsNeverKeyword();
-      const keys = keyFieldsForType(config4.configFile, type.name);
-      if (graphql17.isObjectType(type) && keys.length > 0 && keys.every((key) => type.getFields()[key])) {
-        idFields = AST10.tsTypeLiteral(
-          keys.map((key) => {
-            const fieldType = type.getFields()[key];
-            const unwrapped = unwrapType(config4, fieldType.type);
-            return AST10.tsPropertySignature(
-              AST10.identifier(key),
-              AST10.tsTypeAnnotation(
-                scalarPropertyValue(config4, /* @__PURE__ */ new Set(), unwrapped.type)
-              )
-            );
-          })
-        );
-      } else if (typeName === "__ROOT__") {
-        idFields = AST10.tsTypeLiteral([]);
-      }
-      let fields = AST10.tsTypeLiteral([]);
-      if (graphql17.isObjectType(type)) {
-        fields = AST10.tsTypeLiteral(
-          Object.entries(type.getFields()).map(
-            ([key, fieldType]) => {
-              const unwrapped = unwrapType(config4, fieldType.type);
-              let typeOptions = AST10.tsUnionType([]);
-              if (graphql17.isScalarType(unwrapped.type)) {
-                typeOptions.types.push(
-                  scalarPropertyValue(config4, /* @__PURE__ */ new Set(), unwrapped.type)
-                );
-              } else if (graphql17.isEnumType(unwrapped.type)) {
-                typeOptions.types.push(
-                  AST10.tsTypeReference(AST10.identifier(unwrapped.type.name))
-                );
-              } else if (!graphql17.isAbstractType(unwrapped.type)) {
-                typeOptions.types.push(record(unwrapped.type.name));
-              } else {
-                typeOptions.types.push(
-                  ...config4.schema.getPossibleTypes(unwrapped.type).map((type2) => record(type2.name))
-                );
-              }
-              for (const wrapper of unwrapped.wrappers) {
-                if (wrapper === "Nullable" /* Nullable */) {
-                  typeOptions = AST10.tsParenthesizedType(
-                    AST10.tsUnionType([typeOptions, AST10.tsNullKeyword()])
-                  );
-                } else if (wrapper === "List" /* List */) {
-                  typeOptions = AST10.tsArrayType(
-                    AST10.tsParenthesizedType(typeOptions)
-                  );
-                }
-              }
-              if (typeOptions.type === "TSParenthesizedType") {
-                typeOptions = typeOptions.typeAnnotation;
-              }
-              let args = AST10.tsNeverKeyword();
-              if (fieldType.args?.length > 0) {
-                args = AST10.tsTypeLiteral(
-                  fieldType.args.map((arg) => {
-                    addReferencedInputTypes(
-                      config4,
-                      "",
-                      body,
-                      visitedTypes,
-                      /* @__PURE__ */ new Set(),
-                      arg.type
-                    );
-                    const prop = AST10.tsPropertySignature(
-                      AST10.identifier(arg.name),
-                      AST10.tsTypeAnnotation(
-                        tsTypeReference(config4, /* @__PURE__ */ new Set(), arg)
-                      )
-                    );
-                    const unwrapped2 = unwrapType(config4, arg.type);
-                    prop.optional = unwrapped2.wrappers[unwrapped2.wrappers.length - 1] === "Nullable" /* Nullable */;
-                    return prop;
-                  })
-                );
-              }
-              return AST10.tsPropertySignature(
-                AST10.identifier(key),
-                AST10.tsTypeAnnotation(
-                  AST10.tsTypeLiteral([
-                    AST10.tsPropertySignature(
-                      AST10.identifier("type"),
-                      AST10.tsTypeAnnotation(typeOptions)
-                    ),
-                    AST10.tsPropertySignature(
-                      AST10.identifier("args"),
-                      AST10.tsTypeAnnotation(args)
-                    )
-                  ])
-                )
-              );
-            }
-          )
+      return AST7.tsStringKeyword();
+    }
+    default: {
+      if (graphql15.isNonNullType(target) && "ofType" in target) {
+        return scalarPropertyValue(
+          config4,
+          missingScalars,
+          target.ofType
         );
       }
-      return AST10.tsPropertySignature(
-        AST10.identifier(typeName),
-        AST10.tsTypeAnnotation(
-          AST10.tsTypeLiteral([
-            AST10.tsPropertySignature(
-              AST10.identifier("idFields"),
-              AST10.tsTypeAnnotation(idFields)
-            ),
-            AST10.tsPropertySignature(
-              AST10.identifier("fields"),
-              AST10.tsTypeAnnotation(fields)
-            )
-          ])
-        )
-      );
-    })
-  );
-}
-function listDefinitions(config4, docs) {
-  const lists = [];
-  const visitedLists = /* @__PURE__ */ new Set();
-  for (const doc of docs) {
-    graphql17.visit(doc.document, {
-      Directive(node, key, parent, path2, ancestors) {
-        if (![config4.listDirective, config4.paginateDirective].includes(node.name.value)) {
-          return;
-        }
-        const nameArg = node.arguments?.find((arg) => arg.name.value === "name");
-        const nameValue = nameArg?.value?.value || "";
-        if (!nameValue || visitedLists.has(nameValue)) {
-          return;
-        }
-        visitedLists.add(nameValue);
-        const parentType = parentTypeFromAncestors(
-          config4.schema,
-          doc.filename,
-          ancestors.slice(0, -1)
-        );
-        const targetField = ancestors[ancestors.length - 1];
-        const targetFieldDefinition = parentType.getFields()[targetField.name.value];
-        const { type: listType } = unwrapType(config4, targetFieldDefinition.type);
-        const possibleTypes = [];
-        if (graphql17.isAbstractType(listType)) {
-          possibleTypes.push(
-            ...config4.schema.getPossibleTypes(listType).map((possible) => possible.name)
-          );
-        } else {
-          possibleTypes.push(listType.name);
-        }
-        lists.push(
-          AST10.tsPropertySignature(
-            AST10.identifier(nameValue),
-            AST10.tsTypeAnnotation(
-              AST10.tsTypeLiteral([
-                AST10.tsPropertySignature(
-                  AST10.identifier("types"),
-                  AST10.tsTypeAnnotation(
-                    AST10.tsUnionType(
-                      possibleTypes.map(
-                        (possible) => AST10.tsLiteralType(AST10.stringLiteral(possible))
-                      )
-                    )
-                  )
-                ),
-                AST10.tsPropertySignature(
-                  AST10.identifier("filters"),
-                  AST10.tsTypeAnnotation(
-                    targetFieldDefinition.args.length === 0 ? AST10.tsNeverKeyword() : AST10.tsTypeLiteral(
-                      targetFieldDefinition.args.map((arg) => {
-                        const argDef = AST10.tsPropertySignature(
-                          AST10.identifier(arg.name),
-                          AST10.tsTypeAnnotation(
-                            tsTypeReference(
-                              config4,
-                              /* @__PURE__ */ new Set(),
-                              arg
-                            )
-                          )
-                        );
-                        argDef.optional = true;
-                        return argDef;
-                      })
-                    )
-                  )
-                )
-              ])
-            )
-          )
-        );
+      if (config4.scalars?.[target.name]) {
+        return AST7.tsTypeReference(AST7.identifier(config4.scalars?.[target.name].type));
       }
-    });
+      missingScalars.add(target.name);
+      return AST7.tsAnyKeyword();
+    }
   }
-  return AST10.tsTypeLiteral(lists);
 }
-var CacheTypeDefName = "CacheTypeDef";
-function record(name2) {
-  return AST10.tsTypeReference(
-    AST10.identifier("Record"),
-    AST10.tsTypeParameterInstantiation([
-      AST10.tsTypeReference(AST10.identifier(CacheTypeDefName)),
-      AST10.tsLiteralType(AST10.stringLiteral(name2))
-    ])
-  );
+
+// src/codegen/generators/typescript/typeReference.ts
+var AST8 = recast8.types.builders;
+function tsTypeReference(config4, missingScalars, definition) {
+  const { type, wrappers } = unwrapType(config4, definition.type);
+  let result;
+  if (graphql16.isScalarType(type)) {
+    result = scalarPropertyValue(config4, missingScalars, type);
+  } else {
+    result = AST8.tsTypeReference(AST8.identifier(type.name));
+  }
+  for (const toWrap of wrappers) {
+    if (toWrap === "NonNull" /* NonNull */) {
+      continue;
+    } else if (toWrap === "Nullable" /* Nullable */) {
+      result = nullableField(result, true);
+    } else if (toWrap === "List" /* List */) {
+      result = AST8.tsArrayType(AST8.tsParenthesizedType(result));
+    }
+  }
+  return result;
+}
+
+// src/codegen/generators/typescript/addReferencedInputTypes.ts
+var AST9 = recast9.types.builders;
+function addReferencedInputTypes(config4, filepath, body, visitedTypes, missingScalars, rootType) {
+  const { type } = unwrapType(config4, rootType);
+  if (graphql17.isScalarType(type)) {
+    return;
+  }
+  if (visitedTypes.has(type.name)) {
+    return;
+  }
+  if (graphql17.isUnionType(type)) {
+    throw new HoudiniError({ filepath, message: "Input Unions are not supported yet. Sorry!" });
+  }
+  visitedTypes.add(type.name);
+  if (graphql17.isEnumType(type)) {
+    ensureImports({
+      config: config4,
+      body,
+      import: [type.name],
+      sourceModule: "$houdini/graphql/enums",
+      importKind: "type"
+    });
+    return;
+  }
+  const members = [];
+  for (const field of Object.values(type.getFields())) {
+    addReferencedInputTypes(config4, filepath, body, visitedTypes, missingScalars, field.type);
+    members.push(
+      AST9.tsPropertySignature(
+        AST9.identifier(field.name),
+        AST9.tsTypeAnnotation(tsTypeReference(config4, missingScalars, field)),
+        graphql17.isNullableType(field.type)
+      )
+    );
+  }
+  body.push(AST9.tsTypeAliasDeclaration(AST9.identifier(type.name), AST9.tsTypeLiteral(members)));
 }
 
 // src/codegen/generators/typescript/inlineType.ts
 var graphql18 = __toESM(require_graphql2(), 1);
-var recast11 = __toESM(require_main2(), 1);
-var AST11 = recast11.types.builders;
+var recast10 = __toESM(require_main2(), 1);
+var AST10 = recast10.types.builders;
 var fragmentKey = "$fragments";
 function inlineType({
   config: config4,
@@ -70254,7 +70384,7 @@ function inlineType({
       });
       visitedTypes.add(type.name);
     }
-    result = AST11.tsTypeReference(AST11.identifier(type.name));
+    result = AST10.tsTypeReference(AST10.identifier(type.name));
   } else if (selections) {
     const rootObj = type;
     const inlineFragments = {};
@@ -70305,7 +70435,7 @@ function inlineType({
         selectedFields.push(selection2);
       }
     }
-    result = AST11.tsTypeLiteral([
+    result = AST10.tsTypeLiteral([
       ...(selectedFields || []).filter(
         (field) => field.kind === "Field"
       ).map((selection2) => {
@@ -70325,9 +70455,9 @@ function inlineType({
           allOptional
         });
         const prop = readonlyProperty(
-          AST11.tsPropertySignature(
-            AST11.identifier(attributeName),
-            AST11.tsTypeAnnotation(attributeType)
+          AST10.tsPropertySignature(
+            AST10.identifier(attributeName),
+            AST10.tsTypeAnnotation(attributeType)
           ),
           allowReadonly
         );
@@ -70341,15 +70471,15 @@ function inlineType({
     if (includeFragments && fragmentSpreads && fragmentSpreads.length) {
       result.members.push(
         readonlyProperty(
-          AST11.tsPropertySignature(
-            AST11.identifier(fragmentKey),
-            AST11.tsTypeAnnotation(
-              AST11.tsTypeLiteral(
+          AST10.tsPropertySignature(
+            AST10.identifier(fragmentKey),
+            AST10.tsTypeAnnotation(
+              AST10.tsTypeLiteral(
                 (fragmentSpreads || []).map(
-                  (fragmentSpread) => AST11.tsPropertySignature(
-                    AST11.identifier(fragmentSpread.name.value),
-                    AST11.tsTypeAnnotation(
-                      AST11.tsLiteralType(AST11.booleanLiteral(true))
+                  (fragmentSpread) => AST10.tsPropertySignature(
+                    AST10.identifier(fragmentSpread.name.value),
+                    AST10.tsTypeAnnotation(
+                      AST10.tsLiteralType(AST10.booleanLiteral(true))
                     )
                   )
                 )
@@ -70395,9 +70525,9 @@ function inlineType({
         }
         objectType.members.push(
           readonlyProperty(
-            AST11.tsPropertySignature(
-              AST11.identifier("__typename"),
-              AST11.tsTypeAnnotation(AST11.tsLiteralType(AST11.stringLiteral(typeName)))
+            AST10.tsPropertySignature(
+              AST10.identifier("__typename"),
+              AST10.tsTypeAnnotation(AST10.tsLiteralType(AST10.stringLiteral(typeName)))
             ),
             allowReadonly
           )
@@ -70408,8 +70538,8 @@ function inlineType({
     if (Object.keys(inlineFragmentSelections).length > 0) {
       let selectionTypes = Object.entries(inlineFragmentSelections).map(
         ([typeName, { type: type2, tsType }]) => {
-          return AST11.tsParenthesizedType(
-            AST11.tsIntersectionType(
+          return AST10.tsParenthesizedType(
+            AST10.tsIntersectionType(
               [tsType].flatMap((type3) => {
                 if (type3.type === "TSUnionType") {
                   return type3.types.filter(
@@ -70422,9 +70552,9 @@ function inlineType({
           );
         }
       );
-      result = AST11.tsIntersectionType([
+      result = AST10.tsIntersectionType([
         result,
-        AST11.tsParenthesizedType(AST11.tsUnionType(selectionTypes))
+        AST10.tsParenthesizedType(AST10.tsUnionType(selectionTypes))
       ]);
     }
   } else {
@@ -70436,7 +70566,7 @@ function inlineType({
     } else if (toWrap === "NonNull" /* NonNull */) {
       continue;
     } else if (toWrap === "List" /* List */) {
-      result = AST11.tsArrayType(AST11.tsParenthesizedType(result));
+      result = AST10.tsArrayType(AST10.tsParenthesizedType(result));
     }
   }
   return result;
@@ -70480,9 +70610,9 @@ function selectionTypeInfo(schema, filepath, rootType, selection2) {
   return { field, type: selectionType };
 }
 
-// src/codegen/generators/typescript/index.ts
-var AST12 = recast12.types.builders;
-async function typescriptGenerator(config4, docs) {
+// src/codegen/generators/typescript/documentTypes.ts
+var AST11 = recast11.types.builders;
+async function generateDocumentTypes(config4, docs) {
   const typePaths = [];
   const fragmentDefinitions = {};
   for (const document of docs) {
@@ -70499,7 +70629,7 @@ async function typescriptGenerator(config4, docs) {
         return;
       }
       const typeDefPath = config4.artifactTypePath(originalDocument);
-      const program = AST12.program([]);
+      const program = AST11.program([]);
       const visitedTypes = /* @__PURE__ */ new Set();
       let definition = originalDocument.definitions.find(
         (def) => (def.kind === "OperationDefinition" || def.kind === "FragmentDefinition") && def.name?.value === name2
@@ -70532,21 +70662,21 @@ async function typescriptGenerator(config4, docs) {
           missingScalars
         );
       }
-      await fs_exports.writeFile(typeDefPath, recast12.print(program).code);
+      await fs_exports.writeFile(typeDefPath, recast11.print(program).code);
       typePaths.push(typeDefPath);
     })
   );
-  const typeIndex = AST12.program(
+  const typeIndex = AST11.program(
     typePaths.sort((a, b) => a.localeCompare(b)).map((typePath) => {
-      return AST12.exportAllDeclaration(
-        AST12.literal(
+      return AST11.exportAllDeclaration(
+        AST11.literal(
           "./" + path_exports.relative(path_exports.resolve(config4.typeIndexPath, ".."), typePath).replace(/\.[^/.]+\.[^/.]+$/, "")
         ),
         null
       );
     }).concat([
-      AST12.exportAllDeclaration(AST12.literal("./runtime"), null),
-      AST12.exportAllDeclaration(AST12.literal("./graphql"), null)
+      AST11.exportAllDeclaration(AST11.literal("./runtime"), null),
+      AST11.exportAllDeclaration(AST11.literal("./graphql"), null)
     ])
   );
   const export_default_as = ({ module: module2, as }) => `
@@ -70555,7 +70685,7 @@ export { default as ${as} } from "${module2}"
   const export_star_from = ({ module: module2 }) => `
 export * from "${module2}"
 `;
-  let indexContent = recast12.print(typeIndex).code;
+  let indexContent = recast11.print(typeIndex).code;
   for (const plugin of config4.plugins) {
     if (!plugin.index_file) {
       continue;
@@ -70576,7 +70706,6 @@ export * from "${module2}"
     }
   }
   await fs_exports.writeFile(config4.typeIndexPath, indexContent);
-  await imperativeCacheTypef(config4, docs);
   if (missingScalars.size > 0) {
     console.warn(`\u26A0\uFE0F  Missing definitions for the following scalars: ${[...missingScalars].join(
       ", "
@@ -70618,23 +70747,23 @@ async function generateOperationTypeDefs(config4, filepath, body, definition, se
   const optimisticTypeName = `${definition.name.value}$optimistic`;
   const hasInputs = definition.variableDefinitions && definition.variableDefinitions.length > 0;
   body.push(
-    AST12.exportNamedDeclaration(
-      AST12.tsTypeAliasDeclaration(
-        AST12.identifier(definition.name.value),
-        AST12.tsTypeLiteral([
+    AST11.exportNamedDeclaration(
+      AST11.tsTypeAliasDeclaration(
+        AST11.identifier(definition.name.value),
+        AST11.tsTypeLiteral([
           readonlyProperty(
-            AST12.tsPropertySignature(
-              AST12.stringLiteral("input"),
-              AST12.tsTypeAnnotation(AST12.tsTypeReference(AST12.identifier(inputTypeName)))
+            AST11.tsPropertySignature(
+              AST11.stringLiteral("input"),
+              AST11.tsTypeAnnotation(AST11.tsTypeReference(AST11.identifier(inputTypeName)))
             )
           ),
           readonlyProperty(
-            AST12.tsPropertySignature(
-              AST12.stringLiteral("result"),
-              AST12.tsTypeAnnotation(
-                definition.operation === "mutation" ? AST12.tsTypeReference(AST12.identifier(shapeTypeName)) : AST12.tsUnionType([
-                  AST12.tsTypeReference(AST12.identifier(shapeTypeName)),
-                  AST12.tsUndefinedKeyword()
+            AST11.tsPropertySignature(
+              AST11.stringLiteral("result"),
+              AST11.tsTypeAnnotation(
+                definition.operation === "mutation" ? AST11.tsTypeReference(AST11.identifier(shapeTypeName)) : AST11.tsUnionType([
+                  AST11.tsTypeReference(AST11.identifier(shapeTypeName)),
+                  AST11.tsUndefinedKeyword()
                 ])
               )
             )
@@ -70642,9 +70771,9 @@ async function generateOperationTypeDefs(config4, filepath, body, definition, se
         ])
       )
     ),
-    AST12.exportNamedDeclaration(
-      AST12.tsTypeAliasDeclaration(
-        AST12.identifier(shapeTypeName),
+    AST11.exportNamedDeclaration(
+      AST11.tsTypeAliasDeclaration(
+        AST11.identifier(shapeTypeName),
         inlineType({
           config: config4,
           filepath,
@@ -70672,15 +70801,15 @@ async function generateOperationTypeDefs(config4, filepath, body, definition, se
       );
     }
     body.push(
-      AST12.exportNamedDeclaration(
-        AST12.tsTypeAliasDeclaration(
-          AST12.identifier(inputTypeName),
-          AST12.tsTypeLiteral(
+      AST11.exportNamedDeclaration(
+        AST11.tsTypeAliasDeclaration(
+          AST11.identifier(inputTypeName),
+          AST11.tsTypeLiteral(
             (definition.variableDefinitions || []).map(
               (definition2) => {
-                return AST12.tsPropertySignature(
-                  AST12.identifier(definition2.variable.name.value),
-                  AST12.tsTypeAnnotation(
+                return AST11.tsPropertySignature(
+                  AST11.identifier(definition2.variable.name.value),
+                  AST11.tsTypeAnnotation(
                     tsTypeReference(config4, missingScalars, definition2)
                   ),
                   definition2.type.kind !== "NonNullType"
@@ -70693,16 +70822,16 @@ async function generateOperationTypeDefs(config4, filepath, body, definition, se
     );
   } else {
     body.push(
-      AST12.exportNamedDeclaration(
-        AST12.tsTypeAliasDeclaration(AST12.identifier(inputTypeName), AST12.tsNullKeyword())
+      AST11.exportNamedDeclaration(
+        AST11.tsTypeAliasDeclaration(AST11.identifier(inputTypeName), AST11.tsNullKeyword())
       )
     );
   }
   if (definition.operation === "mutation") {
     body.push(
-      AST12.exportNamedDeclaration(
-        AST12.tsTypeAliasDeclaration(
-          AST12.identifier(optimisticTypeName),
+      AST11.exportNamedDeclaration(
+        AST11.tsTypeAliasDeclaration(
+          AST11.identifier(optimisticTypeName),
           inlineType({
             config: config4,
             filepath,
@@ -70728,65 +70857,463 @@ async function generateFragmentTypeDefs(config4, filepath, body, selections, def
     }
     const propTypeName = definition.name.value;
     const shapeTypeName = `${definition.name.value}$data`;
+    const inputTypeName = `${definition.name.value}$input`;
     const type = config4.schema.getType(definition.typeCondition.name.value);
     if (!type) {
       throw new Error("Should not get here");
     }
+    let extraExports = [];
+    let directive = definition.directives?.find(
+      (directive2) => directive2.name.value === config4.argumentsDirective
+    );
+    if (directive) {
+      extraExports.push(
+        AST11.exportNamedDeclaration(
+          AST11.tsTypeAliasDeclaration(
+            AST11.identifier(inputTypeName),
+            AST11.tsTypeLiteral(
+              (fragmentArgumentsDefinitions(config4, filepath, definition) || []).map(
+                (definition2) => {
+                  return AST11.tsPropertySignature(
+                    AST11.identifier(definition2.variable.name.value),
+                    AST11.tsTypeAnnotation(
+                      tsTypeReference(config4, missingScalars, definition2)
+                    ),
+                    definition2.type.kind !== "NonNullType"
+                  );
+                }
+              )
+            )
+          )
+        )
+      );
+    }
     body.push(
-      AST12.exportNamedDeclaration(
-        AST12.tsTypeAliasDeclaration(
-          AST12.identifier(propTypeName),
-          AST12.tsTypeLiteral([
+      ...extraExports,
+      AST11.exportNamedDeclaration(
+        AST11.tsTypeAliasDeclaration(
+          AST11.identifier(propTypeName),
+          AST11.tsTypeLiteral([
             readonlyProperty(
-              AST12.tsPropertySignature(
-                AST12.stringLiteral("shape"),
-                AST12.tsTypeAnnotation(
-                  AST12.tsTypeReference(AST12.identifier(shapeTypeName))
+              AST11.tsPropertySignature(
+                AST11.stringLiteral("shape"),
+                AST11.tsTypeAnnotation(
+                  AST11.tsTypeReference(AST11.identifier(shapeTypeName))
                 ),
                 true
               )
             ),
             readonlyProperty(
-              AST12.tsPropertySignature(
-                AST12.stringLiteral(fragmentKey),
+              AST11.tsPropertySignature(
+                AST11.stringLiteral(fragmentKey),
+                AST11.tsTypeAnnotation(
+                  AST11.tsTypeLiteral([
+                    AST11.tsPropertySignature(
+                      AST11.stringLiteral(propTypeName),
+                      AST11.tsTypeAnnotation(
+                        AST11.tsLiteralType(AST11.booleanLiteral(true))
+                      )
+                    )
+                  ])
+                )
+              )
+            )
+          ])
+        )
+      ),
+      AST11.exportNamedDeclaration(
+        AST11.tsTypeAliasDeclaration(
+          AST11.identifier(shapeTypeName),
+          inlineType({
+            config: config4,
+            filepath,
+            rootType: type,
+            selections,
+            root: true,
+            allowReadonly: true,
+            body,
+            visitedTypes,
+            missingScalars,
+            includeFragments: true
+          })
+        )
+      )
+    );
+  }
+}
+
+// src/codegen/generators/typescript/imperativeTypeDef.ts
+var graphql19 = __toESM(require_graphql2(), 1);
+var recast12 = __toESM(require_main2(), 1);
+var AST12 = recast12.types.builders;
+async function imperativeCacheTypef(config4, docs) {
+  const returnType = (doc) => config4.plugins.find((plugin) => plugin.graphql_tag_return)?.graphql_tag_return?.({
+    config: config4,
+    doc,
+    ensure_import({ identifier, module: module2 }) {
+      ensureImports({
+        config: config4,
+        body,
+        sourceModule: module2,
+        import: [identifier]
+      });
+    }
+  }) ?? "any";
+  const target = path_exports.join(config4.runtimeDirectory, "generated.d.ts");
+  const body = [];
+  const declaration = AST12.tsTypeAliasDeclaration(
+    AST12.identifier(CacheTypeDefName),
+    AST12.tsTypeLiteral([
+      AST12.tsPropertySignature(
+        AST12.identifier("types"),
+        AST12.tsTypeAnnotation(typeDefinitions(config4, body, docs, returnType))
+      ),
+      AST12.tsPropertySignature(
+        AST12.identifier("lists"),
+        AST12.tsTypeAnnotation(listDefinitions(config4, docs))
+      ),
+      AST12.tsPropertySignature(
+        AST12.identifier("queries"),
+        AST12.tsTypeAnnotation(queryDefinitions(config4, body, docs, returnType))
+      )
+    ])
+  );
+  declaration.declare = true;
+  const importRecord = AST12.importDeclaration(
+    [AST12.importSpecifier(AST12.identifier("Record"))],
+    AST12.stringLiteral("./public/record")
+  );
+  importRecord.importKind = "type";
+  await fs_exports.writeFile(
+    target,
+    recast12.prettyPrint(
+      AST12.program([importRecord, ...body, AST12.exportNamedDeclaration(declaration)])
+    ).code
+  );
+}
+function typeDefinitions(config4, body, docs, returnType) {
+  const operationTypes = [config4.schema.getMutationType(), config4.schema.getSubscriptionType()].filter(Boolean).map((type) => type?.name);
+  const visitedTypes = /* @__PURE__ */ new Set();
+  const types17 = Object.values(config4.schema.getTypeMap()).filter(
+    (type) => !graphql19.isAbstractType(type) && !graphql19.isScalarType(type) && !graphql19.isEnumType(type) && !graphql19.isInputObjectType(type) && !type.name.startsWith("__") && !operationTypes.includes(type.name)
+  );
+  const fragmentMap = fragmentListMap(
+    config4,
+    types17.map((type) => type.name),
+    body,
+    docs,
+    returnType
+  );
+  return AST12.tsTypeLiteral(
+    types17.map((type) => {
+      let typeName = type.name;
+      if (config4.schema.getQueryType() && config4.schema.getQueryType()?.name === type.name) {
+        typeName = "__ROOT__";
+      }
+      let idFields = AST12.tsNeverKeyword();
+      const keys = keyFieldsForType(config4.configFile, type.name);
+      if (graphql19.isObjectType(type) && keys.length > 0 && keys.every((key) => type.getFields()[key])) {
+        idFields = AST12.tsTypeLiteral(
+          keys.map((key) => {
+            const fieldType = type.getFields()[key];
+            const unwrapped = unwrapType(config4, fieldType.type);
+            return AST12.tsPropertySignature(
+              AST12.identifier(key),
+              AST12.tsTypeAnnotation(
+                scalarPropertyValue(config4, /* @__PURE__ */ new Set(), unwrapped.type)
+              )
+            );
+          })
+        );
+      } else if (typeName === "__ROOT__") {
+        idFields = AST12.tsTypeLiteral([]);
+      }
+      let fields = AST12.tsTypeLiteral([]);
+      if (graphql19.isObjectType(type)) {
+        fields = AST12.tsTypeLiteral(
+          Object.entries(type.getFields()).map(
+            ([key, fieldType]) => {
+              const unwrapped = unwrapType(config4, fieldType.type);
+              let typeOptions = AST12.tsUnionType([]);
+              if (graphql19.isScalarType(unwrapped.type)) {
+                typeOptions.types.push(
+                  scalarPropertyValue(config4, /* @__PURE__ */ new Set(), unwrapped.type)
+                );
+              } else if (graphql19.isEnumType(unwrapped.type)) {
+                typeOptions.types.push(
+                  AST12.tsTypeReference(AST12.identifier(unwrapped.type.name))
+                );
+              } else if (!graphql19.isAbstractType(unwrapped.type)) {
+                typeOptions.types.push(record(unwrapped.type.name));
+              } else {
+                typeOptions.types.push(
+                  ...config4.schema.getPossibleTypes(unwrapped.type).map((type2) => record(type2.name))
+                );
+              }
+              for (const wrapper of unwrapped.wrappers) {
+                if (wrapper === "Nullable" /* Nullable */) {
+                  typeOptions = AST12.tsParenthesizedType(
+                    AST12.tsUnionType([typeOptions, AST12.tsNullKeyword()])
+                  );
+                } else if (wrapper === "List" /* List */) {
+                  typeOptions = AST12.tsArrayType(
+                    AST12.tsParenthesizedType(typeOptions)
+                  );
+                }
+              }
+              if (typeOptions.type === "TSParenthesizedType") {
+                typeOptions = typeOptions.typeAnnotation;
+              }
+              let args = AST12.tsNeverKeyword();
+              if (fieldType.args?.length > 0) {
+                args = AST12.tsTypeLiteral(
+                  fieldType.args.map((arg) => {
+                    addReferencedInputTypes(
+                      config4,
+                      "",
+                      body,
+                      visitedTypes,
+                      /* @__PURE__ */ new Set(),
+                      arg.type
+                    );
+                    const prop = AST12.tsPropertySignature(
+                      AST12.identifier(arg.name),
+                      AST12.tsTypeAnnotation(
+                        tsTypeReference(config4, /* @__PURE__ */ new Set(), arg)
+                      )
+                    );
+                    const unwrapped2 = unwrapType(config4, arg.type);
+                    prop.optional = unwrapped2.wrappers[unwrapped2.wrappers.length - 1] === "Nullable" /* Nullable */;
+                    return prop;
+                  })
+                );
+              }
+              return AST12.tsPropertySignature(
+                AST12.identifier(key),
                 AST12.tsTypeAnnotation(
                   AST12.tsTypeLiteral([
                     AST12.tsPropertySignature(
-                      AST12.stringLiteral(propTypeName),
-                      AST12.tsTypeAnnotation(
-                        AST12.tsLiteralType(AST12.booleanLiteral(true))
-                      )
+                      AST12.identifier("type"),
+                      AST12.tsTypeAnnotation(typeOptions)
+                    ),
+                    AST12.tsPropertySignature(
+                      AST12.identifier("args"),
+                      AST12.tsTypeAnnotation(args)
                     )
                   ])
                 )
-              )
+              );
+            }
+          )
+        );
+      }
+      return AST12.tsPropertySignature(
+        AST12.identifier(typeName),
+        AST12.tsTypeAnnotation(
+          AST12.tsTypeLiteral([
+            AST12.tsPropertySignature(
+              AST12.identifier("idFields"),
+              AST12.tsTypeAnnotation(idFields)
+            ),
+            AST12.tsPropertySignature(
+              AST12.identifier("fields"),
+              AST12.tsTypeAnnotation(fields)
+            ),
+            AST12.tsPropertySignature(
+              AST12.identifier("fragments"),
+              AST12.tsTypeAnnotation(fragmentMap[typeName] ?? AST12.tsTupleType([]))
             )
           ])
         )
+      );
+    })
+  );
+}
+function listDefinitions(config4, docs) {
+  const lists = [];
+  const visitedLists = /* @__PURE__ */ new Set();
+  for (const doc of docs) {
+    graphql19.visit(doc.document, {
+      Directive(node, key, parent, path2, ancestors) {
+        if (![config4.listDirective, config4.paginateDirective].includes(node.name.value)) {
+          return;
+        }
+        const nameArg = node.arguments?.find((arg) => arg.name.value === "name");
+        const nameValue = nameArg?.value?.value || "";
+        if (!nameValue || visitedLists.has(nameValue)) {
+          return;
+        }
+        visitedLists.add(nameValue);
+        const parentType = parentTypeFromAncestors(
+          config4.schema,
+          doc.filename,
+          ancestors.slice(0, -1)
+        );
+        const targetField = ancestors[ancestors.length - 1];
+        const targetFieldDefinition = parentType.getFields()[targetField.name.value];
+        const { type: listType } = unwrapType(config4, targetFieldDefinition.type);
+        const possibleTypes = [];
+        if (graphql19.isAbstractType(listType)) {
+          possibleTypes.push(
+            ...config4.schema.getPossibleTypes(listType).map((possible) => possible.name)
+          );
+        } else {
+          possibleTypes.push(listType.name);
+        }
+        lists.push(
+          AST12.tsPropertySignature(
+            AST12.identifier(nameValue),
+            AST12.tsTypeAnnotation(
+              AST12.tsTypeLiteral([
+                AST12.tsPropertySignature(
+                  AST12.identifier("types"),
+                  AST12.tsTypeAnnotation(
+                    AST12.tsUnionType(
+                      possibleTypes.map(
+                        (possible) => AST12.tsLiteralType(AST12.stringLiteral(possible))
+                      )
+                    )
+                  )
+                ),
+                AST12.tsPropertySignature(
+                  AST12.identifier("filters"),
+                  AST12.tsTypeAnnotation(
+                    targetFieldDefinition.args.length === 0 ? AST12.tsNeverKeyword() : AST12.tsTypeLiteral(
+                      targetFieldDefinition.args.map((arg) => {
+                        const argDef = AST12.tsPropertySignature(
+                          AST12.identifier(arg.name),
+                          AST12.tsTypeAnnotation(
+                            tsTypeReference(
+                              config4,
+                              /* @__PURE__ */ new Set(),
+                              arg
+                            )
+                          )
+                        );
+                        argDef.optional = true;
+                        return argDef;
+                      })
+                    )
+                  )
+                )
+              ])
+            )
+          )
+        );
+      }
+    });
+  }
+  return AST12.tsTypeLiteral(lists);
+}
+function queryDefinitions(config4, body, docs, returnType) {
+  return AST12.tsTupleType(
+    docs.reduce((prev, doc) => {
+      if (doc.kind !== "HoudiniQuery" /* Query */ || !doc.generateStore) {
+        return prev;
+      }
+      const definition = doc.document.definitions.find(
+        (def) => def.kind === "OperationDefinition" && def.operation === "query"
+      );
+      if (!definition) {
+        return prev;
+      }
+      const runtimeType = returnType(doc);
+      const [shapeType, inputType] = ensureImports({
+        config: config4,
+        body,
+        sourceModule: path_exports.relative(
+          config4.runtimeDirectory,
+          config4.artifactImportPath(doc.name)
+        ),
+        import: [`${doc.name}$result`, `${doc.name}$input`]
+      });
+      return prev.concat(
+        AST12.tsTupleType([
+          AST12.tsTypeReference(AST12.identifier(runtimeType)),
+          AST12.tsTypeReference(AST12.identifier(shapeType)),
+          AST12.tsTypeReference(AST12.identifier(inputType))
+        ])
+      );
+    }, [])
+  );
+}
+function fragmentListMap(config4, concreteTypes, body, docs, return_type) {
+  return docs.reduce((prev, doc) => {
+    if (doc.kind !== "HoudiniFragment" /* Fragment */) {
+      return prev;
+    }
+    const definition = doc.document.definitions.find(
+      (def) => def.kind === "FragmentDefinition" && def.name.value === doc.name
+    );
+    if (!definition || !concreteTypes.includes(definition.typeCondition.name.value)) {
+      return prev;
+    }
+    const typeName = definition.typeCondition.name.value;
+    const previousValue = prev[typeName]?.elementTypes ?? [];
+    const tagResult = return_type(doc);
+    const [shapeType] = ensureImports({
+      config: config4,
+      body,
+      sourceModule: path_exports.relative(
+        config4.runtimeDirectory,
+        config4.artifactImportPath(doc.name)
       ),
-      AST12.exportNamedDeclaration(
-        AST12.tsTypeAliasDeclaration(
-          AST12.identifier(shapeTypeName),
-          inlineType({
+      import: [`${definition.name.value}$data`]
+    });
+    let inputType = AST12.tsNeverKeyword();
+    let directive = definition.directives?.find(
+      (directive2) => directive2.name.value === config4.argumentsDirective
+    );
+    if (directive) {
+      inputType = AST12.tsTypeReference(
+        AST12.identifier(
+          ensureImports({
             config: config4,
-            filepath,
-            rootType: type,
-            selections,
-            root: true,
-            allowReadonly: true,
             body,
-            visitedTypes,
-            missingScalars,
-            includeFragments: true
-          })
+            sourceModule: path_exports.relative(
+              config4.runtimeDirectory,
+              config4.artifactImportPath(doc.name)
+            ),
+            import: [`${definition.name.value}$input`]
+          })[0]
+        )
+      );
+    }
+    return {
+      ...prev,
+      [typeName]: AST12.tsTupleType(
+        previousValue.concat(
+          AST12.tsTupleType([
+            AST12.tsTypeReference(AST12.identifier(tagResult)),
+            AST12.tsTypeReference(AST12.identifier(shapeType)),
+            inputType
+          ])
         )
       )
-    );
-  }
+    };
+  }, {});
+}
+var CacheTypeDefName = "CacheTypeDef";
+function record(name2) {
+  return AST12.tsTypeReference(
+    AST12.identifier("Record"),
+    AST12.tsTypeParameterInstantiation([
+      AST12.tsTypeReference(AST12.identifier(CacheTypeDefName)),
+      AST12.tsLiteralType(AST12.stringLiteral(name2))
+    ])
+  );
+}
+
+// src/codegen/generators/typescript/index.ts
+async function typescriptGenerator(config4, docs) {
+  await Promise.all([
+    generateDocumentTypes(config4, docs),
+    imperativeCacheTypef(config4, docs)
+  ]);
 }
 
 // src/codegen/generators/persistedQueries/index.ts
-var graphql19 = __toESM(require_graphql2(), 1);
+var graphql20 = __toESM(require_graphql2(), 1);
 async function persistOutputGenerator(config4, docs) {
   if (typeof config4.persistedQueryPath !== "string" || config4.persistedQueryPath.length === 0)
     return;
@@ -70798,8 +71325,8 @@ async function persistOutputGenerator(config4, docs) {
     if (!generateArtifact) {
       return acc;
     }
-    let rawString = graphql19.print(
-      graphql19.visit(document, {
+    let rawString = graphql20.print(
+      graphql20.visit(document, {
         Directive(node) {
           if (config4.isInternalDirective(node)) {
             return null;
@@ -70808,7 +71335,7 @@ async function persistOutputGenerator(config4, docs) {
       })
     );
     const operations = document.definitions.filter(
-      ({ kind }) => kind === graphql19.Kind.OPERATION_DEFINITION
+      ({ kind }) => kind === graphql20.Kind.OPERATION_DEFINITION
     );
     if (operations.length > 0 && operations[0].kind === "OperationDefinition") {
       acc[hashDocument(rawString)] = rawString;
@@ -70821,11 +71348,11 @@ async function persistOutputGenerator(config4, docs) {
 }
 
 // src/codegen/generators/definitions/enums.ts
-var graphql20 = __toESM(require_graphql2(), 1);
+var graphql21 = __toESM(require_graphql2(), 1);
 var recast13 = __toESM(require_main2(), 1);
 var AST13 = recast13.types.builders;
 async function definitionsGenerator(config4) {
-  const enums = graphql20.parse(graphql20.printSchema(config4.schema)).definitions.filter(
+  const enums = graphql21.parse(graphql21.printSchema(config4.schema)).definitions.filter(
     (definition) => definition.kind === "EnumTypeDefinition"
   ).filter((def) => !config4.isInternalEnum(def));
   const runtimeDefinitions = recast13.print(
@@ -70915,91 +71442,8 @@ async function writeIndexFile2(config4, docs) {
   await fs_exports.writeFile(path_exports.join(config4.rootDir, "index.js"), body);
 }
 
-// src/codegen/transforms/composeQueries.ts
-var import_graphql30 = __toESM(require_graphql2(), 1);
-async function includeFragmentDefinitions(config4, documents) {
-  const fragments = collectFragments(config4, documents);
-  for (const [index, { name: name2, document, filename }] of documents.entries()) {
-    const operation = document.definitions.find(
-      ({ kind }) => kind === import_graphql30.Kind.OPERATION_DEFINITION
-    );
-    if (!operation) {
-      continue;
-    }
-    const allFragments = flattenFragments(
-      filename,
-      { requiredFragments: findRequiredFragments(operation.selectionSet) },
-      fragments
-    );
-    documents[index].document = {
-      ...document,
-      definitions: [
-        operation,
-        ...allFragments.map((fragmentName) => fragments[fragmentName].definition)
-      ]
-    };
-  }
-}
-function collectFragments(config4, docs) {
-  return docs.reduce((acc, doc) => {
-    const definitions = doc.document.definitions.reduce(
-      (prev, definition) => definition.kind !== "FragmentDefinition" ? prev : {
-        ...prev,
-        [definition.name.value]: {
-          definition,
-          requiredFragments: findRequiredFragments(definition.selectionSet),
-          document: doc
-        }
-      },
-      {}
-    );
-    return {
-      ...acc,
-      ...definitions
-    };
-  }, {});
-}
-function findRequiredFragments(selectionSet) {
-  if (selectionSet.selections.length === 0) {
-    return [];
-  }
-  const referencedFragments = [];
-  for (const selection2 of selectionSet.selections) {
-    if (selection2.kind === import_graphql30.Kind.FRAGMENT_SPREAD) {
-      referencedFragments.push(selection2.name.value);
-    } else if (selection2.selectionSet) {
-      referencedFragments.push(...findRequiredFragments(selection2.selectionSet));
-    }
-  }
-  return referencedFragments;
-}
-function flattenFragments(filepath, operation, fragments) {
-  const frags = /* @__PURE__ */ new Set();
-  const remaining = [...operation.requiredFragments];
-  while (remaining.length > 0) {
-    const nextFragment = remaining.shift();
-    if (!nextFragment) {
-      continue;
-    }
-    if (!frags.has(nextFragment)) {
-      frags.add(nextFragment);
-    } else {
-      continue;
-    }
-    const targetFragment = fragments[nextFragment];
-    if (!targetFragment) {
-      throw new HoudiniError({
-        filepath,
-        message: "compose: could not find definition for fragment " + nextFragment
-      });
-    }
-    remaining.push(...targetFragment.requiredFragments);
-  }
-  return [...frags];
-}
-
 // src/codegen/transforms/schema.ts
-var graphql21 = __toESM(require_graphql2(), 1);
+var graphql22 = __toESM(require_graphql2(), 1);
 async function graphqlExtensions(config4, documents) {
   const internalSchema = `
 enum CachePolicy {
@@ -71063,9 +71507,9 @@ directive @${config4.argumentsDirective} on FRAGMENT_DEFINITION
 directive @${config4.cacheDirective}(${config4.cachePolicyArg}: CachePolicy, ${config4.cachePartialArg}: Boolean) on QUERY
 
 """
-	@${config4.manualLoadDirective} is used to disable automatic fetch (no load, no auto fetch in component), you will have to do it manually.
+	@${config4.loadDirective} is used to disable automatic fetch (no load, no auto fetch in component), you will have to do it manually.
 """
-directive @${config4.manualLoadDirective} on QUERY
+directive @${config4.loadDirective} on QUERY
 
 """
 	@${config4.maskEnableDirective} to enable masking on fragment (overwriting the global conf)
@@ -71077,19 +71521,19 @@ directive @${config4.maskEnableDirective} on FRAGMENT_SPREAD
 """
 directive @${config4.maskDisableDirective} on FRAGMENT_SPREAD
 `;
-  let currentSchema = graphql21.printSchema(config4.schema);
+  let currentSchema = graphql22.printSchema(config4.schema);
   if (!currentSchema.includes(`directive @${config4.listDirective}`)) {
     currentSchema += internalSchema;
   }
   config4.newSchema += internalSchema;
-  config4.schema = graphql21.buildSchema(currentSchema);
+  config4.schema = graphql22.buildSchema(currentSchema);
 }
 
 // src/codegen/transforms/typename.ts
-var graphql22 = __toESM(require_graphql2(), 1);
+var graphql23 = __toESM(require_graphql2(), 1);
 async function addTypename(config4, documents) {
   for (const doc of documents) {
-    doc.document = graphql22.visit(doc.document, {
+    doc.document = graphql23.visit(doc.document, {
       Field(node, key, parent, path2, ancestors) {
         if (!node.selectionSet) {
           return;
@@ -71101,7 +71545,7 @@ async function addTypename(config4, documents) {
         );
         const field = type.getFields()[node.name.value];
         const fieldType = unwrapType(config4, field.type).type;
-        if (graphql22.isInterfaceType(fieldType) || graphql22.isUnionType(fieldType)) {
+        if (graphql23.isInterfaceType(fieldType) || graphql23.isUnionType(fieldType)) {
           return {
             ...node,
             selectionSet: {
@@ -71109,9 +71553,9 @@ async function addTypename(config4, documents) {
               selections: [
                 ...node.selectionSet.selections,
                 {
-                  kind: graphql22.Kind.FIELD,
+                  kind: graphql23.Kind.FIELD,
                   name: {
-                    kind: graphql22.Kind.NAME,
+                    kind: graphql23.Kind.NAME,
                     value: "__typename"
                   }
                 }
@@ -71125,10 +71569,10 @@ async function addTypename(config4, documents) {
 }
 
 // src/codegen/transforms/addID.ts
-var graphql23 = __toESM(require_graphql2(), 1);
+var graphql24 = __toESM(require_graphql2(), 1);
 async function addID(config4, documents) {
   for (const doc of documents) {
-    doc.document = graphql23.visit(doc.document, {
+    doc.document = graphql24.visit(doc.document, {
       Field(node, key, parent, path2, ancestors) {
         if (!node.selectionSet) {
           return;
@@ -71141,7 +71585,7 @@ async function addID(config4, documents) {
         const field = type.getFields()[node.name.value];
         const fieldType = unwrapType(config4, field.type).type;
         if (node.selectionSet?.selections.length > 0) {
-          if (!graphql23.isObjectType(fieldType) && !graphql23.isInterfaceType(fieldType)) {
+          if (!graphql24.isObjectType(fieldType) && !graphql24.isInterfaceType(fieldType)) {
             return;
           }
           const keyFields = config4.keyFieldsForType(fieldType.name);
@@ -71156,9 +71600,9 @@ async function addID(config4, documents) {
               continue;
             }
             selections.push({
-              kind: graphql23.Kind.FIELD,
+              kind: graphql24.Kind.FIELD,
               name: {
-                kind: graphql23.Kind.NAME,
+                kind: graphql24.Kind.NAME,
                 value: keyField
               }
             });
@@ -71176,266 +71620,6 @@ async function addID(config4, documents) {
   }
 }
 
-// src/codegen/transforms/fragmentVariables.ts
-var graphql24 = __toESM(require_graphql2(), 1);
-var GraphqlKinds2 = graphql24.Kind;
-async function fragmentVariables(config4, documents) {
-  const fragments = collectFragments(config4, documents);
-  const generatedFragments = {};
-  const visitedFragments = /* @__PURE__ */ new Set();
-  for (const doc2 of documents) {
-    const operation = doc2.document.definitions.find(
-      ({ kind }) => kind === GraphqlKinds2.OPERATION_DEFINITION
-    );
-    if (!operation) {
-      continue;
-    }
-    doc2.document = inlineFragmentArgs({
-      config: config4,
-      filepath: doc2.filename,
-      fragmentDefinitions: fragments,
-      document: doc2.document,
-      generatedFragments,
-      visitedFragments,
-      scope: null
-    });
-  }
-  const doc = {
-    kind: graphql24.Kind.DOCUMENT,
-    definitions: Object.values(generatedFragments)
-  };
-  documents.push({
-    name: "generated::fragmentVariables",
-    kind: "HoudiniFragment" /* Fragment */,
-    document: doc,
-    originalDocument: doc,
-    generateStore: false,
-    generateArtifact: false,
-    filename: "generated::fragmentVariables",
-    originalString: ""
-  });
-}
-function inlineFragmentArgs({
-  config: config4,
-  filepath,
-  fragmentDefinitions,
-  document,
-  generatedFragments,
-  visitedFragments,
-  scope,
-  newName
-}) {
-  if (!scope) {
-    scope = operationScope(
-      document.definitions.find(
-        ({ kind }) => kind === GraphqlKinds2.OPERATION_DEFINITION
-      )
-    );
-  }
-  const definitionArgs = fragmentArguments(
-    config4,
-    filepath,
-    document
-  ).reduce((acc, arg) => ({ ...acc, [arg.name]: arg }), {});
-  const result = graphql24.visit(document, {
-    FragmentSpread(node) {
-      const { definition } = fragmentDefinitions[node.name.value];
-      let { args, hash } = collectWithArguments(config4, filepath, node, scope);
-      const newFragmentName = `${node.name.value}${hash}`;
-      if (!visitedFragments.has(newFragmentName)) {
-        visitedFragments.add(newFragmentName);
-        const defaultArguments = collectDefaultArgumentValues(config4, filepath, definition);
-        if (args) {
-          for (const [field, value] of Object.entries(defaultArguments || {})) {
-            if (!args[field]) {
-              args[field] = value;
-            }
-          }
-          generatedFragments[newFragmentName] = inlineFragmentArgs({
-            config: config4,
-            filepath,
-            fragmentDefinitions,
-            document: fragmentDefinitions[node.name.value].definition,
-            generatedFragments,
-            visitedFragments,
-            scope: args,
-            newName: newFragmentName
-          });
-        } else {
-          const doc = fragmentDefinitions[node.name.value].document;
-          const definitionIndex = doc.document.definitions.findIndex(
-            (definition2) => definition2.kind === "FragmentDefinition" && definition2.name.value === node.name.value
-          );
-          const localDefinitions = [...doc.document.definitions];
-          localDefinitions.splice(definitionIndex, 1);
-          localDefinitions.push(
-            inlineFragmentArgs({
-              config: config4,
-              filepath,
-              fragmentDefinitions,
-              document: fragmentDefinitions[node.name.value].definition,
-              generatedFragments,
-              visitedFragments,
-              scope: defaultArguments,
-              newName: ""
-            })
-          );
-          doc.document = {
-            ...doc.document,
-            definitions: localDefinitions
-          };
-        }
-        if (node.name.value !== newFragmentName) {
-          return {
-            ...node,
-            name: {
-              kind: "Name",
-              value: newFragmentName
-            }
-          };
-        }
-      }
-    },
-    Argument(node) {
-      const value = node.value;
-      if (value.kind !== "Variable") {
-        return;
-      }
-      if (!scope) {
-        throw new HoudiniError({
-          filepath,
-          message: node.name.value + " is not defined in the current scope: " + JSON.stringify(scope)
-        });
-      }
-      const newValue = scope[value.name.value];
-      if (newValue) {
-        return {
-          ...node,
-          value: newValue
-        };
-      }
-      if (definitionArgs[value.name.value] && definitionArgs[value.name.value].required) {
-        throw new HoudiniError({
-          filepath,
-          message: "Missing value for required arg: " + value.name.value
-        });
-      }
-      return null;
-    }
-  });
-  if (newName) {
-    result.name = {
-      kind: graphql24.Kind.NAME,
-      value: newName
-    };
-  }
-  return result;
-}
-function withArguments(config4, node) {
-  const withDirectives = node.directives?.filter(
-    (directive) => directive.name.value === config4.withDirective
-  );
-  if (!withDirectives || withDirectives.length === 0) {
-    return [];
-  }
-  return withDirectives.flatMap((directive) => directive.arguments || []);
-}
-function fragmentArguments(config4, filepath, definition) {
-  const directives = definition.directives?.filter(
-    (directive) => directive.name.value === config4.argumentsDirective
-  );
-  if (!directives || directives.length === 0) {
-    return [];
-  }
-  return directives.flatMap(
-    (directive) => directive.arguments?.flatMap((arg) => {
-      if (arg.value.kind !== "ObjectValue") {
-        throw new HoudiniError({
-          filepath,
-          message: "values of @argument must be objects"
-        });
-      }
-      const typeArg = arg.value.fields?.find((arg2) => arg2.name.value === "type")?.value;
-      if (!typeArg || typeArg.kind !== "StringValue") {
-        return [];
-      }
-      let type = typeArg.value;
-      let name2 = arg.name.value;
-      let required = false;
-      let defaultValue = arg.value.fields?.find((arg2) => arg2.name.value === "default")?.value || null;
-      if (type[type.length - 1] === "!") {
-        type = type.slice(0, -1);
-        required = true;
-        defaultValue = null;
-      }
-      return [
-        {
-          name: name2,
-          type,
-          required,
-          defaultValue
-        }
-      ];
-    }) || []
-  );
-}
-function collectDefaultArgumentValues(config4, filepath, definition) {
-  let result = {};
-  for (const { name: name2, required, defaultValue } of fragmentArguments(
-    config4,
-    filepath,
-    definition
-  )) {
-    if (required || !defaultValue) {
-      continue;
-    }
-    result[name2] = defaultValue;
-  }
-  return result;
-}
-function collectWithArguments(config4, filepath, node, scope = {}) {
-  const withArgs = withArguments(config4, node);
-  if (withArgs.length === 0) {
-    return { args: null, hash: "" };
-  }
-  let args = {};
-  for (const arg of withArgs) {
-    let value = arg.value;
-    if (value.kind === GraphqlKinds2.VARIABLE) {
-      if (!scope || !scope[value.name.value]) {
-        throw new HoudiniError({
-          filepath,
-          message: "Encountered undefined variable: " + value.name.value
-        });
-      }
-      value = scope[value.name.value];
-    }
-    args[arg.name.value] = {
-      ...value,
-      loc: void 0
-    };
-  }
-  return {
-    args,
-    hash: "_" + murmurHash(JSON.stringify(args))
-  };
-}
-function operationScope(operation) {
-  return operation.variableDefinitions?.reduce(
-    (scope, definition) => ({
-      ...scope,
-      [definition.variable.name.value]: {
-        kind: "Variable",
-        name: {
-          kind: "Name",
-          value: definition.variable.name.value
-        }
-      }
-    }),
-    {}
-  ) || {};
-}
-
 // src/codegen/validators/typeCheck.ts
 var graphql25 = __toESM(require_graphql2(), 1);
 async function typeCheck(config4, docs) {