@fern-api/fern-api-dev 5.104.1 → 5.105.1

package/cli.cjs

@@ -38761,11 +38761,11 @@ var require_errors = __commonJS({
       gen.code((0, codegen_1._)`${names_1.default.errors}++`);
     }
     function returnErrors(it3, errs) {
-      const { gen, validateName: validateName3, schemaEnv } = it3;
+      const { gen, validateName: validateName4, schemaEnv } = it3;
       if (schemaEnv.$async) {
         gen.throw((0, codegen_1._)`new ${it3.ValidationError}(${errs})`);
       } else {
-        gen.assign((0, codegen_1._)`${validateName3}.errors`, errs);
+        gen.assign((0, codegen_1._)`${validateName4}.errors`, errs);
         gen.return(false);
       }
     }
@@ -38834,13 +38834,13 @@ var require_boolSchema = __commonJS({
       message: "boolean schema is false"
     };
     function topBoolOrEmptySchema(it3) {
-      const { gen, schema, validateName: validateName3 } = it3;
+      const { gen, schema, validateName: validateName4 } = it3;
       if (schema === false) {
         falseSchemaError(it3, false);
       } else if (typeof schema == "object" && schema.$async === true) {
         gen.return(names_1.default.data);
       } else {
-        gen.assign((0, codegen_1._)`${validateName3}.errors`, null);
+        gen.assign((0, codegen_1._)`${validateName4}.errors`, null);
         gen.return(true);
       }
     }
@@ -39789,15 +39789,15 @@ var require_validate = __commonJS({
       validateFunction(it3, () => (0, boolSchema_1.topBoolOrEmptySchema)(it3));
     }
     exports2.validateFunctionCode = validateFunctionCode;
-    function validateFunction({ gen, validateName: validateName3, schema, schemaEnv, opts }, body) {
+    function validateFunction({ gen, validateName: validateName4, schema, schemaEnv, opts }, body) {
       if (opts.code.es5) {
-        gen.func(validateName3, (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => {
+        gen.func(validateName4, (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => {
           gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema, opts)}`);
           destructureValCxtES5(gen, opts);
           gen.code(body);
         });
       } else {
-        gen.func(validateName3, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body));
+        gen.func(validateName4, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body));
       }
     }
     function destructureValCxt(opts) {
@@ -39836,8 +39836,8 @@ var require_validate = __commonJS({
       return;
     }
     function resetEvaluated(it3) {
-      const { gen, validateName: validateName3 } = it3;
-      it3.evaluated = gen.const("evaluated", (0, codegen_1._)`${validateName3}.evaluated`);
+      const { gen, validateName: validateName4 } = it3;
+      it3.evaluated = gen.const("evaluated", (0, codegen_1._)`${validateName4}.evaluated`);
       gen.if((0, codegen_1._)`${it3.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1._)`${it3.evaluated}.props`, (0, codegen_1._)`undefined`));
       gen.if((0, codegen_1._)`${it3.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1._)`${it3.evaluated}.items`, (0, codegen_1._)`undefined`));
     }
@@ -39919,11 +39919,11 @@ var require_validate = __commonJS({
       }
     }
     function returnResults(it3) {
-      const { gen, schemaEnv, validateName: validateName3, ValidationError: ValidationError5, opts } = it3;
+      const { gen, schemaEnv, validateName: validateName4, ValidationError: ValidationError5, opts } = it3;
       if (schemaEnv.$async) {
         gen.if((0, codegen_1._)`${names_1.default.errors} === 0`, () => gen.return(names_1.default.data), () => gen.throw((0, codegen_1._)`new ${ValidationError5}(${names_1.default.vErrors})`));
       } else {
-        gen.assign((0, codegen_1._)`${validateName3}.errors`, names_1.default.vErrors);
+        gen.assign((0, codegen_1._)`${validateName4}.errors`, names_1.default.vErrors);
         if (opts.unevaluated)
           assignEvaluated(it3);
         gen.return((0, codegen_1._)`${names_1.default.errors} === 0`);
@@ -40348,8 +40348,8 @@ var require_compile = __commonJS({
           code: (0, codegen_1._)`require("ajv/dist/runtime/validation_error").default`
         });
       }
-      const validateName3 = gen.scopeName("validate");
-      sch.validateName = validateName3;
+      const validateName4 = gen.scopeName("validate");
+      sch.validateName = validateName4;
       const schemaCxt = {
         gen,
         allErrors: this.opts.allErrors,
@@ -40363,7 +40363,7 @@ var require_compile = __commonJS({
         dataTypes: [],
         definedProperties: /* @__PURE__ */ new Set(),
         topSchemaRef: gen.scopeValue("schema", this.opts.code.source === true ? { ref: sch.schema, code: (0, codegen_1.stringify)(sch.schema) } : { ref: sch.schema }),
-        validateName: validateName3,
+        validateName: validateName4,
         ValidationError: _ValidationError,
         schema: sch.schema,
         schemaEnv: sch,
@@ -40386,14 +40386,14 @@ var require_compile = __commonJS({
           sourceCode = this.opts.code.process(sourceCode, sch);
         const makeValidate = new Function(`${names_1.default.self}`, `${names_1.default.scope}`, sourceCode);
         const validate3 = makeValidate(this, this.scope.get());
-        this.scope.value(validateName3, { ref: validate3 });
+        this.scope.value(validateName4, { ref: validate3 });
         validate3.errors = null;
         validate3.schema = sch.schema;
         validate3.schemaEnv = sch;
         if (sch.$async)
           validate3.$async = true;
         if (this.opts.code.source === true) {
-          validate3.source = { validateName: validateName3, validateCode, scopeValues: gen._values };
+          validate3.source = { validateName: validateName4, validateCode, scopeValues: gen._values };
         }
         if (this.opts.unevaluated) {
           const { props, items } = schemaCxt;
@@ -42007,7 +42007,7 @@ var require_ref = __commonJS({
       schemaType: "string",
       code(cxt) {
         const { gen, schema: $ref, it: it3 } = cxt;
-        const { baseId, schemaEnv: env5, validateName: validateName3, opts, self: self2 } = it3;
+        const { baseId, schemaEnv: env5, validateName: validateName4, opts, self: self2 } = it3;
         const { root: root6 } = env5;
         if (($ref === "#" || $ref === "#/") && baseId === root6.baseId)
           return callRootRef();
@@ -42019,7 +42019,7 @@ var require_ref = __commonJS({
         return inlineRefSchema(schOrEnv);
         function callRootRef() {
           if (env5 === root6)
-            return callRef(cxt, validateName3, env5, env5.$async);
+            return callRef(cxt, validateName4, env5, env5.$async);
           const rootName = gen.scopeValue("root", { ref: root6 });
           return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root6, root6.$async);
         }
@@ -180798,11 +180798,11 @@ var require_errors2 = __commonJS({
       gen.code((0, codegen_1._)`${names_1.default.errors}++`);
     }
     function returnErrors(it3, errs) {
-      const { gen, validateName: validateName3, schemaEnv } = it3;
+      const { gen, validateName: validateName4, schemaEnv } = it3;
       if (schemaEnv.$async) {
         gen.throw((0, codegen_1._)`new ${it3.ValidationError}(${errs})`);
       } else {
-        gen.assign((0, codegen_1._)`${validateName3}.errors`, errs);
+        gen.assign((0, codegen_1._)`${validateName4}.errors`, errs);
         gen.return(false);
       }
     }
@@ -180872,13 +180872,13 @@ var require_boolSchema2 = __commonJS({
       message: "boolean schema is false"
     };
     function topBoolOrEmptySchema(it3) {
-      const { gen, schema, validateName: validateName3 } = it3;
+      const { gen, schema, validateName: validateName4 } = it3;
       if (schema === false) {
         falseSchemaError(it3, false);
       } else if (typeof schema == "object" && schema.$async === true) {
         gen.return(names_1.default.data);
       } else {
-        gen.assign((0, codegen_1._)`${validateName3}.errors`, null);
+        gen.assign((0, codegen_1._)`${validateName4}.errors`, null);
         gen.return(true);
       }
     }
@@ -181699,15 +181699,15 @@ var require_validate2 = __commonJS({
       }
       validateFunction(it3, () => (0, boolSchema_1.topBoolOrEmptySchema)(it3));
     }
-    function validateFunction({ gen, validateName: validateName3, schema, schemaEnv, opts }, body) {
+    function validateFunction({ gen, validateName: validateName4, schema, schemaEnv, opts }, body) {
       if (opts.code.es5) {
-        gen.func(validateName3, (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => {
+        gen.func(validateName4, (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => {
           gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema, opts)}`);
           destructureValCxtES5(gen, opts);
           gen.code(body);
         });
       } else {
-        gen.func(validateName3, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body));
+        gen.func(validateName4, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body));
       }
     }
     function destructureValCxt(opts) {
@@ -181748,8 +181748,8 @@ var require_validate2 = __commonJS({
       return;
     }
     function resetEvaluated(it3) {
-      const { gen, validateName: validateName3 } = it3;
-      it3.evaluated = gen.const("evaluated", (0, codegen_1._)`${validateName3}.evaluated`);
+      const { gen, validateName: validateName4 } = it3;
+      it3.evaluated = gen.const("evaluated", (0, codegen_1._)`${validateName4}.evaluated`);
       gen.if((0, codegen_1._)`${it3.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1._)`${it3.evaluated}.props`, (0, codegen_1._)`undefined`));
       gen.if((0, codegen_1._)`${it3.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1._)`${it3.evaluated}.items`, (0, codegen_1._)`undefined`));
     }
@@ -181831,11 +181831,11 @@ var require_validate2 = __commonJS({
       }
     }
     function returnResults(it3) {
-      const { gen, schemaEnv, validateName: validateName3, ValidationError: ValidationError5, opts } = it3;
+      const { gen, schemaEnv, validateName: validateName4, ValidationError: ValidationError5, opts } = it3;
       if (schemaEnv.$async) {
         gen.if((0, codegen_1._)`${names_1.default.errors} === 0`, () => gen.return(names_1.default.data), () => gen.throw((0, codegen_1._)`new ${ValidationError5}(${names_1.default.vErrors})`));
       } else {
-        gen.assign((0, codegen_1._)`${validateName3}.errors`, names_1.default.vErrors);
+        gen.assign((0, codegen_1._)`${validateName4}.errors`, names_1.default.vErrors);
         if (opts.unevaluated)
           assignEvaluated(it3);
         gen.return((0, codegen_1._)`${names_1.default.errors} === 0`);
@@ -182262,8 +182262,8 @@ var require_compile2 = __commonJS({
           code: (0, codegen_1._)`require("ajv/dist/runtime/validation_error").default`
         });
       }
-      const validateName3 = gen.scopeName("validate");
-      sch.validateName = validateName3;
+      const validateName4 = gen.scopeName("validate");
+      sch.validateName = validateName4;
       const schemaCxt = {
         gen,
         allErrors: this.opts.allErrors,
@@ -182277,7 +182277,7 @@ var require_compile2 = __commonJS({
         dataTypes: [],
         definedProperties: /* @__PURE__ */ new Set(),
         topSchemaRef: gen.scopeValue("schema", this.opts.code.source === true ? { ref: sch.schema, code: (0, codegen_1.stringify)(sch.schema) } : { ref: sch.schema }),
-        validateName: validateName3,
+        validateName: validateName4,
         ValidationError: _ValidationError,
         schema: sch.schema,
         schemaEnv: sch,
@@ -182300,14 +182300,14 @@ var require_compile2 = __commonJS({
           sourceCode = this.opts.code.process(sourceCode, sch);
         const makeValidate = new Function(`${names_1.default.self}`, `${names_1.default.scope}`, sourceCode);
         const validate3 = makeValidate(this, this.scope.get());
-        this.scope.value(validateName3, { ref: validate3 });
+        this.scope.value(validateName4, { ref: validate3 });
         validate3.errors = null;
         validate3.schema = sch.schema;
         validate3.schemaEnv = sch;
         if (sch.$async)
           validate3.$async = true;
         if (this.opts.code.source === true) {
-          validate3.source = { validateName: validateName3, validateCode, scopeValues: gen._values };
+          validate3.source = { validateName: validateName4, validateCode, scopeValues: gen._values };
         }
         if (this.opts.unevaluated) {
           const { props, items } = schemaCxt;
@@ -183485,7 +183485,7 @@ var require_ref2 = __commonJS({
       schemaType: "string",
       code(cxt) {
         const { gen, schema: $ref, it: it3 } = cxt;
-        const { baseId, schemaEnv: env5, validateName: validateName3, opts, self: self2 } = it3;
+        const { baseId, schemaEnv: env5, validateName: validateName4, opts, self: self2 } = it3;
         const { root: root6 } = env5;
         if (($ref === "#" || $ref === "#/") && baseId === root6.baseId)
           return callRootRef();
@@ -183497,7 +183497,7 @@ var require_ref2 = __commonJS({
         return inlineRefSchema(schOrEnv);
         function callRootRef() {
           if (env5 === root6)
-            return callRef(cxt, validateName3, env5, env5.$async);
+            return callRef(cxt, validateName4, env5, env5.$async);
           const rootName = gen.scopeValue("root", { ref: root6 });
           return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root6, root6.$async);
         }
@@ -200171,6 +200171,19 @@ var init_Source5 = __esm({
 });
 
 // ../../commons/api-workspace-commons/lib/Spec.js
+function groupGraphQLSpecsByNamespace(specs) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const spec of specs) {
+    const key2 = spec.namespace ?? "";
+    const existing = grouped.get(key2);
+    if (existing != null) {
+      existing.push(spec);
+    } else {
+      grouped.set(key2, [spec]);
+    }
+  }
+  return grouped;
+}
 var init_Spec = __esm({
   "../../commons/api-workspace-commons/lib/Spec.js"() {
     "use strict";
@@ -235999,6 +236012,48 @@ async function getDefaultRemote({ repoRoot, context: context3 }) {
   const remotes = result.stdout.split("\n").map((line) => line.trim());
   return remotes.includes("origin") ? "origin" : remotes[0];
 }
+async function worktreeContainsGitLfsPointers({ worktreePath, ref: ref2, sha, context: context3 }) {
+  const result = await runGit({
+    args: ["grep", "-l", "-I", "-e", "^version https://git-lfs.github.com/spec/v1$", "--", "."],
+    cwd: worktreePath,
+    context: context3
+  });
+  if (result.exitCode === 0) {
+    return true;
+  }
+  if (result.exitCode === 1) {
+    return false;
+  }
+  throw new CliError({
+    message: `Failed to inspect git ref '${ref2}' (${sha}) for Git LFS pointers: ${result.stderr || result.stdout}`,
+    code: CliError.Code.ConfigError
+  });
+}
+async function materializeGitLfsFiles({ worktreePath, ref: ref2, sha, context: context3 }) {
+  if (!await worktreeContainsGitLfsPointers({ worktreePath, ref: ref2, sha, context: context3 })) {
+    return;
+  }
+  const remote = await getDefaultRemote({ repoRoot: worktreePath, context: context3 });
+  const pullResult = await runGit({
+    args: remote != null ? ["lfs", "pull", "--include=*", "--exclude=", remote] : ["lfs", "checkout"],
+    cwd: worktreePath,
+    context: context3
+  });
+  if (pullResult.exitCode !== 0) {
+    const output2 = pullResult.stderr || pullResult.stdout;
+    const gitLfsUnavailable = output2.includes("'lfs' is not a git command");
+    throw new CliError({
+      message: gitLfsUnavailable ? `Git LFS is required to materialize files for git ref '${ref2}' (${sha}). Install Git LFS and retry.` : `Failed to materialize Git LFS files for git ref '${ref2}' (${sha}): ${output2}`,
+      code: CliError.Code.ConfigError
+    });
+  }
+  if (await worktreeContainsGitLfsPointers({ worktreePath, ref: ref2, sha, context: context3 })) {
+    throw new CliError({
+      message: `Git LFS files for git ref '${ref2}' (${sha}) could not be materialized. Ensure the required LFS objects are available from the configured git remote.`,
+      code: CliError.Code.ConfigError
+    });
+  }
+}
 async function tryResolveSha({ repoRoot, ref: ref2, context: context3 }) {
   const result = await runGit({
     // `--end-of-options` terminates option parsing so a ref beginning with `-` cannot be read as
@@ -236114,6 +236169,7 @@ async function materializeGitRef({ ref: ref2, absolutePathToFernFolder, context:
       code: CliError.Code.ConfigError
     });
   }
+  await materializeGitLfsFiles({ worktreePath, ref: ref2, sha, context: context3 });
   const materialized = {
     ref: ref2,
     sha,
@@ -365704,6 +365760,9 @@ function getNullableType(type7) {
     return isNonNullType(type7) ? type7.ofType : type7;
   }
 }
+function isNamedType(type7) {
+  return isScalarType(type7) || isObjectType(type7) || isInterfaceType(type7) || isUnionType(type7) || isEnumType(type7) || isInputObjectType(type7);
+}
 function getNamedType(type7) {
   if (type7) {
     let unwrappedType = type7;
@@ -366268,6 +366327,18 @@ var init_definition = __esm({
 });
 
 // ../../../node_modules/.pnpm/graphql@16.13.2/node_modules/graphql/utilities/typeComparators.mjs
+function isEqualType(typeA, typeB) {
+  if (typeA === typeB) {
+    return true;
+  }
+  if (isNonNullType(typeA) && isNonNullType(typeB)) {
+    return isEqualType(typeA.ofType, typeB.ofType);
+  }
+  if (isListType2(typeA) && isListType2(typeB)) {
+    return isEqualType(typeA.ofType, typeB.ofType);
+  }
+  return false;
+}
 function isTypeSubTypeOf(schema, maybeSubType, superType) {
   if (maybeSubType === superType) {
     return true;
@@ -367312,6 +367383,15 @@ var init_introspection = __esm({
 });
 
 // ../../../node_modules/.pnpm/graphql@16.13.2/node_modules/graphql/type/schema.mjs
+function isSchema(schema) {
+  return instanceOf(schema, GraphQLSchema);
+}
+function assertSchema(schema) {
+  if (!isSchema(schema)) {
+    throw new Error(`Expected ${inspect4(schema)} to be a GraphQL schema.`);
+  }
+  return schema;
+}
 function collectReferencedTypes(type7, typeSet) {
   const namedType = getNamedType(type7);
   if (!typeSet.has(namedType)) {
@@ -367344,6 +367424,7 @@ var init_schema2 = __esm({
     "use strict";
     init_devAssert();
     init_inspect();
+    init_instanceOf();
     init_isObjectLike2();
     init_toObjMap();
     init_ast2();
@@ -367526,6 +367607,464 @@ var init_schema2 = __esm({
   }
 });
 
+// ../../../node_modules/.pnpm/graphql@16.13.2/node_modules/graphql/type/validate.mjs
+function validateSchema2(schema) {
+  assertSchema(schema);
+  if (schema.__validationErrors) {
+    return schema.__validationErrors;
+  }
+  const context3 = new SchemaValidationContext(schema);
+  validateRootTypes(context3);
+  validateDirectives(context3);
+  validateTypes(context3);
+  const errors4 = context3.getErrors();
+  schema.__validationErrors = errors4;
+  return errors4;
+}
+function validateRootTypes(context3) {
+  const schema = context3.schema;
+  const queryType = schema.getQueryType();
+  if (!queryType) {
+    context3.reportError("Query root type must be provided.", schema.astNode);
+  } else if (!isObjectType(queryType)) {
+    var _getOperationTypeNode;
+    context3.reportError(
+      `Query root type must be Object type, it cannot be ${inspect4(
+        queryType
+      )}.`,
+      (_getOperationTypeNode = getOperationTypeNode(
+        schema,
+        OperationTypeNode.QUERY
+      )) !== null && _getOperationTypeNode !== void 0 ? _getOperationTypeNode : queryType.astNode
+    );
+  }
+  const mutationType = schema.getMutationType();
+  if (mutationType && !isObjectType(mutationType)) {
+    var _getOperationTypeNode2;
+    context3.reportError(
+      `Mutation root type must be Object type if provided, it cannot be ${inspect4(mutationType)}.`,
+      (_getOperationTypeNode2 = getOperationTypeNode(
+        schema,
+        OperationTypeNode.MUTATION
+      )) !== null && _getOperationTypeNode2 !== void 0 ? _getOperationTypeNode2 : mutationType.astNode
+    );
+  }
+  const subscriptionType = schema.getSubscriptionType();
+  if (subscriptionType && !isObjectType(subscriptionType)) {
+    var _getOperationTypeNode3;
+    context3.reportError(
+      `Subscription root type must be Object type if provided, it cannot be ${inspect4(subscriptionType)}.`,
+      (_getOperationTypeNode3 = getOperationTypeNode(
+        schema,
+        OperationTypeNode.SUBSCRIPTION
+      )) !== null && _getOperationTypeNode3 !== void 0 ? _getOperationTypeNode3 : subscriptionType.astNode
+    );
+  }
+}
+function getOperationTypeNode(schema, operation) {
+  var _flatMap$find;
+  return (_flatMap$find = [schema.astNode, ...schema.extensionASTNodes].flatMap(
+    // FIXME: https://github.com/graphql/graphql-js/issues/2203
+    (schemaNode) => {
+      var _schemaNode$operation;
+      return (
+        /* c8 ignore next */
+        (_schemaNode$operation = schemaNode === null || schemaNode === void 0 ? void 0 : schemaNode.operationTypes) !== null && _schemaNode$operation !== void 0 ? _schemaNode$operation : []
+      );
+    }
+  ).find((operationNode) => operationNode.operation === operation)) === null || _flatMap$find === void 0 ? void 0 : _flatMap$find.type;
+}
+function validateDirectives(context3) {
+  for (const directive of context3.schema.getDirectives()) {
+    if (!isDirective(directive)) {
+      context3.reportError(
+        `Expected directive but got: ${inspect4(directive)}.`,
+        directive === null || directive === void 0 ? void 0 : directive.astNode
+      );
+      continue;
+    }
+    validateName3(context3, directive);
+    if (directive.locations.length === 0) {
+      context3.reportError(
+        `Directive @${directive.name} must include 1 or more locations.`,
+        directive.astNode
+      );
+    }
+    for (const arg of directive.args) {
+      validateName3(context3, arg);
+      if (!isInputType(arg.type)) {
+        context3.reportError(
+          `The type of @${directive.name}(${arg.name}:) must be Input Type but got: ${inspect4(arg.type)}.`,
+          arg.astNode
+        );
+      }
+      if (isRequiredArgument(arg) && arg.deprecationReason != null) {
+        var _arg$astNode;
+        context3.reportError(
+          `Required argument @${directive.name}(${arg.name}:) cannot be deprecated.`,
+          [
+            getDeprecatedDirectiveNode(arg.astNode),
+            (_arg$astNode = arg.astNode) === null || _arg$astNode === void 0 ? void 0 : _arg$astNode.type
+          ]
+        );
+      }
+    }
+  }
+}
+function validateName3(context3, node4) {
+  if (node4.name.startsWith("__")) {
+    context3.reportError(
+      `Name "${node4.name}" must not begin with "__", which is reserved by GraphQL introspection.`,
+      node4.astNode
+    );
+  }
+}
+function validateTypes(context3) {
+  const validateInputObjectCircularRefs = createInputObjectCircularRefsValidator(context3);
+  const typeMap = context3.schema.getTypeMap();
+  for (const type7 of Object.values(typeMap)) {
+    if (!isNamedType(type7)) {
+      context3.reportError(
+        `Expected GraphQL named type but got: ${inspect4(type7)}.`,
+        type7.astNode
+      );
+      continue;
+    }
+    if (!isIntrospectionType(type7)) {
+      validateName3(context3, type7);
+    }
+    if (isObjectType(type7)) {
+      validateFields(context3, type7);
+      validateInterfaces(context3, type7);
+    } else if (isInterfaceType(type7)) {
+      validateFields(context3, type7);
+      validateInterfaces(context3, type7);
+    } else if (isUnionType(type7)) {
+      validateUnionMembers(context3, type7);
+    } else if (isEnumType(type7)) {
+      validateEnumValues(context3, type7);
+    } else if (isInputObjectType(type7)) {
+      validateInputFields(context3, type7);
+      validateInputObjectCircularRefs(type7);
+    }
+  }
+}
+function validateFields(context3, type7) {
+  const fields = Object.values(type7.getFields());
+  if (fields.length === 0) {
+    context3.reportError(`Type ${type7.name} must define one or more fields.`, [
+      type7.astNode,
+      ...type7.extensionASTNodes
+    ]);
+  }
+  for (const field5 of fields) {
+    validateName3(context3, field5);
+    if (!isOutputType(field5.type)) {
+      var _field$astNode;
+      context3.reportError(
+        `The type of ${type7.name}.${field5.name} must be Output Type but got: ${inspect4(field5.type)}.`,
+        (_field$astNode = field5.astNode) === null || _field$astNode === void 0 ? void 0 : _field$astNode.type
+      );
+    }
+    for (const arg of field5.args) {
+      const argName = arg.name;
+      validateName3(context3, arg);
+      if (!isInputType(arg.type)) {
+        var _arg$astNode2;
+        context3.reportError(
+          `The type of ${type7.name}.${field5.name}(${argName}:) must be Input Type but got: ${inspect4(arg.type)}.`,
+          (_arg$astNode2 = arg.astNode) === null || _arg$astNode2 === void 0 ? void 0 : _arg$astNode2.type
+        );
+      }
+      if (isRequiredArgument(arg) && arg.deprecationReason != null) {
+        var _arg$astNode3;
+        context3.reportError(
+          `Required argument ${type7.name}.${field5.name}(${argName}:) cannot be deprecated.`,
+          [
+            getDeprecatedDirectiveNode(arg.astNode),
+            (_arg$astNode3 = arg.astNode) === null || _arg$astNode3 === void 0 ? void 0 : _arg$astNode3.type
+          ]
+        );
+      }
+    }
+  }
+}
+function validateInterfaces(context3, type7) {
+  const ifaceTypeNames = /* @__PURE__ */ Object.create(null);
+  for (const iface of type7.getInterfaces()) {
+    if (!isInterfaceType(iface)) {
+      context3.reportError(
+        `Type ${inspect4(type7)} must only implement Interface types, it cannot implement ${inspect4(iface)}.`,
+        getAllImplementsInterfaceNodes(type7, iface)
+      );
+      continue;
+    }
+    if (type7 === iface) {
+      context3.reportError(
+        `Type ${type7.name} cannot implement itself because it would create a circular reference.`,
+        getAllImplementsInterfaceNodes(type7, iface)
+      );
+      continue;
+    }
+    if (ifaceTypeNames[iface.name]) {
+      context3.reportError(
+        `Type ${type7.name} can only implement ${iface.name} once.`,
+        getAllImplementsInterfaceNodes(type7, iface)
+      );
+      continue;
+    }
+    ifaceTypeNames[iface.name] = true;
+    validateTypeImplementsAncestors(context3, type7, iface);
+    validateTypeImplementsInterface(context3, type7, iface);
+  }
+}
+function validateTypeImplementsInterface(context3, type7, iface) {
+  const typeFieldMap = type7.getFields();
+  for (const ifaceField of Object.values(iface.getFields())) {
+    const fieldName = ifaceField.name;
+    const typeField = typeFieldMap[fieldName];
+    if (!typeField) {
+      context3.reportError(
+        `Interface field ${iface.name}.${fieldName} expected but ${type7.name} does not provide it.`,
+        [ifaceField.astNode, type7.astNode, ...type7.extensionASTNodes]
+      );
+      continue;
+    }
+    if (!isTypeSubTypeOf(context3.schema, typeField.type, ifaceField.type)) {
+      var _ifaceField$astNode, _typeField$astNode;
+      context3.reportError(
+        `Interface field ${iface.name}.${fieldName} expects type ${inspect4(ifaceField.type)} but ${type7.name}.${fieldName} is type ${inspect4(typeField.type)}.`,
+        [
+          (_ifaceField$astNode = ifaceField.astNode) === null || _ifaceField$astNode === void 0 ? void 0 : _ifaceField$astNode.type,
+          (_typeField$astNode = typeField.astNode) === null || _typeField$astNode === void 0 ? void 0 : _typeField$astNode.type
+        ]
+      );
+    }
+    for (const ifaceArg of ifaceField.args) {
+      const argName = ifaceArg.name;
+      const typeArg = typeField.args.find((arg) => arg.name === argName);
+      if (!typeArg) {
+        context3.reportError(
+          `Interface field argument ${iface.name}.${fieldName}(${argName}:) expected but ${type7.name}.${fieldName} does not provide it.`,
+          [ifaceArg.astNode, typeField.astNode]
+        );
+        continue;
+      }
+      if (!isEqualType(ifaceArg.type, typeArg.type)) {
+        var _ifaceArg$astNode, _typeArg$astNode;
+        context3.reportError(
+          `Interface field argument ${iface.name}.${fieldName}(${argName}:) expects type ${inspect4(ifaceArg.type)} but ${type7.name}.${fieldName}(${argName}:) is type ${inspect4(typeArg.type)}.`,
+          [
+            (_ifaceArg$astNode = ifaceArg.astNode) === null || _ifaceArg$astNode === void 0 ? void 0 : _ifaceArg$astNode.type,
+            (_typeArg$astNode = typeArg.astNode) === null || _typeArg$astNode === void 0 ? void 0 : _typeArg$astNode.type
+          ]
+        );
+      }
+    }
+    for (const typeArg of typeField.args) {
+      const argName = typeArg.name;
+      const ifaceArg = ifaceField.args.find((arg) => arg.name === argName);
+      if (!ifaceArg && isRequiredArgument(typeArg)) {
+        context3.reportError(
+          `Object field ${type7.name}.${fieldName} includes required argument ${argName} that is missing from the Interface field ${iface.name}.${fieldName}.`,
+          [typeArg.astNode, ifaceField.astNode]
+        );
+      }
+    }
+  }
+}
+function validateTypeImplementsAncestors(context3, type7, iface) {
+  const ifaceInterfaces = type7.getInterfaces();
+  for (const transitive of iface.getInterfaces()) {
+    if (!ifaceInterfaces.includes(transitive)) {
+      context3.reportError(
+        transitive === type7 ? `Type ${type7.name} cannot implement ${iface.name} because it would create a circular reference.` : `Type ${type7.name} must implement ${transitive.name} because it is implemented by ${iface.name}.`,
+        [
+          ...getAllImplementsInterfaceNodes(iface, transitive),
+          ...getAllImplementsInterfaceNodes(type7, iface)
+        ]
+      );
+    }
+  }
+}
+function validateUnionMembers(context3, union23) {
+  const memberTypes = union23.getTypes();
+  if (memberTypes.length === 0) {
+    context3.reportError(
+      `Union type ${union23.name} must define one or more member types.`,
+      [union23.astNode, ...union23.extensionASTNodes]
+    );
+  }
+  const includedTypeNames = /* @__PURE__ */ Object.create(null);
+  for (const memberType of memberTypes) {
+    if (includedTypeNames[memberType.name]) {
+      context3.reportError(
+        `Union type ${union23.name} can only include type ${memberType.name} once.`,
+        getUnionMemberTypeNodes(union23, memberType.name)
+      );
+      continue;
+    }
+    includedTypeNames[memberType.name] = true;
+    if (!isObjectType(memberType)) {
+      context3.reportError(
+        `Union type ${union23.name} can only include Object types, it cannot include ${inspect4(memberType)}.`,
+        getUnionMemberTypeNodes(union23, String(memberType))
+      );
+    }
+  }
+}
+function validateEnumValues(context3, enumType2) {
+  const enumValues = enumType2.getValues();
+  if (enumValues.length === 0) {
+    context3.reportError(
+      `Enum type ${enumType2.name} must define one or more values.`,
+      [enumType2.astNode, ...enumType2.extensionASTNodes]
+    );
+  }
+  for (const enumValue of enumValues) {
+    validateName3(context3, enumValue);
+  }
+}
+function validateInputFields(context3, inputObj) {
+  const fields = Object.values(inputObj.getFields());
+  if (fields.length === 0) {
+    context3.reportError(
+      `Input Object type ${inputObj.name} must define one or more fields.`,
+      [inputObj.astNode, ...inputObj.extensionASTNodes]
+    );
+  }
+  for (const field5 of fields) {
+    validateName3(context3, field5);
+    if (!isInputType(field5.type)) {
+      var _field$astNode2;
+      context3.reportError(
+        `The type of ${inputObj.name}.${field5.name} must be Input Type but got: ${inspect4(field5.type)}.`,
+        (_field$astNode2 = field5.astNode) === null || _field$astNode2 === void 0 ? void 0 : _field$astNode2.type
+      );
+    }
+    if (isRequiredInputField(field5) && field5.deprecationReason != null) {
+      var _field$astNode3;
+      context3.reportError(
+        `Required input field ${inputObj.name}.${field5.name} cannot be deprecated.`,
+        [
+          getDeprecatedDirectiveNode(field5.astNode),
+          (_field$astNode3 = field5.astNode) === null || _field$astNode3 === void 0 ? void 0 : _field$astNode3.type
+        ]
+      );
+    }
+    if (inputObj.isOneOf) {
+      validateOneOfInputObjectField(inputObj, field5, context3);
+    }
+  }
+}
+function validateOneOfInputObjectField(type7, field5, context3) {
+  if (isNonNullType(field5.type)) {
+    var _field$astNode4;
+    context3.reportError(
+      `OneOf input field ${type7.name}.${field5.name} must be nullable.`,
+      (_field$astNode4 = field5.astNode) === null || _field$astNode4 === void 0 ? void 0 : _field$astNode4.type
+    );
+  }
+  if (field5.defaultValue !== void 0) {
+    context3.reportError(
+      `OneOf input field ${type7.name}.${field5.name} cannot have a default value.`,
+      field5.astNode
+    );
+  }
+}
+function createInputObjectCircularRefsValidator(context3) {
+  const visitedTypes = /* @__PURE__ */ Object.create(null);
+  const fieldPath = [];
+  const fieldPathIndexByTypeName = /* @__PURE__ */ Object.create(null);
+  return detectCycleRecursive;
+  function detectCycleRecursive(inputObj) {
+    if (visitedTypes[inputObj.name]) {
+      return;
+    }
+    visitedTypes[inputObj.name] = true;
+    fieldPathIndexByTypeName[inputObj.name] = fieldPath.length;
+    const fields = Object.values(inputObj.getFields());
+    for (const field5 of fields) {
+      if (isNonNullType(field5.type) && isInputObjectType(field5.type.ofType)) {
+        const fieldType = field5.type.ofType;
+        const cycleIndex = fieldPathIndexByTypeName[fieldType.name];
+        fieldPath.push(field5);
+        if (cycleIndex === void 0) {
+          detectCycleRecursive(fieldType);
+        } else {
+          const cyclePath = fieldPath.slice(cycleIndex);
+          const pathStr = cyclePath.map((fieldObj) => fieldObj.name).join(".");
+          context3.reportError(
+            `Cannot reference Input Object "${fieldType.name}" within itself through a series of non-null fields: "${pathStr}".`,
+            cyclePath.map((fieldObj) => fieldObj.astNode)
+          );
+        }
+        fieldPath.pop();
+      }
+    }
+    fieldPathIndexByTypeName[inputObj.name] = void 0;
+  }
+}
+function getAllImplementsInterfaceNodes(type7, iface) {
+  const { astNode, extensionASTNodes } = type7;
+  const nodes = astNode != null ? [astNode, ...extensionASTNodes] : extensionASTNodes;
+  return nodes.flatMap((typeNode) => {
+    var _typeNode$interfaces;
+    return (
+      /* c8 ignore next */
+      (_typeNode$interfaces = typeNode.interfaces) !== null && _typeNode$interfaces !== void 0 ? _typeNode$interfaces : []
+    );
+  }).filter((ifaceNode) => ifaceNode.name.value === iface.name);
+}
+function getUnionMemberTypeNodes(union23, typeName) {
+  const { astNode, extensionASTNodes } = union23;
+  const nodes = astNode != null ? [astNode, ...extensionASTNodes] : extensionASTNodes;
+  return nodes.flatMap((unionNode) => {
+    var _unionNode$types;
+    return (
+      /* c8 ignore next */
+      (_unionNode$types = unionNode.types) !== null && _unionNode$types !== void 0 ? _unionNode$types : []
+    );
+  }).filter((typeNode) => typeNode.name.value === typeName);
+}
+function getDeprecatedDirectiveNode(definitionNode) {
+  var _definitionNode$direc;
+  return definitionNode === null || definitionNode === void 0 ? void 0 : (_definitionNode$direc = definitionNode.directives) === null || _definitionNode$direc === void 0 ? void 0 : _definitionNode$direc.find(
+    (node4) => node4.name.value === GraphQLDeprecatedDirective.name
+  );
+}
+var SchemaValidationContext;
+var init_validate2 = __esm({
+  "../../../node_modules/.pnpm/graphql@16.13.2/node_modules/graphql/type/validate.mjs"() {
+    "use strict";
+    init_inspect();
+    init_GraphQLError();
+    init_ast2();
+    init_typeComparators();
+    init_definition();
+    init_directives();
+    init_introspection();
+    init_schema2();
+    SchemaValidationContext = class {
+      constructor(schema) {
+        this._errors = [];
+        this.schema = schema;
+      }
+      reportError(message, nodes) {
+        const _nodes = Array.isArray(nodes) ? nodes.filter(Boolean) : nodes;
+        this._errors.push(
+          new GraphQLError(message, {
+            nodes: _nodes
+          })
+        );
+      }
+      getErrors() {
+        return this._errors;
+      }
+    };
+  }
+});
+
 // ../../../node_modules/.pnpm/graphql@16.13.2/node_modules/graphql/utilities/typeFromAST.mjs
 function typeFromAST(schema, typeNode) {
   switch (typeNode.kind) {
@@ -370613,7 +371152,7 @@ function assertValidSDL(documentAST) {
   }
 }
 var QueryDocumentKeysToValidate;
-var init_validate2 = __esm({
+var init_validate3 = __esm({
   "../../../node_modules/.pnpm/graphql@16.13.2/node_modules/graphql/validation/validate.mjs"() {
     "use strict";
     init_mapValue();
@@ -370633,6 +371172,18 @@ var init_type3 = __esm({
   "../../../node_modules/.pnpm/graphql@16.13.2/node_modules/graphql/type/index.mjs"() {
     "use strict";
     init_definition();
+    init_directives();
+    init_validate2();
+  }
+});
+
+// ../../../node_modules/.pnpm/graphql@16.13.2/node_modules/graphql/language/index.mjs
+var init_language = __esm({
+  "../../../node_modules/.pnpm/graphql@16.13.2/node_modules/graphql/language/index.mjs"() {
+    "use strict";
+    init_kinds();
+    init_parser();
+    init_printer();
   }
 });
 
@@ -371541,25 +372092,14 @@ function buildASTSchema(documentAST, options2) {
   ];
   return new GraphQLSchema({ ...config5, directives });
 }
-function buildSchema(source2, options2) {
-  const document4 = parse9(source2, {
-    noLocation: options2 === null || options2 === void 0 ? void 0 : options2.noLocation,
-    allowLegacyFragmentVariables: options2 === null || options2 === void 0 ? void 0 : options2.allowLegacyFragmentVariables
-  });
-  return buildASTSchema(document4, {
-    assumeValidSDL: options2 === null || options2 === void 0 ? void 0 : options2.assumeValidSDL,
-    assumeValid: options2 === null || options2 === void 0 ? void 0 : options2.assumeValid
-  });
-}
 var init_buildASTSchema = __esm({
   "../../../node_modules/.pnpm/graphql@16.13.2/node_modules/graphql/utilities/buildASTSchema.mjs"() {
     "use strict";
     init_devAssert();
     init_kinds();
-    init_parser();
     init_directives();
     init_schema2();
-    init_validate2();
+    init_validate3();
     init_extendSchema();
   }
 });
@@ -371770,10 +372310,445 @@ var init_graphql = __esm({
   "../../../node_modules/.pnpm/graphql@16.13.2/node_modules/graphql/index.mjs"() {
     "use strict";
     init_type3();
+    init_language();
     init_utilities2();
   }
 });
 
+// ../api-importers/graphql/lib/mergeGraphQlDocuments.js
+function mergeGraphQlDocuments(sources) {
+  const conflicts2 = [];
+  const types4 = /* @__PURE__ */ new Map();
+  const directiveDefinitions = /* @__PURE__ */ new Map();
+  const operationTypes = /* @__PURE__ */ new Map();
+  const otherDefinitions = [];
+  const inaccessible = { types: /* @__PURE__ */ new Set(), seen: false };
+  for (const source2 of sources) {
+    for (const definition3 of parseSource(source2).definitions) {
+      if (definition3.kind === Kind.DIRECTIVE_DEFINITION) {
+        const directiveName = definition3.name.value;
+        if (FEDERATION_DIRECTIVES.has(directiveName)) {
+          continue;
+        }
+        const owner = directiveDefinitions.get(directiveName);
+        if (owner == null) {
+          directiveDefinitions.set(directiveName, { definition: definition3, filePath: source2.filePath });
+        } else if (print(owner.definition) !== print(definition3)) {
+          conflicts2.push({
+            typeName: `@${directiveName}`,
+            memberName: "<declaration>",
+            kept: owner.filePath,
+            dropped: source2.filePath
+          });
+        }
+        continue;
+      }
+      if (definition3.kind === Kind.SCHEMA_DEFINITION || definition3.kind === Kind.SCHEMA_EXTENSION) {
+        for (const operationType of definition3.operationTypes ?? []) {
+          const owner = operationTypes.get(operationType.operation);
+          if (owner == null) {
+            operationTypes.set(operationType.operation, { operationType, filePath: source2.filePath });
+          } else if (owner.operationType.type.name.value !== operationType.type.name.value) {
+            conflicts2.push({
+              typeName: "schema",
+              memberName: operationType.operation,
+              kept: owner.filePath,
+              dropped: source2.filePath
+            });
+          }
+        }
+        continue;
+      }
+      if (isTypeExtension(definition3)) {
+        mergeTypeDefinition({
+          incoming: typeExtensionToDefinition(definition3),
+          isExtension: true,
+          filePath: source2.filePath,
+          types: types4,
+          conflicts: conflicts2,
+          inaccessible
+        });
+        continue;
+      }
+      if (isTypeDefinition(definition3)) {
+        mergeTypeDefinition({
+          incoming: definition3,
+          isExtension: false,
+          filePath: source2.filePath,
+          types: types4,
+          conflicts: conflicts2,
+          inaccessible
+        });
+        continue;
+      }
+      if (definition3.kind === Kind.OPERATION_DEFINITION || definition3.kind === Kind.FRAGMENT_DEFINITION) {
+        continue;
+      }
+      otherDefinitions.push(definition3);
+    }
+  }
+  if (inaccessible.seen) {
+    const queryRootName = queryRootTypeName(operationTypes, types4);
+    pruneInaccessibleTypes(types4, inaccessible.types);
+    pruneUnsatisfiedInterfaces(types4);
+    if (queryRootName != null && !types4.has(queryRootName)) {
+      throw new Error(`Every field on the GraphQL query root "${queryRootName}" returns a type marked @inaccessible (${[...inaccessible.types].sort().join(", ")}), so the merged schema has no reachable operations. Remove @inaccessible from at least one reachable type, or exclude these files from the docs.`);
+    }
+  }
+  const definitions7 = [
+    ...[...directiveDefinitions.values()].map((entry) => entry.definition),
+    ...otherDefinitions,
+    ...[...types4.values()].map((type7) => type7.definition)
+  ];
+  const rootOperationTypes = [...operationTypes.values()].map((entry) => entry.operationType).filter((operationType) => types4.has(operationType.type.name.value));
+  if (rootOperationTypes.length > 0) {
+    definitions7.push({ kind: Kind.SCHEMA_DEFINITION, operationTypes: rootOperationTypes });
+  }
+  return { document: { kind: Kind.DOCUMENT, definitions: definitions7 }, conflicts: conflicts2 };
+}
+function queryRootTypeName(operationTypes, types4) {
+  const declared = operationTypes.get("query")?.operationType.type.name.value;
+  if (declared != null) {
+    return types4.has(declared) ? declared : void 0;
+  }
+  return types4.has("Query") ? "Query" : void 0;
+}
+function parseSource(source2) {
+  try {
+    return parse9(source2.sdl);
+  } catch (error50) {
+    throw new Error(`${source2.filePath}: ${error50 instanceof Error ? error50.message : String(error50)}`);
+  }
+}
+function isTypeDefinition(definition3) {
+  return definition3.kind === Kind.SCALAR_TYPE_DEFINITION || definition3.kind === Kind.OBJECT_TYPE_DEFINITION || definition3.kind === Kind.INTERFACE_TYPE_DEFINITION || definition3.kind === Kind.UNION_TYPE_DEFINITION || definition3.kind === Kind.ENUM_TYPE_DEFINITION || definition3.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION;
+}
+function isTypeExtension(definition3) {
+  return definition3.kind === Kind.SCALAR_TYPE_EXTENSION || definition3.kind === Kind.OBJECT_TYPE_EXTENSION || definition3.kind === Kind.INTERFACE_TYPE_EXTENSION || definition3.kind === Kind.UNION_TYPE_EXTENSION || definition3.kind === Kind.ENUM_TYPE_EXTENSION || definition3.kind === Kind.INPUT_OBJECT_TYPE_EXTENSION;
+}
+function typeExtensionToDefinition(extension4) {
+  switch (extension4.kind) {
+    case Kind.SCALAR_TYPE_EXTENSION:
+      return { ...extension4, kind: Kind.SCALAR_TYPE_DEFINITION, description: void 0 };
+    case Kind.OBJECT_TYPE_EXTENSION:
+      return { ...extension4, kind: Kind.OBJECT_TYPE_DEFINITION, description: void 0 };
+    case Kind.INTERFACE_TYPE_EXTENSION:
+      return { ...extension4, kind: Kind.INTERFACE_TYPE_DEFINITION, description: void 0 };
+    case Kind.UNION_TYPE_EXTENSION:
+      return { ...extension4, kind: Kind.UNION_TYPE_DEFINITION, description: void 0 };
+    case Kind.ENUM_TYPE_EXTENSION:
+      return { ...extension4, kind: Kind.ENUM_TYPE_DEFINITION, description: void 0 };
+    case Kind.INPUT_OBJECT_TYPE_EXTENSION:
+      return { ...extension4, kind: Kind.INPUT_OBJECT_TYPE_DEFINITION, description: void 0 };
+  }
+}
+function stripFederationDirectives(directives) {
+  if (directives == null) {
+    return void 0;
+  }
+  return directives.filter((directive) => !FEDERATION_DIRECTIVES.has(directive.name.value));
+}
+function isInaccessible(node4) {
+  return node4.directives?.some((directive) => directive.name.value === INACCESSIBLE_DIRECTIVE) ?? false;
+}
+function cleanArguments(args, inaccessible) {
+  return args?.filter(keepAccessible(inaccessible)).map((argument) => ({
+    ...argument,
+    directives: stripFederationDirectives(argument.directives)
+  }));
+}
+function keepAccessible(inaccessible) {
+  return (node4) => {
+    if (!isInaccessible(node4)) {
+      return true;
+    }
+    inaccessible.seen = true;
+    return false;
+  };
+}
+function cleanTypeDefinition(definition3, inaccessible) {
+  const directives = stripFederationDirectives(definition3.directives);
+  if (isInaccessible(definition3)) {
+    inaccessible.seen = true;
+    inaccessible.types.add(definition3.name.value);
+  }
+  const keep = keepAccessible(inaccessible);
+  switch (definition3.kind) {
+    case Kind.OBJECT_TYPE_DEFINITION:
+    case Kind.INTERFACE_TYPE_DEFINITION:
+      return {
+        ...definition3,
+        directives,
+        fields: definition3.fields?.filter(keep).map((field5) => ({
+          ...field5,
+          directives: stripFederationDirectives(field5.directives),
+          arguments: cleanArguments(field5.arguments, inaccessible)
+        }))
+      };
+    case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+      return {
+        ...definition3,
+        directives,
+        fields: definition3.fields?.filter(keep).map((field5) => ({
+          ...field5,
+          directives: stripFederationDirectives(field5.directives)
+        }))
+      };
+    case Kind.ENUM_TYPE_DEFINITION:
+      return {
+        ...definition3,
+        directives,
+        values: definition3.values?.filter(keep).map((value2) => ({
+          ...value2,
+          directives: stripFederationDirectives(value2.directives)
+        }))
+      };
+    case Kind.SCALAR_TYPE_DEFINITION:
+    case Kind.UNION_TYPE_DEFINITION:
+      return { ...definition3, directives };
+  }
+}
+function namedTypeName(type7) {
+  switch (type7.kind) {
+    case Kind.NAMED_TYPE:
+      return type7.name.value;
+    case Kind.LIST_TYPE:
+    case Kind.NON_NULL_TYPE:
+      return namedTypeName(type7.type);
+  }
+}
+function pruneInaccessibleTypes(types4, inaccessibleTypes) {
+  const removed = /* @__PURE__ */ new Set();
+  for (const typeName of inaccessibleTypes) {
+    if (types4.delete(typeName)) {
+      removed.add(typeName);
+    }
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [typeName, type7] of types4) {
+      const pruned = pruneReferences(type7.definition, removed);
+      if (pruned == null) {
+        types4.delete(typeName);
+        removed.add(typeName);
+        changed = true;
+        continue;
+      }
+      if (pruned !== type7.definition) {
+        type7.definition = pruned;
+        changed = true;
+      }
+    }
+  }
+}
+function fieldNamesOf(definition3) {
+  if (definition3.kind !== Kind.OBJECT_TYPE_DEFINITION && definition3.kind !== Kind.INTERFACE_TYPE_DEFINITION) {
+    return /* @__PURE__ */ new Set();
+  }
+  return new Set((definition3.fields ?? []).map((field5) => field5.name.value));
+}
+function pruneUnsatisfiedInterfaces(types4) {
+  for (const type7 of types4.values()) {
+    const definition3 = type7.definition;
+    if (definition3.kind !== Kind.OBJECT_TYPE_DEFINITION && definition3.kind !== Kind.INTERFACE_TYPE_DEFINITION) {
+      continue;
+    }
+    const declared = definition3.interfaces ?? [];
+    const ownFields = fieldNamesOf(definition3);
+    const interfaces = declared.filter((node4) => {
+      const implemented = types4.get(node4.name.value);
+      if (implemented == null) {
+        return false;
+      }
+      return [...fieldNamesOf(implemented.definition)].every((fieldName) => ownFields.has(fieldName));
+    });
+    if (interfaces.length !== declared.length) {
+      type7.definition = { ...definition3, interfaces };
+    }
+  }
+}
+function pruneReferences(definition3, removed) {
+  switch (definition3.kind) {
+    case Kind.OBJECT_TYPE_DEFINITION:
+    case Kind.INTERFACE_TYPE_DEFINITION: {
+      const fields = (definition3.fields ?? []).filter((field5) => !removed.has(namedTypeName(field5.type)) && !(field5.arguments ?? []).some((argument) => removed.has(namedTypeName(argument.type))));
+      if (fields.length === 0) {
+        return null;
+      }
+      const interfaces = (definition3.interfaces ?? []).filter((node4) => !removed.has(node4.name.value));
+      if (fields.length === definition3.fields?.length && interfaces.length === (definition3.interfaces ?? []).length) {
+        return definition3;
+      }
+      return { ...definition3, fields, interfaces };
+    }
+    case Kind.INPUT_OBJECT_TYPE_DEFINITION: {
+      const fields = (definition3.fields ?? []).filter((field5) => !removed.has(namedTypeName(field5.type)));
+      if (fields.length === 0) {
+        return null;
+      }
+      return fields.length === definition3.fields?.length ? definition3 : { ...definition3, fields };
+    }
+    case Kind.UNION_TYPE_DEFINITION: {
+      const members = (definition3.types ?? []).filter((node4) => !removed.has(node4.name.value));
+      if (members.length === 0) {
+        return null;
+      }
+      return members.length === definition3.types?.length ? definition3 : { ...definition3, types: members };
+    }
+    case Kind.ENUM_TYPE_DEFINITION:
+      return definition3.values?.length === 0 ? null : definition3;
+    case Kind.SCALAR_TYPE_DEFINITION:
+      return definition3;
+  }
+}
+function mergeTypeDefinition({ incoming, isExtension, filePath, types: types4, conflicts: conflicts2, inaccessible }) {
+  const name2 = incoming.name.value;
+  const cleaned = cleanTypeDefinition(incoming, inaccessible);
+  const existing = types4.get(name2);
+  if (existing == null) {
+    types4.set(name2, initMergedType(cleaned, filePath, isExtension));
+    return;
+  }
+  if (existing.definition.kind !== cleaned.kind) {
+    conflicts2.push({
+      typeName: name2,
+      memberName: "<declaration>",
+      kept: existing.filePath,
+      dropped: filePath
+    });
+    return;
+  }
+  if (existing.fromExtension && !isExtension) {
+    const promoted = initMergedType(cleaned, filePath, false);
+    promoted.definition = mergeMembers(promoted, existing.definition, existing.filePath, conflicts2);
+    types4.set(name2, promoted);
+    return;
+  }
+  existing.definition = mergeMembers(existing, cleaned, filePath, conflicts2);
+}
+function initMergedType(definition3, filePath, fromExtension) {
+  const members = /* @__PURE__ */ new Map();
+  for (const member of getMembers(definition3)) {
+    members.set(member.name.value, { filePath, signature: memberSignature(member) });
+  }
+  return { definition: definition3, filePath, members, fromExtension };
+}
+function getMembers(definition3) {
+  switch (definition3.kind) {
+    case Kind.OBJECT_TYPE_DEFINITION:
+    case Kind.INTERFACE_TYPE_DEFINITION:
+    case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+      return definition3.fields ?? [];
+    case Kind.ENUM_TYPE_DEFINITION:
+      return definition3.values ?? [];
+    case Kind.UNION_TYPE_DEFINITION:
+      return definition3.types ?? [];
+    case Kind.SCALAR_TYPE_DEFINITION:
+      return [];
+  }
+}
+function memberSignature(member) {
+  if (member.kind === Kind.FIELD_DEFINITION) {
+    const args = (member.arguments ?? []).map((argument) => `${argument.name.value}:${print(argument.type)}`);
+    return `${print(member.type)}(${args.join(",")})`;
+  }
+  if (member.kind === Kind.INPUT_VALUE_DEFINITION) {
+    return print(member.type);
+  }
+  return member.name.value;
+}
+function mergeMembers(existing, incoming, filePath, conflicts2) {
+  const base4 = existing.definition;
+  const description = base4.description ?? incoming.description;
+  const typeName = base4.name.value;
+  const dedupe = (current3, additional) => {
+    const merged = [...current3 ?? []];
+    for (const member of additional ?? []) {
+      const memberName = member.name.value;
+      const signature = memberSignature(member);
+      const owner = existing.members.get(memberName);
+      if (owner != null) {
+        if (owner.signature !== signature) {
+          conflicts2.push({ typeName, memberName, kept: owner.filePath, dropped: filePath });
+        }
+        continue;
+      }
+      existing.members.set(memberName, { filePath, signature });
+      merged.push(member);
+    }
+    return merged;
+  };
+  if (base4.kind === Kind.OBJECT_TYPE_DEFINITION && incoming.kind === Kind.OBJECT_TYPE_DEFINITION) {
+    return {
+      ...base4,
+      description,
+      interfaces: dedupeNamedTypes(base4.interfaces, incoming.interfaces),
+      fields: dedupe(base4.fields, incoming.fields)
+    };
+  }
+  if (base4.kind === Kind.INTERFACE_TYPE_DEFINITION && incoming.kind === Kind.INTERFACE_TYPE_DEFINITION) {
+    return {
+      ...base4,
+      description,
+      interfaces: dedupeNamedTypes(base4.interfaces, incoming.interfaces),
+      fields: dedupe(base4.fields, incoming.fields)
+    };
+  }
+  if (base4.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION && incoming.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION) {
+    return { ...base4, description, fields: dedupe(base4.fields, incoming.fields) };
+  }
+  if (base4.kind === Kind.ENUM_TYPE_DEFINITION && incoming.kind === Kind.ENUM_TYPE_DEFINITION) {
+    return { ...base4, description, values: dedupe(base4.values, incoming.values) };
+  }
+  if (base4.kind === Kind.UNION_TYPE_DEFINITION && incoming.kind === Kind.UNION_TYPE_DEFINITION) {
+    return { ...base4, description, types: dedupeNamedTypes(base4.types, incoming.types) };
+  }
+  return { ...base4, description };
+}
+function dedupeNamedTypes(current3, additional) {
+  const seen = new Set((current3 ?? []).map((type7) => type7.name.value));
+  const merged = [...current3 ?? []];
+  for (const type7 of additional ?? []) {
+    if (!seen.has(type7.name.value)) {
+      seen.add(type7.name.value);
+      merged.push(type7);
+    }
+  }
+  return merged;
+}
+var INACCESSIBLE_DIRECTIVE, FEDERATION_DIRECTIVES;
+var init_mergeGraphQlDocuments = __esm({
+  "../api-importers/graphql/lib/mergeGraphQlDocuments.js"() {
+    "use strict";
+    init_graphql();
+    INACCESSIBLE_DIRECTIVE = "inaccessible";
+    FEDERATION_DIRECTIVES = /* @__PURE__ */ new Set([
+      "link",
+      "key",
+      "external",
+      "requires",
+      "provides",
+      "shareable",
+      "inaccessible",
+      "override",
+      "extends",
+      "composeDirective",
+      "interfaceObject",
+      "tag",
+      "authenticated",
+      "requiresScopes",
+      "policy",
+      // federation v2.8
+      "context",
+      "fromContext",
+      // federation v2.9 (demand control)
+      "cost",
+      "listSize"
+    ]);
+  }
+});
+
 // ../api-importers/graphql/lib/GraphQLConverter.js
 var import_promises39, GraphQLConverter;
 var init_GraphQLConverter = __esm({
@@ -371782,17 +372757,18 @@ var init_GraphQLConverter = __esm({
     init_js();
     import_promises39 = require("fs/promises");
     init_graphql();
+    init_mergeGraphQlDocuments();
     GraphQLConverter = class {
       schema;
       context;
-      filePath;
+      filePaths;
       namespace;
       processingTypes = /* @__PURE__ */ new Set();
       types = {};
       examplesByOperation = /* @__PURE__ */ new Map();
       constructor({ context: context3, filePath, namespace, examples }) {
         this.context = context3;
-        this.filePath = filePath;
+        this.filePaths = Array.isArray(filePath) ? filePath : [filePath];
         this.namespace = namespace;
         if (examples != null) {
           for (const entry of examples) {
@@ -371803,15 +372779,32 @@ var init_GraphQLConverter = __esm({
               variables: ex.variables ?? void 0,
               response: ex.response ?? void 0
             }));
-            if (entry.operationType != null) {
-              const key2 = `${entry.operationType.toLowerCase()}:${entry.operation}`;
-              this.examplesByOperation.set(key2, mapped);
-            } else {
-              this.examplesByOperation.set(entry.operation, mapped);
+            const key2 = entry.operationType != null ? `${entry.operationType.toLowerCase()}:${entry.operation}` : entry.operation;
+            if (this.examplesByOperation.has(key2)) {
+              this.context.logger.warn(`Multiple GraphQL examples provided for "${key2}". Keeping the first and ignoring the rest.`);
+              continue;
             }
+            this.examplesByOperation.set(key2, mapped);
           }
         }
       }
+      // `@deprecated` is a standard, consumer-facing directive (unlike the federation directives
+      // dropped during merging), so it is carried through as availability metadata.
+      availabilityOf(node4) {
+        return node4.deprecationReason != null ? "Deprecated" : void 0;
+      }
+      // The deprecation reason has nowhere to live in the FDR shape other than the description,
+      // and it is the part consumers act on ("use X instead").
+      describeWithDeprecation(node4) {
+        const description = node4.description ?? void 0;
+        if (node4.deprecationReason == null || node4.deprecationReason === DEFAULT_DEPRECATION_REASON) {
+          return description;
+        }
+        const deprecation = `**Deprecated:** ${node4.deprecationReason}`;
+        return description != null ? `${description}
+
+${deprecation}` : deprecation;
+      }
       isBuiltInScalar(typeName) {
         return ["String", "Int", "Float", "Boolean", "ID"].includes(typeName);
       }
@@ -371844,9 +372837,42 @@ var init_GraphQLConverter = __esm({
         }
         return fields.every((f3) => f3.args.length > 0);
       }
+      /**
+       * Builds the merged document, reporting SDL problems instead of silently accepting them.
+       *
+       * `assumeValidSDL` is the fallback rather than the default: merged subgraphs can still carry
+       * constructs that only compose at runtime (e.g. a directive whose definition lives in the
+       * supergraph), and failing the docs build on those would make federation unusable.
+       */
+      buildSchema(document4) {
+        try {
+          const schema = buildASTSchema(document4);
+          for (const error50 of validateSchema2(schema)) {
+            this.context.logger.warn(`Invalid GraphQL schema: ${error50.message}`);
+          }
+          return schema;
+        } catch (validationError) {
+          let schema;
+          try {
+            schema = buildASTSchema(document4, { assumeValidSDL: true });
+          } catch {
+            throw validationError;
+          }
+          this.context.logger.warn(`Invalid GraphQL schema: ${validationError instanceof Error ? validationError.message : String(validationError)} Continuing without SDL validation.`);
+          return schema;
+        }
+      }
       async convert() {
-        const sdlContent = await (0, import_promises39.readFile)(this.filePath, "utf-8");
-        this.schema = buildSchema(sdlContent);
+        const sources = await Promise.all(this.filePaths.map(async (filePath) => ({
+          filePath,
+          sdl: await (0, import_promises39.readFile)(filePath, "utf-8")
+        })));
+        const { document: document4, conflicts: conflicts2 } = mergeGraphQlDocuments(sources);
+        for (const conflict of conflicts2) {
+          const member = `${conflict.typeName}.${conflict.memberName}`;
+          this.context.logger.warn(conflict.kept === conflict.dropped ? `GraphQL schema conflict: ${member} is declared more than once in ${conflict.kept} with differing shapes. Keeping the first declaration.` : `GraphQL schema conflict: ${member} is defined in both ${conflict.kept} and ${conflict.dropped}. Keeping the definition from ${conflict.kept}.`);
+        }
+        this.schema = this.buildSchema(document4);
         this.collectTypeDefinitions();
         const pendingOperations = [];
         const queryType = this.schema.getQueryType();
@@ -372040,8 +373066,8 @@ var init_GraphQLConverter = __esm({
           operationType,
           name: name2,
           displayName: void 0,
-          description: field5.description ?? void 0,
-          availability: void 0,
+          description: this.describeWithDeprecation(field5),
+          availability: this.availabilityOf(field5),
           fieldPath: fieldPath != null && fieldPath.length > 0 ? fieldPath : void 0,
           arguments: args.length > 0 ? args : void 0,
           returnType: this.convertOutputType(field5.type),
@@ -372052,8 +373078,8 @@ var init_GraphQLConverter = __esm({
       convertArgument(arg) {
         return {
           name: arg.name,
-          description: arg.description ?? void 0,
-          availability: void 0,
+          description: this.describeWithDeprecation(arg),
+          availability: this.availabilityOf(arg),
           type: this.convertInputType(arg.type),
           defaultValue: arg.defaultValue
         };
@@ -372223,8 +373249,8 @@ var init_GraphQLConverter = __esm({
           type: "enum",
           values: values2.map((value2) => ({
             value: value2.name,
-            description: value2.description ?? void 0,
-            availability: void 0
+            description: this.describeWithDeprecation(value2),
+            availability: this.availabilityOf(value2)
           })),
           default: void 0
         };
@@ -372234,8 +373260,8 @@ var init_GraphQLConverter = __esm({
         const properties7 = Object.entries(fields).map(([fieldName, field5]) => ({
           key: FdrAPI_exports.PropertyKey(fieldName),
           valueType: this.convertOutputType(field5.type),
-          description: field5.description ?? void 0,
-          availability: void 0,
+          description: this.describeWithDeprecation(field5),
+          availability: this.availabilityOf(field5),
           propertyAccess: void 0,
           arguments: field5.args.length > 0 ? field5.args.map((arg) => this.convertArgument(arg)) : void 0
         }));
@@ -372282,8 +373308,8 @@ var init_GraphQLConverter = __esm({
         const properties7 = Object.entries(fields).map(([fieldName, field5]) => ({
           key: FdrAPI_exports.PropertyKey(fieldName),
           valueType: this.convertOutputType(field5.type),
-          description: field5.description ?? void 0,
-          availability: void 0,
+          description: this.describeWithDeprecation(field5),
+          availability: this.availabilityOf(field5),
           propertyAccess: void 0,
           arguments: field5.args.length > 0 ? field5.args.map((arg) => this.convertArgument(arg)) : void 0
         }));
@@ -372299,8 +373325,8 @@ var init_GraphQLConverter = __esm({
         const properties7 = Object.entries(fields).map(([fieldName, field5]) => ({
           key: FdrAPI_exports.PropertyKey(fieldName),
           valueType: this.convertInputType(field5.type),
-          description: field5.description ?? void 0,
-          availability: void 0,
+          description: this.describeWithDeprecation(field5),
+          availability: this.availabilityOf(field5),
           propertyAccess: void 0
         }));
         return {
@@ -372687,20 +373713,21 @@ var init_OSSWorkspace = __esm({
       async processGraphQLSpecs(context3) {
         const { GraphQLConverter: GraphQLConverter2 } = await Promise.resolve().then(() => (init_lib34(), lib_exports9));
         const graphqlSpecs = this.allSpecs.filter((spec) => spec.type === "graphql");
-        for (const spec of graphqlSpecs) {
+        for (const [, specs] of groupGraphQLSpecsByNamespace(graphqlSpecs)) {
+          const filePaths = specs.map((spec) => spec.absoluteFilepath);
           try {
-            const examples = await loadGraphQlExamples(spec.absoluteFilepathToExamples, context3);
+            const examples = (await Promise.all(specs.map((spec) => loadGraphQlExamples(spec.absoluteFilepathToExamples, context3)))).filter(isNonNullish).flat();
             const converter = new GraphQLConverter2({
               context: context3,
-              filePath: spec.absoluteFilepath,
-              namespace: spec.namespace,
+              filePath: filePaths,
+              namespace: specs[0]?.namespace,
               examples
             });
             const result = await converter.convert();
             Object.assign(this.graphqlOperations, result.graphqlOperations);
             Object.assign(this.graphqlTypes, result.types);
           } catch (error50) {
-            context3.logger.error(`Failed to process GraphQL spec ${spec.absoluteFilepath}:`, extractErrorMessage(error50));
+            context3.logger.error(`Failed to process GraphQL spec(s) ${filePaths.join(", ")}:`, extractErrorMessage(error50));
           }
         }
       }
@@ -472773,6 +473800,7 @@ var import_dayjs3, import_utc3, import_fs26, import_promises80, import_gray_matt
 var init_DocsDefinitionResolver = __esm({
   "../docs-resolver/lib/DocsDefinitionResolver.js"() {
     "use strict";
+    init_lib17();
     init_lib36();
     init_lib20();
     init_lib4();
@@ -474195,25 +475223,27 @@ https://buildwithfern.com/learn/docs/getting-started/project-structure#api-defin
           return { operations: graphqlOperations, types: graphqlTypes, namespacesByOperationId };
         }
         const graphqlSpecs = workspace.allSpecs.filter((spec) => spec.type === "graphql");
-        for (const spec of graphqlSpecs) {
+        for (const [, specs] of groupGraphQLSpecsByNamespace(graphqlSpecs)) {
+          const filePaths = specs.map((spec) => spec.absoluteFilepath);
+          const namespace = specs[0]?.namespace;
           try {
-            const examples = await this.loadGraphQlExamples(spec.absoluteFilepathToExamples);
+            const examples = (await Promise.all(specs.map((spec) => this.loadGraphQlExamples(spec.absoluteFilepathToExamples)))).filter(isNonNullish).flat();
             const converter = new GraphQLConverter({
               context: this.taskContext,
-              filePath: spec.absoluteFilepath,
-              namespace: spec.namespace,
+              filePath: filePaths,
+              namespace,
               examples
             });
             const graphqlResult = await converter.convert();
             Object.assign(graphqlOperations, graphqlResult.graphqlOperations);
             Object.assign(graphqlTypes, graphqlResult.types);
-            if (spec.namespace) {
+            if (namespace) {
               for (const operationId of Object.keys(graphqlResult.graphqlOperations)) {
-                namespacesByOperationId.set(FdrAPI_exports.GraphQlOperationId(operationId), spec.namespace);
+                namespacesByOperationId.set(FdrAPI_exports.GraphQlOperationId(operationId), namespace);
               }
             }
           } catch (error50) {
-            this.taskContext.logger.error(`Failed to process GraphQL spec ${spec.absoluteFilepath}:`, String(error50));
+            this.taskContext.logger.error(`Failed to process GraphQL spec(s) ${filePaths.join(", ")}:`, extractErrorMessage(error50));
           }
         }
         return { operations: graphqlOperations, types: graphqlTypes, namespacesByOperationId };
@@ -703487,7 +704517,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "5.104.1",
+          version: "5.105.1",
           usingAccessToken: true,
           ...getRunIdProperties()
         }
@@ -703553,7 +704583,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "5.104.1",
+        version: "5.105.1",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -884936,7 +885966,7 @@ var LOCAL_STORAGE_FOLDER4 = ".fern-dev";
 var LOGS_FOLDER_NAME = "logs";
 var MAX_LOGS_DIR_SIZE_BYTES = 100 * 1024 * 1024;
 function getCliSource() {
-  const version7 = "5.104.1";
+  const version7 = "5.105.1";
   return `cli@${version7}`;
 }
 var DebugLogger = class {
@@ -911022,7 +912052,7 @@ var LegacyDocsPublisher = class {
         previewId,
         disableTemplates: void 0,
         skipUpload,
-        cliVersion: "5.104.1",
+        cliVersion: "5.105.1",
         loginCommand: "fern auth login"
       });
       if (taskContext.getResult() === TaskResult.Failure) {
@@ -951691,6 +952721,7 @@ var RUST_KEYWORDS = /* @__PURE__ */ new Set([
   "virtual",
   "yield"
 ]);
+var RUST_NON_RAW_KEYWORDS = /* @__PURE__ */ new Set(["crate", "self", "Self", "super"]);
 var RUST_RESERVED_TYPES = /* @__PURE__ */ new Set([
   "Box",
   "Option",
@@ -952110,6 +953141,9 @@ function escapeRustKeyword(name2) {
   if (/^[0-9]/.test(name2)) {
     return `_${name2}`;
   }
+  if (RUST_NON_RAW_KEYWORDS.has(name2)) {
+    return `${name2}_`;
+  }
   return RUST_KEYWORDS.has(name2) ? `r#${name2}` : name2;
 }
 function escapeRustReservedType(name2) {
@@ -978393,7 +979427,7 @@ function getAutomationContextFromEnv() {
     config_branch: process.env.FERN_CONFIG_BRANCH,
     config_pr_number: process.env.FERN_CONFIG_PR_NUMBER,
     trigger: process.env.GITHUB_EVENT_NAME,
-    cli_version: "5.104.1"
+    cli_version: "5.105.1"
   };
 }
 function isAutomationMode() {
@@ -979225,7 +980259,7 @@ var CliContext = class _CliContext {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "5.104.1";
+    return "5.105.1";
   }
   getCliName() {
     if (false) {