houdini 1.5.2 → 1.5.4

package/build/vite-cjs/index.js

@@ -62977,7 +62977,7 @@ function mergeSchemas(config2) {
 }
 
 // src/lib/config.ts
-var graphql4 = __toESM(require("graphql"), 1);
+var graphql5 = __toESM(require("graphql"), 1);
 var import_minimatch8 = __toESM(require_minimatch(), 1);
 var import_node_url4 = require("node:url");
 
@@ -70198,43 +70198,43 @@ __export(conventions_exports, {
   vite_render_path: () => vite_render_path
 });
 function router_path(config2) {
-  return path_exports.join(base_dir(config2), "Router.jsx");
+  return join2(base_dir(config2), "Router.jsx");
 }
 function page_entry_path(config2, id, base) {
-  return path_exports.join(page_entries_dir(config2, base), `${id}.jsx`);
+  return join2(page_entries_dir(config2, base), `${id}.jsx`);
 }
 function server_adapter_path(config2, base) {
-  return path_exports.join(units_dir(config2, base), "render", "server.js");
+  return join2(units_dir(config2, base), "render", "server.js");
 }
 function adapter_config_path(config2, base) {
-  return path_exports.join(units_dir(config2, base), "render", "config.js");
+  return join2(units_dir(config2, base), "render", "config.js");
 }
 function vite_render_path(config2, base) {
-  return path_exports.join(units_dir(config2, base), "render", "vite.js");
+  return join2(units_dir(config2, base), "render", "vite.js");
 }
 function app_component_path(config2, base) {
-  return path_exports.join(units_dir(config2, base), "render", "App.jsx");
+  return join2(units_dir(config2, base), "render", "App.jsx");
 }
 function page_unit_path(config2, id, base) {
-  return path_exports.join(page_units_dir(config2, base), `${id}.jsx`);
+  return join2(page_units_dir(config2, base), `${id}.jsx`);
 }
 function layout_unit_path(config2, id, base) {
-  return path_exports.join(layout_units_dir(config2, base), `${id}.jsx`);
+  return join2(layout_units_dir(config2, base), `${id}.jsx`);
 }
 function componentField_unit_path(config2, id, base) {
-  return path_exports.join(units_dir(config2, base), "componentFields", `wrapper_${id}.jsx`);
+  return join2(units_dir(config2, base), "componentFields", `wrapper_${id}.jsx`);
 }
 function fallback_unit_path(config2, which, id, base) {
-  return path_exports.join(fallbacks_units_dir(config2, which, base), `${id}.jsx`);
+  return join2(fallbacks_units_dir(config2, which, base), `${id}.jsx`);
 }
 async function read_pageQuery(base) {
-  const target = path_exports.join(base, "+page.gql");
-  return [target, await fs_exports.readFile(target)];
+  const target = join2(base, "+page.gql");
+  return [target, await readFile(target)];
 }
 async function read_pageView(base) {
   for (const name of ["+page.tsx", "+page.jsx"]) {
-    let target = path_exports.join(base, name);
-    let result = await fs_exports.readFile(target);
+    let target = join2(base, name);
+    let result = await readFile(target);
     if (result) {
       return [target, result];
     }
@@ -70242,13 +70242,13 @@ async function read_pageView(base) {
   return [null, null];
 }
 async function read_layoutQuery(base) {
-  const target = path_exports.join(base, "+layout.gql");
-  return [target, await fs_exports.readFile(target)];
+  const target = join2(base, "+layout.gql");
+  return [target, await readFile(target)];
 }
 async function read_layoutView(base) {
   for (const name of ["+layout.tsx", "+layout.jsx"]) {
-    let target = path_exports.join(base, name);
-    let result = await fs_exports.readFile(target);
+    let target = join2(base, name);
+    let result = await readFile(target);
     if (result) {
       return [target, result];
     }
@@ -70256,10 +70256,10 @@ async function read_layoutView(base) {
   return [null, null];
 }
 function temp_dir(config2, key) {
-  return path_exports.join(config2.rootDir, "temp", key);
+  return join2(config2.rootDir, "temp", key);
 }
 function router_index_path(config2) {
-  return path_exports.join(config2.routesDir, "..", "+index.jsx");
+  return join2(config2.routesDir, "..", "+index.jsx");
 }
 function is_layout(path4) {
   return path4.endsWith("+layout.tsx") || path4.endsWith("+layout.jsx");
@@ -70282,202 +70282,510 @@ function page_id(path4) {
   return copy;
 }
 function page_entries_dir(config2, base) {
-  return path_exports.join(units_dir(config2, base), "entries");
+  return join2(units_dir(config2, base), "entries");
 }
 function page_units_dir(config2, base) {
-  return path_exports.join(units_dir(config2, base), "pages");
+  return join2(units_dir(config2, base), "pages");
 }
 function layout_units_dir(config2, base) {
-  return path_exports.join(units_dir(config2, base), "layouts");
+  return join2(units_dir(config2, base), "layouts");
 }
 function fallbacks_units_dir(config2, which, base) {
-  return path_exports.join(units_dir(config2, base), "fallbacks", which);
+  return join2(units_dir(config2, base), "fallbacks", which);
 }
 function units_dir(config2, base = base_dir(config2)) {
-  return path_exports.join(base, "units");
+  return join2(base, "units");
 }
 function base_dir(config2) {
   return config2.pluginDirectory("houdini-react");
 }
 function serialized_manifest_path(config2, base = base_dir(config2)) {
-  return path_exports.join(base, "manifest.json");
+  return join2(base, "manifest.json");
 }
 
 // src/lib/router/manifest.ts
 var t2 = __toESM(require_lib5(), 1);
-var graphql2 = __toESM(require("graphql"), 1);
-async function load_manifest(args) {
-  const manifest = await walk_routes({
-    config: args.config,
-    url: "/",
-    filepath: args.config.routesDir,
-    project: {
-      component_fields: {},
-      pages: {},
-      layouts: {},
-      page_queries: {},
-      layout_queries: {},
-      artifacts: [],
-      local_schema: false,
-      local_yoga: false
-    },
-    queries: [],
-    layouts: [],
-    variables: {}
-  });
-  if (args.includeArtifacts) {
-    try {
-      for (const artifactPath of await fs_exports.readdir(args.config.artifactDirectory)) {
-        if (!artifactPath.endsWith(".js") || artifactPath === "index.js") {
-          continue;
-        }
-        manifest.artifacts.push(artifactPath.substring(0, artifactPath.length - 3));
+var graphql3 = __toESM(require("graphql"), 1);
+
+// src/runtime/router/match.ts
+var param_pattern = /^(\[)?(\.\.\.)?(\w+)(?:=(\w+))?(\])?$/;
+function parse_page_pattern(id) {
+  const params = [];
+  const pattern = id === "/" ? /^\/$/ : new RegExp(
+    `^${get_route_segments(id).map((segment) => {
+      const rest_match = /^\[\.\.\.(\w+)(?:=(\w+))?\]$/.exec(segment);
+      if (rest_match) {
+        params.push({
+          name: rest_match[1],
+          matcher: rest_match[2],
+          optional: false,
+          rest: true,
+          chained: true
+        });
+        return "(?:/(.*))?";
       }
-    } catch {
-    }
-  }
-  try {
-    await fs_exports.stat(args.config.localApiDir);
-    for (const child of await fs_exports.readdir(args.config.localApiDir, { withFileTypes: true })) {
-      const name = child.isDirectory() ? child.name : path_exports.parse(child.name).name;
-      if (name === "+schema") {
-        manifest.local_schema = true;
-      } else if (name === "+yoga") {
-        manifest.local_yoga = true;
+      const optional_match = /^\[\[(\w+)(?:=(\w+))?\]\]$/.exec(segment);
+      if (optional_match) {
+        params.push({
+          name: optional_match[1],
+          matcher: optional_match[2],
+          optional: true,
+          rest: false,
+          chained: true
+        });
+        return "(?:/([^/]+))?";
       }
-    }
-  } catch {
-  }
-  return manifest;
-}
-async function walk_routes(args) {
-  const directory_contents = await fs_exports.readdir(args.filepath, {
-    withFileTypes: true
-  });
-  const variables = { ...args.variables };
-  let newLayouts = args.layouts;
-  let newLayoutQueries = args.queries;
-  let layout = null;
-  let layoutQuery = null;
-  let pageQuery = null;
-  const [
-    [layoutQueryPath, layoutQueryContents],
-    [layoutViewPath, layoutViewContents],
-    [pageQueryPath, pageQueryContents],
-    [pageViewPath, pageViewContents]
-  ] = await Promise.all([
-    read_layoutQuery(args.filepath),
-    read_layoutView(args.filepath),
-    read_pageQuery(args.filepath),
-    read_pageView(args.filepath)
-  ]);
-  if (layoutQueryContents) {
-    layoutQuery = await add_query({
-      path: layoutQueryPath,
-      config: args.config,
-      url: args.url,
-      project: args.project,
-      type: "layout",
-      contents: layoutQueryContents,
-      variables
-    });
-    newLayoutQueries = [...args.queries, layoutQuery.name];
-  }
-  if (layoutViewContents) {
-    layout = await add_view({
-      url: args.url,
-      path: layoutViewPath,
-      project: args.project,
-      type: "layout",
-      contents: layoutViewContents,
-      layouts: args.layouts,
-      queries: newLayoutQueries,
-      config: args.config,
-      variables
-    });
-    newLayouts = [...args.layouts, page_id(layout.url)];
-  }
-  if (pageQueryContents) {
-    pageQuery = await add_query({
-      path: pageQueryPath,
-      config: args.config,
-      url: args.url,
-      project: args.project,
-      type: "page",
-      contents: pageQueryContents,
-      variables
-    });
-  }
-  if (pageViewContents) {
-    await add_view({
-      path: pageViewPath,
-      url: args.url.substring(0, args.url.length - 1) || "/",
-      project: args.project,
-      type: "page",
-      contents: pageViewContents,
-      layouts: newLayouts,
-      queries: pageQuery ? [...newLayoutQueries, pageQuery.name] : newLayoutQueries,
-      config: args.config,
-      variables
-    });
-  }
-  await Promise.all(
-    directory_contents.map((dir) => {
-      if (!dir.isDirectory()) {
+      if (!segment) {
         return;
       }
-      return walk_routes({
-        ...args,
-        filepath: path_exports.join(args.filepath, dir.name),
-        url: `${args.url}${dir.name}/`,
-        queries: newLayoutQueries,
-        layouts: newLayouts,
-        variables
-      });
-    })
+      const parts = segment.split(/\[(.+?)\](?!\])/);
+      const result = parts.map((content, i2) => {
+        if (i2 % 2) {
+          if (content.startsWith("x+")) {
+            return escape3(
+              String.fromCharCode(parseInt(content.slice(2), 16))
+            );
+          }
+          if (content.startsWith("u+")) {
+            return escape3(
+              String.fromCharCode(
+                ...content.slice(2).split("-").map((code) => parseInt(code, 16))
+              )
+            );
+          }
+          const match2 = param_pattern.exec(content);
+          if (!match2) {
+            throw new Error(
+              `Invalid param: ${content}. Params and matcher names can only have underscores and alphanumeric characters.`
+            );
+          }
+          const [, is_optional, is_rest, name, matcher] = match2;
+          params.push({
+            name,
+            matcher,
+            optional: !!is_optional,
+            rest: !!is_rest,
+            chained: is_rest ? i2 === 1 && parts[0] === "" : false
+          });
+          return is_rest ? "(.*?)" : is_optional ? "([^/]*)?" : "([^/]+?)";
+        }
+        return escape3(content);
+      }).join("");
+      return "/" + result;
+    }).join("")}/?$`
   );
-  return args.project;
+  return { pattern, params, page_id: id };
 }
-async function add_view(args) {
-  const target = args.type === "page" ? args.project.pages : args.project.layouts;
-  const queries = await extractQueries(args.contents);
-  const missing_queries = queries.filter((query2) => !args.queries.includes(query2));
-  if (missing_queries.length > 0) {
-    throw {
-      message: `Unknown queries in ${args.path}: ${missing_queries.join(", ")}`
-    };
+function affects_path(segment) {
+  return !/^\([^)]+\)$/.test(segment);
+}
+function get_route_segments(route) {
+  return route.slice(1).split("/").filter(affects_path);
+}
+function escape3(str) {
+  return str.normalize().replace(/[[\]]/g, "\\$&").replace(/%/g, "%25").replace(/\//g, "%2[Ff]").replace(/\?/g, "%3[Ff]").replace(/#/g, "%23").replace(/[.*+?^${}()|\\]/g, "\\$&");
+}
+
+// src/lib/graphql.ts
+var graphql2 = __toESM(require("graphql"), 1);
+var import_node_crypto = __toESM(require("node:crypto"), 1);
+function getRootType(type) {
+  if (graphql2.isNonNullType(type)) {
+    return getRootType(type.ofType);
   }
-  const id = page_id(args.url);
-  target[id] = {
-    id,
-    queries,
-    url: args.url,
-    layouts: args.layouts,
-    path: path_exports.relative(args.config.projectRoot, args.path),
-    query_options: args.queries,
-    params: Object.fromEntries(
-      parse_page_pattern(args.url).params.map((param) => [
-        param.name,
-        args.variables[param.name] ?? null
-      ])
-    )
-  };
-  return target[id];
+  if (graphql2.isListType(type)) {
+    return getRootType(type.ofType);
+  }
+  return type;
 }
-async function add_query(args) {
-  const parsed = graphql2.parse(args.contents);
-  const query2 = parsed.definitions.find(
-    (def) => def.kind === "OperationDefinition" && def.operation === "query"
-  );
-  if (!query2?.name) {
-    throw new Error("No query found");
+function hashOriginal({ document }) {
+  return hashDocument(document.originalString);
+}
+function hashRaw({ document }) {
+  return hashDocument(document.artifact?.raw);
+}
+function hashDocument(str) {
+  return import_node_crypto.default.createHash("sha256").update(str || "").digest("hex");
+}
+function parentField(ancestors) {
+  return walkParentField([...ancestors].sort(() => -1));
+}
+function walkParentField(ancestors) {
+  let head = ancestors.shift();
+  if (Array.isArray(head) || head.kind === "SelectionSet") {
+    return walkParentField(ancestors);
   }
-  let loading = false;
-  await graphql2.visit(parsed, {
-    Directive(node) {
-      if (node.name.value === args.config.loadingDirective) {
-        loading = true;
-      }
+  return head;
+}
+function parentTypeFromAncestors(schema, filepath, ancestors) {
+  const parents = [...ancestors];
+  parents.reverse();
+  return walkAncestors(schema, filepath, parents);
+}
+function walkAncestors(schema, filepath, ancestors) {
+  let head = ancestors.shift();
+  if (Array.isArray(head)) {
+    return walkAncestors(schema, filepath, ancestors);
+  }
+  if (!head) {
+    throw new HoudiniError({ filepath, message: "Could not figure out type of field" });
+  }
+  if (head.kind === "OperationDefinition") {
+    const operationType = {
+      query: schema.getQueryType(),
+      mutation: schema.getMutationType(),
+      subscription: schema.getSubscriptionType()
+    }[head.operation];
+    if (!operationType) {
+      throw new HoudiniError({ filepath, message: "Could not find operation type" });
+    }
+    return operationType;
+  }
+  if (head.kind === "FragmentDefinition") {
+    const result = schema.getType(head.typeCondition.name.value);
+    if (!result) {
+      throw new HoudiniError({
+        filepath,
+        message: `Could not find definition for ${head.typeCondition.name.value} in the schema`
+      });
+    }
+    return result;
+  }
+  if (head.kind === "FragmentSpread") {
+    throw new Error("How the hell did this happen?");
+  }
+  const parent2 = walkAncestors(schema, filepath, ancestors);
+  if (head.kind === "InlineFragment") {
+    if (!head.typeCondition) {
+      return parent2;
+    }
+    const wrapper = schema.getType(head.typeCondition.name.value);
+    if (!wrapper) {
+      throw new HoudiniError({
+        filepath,
+        message: "Could not find type with name: " + head.typeCondition.name.value
+      });
+    }
+    return wrapper;
+  }
+  if (head.kind === "SelectionSet") {
+    return parent2;
+  }
+  const field = parent2.getFields()[head.name.value];
+  if (!field) {
+    throw new HoudiniError({
+      filepath,
+      message: `Could not find definition of ${head.name.value} in ${parent2.toString()}`
+    });
+  }
+  return getRootType(field.type);
+}
+function definitionFromAncestors(ancestors) {
+  let parents = [...ancestors];
+  parents.shift();
+  let definition = parents.shift();
+  while (Array.isArray(definition) && definition) {
+    definition = parents.shift();
+  }
+  return { parents, definition };
+}
+function formatErrors(e2, afterError) {
+  const errors = Array.isArray(e2) ? e2 : [e2];
+  for (const error of errors) {
+    if ("filepath" in error && error.filepath) {
+      const relative2 = relative(process.cwd(), error.filepath);
+      console.error(`\u274C Encountered error in ${relative2}`);
+      if (error.message) {
+        console.error(error.message);
+      }
+    } else {
+      console.error(`\u274C ${error.message}`);
+      if ("description" in error && error.description) {
+        console.error(`${error.description}`);
+      }
+    }
+    afterError?.(e2);
+  }
+}
+function unwrapType(config2, type, wrappers = [], convertRuntimeScalars) {
+  if (type.kind === "NonNullType") {
+    return unwrapType(config2, type.type, [TypeWrapper.NonNull, ...wrappers]);
+  }
+  if (type instanceof graphql2.GraphQLNonNull) {
+    return unwrapType(config2, type.ofType, [TypeWrapper.NonNull, ...wrappers]);
+  }
+  if (wrappers[0] !== TypeWrapper.NonNull) {
+    wrappers.unshift(TypeWrapper.Nullable);
+  }
+  if (type.kind === "ListType") {
+    return unwrapType(config2, type.type, [TypeWrapper.List, ...wrappers]);
+  }
+  if (type instanceof graphql2.GraphQLList) {
+    return unwrapType(config2, type.ofType, [TypeWrapper.List, ...wrappers]);
+  }
+  if (convertRuntimeScalars && config2.configFile.features?.runtimeScalars?.[type.name.value]) {
+    type = config2.schema.getType(
+      config2.configFile.features?.runtimeScalars?.[type.name.value].type
+    );
+  }
+  const namedType = config2.schema.getType(type.name.value || type.name);
+  if (!namedType) {
+    throw new Error("Unknown type: " + type.name.value || type.name);
+  }
+  return { type: namedType, wrappers };
+}
+function wrapType({
+  type,
+  wrappers
+}) {
+  const head = wrappers[0];
+  const tail = wrappers.slice(1);
+  let kind = graphql2.Kind.NAMED_TYPE;
+  if (head === TypeWrapper.List) {
+    kind = graphql2.Kind.LIST_TYPE;
+  } else if (head === TypeWrapper.NonNull) {
+    kind = graphql2.Kind.NON_NULL_TYPE;
+  }
+  if (kind === "NamedType") {
+    return {
+      kind,
+      name: {
+        kind: graphql2.Kind.NAME,
+        value: type.name
+      }
+    };
+  }
+  return {
+    kind,
+    type: wrapType({ type, wrappers: tail })
+  };
+}
+var TypeWrapper = /* @__PURE__ */ ((TypeWrapper2) => {
+  TypeWrapper2["Nullable"] = "Nullable";
+  TypeWrapper2["List"] = "List";
+  TypeWrapper2["NonNull"] = "NonNull";
+  return TypeWrapper2;
+})(TypeWrapper || {});
+
+// src/lib/parse.ts
+var import_parser = __toESM(require_lib6(), 1);
+var import_recast = __toESM(require_main2(), 1);
+
+// src/lib/deepMerge.ts
+var import_deepmerge = __toESM(require_cjs(), 1);
+function deepMerge2(filepath, ...targets) {
+  try {
+    if (targets.length === 1) {
+      return targets[0];
+    } else if (targets.length === 2) {
+      return (0, import_deepmerge.default)(targets[0], targets[1], {
+        arrayMerge: (source, update) => [...new Set(source.concat(update))]
+      });
+    }
+    return deepMerge2(filepath, targets[0], deepMerge2(filepath, ...targets.slice(1)));
+  } catch (e2) {
+    throw new HoudiniError({
+      filepath,
+      message: "could not merge: " + JSON.stringify(targets, null, 4),
+      description: e2.message
+    });
+  }
+}
+
+// src/lib/parse.ts
+function parseJS(str, config2) {
+  const defaultConfig = {
+    plugins: [
+      "typescript",
+      "importAssertions",
+      "decorators-legacy",
+      "explicitResourceManagement"
+    ],
+    sourceType: "module"
+  };
+  return (0, import_parser.parse)(str || "", config2 ? deepMerge2("", defaultConfig, config2) : defaultConfig).program;
+}
+async function printJS(script, options) {
+  if (options?.pretty) {
+    return (0, import_recast.prettyPrint)(script, options);
+  } else {
+    return (0, import_recast.print)(script, options);
+  }
+}
+
+// src/lib/router/manifest.ts
+async function load_manifest(args) {
+  const manifest = await walk_routes({
+    config: args.config,
+    url: "/",
+    filepath: args.config.routesDir,
+    project: {
+      component_fields: {},
+      pages: {},
+      layouts: {},
+      page_queries: {},
+      layout_queries: {},
+      artifacts: [],
+      local_schema: false,
+      local_yoga: false
+    },
+    queries: [],
+    layouts: [],
+    variables: {}
+  });
+  if (args.includeArtifacts) {
+    try {
+      for (const artifactPath of await readdir2(args.config.artifactDirectory)) {
+        if (!artifactPath.endsWith(".js") || artifactPath === "index.js") {
+          continue;
+        }
+        manifest.artifacts.push(artifactPath.substring(0, artifactPath.length - 3));
+      }
+    } catch {
+    }
+  }
+  try {
+    await stat(args.config.localApiDir);
+    for (const child of await readdir2(args.config.localApiDir, { withFileTypes: true })) {
+      const name = child.isDirectory() ? child.name : parse3(child.name).name;
+      if (name === "+schema") {
+        manifest.local_schema = true;
+      } else if (name === "+yoga") {
+        manifest.local_yoga = true;
+      }
+    }
+  } catch {
+  }
+  return manifest;
+}
+async function walk_routes(args) {
+  const directory_contents = await readdir2(args.filepath, {
+    withFileTypes: true
+  });
+  const variables = { ...args.variables };
+  let newLayouts = args.layouts;
+  let newLayoutQueries = args.queries;
+  let layout = null;
+  let layoutQuery = null;
+  let pageQuery = null;
+  const [
+    [layoutQueryPath, layoutQueryContents],
+    [layoutViewPath, layoutViewContents],
+    [pageQueryPath, pageQueryContents],
+    [pageViewPath, pageViewContents]
+  ] = await Promise.all([
+    read_layoutQuery(args.filepath),
+    read_layoutView(args.filepath),
+    read_pageQuery(args.filepath),
+    read_pageView(args.filepath)
+  ]);
+  if (layoutQueryContents) {
+    layoutQuery = await add_query({
+      path: layoutQueryPath,
+      config: args.config,
+      url: args.url,
+      project: args.project,
+      type: "layout",
+      contents: layoutQueryContents,
+      variables
+    });
+    newLayoutQueries = [...args.queries, layoutQuery.name];
+  }
+  if (layoutViewContents) {
+    layout = await add_view({
+      url: args.url,
+      path: layoutViewPath,
+      project: args.project,
+      type: "layout",
+      contents: layoutViewContents,
+      layouts: args.layouts,
+      queries: newLayoutQueries,
+      config: args.config,
+      variables
+    });
+    newLayouts = [...args.layouts, page_id(layout.url)];
+  }
+  if (pageQueryContents) {
+    pageQuery = await add_query({
+      path: pageQueryPath,
+      config: args.config,
+      url: args.url,
+      project: args.project,
+      type: "page",
+      contents: pageQueryContents,
+      variables
+    });
+  }
+  if (pageViewContents) {
+    await add_view({
+      path: pageViewPath,
+      url: args.url.substring(0, args.url.length - 1) || "/",
+      project: args.project,
+      type: "page",
+      contents: pageViewContents,
+      layouts: newLayouts,
+      queries: pageQuery ? [...newLayoutQueries, pageQuery.name] : newLayoutQueries,
+      config: args.config,
+      variables
+    });
+  }
+  await Promise.all(
+    directory_contents.map((dir) => {
+      if (!dir.isDirectory()) {
+        return;
+      }
+      return walk_routes({
+        ...args,
+        filepath: join2(args.filepath, dir.name),
+        url: `${args.url}${dir.name}/`,
+        queries: newLayoutQueries,
+        layouts: newLayouts,
+        variables
+      });
+    })
+  );
+  return args.project;
+}
+async function add_view(args) {
+  const target = args.type === "page" ? args.project.pages : args.project.layouts;
+  const queries = await extractQueries(args.contents);
+  const missing_queries = queries.filter((query2) => !args.queries.includes(query2));
+  if (missing_queries.length > 0) {
+    throw {
+      message: `Unknown queries in ${args.path}: ${missing_queries.join(", ")}`
+    };
+  }
+  const id = page_id(args.url);
+  target[id] = {
+    id,
+    queries,
+    url: args.url,
+    layouts: args.layouts,
+    path: relative(args.config.projectRoot, args.path),
+    query_options: args.queries,
+    params: Object.fromEntries(
+      parse_page_pattern(args.url).params.map((param) => [
+        param.name,
+        args.variables[param.name] ?? null
+      ])
+    )
+  };
+  return target[id];
+}
+async function add_query(args) {
+  const parsed = graphql3.parse(args.contents);
+  const query2 = parsed.definitions.find(
+    (def) => def.kind === "OperationDefinition" && def.operation === "query"
+  );
+  if (!query2?.name) {
+    throw new Error("No query found");
+  }
+  let loading = false;
+  await graphql3.visit(parsed, {
+    Directive(node) {
+      if (node.name.value === args.config.loadingDirective) {
+        loading = true;
+      }
     }
   });
   const queryVariables = Object.fromEntries(
@@ -70492,7 +70800,7 @@ async function add_query(args) {
   Object.assign(args.variables, queryVariables);
   const target = args.type === "page" ? args.project.page_queries : args.project.layout_queries;
   target[page_id(args.url)] = {
-    path: path_exports.relative(args.config.routesDir, args.path),
+    path: relative(args.config.routesDir, args.path),
     name: query2.name.value,
     url: args.url,
     loading,
@@ -70567,7 +70875,7 @@ async function extractQueries(source) {
 }
 
 // src/lib/router/server.ts
-var graphql3 = __toESM(require("graphql"), 1);
+var graphql4 = __toESM(require("graphql"), 1);
 var import_node_path3 = __toESM(require("node:path"), 1);
 
 // src/runtime/lib/flatten.ts
@@ -72916,14 +73224,14 @@ function isSecondaryBuild() {
 async function buildLocalSchema(config2) {
   const { build } = await import("vite");
   const schema = import_node_path3.default.join(config2.localApiDir, "+schema");
-  const outDir = conventions_exports.temp_dir(config2, "schema");
+  const outDir = temp_dir(config2, "schema");
   process.env.HOUDINI_SECONDARY_BUILD = "true";
   try {
-    await fs_exports.remove(import_node_path3.default.join(outDir, "assets", "schema.js"));
+    await remove(import_node_path3.default.join(outDir, "assets", "schema.js"));
   } catch {
   }
   try {
-    await fs_exports.mkdir(outDir);
+    await mkdir(outDir);
   } catch {
   }
   await build({
@@ -72955,14 +73263,14 @@ async function loadLocalSchema(config2) {
   }
   try {
     const { default: schema } = await import(import_node_path3.default.join(
-      conventions_exports.temp_dir(config2, "schema"),
+      temp_dir(config2, "schema"),
       `schema.js?${Date.now().valueOf()}}`
     ));
     return schema;
   } catch (e2) {
     const message = "message" in e2 ? e2.message : e2;
     console.error("\u26A0\uFE0F Failed to load local schema: ", message);
-    return new graphql3.GraphQLSchema({});
+    return new graphql4.GraphQLSchema({});
   }
 }
 
@@ -73038,7 +73346,7 @@ var Config = class {
       persistedQueriesPath
     } = this.configFile;
     if (typeof schema === "string") {
-      this.schema = graphql4.buildSchema(schema);
+      this.schema = graphql5.buildSchema(schema);
     } else {
       this.schema = schema;
     }
@@ -73186,7 +73494,7 @@ var Config = class {
   set newSchema(value) {
     this.schemaString = value;
     if (value) {
-      this.#newSchemaInstance = graphql4.buildSchema(value);
+      this.#newSchemaInstance = graphql5.buildSchema(value);
     } else {
       this.#newSchemaInstance = null;
     }
@@ -73276,21 +73584,21 @@ var Config = class {
   }
   documentName(document) {
     const operation = document.definitions.find(
-      ({ kind }) => kind === graphql4.Kind.OPERATION_DEFINITION
+      ({ kind }) => kind === graphql5.Kind.OPERATION_DEFINITION
     );
     if (operation) {
       if (!operation.name) {
-        throw new Error("encountered operation with no name: " + graphql4.print(document));
+        throw new Error("encountered operation with no name: " + graphql5.print(document));
       }
       return operation.name.value;
     }
     const fragmentDefinitions = document.definitions.filter(
-      ({ kind }) => kind === graphql4.Kind.FRAGMENT_DEFINITION
+      ({ kind }) => kind === graphql5.Kind.FRAGMENT_DEFINITION
     );
     if (fragmentDefinitions.length) {
       return fragmentDefinitions[0].name.value;
     }
-    throw new Error("Could not generate artifact name for document: " + graphql4.print(document));
+    throw new Error("Could not generate artifact name for document: " + graphql5.print(document));
   }
   isSelectionScalar(type) {
     return ["String", "Boolean", "Float", "ID", "Int"].concat(Object.keys(this.scalars || {})).includes(type);
@@ -73310,8 +73618,8 @@ var Config = class {
       relative(process.cwd(), filepath).replaceAll(sep2, "_").replace(".ts", ".js")
     );
   }
-  excludeFile(filepath) {
-    if (this.exclude.length > 0 && this.exclude.some((pattern) => (0, import_minimatch8.default)(filepath, pattern))) {
+  excludeFile(filepath, { root = this.projectRoot }) {
+    if (this.exclude.length > 0 && this.exclude.some((pattern) => (0, import_minimatch8.default)(filepath, join2(root, pattern)))) {
       return true;
     }
     for (const plugin2 of this.plugins) {
@@ -73340,7 +73648,7 @@ var Config = class {
     if (!included && !this.include.some((pattern) => (0, import_minimatch8.default)(filepath, join2(root, pattern)))) {
       return false;
     }
-    return !this.excludeFile(filepath);
+    return !this.excludeFile(filepath, { root });
   }
   pluginRuntimeDirectory(name) {
     return join2(this.pluginDirectory(name), "runtime");
@@ -73500,10 +73808,10 @@ var Config = class {
   localDocumentData(document) {
     let paginated = false;
     let componentFields3 = [];
-    const typeInfo = new graphql4.TypeInfo(this.schema);
-    graphql4.visit(
+    const typeInfo = new graphql5.TypeInfo(this.schema);
+    graphql5.visit(
       document,
-      graphql4.visitWithTypeInfo(typeInfo, {
+      graphql5.visitWithTypeInfo(typeInfo, {
         Directive: (node) => {
           if ([this.paginateDirective].includes(node.name.value)) {
             paginated = true;
@@ -73815,291 +74123,64 @@ async function pluginPath(plugin_name, config_path) {
       throw new Error("");
     }
     return join2(pluginDirectory, packageJSON.exports["."].import);
-  } catch {
-    const err = new Error(
-      `Could not find plugin: ${plugin_name}. Are you sure its installed? If so, please open a ticket on GitHub.`
-    );
-    throw err;
-  }
-}
-function findModule(pkg = "houdini", currentLocation) {
-  const pathEndingBy = ["node_modules", pkg];
-  let locationFound = join2(currentLocation, ...pathEndingBy);
-  let previousLocation = "";
-  const backFolder = [];
-  while (previousLocation !== locationFound && !existsSync(locationFound)) {
-    previousLocation = locationFound;
-    backFolder.push("../");
-    locationFound = join2(currentLocation, ...backFolder, ...pathEndingBy);
-  }
-  if (previousLocation === locationFound) {
-    throw new Error("Could not find any node_modules/houdini folder");
-  }
-  return locationFound;
-}
-async function loadSchemaFile(schemaPath) {
-  if (isAbsolute(schemaPath)) {
-    const relPath = relative(process.cwd(), schemaPath);
-    const error = new Error(
-      `Invalid config value: 'schemaPath' must now be passed as a relative directory. Please change its value to "./${relPath}".`
-    );
-    error.stack = "";
-    throw error;
-  }
-  if (glob2.hasMagic(schemaPath)) {
-    const sourceFiles = await glob2(schemaPath);
-    return mergeSchemas({
-      typeDefs: await Promise.all(
-        sourceFiles.map(async (filepath) => await readFile(filepath))
-      )
-    });
-  }
-  try {
-    await stat(schemaPath);
-  } catch {
-    throw new HoudiniError({
-      message: `Schema file does not exist! Create it using houdini pull-schema`
-    });
-  }
-  const contents = await readFile(schemaPath);
-  if (schemaPath.endsWith("gql") || schemaPath.endsWith("graphql") || schemaPath.endsWith("graphqls")) {
-    return graphql4.buildSchema(contents);
-  }
-  const jsonContents = JSON.parse(contents);
-  if (jsonContents.data) {
-    return graphql4.buildClientSchema(jsonContents.data);
-  }
-  return graphql4.buildClientSchema(jsonContents);
-}
-var emptySchema = graphql4.buildSchema("type Query { hello: String }");
-var defaultDirectives = emptySchema.getDirectives().map((dir) => dir.name);
-
-// src/lib/graphql.ts
-var graphql5 = __toESM(require("graphql"), 1);
-var import_node_crypto = __toESM(require("node:crypto"), 1);
-function getRootType(type) {
-  if (graphql5.isNonNullType(type)) {
-    return getRootType(type.ofType);
-  }
-  if (graphql5.isListType(type)) {
-    return getRootType(type.ofType);
-  }
-  return type;
-}
-function hashOriginal({ document }) {
-  return hashDocument(document.originalString);
-}
-function hashRaw({ document }) {
-  return hashDocument(document.artifact?.raw);
-}
-function hashDocument(str) {
-  return import_node_crypto.default.createHash("sha256").update(str || "").digest("hex");
-}
-function parentField(ancestors) {
-  return walkParentField([...ancestors].sort(() => -1));
-}
-function walkParentField(ancestors) {
-  let head = ancestors.shift();
-  if (Array.isArray(head) || head.kind === "SelectionSet") {
-    return walkParentField(ancestors);
-  }
-  return head;
-}
-function parentTypeFromAncestors(schema, filepath, ancestors) {
-  const parents = [...ancestors];
-  parents.reverse();
-  return walkAncestors(schema, filepath, parents);
-}
-function walkAncestors(schema, filepath, ancestors) {
-  let head = ancestors.shift();
-  if (Array.isArray(head)) {
-    return walkAncestors(schema, filepath, ancestors);
-  }
-  if (!head) {
-    throw new HoudiniError({ filepath, message: "Could not figure out type of field" });
-  }
-  if (head.kind === "OperationDefinition") {
-    const operationType = {
-      query: schema.getQueryType(),
-      mutation: schema.getMutationType(),
-      subscription: schema.getSubscriptionType()
-    }[head.operation];
-    if (!operationType) {
-      throw new HoudiniError({ filepath, message: "Could not find operation type" });
-    }
-    return operationType;
-  }
-  if (head.kind === "FragmentDefinition") {
-    const result = schema.getType(head.typeCondition.name.value);
-    if (!result) {
-      throw new HoudiniError({
-        filepath,
-        message: `Could not find definition for ${head.typeCondition.name.value} in the schema`
-      });
-    }
-    return result;
-  }
-  if (head.kind === "FragmentSpread") {
-    throw new Error("How the hell did this happen?");
-  }
-  const parent2 = walkAncestors(schema, filepath, ancestors);
-  if (head.kind === "InlineFragment") {
-    if (!head.typeCondition) {
-      return parent2;
-    }
-    const wrapper = schema.getType(head.typeCondition.name.value);
-    if (!wrapper) {
-      throw new HoudiniError({
-        filepath,
-        message: "Could not find type with name: " + head.typeCondition.name.value
-      });
-    }
-    return wrapper;
-  }
-  if (head.kind === "SelectionSet") {
-    return parent2;
-  }
-  const field = parent2.getFields()[head.name.value];
-  if (!field) {
-    throw new HoudiniError({
-      filepath,
-      message: `Could not find definition of ${head.name.value} in ${parent2.toString()}`
-    });
-  }
-  return getRootType(field.type);
-}
-function definitionFromAncestors(ancestors) {
-  let parents = [...ancestors];
-  parents.shift();
-  let definition = parents.shift();
-  while (Array.isArray(definition) && definition) {
-    definition = parents.shift();
-  }
-  return { parents, definition };
-}
-function formatErrors(e2, afterError) {
-  const errors = Array.isArray(e2) ? e2 : [e2];
-  for (const error of errors) {
-    if ("filepath" in error && error.filepath) {
-      const relative2 = relative(process.cwd(), error.filepath);
-      console.error(`\u274C Encountered error in ${relative2}`);
-      if (error.message) {
-        console.error(error.message);
-      }
-    } else {
-      console.error(`\u274C ${error.message}`);
-      if ("description" in error && error.description) {
-        console.error(`${error.description}`);
-      }
-    }
-    afterError?.(e2);
-  }
-}
-function unwrapType(config2, type, wrappers = [], convertRuntimeScalars) {
-  if (type.kind === "NonNullType") {
-    return unwrapType(config2, type.type, [TypeWrapper.NonNull, ...wrappers]);
-  }
-  if (type instanceof graphql5.GraphQLNonNull) {
-    return unwrapType(config2, type.ofType, [TypeWrapper.NonNull, ...wrappers]);
-  }
-  if (wrappers[0] !== TypeWrapper.NonNull) {
-    wrappers.unshift(TypeWrapper.Nullable);
-  }
-  if (type.kind === "ListType") {
-    return unwrapType(config2, type.type, [TypeWrapper.List, ...wrappers]);
-  }
-  if (type instanceof graphql5.GraphQLList) {
-    return unwrapType(config2, type.ofType, [TypeWrapper.List, ...wrappers]);
-  }
-  if (convertRuntimeScalars && config2.configFile.features?.runtimeScalars?.[type.name.value]) {
-    type = config2.schema.getType(
-      config2.configFile.features?.runtimeScalars?.[type.name.value].type
+  } catch {
+    const err = new Error(
+      `Could not find plugin: ${plugin_name}. Are you sure its installed? If so, please open a ticket on GitHub.`
     );
+    throw err;
   }
-  const namedType = config2.schema.getType(type.name.value || type.name);
-  if (!namedType) {
-    throw new Error("Unknown type: " + type.name.value || type.name);
-  }
-  return { type: namedType, wrappers };
 }
-function wrapType({
-  type,
-  wrappers
-}) {
-  const head = wrappers[0];
-  const tail = wrappers.slice(1);
-  let kind = graphql5.Kind.NAMED_TYPE;
-  if (head === TypeWrapper.List) {
-    kind = graphql5.Kind.LIST_TYPE;
-  } else if (head === TypeWrapper.NonNull) {
-    kind = graphql5.Kind.NON_NULL_TYPE;
+function findModule(pkg = "houdini", currentLocation) {
+  const pathEndingBy = ["node_modules", pkg];
+  let locationFound = join2(currentLocation, ...pathEndingBy);
+  let previousLocation = "";
+  const backFolder = [];
+  while (previousLocation !== locationFound && !existsSync(locationFound)) {
+    previousLocation = locationFound;
+    backFolder.push("../");
+    locationFound = join2(currentLocation, ...backFolder, ...pathEndingBy);
   }
-  if (kind === "NamedType") {
-    return {
-      kind,
-      name: {
-        kind: graphql5.Kind.NAME,
-        value: type.name
-      }
-    };
+  if (previousLocation === locationFound) {
+    throw new Error("Could not find any node_modules/houdini folder");
   }
-  return {
-    kind,
-    type: wrapType({ type, wrappers: tail })
-  };
+  return locationFound;
 }
-var TypeWrapper = /* @__PURE__ */ ((TypeWrapper2) => {
-  TypeWrapper2["Nullable"] = "Nullable";
-  TypeWrapper2["List"] = "List";
-  TypeWrapper2["NonNull"] = "NonNull";
-  return TypeWrapper2;
-})(TypeWrapper || {});
-
-// src/lib/parse.ts
-var import_parser = __toESM(require_lib6(), 1);
-var import_recast = __toESM(require_main2(), 1);
-
-// src/lib/deepMerge.ts
-var import_deepmerge = __toESM(require_cjs(), 1);
-function deepMerge2(filepath, ...targets) {
+async function loadSchemaFile(schemaPath) {
+  if (isAbsolute(schemaPath)) {
+    const relPath = relative(process.cwd(), schemaPath);
+    const error = new Error(
+      `Invalid config value: 'schemaPath' must now be passed as a relative directory. Please change its value to "./${relPath}".`
+    );
+    error.stack = "";
+    throw error;
+  }
+  if (glob2.hasMagic(schemaPath)) {
+    const sourceFiles = await glob2(schemaPath);
+    return mergeSchemas({
+      typeDefs: await Promise.all(
+        sourceFiles.map(async (filepath) => await readFile(filepath))
+      )
+    });
+  }
   try {
-    if (targets.length === 1) {
-      return targets[0];
-    } else if (targets.length === 2) {
-      return (0, import_deepmerge.default)(targets[0], targets[1], {
-        arrayMerge: (source, update) => [...new Set(source.concat(update))]
-      });
-    }
-    return deepMerge2(filepath, targets[0], deepMerge2(filepath, ...targets.slice(1)));
-  } catch (e2) {
+    await stat(schemaPath);
+  } catch {
     throw new HoudiniError({
-      filepath,
-      message: "could not merge: " + JSON.stringify(targets, null, 4),
-      description: e2.message
+      message: `Schema file does not exist! Create it using houdini pull-schema`
     });
   }
-}
-
-// src/lib/parse.ts
-function parseJS(str, config2) {
-  const defaultConfig = {
-    plugins: [
-      "typescript",
-      "importAssertions",
-      "decorators-legacy",
-      "explicitResourceManagement"
-    ],
-    sourceType: "module"
-  };
-  return (0, import_parser.parse)(str || "", config2 ? deepMerge2("", defaultConfig, config2) : defaultConfig).program;
-}
-async function printJS(script, options) {
-  if (options?.pretty) {
-    return (0, import_recast.prettyPrint)(script, options);
-  } else {
-    return (0, import_recast.print)(script, options);
+  const contents = await readFile(schemaPath);
+  if (schemaPath.endsWith("gql") || schemaPath.endsWith("graphql") || schemaPath.endsWith("graphqls")) {
+    return graphql5.buildSchema(contents);
   }
+  const jsonContents = JSON.parse(contents);
+  if (jsonContents.data) {
+    return graphql5.buildClientSchema(jsonContents.data);
+  }
+  return graphql5.buildClientSchema(jsonContents);
 }
+var emptySchema = graphql5.buildSchema("type Query { hello: String }");
+var defaultDirectives = emptySchema.getDirectives().map((dir) => dir.name);
 
 // src/lib/imports.ts
 var recast = __toESM(require_main2(), 1);
@@ -74160,85 +74241,6 @@ async function cleanupFiles(pathFolder, listOfObj) {
   return allFilesNotInList;
 }
 
-// src/runtime/router/match.ts
-var param_pattern = /^(\[)?(\.\.\.)?(\w+)(?:=(\w+))?(\])?$/;
-function parse_page_pattern(id) {
-  const params = [];
-  const pattern = id === "/" ? /^\/$/ : new RegExp(
-    `^${get_route_segments(id).map((segment) => {
-      const rest_match = /^\[\.\.\.(\w+)(?:=(\w+))?\]$/.exec(segment);
-      if (rest_match) {
-        params.push({
-          name: rest_match[1],
-          matcher: rest_match[2],
-          optional: false,
-          rest: true,
-          chained: true
-        });
-        return "(?:/(.*))?";
-      }
-      const optional_match = /^\[\[(\w+)(?:=(\w+))?\]\]$/.exec(segment);
-      if (optional_match) {
-        params.push({
-          name: optional_match[1],
-          matcher: optional_match[2],
-          optional: true,
-          rest: false,
-          chained: true
-        });
-        return "(?:/([^/]+))?";
-      }
-      if (!segment) {
-        return;
-      }
-      const parts = segment.split(/\[(.+?)\](?!\])/);
-      const result = parts.map((content, i2) => {
-        if (i2 % 2) {
-          if (content.startsWith("x+")) {
-            return escape3(
-              String.fromCharCode(parseInt(content.slice(2), 16))
-            );
-          }
-          if (content.startsWith("u+")) {
-            return escape3(
-              String.fromCharCode(
-                ...content.slice(2).split("-").map((code) => parseInt(code, 16))
-              )
-            );
-          }
-          const match2 = param_pattern.exec(content);
-          if (!match2) {
-            throw new Error(
-              `Invalid param: ${content}. Params and matcher names can only have underscores and alphanumeric characters.`
-            );
-          }
-          const [, is_optional, is_rest, name, matcher] = match2;
-          params.push({
-            name,
-            matcher,
-            optional: !!is_optional,
-            rest: !!is_rest,
-            chained: is_rest ? i2 === 1 && parts[0] === "" : false
-          });
-          return is_rest ? "(.*?)" : is_optional ? "([^/]*)?" : "([^/]+?)";
-        }
-        return escape3(content);
-      }).join("");
-      return "/" + result;
-    }).join("")}/?$`
-  );
-  return { pattern, params, page_id: id };
-}
-function affects_path(segment) {
-  return !/^\([^)]+\)$/.test(segment);
-}
-function get_route_segments(route) {
-  return route.slice(1).split("/").filter(affects_path);
-}
-function escape3(str) {
-  return str.normalize().replace(/[[\]]/g, "\\$&").replace(/%/g, "%25").replace(/\//g, "%2[Ff]").replace(/\?/g, "%3[Ff]").replace(/#/g, "%23").replace(/[.*+?^${}()|\\]/g, "\\$&");
-}
-
 // src/lib/typescript.ts
 var graphql6 = __toESM(require("graphql"), 1);
 var recast2 = __toESM(require_main2(), 1);
@@ -74308,18 +74310,18 @@ function scalarPropertyValue(config2, filepath, missingScalars, target, body, fi
       return AST3.tsNeverKeyword();
     }
     const component = config2.componentFields[field.parent][field.field];
-    const sourcePathRelative = path_exports.relative(
-      path_exports.join(config2.projectRoot, "src"),
+    const sourcePathRelative = relative(
+      join2(config2.projectRoot, "src"),
       component.filepath
     );
-    let sourcePathParsed = path_exports.parse(sourcePathRelative);
-    let sourcePath = path_exports.join(sourcePathParsed.dir, sourcePathParsed.name);
+    let sourcePathParsed = parse3(sourcePathRelative);
+    let sourcePath = join2(sourcePathParsed.dir, sourcePathParsed.name);
     const localImport = ensureImports({
       config: config2,
       body,
       import: "__component__" + component.fragment,
-      sourceModule: path_exports.join(
-        path_exports.relative(path_exports.dirname(filepath), config2.projectRoot),
+      sourceModule: join2(
+        relative(dirname(filepath), config2.projectRoot),
         "src",
         sourcePath
       )
@@ -74385,9 +74387,9 @@ function scalarPropertyValue(config2, filepath, missingScalars, target, body, fi
   }
 }
 async function writeTsConfig(config2) {
-  await fs_exports.mkdirp(config2.rootDir);
-  await fs_exports.writeFile(
-    path_exports.join(config2.rootDir, "tsconfig.json"),
+  await mkdirp(config2.rootDir);
+  await writeFile(
+    join2(config2.rootDir, "tsconfig.json"),
     JSON.stringify(
       {
         compilerOptions: {
@@ -75281,12 +75283,12 @@ function stripLoc(value) {
 
 // src/codegen/transforms/collectDefinitions.ts
 var graphql8 = __toESM(require("graphql"), 1);
-var import_graphql32 = require("graphql");
+var import_graphql33 = require("graphql");
 async function includeFragmentDefinitions(config2, documents) {
   const fragments = collectDefinitions(config2, documents);
   for (const [index, { name, document, filename }] of documents.entries()) {
     const operation = document.definitions.find(
-      (def) => def.kind === import_graphql32.Kind.OPERATION_DEFINITION || def.kind === "FragmentDefinition"
+      (def) => def.kind === import_graphql33.Kind.OPERATION_DEFINITION || def.kind === "FragmentDefinition"
     );
     if (!operation) {
       continue;
@@ -77282,6 +77284,16 @@ async function generatePluginIndex({
 }
 
 // src/codegen/generators/runtime/pluginRuntime.ts
+function moduleStatments(config2) {
+  const importStatement = config2.module === "commonjs" ? importDefaultFrom : (where, as) => `import ${as} from '${where}'`;
+  const exportDefaultStatement = config2.module === "commonjs" ? exportDefault : (as) => `export default ${as}`;
+  const exportStarStatement = config2.module === "commonjs" ? exportStarFrom : (where) => `export * from '${where}'`;
+  return {
+    importStatement,
+    exportDefaultStatement,
+    exportStarStatement
+  };
+}
 async function generatePluginRuntimes({
   config: config2,
   docs
@@ -77297,7 +77309,7 @@ async function generatePluginRuntimes({
         return;
       }
       try {
-        await fs_exports.stat(runtime_path);
+        await stat(runtime_path);
       } catch {
         throw new HoudiniError({
           message: "Cannot find runtime to generate for " + plugin2.name,
@@ -77309,13 +77321,13 @@ async function generatePluginRuntimes({
       if (transformMap && typeof transformMap === "function") {
         transformMap = transformMap(docs, { config: config2 });
       }
-      await fs_exports.mkdirp(pluginDir);
-      await fs_exports.recursiveCopy(
+      await mkdirp(pluginDir);
+      await recursiveCopy(
         runtime_path,
         pluginDir,
         Object.fromEntries(
           Object.entries(transformMap).map(([key, value]) => [
-            path_exports.join(runtime_path, key),
+            join2(runtime_path, key),
             (content) => value({
               config: config2,
               content,
@@ -77362,21 +77374,21 @@ async function runtimeGenerator(config2, docs) {
     exportStarStatement: exportStar
   } = moduleStatments(config2);
   await Promise.all([
-    fs_exports.recursiveCopy(config2.runtimeSource, config2.runtimeDirectory, {
-      [path_exports.join(config2.runtimeSource, "lib", "constants.js")]: (content) => {
+    recursiveCopy(config2.runtimeSource, config2.runtimeDirectory, {
+      [join2(config2.runtimeSource, "lib", "constants.js")]: (content) => {
         return content.replace("SITE_URL", siteURL);
       },
-      [path_exports.join(config2.runtimeSource, "imports", "pluginConfig.js")]: (content) => {
+      [join2(config2.runtimeSource, "imports", "pluginConfig.js")]: (content) => {
         return injectConfig({ config: config2, importStatement, exportStatement, content });
       },
-      [path_exports.join(config2.runtimeSource, "imports", "config.js")]: (content) => {
-        const configFilePath = path_exports.join(config2.runtimeDirectory, "imports", "config.js");
-        const relativePath = path_exports.relative(path_exports.dirname(configFilePath), config2.filepath);
+      [join2(config2.runtimeSource, "imports", "config.js")]: (content) => {
+        const configFilePath = join2(config2.runtimeDirectory, "imports", "config.js");
+        const relativePath = relative(dirname(configFilePath), config2.filepath);
         return `${importStatement(relativePath, "config")}
 ${exportStatement("config")}
 `;
       },
-      [path_exports.join(config2.runtimeSource, "client", "plugins", "injectedPlugins.js")]: (content) => injectPlugins({ config: config2, content, importStatement, exportStatement })
+      [join2(config2.runtimeSource, "client", "plugins", "injectedPlugins.js")]: (content) => injectPlugins({ config: config2, content, importStatement, exportStatement })
     }),
     generatePluginRuntimes({
       config: config2,
@@ -77386,16 +77398,6 @@ ${exportStatement("config")}
   ]);
   await generateGraphqlReturnTypes(config2, docs);
 }
-function moduleStatments(config2) {
-  const importStatement = config2.module === "commonjs" ? importDefaultFrom : (where, as) => `import ${as} from '${where}'`;
-  const exportDefaultStatement = config2.module === "commonjs" ? exportDefault : (as) => `export default ${as}`;
-  const exportStarStatement = config2.module === "commonjs" ? exportStarFrom : (where) => `export * from '${where}'`;
-  return {
-    importStatement,
-    exportDefaultStatement,
-    exportStarStatement
-  };
-}
 
 // src/codegen/generators/typescript/documentTypes.ts
 var recast11 = __toESM(require_main2(), 1);
@@ -78878,7 +78880,7 @@ async function writeIndexFile2(config2, docs) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/helpers.js
-var import_graphql33 = require("graphql");
+var import_graphql34 = require("graphql");
 function compareStrings2(a, b) {
   if (String(a) < String(b)) {
     return -1;
@@ -78914,7 +78916,7 @@ function isSome2(input) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/inspect.js
-var import_graphql34 = require("graphql");
+var import_graphql35 = require("graphql");
 var MAX_RECURSIVE_DEPTH2 = 3;
 function inspect2(value) {
   return formatValue2(value, []);
@@ -78932,7 +78934,7 @@ function formatValue2(value, seenValues) {
   }
 }
 function formatError2(value) {
-  if (value instanceof import_graphql34.GraphQLError) {
+  if (value instanceof import_graphql35.GraphQLError) {
     return value.toString();
   }
   return `${value.name}: ${value.message};
@@ -79015,43 +79017,43 @@ function getDirectivesInExtensions2(node, pathToDirectivesInExtensions = ["direc
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/print-schema-with-directives.js
-var import_graphql38 = require("graphql");
+var import_graphql39 = require("graphql");
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/astFromType.js
-var import_graphql35 = require("graphql");
+var import_graphql36 = require("graphql");
 function astFromType2(type) {
-  if ((0, import_graphql35.isNonNullType)(type)) {
+  if ((0, import_graphql36.isNonNullType)(type)) {
     const innerType = astFromType2(type.ofType);
-    if (innerType.kind === import_graphql35.Kind.NON_NULL_TYPE) {
+    if (innerType.kind === import_graphql36.Kind.NON_NULL_TYPE) {
       throw new Error(`Invalid type node ${inspect2(type)}. Inner type of non-null type cannot be a non-null type.`);
     }
     return {
-      kind: import_graphql35.Kind.NON_NULL_TYPE,
+      kind: import_graphql36.Kind.NON_NULL_TYPE,
       type: innerType
     };
-  } else if ((0, import_graphql35.isListType)(type)) {
+  } else if ((0, import_graphql36.isListType)(type)) {
     return {
-      kind: import_graphql35.Kind.LIST_TYPE,
+      kind: import_graphql36.Kind.LIST_TYPE,
       type: astFromType2(type.ofType)
     };
   }
   return {
-    kind: import_graphql35.Kind.NAMED_TYPE,
+    kind: import_graphql36.Kind.NAMED_TYPE,
     name: {
-      kind: import_graphql35.Kind.NAME,
+      kind: import_graphql36.Kind.NAME,
       value: type.name
     }
   };
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/astFromValue.js
-var import_graphql37 = require("graphql");
+var import_graphql38 = require("graphql");
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/astFromValueUntyped.js
-var import_graphql36 = require("graphql");
+var import_graphql37 = require("graphql");
 function astFromValueUntyped2(value) {
   if (value === null) {
-    return { kind: import_graphql36.Kind.NULL };
+    return { kind: import_graphql37.Kind.NULL };
   }
   if (value === void 0) {
     return null;
@@ -79064,7 +79066,7 @@ function astFromValueUntyped2(value) {
         valuesNodes.push(itemNode);
       }
     }
-    return { kind: import_graphql36.Kind.LIST, values: valuesNodes };
+    return { kind: import_graphql37.Kind.LIST, values: valuesNodes };
   }
   if (typeof value === "object") {
     const fieldNodes = [];
@@ -79073,26 +79075,26 @@ function astFromValueUntyped2(value) {
       const ast = astFromValueUntyped2(fieldValue);
       if (ast) {
         fieldNodes.push({
-          kind: import_graphql36.Kind.OBJECT_FIELD,
-          name: { kind: import_graphql36.Kind.NAME, value: fieldName },
+          kind: import_graphql37.Kind.OBJECT_FIELD,
+          name: { kind: import_graphql37.Kind.NAME, value: fieldName },
           value: ast
         });
       }
     }
-    return { kind: import_graphql36.Kind.OBJECT, fields: fieldNodes };
+    return { kind: import_graphql37.Kind.OBJECT, fields: fieldNodes };
   }
   if (typeof value === "boolean") {
-    return { kind: import_graphql36.Kind.BOOLEAN, value };
+    return { kind: import_graphql37.Kind.BOOLEAN, value };
   }
   if (typeof value === "bigint") {
-    return { kind: import_graphql36.Kind.INT, value: String(value) };
+    return { kind: import_graphql37.Kind.INT, value: String(value) };
   }
   if (typeof value === "number" && isFinite(value)) {
     const stringNum = String(value);
-    return integerStringRegExp2.test(stringNum) ? { kind: import_graphql36.Kind.INT, value: stringNum } : { kind: import_graphql36.Kind.FLOAT, value: stringNum };
+    return integerStringRegExp2.test(stringNum) ? { kind: import_graphql37.Kind.INT, value: stringNum } : { kind: import_graphql37.Kind.FLOAT, value: stringNum };
   }
   if (typeof value === "string") {
-    return { kind: import_graphql36.Kind.STRING, value };
+    return { kind: import_graphql37.Kind.STRING, value };
   }
   throw new TypeError(`Cannot convert value to AST: ${value}.`);
 }
@@ -79100,20 +79102,20 @@ var integerStringRegExp2 = /^-?(?:0|[1-9][0-9]*)$/;
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/astFromValue.js
 function astFromValue2(value, type) {
-  if ((0, import_graphql37.isNonNullType)(type)) {
+  if ((0, import_graphql38.isNonNullType)(type)) {
     const astValue = astFromValue2(value, type.ofType);
-    if (astValue?.kind === import_graphql37.Kind.NULL) {
+    if (astValue?.kind === import_graphql38.Kind.NULL) {
       return null;
     }
     return astValue;
   }
   if (value === null) {
-    return { kind: import_graphql37.Kind.NULL };
+    return { kind: import_graphql38.Kind.NULL };
   }
   if (value === void 0) {
     return null;
   }
-  if ((0, import_graphql37.isListType)(type)) {
+  if ((0, import_graphql38.isListType)(type)) {
     const itemType = type.ofType;
     if (isIterableObject(value)) {
       const valuesNodes = [];
@@ -79123,11 +79125,11 @@ function astFromValue2(value, type) {
           valuesNodes.push(itemNode);
         }
       }
-      return { kind: import_graphql37.Kind.LIST, values: valuesNodes };
+      return { kind: import_graphql38.Kind.LIST, values: valuesNodes };
     }
     return astFromValue2(value, itemType);
   }
-  if ((0, import_graphql37.isInputObjectType)(type)) {
+  if ((0, import_graphql38.isInputObjectType)(type)) {
     if (!isObjectLike(value)) {
       return null;
     }
@@ -79136,24 +79138,24 @@ function astFromValue2(value, type) {
       const fieldValue = astFromValue2(value[field.name], field.type);
       if (fieldValue) {
         fieldNodes.push({
-          kind: import_graphql37.Kind.OBJECT_FIELD,
-          name: { kind: import_graphql37.Kind.NAME, value: field.name },
+          kind: import_graphql38.Kind.OBJECT_FIELD,
+          name: { kind: import_graphql38.Kind.NAME, value: field.name },
           value: fieldValue
         });
       }
     }
-    return { kind: import_graphql37.Kind.OBJECT, fields: fieldNodes };
+    return { kind: import_graphql38.Kind.OBJECT, fields: fieldNodes };
   }
-  if ((0, import_graphql37.isLeafType)(type)) {
+  if ((0, import_graphql38.isLeafType)(type)) {
     const serialized = type.serialize(value);
     if (serialized == null) {
       return null;
     }
-    if ((0, import_graphql37.isEnumType)(type)) {
-      return { kind: import_graphql37.Kind.ENUM, value: serialized };
+    if ((0, import_graphql38.isEnumType)(type)) {
+      return { kind: import_graphql38.Kind.ENUM, value: serialized };
     }
     if (type.name === "ID" && typeof serialized === "string" && integerStringRegExp3.test(serialized)) {
-      return { kind: import_graphql37.Kind.INT, value: serialized };
+      return { kind: import_graphql38.Kind.INT, value: serialized };
     }
     return astFromValueUntyped2(serialized);
   }
@@ -79209,36 +79211,36 @@ function getDocumentNodeFromSchema2(schema, options = {}) {
   const definitions = schemaNode != null ? [schemaNode] : [];
   const directives = schema.getDirectives();
   for (const directive of directives) {
-    if ((0, import_graphql38.isSpecifiedDirective)(directive)) {
+    if ((0, import_graphql39.isSpecifiedDirective)(directive)) {
       continue;
     }
     definitions.push(astFromDirective2(directive, schema, pathToDirectivesInExtensions));
   }
   for (const typeName in typesMap) {
     const type = typesMap[typeName];
-    const isPredefinedScalar = (0, import_graphql38.isSpecifiedScalarType)(type);
-    const isIntrospection = (0, import_graphql38.isIntrospectionType)(type);
+    const isPredefinedScalar = (0, import_graphql39.isSpecifiedScalarType)(type);
+    const isIntrospection = (0, import_graphql39.isIntrospectionType)(type);
     if (isPredefinedScalar || isIntrospection) {
       continue;
     }
-    if ((0, import_graphql38.isObjectType)(type)) {
+    if ((0, import_graphql39.isObjectType)(type)) {
       definitions.push(astFromObjectType2(type, schema, pathToDirectivesInExtensions));
-    } else if ((0, import_graphql38.isInterfaceType)(type)) {
+    } else if ((0, import_graphql39.isInterfaceType)(type)) {
       definitions.push(astFromInterfaceType2(type, schema, pathToDirectivesInExtensions));
-    } else if ((0, import_graphql38.isUnionType)(type)) {
+    } else if ((0, import_graphql39.isUnionType)(type)) {
       definitions.push(astFromUnionType2(type, schema, pathToDirectivesInExtensions));
-    } else if ((0, import_graphql38.isInputObjectType)(type)) {
+    } else if ((0, import_graphql39.isInputObjectType)(type)) {
       definitions.push(astFromInputObjectType2(type, schema, pathToDirectivesInExtensions));
-    } else if ((0, import_graphql38.isEnumType)(type)) {
+    } else if ((0, import_graphql39.isEnumType)(type)) {
       definitions.push(astFromEnumType2(type, schema, pathToDirectivesInExtensions));
-    } else if ((0, import_graphql38.isScalarType)(type)) {
+    } else if ((0, import_graphql39.isScalarType)(type)) {
       definitions.push(astFromScalarType2(type, schema, pathToDirectivesInExtensions));
     } else {
       throw new Error(`Unknown type ${type}.`);
     }
   }
   return {
-    kind: import_graphql38.Kind.DOCUMENT,
+    kind: import_graphql39.Kind.DOCUMENT,
     definitions
   };
 }
@@ -79273,7 +79275,7 @@ function astFromSchema2(schema, pathToDirectivesInExtensions) {
         operationTypeDefinitionNode.type = rootTypeAST;
       } else {
         operationTypeMap.set(operationTypeNode, {
-          kind: import_graphql38.Kind.OPERATION_TYPE_DEFINITION,
+          kind: import_graphql39.Kind.OPERATION_TYPE_DEFINITION,
           operation: operationTypeNode,
           type: rootTypeAST
         });
@@ -79286,12 +79288,12 @@ function astFromSchema2(schema, pathToDirectivesInExtensions) {
     return null;
   }
   const schemaNode = {
-    kind: operationTypes != null ? import_graphql38.Kind.SCHEMA_DEFINITION : import_graphql38.Kind.SCHEMA_EXTENSION,
+    kind: operationTypes != null ? import_graphql39.Kind.SCHEMA_DEFINITION : import_graphql39.Kind.SCHEMA_EXTENSION,
     operationTypes,
     directives
   };
   schemaNode.description = schema.astNode?.description ?? schema.description != null ? {
-    kind: import_graphql38.Kind.STRING,
+    kind: import_graphql39.Kind.STRING,
     value: schema.description,
     block: true
   } : void 0;
@@ -79299,19 +79301,19 @@ function astFromSchema2(schema, pathToDirectivesInExtensions) {
 }
 function astFromDirective2(directive, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql38.Kind.DIRECTIVE_DEFINITION,
+    kind: import_graphql39.Kind.DIRECTIVE_DEFINITION,
     description: directive.astNode?.description ?? (directive.description ? {
-      kind: import_graphql38.Kind.STRING,
+      kind: import_graphql39.Kind.STRING,
       value: directive.description
     } : void 0),
     name: {
-      kind: import_graphql38.Kind.NAME,
+      kind: import_graphql39.Kind.NAME,
       value: directive.name
     },
     arguments: directive.args?.map((arg) => astFromArg2(arg, schema, pathToDirectivesInExtensions)),
     repeatable: directive.isRepeatable,
     locations: directive.locations?.map((location) => ({
-      kind: import_graphql38.Kind.NAME,
+      kind: import_graphql39.Kind.NAME,
       value: location
     })) || []
   };
@@ -79361,14 +79363,14 @@ function getDeprecatableDirectiveNodes2(entity, schema, pathToDirectivesInExtens
 }
 function astFromArg2(arg, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql38.Kind.INPUT_VALUE_DEFINITION,
+    kind: import_graphql39.Kind.INPUT_VALUE_DEFINITION,
     description: arg.astNode?.description ?? (arg.description ? {
-      kind: import_graphql38.Kind.STRING,
+      kind: import_graphql39.Kind.STRING,
       value: arg.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql38.Kind.NAME,
+      kind: import_graphql39.Kind.NAME,
       value: arg.name
     },
     type: astFromType2(arg.type),
@@ -79378,14 +79380,14 @@ function astFromArg2(arg, schema, pathToDirectivesInExtensions) {
 }
 function astFromObjectType2(type, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql38.Kind.OBJECT_TYPE_DEFINITION,
+    kind: import_graphql39.Kind.OBJECT_TYPE_DEFINITION,
     description: type.astNode?.description ?? (type.description ? {
-      kind: import_graphql38.Kind.STRING,
+      kind: import_graphql39.Kind.STRING,
       value: type.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql38.Kind.NAME,
+      kind: import_graphql39.Kind.NAME,
       value: type.name
     },
     fields: Object.values(type.getFields()).map((field) => astFromField2(field, schema, pathToDirectivesInExtensions)),
@@ -79395,14 +79397,14 @@ function astFromObjectType2(type, schema, pathToDirectivesInExtensions) {
 }
 function astFromInterfaceType2(type, schema, pathToDirectivesInExtensions) {
   const node = {
-    kind: import_graphql38.Kind.INTERFACE_TYPE_DEFINITION,
+    kind: import_graphql39.Kind.INTERFACE_TYPE_DEFINITION,
     description: type.astNode?.description ?? (type.description ? {
-      kind: import_graphql38.Kind.STRING,
+      kind: import_graphql39.Kind.STRING,
       value: type.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql38.Kind.NAME,
+      kind: import_graphql39.Kind.NAME,
       value: type.name
     },
     fields: Object.values(type.getFields()).map((field) => astFromField2(field, schema, pathToDirectivesInExtensions)),
@@ -79415,14 +79417,14 @@ function astFromInterfaceType2(type, schema, pathToDirectivesInExtensions) {
 }
 function astFromUnionType2(type, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql38.Kind.UNION_TYPE_DEFINITION,
+    kind: import_graphql39.Kind.UNION_TYPE_DEFINITION,
     description: type.astNode?.description ?? (type.description ? {
-      kind: import_graphql38.Kind.STRING,
+      kind: import_graphql39.Kind.STRING,
       value: type.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql38.Kind.NAME,
+      kind: import_graphql39.Kind.NAME,
       value: type.name
     },
     directives: getDirectiveNodes2(type, schema, pathToDirectivesInExtensions),
@@ -79431,14 +79433,14 @@ function astFromUnionType2(type, schema, pathToDirectivesInExtensions) {
 }
 function astFromInputObjectType2(type, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql38.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+    kind: import_graphql39.Kind.INPUT_OBJECT_TYPE_DEFINITION,
     description: type.astNode?.description ?? (type.description ? {
-      kind: import_graphql38.Kind.STRING,
+      kind: import_graphql39.Kind.STRING,
       value: type.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql38.Kind.NAME,
+      kind: import_graphql39.Kind.NAME,
       value: type.name
     },
     fields: Object.values(type.getFields()).map((field) => astFromInputField2(field, schema, pathToDirectivesInExtensions)),
@@ -79447,14 +79449,14 @@ function astFromInputObjectType2(type, schema, pathToDirectivesInExtensions) {
 }
 function astFromEnumType2(type, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql38.Kind.ENUM_TYPE_DEFINITION,
+    kind: import_graphql39.Kind.ENUM_TYPE_DEFINITION,
     description: type.astNode?.description ?? (type.description ? {
-      kind: import_graphql38.Kind.STRING,
+      kind: import_graphql39.Kind.STRING,
       value: type.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql38.Kind.NAME,
+      kind: import_graphql39.Kind.NAME,
       value: type.name
     },
     values: Object.values(type.getValues()).map((value) => astFromEnumValue2(value, schema, pathToDirectivesInExtensions)),
@@ -79472,14 +79474,14 @@ function astFromScalarType2(type, schema, pathToDirectivesInExtensions) {
     directives.push(makeDirectiveNode2("specifiedBy", specifiedByArgs));
   }
   return {
-    kind: import_graphql38.Kind.SCALAR_TYPE_DEFINITION,
+    kind: import_graphql39.Kind.SCALAR_TYPE_DEFINITION,
     description: type.astNode?.description ?? (type.description ? {
-      kind: import_graphql38.Kind.STRING,
+      kind: import_graphql39.Kind.STRING,
       value: type.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql38.Kind.NAME,
+      kind: import_graphql39.Kind.NAME,
       value: type.name
     },
     directives
@@ -79487,14 +79489,14 @@ function astFromScalarType2(type, schema, pathToDirectivesInExtensions) {
 }
 function astFromField2(field, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql38.Kind.FIELD_DEFINITION,
+    kind: import_graphql39.Kind.FIELD_DEFINITION,
     description: field.astNode?.description ?? (field.description ? {
-      kind: import_graphql38.Kind.STRING,
+      kind: import_graphql39.Kind.STRING,
       value: field.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql38.Kind.NAME,
+      kind: import_graphql39.Kind.NAME,
       value: field.name
     },
     arguments: field.args.map((arg) => astFromArg2(arg, schema, pathToDirectivesInExtensions)),
@@ -79504,14 +79506,14 @@ function astFromField2(field, schema, pathToDirectivesInExtensions) {
 }
 function astFromInputField2(field, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql38.Kind.INPUT_VALUE_DEFINITION,
+    kind: import_graphql39.Kind.INPUT_VALUE_DEFINITION,
     description: field.astNode?.description ?? (field.description ? {
-      kind: import_graphql38.Kind.STRING,
+      kind: import_graphql39.Kind.STRING,
       value: field.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql38.Kind.NAME,
+      kind: import_graphql39.Kind.NAME,
       value: field.name
     },
     type: astFromType2(field.type),
@@ -79521,21 +79523,21 @@ function astFromInputField2(field, schema, pathToDirectivesInExtensions) {
 }
 function astFromEnumValue2(value, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql38.Kind.ENUM_VALUE_DEFINITION,
+    kind: import_graphql39.Kind.ENUM_VALUE_DEFINITION,
     description: value.astNode?.description ?? (value.description ? {
-      kind: import_graphql38.Kind.STRING,
+      kind: import_graphql39.Kind.STRING,
       value: value.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql38.Kind.NAME,
+      kind: import_graphql39.Kind.NAME,
       value: value.name
     },
     directives: getDeprecatableDirectiveNodes2(value, schema, pathToDirectivesInExtensions)
   };
 }
 function makeDeprecatedDirective2(deprecationReason) {
-  return makeDirectiveNode2("deprecated", { reason: deprecationReason }, import_graphql38.GraphQLDeprecatedDirective);
+  return makeDirectiveNode2("deprecated", { reason: deprecationReason }, import_graphql39.GraphQLDeprecatedDirective);
 }
 function makeDirectiveNode2(name, args, directive) {
   const directiveArguments = [];
@@ -79547,9 +79549,9 @@ function makeDirectiveNode2(name, args, directive) {
         const value = astFromValue2(argValue, arg.type);
         if (value) {
           directiveArguments.push({
-            kind: import_graphql38.Kind.ARGUMENT,
+            kind: import_graphql39.Kind.ARGUMENT,
             name: {
-              kind: import_graphql38.Kind.NAME,
+              kind: import_graphql39.Kind.NAME,
               value: argName
             },
             value
@@ -79563,9 +79565,9 @@ function makeDirectiveNode2(name, args, directive) {
       const value = astFromValueUntyped2(argValue);
       if (value) {
         directiveArguments.push({
-          kind: import_graphql38.Kind.ARGUMENT,
+          kind: import_graphql39.Kind.ARGUMENT,
           name: {
-            kind: import_graphql38.Kind.NAME,
+            kind: import_graphql39.Kind.NAME,
             value: argName
           },
           value
@@ -79574,9 +79576,9 @@ function makeDirectiveNode2(name, args, directive) {
     }
   }
   return {
-    kind: import_graphql38.Kind.DIRECTIVE,
+    kind: import_graphql39.Kind.DIRECTIVE,
     name: {
-      kind: import_graphql38.Kind.NAME,
+      kind: import_graphql39.Kind.NAME,
       value: name
     },
     arguments: directiveArguments
@@ -79599,7 +79601,7 @@ function makeDirectiveNodes2(schema, directiveValues) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/comments.js
-var import_graphql39 = require("graphql");
+var import_graphql40 = require("graphql");
 var MAX_LINE_LENGTH2 = 80;
 var commentsRegistry2 = {};
 function resetComments2() {
@@ -79844,7 +79846,7 @@ var printDocASTReducerWithComments2 = Object.keys(printDocASTReducer2).reduce((p
   }
 }), {});
 function printWithComments2(ast) {
-  return (0, import_graphql39.visit)(ast, printDocASTReducerWithComments2);
+  return (0, import_graphql40.visit)(ast, printDocASTReducerWithComments2);
 }
 function isFieldDefinitionNode2(node) {
   return node.kind === "FieldDefinition";
@@ -79863,7 +79865,7 @@ function getLeadingCommentBlock2(node) {
   }
   const comments = [];
   let token = loc.startToken.prev;
-  while (token != null && token.kind === import_graphql39.TokenKind.COMMENT && token.next != null && token.prev != null && token.line + 1 === token.next.line && token.line !== token.prev.line) {
+  while (token != null && token.kind === import_graphql40.TokenKind.COMMENT && token.next != null && token.prev != null && token.line + 1 === token.next.line && token.line !== token.prev.line) {
     const value = String(token.value);
     comments.push(value);
     token = token.prev;
@@ -79915,9 +79917,9 @@ function isBlank2(str) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/isDocumentNode.js
-var import_graphql40 = require("graphql");
+var import_graphql41 = require("graphql");
 function isDocumentNode2(object) {
-  return object && typeof object === "object" && "kind" in object && object.kind === import_graphql40.Kind.DOCUMENT;
+  return object && typeof object === "object" && "kind" in object && object.kind === import_graphql41.Kind.DOCUMENT;
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/arguments.js
@@ -79941,7 +79943,7 @@ function deduplicateArguments2(args, config2) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/directives.js
-var import_graphql41 = require("graphql");
+var import_graphql42 = require("graphql");
 function directiveAlreadyExists2(directivesArr, otherDirective) {
   return !!directivesArr.find((directive) => directive.name.value === otherDirective.name.value);
 }
@@ -80001,11 +80003,11 @@ function mergeDirectives2(d1 = [], d2 = [], config2, directives) {
   return result;
 }
 function validateInputs2(node, existingNode) {
-  const printedNode = (0, import_graphql41.print)({
+  const printedNode = (0, import_graphql42.print)({
     ...node,
     description: void 0
   });
-  const printedExistingNode = (0, import_graphql41.print)({
+  const printedExistingNode = (0, import_graphql42.print)({
     ...existingNode,
     description: void 0
   });
@@ -80072,7 +80074,7 @@ function mergeEnumValues2(first, second, config2, directives) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/enum.js
-var import_graphql42 = require("graphql");
+var import_graphql43 = require("graphql");
 function mergeEnum2(e1, e2, config2, directives) {
   if (e2) {
     return {
@@ -80086,33 +80088,33 @@ function mergeEnum2(e1, e2, config2, directives) {
   }
   return config2?.convertExtensions ? {
     ...e1,
-    kind: import_graphql42.Kind.ENUM_TYPE_DEFINITION
+    kind: import_graphql43.Kind.ENUM_TYPE_DEFINITION
   } : e1;
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/utils.js
-var import_graphql43 = require("graphql");
+var import_graphql44 = require("graphql");
 function isStringTypes2(types19) {
   return typeof types19 === "string";
 }
 function isSourceTypes2(types19) {
-  return types19 instanceof import_graphql43.Source;
+  return types19 instanceof import_graphql44.Source;
 }
 function extractType2(type) {
   let visitedType = type;
-  while (visitedType.kind === import_graphql43.Kind.LIST_TYPE || visitedType.kind === "NonNullType") {
+  while (visitedType.kind === import_graphql44.Kind.LIST_TYPE || visitedType.kind === "NonNullType") {
     visitedType = visitedType.type;
   }
   return visitedType;
 }
 function isWrappingTypeNode2(type) {
-  return type.kind !== import_graphql43.Kind.NAMED_TYPE;
+  return type.kind !== import_graphql44.Kind.NAMED_TYPE;
 }
 function isListTypeNode2(type) {
-  return type.kind === import_graphql43.Kind.LIST_TYPE;
+  return type.kind === import_graphql44.Kind.LIST_TYPE;
 }
 function isNonNullTypeNode2(type) {
-  return type.kind === import_graphql43.Kind.NON_NULL_TYPE;
+  return type.kind === import_graphql44.Kind.NON_NULL_TYPE;
 }
 function printTypeNode2(type) {
   if (isListTypeNode2(type)) {
@@ -80215,7 +80217,7 @@ function safeChangeForFieldType2(oldType, newType, ignoreNullability = false) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/input-type.js
-var import_graphql44 = require("graphql");
+var import_graphql45 = require("graphql");
 function mergeInputType2(node, existingNode, config2, directives) {
   if (existingNode) {
     try {
@@ -80233,12 +80235,12 @@ function mergeInputType2(node, existingNode, config2, directives) {
   }
   return config2?.convertExtensions ? {
     ...node,
-    kind: import_graphql44.Kind.INPUT_OBJECT_TYPE_DEFINITION
+    kind: import_graphql45.Kind.INPUT_OBJECT_TYPE_DEFINITION
   } : node;
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/interface.js
-var import_graphql45 = require("graphql");
+var import_graphql46 = require("graphql");
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/merge-named-type-array.js
 function alreadyExists2(arr, other) {
@@ -80271,15 +80273,15 @@ function mergeInterface2(node, existingNode, config2, directives) {
   }
   return config2?.convertExtensions ? {
     ...node,
-    kind: import_graphql45.Kind.INTERFACE_TYPE_DEFINITION
+    kind: import_graphql46.Kind.INTERFACE_TYPE_DEFINITION
   } : node;
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/merge-nodes.js
-var import_graphql50 = require("graphql");
+var import_graphql51 = require("graphql");
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/type.js
-var import_graphql46 = require("graphql");
+var import_graphql47 = require("graphql");
 function mergeType2(node, existingNode, config2, directives) {
   if (existingNode) {
     try {
@@ -80298,12 +80300,12 @@ function mergeType2(node, existingNode, config2, directives) {
   }
   return config2?.convertExtensions ? {
     ...node,
-    kind: import_graphql46.Kind.OBJECT_TYPE_DEFINITION
+    kind: import_graphql47.Kind.OBJECT_TYPE_DEFINITION
   } : node;
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/scalar.js
-var import_graphql47 = require("graphql");
+var import_graphql48 = require("graphql");
 function mergeScalar2(node, existingNode, config2, directives) {
   if (existingNode) {
     return {
@@ -80316,31 +80318,31 @@ function mergeScalar2(node, existingNode, config2, directives) {
   }
   return config2?.convertExtensions ? {
     ...node,
-    kind: import_graphql47.Kind.SCALAR_TYPE_DEFINITION
+    kind: import_graphql48.Kind.SCALAR_TYPE_DEFINITION
   } : node;
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/union.js
-var import_graphql48 = require("graphql");
+var import_graphql49 = require("graphql");
 function mergeUnion2(first, second, config2, directives) {
   if (second) {
     return {
       name: first.name,
       description: first["description"] || second["description"],
       directives: mergeDirectives2(first.directives, second.directives, config2, directives),
-      kind: config2?.convertExtensions || first.kind === "UnionTypeDefinition" || second.kind === "UnionTypeDefinition" ? import_graphql48.Kind.UNION_TYPE_DEFINITION : import_graphql48.Kind.UNION_TYPE_EXTENSION,
+      kind: config2?.convertExtensions || first.kind === "UnionTypeDefinition" || second.kind === "UnionTypeDefinition" ? import_graphql49.Kind.UNION_TYPE_DEFINITION : import_graphql49.Kind.UNION_TYPE_EXTENSION,
       loc: first.loc,
       types: mergeNamedTypeArray2(first.types, second.types, config2)
     };
   }
   return config2?.convertExtensions ? {
     ...first,
-    kind: import_graphql48.Kind.UNION_TYPE_DEFINITION
+    kind: import_graphql49.Kind.UNION_TYPE_DEFINITION
   } : first;
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/schema-def.js
-var import_graphql49 = require("graphql");
+var import_graphql50 = require("graphql");
 var DEFAULT_OPERATION_TYPE_NAME_MAP2 = {
   query: "Query",
   mutation: "Mutation",
@@ -80359,7 +80361,7 @@ function mergeOperationTypes2(opNodeList = [], existingOpNodeList = []) {
 function mergeSchemaDefs2(node, existingNode, config2, directives) {
   if (existingNode) {
     return {
-      kind: node.kind === import_graphql49.Kind.SCHEMA_DEFINITION || existingNode.kind === import_graphql49.Kind.SCHEMA_DEFINITION ? import_graphql49.Kind.SCHEMA_DEFINITION : import_graphql49.Kind.SCHEMA_EXTENSION,
+      kind: node.kind === import_graphql50.Kind.SCHEMA_DEFINITION || existingNode.kind === import_graphql50.Kind.SCHEMA_DEFINITION ? import_graphql50.Kind.SCHEMA_DEFINITION : import_graphql50.Kind.SCHEMA_EXTENSION,
       description: node["description"] || existingNode["description"],
       directives: mergeDirectives2(node.directives, existingNode.directives, config2, directives),
       operationTypes: mergeOperationTypes2(node.operationTypes, existingNode.operationTypes)
@@ -80367,7 +80369,7 @@ function mergeSchemaDefs2(node, existingNode, config2, directives) {
   }
   return config2?.convertExtensions ? {
     ...node,
-    kind: import_graphql49.Kind.SCHEMA_DEFINITION
+    kind: import_graphql50.Kind.SCHEMA_DEFINITION
   } : node;
 }
 
@@ -80391,36 +80393,36 @@ function mergeGraphQLNodes2(nodes, config2, directives = {}) {
         delete mergedResultMap[name];
       } else {
         switch (nodeDefinition.kind) {
-          case import_graphql50.Kind.OBJECT_TYPE_DEFINITION:
-          case import_graphql50.Kind.OBJECT_TYPE_EXTENSION:
+          case import_graphql51.Kind.OBJECT_TYPE_DEFINITION:
+          case import_graphql51.Kind.OBJECT_TYPE_EXTENSION:
             mergedResultMap[name] = mergeType2(nodeDefinition, mergedResultMap[name], config2, directives);
             break;
-          case import_graphql50.Kind.ENUM_TYPE_DEFINITION:
-          case import_graphql50.Kind.ENUM_TYPE_EXTENSION:
+          case import_graphql51.Kind.ENUM_TYPE_DEFINITION:
+          case import_graphql51.Kind.ENUM_TYPE_EXTENSION:
             mergedResultMap[name] = mergeEnum2(nodeDefinition, mergedResultMap[name], config2, directives);
             break;
-          case import_graphql50.Kind.UNION_TYPE_DEFINITION:
-          case import_graphql50.Kind.UNION_TYPE_EXTENSION:
+          case import_graphql51.Kind.UNION_TYPE_DEFINITION:
+          case import_graphql51.Kind.UNION_TYPE_EXTENSION:
             mergedResultMap[name] = mergeUnion2(nodeDefinition, mergedResultMap[name], config2, directives);
             break;
-          case import_graphql50.Kind.SCALAR_TYPE_DEFINITION:
-          case import_graphql50.Kind.SCALAR_TYPE_EXTENSION:
+          case import_graphql51.Kind.SCALAR_TYPE_DEFINITION:
+          case import_graphql51.Kind.SCALAR_TYPE_EXTENSION:
             mergedResultMap[name] = mergeScalar2(nodeDefinition, mergedResultMap[name], config2, directives);
             break;
-          case import_graphql50.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-          case import_graphql50.Kind.INPUT_OBJECT_TYPE_EXTENSION:
+          case import_graphql51.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+          case import_graphql51.Kind.INPUT_OBJECT_TYPE_EXTENSION:
             mergedResultMap[name] = mergeInputType2(nodeDefinition, mergedResultMap[name], config2, directives);
             break;
-          case import_graphql50.Kind.INTERFACE_TYPE_DEFINITION:
-          case import_graphql50.Kind.INTERFACE_TYPE_EXTENSION:
+          case import_graphql51.Kind.INTERFACE_TYPE_DEFINITION:
+          case import_graphql51.Kind.INTERFACE_TYPE_EXTENSION:
             mergedResultMap[name] = mergeInterface2(nodeDefinition, mergedResultMap[name], config2, directives);
             break;
-          case import_graphql50.Kind.DIRECTIVE_DEFINITION:
+          case import_graphql51.Kind.DIRECTIVE_DEFINITION:
             mergedResultMap[name] = mergeDirective2(nodeDefinition, mergedResultMap[name]);
             break;
         }
       }
-    } else if (nodeDefinition.kind === import_graphql50.Kind.SCHEMA_DEFINITION || nodeDefinition.kind === import_graphql50.Kind.SCHEMA_EXTENSION) {
+    } else if (nodeDefinition.kind === import_graphql51.Kind.SCHEMA_DEFINITION || nodeDefinition.kind === import_graphql51.Kind.SCHEMA_EXTENSION) {
       mergedResultMap[schemaDefSymbol2] = mergeSchemaDefs2(nodeDefinition, mergedResultMap[schemaDefSymbol2], config2);
     }
   }
@@ -80428,11 +80430,11 @@ function mergeGraphQLNodes2(nodes, config2, directives = {}) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/merge-typedefs.js
-var import_graphql51 = require("graphql");
+var import_graphql52 = require("graphql");
 function mergeTypeDefs2(typeSource, config2) {
   resetComments2();
   const doc = {
-    kind: import_graphql51.Kind.DOCUMENT,
+    kind: import_graphql52.Kind.DOCUMENT,
     definitions: mergeGraphQLTypes2(typeSource, {
       useSchemaDefinition: true,
       forceSchemaDefinition: false,
@@ -80459,14 +80461,14 @@ function visitTypeSources2(typeSource, options, allDirectives = [], allNodes = [
       for (const type of typeSource) {
         visitTypeSources2(type, options, allDirectives, allNodes, visitedTypeSources);
       }
-    } else if ((0, import_graphql51.isSchema)(typeSource)) {
+    } else if ((0, import_graphql52.isSchema)(typeSource)) {
       const documentNode = getDocumentNodeFromSchema2(typeSource, options);
       visitTypeSources2(documentNode.definitions, options, allDirectives, allNodes, visitedTypeSources);
     } else if (isStringTypes2(typeSource) || isSourceTypes2(typeSource)) {
-      const documentNode = (0, import_graphql51.parse)(typeSource, options);
+      const documentNode = (0, import_graphql52.parse)(typeSource, options);
       visitTypeSources2(documentNode.definitions, options, allDirectives, allNodes, visitedTypeSources);
-    } else if (typeof typeSource === "object" && (0, import_graphql51.isDefinitionNode)(typeSource)) {
-      if (typeSource.kind === import_graphql51.Kind.DIRECTIVE_DEFINITION) {
+    } else if (typeof typeSource === "object" && (0, import_graphql52.isDefinitionNode)(typeSource)) {
+      if (typeSource.kind === import_graphql52.Kind.DIRECTIVE_DEFINITION) {
         allDirectives.push(typeSource);
       } else {
         allNodes.push(typeSource);
@@ -80486,7 +80488,7 @@ function mergeGraphQLTypes2(typeSource, config2) {
   const mergedNodes = mergeGraphQLNodes2(allNodes, config2, mergedDirectives);
   if (config2?.useSchemaDefinition) {
     const schemaDef = mergedNodes[schemaDefSymbol2] || {
-      kind: import_graphql51.Kind.SCHEMA_DEFINITION,
+      kind: import_graphql52.Kind.SCHEMA_DEFINITION,
       operationTypes: []
     };
     const operationTypes = schemaDef.operationTypes;
@@ -80497,9 +80499,9 @@ function mergeGraphQLTypes2(typeSource, config2) {
         const existingPossibleRootType = mergedNodes[possibleRootTypeName];
         if (existingPossibleRootType != null && existingPossibleRootType.name != null) {
           operationTypes.push({
-            kind: import_graphql51.Kind.OPERATION_TYPE_DEFINITION,
+            kind: import_graphql52.Kind.OPERATION_TYPE_DEFINITION,
             type: {
-              kind: import_graphql51.Kind.NAMED_TYPE,
+              kind: import_graphql52.Kind.NAMED_TYPE,
               name: existingPossibleRootType.name
             },
             operation: opTypeDefNodeType
@@ -80513,15 +80515,15 @@ function mergeGraphQLTypes2(typeSource, config2) {
   }
   if (config2?.forceSchemaDefinition && !mergedNodes[schemaDefSymbol2]?.operationTypes?.length) {
     mergedNodes[schemaDefSymbol2] = {
-      kind: import_graphql51.Kind.SCHEMA_DEFINITION,
+      kind: import_graphql52.Kind.SCHEMA_DEFINITION,
       operationTypes: [
         {
-          kind: import_graphql51.Kind.OPERATION_TYPE_DEFINITION,
+          kind: import_graphql52.Kind.OPERATION_TYPE_DEFINITION,
           operation: "query",
           type: {
-            kind: import_graphql51.Kind.NAMED_TYPE,
+            kind: import_graphql52.Kind.NAMED_TYPE,
             name: {
-              kind: import_graphql51.Kind.NAME,
+              kind: import_graphql52.Kind.NAME,
               value: "Query"
             }
           }