diff --git a/src/json-type/README.md b/src/json-type/README.md
index b53310e669..75b5dc8ab4 100644
--- a/src/json-type/README.md
+++ b/src/json-type/README.md
@@ -5,8 +5,8 @@ Type builder for JSON and MessagePack.
 ```ts
 import {t} from 'json-joy/lib/json-type';
 
-t.String(); // { __t: 'str' }
-t.String({const: 'add'}); // { __t: 'str', const: 'add' }
+t.String(); // { kind: 'str' }
+t.String({const: 'add'}); // { kind: 'str', const: 'add' }
 
 const type = t.Object([
   t.Field('collection', t.Object([
diff --git a/src/json-type/index.ts b/src/json-type/index.ts
index 0a2afed1e2..a736a4f568 100644
--- a/src/json-type/index.ts
+++ b/src/json-type/index.ts
@@ -17,7 +17,7 @@
  * Define basic types, for example, a string:
  *
  * ```ts
- * t.String(); // { __t: 'str' }
+ * t.String(); // { kind: 'str' }
  * ```
  *
  * Define complex types:
diff --git a/src/json-type/schema/SchemaBuilder.ts b/src/json-type/schema/SchemaBuilder.ts
index 837f0b427c..5cbe9220a7 100644
--- a/src/json-type/schema/SchemaBuilder.ts
+++ b/src/json-type/schema/SchemaBuilder.ts
@@ -74,23 +74,23 @@ export class SchemaBuilder {
   public Boolean(options?: NoT<BooleanSchema>): BooleanSchema;
   public Boolean(a?: string | NoT<BooleanSchema>, b?: NoT<BooleanSchema> | void): BooleanSchema {
     if (typeof a === 'string') return this.Boolean({id: a, ...(b || {})});
-    return {__t: 'bool', ...(a || {})};
+    return {kind: 'bool', ...(a || {})};
   }
 
   public Number(options?: NoT<NumberSchema>): NumberSchema {
-    return {__t: 'num', ...options};
+    return {kind: 'num', ...options};
   }
 
   public String(id: string, options?: NoT<StringSchema>): StringSchema;
   public String(options?: NoT<StringSchema>): StringSchema;
   public String(a?: string | NoT<StringSchema>, b?: NoT<StringSchema>): StringSchema {
     if (typeof a === 'string') return this.String({id: a, ...(b || {})});
-    return {__t: 'str', ...(a || {})};
+    return {kind: 'str', ...(a || {})};
   }
 
   public Binary<T extends Schema>(type: T, options: Optional<BinarySchema> = {}): BinarySchema {
     return {
-      __t: 'bin',
+      kind: 'bin',
       type,
       ...options,
     };
@@ -108,7 +108,7 @@ export class SchemaBuilder {
     c?: Omit<NoT<ArraySchema<T>>, 'id' | 'type'>,
   ): ArraySchema<T> {
     if (typeof a === 'string') return this.Array(b as T, {id: a, ...(c || {})});
-    return {__t: 'arr', ...(b as Omit<NoT<ArraySchema<T>>, 'id' | 'type'>), type: a as T};
+    return {kind: 'arr', ...(b as Omit<NoT<ArraySchema<T>>, 'id' | 'type'>), type: a as T};
   }
 
   /**
@@ -127,11 +127,11 @@ export class SchemaBuilder {
   ): ConstSchema<
     string extends V ? never : number extends V ? never : boolean extends V ? never : any[] extends V ? never : V
   > {
-    return {__t: 'const', value: value as any, ...options};
+    return {kind: 'const', value: value as any, ...options};
   }
 
   public Tuple<T extends Schema[]>(...types: T): TupleSchema<T> {
-    return {__t: 'tup', types};
+    return {kind: 'tup', types};
   }
 
   public fields<F extends ObjectFieldSchema<any, any>[]>(...fields: ObjectSchema<F>['fields']): F {
@@ -158,7 +158,7 @@ export class SchemaBuilder {
       typeof first === 'object' &&
       (first as NoT<ObjectSchema<F>>).fields instanceof Array
     )
-      return {__t: 'obj', ...(first as NoT<ObjectSchema<F>>)};
+      return {kind: 'obj', ...(first as NoT<ObjectSchema<F>>)};
     if (args.length >= 1 && args[0] instanceof Array)
       return this.Object({fields: args[0] as F, ...(args[1] as Optional<ObjectSchema<F>>)});
     return this.Object({fields: args as F});
@@ -171,7 +171,7 @@ export class SchemaBuilder {
     options: Omit<NoT<ObjectFieldSchema<K, V>>, 'key' | 'type' | 'optional'> = {},
   ): ObjectFieldSchema<K, V> {
     return {
-      __t: 'field',
+      kind: 'field',
       key,
       type,
       ...options,
@@ -185,7 +185,7 @@ export class SchemaBuilder {
     options: Omit<NoT<ObjectFieldSchema<K, V>>, 'key' | 'type' | 'optional'> = {},
   ): ObjectOptionalFieldSchema<K, V> {
     return {
-      __t: 'field',
+      kind: 'field',
       key,
       type,
       ...options,
@@ -200,7 +200,7 @@ export class SchemaBuilder {
     options: Omit<NoT<ObjectFieldSchema<K, V>>, 'key' | 'type' | 'optional'> = {},
   ): ObjectFieldSchema<K, V> {
     return {
-      __t: 'field',
+      kind: 'field',
       key,
       type,
       ...options,
@@ -214,7 +214,7 @@ export class SchemaBuilder {
     options: Omit<NoT<ObjectFieldSchema<K, V>>, 'key' | 'type' | 'optional'> = {},
   ): ObjectOptionalFieldSchema<K, V> {
     return {
-      __t: 'field',
+      kind: 'field',
       key,
       type,
       ...options,
@@ -223,26 +223,26 @@ export class SchemaBuilder {
   }
 
   public Map<T extends Schema>(type: T, options?: Omit<NoT<MapSchema<T>>, 'type'>): MapSchema<T> {
-    return {__t: 'map', type, ...options};
+    return {kind: 'map', type, ...options};
   }
 
   public Any(options: NoT<AnySchema> = {}): AnySchema {
     return {
-      __t: 'any',
+      kind: 'any',
       ...options,
     };
   }
 
   public Ref<T extends TType = any>(ref: string): RefSchema<T> {
     return {
-      __t: 'ref',
+      kind: 'ref',
       ref: ref as string & T,
     };
   }
 
   public Or<T extends Schema[]>(...types: T): OrSchema<T> {
     return {
-      __t: 'or',
+      kind: 'or',
       types,
       discriminator: ['num', -1],
     };
@@ -250,7 +250,7 @@ export class SchemaBuilder {
 
   public Function<Req extends Schema, Res extends Schema>(req: Req, res: Res): FunctionSchema<Req, Res> {
     return {
-      __t: 'fn',
+      kind: 'fn',
       req,
       res,
     };
@@ -258,7 +258,7 @@ export class SchemaBuilder {
 
   public Function$<Req extends Schema, Res extends Schema>(req: Req, res: Res): FunctionStreamingSchema<Req, Res> {
     return {
-      __t: 'fn$',
+      kind: 'fn$',
       req,
       res,
     };
diff --git a/src/json-type/schema/__tests__/SchemaBuilder.spec.ts b/src/json-type/schema/__tests__/SchemaBuilder.spec.ts
index e98210f2ac..60a806fd7d 100644
--- a/src/json-type/schema/__tests__/SchemaBuilder.spec.ts
+++ b/src/json-type/schema/__tests__/SchemaBuilder.spec.ts
@@ -2,56 +2,64 @@ import {s} from '..';
 
 describe('string', () => {
   test('can create a string type', () => {
-    expect(s.String()).toEqual({__t: 'str'});
+    expect(s.String()).toEqual({kind: 'str'});
   });
 
   test('can create a named a string type', () => {
     expect(s.String('UserName')).toEqual({
-      __t: 'str',
+      kind: 'str',
       id: 'UserName',
     });
   });
+
+  test('can add custom metadata', () => {
+    expect(s.String('validator', {meta: {regex: true}})).toEqual({
+      kind: 'str',
+      id: 'validator',
+      meta: {regex: true},
+    });
+  });
 });
 
 describe('object', () => {
   test('can create an empty object using shorthand', () => {
-    expect(s.obj).toEqual({__t: 'obj', fields: []});
+    expect(s.obj).toEqual({kind: 'obj', fields: []});
   });
 
   test('can create an empty object using default syntax', () => {
-    expect(s.Object()).toEqual({__t: 'obj', fields: []});
+    expect(s.Object()).toEqual({kind: 'obj', fields: []});
   });
 
   test('can create an empty object using fields-first syntax', () => {
-    expect(s.Object()).toEqual({__t: 'obj', fields: []});
+    expect(s.Object()).toEqual({kind: 'obj', fields: []});
   });
 
   test('can create a named empty object using fields-first syntax', () => {
-    expect(s.Object([])).toEqual({__t: 'obj', fields: []});
+    expect(s.Object([])).toEqual({kind: 'obj', fields: []});
   });
 
   test('can create a named empty object using default syntax', () => {
-    expect(s.Object({fields: []})).toEqual({__t: 'obj', fields: []});
+    expect(s.Object({fields: []})).toEqual({kind: 'obj', fields: []});
   });
 
   test('can specify types', () => {
     const type = s.Object([s.prop('id', s.String('UserId')), s.prop('name', s.str)]);
     expect(type).toEqual({
-      __t: 'obj',
+      kind: 'obj',
       fields: [
         {
-          __t: 'field',
+          kind: 'field',
           key: 'id',
           type: {
-            __t: 'str',
+            kind: 'str',
             id: 'UserId',
           },
         },
         {
-          __t: 'field',
+          kind: 'field',
           key: 'name',
           type: {
-            __t: 'str',
+            kind: 'str',
           },
         },
       ],
@@ -61,11 +69,11 @@ describe('object', () => {
 
 describe('map', () => {
   test('can create an simple object using shorthand', () => {
-    expect(s.map).toEqual({__t: 'map', type: {__t: 'any'}});
+    expect(s.map).toEqual({kind: 'map', type: {kind: 'any'}});
   });
 
   test('can define a map', () => {
-    expect(s.Map(s.Boolean())).toEqual({__t: 'map', type: {__t: 'bool'}});
+    expect(s.Map(s.Boolean())).toEqual({kind: 'map', type: {kind: 'bool'}});
   });
 });
 
@@ -73,8 +81,8 @@ describe('or', () => {
   test('can create an "or" type', () => {
     const type = s.Or(s.str, s.num);
     expect(type).toEqual({
-      __t: 'or',
-      types: [{__t: 'str'}, {__t: 'num'}],
+      kind: 'or',
+      types: [{kind: 'str'}, {kind: 'num'}],
       discriminator: ['num', -1],
     });
   });
diff --git a/src/json-type/schema/__tests__/type.spec.ts b/src/json-type/schema/__tests__/type.spec.ts
index 4698e7de27..bf77e7b2a6 100644
--- a/src/json-type/schema/__tests__/type.spec.ts
+++ b/src/json-type/schema/__tests__/type.spec.ts
@@ -2,7 +2,7 @@ import {ObjectSchema, s} from '..';
 
 test('can generate any type', () => {
   const address: ObjectSchema = {
-    __t: 'obj',
+    kind: 'obj',
     title: 'User address',
     description: 'Various address fields for user',
     fields: [...s.Object(s.prop('street', s.String()), s.prop('zip', s.String())).fields],
@@ -18,45 +18,45 @@ test('can generate any type', () => {
   );
 
   expect(userType).toMatchObject({
-    __t: 'obj',
+    kind: 'obj',
     fields: [
       {
         key: 'id',
         type: {
-          __t: 'num',
+          kind: 'num',
           format: 'i',
         },
       },
       {
         key: 'alwaysOne',
         type: {
-          __t: 'const',
+          kind: 'const',
           value: 1,
         },
       },
       {
         key: 'name',
         type: {
-          __t: 'str',
+          kind: 'str',
         },
       },
       {
         key: 'address',
         type: {
-          __t: 'obj',
+          kind: 'obj',
           title: 'User address',
           description: 'Various address fields for user',
           fields: [
             {
               key: 'street',
               type: {
-                __t: 'str',
+                kind: 'str',
               },
             },
             {
               key: 'zip',
               type: {
-                __t: 'str',
+                kind: 'str',
               },
             },
           ],
@@ -65,21 +65,21 @@ test('can generate any type', () => {
       {
         key: 'timeCreated',
         type: {
-          __t: 'num',
+          kind: 'num',
         },
       },
       {
         key: 'tags',
         type: {
-          __t: 'arr',
+          kind: 'arr',
           type: {
-            __t: 'or',
+            kind: 'or',
             types: [
               {
-                __t: 'num',
+                kind: 'num',
               },
               {
-                __t: 'str',
+                kind: 'str',
               },
             ],
           },
@@ -88,9 +88,9 @@ test('can generate any type', () => {
       {
         key: 'elements',
         type: {
-          __t: 'map',
+          kind: 'map',
           type: {
-            __t: 'str',
+            kind: 'str',
           },
         },
       },
diff --git a/src/json-type/schema/schema.ts b/src/json-type/schema/schema.ts
index c2cb50f900..20e8dc4db2 100644
--- a/src/json-type/schema/schema.ts
+++ b/src/json-type/schema/schema.ts
@@ -5,11 +5,16 @@ import type {Expr} from '../../json-expression';
 
 export interface TType<Value = unknown> extends Display, Partial<Identifiable> {
   /**
-   * "t" is short for "type". Double underscore "__" is borrowed from GraphQL,
-   * where they use "__typeName". Values are short strings, such as "str", "num",
-   * and "bin", borrowed from MessagePack.
+   * The type of the JSON Type node.
    */
-  __t: string;
+  kind: string;
+
+  /**
+   * Custom metadata that can be attached to the type. This is useful for
+   * documentation generation, and for custom code generators. The `meta` field
+   * is not used by the JSON Type system itself.
+   */
+  meta?: Record<string, unknown>;
 
   /**
    * List of example usages of this type.
@@ -36,7 +41,7 @@ export interface WithValidator {
  * Represents something of which type is not known.
  */
 export interface AnySchema extends TType<unknown>, WithValidator {
-  __t: 'any';
+  kind: 'any';
 
   /**
    * Custom metadata that can be attached to the type. This is useful for
@@ -49,14 +54,14 @@ export interface AnySchema extends TType<unknown>, WithValidator {
  * Represents a JSON boolean.
  */
 export interface BooleanSchema extends TType<boolean>, WithValidator {
-  __t: 'bool';
+  kind: 'bool';
 }
 
 /**
  * Represents a JSON number.
  */
 export interface NumberSchema extends TType<number>, WithValidator {
-  __t: 'num';
+  kind: 'num';
 
   /**
    * A more specific format of the number. When this is set, faster compiled
@@ -96,7 +101,7 @@ export interface NumberSchema extends TType<number>, WithValidator {
  * Represents a JSON string.
  */
 export interface StringSchema extends TType<string>, WithValidator {
-  __t: 'str';
+  kind: 'str';
 
   /**
    * When set to true, means that the string can contain only ASCII characters.
@@ -123,7 +128,7 @@ export interface StringSchema extends TType<string>, WithValidator {
  * Represents a binary type.
  */
 export interface BinarySchema<T extends TType = any> extends TType, WithValidator {
-  __t: 'bin';
+  kind: 'bin';
   /** Type of value encoded in the binary data. */
   type: T;
   /** Codec used for encoding the binary data. */
@@ -134,7 +139,7 @@ export interface BinarySchema<T extends TType = any> extends TType, WithValidato
  * Represents a JSON array.
  */
 export interface ArraySchema<T extends TType = any> extends TType<Array<unknown>>, WithValidator {
-  __t: 'arr';
+  kind: 'arr';
   /** One or more "one-of" types that array contains. */
   type: T;
   /** Minimum number of elements. */
@@ -148,7 +153,7 @@ export interface ArraySchema<T extends TType = any> extends TType<Array<unknown>
  */
 export interface ConstSchema<V = any> extends TType, WithValidator {
   /** @todo Rename to "con". */
-  __t: 'const';
+  kind: 'const';
   /** The value. */
   value: V;
 }
@@ -157,7 +162,7 @@ export interface ConstSchema<V = any> extends TType, WithValidator {
  * Represents a JSON array.
  */
 export interface TupleSchema<T extends TType[] = any> extends TType, WithValidator {
-  __t: 'tup';
+  kind: 'tup';
   // types: any[] extends T ? never : T;
   types: T;
 }
@@ -170,7 +175,7 @@ export interface ObjectSchema<
   Fields extends ObjectFieldSchema<string, TType>[] | readonly ObjectFieldSchema<string, TType>[] = any,
 > extends TType<object>,
     WithValidator {
-  __t: 'obj';
+  kind: 'obj';
 
   /**
    * Sorted list of fields this object contains. Although object fields in JSON
@@ -188,7 +193,7 @@ export interface ObjectSchema<
    *
    * ```json
    * {
-   *   "__t": "obj",
+   *   "kind": "obj",
    *   "fields": [],
    *   "unknownFields": true
    * }
@@ -206,7 +211,7 @@ export interface ObjectSchema<
  * Represents a single field of an object.
  */
 export interface ObjectFieldSchema<K extends string = string, V extends TType = TType> extends TType<[K, V]>, Display {
-  __t: 'field';
+  kind: 'field';
   /** Key name of the field. */
   key: K;
   /** One or more "one-of" types of the field. */
@@ -224,7 +229,7 @@ export interface ObjectOptionalFieldSchema<K extends string = string, V extends
  * values are of the same type.
  */
 export interface MapSchema<T extends TType = any> extends TType<Record<string, unknown>>, WithValidator {
-  __t: 'map';
+  kind: 'map';
   /** Type of all values in the map. */
   type: T;
 }
@@ -233,7 +238,7 @@ export interface MapSchema<T extends TType = any> extends TType<Record<string, u
  * Reference to another type.
  */
 export interface RefSchema<T extends TType = TType> extends TType {
-  __t: 'ref';
+  kind: 'ref';
 
   /** ID of the type it references. */
   ref: string & T;
@@ -243,7 +248,7 @@ export interface RefSchema<T extends TType = TType> extends TType {
  * Represents a type that is one of a set of types.
  */
 export interface OrSchema<T extends TType[] = TType[]> extends TType {
-  __t: 'or';
+  kind: 'or';
 
   /** One or more "one-of" types. */
   types: T;
@@ -254,7 +259,7 @@ export interface OrSchema<T extends TType[] = TType[]> extends TType {
 export type FunctionValue<Req, Res, Ctx = unknown> = (req: Req, ctx?: Ctx) => Res | Promise<Res>;
 
 export interface FunctionSchema<Req extends TType = TType, Res extends TType = TType> extends TType {
-  __t: 'fn';
+  kind: 'fn';
   req: Req;
   res: Res;
 }
@@ -262,7 +267,7 @@ export interface FunctionSchema<Req extends TType = TType, Res extends TType = T
 export type FunctionStreamingValue<Req, Res, Ctx = unknown> = (req: Observable<Req>, ctx?: Ctx) => Observable<Res>;
 
 export interface FunctionStreamingSchema<Req extends TType = TType, Res extends TType = TType> extends TType {
-  __t: 'fn$';
+  kind: 'fn$';
   req: Req;
   res: Res;
 }
@@ -291,7 +296,7 @@ export type JsonSchema =
 
 export type Schema = JsonSchema | RefSchema | OrSchema | AnySchema | FunctionSchema | FunctionStreamingSchema;
 
-export type NoT<T extends TType> = Omit<T, '__t'>;
+export type NoT<T extends TType> = Omit<T, 'kind'>;
 
 export type TypeOf<T> =
   T extends OrSchema<any>
diff --git a/src/json-type/schema/validate.ts b/src/json-type/schema/validate.ts
index 774ec872ce..459006fbec 100644
--- a/src/json-type/schema/validate.ts
+++ b/src/json-type/schema/validate.ts
@@ -11,11 +11,11 @@ export const validateTExample = (example: TExample): void => {
   validateDisplay(example);
 };
 
-export const validateTType = (tType: TType, __t: string): void => {
+export const validateTType = (tType: TType, kind: string): void => {
   validateDisplay(tType);
   const {id} = tType;
   if (id !== undefined && typeof id !== 'string') throw new Error('INVALID_ID');
-  if (tType.__t !== __t) throw new Error('INVALID_TYPE');
+  if (tType.kind !== kind) throw new Error('INVALID_TYPE');
   const {examples} = tType;
   if (examples) {
     if (!Array.isArray(examples)) throw new Error('INVALID_EXAMPLES');
diff --git a/src/json-type/type/TypeBuilder.ts b/src/json-type/type/TypeBuilder.ts
index b9ca165017..c8857f6bbc 100644
--- a/src/json-type/type/TypeBuilder.ts
+++ b/src/json-type/type/TypeBuilder.ts
@@ -165,7 +165,7 @@ export class TypeBuilder {
   }
 
   public import(node: schema.Schema): Type {
-    switch (node.__t) {
+    switch (node.kind) {
       case 'any':
         return this.Any(node);
       case 'bool':
@@ -196,7 +196,7 @@ export class TypeBuilder {
       case 'ref':
         return this.Ref(node.ref).options(node);
     }
-    throw new Error(`UNKNOWN_NODE [${node.__t}]`);
+    throw new Error(`UNKNOWN_NODE [${node.kind}]`);
   }
 
   public from(value: unknown): Type {
diff --git a/src/json-type/type/__tests__/TypeBuilder.spec.ts b/src/json-type/type/__tests__/TypeBuilder.spec.ts
index a531eb5529..744ee1e98c 100644
--- a/src/json-type/type/__tests__/TypeBuilder.spec.ts
+++ b/src/json-type/type/__tests__/TypeBuilder.spec.ts
@@ -8,7 +8,7 @@ test('number', () => {
     format: 'i32',
   });
   expect(type.getSchema()).toStrictEqual({
-    __t: 'num',
+    kind: 'num',
     description: 'A number',
     format: 'i32',
   });
@@ -17,10 +17,10 @@ test('number', () => {
 test('can construct a array type', () => {
   const type = t.Array(t.Or(t.num, t.str.options({title: 'Just a string'})));
   expect(type.getSchema()).toStrictEqual({
-    __t: 'arr',
+    kind: 'arr',
     type: {
-      __t: 'or',
-      types: [{__t: 'num'}, {__t: 'str', title: 'Just a string'}],
+      kind: 'or',
+      types: [{kind: 'num'}, {kind: 'str', title: 'Just a string'}],
       discriminator: expect.any(Array),
     },
   });
@@ -29,10 +29,10 @@ test('can construct a array type', () => {
 test('array of any with options', () => {
   const type = t.Array(t.any.options({description: 'Any type'})).options({intro: 'An array of any type'});
   expect(type.getSchema()).toStrictEqual({
-    __t: 'arr',
+    kind: 'arr',
     intro: 'An array of any type',
     type: {
-      __t: 'any',
+      kind: 'any',
       description: 'Any type',
     },
   });
@@ -46,12 +46,12 @@ test('can construct a realistic object', () => {
     t.prop('verified', t.bool),
   );
   expect(type.getSchema()).toStrictEqual({
-    __t: 'obj',
+    kind: 'obj',
     fields: [
-      {__t: 'field', key: 'id', type: {__t: 'str'}},
-      {__t: 'field', key: 'name', type: {__t: 'str'}, optional: true},
-      {__t: 'field', key: 'age', type: {__t: 'num'}, optional: true},
-      {__t: 'field', key: 'verified', type: {__t: 'bool'}},
+      {kind: 'field', key: 'id', type: {kind: 'str'}},
+      {kind: 'field', key: 'name', type: {kind: 'str'}, optional: true},
+      {kind: 'field', key: 'age', type: {kind: 'num'}, optional: true},
+      {kind: 'field', key: 'verified', type: {kind: 'bool'}},
     ],
   });
   type T = TypeOf<SchemaOf<typeof type>>;
@@ -64,14 +64,14 @@ test('can construct a realistic object', () => {
 describe('import()', () => {
   test('can import a number schema', () => {
     const type = t.import({
-      __t: 'num',
+      kind: 'num',
       description: 'A number',
       format: 'i32',
     });
     expect(type).toBeInstanceOf(NumberType);
     expect(type.getTypeName()).toBe('num');
     expect(type.getSchema()).toStrictEqual({
-      __t: 'num',
+      kind: 'num',
       description: 'A number',
       format: 'i32',
     });
@@ -79,12 +79,12 @@ describe('import()', () => {
 
   test('can import an object schema', () => {
     const type = t.import({
-      __t: 'obj',
+      kind: 'obj',
       fields: [
-        {__t: 'field', key: 'id', type: {__t: 'str'}},
-        {__t: 'field', key: 'name', type: {__t: 'str'}, optional: true},
-        {__t: 'field', key: 'age', type: {__t: 'num'}, optional: true},
-        {__t: 'field', key: 'verified', type: {__t: 'bool'}},
+        {kind: 'field', key: 'id', type: {kind: 'str'}},
+        {kind: 'field', key: 'name', type: {kind: 'str'}, optional: true},
+        {kind: 'field', key: 'age', type: {kind: 'num'}, optional: true},
+        {kind: 'field', key: 'verified', type: {kind: 'bool'}},
       ],
     }) as ObjectType<any>;
     expect(type).toBeInstanceOf(ObjectType);
@@ -95,12 +95,12 @@ describe('import()', () => {
     expect(id.value).toBeInstanceOf(StringType);
     expect(id.value.getTypeName()).toBe('str');
     expect(type.getSchema()).toStrictEqual({
-      __t: 'obj',
+      kind: 'obj',
       fields: [
-        {__t: 'field', key: 'id', type: {__t: 'str'}},
-        {__t: 'field', key: 'name', type: {__t: 'str'}, optional: true},
-        {__t: 'field', key: 'age', type: {__t: 'num'}, optional: true},
-        {__t: 'field', key: 'verified', type: {__t: 'bool'}},
+        {kind: 'field', key: 'id', type: {kind: 'str'}},
+        {kind: 'field', key: 'name', type: {kind: 'str'}, optional: true},
+        {kind: 'field', key: 'age', type: {kind: 'num'}, optional: true},
+        {kind: 'field', key: 'verified', type: {kind: 'bool'}},
       ],
     });
   });
@@ -109,7 +109,7 @@ describe('import()', () => {
 describe('validateSchema()', () => {
   test('can validate a number schema', () => {
     const schema = {
-      __t: 'num',
+      kind: 'num',
       description: 'A number',
       format: 'i32',
     };
@@ -148,7 +148,7 @@ describe('validateSchema()', () => {
 
   test('can validate a string schema', () => {
     const schema = {
-      __t: 'str',
+      kind: 'str',
       description: 'A string',
     };
     expect(t.import(schema as any).validateSchema()).toBeUndefined();
@@ -201,25 +201,25 @@ describe('validateSchema()', () => {
 
   test('validates array elements', () => {
     const type = t.import({
-      __t: 'arr',
+      kind: 'arr',
       description: 'An array',
-      type: {__t: 'str', ascii: 'bytes'},
+      type: {kind: 'str', ascii: 'bytes'},
     });
     expect(() => type.validateSchema()).toThrowErrorMatchingInlineSnapshot(`"ASCII"`);
   });
 
   test('validates array elements', () => {
     const type = t.import({
-      __t: 'arr',
+      kind: 'arr',
       description: 'An array',
-      type: {__t: 'str', ascii: 'bytes'},
+      type: {kind: 'str', ascii: 'bytes'},
     });
     expect(() => type.validateSchema()).toThrowErrorMatchingInlineSnapshot(`"ASCII"`);
   });
 
   test('validates object', () => {
     const type = t.import({
-      __t: 'obj',
+      kind: 'obj',
       description: 'An object',
       fields: [],
       unknownFields: 123 as any,
@@ -229,33 +229,33 @@ describe('validateSchema()', () => {
 
   test('validates object fields', () => {
     const type = t.import({
-      __t: 'obj',
+      kind: 'obj',
       description: 'An object',
-      fields: [{__t: 'field', key: 'id', type: {__t: 'str', ascii: 'bytes'} as any}],
+      fields: [{kind: 'field', key: 'id', type: {kind: 'str', ascii: 'bytes'} as any}],
     });
     expect(() => type.validateSchema()).toThrowErrorMatchingInlineSnapshot(`"ASCII"`);
   });
 
   test('validates object fields - 2', () => {
     const type = t.import({
-      __t: 'obj',
+      kind: 'obj',
       description: 'An object',
-      fields: [{__t: 'field', key: 'id', optional: 123, type: {__t: 'str'}} as any],
+      fields: [{kind: 'field', key: 'id', optional: 123, type: {kind: 'str'}} as any],
     });
     expect(() => type.validateSchema()).toThrowErrorMatchingInlineSnapshot(`"OPTIONAL_TYPE"`);
   });
 
   test('validates ref', () => {
     const type = t.import({
-      __t: 'ref',
+      kind: 'ref',
     } as any);
     expect(() => type.validateSchema()).toThrowErrorMatchingInlineSnapshot(`"REF_TYPE"`);
   });
 
   test('validates or', () => {
     const type = t.import({
-      __t: 'or',
-      types: [{__t: 'str', ascii: '123'} as any],
+      kind: 'or',
+      types: [{kind: 'str', ascii: '123'} as any],
       discriminator: ['!', 0],
     });
     expect(() => type.validateSchema()).toThrowErrorMatchingInlineSnapshot(`"ASCII"`);
diff --git a/src/json-type/type/__tests__/fixtures.ts b/src/json-type/type/__tests__/fixtures.ts
index 5f821be0e5..8154c75a38 100644
--- a/src/json-type/type/__tests__/fixtures.ts
+++ b/src/json-type/type/__tests__/fixtures.ts
@@ -2,50 +2,50 @@ import {TypeOf} from '../../schema';
 import {SchemaOf, t} from '..';
 
 export const everyType = t.Object(
-  t.prop('id', t.str.options({noJsonEscape: true})),
-  t.prop('bin', t.bin),
-  t.prop('bool', t.bool),
-  t.prop('nil', t.nil),
-  t.prop('num', t.num),
-  t.prop('str', t.str),
-  t.prop('arr', t.arr),
-  t.prop('obj', t.obj),
-  t.prop('any', t.any),
+  // t.prop('id', t.str.options({noJsonEscape: true})),
+  // t.prop('bin', t.bin),
+  // t.prop('bool', t.bool),
+  // t.prop('nil', t.nil),
+  // t.prop('num', t.num),
+  // t.prop('str', t.str),
+  // t.prop('arr', t.arr),
+  // t.prop('obj', t.obj),
+  // t.prop('any', t.any),
   t.prop('undef', t.undef),
-  t.prop('const', t.Const(<const>'const')),
-  t.prop('const2', t.Const(<const>2)),
-  t.prop('emptyArray', t.arr.options({max: 0})),
-  t.prop('oneItemArray', t.arr.options({min: 1, max: 1})),
-  t.prop('objWithArray', t.Object(t.propOpt('arr', t.arr), t.propOpt('arr2', t.arr))),
-  t.prop('emptyMap', t.map),
-  t.prop('mapWithOneNumField', t.Map(t.num)),
-  t.prop('mapOfStr', t.Map(t.str)),
+  // t.prop('const', t.Const(<const>'const')),
+  // t.prop('const2', t.Const(<const>2)),
+  // t.prop('emptyArray', t.arr.options({max: 0})),
+  // t.prop('oneItemArray', t.arr.options({min: 1, max: 1})),
+  // t.prop('objWithArray', t.Object(t.propOpt('arr', t.arr), t.propOpt('arr2', t.arr))),
+  // t.prop('emptyMap', t.map),
+  // t.prop('mapWithOneNumField', t.Map(t.num)),
+  // t.prop('mapOfStr', t.Map(t.str)),
 );
 
 export const everyTypeValue: TypeOf<SchemaOf<typeof everyType>> = {
-  id: 'asdf',
-  bin: new Uint8Array([1, 2, 3]),
-  bool: true,
-  nil: null,
-  num: 1,
-  str: 'asdf',
-  arr: [1, 2, 3],
-  obj: {},
-  any: 1,
+  // id: 'asdf',
+  // bin: new Uint8Array([1, 2, 3]),
+  // bool: true,
+  // nil: null,
+  // num: 1,
+  // str: 'asdf',
+  // arr: [1, 2, 3],
+  // obj: {},
+  // any: 1,
   undef: undefined,
-  const: 'const',
-  const2: 2,
-  emptyArray: [],
-  oneItemArray: [1],
-  objWithArray: {
-    arr: [1, 2, 3],
-  },
-  emptyMap: {},
-  mapWithOneNumField: {
-    a: 1,
-  },
-  mapOfStr: {
-    a: 'a',
-    b: 'b',
-  },
+  // const: 'const',
+  // const2: 2,
+  // emptyArray: [],
+  // oneItemArray: [1],
+  // objWithArray: {
+  //   arr: [1, 2, 3],
+  // },
+  // emptyMap: {},
+  // mapWithOneNumField: {
+  //   a: 1,
+  // },
+  // mapOfStr: {
+  //   a: 'a',
+  //   b: 'b',
+  // },
 };
diff --git a/src/json-type/type/classes/AbstractType.ts b/src/json-type/type/classes/AbstractType.ts
index 5d5c7288ba..5d0b564c73 100644
--- a/src/json-type/type/classes/AbstractType.ts
+++ b/src/json-type/type/classes/AbstractType.ts
@@ -60,8 +60,8 @@ export abstract class AbstractType<S extends schema.Schema> implements BaseType<
     return system;
   }
 
-  public getTypeName(): S['__t'] {
-    return this.schema.__t;
+  public getTypeName(): S['kind'] {
+    return this.schema.kind;
   }
 
   /**
@@ -92,7 +92,7 @@ export abstract class AbstractType<S extends schema.Schema> implements BaseType<
   }
 
   public getOptions(): schema.Optional<S> {
-    const {__t, ...options} = this.schema;
+    const {kind, ...options} = this.schema;
     return options as any;
   }
 
diff --git a/src/json-type/type/classes/ArrayType.ts b/src/json-type/type/classes/ArrayType.ts
index 4cb4da2c82..803335eb02 100644
--- a/src/json-type/type/classes/ArrayType.ts
+++ b/src/json-type/type/classes/ArrayType.ts
@@ -55,7 +55,7 @@ export class ArrayType<T extends Type> extends AbstractType<schema.ArraySchema<S
   }
 
   public getOptions(): schema.Optional<schema.ArraySchema<SchemaOf<T>>> {
-    const {__t, type, ...options} = this.schema;
+    const {kind, type, ...options} = this.schema;
     return options as any;
   }
 
diff --git a/src/json-type/type/classes/BinaryType.ts b/src/json-type/type/classes/BinaryType.ts
index b3784f9658..2c99f2bfe5 100644
--- a/src/json-type/type/classes/BinaryType.ts
+++ b/src/json-type/type/classes/BinaryType.ts
@@ -49,7 +49,7 @@ export class BinaryType<T extends Type> extends AbstractType<schema.BinarySchema
   }
 
   public getOptions(): schema.Optional<schema.ArraySchema<SchemaOf<T>>> {
-    const {__t, type, ...options} = this.schema;
+    const {kind, type, ...options} = this.schema;
     return options as any;
   }
 
diff --git a/src/json-type/type/classes/ConstType.ts b/src/json-type/type/classes/ConstType.ts
index a78898fd20..cecd80affc 100644
--- a/src/json-type/type/classes/ConstType.ts
+++ b/src/json-type/type/classes/ConstType.ts
@@ -44,7 +44,7 @@ export class ConstType<V = any> extends AbstractType<schema.ConstSchema<V>> {
   }
 
   public getOptions(): schema.Optional<schema.ConstSchema<V>> {
-    const {__t, value, ...options} = this.schema;
+    const {kind, value, ...options} = this.schema;
     return options as any;
   }
 
diff --git a/src/json-type/type/classes/MapType.ts b/src/json-type/type/classes/MapType.ts
index f891a56668..ee5afb1f13 100644
--- a/src/json-type/type/classes/MapType.ts
+++ b/src/json-type/type/classes/MapType.ts
@@ -52,7 +52,7 @@ export class MapType<T extends Type> extends AbstractType<schema.MapSchema<Schem
   }
 
   public getOptions(): schema.Optional<schema.MapSchema<SchemaOf<T>>> {
-    const {__t, type, ...options} = this.schema;
+    const {kind, type, ...options} = this.schema;
     return options as any;
   }
 
diff --git a/src/json-type/type/classes/ObjectType.ts b/src/json-type/type/classes/ObjectType.ts
index 9029cc229b..e3e61823de 100644
--- a/src/json-type/type/classes/ObjectType.ts
+++ b/src/json-type/type/classes/ObjectType.ts
@@ -57,7 +57,7 @@ export class ObjectFieldType<K extends string, V extends Type> extends AbstractT
   }
 
   public getOptions(): schema.Optional<schema.ObjectFieldSchema<K, SchemaOf<V>>> {
-    const {__t, key, type, optional, ...options} = this.schema;
+    const {kind, key, type, optional, ...options} = this.schema;
     return options as any;
   }
 
@@ -128,7 +128,7 @@ export class ObjectType<F extends ObjectFieldType<any, any>[] = ObjectFieldType<
   }
 
   public getOptions(): schema.Optional<schema.ObjectSchema<SchemaOfObjectFields<F>>> {
-    const {__t, fields, ...options} = this.schema;
+    const {kind, fields, ...options} = this.schema;
     return options as any;
   }
 
@@ -180,9 +180,9 @@ export class ObjectType<F extends ObjectFieldType<any, any>[] = ObjectFieldType<
         field.value.codegenValidator(ctx, keyPath, rv);
         ctx.js(`}`);
       } else {
-        ctx.js(/* js */ `var ${rv} = ${r}${accessor};`);
-        if (!canSkipObjectKeyUndefinedCheck((field.value as AbstractType<any>).getSchema().__t)) {
+        if (!canSkipObjectKeyUndefinedCheck((field.value as AbstractType<any>).getSchema().kind)) {
           const err = ctx.err(ValidationError.KEY, [...path, field.key]);
+          ctx.js(/* js */ `var ${rv} = ${r}${accessor};`);
           ctx.js(/* js */ `if (${rv} === undefined) return ${err};`);
         }
         field.value.codegenValidator(ctx, keyPath, `${r}${accessor}`);
@@ -554,7 +554,7 @@ if (${rLength}) {
   }
 
   public toString(tab: string = ''): string {
-    const {__t, fields, ...rest} = this.getSchema();
+    const {kind, fields, ...rest} = this.getSchema();
     return (
       super.toString(tab) +
       printTree(
diff --git a/src/json-type/type/classes/OrType.ts b/src/json-type/type/classes/OrType.ts
index 3b5cde4bef..a9e7d93626 100644
--- a/src/json-type/type/classes/OrType.ts
+++ b/src/json-type/type/classes/OrType.ts
@@ -29,7 +29,7 @@ export class OrType<T extends Type[]> extends AbstractType<schema.OrSchema<{[K i
 
   constructor(
     protected types: T,
-    options?: Omit<schema.OrSchema, '__t' | 'type'>,
+    options?: Omit<schema.OrSchema, 'kind' | 'type'>,
   ) {
     super();
     this.schema = {
@@ -53,7 +53,7 @@ export class OrType<T extends Type[]> extends AbstractType<schema.OrSchema<{[K i
   }
 
   public getOptions(): schema.Optional<schema.OrSchema<{[K in keyof T]: SchemaOf<T[K]>}>> {
-    const {__t, types, ...options} = this.schema;
+    const {kind, types, ...options} = this.schema;
     return options as any;
   }
 
diff --git a/src/json-type/type/classes/RefType.ts b/src/json-type/type/classes/RefType.ts
index d2222174d6..956f18d834 100644
--- a/src/json-type/type/classes/RefType.ts
+++ b/src/json-type/type/classes/RefType.ts
@@ -44,7 +44,7 @@ export class RefType<T extends Type> extends AbstractType<schema.RefSchema<Schem
   }
 
   public getOptions(): schema.Optional<schema.RefSchema<SchemaOf<T>>> {
-    const {__t, ref, ...options} = this.schema;
+    const {kind, ref, ...options} = this.schema;
     return options as any;
   }
 
diff --git a/src/json-type/type/classes/TupleType.ts b/src/json-type/type/classes/TupleType.ts
index 8391c13c98..eee33adb17 100644
--- a/src/json-type/type/classes/TupleType.ts
+++ b/src/json-type/type/classes/TupleType.ts
@@ -24,7 +24,7 @@ export class TupleType<T extends Type[]> extends AbstractType<schema.TupleSchema
 
   constructor(
     public readonly types: T,
-    options?: Omit<schema.TupleSchema, '__t' | 'type'>,
+    options?: Omit<schema.TupleSchema, 'kind' | 'type'>,
   ) {
     super();
     this.schema = {...schema.s.Tuple(), ...options};
@@ -48,7 +48,7 @@ export class TupleType<T extends Type[]> extends AbstractType<schema.TupleSchema
   }
 
   public getOptions(): schema.Optional<schema.TupleSchema<{[K in keyof T]: SchemaOf<T[K]>}>> {
-    const {__t, types, ...options} = this.schema;
+    const {kind, types, ...options} = this.schema;
     return options as any;
   }