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

package/build/test-cjs/index.js

@@ -54349,8 +54349,7 @@ var Config = class {
       types: types14 = {},
       logLevel,
       defaultFragmentMasking = "enable",
-      schemaPollInterval = 2e3,
-      schemaPollHeaders = {},
+      watchSchema,
       projectDir
     } = this.configFile;
     if (typeof schema === "string") {
@@ -54383,8 +54382,8 @@ var Config = class {
     this.logLevel = (logLevel || LogLevel.Summary).toLowerCase();
     this.defaultFragmentMasking = defaultFragmentMasking;
     this.routesDir = join(this.projectRoot, "src", "routes");
-    this.schemaPollInterval = schemaPollInterval;
-    this.schemaPollHeaders = schemaPollHeaders;
+    this.schemaPollInterval = watchSchema?.interval ?? 2e3;
+    this.schemaPollHeaders = watchSchema?.headers ?? {};
     this.rootDir = join(this.projectRoot, "$houdini");
     if (defaultKeys) {
       this.defaultKeys = defaultKeys;
@@ -54397,11 +54396,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) {
@@ -54605,8 +54605,8 @@ var Config = class {
   pluginDirectory(name2) {
     return join(this.pluginRootDirectory, name2);
   }
-  get manualLoadDirective() {
-    return "manual_load";
+  get loadDirective() {
+    return "load";
   }
   get maskEnableDirective() {
     return "mask_enable";
@@ -54723,7 +54723,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);
@@ -54994,7 +54994,7 @@ async function cleanupFiles(pathFolder, listOfObj) {
 }
 
 // src/codegen/generators/artifacts/index.ts
-var graphql11 = __toESM(require_graphql2(), 1);
+var graphql12 = __toESM(require_graphql2(), 1);
 var recast5 = __toESM(require_main2(), 1);
 
 // src/codegen/utils/commonjs.ts
@@ -55252,159 +55252,534 @@ function murmurHash(str) {
   return s;
 }
 
-// src/codegen/generators/artifacts/indexFile.ts
-async function writeIndexFile(config2, docs) {
-  const docsToGenerate = docs.filter((doc) => doc.generateArtifact).sort((a, b) => a.name.localeCompare(b.name));
-  let body = config2.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(config2.artifactDirectory, "index.js"), body);
-}
-
-// src/codegen/generators/artifacts/inputs.ts
+// src/codegen/transforms/fragmentVariables.ts
 var graphql3 = __toESM(require_graphql2(), 1);
-var recast3 = __toESM(require_main2(), 1);
-var AST3 = recast3.types.builders;
-function inputObject(config2, inputs) {
-  const visitedTypes = /* @__PURE__ */ new Set();
-  const inputObj = {
-    fields: inputs.reduce((fields, input) => {
-      const { type } = unwrapType(config2, input.type);
-      return {
-        ...fields,
-        [input.variable.name.value]: type.name
-      };
-    }, {}),
-    types: {}
-  };
-  for (const input of inputs) {
-    walkInputs(config2, visitedTypes, inputObj, input.type);
-  }
-  return inputObj;
-}
-function walkInputs(config2, visitedTypes, inputObj, rootType) {
-  const { type } = unwrapType(config2, rootType);
-  if (visitedTypes.has(type.name)) {
-    return;
-  }
-  if (graphql3.isEnumType(type) || graphql3.isScalarType(type)) {
-    return;
-  }
-  if (graphql3.isUnionType(type)) {
-    return;
-  }
-  visitedTypes.add(type.name);
-  inputObj.types[type.name] = Object.values(type.getFields()).reduce(
-    (typeFields, field) => {
-      const { type: fieldType } = unwrapType(config2, field.type);
-      walkInputs(config2, visitedTypes, inputObj, fieldType);
-      return {
-        ...typeFields,
-        [field.name]: fieldType.toString()
-      };
-    },
-    {}
-  );
-}
 
-// src/codegen/generators/artifacts/operations.ts
-var graphql5 = __toESM(require_graphql2(), 1);
-
-// src/codegen/generators/artifacts/utils.ts
-var graphql4 = __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_graphql = __toESM(require_graphql2(), 1);
+async function includeFragmentDefinitions(config2, documents) {
+  const fragments = collectFragments(config2, documents);
+  for (const [index, { name: name2, document, filename }] of documents.entries()) {
+    const operation = document.definitions.find(
+      ({ kind }) => kind === import_graphql.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(config2, 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_graphql.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(config2, val) {
-  let value;
-  let kind;
-  if (val.kind === graphql4.Kind.INT) {
-    value = parseInt(val.value, 10);
-    kind = "Int";
-  } else if (val.kind === graphql4.Kind.FLOAT) {
-    value = parseFloat(val.value);
-    kind = "Float";
-  } else if (val.kind === graphql4.Kind.BOOLEAN) {
-    value = val.value;
-    kind = "Boolean";
-  } else if (val.kind === graphql4.Kind.VARIABLE) {
-    value = val.name.value;
-    kind = "Variable";
-  } else if (val.kind === graphql4.Kind.STRING) {
-    value = val.value;
-    kind = "String";
+
+// src/codegen/transforms/fragmentVariables.ts
+var GraphqlKinds2 = graphql3.Kind;
+async function fragmentVariables(config2, documents) {
+  const fragments = collectFragments(config2, 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: config2,
+      filepath: doc2.filename,
+      fragmentDefinitions: fragments,
+      document: doc2.document,
+      generatedFragments,
+      visitedFragments,
+      scope: null
+    });
   }
-  return { kind, value };
+  const doc = {
+    kind: graphql3.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(config2, filepath, definition, filterTypes) {
-  if (!definition) {
-    return {};
+function inlineFragmentArgs({
+  config: config2,
+  filepath,
+  fragmentDefinitions,
+  document,
+  generatedFragments,
+  visitedFragments,
+  scope,
+  newName
+}) {
+  if (!scope) {
+    scope = operationScope(
+      document.definitions.find(
+        ({ kind }) => kind === GraphqlKinds2.OPERATION_DEFINITION
+      )
+    );
   }
-  const pathOperations = {};
-  graphql5.visit(definition, {
-    FragmentSpread(node, _, __, ___, ancestors) {
-      if (!config2.isListFragment(node.name.value)) {
-        return;
-      }
-      const path2 = ancestorKey(ancestors);
-      if (!pathOperations[path2]) {
-        pathOperations[path2] = [];
-      }
-      pathOperations[path2].push(
-        operationObject({
+  const definitionArgs = fragmentArguments(
+    config2,
+    filepath,
+    document
+  ).reduce((acc, arg) => ({ ...acc, [arg.name]: arg }), {});
+  const result = graphql3.visit(document, {
+    FragmentSpread(node) {
+      const { definition } = fragmentDefinitions[node.name.value];
+      let { args, hash } = collectWithArguments(config2, filepath, node, scope);
+      const newFragmentName = `${node.name.value}${hash}`;
+      if (!visitedFragments.has(newFragmentName)) {
+        visitedFragments.add(newFragmentName);
+        const defaultArguments = collectDefaultArgumentValues(config2, filepath, definition);
+        if (args) {
+          for (const [field, value] of Object.entries(defaultArguments || {})) {
+            if (!args[field]) {
+              args[field] = value;
+            }
+          }
+          generatedFragments[newFragmentName] = inlineFragmentArgs({
+            config: config2,
+            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: config2,
+              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: graphql3.Kind.NAME,
+      value: newName
+    };
+  }
+  return result;
+}
+function withArguments(config2, node) {
+  const withDirectives = node.directives?.filter(
+    (directive) => directive.name.value === config2.withDirective
+  );
+  if (!withDirectives || withDirectives.length === 0) {
+    return [];
+  }
+  return withDirectives.flatMap((directive) => directive.arguments || []);
+}
+function fragmentArguments(config2, filepath, definition) {
+  const directives = definition.directives?.filter(
+    (directive) => directive.name.value === config2.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(config2, filepath, definition) {
+  let result = {};
+  for (const { name: name2, required, defaultValue } of fragmentArguments(
+    config2,
+    filepath,
+    definition
+  )) {
+    if (required || !defaultValue) {
+      continue;
+    }
+    result[name2] = defaultValue;
+  }
+  return result;
+}
+function collectWithArguments(config2, filepath, node, scope = {}) {
+  const withArgs = withArguments(config2, 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(config2, filepath, definition) {
+  const args = fragmentArguments(config2, 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(config2, docs) {
+  const docsToGenerate = docs.filter((doc) => doc.generateArtifact).sort((a, b) => a.name.localeCompare(b.name));
+  let body = config2.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(config2.artifactDirectory, "index.js"), body);
+}
+
+// src/codegen/generators/artifacts/inputs.ts
+var graphql4 = __toESM(require_graphql2(), 1);
+var recast3 = __toESM(require_main2(), 1);
+var AST3 = recast3.types.builders;
+function inputObject(config2, inputs) {
+  const visitedTypes = /* @__PURE__ */ new Set();
+  const inputObj = {
+    fields: inputs.reduce((fields, input) => {
+      const { type } = unwrapType(config2, input.type);
+      return {
+        ...fields,
+        [input.variable.name.value]: type.name
+      };
+    }, {}),
+    types: {}
+  };
+  for (const input of inputs) {
+    walkInputs(config2, visitedTypes, inputObj, input.type);
+  }
+  return inputObj;
+}
+function walkInputs(config2, visitedTypes, inputObj, rootType) {
+  const { type } = unwrapType(config2, rootType);
+  if (visitedTypes.has(type.name)) {
+    return;
+  }
+  if (graphql4.isEnumType(type) || graphql4.isScalarType(type)) {
+    return;
+  }
+  if (graphql4.isUnionType(type)) {
+    return;
+  }
+  visitedTypes.add(type.name);
+  inputObj.types[type.name] = Object.values(type.getFields()).reduce(
+    (typeFields, field) => {
+      const { type: fieldType } = unwrapType(config2, field.type);
+      walkInputs(config2, visitedTypes, inputObj, fieldType);
+      return {
+        ...typeFields,
+        [field.name]: fieldType.toString()
+      };
+    },
+    {}
+  );
+}
+
+// src/codegen/generators/artifacts/operations.ts
+var graphql6 = __toESM(require_graphql2(), 1);
+
+// src/codegen/generators/artifacts/utils.ts
+var graphql5 = __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(config2, val) {
+  let value;
+  let kind;
+  if (val.kind === graphql5.Kind.INT) {
+    value = parseInt(val.value, 10);
+    kind = "Int";
+  } else if (val.kind === graphql5.Kind.FLOAT) {
+    value = parseFloat(val.value);
+    kind = "Float";
+  } else if (val.kind === graphql5.Kind.BOOLEAN) {
+    value = val.value;
+    kind = "Boolean";
+  } else if (val.kind === graphql5.Kind.VARIABLE) {
+    value = val.name.value;
+    kind = "Variable";
+  } else if (val.kind === graphql5.Kind.STRING) {
+    value = val.value;
+    kind = "String";
+  }
+  return { kind, value };
+}
+
+// src/codegen/generators/artifacts/operations.ts
+function operationsByPath(config2, filepath, definition, filterTypes) {
+  if (!definition) {
+    return {};
+  }
+  const pathOperations = {};
+  graphql6.visit(definition, {
+    FragmentSpread(node, _, __, ___, ancestors) {
+      if (!config2.isListFragment(node.name.value)) {
+        return;
+      }
+      const path2 = ancestorKey(ancestors);
+      if (!pathOperations[path2]) {
+        pathOperations[path2] = [];
+      }
+      pathOperations[path2].push(
+        operationObject({
           config: config2,
           filepath,
           listName: config2.listNameFromFragment(node.name.value),
@@ -55553,7 +55928,7 @@ function ancestorKey(ancestors) {
 }
 
 // src/codegen/generators/artifacts/selection.ts
-var graphql10 = __toESM(require_graphql2(), 1);
+var graphql11 = __toESM(require_graphql2(), 1);
 
 // ../../node_modules/.pnpm/@kitql+helper@0.5.0/node_modules/@kitql/helper/index.mjs
 var config = {
@@ -55593,16 +55968,16 @@ function logYellow(str) {
 }
 
 // src/codegen/transforms/list.ts
-var graphql8 = __toESM(require_graphql2(), 1);
+var graphql9 = __toESM(require_graphql2(), 1);
 
 // src/codegen/utils/objectIdentificationSelection.ts
-var graphql6 = __toESM(require_graphql2(), 1);
+var graphql7 = __toESM(require_graphql2(), 1);
 var objectIdentificationSelection = (config2, type) => {
   return config2.keyFieldsForType(type.name).map((key) => {
     return {
-      kind: graphql6.Kind.FIELD,
+      kind: graphql7.Kind.FIELD,
       name: {
-        kind: graphql6.Kind.NAME,
+        kind: graphql7.Kind.NAME,
         value: key
       }
     };
@@ -55610,7 +55985,7 @@ var objectIdentificationSelection = (config2, type) => {
 };
 
 // src/codegen/transforms/paginate.ts
-var graphql7 = __toESM(require_graphql2(), 1);
+var graphql8 = __toESM(require_graphql2(), 1);
 async function paginate(config2, documents) {
   const newDocs = [];
   for (const doc of documents) {
@@ -55643,7 +56018,7 @@ async function paginate(config2, documents) {
     };
     let cursorType = "String";
     let paginationPath = [];
-    doc.document = graphql7.visit(doc.document, {
+    doc.document = graphql8.visit(doc.document, {
       Field(node, _, __, ___, ancestors) {
         const paginateDirective = node.directives?.find(
           (directive) => directive.name.value === config2.paginateDirective
@@ -55654,23 +56029,22 @@ async function paginate(config2, documents) {
         paginated = true;
         const fieldTypeFields = parentTypeFromAncestors(config2.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 === graphql7.Kind.FIELD
+          (ancestor) => !Array.isArray(ancestor) && ancestor.kind === graphql8.Kind.FIELD
         ).concat(node).map((field) => field.alias?.value || field.name.value);
         return {
           ...node,
@@ -55686,12 +56060,8 @@ async function paginate(config2, documents) {
       let fragmentName = "";
       let refetchQueryName = "";
       let nodeQuery = false;
-      let refetchUpdate = "append" /* append */;
-      if (flags.last.enabled) {
-        refetchUpdate = "prepend" /* prepend */;
-      }
       let fragment = "";
-      doc.document = graphql7.visit(doc.document, {
+      doc.document = graphql8.visit(doc.document, {
         OperationDefinition(node) {
           if (node.operation !== "query") {
             throw new HoudiniError({
@@ -55745,9 +56115,9 @@ async function paginate(config2, documents) {
               directives: [
                 ...node.directives || [],
                 {
-                  kind: graphql7.Kind.DIRECTIVE,
+                  kind: graphql8.Kind.DIRECTIVE,
                   name: {
-                    kind: graphql7.Kind.NAME,
+                    kind: graphql8.Kind.NAME,
                     value: config2.argumentsDirective
                   }
                 }
@@ -55784,42 +56154,40 @@ async function paginate(config2, 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: graphql7.Kind.FRAGMENT_SPREAD,
+          kind: graphql8.Kind.FRAGMENT_SPREAD,
           name: {
-            kind: graphql7.Kind.NAME,
+            kind: graphql8.Kind.NAME,
             value: fragmentName
           },
           directives: [
             {
-              kind: graphql7.Kind.DIRECTIVE,
+              kind: graphql8.Kind.DIRECTIVE,
               name: {
-                kind: graphql7.Kind.NAME,
+                kind: graphql8.Kind.NAME,
                 value: config2.withDirective
               },
               ["arguments"]: paginationArgs.map(
@@ -55847,29 +56215,29 @@ async function paginate(config2, documents) {
       });
       const typeConfig = config2.typeConfig?.[fragment];
       const queryDoc = {
-        kind: graphql7.Kind.DOCUMENT,
+        kind: graphql8.Kind.DOCUMENT,
         definitions: [
           {
-            kind: graphql7.Kind.OPERATION_DEFINITION,
+            kind: graphql8.Kind.OPERATION_DEFINITION,
             name: {
-              kind: graphql7.Kind.NAME,
+              kind: graphql8.Kind.NAME,
               value: refetchQueryName
             },
             operation: "query",
             variableDefinitions: paginationArgs.map(
               (arg) => ({
-                kind: graphql7.Kind.VARIABLE_DEFINITION,
+                kind: graphql8.Kind.VARIABLE_DEFINITION,
                 type: {
-                  kind: graphql7.Kind.NAMED_TYPE,
+                  kind: graphql8.Kind.NAMED_TYPE,
                   name: {
-                    kind: graphql7.Kind.NAME,
+                    kind: graphql8.Kind.NAME,
                     value: arg.type
                   }
                 },
                 variable: {
-                  kind: graphql7.Kind.VARIABLE,
+                  kind: graphql8.Kind.VARIABLE,
                   name: {
-                    kind: graphql7.Kind.NAME,
+                    kind: graphql8.Kind.NAME,
                     value: arg.name
                   }
                 },
@@ -55881,12 +56249,12 @@ async function paginate(config2, documents) {
             ).concat(
               !nodeQuery ? [] : keys.map(
                 (key) => ({
-                  kind: graphql7.Kind.VARIABLE_DEFINITION,
+                  kind: graphql8.Kind.VARIABLE_DEFINITION,
                   type: key.type,
                   variable: {
-                    kind: graphql7.Kind.VARIABLE,
+                    kind: graphql8.Kind.VARIABLE,
                     name: {
-                      kind: graphql7.Kind.NAME,
+                      kind: graphql8.Kind.NAME,
                       value: key.name
                     }
                   }
@@ -55894,42 +56262,42 @@ async function paginate(config2, documents) {
               )
             ),
             selectionSet: {
-              kind: graphql7.Kind.SELECTION_SET,
+              kind: graphql8.Kind.SELECTION_SET,
               selections: !nodeQuery ? fragmentSpreadSelection : [
                 {
-                  kind: graphql7.Kind.FIELD,
+                  kind: graphql8.Kind.FIELD,
                   name: {
-                    kind: graphql7.Kind.NAME,
+                    kind: graphql8.Kind.NAME,
                     value: typeConfig?.resolve?.queryField || "node"
                   },
                   ["arguments"]: keys.map((key) => ({
-                    kind: graphql7.Kind.ARGUMENT,
+                    kind: graphql8.Kind.ARGUMENT,
                     name: {
-                      kind: graphql7.Kind.NAME,
+                      kind: graphql8.Kind.NAME,
                       value: key.name
                     },
                     value: {
-                      kind: graphql7.Kind.VARIABLE,
+                      kind: graphql8.Kind.VARIABLE,
                       name: {
-                        kind: graphql7.Kind.NAME,
+                        kind: graphql8.Kind.NAME,
                         value: key.name
                       }
                     }
                   })),
                   selectionSet: {
-                    kind: graphql7.Kind.SELECTION_SET,
+                    kind: graphql8.Kind.SELECTION_SET,
                     selections: [
                       {
-                        kind: graphql7.Kind.FIELD,
+                        kind: graphql8.Kind.FIELD,
                         name: {
-                          kind: graphql7.Kind.NAME,
+                          kind: graphql8.Kind.NAME,
                           value: "__typename"
                         }
                       },
                       ...(typeConfig?.keys || ["id"]).map((key) => ({
-                        kind: graphql7.Kind.FIELD,
+                        kind: graphql8.Kind.FIELD,
                         name: {
-                          kind: graphql7.Kind.NAME,
+                          kind: graphql8.Kind.NAME,
                           value: key
                         }
                       })),
@@ -55979,27 +56347,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: graphql7.Kind.ARGUMENT,
+    kind: graphql8.Kind.ARGUMENT,
     name: {
-      kind: graphql7.Kind.NAME,
+      kind: graphql8.Kind.NAME,
       value: name2
     },
     value: {
-      kind: graphql7.Kind.VARIABLE,
+      kind: graphql8.Kind.VARIABLE,
       name: {
-        kind: graphql7.Kind.NAME,
+        kind: graphql8.Kind.NAME,
         value: variable ?? name2
       }
     }
@@ -56007,18 +56369,18 @@ function variableAsArgument(name2, variable) {
 }
 function staticVariableDefinition(name2, type, defaultValue, variableName) {
   return {
-    kind: graphql7.Kind.VARIABLE_DEFINITION,
+    kind: graphql8.Kind.VARIABLE_DEFINITION,
     type: {
-      kind: graphql7.Kind.NAMED_TYPE,
+      kind: graphql8.Kind.NAMED_TYPE,
       name: {
-        kind: graphql7.Kind.NAME,
+        kind: graphql8.Kind.NAME,
         value: type
       }
     },
     variable: {
-      kind: graphql7.Kind.VARIABLE,
+      kind: graphql8.Kind.VARIABLE,
       name: {
-        kind: graphql7.Kind.NAME,
+        kind: graphql8.Kind.NAME,
         value: variableName ?? name2
       }
     },
@@ -56030,9 +56392,9 @@ function staticVariableDefinition(name2, type, defaultValue, variableName) {
 }
 function argumentNode(name2, value) {
   return {
-    kind: graphql7.Kind.ARGUMENT,
+    kind: graphql8.Kind.ARGUMENT,
     name: {
-      kind: graphql7.Kind.NAME,
+      kind: graphql8.Kind.NAME,
       value: name2
     },
     value: objectNode(value)
@@ -56040,16 +56402,16 @@ function argumentNode(name2, value) {
 }
 function objectNode([type, defaultValue]) {
   const node = {
-    kind: graphql7.Kind.OBJECT,
+    kind: graphql8.Kind.OBJECT,
     fields: [
       {
-        kind: graphql7.Kind.OBJECT_FIELD,
+        kind: graphql8.Kind.OBJECT_FIELD,
         name: {
-          kind: graphql7.Kind.NAME,
+          kind: graphql8.Kind.NAME,
           value: "type"
         },
         value: {
-          kind: graphql7.Kind.STRING,
+          kind: graphql8.Kind.STRING,
           value: type
         }
       }
@@ -56057,8 +56419,8 @@ function objectNode([type, defaultValue]) {
   };
   if (defaultValue) {
     node.fields.push({
-      kind: graphql7.Kind.OBJECT_FIELD,
-      name: { kind: graphql7.Kind.NAME, value: "default" },
+      kind: graphql8.Kind.OBJECT_FIELD,
+      name: { kind: graphql8.Kind.NAME, value: "default" },
       value: {
         kind: typeof defaultValue === "number" ? "IntValue" : "StringValue",
         value: defaultValue.toString()
@@ -56069,34 +56431,34 @@ function objectNode([type, defaultValue]) {
 }
 var pageInfoSelection = [
   {
-    kind: graphql7.Kind.FIELD,
+    kind: graphql8.Kind.FIELD,
     name: {
-      kind: graphql7.Kind.NAME,
+      kind: graphql8.Kind.NAME,
       value: "edges"
     },
     selectionSet: {
-      kind: graphql7.Kind.SELECTION_SET,
+      kind: graphql8.Kind.SELECTION_SET,
       selections: [
         {
-          kind: graphql7.Kind.FIELD,
+          kind: graphql8.Kind.FIELD,
           name: {
-            kind: graphql7.Kind.NAME,
+            kind: graphql8.Kind.NAME,
             value: "cursor"
           }
         },
         {
-          kind: graphql7.Kind.FIELD,
+          kind: graphql8.Kind.FIELD,
           name: {
-            kind: graphql7.Kind.NAME,
+            kind: graphql8.Kind.NAME,
             value: "node"
           },
           selectionSet: {
-            kind: graphql7.Kind.SELECTION_SET,
+            kind: graphql8.Kind.SELECTION_SET,
             selections: [
               {
-                kind: graphql7.Kind.FIELD,
+                kind: graphql8.Kind.FIELD,
                 name: {
-                  kind: graphql7.Kind.NAME,
+                  kind: graphql8.Kind.NAME,
                   value: "__typename"
                 }
               }
@@ -56107,39 +56469,39 @@ var pageInfoSelection = [
     }
   },
   {
-    kind: graphql7.Kind.FIELD,
+    kind: graphql8.Kind.FIELD,
     name: {
-      kind: graphql7.Kind.NAME,
+      kind: graphql8.Kind.NAME,
       value: "pageInfo"
     },
     selectionSet: {
-      kind: graphql7.Kind.SELECTION_SET,
+      kind: graphql8.Kind.SELECTION_SET,
       selections: [
         {
-          kind: graphql7.Kind.FIELD,
+          kind: graphql8.Kind.FIELD,
           name: {
-            kind: graphql7.Kind.NAME,
+            kind: graphql8.Kind.NAME,
             value: "hasPreviousPage"
           }
         },
         {
-          kind: graphql7.Kind.FIELD,
+          kind: graphql8.Kind.FIELD,
           name: {
-            kind: graphql7.Kind.NAME,
+            kind: graphql8.Kind.NAME,
             value: "hasNextPage"
           }
         },
         {
-          kind: graphql7.Kind.FIELD,
+          kind: graphql8.Kind.FIELD,
           name: {
-            kind: graphql7.Kind.NAME,
+            kind: graphql8.Kind.NAME,
             value: "startCursor"
           }
         },
         {
-          kind: graphql7.Kind.FIELD,
+          kind: graphql8.Kind.FIELD,
           name: {
-            kind: graphql7.Kind.NAME,
+            kind: graphql8.Kind.NAME,
             value: "endCursor"
           }
         }
@@ -56153,15 +56515,15 @@ async function addListFragments(config2, documents) {
   const lists = {};
   const errors = [];
   for (const doc of documents) {
-    doc.document = graphql8.visit(doc.document, {
+    doc.document = graphql9.visit(doc.document, {
       Directive(node, key, parent, path2, ancestors) {
         if ([config2.listDirective, config2.paginateDirective].includes(node.name.value)) {
           const nameArg = node.arguments?.find((arg) => arg.name.value === "name");
           let error = {
-            ...new graphql8.GraphQLError(
+            ...new graphql9.GraphQLError(
               "",
               node,
-              new graphql8.Source(""),
+              new graphql9.Source(""),
               node.loc ? [node.loc.start, node.loc.end] : null,
               path2
             ),
@@ -56213,7 +56575,7 @@ async function addListFragments(config2, documents) {
                 {
                   kind: "Argument",
                   name: {
-                    kind: graphql8.Kind.NAME,
+                    kind: graphql9.Kind.NAME,
                     value: "connection"
                   },
                   value: {
@@ -56263,7 +56625,7 @@ async function addListFragments(config2, documents) {
   const validDeletes = [
     ...new Set(
       Object.values(lists).map(({ type }) => {
-        if (!(type instanceof graphql8.GraphQLObjectType)) {
+        if (!(type instanceof graphql9.GraphQLObjectType)) {
           return "";
         }
         if (config2.keyFieldsForType(type.name).length !== 1) {
@@ -56277,7 +56639,7 @@ async function addListFragments(config2, documents) {
     return;
   }
   const generatedDoc = {
-    kind: graphql8.Kind.DOCUMENT,
+    kind: graphql9.Kind.DOCUMENT,
     definitions: Object.entries(lists).flatMap(
       ([name2, { selection: selection2, type }]) => {
         const schemaType = config2.schema.getType(type.name);
@@ -56285,7 +56647,7 @@ async function addListFragments(config2, documents) {
           throw new HoudiniError({ message: "Lists must have a selection" });
         }
         const fragmentSelection = {
-          kind: graphql8.Kind.SELECTION_SET,
+          kind: graphql9.Kind.SELECTION_SET,
           selections: [...selection2.selections]
         };
         if (schemaType && fragmentSelection && !fragmentSelection?.selections.find(
@@ -56300,14 +56662,14 @@ async function addListFragments(config2, documents) {
           {
             name: {
               value: config2.listInsertFragment(name2),
-              kind: graphql8.Kind.NAME
+              kind: graphql9.Kind.NAME
             },
-            kind: graphql8.Kind.FRAGMENT_DEFINITION,
+            kind: graphql9.Kind.FRAGMENT_DEFINITION,
             selectionSet: fragmentSelection,
             typeCondition: {
-              kind: graphql8.Kind.NAMED_TYPE,
+              kind: graphql9.Kind.NAMED_TYPE,
               name: {
-                kind: graphql8.Kind.NAME,
+                kind: graphql9.Kind.NAME,
                 value: type.name
               }
             }
@@ -56315,32 +56677,32 @@ async function addListFragments(config2, documents) {
           {
             name: {
               value: config2.listToggleFragment(name2),
-              kind: graphql8.Kind.NAME
+              kind: graphql9.Kind.NAME
             },
-            kind: graphql8.Kind.FRAGMENT_DEFINITION,
+            kind: graphql9.Kind.FRAGMENT_DEFINITION,
             selectionSet: fragmentSelection,
             typeCondition: {
-              kind: graphql8.Kind.NAMED_TYPE,
+              kind: graphql9.Kind.NAMED_TYPE,
               name: {
-                kind: graphql8.Kind.NAME,
+                kind: graphql9.Kind.NAME,
                 value: type.name
               }
             }
           },
           {
-            kind: graphql8.Kind.FRAGMENT_DEFINITION,
+            kind: graphql9.Kind.FRAGMENT_DEFINITION,
             name: {
               value: config2.listRemoveFragment(name2),
-              kind: graphql8.Kind.NAME
+              kind: graphql9.Kind.NAME
             },
             selectionSet: {
-              kind: graphql8.Kind.SELECTION_SET,
+              kind: graphql9.Kind.SELECTION_SET,
               selections: [...objectIdentificationSelection(config2, type)]
             },
             typeCondition: {
-              kind: graphql8.Kind.NAMED_TYPE,
+              kind: graphql9.Kind.NAMED_TYPE,
               name: {
-                kind: graphql8.Kind.NAME,
+                kind: graphql9.Kind.NAME,
                 value: type.name
               }
             }
@@ -56349,14 +56711,14 @@ async function addListFragments(config2, documents) {
       }
     ).concat(
       ...validDeletes.map((typeName) => ({
-        kind: graphql8.Kind.DIRECTIVE_DEFINITION,
+        kind: graphql9.Kind.DIRECTIVE_DEFINITION,
         name: {
-          kind: graphql8.Kind.NAME,
+          kind: graphql9.Kind.NAME,
           value: config2.listDeleteDirective(typeName)
         },
         locations: [
           {
-            kind: graphql8.Kind.NAME,
+            kind: graphql9.Kind.NAME,
             value: "FIELD"
           }
         ],
@@ -56364,8 +56726,8 @@ async function addListFragments(config2, documents) {
       }))
     )
   };
-  config2.newSchema += "\n" + generatedDoc.definitions.filter((c) => c.kind !== "FragmentDefinition").map(graphql8.print).join("\n\n");
-  config2.newDocuments += "\n" + generatedDoc.definitions.filter((c) => c.kind === "FragmentDefinition").map(graphql8.print).join("\n\n");
+  config2.newSchema += "\n" + generatedDoc.definitions.filter((c) => c.kind !== "FragmentDefinition").map(graphql9.print).join("\n\n");
+  config2.newDocuments += "\n" + generatedDoc.definitions.filter((c) => c.kind === "FragmentDefinition").map(graphql9.print).join("\n\n");
   documents.push({
     name: "generated::lists",
     kind: "HoudiniFragment" /* Fragment */,
@@ -56450,11 +56812,11 @@ var nodeNotDefinedMessage = (config2) => `Looks like you are trying to use the $
 For more information, visit this link: ${siteURL}/guides/pagination`;
 
 // src/codegen/generators/artifacts/fieldKey.ts
-var graphql9 = __toESM(require_graphql2(), 1);
+var graphql10 = __toESM(require_graphql2(), 1);
 function fieldKey(config2, field) {
   const attributeName = field.alias?.value || field.name.value;
-  const printed = graphql9.print(field);
-  const secondParse = graphql9.parse(`{${printed}}`).definitions[0].selectionSet.selections[0];
+  const printed = graphql10.print(field);
+  const secondParse = graphql10.parse(`{${printed}}`).definitions[0].selectionSet.selections[0];
   const paginated = !!field.directives?.find(
     (directive) => directive.name.value === config2.paginateDirective
   );
@@ -56492,7 +56854,7 @@ function selection({
   path: path2 = [],
   includeFragments,
   document,
-  markEdges
+  inConnection
 }) {
   let object = {};
   const typeMap = {};
@@ -56549,8 +56911,8 @@ function selection({
         const typeConditionName = field.typeCondition.name.value;
         const typeCondition = config2.schema.getType(typeConditionName);
         const possibleTypes = [];
-        if (!graphql10.isAbstractType(typeCondition)) {
-        } else if (graphql10.isAbstractType(parentType)) {
+        if (!graphql11.isAbstractType(typeCondition)) {
+        } else if (graphql11.isAbstractType(parentType)) {
           const possibleParentTypes = config2.schema.getPossibleTypes(parentType).map((type) => type.name);
           for (const possible of config2.schema.getPossibleTypes(typeCondition)) {
             if (possibleParentTypes.includes(possible.name)) {
@@ -56598,7 +56960,7 @@ function selection({
       } else {
         let typeRef = type.getFields()[field.name.value].type;
         fieldType = getRootType(typeRef);
-        nullable = !graphql10.isNonNullType(typeRef);
+        nullable = !graphql11.isNonNullType(typeRef);
       }
       const typeName = fieldType.toString();
       const pathSoFar = path2.concat(attributeName);
@@ -56634,14 +56996,23 @@ function selection({
         (directive) => directive.name.value === config2.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: config2,
           filepath,
@@ -56651,7 +57022,7 @@ function selection({
           path: pathSoFar,
           includeFragments,
           document,
-          markEdges: edgesMark
+          inConnection: connectionState
         });
       }
       if (field.arguments?.length && fieldObj.list) {
@@ -56663,7 +57034,7 @@ function selection({
           {}
         );
       }
-      if (graphql10.isInterfaceType(fieldType) || graphql10.isUnionType(fieldType)) {
+      if (graphql11.isInterfaceType(fieldType) || graphql11.isUnionType(fieldType)) {
         fieldObj.abstract = true;
       }
       object.fields = {
@@ -56720,7 +57091,7 @@ function artifactGenerator(stats) {
   return async function(config2, docs) {
     const filterTypes = {};
     for (const doc of docs) {
-      graphql11.visit(doc.document, {
+      graphql12.visit(doc.document, {
         Directive(node, _, __, ___, ancestors) {
           if (node.name.value !== config2.listDirective) {
             return;
@@ -56779,7 +57150,7 @@ function artifactGenerator(stats) {
             return;
           }
           const usedVariableNames = /* @__PURE__ */ new Set();
-          let documentWithoutInternalDirectives = graphql11.visit(document, {
+          let documentWithoutInternalDirectives = graphql12.visit(document, {
             Directive(node) {
               if (config2.isInternalDirective(node)) {
                 return null;
@@ -56792,7 +57163,7 @@ function artifactGenerator(stats) {
               }
             }
           });
-          let documentWithoutExtraVariables = graphql11.visit(
+          let documentWithoutExtraVariables = graphql12.visit(
             documentWithoutInternalDirectives,
             {
               VariableDefinition(variableDefinitionNode) {
@@ -56803,13 +57174,13 @@ function artifactGenerator(stats) {
               }
             }
           );
-          let rawString = graphql11.print(documentWithoutExtraVariables);
+          let rawString = graphql12.print(documentWithoutExtraVariables);
           let docKind = doc.kind;
           const operations = document.definitions.filter(
-            ({ kind }) => kind === graphql11.Kind.OPERATION_DEFINITION
+            ({ kind }) => kind === graphql12.Kind.OPERATION_DEFINITION
           );
           const fragments = document.definitions.filter(
-            ({ kind }) => kind === graphql11.Kind.FRAGMENT_DEFINITION
+            ({ kind }) => kind === graphql12.Kind.FRAGMENT_DEFINITION
           );
           let rootType = "";
           let selectionSet;
@@ -56842,7 +57213,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 === config2.argumentsDirective
+          );
+          if (docKind === "HoudiniFragment" /* Fragment */ && directive) {
+            inputs = fragmentArgumentsDefinitions(config2, doc.filename, fragments[0]);
+          }
           const mergedSelection = flattenSelections({
             config: config2,
             filepath: doc.filename,
@@ -56903,7 +57280,7 @@ function artifactGenerator(stats) {
           }
           if (docKind === "HoudiniQuery") {
             const cacheDirective = operations[0].directives?.find(
-              (directive) => directive.name.value === config2.cacheDirective
+              (directive2) => directive2.name.value === config2.cacheDirective
             );
             if (cacheDirective) {
               const args = cacheDirective.arguments?.reduce(
@@ -57119,19 +57496,19 @@ async function generatePluginRuntime(config2, 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 graphql14 = __toESM(require_graphql2(), 1);
+var graphql15 = __toESM(require_graphql2(), 1);
 var recast9 = __toESM(require_main2(), 1);
 
 // src/codegen/generators/typescript/typeReference.ts
-var graphql13 = __toESM(require_graphql2(), 1);
+var graphql14 = __toESM(require_graphql2(), 1);
 var recast8 = __toESM(require_main2(), 1);
 
 // src/codegen/generators/typescript/types.ts
-var graphql12 = __toESM(require_graphql2(), 1);
+var graphql13 = __toESM(require_graphql2(), 1);
 var recast7 = __toESM(require_main2(), 1);
 var AST7 = recast7.types.builders;
 function readonlyProperty(prop, enable = true) {
@@ -57162,336 +57539,89 @@ function scalarPropertyValue(config2, missingScalars, target) {
       return AST7.tsBooleanKeyword();
     }
     case "ID": {
-      return AST7.tsStringKeyword();
-    }
-    default: {
-      if (graphql12.isNonNullType(target) && "ofType" in target) {
-        return scalarPropertyValue(
-          config2,
-          missingScalars,
-          target.ofType
-        );
-      }
-      if (config2.scalars?.[target.name]) {
-        return AST7.tsTypeReference(AST7.identifier(config2.scalars?.[target.name].type));
-      }
-      missingScalars.add(target.name);
-      return AST7.tsAnyKeyword();
-    }
-  }
-}
-
-// src/codegen/generators/typescript/typeReference.ts
-var AST8 = recast8.types.builders;
-function tsTypeReference(config2, missingScalars, definition) {
-  const { type, wrappers } = unwrapType(config2, definition.type);
-  let result;
-  if (graphql13.isScalarType(type)) {
-    result = scalarPropertyValue(config2, 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(config2, filepath, body, visitedTypes, missingScalars, rootType) {
-  const { type } = unwrapType(config2, rootType);
-  if (graphql14.isScalarType(type)) {
-    return;
-  }
-  if (visitedTypes.has(type.name)) {
-    return;
-  }
-  if (graphql14.isUnionType(type)) {
-    throw new HoudiniError({ filepath, message: "Input Unions are not supported yet. Sorry!" });
-  }
-  visitedTypes.add(type.name);
-  if (graphql14.isEnumType(type)) {
-    ensureImports({
-      config: config2,
-      body,
-      import: [type.name],
-      sourceModule: "$houdini/graphql/enums",
-      importKind: "type"
-    });
-    return;
-  }
-  const members = [];
-  for (const field of Object.values(type.getFields())) {
-    addReferencedInputTypes(config2, filepath, body, visitedTypes, missingScalars, field.type);
-    members.push(
-      AST9.tsPropertySignature(
-        AST9.identifier(field.name),
-        AST9.tsTypeAnnotation(tsTypeReference(config2, missingScalars, field)),
-        graphql14.isNullableType(field.type)
-      )
-    );
-  }
-  body.push(AST9.tsTypeAliasDeclaration(AST9.identifier(type.name), AST9.tsTypeLiteral(members)));
-}
-
-// src/codegen/generators/typescript/imperativeCache.ts
-var graphql15 = __toESM(require_graphql2(), 1);
-var recast10 = __toESM(require_main2(), 1);
-var AST10 = recast10.types.builders;
-async function imperativeCacheTypef(config2, docs) {
-  const target = path_exports.join(config2.runtimeDirectory, "generated.d.ts");
-  const body = [];
-  const declaration = AST10.tsTypeAliasDeclaration(
-    AST10.identifier(CacheTypeDefName),
-    AST10.tsTypeLiteral([
-      AST10.tsPropertySignature(
-        AST10.identifier("types"),
-        AST10.tsTypeAnnotation(typeDefinitions(config2, body))
-      ),
-      AST10.tsPropertySignature(
-        AST10.identifier("lists"),
-        AST10.tsTypeAnnotation(listDefinitions(config2, 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(config2, body) {
-  const operationTypes = [config2.schema.getMutationType(), config2.schema.getSubscriptionType()].filter(Boolean).map((type) => type?.name);
-  const visitedTypes = /* @__PURE__ */ new Set();
-  const types14 = Object.values(config2.schema.getTypeMap()).filter(
-    (type) => !graphql15.isAbstractType(type) && !graphql15.isScalarType(type) && !graphql15.isEnumType(type) && !graphql15.isInputObjectType(type) && !type.name.startsWith("__") && !operationTypes.includes(type.name)
-  );
-  return AST10.tsTypeLiteral(
-    types14.map((type) => {
-      let typeName = type.name;
-      if (config2.schema.getQueryType() && config2.schema.getQueryType()?.name === type.name) {
-        typeName = "__ROOT__";
-      }
-      let idFields = AST10.tsNeverKeyword();
-      const keys = keyFieldsForType(config2.configFile, type.name);
-      if (graphql15.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(config2, fieldType.type);
-            return AST10.tsPropertySignature(
-              AST10.identifier(key),
-              AST10.tsTypeAnnotation(
-                scalarPropertyValue(config2, /* @__PURE__ */ new Set(), unwrapped.type)
-              )
-            );
-          })
-        );
-      } else if (typeName === "__ROOT__") {
-        idFields = AST10.tsTypeLiteral([]);
-      }
-      let fields = AST10.tsTypeLiteral([]);
-      if (graphql15.isObjectType(type)) {
-        fields = AST10.tsTypeLiteral(
-          Object.entries(type.getFields()).map(
-            ([key, fieldType]) => {
-              const unwrapped = unwrapType(config2, fieldType.type);
-              let typeOptions = AST10.tsUnionType([]);
-              if (graphql15.isScalarType(unwrapped.type)) {
-                typeOptions.types.push(
-                  scalarPropertyValue(config2, /* @__PURE__ */ new Set(), unwrapped.type)
-                );
-              } else if (graphql15.isEnumType(unwrapped.type)) {
-                typeOptions.types.push(
-                  AST10.tsTypeReference(AST10.identifier(unwrapped.type.name))
-                );
-              } else if (!graphql15.isAbstractType(unwrapped.type)) {
-                typeOptions.types.push(record(unwrapped.type.name));
-              } else {
-                typeOptions.types.push(
-                  ...config2.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(
-                      config2,
-                      "",
-                      body,
-                      visitedTypes,
-                      /* @__PURE__ */ new Set(),
-                      arg.type
-                    );
-                    const prop = AST10.tsPropertySignature(
-                      AST10.identifier(arg.name),
-                      AST10.tsTypeAnnotation(
-                        tsTypeReference(config2, /* @__PURE__ */ new Set(), arg)
-                      )
-                    );
-                    const unwrapped2 = unwrapType(config2, 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 (graphql13.isNonNullType(target) && "ofType" in target) {
+        return scalarPropertyValue(
+          config2,
+          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(config2, docs) {
-  const lists = [];
-  const visitedLists = /* @__PURE__ */ new Set();
-  for (const doc of docs) {
-    graphql15.visit(doc.document, {
-      Directive(node, key, parent, path2, ancestors) {
-        if (![config2.listDirective, config2.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(
-          config2.schema,
-          doc.filename,
-          ancestors.slice(0, -1)
-        );
-        const targetField = ancestors[ancestors.length - 1];
-        const targetFieldDefinition = parentType.getFields()[targetField.name.value];
-        const { type: listType } = unwrapType(config2, targetFieldDefinition.type);
-        const possibleTypes = [];
-        if (graphql15.isAbstractType(listType)) {
-          possibleTypes.push(
-            ...config2.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(
-                              config2,
-                              /* @__PURE__ */ new Set(),
-                              arg
-                            )
-                          )
-                        );
-                        argDef.optional = true;
-                        return argDef;
-                      })
-                    )
-                  )
-                )
-              ])
-            )
-          )
-        );
+      if (config2.scalars?.[target.name]) {
+        return AST7.tsTypeReference(AST7.identifier(config2.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(config2, missingScalars, definition) {
+  const { type, wrappers } = unwrapType(config2, definition.type);
+  let result;
+  if (graphql14.isScalarType(type)) {
+    result = scalarPropertyValue(config2, 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(config2, filepath, body, visitedTypes, missingScalars, rootType) {
+  const { type } = unwrapType(config2, rootType);
+  if (graphql15.isScalarType(type)) {
+    return;
+  }
+  if (visitedTypes.has(type.name)) {
+    return;
+  }
+  if (graphql15.isUnionType(type)) {
+    throw new HoudiniError({ filepath, message: "Input Unions are not supported yet. Sorry!" });
+  }
+  visitedTypes.add(type.name);
+  if (graphql15.isEnumType(type)) {
+    ensureImports({
+      config: config2,
+      body,
+      import: [type.name],
+      sourceModule: "$houdini/graphql/enums",
+      importKind: "type"
+    });
+    return;
+  }
+  const members = [];
+  for (const field of Object.values(type.getFields())) {
+    addReferencedInputTypes(config2, filepath, body, visitedTypes, missingScalars, field.type);
+    members.push(
+      AST9.tsPropertySignature(
+        AST9.identifier(field.name),
+        AST9.tsTypeAnnotation(tsTypeReference(config2, missingScalars, field)),
+        graphql15.isNullableType(field.type)
+      )
+    );
+  }
+  body.push(AST9.tsTypeAliasDeclaration(AST9.identifier(type.name), AST9.tsTypeLiteral(members)));
 }
 
 // src/codegen/generators/typescript/inlineType.ts
 var graphql16 = __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: config2,
@@ -57520,7 +57650,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 = {};
@@ -57571,7 +57701,7 @@ function inlineType({
         selectedFields.push(selection2);
       }
     }
-    result = AST11.tsTypeLiteral([
+    result = AST10.tsTypeLiteral([
       ...(selectedFields || []).filter(
         (field) => field.kind === "Field"
       ).map((selection2) => {
@@ -57591,9 +57721,9 @@ function inlineType({
           allOptional
         });
         const prop = readonlyProperty(
-          AST11.tsPropertySignature(
-            AST11.identifier(attributeName),
-            AST11.tsTypeAnnotation(attributeType)
+          AST10.tsPropertySignature(
+            AST10.identifier(attributeName),
+            AST10.tsTypeAnnotation(attributeType)
           ),
           allowReadonly
         );
@@ -57607,15 +57737,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))
                     )
                   )
                 )
@@ -57661,9 +57791,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
           )
@@ -57674,8 +57804,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(
@@ -57688,9 +57818,9 @@ function inlineType({
           );
         }
       );
-      result = AST11.tsIntersectionType([
+      result = AST10.tsIntersectionType([
         result,
-        AST11.tsParenthesizedType(AST11.tsUnionType(selectionTypes))
+        AST10.tsParenthesizedType(AST10.tsUnionType(selectionTypes))
       ]);
     }
   } else {
@@ -57702,7 +57832,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;
@@ -57746,9 +57876,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(config2, docs) {
+// src/codegen/generators/typescript/documentTypes.ts
+var AST11 = recast11.types.builders;
+async function generateDocumentTypes(config2, docs) {
   const typePaths = [];
   const fragmentDefinitions = {};
   for (const document of docs) {
@@ -57765,7 +57895,7 @@ async function typescriptGenerator(config2, docs) {
         return;
       }
       const typeDefPath = config2.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
@@ -57798,21 +57928,21 @@ async function typescriptGenerator(config2, 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(config2.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 }) => `
@@ -57821,7 +57951,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 config2.plugins) {
     if (!plugin.index_file) {
       continue;
@@ -57842,7 +57972,6 @@ export * from "${module2}"
     }
   }
   await fs_exports.writeFile(config2.typeIndexPath, indexContent);
-  await imperativeCacheTypef(config2, docs);
   if (missingScalars.size > 0) {
     console.warn(`\u26A0\uFE0F  Missing definitions for the following scalars: ${[...missingScalars].join(
       ", "
@@ -57884,23 +58013,23 @@ async function generateOperationTypeDefs(config2, 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()
                 ])
               )
             )
@@ -57908,9 +58037,9 @@ async function generateOperationTypeDefs(config2, filepath, body, definition, se
         ])
       )
     ),
-    AST12.exportNamedDeclaration(
-      AST12.tsTypeAliasDeclaration(
-        AST12.identifier(shapeTypeName),
+    AST11.exportNamedDeclaration(
+      AST11.tsTypeAliasDeclaration(
+        AST11.identifier(shapeTypeName),
         inlineType({
           config: config2,
           filepath,
@@ -57938,15 +58067,15 @@ async function generateOperationTypeDefs(config2, 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(config2, missingScalars, definition2)
                   ),
                   definition2.type.kind !== "NonNullType"
@@ -57959,16 +58088,16 @@ async function generateOperationTypeDefs(config2, 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: config2,
             filepath,
@@ -57994,65 +58123,463 @@ async function generateFragmentTypeDefs(config2, filepath, body, selections, def
     }
     const propTypeName = definition.name.value;
     const shapeTypeName = `${definition.name.value}$data`;
+    const inputTypeName = `${definition.name.value}$input`;
     const type = config2.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 === config2.argumentsDirective
+    );
+    if (directive) {
+      extraExports.push(
+        AST11.exportNamedDeclaration(
+          AST11.tsTypeAliasDeclaration(
+            AST11.identifier(inputTypeName),
+            AST11.tsTypeLiteral(
+              (fragmentArgumentsDefinitions(config2, filepath, definition) || []).map(
+                (definition2) => {
+                  return AST11.tsPropertySignature(
+                    AST11.identifier(definition2.variable.name.value),
+                    AST11.tsTypeAnnotation(
+                      tsTypeReference(config2, 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: config2,
+            filepath,
+            rootType: type,
+            selections,
+            root: true,
+            allowReadonly: true,
+            body,
+            visitedTypes,
+            missingScalars,
+            includeFragments: true
+          })
+        )
+      )
+    );
+  }
+}
+
+// src/codegen/generators/typescript/imperativeTypeDef.ts
+var graphql17 = __toESM(require_graphql2(), 1);
+var recast12 = __toESM(require_main2(), 1);
+var AST12 = recast12.types.builders;
+async function imperativeCacheTypef(config2, docs) {
+  const returnType = (doc) => config2.plugins.find((plugin) => plugin.graphql_tag_return)?.graphql_tag_return?.({
+    config: config2,
+    doc,
+    ensure_import({ identifier, module: module2 }) {
+      ensureImports({
+        config: config2,
+        body,
+        sourceModule: module2,
+        import: [identifier]
+      });
+    }
+  }) ?? "any";
+  const target = path_exports.join(config2.runtimeDirectory, "generated.d.ts");
+  const body = [];
+  const declaration = AST12.tsTypeAliasDeclaration(
+    AST12.identifier(CacheTypeDefName),
+    AST12.tsTypeLiteral([
+      AST12.tsPropertySignature(
+        AST12.identifier("types"),
+        AST12.tsTypeAnnotation(typeDefinitions(config2, body, docs, returnType))
+      ),
+      AST12.tsPropertySignature(
+        AST12.identifier("lists"),
+        AST12.tsTypeAnnotation(listDefinitions(config2, docs))
+      ),
+      AST12.tsPropertySignature(
+        AST12.identifier("queries"),
+        AST12.tsTypeAnnotation(queryDefinitions(config2, 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(config2, body, docs, returnType) {
+  const operationTypes = [config2.schema.getMutationType(), config2.schema.getSubscriptionType()].filter(Boolean).map((type) => type?.name);
+  const visitedTypes = /* @__PURE__ */ new Set();
+  const types14 = Object.values(config2.schema.getTypeMap()).filter(
+    (type) => !graphql17.isAbstractType(type) && !graphql17.isScalarType(type) && !graphql17.isEnumType(type) && !graphql17.isInputObjectType(type) && !type.name.startsWith("__") && !operationTypes.includes(type.name)
+  );
+  const fragmentMap = fragmentListMap(
+    config2,
+    types14.map((type) => type.name),
+    body,
+    docs,
+    returnType
+  );
+  return AST12.tsTypeLiteral(
+    types14.map((type) => {
+      let typeName = type.name;
+      if (config2.schema.getQueryType() && config2.schema.getQueryType()?.name === type.name) {
+        typeName = "__ROOT__";
+      }
+      let idFields = AST12.tsNeverKeyword();
+      const keys = keyFieldsForType(config2.configFile, type.name);
+      if (graphql17.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(config2, fieldType.type);
+            return AST12.tsPropertySignature(
+              AST12.identifier(key),
+              AST12.tsTypeAnnotation(
+                scalarPropertyValue(config2, /* @__PURE__ */ new Set(), unwrapped.type)
+              )
+            );
+          })
+        );
+      } else if (typeName === "__ROOT__") {
+        idFields = AST12.tsTypeLiteral([]);
+      }
+      let fields = AST12.tsTypeLiteral([]);
+      if (graphql17.isObjectType(type)) {
+        fields = AST12.tsTypeLiteral(
+          Object.entries(type.getFields()).map(
+            ([key, fieldType]) => {
+              const unwrapped = unwrapType(config2, fieldType.type);
+              let typeOptions = AST12.tsUnionType([]);
+              if (graphql17.isScalarType(unwrapped.type)) {
+                typeOptions.types.push(
+                  scalarPropertyValue(config2, /* @__PURE__ */ new Set(), unwrapped.type)
+                );
+              } else if (graphql17.isEnumType(unwrapped.type)) {
+                typeOptions.types.push(
+                  AST12.tsTypeReference(AST12.identifier(unwrapped.type.name))
+                );
+              } else if (!graphql17.isAbstractType(unwrapped.type)) {
+                typeOptions.types.push(record(unwrapped.type.name));
+              } else {
+                typeOptions.types.push(
+                  ...config2.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(
+                      config2,
+                      "",
+                      body,
+                      visitedTypes,
+                      /* @__PURE__ */ new Set(),
+                      arg.type
+                    );
+                    const prop = AST12.tsPropertySignature(
+                      AST12.identifier(arg.name),
+                      AST12.tsTypeAnnotation(
+                        tsTypeReference(config2, /* @__PURE__ */ new Set(), arg)
+                      )
+                    );
+                    const unwrapped2 = unwrapType(config2, 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(config2, docs) {
+  const lists = [];
+  const visitedLists = /* @__PURE__ */ new Set();
+  for (const doc of docs) {
+    graphql17.visit(doc.document, {
+      Directive(node, key, parent, path2, ancestors) {
+        if (![config2.listDirective, config2.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(
+          config2.schema,
+          doc.filename,
+          ancestors.slice(0, -1)
+        );
+        const targetField = ancestors[ancestors.length - 1];
+        const targetFieldDefinition = parentType.getFields()[targetField.name.value];
+        const { type: listType } = unwrapType(config2, targetFieldDefinition.type);
+        const possibleTypes = [];
+        if (graphql17.isAbstractType(listType)) {
+          possibleTypes.push(
+            ...config2.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(
+                              config2,
+                              /* @__PURE__ */ new Set(),
+                              arg
+                            )
+                          )
+                        );
+                        argDef.optional = true;
+                        return argDef;
+                      })
+                    )
+                  )
+                )
+              ])
+            )
+          )
+        );
+      }
+    });
+  }
+  return AST12.tsTypeLiteral(lists);
+}
+function queryDefinitions(config2, 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: config2,
+        body,
+        sourceModule: path_exports.relative(
+          config2.runtimeDirectory,
+          config2.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(config2, 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: config2,
+      body,
+      sourceModule: path_exports.relative(
+        config2.runtimeDirectory,
+        config2.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 === config2.argumentsDirective
+    );
+    if (directive) {
+      inputType = AST12.tsTypeReference(
+        AST12.identifier(
+          ensureImports({
             config: config2,
-            filepath,
-            rootType: type,
-            selections,
-            root: true,
-            allowReadonly: true,
             body,
-            visitedTypes,
-            missingScalars,
-            includeFragments: true
-          })
+            sourceModule: path_exports.relative(
+              config2.runtimeDirectory,
+              config2.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(config2, docs) {
+  await Promise.all([
+    generateDocumentTypes(config2, docs),
+    imperativeCacheTypef(config2, docs)
+  ]);
 }
 
 // src/codegen/generators/persistedQueries/index.ts
-var graphql17 = __toESM(require_graphql2(), 1);
+var graphql18 = __toESM(require_graphql2(), 1);
 async function persistOutputGenerator(config2, docs) {
   if (typeof config2.persistedQueryPath !== "string" || config2.persistedQueryPath.length === 0)
     return;
@@ -58064,8 +58591,8 @@ async function persistOutputGenerator(config2, docs) {
     if (!generateArtifact) {
       return acc;
     }
-    let rawString = graphql17.print(
-      graphql17.visit(document, {
+    let rawString = graphql18.print(
+      graphql18.visit(document, {
         Directive(node) {
           if (config2.isInternalDirective(node)) {
             return null;
@@ -58074,7 +58601,7 @@ async function persistOutputGenerator(config2, docs) {
       })
     );
     const operations = document.definitions.filter(
-      ({ kind }) => kind === graphql17.Kind.OPERATION_DEFINITION
+      ({ kind }) => kind === graphql18.Kind.OPERATION_DEFINITION
     );
     if (operations.length > 0 && operations[0].kind === "OperationDefinition") {
       acc[hashDocument(rawString)] = rawString;
@@ -58087,11 +58614,11 @@ async function persistOutputGenerator(config2, docs) {
 }
 
 // src/codegen/generators/definitions/enums.ts
-var graphql18 = __toESM(require_graphql2(), 1);
+var graphql19 = __toESM(require_graphql2(), 1);
 var recast13 = __toESM(require_main2(), 1);
 var AST13 = recast13.types.builders;
 async function definitionsGenerator(config2) {
-  const enums = graphql18.parse(graphql18.printSchema(config2.schema)).definitions.filter(
+  const enums = graphql19.parse(graphql19.printSchema(config2.schema)).definitions.filter(
     (definition) => definition.kind === "EnumTypeDefinition"
   ).filter((def) => !config2.isInternalEnum(def));
   const runtimeDefinitions = recast13.print(
@@ -58181,91 +58708,8 @@ async function writeIndexFile2(config2, docs) {
   await fs_exports.writeFile(path_exports.join(config2.rootDir, "index.js"), body);
 }
 
-// src/codegen/transforms/composeQueries.ts
-var import_graphql = __toESM(require_graphql2(), 1);
-async function includeFragmentDefinitions(config2, documents) {
-  const fragments = collectFragments(config2, documents);
-  for (const [index, { name: name2, document, filename }] of documents.entries()) {
-    const operation = document.definitions.find(
-      ({ kind }) => kind === import_graphql.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(config2, 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_graphql.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 graphql19 = __toESM(require_graphql2(), 1);
+var graphql20 = __toESM(require_graphql2(), 1);
 async function graphqlExtensions(config2, documents) {
   const internalSchema = `
 enum CachePolicy {
@@ -58329,9 +58773,9 @@ directive @${config2.argumentsDirective} on FRAGMENT_DEFINITION
 directive @${config2.cacheDirective}(${config2.cachePolicyArg}: CachePolicy, ${config2.cachePartialArg}: Boolean) on QUERY
 
 """
-	@${config2.manualLoadDirective} is used to disable automatic fetch (no load, no auto fetch in component), you will have to do it manually.
+	@${config2.loadDirective} is used to disable automatic fetch (no load, no auto fetch in component), you will have to do it manually.
 """
-directive @${config2.manualLoadDirective} on QUERY
+directive @${config2.loadDirective} on QUERY
 
 """
 	@${config2.maskEnableDirective} to enable masking on fragment (overwriting the global conf)
@@ -58343,19 +58787,19 @@ directive @${config2.maskEnableDirective} on FRAGMENT_SPREAD
 """
 directive @${config2.maskDisableDirective} on FRAGMENT_SPREAD
 `;
-  let currentSchema = graphql19.printSchema(config2.schema);
+  let currentSchema = graphql20.printSchema(config2.schema);
   if (!currentSchema.includes(`directive @${config2.listDirective}`)) {
     currentSchema += internalSchema;
   }
   config2.newSchema += internalSchema;
-  config2.schema = graphql19.buildSchema(currentSchema);
+  config2.schema = graphql20.buildSchema(currentSchema);
 }
 
 // src/codegen/transforms/typename.ts
-var graphql20 = __toESM(require_graphql2(), 1);
+var graphql21 = __toESM(require_graphql2(), 1);
 async function addTypename(config2, documents) {
   for (const doc of documents) {
-    doc.document = graphql20.visit(doc.document, {
+    doc.document = graphql21.visit(doc.document, {
       Field(node, key, parent, path2, ancestors) {
         if (!node.selectionSet) {
           return;
@@ -58367,7 +58811,7 @@ async function addTypename(config2, documents) {
         );
         const field = type.getFields()[node.name.value];
         const fieldType = unwrapType(config2, field.type).type;
-        if (graphql20.isInterfaceType(fieldType) || graphql20.isUnionType(fieldType)) {
+        if (graphql21.isInterfaceType(fieldType) || graphql21.isUnionType(fieldType)) {
           return {
             ...node,
             selectionSet: {
@@ -58375,9 +58819,9 @@ async function addTypename(config2, documents) {
               selections: [
                 ...node.selectionSet.selections,
                 {
-                  kind: graphql20.Kind.FIELD,
+                  kind: graphql21.Kind.FIELD,
                   name: {
-                    kind: graphql20.Kind.NAME,
+                    kind: graphql21.Kind.NAME,
                     value: "__typename"
                   }
                 }
@@ -58391,10 +58835,10 @@ async function addTypename(config2, documents) {
 }
 
 // src/codegen/transforms/addID.ts
-var graphql21 = __toESM(require_graphql2(), 1);
+var graphql22 = __toESM(require_graphql2(), 1);
 async function addID(config2, documents) {
   for (const doc of documents) {
-    doc.document = graphql21.visit(doc.document, {
+    doc.document = graphql22.visit(doc.document, {
       Field(node, key, parent, path2, ancestors) {
         if (!node.selectionSet) {
           return;
@@ -58407,7 +58851,7 @@ async function addID(config2, documents) {
         const field = type.getFields()[node.name.value];
         const fieldType = unwrapType(config2, field.type).type;
         if (node.selectionSet?.selections.length > 0) {
-          if (!graphql21.isObjectType(fieldType) && !graphql21.isInterfaceType(fieldType)) {
+          if (!graphql22.isObjectType(fieldType) && !graphql22.isInterfaceType(fieldType)) {
             return;
           }
           const keyFields = config2.keyFieldsForType(fieldType.name);
@@ -58422,9 +58866,9 @@ async function addID(config2, documents) {
               continue;
             }
             selections.push({
-              kind: graphql21.Kind.FIELD,
+              kind: graphql22.Kind.FIELD,
               name: {
-                kind: graphql21.Kind.NAME,
+                kind: graphql22.Kind.NAME,
                 value: keyField
               }
             });
@@ -58442,266 +58886,6 @@ async function addID(config2, documents) {
   }
 }
 
-// src/codegen/transforms/fragmentVariables.ts
-var graphql22 = __toESM(require_graphql2(), 1);
-var GraphqlKinds2 = graphql22.Kind;
-async function fragmentVariables(config2, documents) {
-  const fragments = collectFragments(config2, 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: config2,
-      filepath: doc2.filename,
-      fragmentDefinitions: fragments,
-      document: doc2.document,
-      generatedFragments,
-      visitedFragments,
-      scope: null
-    });
-  }
-  const doc = {
-    kind: graphql22.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: config2,
-  filepath,
-  fragmentDefinitions,
-  document,
-  generatedFragments,
-  visitedFragments,
-  scope,
-  newName
-}) {
-  if (!scope) {
-    scope = operationScope(
-      document.definitions.find(
-        ({ kind }) => kind === GraphqlKinds2.OPERATION_DEFINITION
-      )
-    );
-  }
-  const definitionArgs = fragmentArguments(
-    config2,
-    filepath,
-    document
-  ).reduce((acc, arg) => ({ ...acc, [arg.name]: arg }), {});
-  const result = graphql22.visit(document, {
-    FragmentSpread(node) {
-      const { definition } = fragmentDefinitions[node.name.value];
-      let { args, hash } = collectWithArguments(config2, filepath, node, scope);
-      const newFragmentName = `${node.name.value}${hash}`;
-      if (!visitedFragments.has(newFragmentName)) {
-        visitedFragments.add(newFragmentName);
-        const defaultArguments = collectDefaultArgumentValues(config2, filepath, definition);
-        if (args) {
-          for (const [field, value] of Object.entries(defaultArguments || {})) {
-            if (!args[field]) {
-              args[field] = value;
-            }
-          }
-          generatedFragments[newFragmentName] = inlineFragmentArgs({
-            config: config2,
-            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: config2,
-              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: graphql22.Kind.NAME,
-      value: newName
-    };
-  }
-  return result;
-}
-function withArguments(config2, node) {
-  const withDirectives = node.directives?.filter(
-    (directive) => directive.name.value === config2.withDirective
-  );
-  if (!withDirectives || withDirectives.length === 0) {
-    return [];
-  }
-  return withDirectives.flatMap((directive) => directive.arguments || []);
-}
-function fragmentArguments(config2, filepath, definition) {
-  const directives = definition.directives?.filter(
-    (directive) => directive.name.value === config2.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(config2, filepath, definition) {
-  let result = {};
-  for (const { name: name2, required, defaultValue } of fragmentArguments(
-    config2,
-    filepath,
-    definition
-  )) {
-    if (required || !defaultValue) {
-      continue;
-    }
-    result[name2] = defaultValue;
-  }
-  return result;
-}
-function collectWithArguments(config2, filepath, node, scope = {}) {
-  const withArgs = withArguments(config2, 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 graphql23 = __toESM(require_graphql2(), 1);
 async function typeCheck(config2, docs) {
@@ -59881,7 +60065,6 @@ function testConfigFile({ plugins, ...config2 } = {}) {
         }
       }
     },
-    framework: "kit",
     types: {
       Ghost: {
         keys: ["name", "aka"],