diff --git a/packages/schema/src/index.ts b/packages/schema/src/index.ts
index c586d1f..ccda7d2 100644
--- a/packages/schema/src/index.ts
+++ b/packages/schema/src/index.ts
@@ -122,4 +122,5 @@ export {
   type InferValueFromArg,
   type InferValueFromArgs,
   type InferValueFromInputType,
+  type InferExternalValueFromInputType,
 } from "./types.js";
diff --git a/packages/schema/src/output.ts b/packages/schema/src/output.ts
index c66ab5a..6716420 100644
--- a/packages/schema/src/output.ts
+++ b/packages/schema/src/output.ts
@@ -32,6 +32,10 @@ import {
   type InferValueFromOutputType,
   type InferValueFromArgs,
   type InferValueFromInputType,
+  type InferExternalValueFromInputType,
+  type GraphQLDefaultInput,
+  type LegacyDefaultValue,
+  type NativeDefault,
 } from "./types.js";
 import {
   GraphQLBoolean,
@@ -58,6 +62,24 @@ type ImpliedResolver<
 
 type Maybe<T> = T | null | undefined;
 
+type RefineGraphQLDefaultInput<Type extends GInputType, Input> = Input extends {
+  value: unknown;
+}
+  ? Input & { value: InferExternalValueFromInputType<Type> }
+  : Input;
+
+type NativeDefaultInput<Type extends GInputType> = RefineGraphQLDefaultInput<
+  Type,
+  GraphQLDefaultInput
+>;
+
+type HasDefaultValue<DefaultValue, DefaultInput> =
+  DefaultValue extends undefined
+    ? DefaultInput extends undefined
+      ? false
+      : true
+    : true;
+
 type FieldFuncArgs<
   Source,
   Args extends { [Key in keyof Args]: GArg<GInputType> },
@@ -636,23 +658,31 @@ export type GWithContext<Context> = {
    *   }
    * `;
    * ```
+   *
+   * With GraphQL 17, `default` accepts uncoerced input or a GraphQL literal. On
+   * GraphQL 16, use `defaultValue`, which accepts an already-coerced value.
+   *
+   * Scalar values in `default: { value: ... }` are checked against the scalar's
+   * serialized output type, which may not cover every input it accepts at
+   * runtime. For example, use a string for an `ID` default rather than an
+   * integer. See {@link InferExternalValueFromInputType} for details.
    */
   arg: <
     Type extends GInputType,
     DefaultValue extends InferValueFromInputType<Type> | undefined = undefined,
+    DefaultInput extends NativeDefaultInput<Type> | undefined = undefined,
   >(
     arg: Flatten<
       {
         type: Type;
       } & Omit<
         GraphQLInputFieldConfig & GraphQLArgumentConfig,
-        "type" | "defaultValue"
+        "type" | "defaultValue" | "default"
       >
     > &
-      (undefined extends DefaultValue
-        ? { defaultValue?: DefaultValue }
-        : { defaultValue: DefaultValue })
-  ) => GArg<Type, DefaultValue extends undefined ? false : true>;
+      LegacyDefaultValue<DefaultValue> &
+      NativeDefault<DefaultInput>
+  ) => GArg<Type, HasDefaultValue<DefaultValue, DefaultInput>>;
   /**
    * Creates an {@link GInputObjectType input object type}
    *
diff --git a/packages/schema/src/types.d.ts b/packages/schema/src/types.d.ts
index 3243e40..0620f14 100644
--- a/packages/schema/src/types.d.ts
+++ b/packages/schema/src/types.d.ts
@@ -18,6 +18,7 @@ import type {
   GraphQLInputFieldExtensions,
   GraphQLInputObjectType,
   GraphQLInputObjectTypeConfig,
+  GraphQLInputType,
   GraphQLInterfaceType,
   GraphQLInterfaceTypeConfig,
   GraphQLList,
@@ -39,6 +40,15 @@ type Maybe<T> = T | null | undefined;
 export type GraphQLDefaultInput = GraphQLArgumentConfig["default" &
   keyof GraphQLArgumentConfig];
 
+// Preserve GraphQL.js's property metadata, including deprecation annotations.
+export type LegacyDefaultValue<
+  Value,
+  IsRequired extends boolean = undefined extends Value ? false : true,
+> = Pick<GraphQLArgumentConfig, "defaultValue"> &
+  (IsRequired extends true
+    ? { defaultValue: Value }
+    : { defaultValue?: Value });
+
 export type NativeDefault<
   Value,
   IsRequired extends boolean = undefined extends Value ? false : true,
@@ -136,24 +146,77 @@ type InferValueFromNullableInputType<Type extends GInputType> =
             : Record<string, unknown>
           : never;
 
-type InferValueForOneOf<
-  T extends { [key: string]: { type: GInputType } },
-  Key extends keyof T = keyof T,
-> = Flatten<
+type InferExternalValueFromNullableInputType<Type extends GInputType> =
+  // Broad input types have no known external shape. Expanding them as lists
+  // would recursively infer their elements without reaching a concrete type.
+  GNullableInputType extends Type
+    ? unknown
+    : Type extends GraphQLScalarType<any, infer Value>
+      ? Value
+      : Type extends GraphQLEnumType
+        ? Type extends GEnumType<infer Values>
+          ? keyof Values & string
+          : unknown
+        : Type extends GList<infer Value extends GInputType>
+          ? // A null input represents a null list, not a singleton null element.
+            | Exclude<InferExternalValueFromInputType<Value>, null>
+            | (object & Iterable<InferExternalValueFromInputType<Value>>)
+          : Type extends GraphQLInputObjectType
+            ? Type extends GInputObjectType<infer Fields, infer IsOneOf>
+              ? IsOneOf extends true
+                ? InferExternalValueForOneOf<Fields>
+                : InferExternalValueFromArgs<Fields>
+              : Record<string, unknown>
+            : never;
+
+type OneOf<Values, Key extends keyof Values = keyof Values> = Flatten<
   Key extends unknown
     ? {
-        readonly [K in Key]: InferValueFromNullableInputType<T[K]["type"]>;
+        readonly [K in Key]: Values[K];
       } & {
-        readonly [K in Exclude<keyof T, Key>]?: never;
+        readonly [K in Exclude<keyof Values, Key>]?: never;
       }
     : never
 >;
 
+type InferValueForOneOf<T extends { [key: string]: { type: GInputType } }> =
+  OneOf<{
+    [K in keyof T]: InferValueFromNullableInputType<T[K]["type"]>;
+  }>;
+
+type InferExternalValueForOneOf<
+  T extends { [key: string]: { type: GInputType } },
+> = OneOf<{
+  [K in keyof T]: InferExternalValueFromNullableInputType<T[K]["type"]>;
+}>;
+
 export type InferValueFromArgs<Args extends Record<string, GArg<GInputType>>> =
   {
     readonly [Key in keyof Args]: InferValueFromArg<Args[Key]>;
   } & {};
 
+type RequiredExternalArgKeys<Args extends Record<string, GArg<GInputType>>> = {
+  // Coercion fills defaults and permits omitted nullable fields.
+  [Key in keyof Args]: Args[Key]["type"] extends GNonNull<any>
+    ? Args[Key] extends GArg<any, true>
+      ? never
+      : Key
+    : never;
+}[keyof Args];
+
+type InferExternalValueFromArgs<Args extends Record<string, GArg<GInputType>>> =
+  Flatten<
+    {
+      readonly [
+        Key in RequiredExternalArgKeys<Args>
+      ]: InferExternalValueFromInputType<Args[Key]["type"]>;
+    } & {
+      readonly [Key in Exclude<keyof Args, RequiredExternalArgKeys<Args>>]?:
+        | InferExternalValueFromInputType<Args[Key]["type"]>
+        | undefined;
+    }
+  >;
+
 export type InferValueFromArg<Arg extends GArg<GInputType>> =
   // the distribution technically only needs to be around the AddUndefined
   // but having it here instead of inside the union
@@ -163,17 +226,40 @@ export type InferValueFromArg<Arg extends GArg<GInputType>> =
   Arg extends unknown
     ?
         | InferValueFromInputType<Arg["type"]>
-        | AddUndefined<Arg["type"], Arg["defaultValue"]>
+        | (Arg extends GArg<Arg["type"], true>
+            ? never
+            : AddUndefined<Arg["type"]>)
     : never;
 
-type AddUndefined<TInputType extends GInputType, DefaultValue> =
-  TInputType extends GNonNull<any> ? never : DefaultValue & undefined;
+type AddUndefined<TInputType extends GInputType> =
+  TInputType extends GNonNull<any> ? never : undefined;
 
 export type InferValueFromInputType<Type extends GInputType> =
   Type extends GNonNull<infer Value extends GNullableInputType>
     ? InferValueFromNullableInputType<Value>
     : InferValueFromNullableInputType<Type> | null;
 
+/**
+ * Infers the externally represented value accepted by input coercion for an
+ * input type.
+ *
+ * This differs from `InferValueFromInputType`, which infers the internal value
+ * passed to resolvers after scalar and enum coercion.
+ *
+ * For scalars, this uses the serialized output type (the second type parameter
+ * of `GraphQLScalarType`) as an approximation of accepted input. GraphQL.js
+ * does not encode accepted input types separately, so some values accepted at
+ * runtime may be excluded. For example, `ID` is typed as `string` even though
+ * it also accepts integer inputs. Custom scalars whose accepted inputs differ
+ * from their serialized outputs have the same limitation.
+ */
+export type InferExternalValueFromInputType<Type extends GInputType> =
+  GInputType extends Type
+    ? unknown
+    : Type extends GNonNull<infer Value extends GNullableInputType>
+      ? InferExternalValueFromNullableInputType<Value>
+      : InferExternalValueFromNullableInputType<Type> | null;
+
 /**
  * A GraphQL output field for an {@link GObjectType object type} which should be
  * created using {@link g.field}.
@@ -351,6 +437,17 @@ export type GInterfaceTypeConfig<
   } & Omit<GraphQLInterfaceTypeConfig<Source, Context>, "interfaces" | "fields">
 >;
 
+type GArgDefaults<HasDefaultValue extends boolean> =
+  HasDefaultValue extends true
+    ?
+        | (LegacyDefaultValue<{} | null, true> &
+            NativeDefault<GraphQLDefaultInput, false>)
+        | ("default" extends keyof GraphQLArgumentConfig
+            ? LegacyDefaultValue<undefined, false> &
+                NativeDefault<Exclude<GraphQLDefaultInput, undefined>, true>
+            : never)
+    : LegacyDefaultValue<undefined, false> & NativeDefault<undefined, false>;
+
 /**
  * A GraphQL argument. These should be created with {@link g.arg}
  *
@@ -408,12 +505,8 @@ export type GInterfaceTypeConfig<
 export type GArg<
   Type extends GInputType,
   HasDefaultValue extends boolean = boolean,
-> = {
+> = GArgDefaults<HasDefaultValue> & {
   type: Type;
-  defaultValue: {
-    true: {} | null;
-    false: undefined;
-  }[`${HasDefaultValue}`];
   description?: Maybe<string>;
   deprecationReason?: Maybe<string>;
   extensions?: Maybe<GraphQLInputFieldExtensions & GraphQLArgumentExtensions>;
@@ -434,6 +527,25 @@ export type GInputObjectTypeConfig<
 > &
   (false extends IsOneOf ? { isOneOf?: IsOneOf } : { isOneOf: IsOneOf });
 
+type ResolvedInputFieldDefaults<Arg extends GArg<GInputType>> =
+  // Broad fields must still accept native GraphQLInputField instances.
+  GArg<Arg["type"]> extends Arg
+    ? {}
+    : // Preserve the alternative ways a concrete field can have a default.
+      Arg extends unknown
+      ? Pick<Arg, "defaultValue" | ("default" & keyof Arg)>
+      : never;
+
+// Override the type property instead of intersecting it with GraphQLInputType,
+// which loses scalar inference when a resolved field is reused as an argument.
+interface TypedInputField<
+  Type extends GraphQLInputType,
+  DefaultValue,
+> extends GraphQLInputField {
+  type: Type;
+  defaultValue: DefaultValue;
+}
+
 /**
  * A GraphQL input object type. This should generally be constructed with
  * {@link g.inputObject}.
@@ -453,10 +565,11 @@ export class GInputObjectType<
   isOneOf: IsOneOf;
   constructor(config: Readonly<GInputObjectTypeConfig<Fields, IsOneOf>>);
   getFields(): {
-    [K in keyof Fields]: GraphQLInputField & {
-      type: Fields[K]["type"];
-      defaultValue: Fields[K]["defaultValue"];
-    };
+    [K in keyof Fields]: TypedInputField<
+      Fields[K]["type"],
+      Fields[K]["defaultValue"]
+    > &
+      ResolvedInputFieldDefaults<Fields[K]>;
   };
 }
 
@@ -533,12 +646,13 @@ type GListToStringTag =
  * exactly the same as it's counterpart `g.nonNull` so it is safe to use
  * directly if desired.
  *
- * Also unlike the named types in this module, the original
+ * On GraphQL 17, native and wrapped non-null types are mutually assignable. On
+ * GraphQL 16, unlike the named types in this module, the original
  * {@link GraphQLNonNull `GraphQLNonNull`} type from the `graphql` package
  * cannot be assigned to a variable of type `GNonNull`. Though `GNonNull` _is_
  * assignable to `GraphQLNonNull`.
  *
- * For example, the following code will not compile:
+ * For example, on GraphQL 16 the following code will not compile:
  *
  * ```ts
  * const nonNull: GNonNull<GScalarType<string>> = new GraphQLNonNull(
@@ -571,12 +685,13 @@ export class GNonNull<
  * exactly the same as it's counterpart `g.list` so it is safe to use directly
  * if desired.
  *
- * Also unlike the named types in this module, the original
+ * On GraphQL 17, native and wrapped list types are mutually assignable. On
+ * GraphQL 16, unlike the named types in this module, the original
  * {@link GraphQLList `GraphQLList`} type from the `graphql` package cannot be
  * assigned to a variable of type `GList`. Though `GList` _is_ assignable to
  * `GraphQLList`.
  *
- * For example, the following code will not compile:
+ * For example, on GraphQL 16 the following code will not compile:
  *
  * ```ts
  * const list: GList<GScalarType<string>> = new GraphQLList(GraphQLString);
diff --git a/test-project/default-value-deprecation.probe.ts b/test-project/default-value-deprecation.probe.ts
new file mode 100644
index 0000000..0fa16d2
--- /dev/null
+++ b/test-project/default-value-deprecation.probe.ts
@@ -0,0 +1,6 @@
+import { gWithContext } from "@graphql-ts/schema";
+
+const g = gWithContext<unknown>();
+const arg = g.arg({ type: g.String, defaultValue: "legacy" });
+
+console.log(arg.defaultValue);
diff --git a/test-project/default-value-deprecation.test.ts b/test-project/default-value-deprecation.test.ts
new file mode 100644
index 0000000..bfbde0d
--- /dev/null
+++ b/test-project/default-value-deprecation.test.ts
@@ -0,0 +1,49 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { resolve } from "node:path";
+import { versionInfo } from "graphql";
+import ts from "typescript";
+
+test("defaultValue follows GraphQL.js deprecation metadata", () => {
+  const projectRoot = process.cwd();
+  const configPath = ts.findConfigFile(projectRoot, ts.sys.fileExists);
+  assert(configPath);
+
+  const config = ts.readConfigFile(configPath, ts.sys.readFile);
+  const parsedConfig = ts.parseJsonConfigFileContent(
+    config.config,
+    ts.sys,
+    projectRoot
+  );
+  const probePath = resolve(
+    projectRoot,
+    "test-project/default-value-deprecation.probe.ts"
+  );
+  const program = ts.createProgram([probePath], parsedConfig.options);
+  const checker = program.getTypeChecker();
+  const source = program.getSourceFile(probePath);
+  assert(source);
+
+  const defaultValueSymbols: ts.Symbol[] = [];
+  source.forEachChild(function visit(node) {
+    if (ts.isIdentifier(node) && node.text === "defaultValue") {
+      const symbol = ts.isPropertyAssignment(node.parent)
+        ? checker
+            .getContextualType(node.parent.parent)
+            ?.getProperty("defaultValue")
+        : checker.getSymbolAtLocation(node);
+      assert(symbol);
+      defaultValueSymbols.push(symbol);
+    }
+    node.forEachChild(visit);
+  });
+  assert.equal(defaultValueSymbols.length, 2);
+
+  for (const symbol of defaultValueSymbols) {
+    const isDeprecated = symbol
+      .getJsDocTags(checker)
+      .some((tag) => tag.name === "deprecated");
+
+    assert.equal(isDeprecated, versionInfo.major >= 17);
+  }
+});
diff --git a/test-project/graphql-17/defaults.test.ts b/test-project/graphql-17/defaults.test.ts
new file mode 100644
index 0000000..8f8d40e
--- /dev/null
+++ b/test-project/graphql-17/defaults.test.ts
@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { gWithContext } from "@graphql-ts/schema";
+import { GraphQLSchema, graphql, versionInfo } from "graphql";
+
+test(
+  "native defaults are coerced before reaching resolvers",
+  {
+    skip: versionInfo.major < 17,
+  },
+  async () => {
+    const g = gWithContext();
+    const mode = g.enum({
+      name: "Mode",
+      values: { FAST: { value: 42 } },
+    });
+    const options = g.inputObject({
+      name: "Options",
+      fields: {
+        mode: g.arg({ type: mode, default: { value: "FAST" } }),
+        numbers: g.arg({
+          type: g.list(g.Int),
+          default: { value: new Set([1, 2]) },
+        }),
+        label: g.arg({ type: g.String }),
+      },
+    });
+    const query = g.object()({
+      name: "Query",
+      fields: {
+        inspect: g.field({
+          type: g.String,
+          args: {
+            options: g.arg({ type: options, default: { value: {} } }),
+            literal: g.arg({
+              type: g.Int,
+              default: { literal: { kind: "IntValue", value: "7" } },
+            }),
+          },
+          resolve(_, args) {
+            assert.equal(args.options?.mode, 42);
+            assert.deepEqual(args.options?.numbers, [1, 2]);
+            assert.equal(args.options?.label, undefined);
+            assert.equal(args.literal, 7);
+            return "coerced";
+          },
+        }),
+      },
+    });
+    const result = await graphql({
+      schema: new GraphQLSchema({ query }),
+      source: "{ inspect }",
+    });
+    assert.deepEqual(JSON.parse(JSON.stringify(result)), {
+      data: { inspect: "coerced" },
+    });
+  }
+);
diff --git a/test-project/graphql-17/index.test-d.ts b/test-project/graphql-17/index.test-d.ts
index 7f31d38..c1a7309 100644
--- a/test-project/graphql-17/index.test-d.ts
+++ b/test-project/graphql-17/index.test-d.ts
@@ -1,13 +1,17 @@
 import type {
   GArg,
   GInputObjectType,
+  GInputType,
   GInterfaceField,
   GInterfaceType,
   GList,
   GNonNull,
   GScalarType,
   GUnionType,
+  InferExternalValueFromInputType,
+  InferValueFromArg,
 } from "@graphql-ts/schema";
+import { gWithContext } from "@graphql-ts/schema";
 import type {
   GraphQLInputObjectType,
   GraphQLInterfaceType,
@@ -51,3 +55,262 @@ assertCompatible<
   // @ts-expect-error precise interface fields are GraphQL-TS-only information
   GraphQLInterfaceType<Source, Context>
 >();
+
+const g = gWithContext<unknown>();
+
+assertCompatible<
+  Invariant<unknown>,
+  Invariant<InferExternalValueFromInputType<any>>
+>();
+assertCompatible<
+  Invariant<unknown>,
+  Invariant<InferExternalValueFromInputType<GInputType>>
+>();
+
+// Broad input object types must not recursively expand untyped list elements.
+const untypedInput = undefined! as GInputObjectType<
+  Record<string, GArg<any>>,
+  boolean
+>;
+g.arg({ type: untypedInput });
+g.arg({ type: untypedInput, default: { value: { anything: [1, "two"] } } });
+
+const broadInput = undefined! as GInputObjectType<
+  Record<string, GArg<GInputType>>
+>;
+g.arg({ type: broadInput, default: { value: { anything: [1, "two"] } } });
+
+type InternalAndExternalScalar = GScalarType<number, string>;
+const internalAndExternalScalar = undefined! as InternalAndExternalScalar;
+assertCompatible<
+  Invariant<string | null>,
+  Invariant<InferExternalValueFromInputType<InternalAndExternalScalar>>
+>();
+
+const argWithDefault = g.arg({
+  type: g.String,
+  default: { value: "external input" },
+});
+assertCompatible<
+  Invariant<GArg<typeof g.String, true>>,
+  Invariant<typeof argWithDefault>
+>();
+
+g.arg<typeof g.String, undefined, { value: string }>({
+  type: g.String,
+  default: { value: "external input" },
+});
+
+// @ts-expect-error explicitly selecting a default type requires default
+g.arg<typeof g.String, undefined, { value: string }>({
+  type: g.String,
+});
+assertCompatible<
+  Invariant<string | null>,
+  Invariant<InferValueFromArg<typeof argWithDefault>>
+>();
+
+const mode = g.enum({
+  name: "Mode",
+  values: { FAST: { value: 42 } },
+});
+g.arg({ type: mode, default: { value: "FAST" } });
+g.arg({
+  type: mode,
+  // @ts-expect-error native enum defaults use names, not internal values
+  default: { value: 42 },
+});
+g.arg({
+  type: mode,
+  // @ts-expect-error native enum defaults must name a defined enum value
+  default: { value: "UNKNOWN" },
+});
+
+g.arg({
+  type: internalAndExternalScalar,
+  default: { value: "external input" },
+});
+g.arg({
+  type: internalAndExternalScalar,
+  // @ts-expect-error native defaults use the scalar's external value type
+  default: { value: 1 },
+});
+g.arg({
+  type: g.Int,
+  // @ts-expect-error native defaults must use the input type's value type
+  default: { value: "not a number" },
+});
+
+const argWithLiteralDefault = g.arg({
+  type: g.String,
+  default: { literal: { kind: "StringValue", value: "literal input" } },
+});
+assertCompatible<
+  Invariant<GArg<typeof g.String, true>>,
+  Invariant<typeof argWithLiteralDefault>
+>();
+
+const argWithUndefinedDefault = g.arg({
+  type: g.String,
+  default: undefined,
+});
+assertCompatible<
+  Invariant<GArg<typeof g.String, false>>,
+  Invariant<typeof argWithUndefinedDefault>
+>();
+
+const argWithBothDefaults = g.arg({
+  type: g.String,
+  defaultValue: "legacy",
+  default: { value: "external input" },
+});
+assertCompatible<
+  Invariant<GArg<typeof g.String, true>>,
+  Invariant<typeof argWithBothDefaults>
+>();
+
+const maybeDefault =
+  Math.random() > 0.5 ? { default: { value: "external input" } } : {};
+const argWithMaybeDefault = g.arg({
+  type: g.String,
+  ...maybeDefault,
+});
+assertCompatible<
+  Invariant<GArg<typeof g.String, boolean>>,
+  Invariant<typeof argWithMaybeDefault>
+>();
+
+g.arg({
+  type: g.String,
+  // @ts-expect-error GraphQLDefaultInput requires exactly one of value or literal
+  default: {},
+});
+
+const optionalFieldsInput = g.inputObject({
+  name: "OptionalFieldsInput",
+  fields: {
+    label: g.arg({ type: g.String }),
+    limit: g.arg({ type: g.nonNull(g.Int), defaultValue: 10 }),
+    offset: g.arg({ type: g.nonNull(g.Int), default: { value: 0 } }),
+    description: g.arg({ type: g.String, default: { value: "default" } }),
+  },
+});
+assertCompatible<
+  Invariant<{
+    readonly label?: string | null | undefined;
+    readonly limit?: number | undefined;
+    readonly offset?: number | undefined;
+    readonly description?: string | null | undefined;
+  } | null>,
+  Invariant<InferExternalValueFromInputType<typeof optionalFieldsInput>>
+>();
+g.arg({ type: optionalFieldsInput, default: { value: {} } });
+g.arg({
+  type: optionalFieldsInput,
+  default: { value: { label: undefined, limit: undefined } },
+});
+g.arg({
+  type: optionalFieldsInput,
+  // @ts-expect-error a default does not allow null for a non-null field
+  default: { value: { limit: null } },
+});
+
+const requiredFieldsInput = g.inputObject({
+  name: "RequiredFieldsInput",
+  fields: {
+    name: g.arg({ type: g.nonNull(g.String) }),
+    options: g.arg({ type: optionalFieldsInput }),
+  },
+});
+g.arg({ type: requiredFieldsInput, default: { value: { name: "name" } } });
+g.arg({
+  type: requiredFieldsInput,
+  default: { value: { name: "name", options: {} } },
+});
+g.arg({
+  type: requiredFieldsInput,
+  // @ts-expect-error non-null fields without defaults must be supplied
+  default: { value: {} },
+});
+
+const oneOfInput = g.inputObject({
+  name: "OneOfInput",
+  isOneOf: true,
+  fields: {
+    name: g.arg({ type: g.String }),
+    options: g.arg({ type: optionalFieldsInput }),
+  },
+});
+g.arg({ type: oneOfInput, default: { value: { options: {} } } });
+g.arg({
+  type: oneOfInput,
+  // @ts-expect-error one-of inputs still require exactly one field
+  default: { value: {} },
+});
+g.arg({
+  type: oneOfInput,
+  // @ts-expect-error a selected one-of field cannot be null
+  default: { value: { name: null } },
+});
+
+const intList = g.list(g.Int);
+assertCompatible<
+  Invariant<number | (object & Iterable<number | null>) | null>,
+  Invariant<InferExternalValueFromInputType<typeof intList>>
+>();
+const singletonDefault = g.arg({ type: intList, default: { value: 1 } });
+assertCompatible<
+  Invariant<(number | null)[] | null>,
+  Invariant<InferValueFromArg<typeof singletonDefault>>
+>();
+g.arg({ type: intList, default: { value: [1, null] as const } });
+g.arg({ type: intList, default: { value: new Set([1, 2]) } });
+g.arg({
+  type: intList,
+  // @ts-expect-error iterable elements must match the input type
+  default: { value: new Set(["wrong"]) },
+});
+g.arg({ type: intList, default: { value: null } });
+g.arg({ type: g.list(g.list(g.Int)), default: { value: 1 } });
+g.arg({ type: g.list(g.list(g.Int)), default: { value: [1, [2]] } });
+g.arg({ type: g.list(optionalFieldsInput), default: { value: {} } });
+g.arg({
+  type: intList,
+  // @ts-expect-error singleton inputs must still match the element type
+  default: { value: "not a number" },
+});
+g.arg({
+  type: g.nonNull(intList),
+  // @ts-expect-error nullable elements do not make the list itself nullable
+  default: { value: null },
+});
+g.arg({
+  type: g.list(g.nonNull(g.Int)),
+  // @ts-expect-error non-null list elements cannot be null
+  default: { value: [null] },
+});
+
+const resolvedFields = optionalFieldsInput.getFields();
+assertCompatible<
+  Invariant<string | null | undefined>,
+  Invariant<InferValueFromArg<typeof resolvedFields.label>>
+>();
+assertCompatible<
+  Invariant<string | null>,
+  Invariant<InferValueFromArg<typeof resolvedFields.description>>
+>();
+const reusedInput = g.inputObject({
+  name: "ReusedInput",
+  fields: resolvedFields,
+});
+g.arg({ type: reusedInput, default: { value: {} } });
+
+type UncertainDefaultArg = {
+  type: typeof g.String;
+  defaultValue?: undefined;
+  default?: { value: string };
+};
+assertCompatible<
+  Invariant<string | null | undefined>,
+  Invariant<InferValueFromArg<UncertainDefaultArg>>
+>();