schematox 1.2.1 → 1.2.2-alpha

package/src/tests/by-struct/record.test.ts

@@ -0,0 +1,1802 @@
+import * as x from '../../'
+import * as fixture from '../fixtures'
+
+import type { StructSharedKeys } from '../type'
+
+describe('Type inference and parse by schema/construct/struct (foldA)', () => {
+  it('branded key', () => {
+    const schema = {
+      type: 'record',
+      key: { type: 'string', brand: ['x', 'y'] },
+      of: { type: 'boolean' },
+    } as const satisfies x.Schema
+
+    const struct = x.record(x.boolean(), x.string().brand('x', 'y'))
+
+    type Key = string & { __x: 'y' }
+    type ExpectedSubj = Record<Key, boolean>
+
+    const subjects: Array<ExpectedSubj> = [
+      {},
+      // @ts-expect-error must not allow not branded string key declaration
+      { ['x']: true },
+      { ['x' as Key]: false },
+    ]
+
+    // @ts-expect-error must not allow not branded string property access
+    subjects[1]!['x'] = false
+
+    foldA: {
+      const construct = x.makeStruct(schema)
+
+      /* ensure that schema/construct/struct/~standard subject types are identical */
+
+      type ConstructSchemaSubj = x.Infer<typeof construct.__schema>
+
+      x.tCh<ConstructSchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, ConstructSchemaSubj>()
+
+      type SchemaSubj = x.Infer<typeof schema>
+
+      x.tCh<SchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, SchemaSubj>()
+
+      type StructSubj = x.Infer<typeof struct.__schema>
+
+      x.tCh<StructSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StructSubj>()
+
+      type StandardSubj = NonNullable<
+        (typeof struct)['~standard']['types']
+      >['output']
+
+      x.tCh<StandardSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardSubj>()
+
+      /* parsed either type check */
+
+      type ExpectedParsed = x.ParseResult<ExpectedSubj>
+
+      const parsed = x.parse(schema, undefined)
+
+      type SchemaParsed = typeof parsed
+
+      x.tCh<SchemaParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, SchemaParsed>()
+
+      type ConstructParsed = ReturnType<typeof construct.parse>
+
+      x.tCh<ConstructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, ConstructParsed>()
+
+      type StructParsed = ReturnType<typeof struct.parse>
+
+      x.tCh<StructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, StructParsed>()
+
+      type StandardParsed = Extract<
+        ReturnType<(typeof struct)['~standard']['validate']>,
+        { value: unknown }
+      >['value']
+
+      x.tCh<StandardParsed, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardParsed>()
+
+      /* runtime schema check */
+
+      expect(struct.__schema).toStrictEqual(schema)
+      expect(construct.__schema).toStrictEqual(schema)
+      expect(construct.__schema === schema).toBe(false)
+
+      /* parse result check */
+
+      for (const subj of subjects) {
+        const schemaParsed = x.parse(schema, subj)
+
+        expect(schemaParsed.error).toBe(undefined)
+        expect(schemaParsed.data).toStrictEqual(subj)
+
+        const constructParsed = construct.parse(subj)
+
+        expect(constructParsed.error).toBe(undefined)
+        expect(constructParsed.data).toStrictEqual(subj)
+
+        const structParsed = struct.parse(subj)
+
+        expect(structParsed.error).toBe(undefined)
+        expect(structParsed.data).toStrictEqual(subj)
+
+        const standardParsed = struct['~standard'].validate(subj)
+
+        if (standardParsed instanceof Promise) {
+          throw Error('Not expected')
+        }
+
+        if (standardParsed.issues !== undefined) {
+          throw Error('not expected')
+        }
+
+        expect(standardParsed.value).toStrictEqual(subj)
+      }
+    }
+  })
+
+  it('required', () => {
+    const schema = {
+      type: 'record',
+      of: { type: 'boolean' },
+    } as const satisfies x.Schema
+
+    const struct = x.record(x.boolean())
+
+    type ExpectedSubj = Record<string, boolean>
+
+    const subjects: Array<ExpectedSubj> = [{}, { x: true }, { x: false }]
+
+    foldA: {
+      const construct = x.makeStruct(schema)
+
+      /* ensure that schema/construct/struct/~standard subject types are identical */
+
+      type ConstructSchemaSubj = x.Infer<typeof construct.__schema>
+
+      x.tCh<ConstructSchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, ConstructSchemaSubj>()
+
+      type SchemaSubj = x.Infer<typeof schema>
+
+      x.tCh<SchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, SchemaSubj>()
+
+      type StructSubj = x.Infer<typeof struct.__schema>
+
+      x.tCh<StructSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StructSubj>()
+
+      type StandardSubj = NonNullable<
+        (typeof struct)['~standard']['types']
+      >['output']
+
+      x.tCh<StandardSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardSubj>()
+
+      /* parsed either type check */
+
+      type ExpectedParsed = x.ParseResult<ExpectedSubj>
+
+      const parsed = x.parse(schema, undefined)
+
+      type SchemaParsed = typeof parsed
+
+      x.tCh<SchemaParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, SchemaParsed>()
+
+      type ConstructParsed = ReturnType<typeof construct.parse>
+
+      x.tCh<ConstructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, ConstructParsed>()
+
+      type StructParsed = ReturnType<typeof struct.parse>
+
+      x.tCh<StructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, StructParsed>()
+
+      type StandardParsed = Extract<
+        ReturnType<(typeof struct)['~standard']['validate']>,
+        { value: unknown }
+      >['value']
+
+      x.tCh<StandardParsed, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardParsed>()
+
+      /* runtime schema check */
+
+      expect(struct.__schema).toStrictEqual(schema)
+      expect(construct.__schema).toStrictEqual(schema)
+      expect(construct.__schema === schema).toBe(false)
+
+      /* parse result check */
+
+      for (const subj of subjects) {
+        const schemaParsed = x.parse(schema, subj)
+
+        expect(schemaParsed.error).toBe(undefined)
+        expect(schemaParsed.data).toStrictEqual(subj)
+
+        const constructParsed = construct.parse(subj)
+
+        expect(constructParsed.error).toBe(undefined)
+        expect(constructParsed.data).toStrictEqual(subj)
+
+        const structParsed = struct.parse(subj)
+
+        expect(structParsed.error).toBe(undefined)
+        expect(structParsed.data).toStrictEqual(subj)
+
+        const standardParsed = struct['~standard'].validate(subj)
+
+        if (standardParsed instanceof Promise) {
+          throw Error('Not expected')
+        }
+
+        if (standardParsed.issues !== undefined) {
+          throw Error('not expected')
+        }
+
+        expect(standardParsed.value).toStrictEqual(subj)
+      }
+    }
+  })
+
+  it('optional', () => {
+    const schema = {
+      type: 'record',
+      of: { type: 'boolean' },
+      optional: true,
+    } as const satisfies x.Schema
+
+    const struct = x.record(x.boolean()).optional()
+
+    type ExpectedSubj = Record<string, boolean> | undefined
+
+    const subjects: Array<ExpectedSubj> = [{}, { x: true }]
+
+    foldA: {
+      const construct = x.makeStruct(schema)
+
+      /* ensure that schema/construct/struct/~standard subject types are identical */
+
+      type ConstructSchemaSubj = x.Infer<typeof construct.__schema>
+
+      x.tCh<ConstructSchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, ConstructSchemaSubj>()
+
+      type SchemaSubj = x.Infer<typeof schema>
+
+      x.tCh<SchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, SchemaSubj>()
+
+      type StructSubj = x.Infer<typeof struct.__schema>
+
+      x.tCh<StructSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StructSubj>()
+
+      type StandardSubj = NonNullable<
+        (typeof struct)['~standard']['types']
+      >['output']
+
+      x.tCh<StandardSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardSubj>()
+
+      /* parsed either type check */
+
+      type ExpectedParsed = x.ParseResult<ExpectedSubj>
+
+      const parsed = x.parse(schema, undefined)
+
+      type SchemaParsed = typeof parsed
+
+      x.tCh<SchemaParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, SchemaParsed>()
+
+      type ConstructParsed = ReturnType<typeof construct.parse>
+
+      x.tCh<ConstructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, ConstructParsed>()
+
+      type StructParsed = ReturnType<typeof struct.parse>
+
+      x.tCh<StructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, StructParsed>()
+
+      type StandardParsed = Extract<
+        ReturnType<(typeof struct)['~standard']['validate']>,
+        { value: unknown }
+      >['value']
+
+      x.tCh<StandardParsed, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardParsed>()
+
+      /* runtime schema check */
+
+      expect(struct.__schema).toStrictEqual(schema)
+      expect(construct.__schema).toStrictEqual(schema)
+      expect(construct.__schema === schema).toBe(false)
+
+      /* parse result check */
+
+      for (const subj of subjects) {
+        const schemaParsed = x.parse(schema, subj)
+
+        expect(schemaParsed.error).toBe(undefined)
+        expect(schemaParsed.data).toStrictEqual(subj)
+
+        const constructParsed = construct.parse(subj)
+
+        expect(constructParsed.error).toBe(undefined)
+        expect(constructParsed.data).toStrictEqual(subj)
+
+        const structParsed = struct.parse(subj)
+
+        expect(structParsed.error).toBe(undefined)
+        expect(structParsed.data).toStrictEqual(subj)
+
+        const standardParsed = struct['~standard'].validate(subj)
+
+        if (standardParsed instanceof Promise) {
+          throw Error('Not expected')
+        }
+
+        if (standardParsed.issues !== undefined) {
+          throw Error('not expected')
+        }
+
+        expect(standardParsed.value).toStrictEqual(subj)
+      }
+    }
+  })
+
+  it('nullable', () => {
+    const schema = {
+      type: 'record',
+      of: { type: 'boolean' },
+      nullable: true,
+    } as const satisfies x.Schema
+
+    const struct = x.record(x.boolean()).nullable()
+
+    type ExpectedSubj = Record<string, boolean> | null
+
+    const subjects: Array<ExpectedSubj> = [{ x: true }, null]
+
+    foldA: {
+      const construct = x.makeStruct(schema)
+
+      /* ensure that schema/construct/struct/~standard subject types are identical */
+
+      type ConstructSchemaSubj = x.Infer<typeof construct.__schema>
+
+      x.tCh<ConstructSchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, ConstructSchemaSubj>()
+
+      type SchemaSubj = x.Infer<typeof schema>
+
+      x.tCh<SchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, SchemaSubj>()
+
+      type StructSubj = x.Infer<typeof struct.__schema>
+
+      x.tCh<StructSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StructSubj>()
+
+      type StandardSubj = NonNullable<
+        (typeof struct)['~standard']['types']
+      >['output']
+
+      x.tCh<StandardSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardSubj>()
+
+      /* parsed either type check */
+
+      type ExpectedParsed = x.ParseResult<ExpectedSubj>
+
+      const parsed = x.parse(schema, undefined)
+
+      type SchemaParsed = typeof parsed
+
+      x.tCh<SchemaParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, SchemaParsed>()
+
+      type ConstructParsed = ReturnType<typeof construct.parse>
+
+      x.tCh<ConstructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, ConstructParsed>()
+
+      type StructParsed = ReturnType<typeof struct.parse>
+
+      x.tCh<StructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, StructParsed>()
+
+      type StandardParsed = Extract<
+        ReturnType<(typeof struct)['~standard']['validate']>,
+        { value: unknown }
+      >['value']
+
+      x.tCh<StandardParsed, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardParsed>()
+
+      /* runtime schema check */
+
+      expect(struct.__schema).toStrictEqual(schema)
+      expect(construct.__schema).toStrictEqual(schema)
+      expect(construct.__schema === schema).toBe(false)
+
+      /* parse result check */
+
+      for (const subj of subjects) {
+        const schemaParsed = x.parse(schema, subj)
+
+        expect(schemaParsed.error).toBe(undefined)
+        expect(schemaParsed.data).toStrictEqual(subj)
+
+        const constructParsed = construct.parse(subj)
+
+        expect(constructParsed.error).toBe(undefined)
+        expect(constructParsed.data).toStrictEqual(subj)
+
+        const structParsed = struct.parse(subj)
+
+        expect(structParsed.error).toBe(undefined)
+        expect(structParsed.data).toStrictEqual(subj)
+
+        const standardParsed = struct['~standard'].validate(subj)
+
+        if (standardParsed instanceof Promise) {
+          throw Error('Not expected')
+        }
+
+        if (standardParsed.issues !== undefined) {
+          throw Error('not expected')
+        }
+
+        expect(standardParsed.value).toStrictEqual(subj)
+      }
+    }
+  })
+
+  it('minLength', () => {
+    const schema = {
+      type: 'record',
+      of: { type: 'boolean' },
+      minLength: 2,
+    } as const satisfies x.Schema
+
+    const struct = x.record(x.boolean()).minLength(schema.minLength)
+
+    type ExpectedSubj = Record<string, boolean>
+
+    const subjects: Array<ExpectedSubj> = [
+      { 0: true, 1: false },
+      { 0: true, 1: false, 3: true },
+    ]
+
+    foldA: {
+      const construct = x.makeStruct(schema)
+
+      /* ensure that schema/construct/struct/~standard subject types are identical */
+
+      type ConstructSchemaSubj = x.Infer<typeof construct.__schema>
+
+      x.tCh<ConstructSchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, ConstructSchemaSubj>()
+
+      type SchemaSubj = x.Infer<typeof schema>
+
+      x.tCh<SchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, SchemaSubj>()
+
+      type StructSubj = x.Infer<typeof struct.__schema>
+
+      x.tCh<StructSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StructSubj>()
+
+      type StandardSubj = NonNullable<
+        (typeof struct)['~standard']['types']
+      >['output']
+
+      x.tCh<StandardSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardSubj>()
+
+      /* parsed either type check */
+
+      type ExpectedParsed = x.ParseResult<ExpectedSubj>
+
+      const parsed = x.parse(schema, undefined)
+
+      type SchemaParsed = typeof parsed
+
+      x.tCh<SchemaParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, SchemaParsed>()
+
+      type ConstructParsed = ReturnType<typeof construct.parse>
+
+      x.tCh<ConstructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, ConstructParsed>()
+
+      type StructParsed = ReturnType<typeof struct.parse>
+
+      x.tCh<StructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, StructParsed>()
+
+      type StandardParsed = Extract<
+        ReturnType<(typeof struct)['~standard']['validate']>,
+        { value: unknown }
+      >['value']
+
+      x.tCh<StandardParsed, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardParsed>()
+
+      /* runtime schema check */
+
+      expect(struct.__schema).toStrictEqual(schema)
+      expect(construct.__schema).toStrictEqual(schema)
+      expect(construct.__schema === schema).toBe(false)
+
+      /* parse result check */
+
+      for (const subj of subjects) {
+        const schemaParsed = x.parse(schema, subj)
+
+        expect(schemaParsed.error).toBe(undefined)
+        expect(schemaParsed.data).toStrictEqual(subj)
+
+        const constructParsed = construct.parse(subj)
+
+        expect(constructParsed.error).toBe(undefined)
+        expect(constructParsed.data).toStrictEqual(subj)
+
+        const structParsed = struct.parse(subj)
+
+        expect(structParsed.error).toBe(undefined)
+        expect(structParsed.data).toStrictEqual(subj)
+
+        const standardParsed = struct['~standard'].validate(subj)
+
+        if (standardParsed instanceof Promise) {
+          throw Error('Not expected')
+        }
+
+        if (standardParsed.issues !== undefined) {
+          throw Error('not expected')
+        }
+
+        expect(standardParsed.value).toStrictEqual(subj)
+      }
+    }
+  })
+
+  it('maxLength', () => {
+    const schema = {
+      type: 'record',
+      of: { type: 'boolean' },
+      maxLength: 3,
+    } as const satisfies x.Schema
+
+    const struct = x.record(x.boolean()).maxLength(schema.maxLength)
+
+    type ExpectedSubj = Record<string, boolean>
+
+    const subjects: Array<ExpectedSubj> = [
+      {},
+      { 0: true },
+      { 0: true, 1: false },
+      { 0: true, 1: false, 2: true },
+    ]
+
+    foldA: {
+      const construct = x.makeStruct(schema)
+
+      /* ensure that schema/construct/struct/~standard subject types are identical */
+
+      type ConstructSchemaSubj = x.Infer<typeof construct.__schema>
+
+      x.tCh<ConstructSchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, ConstructSchemaSubj>()
+
+      type SchemaSubj = x.Infer<typeof schema>
+
+      x.tCh<SchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, SchemaSubj>()
+
+      type StructSubj = x.Infer<typeof struct.__schema>
+
+      x.tCh<StructSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StructSubj>()
+
+      type StandardSubj = NonNullable<
+        (typeof struct)['~standard']['types']
+      >['output']
+
+      x.tCh<StandardSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardSubj>()
+
+      /* parsed either type check */
+
+      type ExpectedParsed = x.ParseResult<ExpectedSubj>
+
+      const parsed = x.parse(schema, undefined)
+
+      type SchemaParsed = typeof parsed
+
+      x.tCh<SchemaParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, SchemaParsed>()
+
+      type ConstructParsed = ReturnType<typeof construct.parse>
+
+      x.tCh<ConstructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, ConstructParsed>()
+
+      type StructParsed = ReturnType<typeof struct.parse>
+
+      x.tCh<StructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, StructParsed>()
+
+      type StandardParsed = Extract<
+        ReturnType<(typeof struct)['~standard']['validate']>,
+        { value: unknown }
+      >['value']
+
+      x.tCh<StandardParsed, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardParsed>()
+
+      /* runtime schema check */
+
+      expect(struct.__schema).toStrictEqual(schema)
+      expect(construct.__schema).toStrictEqual(schema)
+      expect(construct.__schema === schema).toBe(false)
+
+      /* parse result check */
+
+      for (const subj of subjects) {
+        const schemaParsed = x.parse(schema, subj)
+
+        expect(schemaParsed.error).toBe(undefined)
+        expect(schemaParsed.data).toStrictEqual(subj)
+
+        const constructParsed = construct.parse(subj)
+
+        expect(constructParsed.error).toBe(undefined)
+        expect(constructParsed.data).toStrictEqual(subj)
+
+        const structParsed = struct.parse(subj)
+
+        expect(structParsed.error).toBe(undefined)
+        expect(structParsed.data).toStrictEqual(subj)
+
+        const standardParsed = struct['~standard'].validate(subj)
+
+        if (standardParsed instanceof Promise) {
+          throw Error('Not expected')
+        }
+
+        if (standardParsed.issues !== undefined) {
+          throw Error('not expected')
+        }
+
+        expect(standardParsed.value).toStrictEqual(subj)
+      }
+    }
+  })
+
+  it('optional + nullable + minLength + maxLength + branded key', () => {
+    const schema = {
+      type: 'record',
+      key: { type: 'string', brand: ['x', 'y'] },
+      of: { type: 'boolean' },
+      minLength: 1,
+      maxLength: 1,
+      optional: true,
+      nullable: true,
+    } as const satisfies x.Schema
+
+    const struct = x
+      .record(x.boolean(), x.string().brand('x', 'y'))
+      .minLength(1)
+      .maxLength(1)
+      .optional()
+      .nullable()
+
+    type ExpectedSubj = Record<string, boolean> | undefined | null
+
+    const subjects: Array<ExpectedSubj> = [{ x: true }, undefined, null]
+
+    foldA: {
+      const construct = x.makeStruct(schema)
+
+      /* ensure that schema/construct/struct/~standard subject types are identical */
+
+      type ConstructSchemaSubj = x.Infer<typeof construct.__schema>
+
+      x.tCh<ConstructSchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, ConstructSchemaSubj>()
+
+      type SchemaSubj = x.Infer<typeof schema>
+
+      x.tCh<SchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, SchemaSubj>()
+
+      type StructSubj = x.Infer<typeof struct.__schema>
+
+      x.tCh<StructSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StructSubj>()
+
+      type StandardSubj = NonNullable<
+        (typeof struct)['~standard']['types']
+      >['output']
+
+      x.tCh<StandardSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardSubj>()
+
+      /* parsed either type check */
+
+      type ExpectedParsed = x.ParseResult<ExpectedSubj>
+
+      const parsed = x.parse(schema, undefined)
+
+      type SchemaParsed = typeof parsed
+
+      x.tCh<SchemaParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, SchemaParsed>()
+
+      type ConstructParsed = ReturnType<typeof construct.parse>
+
+      x.tCh<ConstructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, ConstructParsed>()
+
+      type StructParsed = ReturnType<typeof struct.parse>
+
+      x.tCh<StructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, StructParsed>()
+
+      type StandardParsed = Extract<
+        ReturnType<(typeof struct)['~standard']['validate']>,
+        { value: unknown }
+      >['value']
+
+      x.tCh<StandardParsed, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardParsed>()
+
+      /* runtime schema check */
+
+      expect(struct.__schema).toStrictEqual(schema)
+      expect(construct.__schema).toStrictEqual(schema)
+      expect(construct.__schema === schema).toBe(false)
+
+      /* parse result check */
+
+      for (const subj of subjects) {
+        const schemaParsed = x.parse(schema, subj)
+
+        expect(schemaParsed.error).toBe(undefined)
+        expect(schemaParsed.data).toStrictEqual(subj)
+
+        const constructParsed = construct.parse(subj)
+
+        expect(constructParsed.error).toBe(undefined)
+        expect(constructParsed.data).toStrictEqual(subj)
+
+        const structParsed = struct.parse(subj)
+
+        expect(structParsed.error).toBe(undefined)
+        expect(structParsed.data).toStrictEqual(subj)
+
+        const standardParsed = struct['~standard'].validate(subj)
+
+        if (standardParsed instanceof Promise) {
+          throw Error('Not expected')
+        }
+
+        if (standardParsed.issues !== undefined) {
+          throw Error('not expected')
+        }
+
+        expect(standardParsed.value).toStrictEqual(subj)
+      }
+    }
+  })
+})
+
+describe('Struct parameter keys reduction and schema immutability (foldB)', () => {
+  it('optional', () => {
+    const schema = {
+      type: 'record',
+      of: { type: 'boolean' },
+      optional: true,
+    } as const satisfies x.Schema
+
+    const prevStruct = x.record(x.boolean())
+    const struct = prevStruct.optional()
+
+    type ExpectedKeys =
+      | StructSharedKeys
+      | 'description'
+      | 'nullable'
+      | 'minLength'
+      | 'maxLength'
+
+    foldB: {
+      const construct = x.makeStruct(schema)
+
+      /* ensure that struct keys are reduced after application */
+
+      type StructKeys = keyof typeof struct
+
+      x.tCh<StructKeys, ExpectedKeys>()
+      x.tCh<ExpectedKeys, StructKeys>()
+
+      type ConstructKeys = keyof typeof construct
+
+      x.tCh<ConstructKeys, ExpectedKeys>()
+      x.tCh<ExpectedKeys, ConstructKeys>()
+
+      /* ensure that construct/struct schema types are identical  */
+
+      type ExpectedSchema = typeof schema
+      type StructSchema = typeof struct.__schema
+
+      x.tCh<StructSchema, ExpectedSchema>()
+      x.tCh<ExpectedSchema, StructSchema>()
+
+      type ConstructSchema = typeof struct.__schema
+
+      x.tCh<ConstructSchema, ExpectedSchema>()
+      x.tCh<ExpectedSchema, ConstructSchema>()
+
+      /* runtime schema check */
+
+      expect(struct.__schema).toStrictEqual(schema)
+      expect(construct.__schema).toStrictEqual(schema)
+      expect(construct.__schema === schema).toBe(false)
+
+      /* runtime schema parameter application immutability check */
+
+      expect(prevStruct.__schema === struct.__schema).toBe(false)
+    }
+  })
+
+  it('optional + nullable', () => {
+    const schema = {
+      type: 'record',
+      of: { type: 'boolean' },
+      optional: true,
+      nullable: true,
+    } as const satisfies x.Schema
+
+    const prevStruct = x.record(x.boolean()).optional()
+    const struct = prevStruct.nullable()
+
+    type ExpectedKeys =
+      | StructSharedKeys
+      | 'description'
+      | 'minLength'
+      | 'maxLength'
+
+    foldB: {
+      const construct = x.makeStruct(schema)
+
+      /* ensure that struct keys are reduced after application */
+
+      type StructKeys = keyof typeof struct
+
+      x.tCh<StructKeys, ExpectedKeys>()
+      x.tCh<ExpectedKeys, StructKeys>()
+
+      type ConstructKeys = keyof typeof construct
+
+      x.tCh<ConstructKeys, ExpectedKeys>()
+      x.tCh<ExpectedKeys, ConstructKeys>()
+
+      /* ensure that construct/struct schema types are identical  */
+
+      type ExpectedSchema = typeof schema
+      type StructSchema = typeof struct.__schema
+
+      x.tCh<StructSchema, ExpectedSchema>()
+      x.tCh<ExpectedSchema, StructSchema>()
+
+      type ConstructSchema = typeof struct.__schema
+
+      x.tCh<ConstructSchema, ExpectedSchema>()
+      x.tCh<ExpectedSchema, ConstructSchema>()
+
+      /* runtime schema check */
+
+      expect(struct.__schema).toStrictEqual(schema)
+      expect(construct.__schema).toStrictEqual(schema)
+      expect(construct.__schema === schema).toBe(false)
+
+      /* runtime schema parameter application immutability check */
+
+      expect(prevStruct.__schema === struct.__schema).toBe(false)
+    }
+  })
+
+  it('optional + nullable + minLength', () => {
+    const schema = {
+      type: 'record',
+      of: { type: 'boolean' },
+      minLength: 1,
+      optional: true,
+      nullable: true,
+    } as const satisfies x.Schema
+
+    const prevStruct = x.record(x.boolean()).optional().nullable()
+    const struct = prevStruct.minLength(1)
+
+    type ExpectedKeys = StructSharedKeys | 'description' | 'maxLength'
+
+    foldB: {
+      const construct = x.makeStruct(schema)
+
+      /* ensure that struct keys are reduced after application */
+
+      type StructKeys = keyof typeof struct
+
+      x.tCh<StructKeys, ExpectedKeys>()
+      x.tCh<ExpectedKeys, StructKeys>()
+
+      type ConstructKeys = keyof typeof construct
+
+      x.tCh<ConstructKeys, ExpectedKeys>()
+      x.tCh<ExpectedKeys, ConstructKeys>()
+
+      /* ensure that construct/struct schema types are identical  */
+
+      type ExpectedSchema = typeof schema
+      type StructSchema = typeof struct.__schema
+
+      x.tCh<StructSchema, ExpectedSchema>()
+      x.tCh<ExpectedSchema, StructSchema>()
+
+      type ConstructSchema = typeof struct.__schema
+
+      x.tCh<ConstructSchema, ExpectedSchema>()
+      x.tCh<ExpectedSchema, ConstructSchema>()
+
+      /* runtime schema check */
+
+      expect(struct.__schema).toStrictEqual(schema)
+      expect(construct.__schema).toStrictEqual(schema)
+      expect(construct.__schema === schema).toBe(false)
+
+      /* runtime schema parameter application immutability check */
+
+      expect(prevStruct.__schema === struct.__schema).toBe(false)
+    }
+  })
+
+  it('optional + nullable + minLength + maxLength', () => {
+    const schema = {
+      type: 'record',
+      of: { type: 'boolean' },
+      minLength: 1,
+      maxLength: 1,
+      optional: true,
+      nullable: true,
+    } as const satisfies x.Schema
+
+    const prevStruct = x.record(x.boolean()).optional().nullable().minLength(1)
+
+    const struct = prevStruct.maxLength(1)
+
+    type ExpectedKeys = StructSharedKeys | 'description'
+
+    foldB: {
+      const construct = x.makeStruct(schema)
+
+      /* ensure that struct keys are reduced after application */
+
+      type StructKeys = keyof typeof struct
+
+      x.tCh<StructKeys, ExpectedKeys>()
+      x.tCh<ExpectedKeys, StructKeys>()
+
+      type ConstructKeys = keyof typeof construct
+
+      x.tCh<ConstructKeys, ExpectedKeys>()
+      x.tCh<ExpectedKeys, ConstructKeys>()
+
+      /* ensure that construct/struct schema types are identical  */
+
+      type ExpectedSchema = typeof schema
+      type StructSchema = typeof struct.__schema
+
+      x.tCh<StructSchema, ExpectedSchema>()
+      x.tCh<ExpectedSchema, StructSchema>()
+
+      type ConstructSchema = typeof struct.__schema
+
+      x.tCh<ConstructSchema, ExpectedSchema>()
+      x.tCh<ExpectedSchema, ConstructSchema>()
+
+      /* runtime schema check */
+
+      expect(struct.__schema).toStrictEqual(schema)
+      expect(construct.__schema).toStrictEqual(schema)
+      expect(construct.__schema === schema).toBe(false)
+
+      /* runtime schema parameter application immutability check */
+
+      expect(prevStruct.__schema === struct.__schema).toBe(false)
+    }
+  })
+
+  it('optional + nullable + minLength + maxLength + description', () => {
+    const schema = {
+      type: 'record',
+      of: { type: 'boolean' },
+      minLength: 1,
+      maxLength: 1,
+      optional: true,
+      nullable: true,
+      description: 'x',
+    } as const satisfies x.Schema
+
+    const prevStruct = x
+      .record(x.boolean())
+      .optional()
+      .minLength(1)
+      .maxLength(1)
+      .nullable()
+
+    const struct = prevStruct.description('x')
+
+    type ExpectedKeys = StructSharedKeys
+
+    foldB: {
+      const construct = x.makeStruct(schema)
+
+      /* ensure that struct keys are reduced after application */
+
+      type StructKeys = keyof typeof struct
+
+      x.tCh<StructKeys, ExpectedKeys>()
+      x.tCh<ExpectedKeys, StructKeys>()
+
+      type ConstructKeys = keyof typeof construct
+
+      x.tCh<ConstructKeys, ExpectedKeys>()
+      x.tCh<ExpectedKeys, ConstructKeys>()
+
+      /* ensure that construct/struct schema types are identical  */
+
+      type ExpectedSchema = typeof schema
+      type StructSchema = typeof struct.__schema
+
+      x.tCh<StructSchema, ExpectedSchema>()
+      x.tCh<ExpectedSchema, StructSchema>()
+
+      type ConstructSchema = typeof struct.__schema
+
+      x.tCh<ConstructSchema, ExpectedSchema>()
+      x.tCh<ExpectedSchema, ConstructSchema>()
+
+      /* runtime schema check */
+
+      expect(struct.__schema).toStrictEqual(schema)
+      expect(construct.__schema).toStrictEqual(schema)
+      expect(construct.__schema === schema).toBe(false)
+
+      /* runtime schema parameter application immutability check */
+
+      expect(prevStruct.__schema === struct.__schema).toBe(false)
+    }
+  })
+
+  it('description + maxLength + minLength + nullable + optional', () => {
+    const schema = {
+      type: 'record',
+      of: { type: 'boolean' },
+      minLength: 1,
+      maxLength: 1,
+      optional: true,
+      nullable: true,
+      description: 'x',
+    } as const satisfies x.Schema
+
+    const prevStruct = x
+      .record(x.boolean())
+      .minLength(1)
+      .maxLength(1)
+      .description(schema.description)
+      .nullable()
+
+    const struct = prevStruct.optional()
+
+    type ExpectedKeys = StructSharedKeys
+
+    foldB: {
+      const construct = x.makeStruct(schema)
+
+      /* ensure that struct keys are reduced after application */
+
+      type StructKeys = keyof typeof struct
+
+      x.tCh<StructKeys, ExpectedKeys>()
+      x.tCh<ExpectedKeys, StructKeys>()
+
+      type ConstructKeys = keyof typeof construct
+
+      x.tCh<ConstructKeys, ExpectedKeys>()
+      x.tCh<ExpectedKeys, ConstructKeys>()
+
+      /* ensure that construct/struct schema types are identical  */
+
+      type ExpectedSchema = typeof schema
+      type StructSchema = typeof struct.__schema
+
+      x.tCh<StructSchema, ExpectedSchema>()
+      x.tCh<ExpectedSchema, StructSchema>()
+
+      type ConstructSchema = typeof struct.__schema
+
+      x.tCh<ConstructSchema, ExpectedSchema>()
+      x.tCh<ExpectedSchema, ConstructSchema>()
+
+      /* runtime schema check */
+
+      expect(struct.__schema).toStrictEqual(schema)
+      expect(construct.__schema).toStrictEqual(schema)
+      expect(construct.__schema === schema).toBe(false)
+
+      /* runtime schema parameter application immutability check */
+
+      expect(prevStruct.__schema === struct.__schema).toBe(false)
+    }
+  })
+})
+
+describe('ERROR_CODE.invalidType (foldC, foldE)', () => {
+  it('iterate over fixture.DATA_TYPE', () => {
+    const schema = {
+      type: 'record',
+      of: { type: 'boolean' },
+    } as const satisfies x.Schema
+
+    const struct = x.record(x.boolean())
+    const source = fixture.DATA_TYPE.filter(([type]) => type !== 'object')
+
+    foldC: {
+      const construct = x.makeStruct(schema)
+
+      for (const [kind, types] of source) {
+        if (kind === schema.type) {
+          continue
+        }
+
+        for (const subject of types) {
+          const expectedError = [
+            {
+              code: x.ERROR_CODE.invalidType,
+              schema: schema,
+              subject: subject,
+              path: [],
+            },
+          ]
+
+          const parsedSchema = x.parse(schema, subject)
+          const parsedConstruct = construct.parse(subject)
+          const parsedStruct = struct.parse(subject)
+
+          expect(parsedSchema.error).toStrictEqual(expectedError)
+          expect(parsedConstruct.error).toStrictEqual(expectedError)
+          expect(parsedStruct.error).toStrictEqual(expectedError)
+
+          const parsedStandard = struct['~standard'].validate(subject)
+
+          if (parsedStandard instanceof Promise) {
+            throw Error('Not expected')
+          }
+
+          expect(parsedStandard.issues).toStrictEqual([
+            { message: x.ERROR_CODE.invalidType, path: [] },
+          ])
+        }
+      }
+    }
+  })
+
+  it('InvalidSubject error of nested schema should have correct path/schema/subject', () => {
+    const schema = {
+      type: 'record',
+      of: {
+        type: 'array',
+        of: {
+          type: 'object',
+          of: {
+            y: { type: 'literal', of: '_' },
+          },
+        },
+      },
+    } as const satisfies x.Schema
+
+    const struct = x.record(x.array(x.object({ y: x.literal('_') })))
+
+    // prettier-ignore
+    const samples: Array<[
+      subj: Record<string, Array<{ y: unknown }>>,
+      invalidSubj: unknown,
+      invalidSubjSchema: x.Schema,
+      errorPath: x.ErrorPath,
+    ]
+    > = [
+        [{ x: [{ y: '+' }, { y: '_' }, { y: '_' }] }, '+', schema.of.of.of.y, ['x', 0, 'y']],
+        [{ y: [{ y: '_' }, { y: '+' }, { y: '_' }] }, '+', schema.of.of.of.y, ['y', 1, 'y']],
+        [{ z: [{ y: '_' }, { y: '_' }, { y: '+' }] }, '+', schema.of.of.of.y, ['z', 2, 'y']],
+      ]
+
+    foldE: {
+      const construct = x.makeStruct(schema)
+
+      for (const [subject, invalidSubj, invalidSubjSchema, path] of samples) {
+        const expectedError = [
+          {
+            path,
+            code: x.ERROR_CODE.invalidType,
+            schema: invalidSubjSchema,
+            subject: invalidSubj,
+          },
+        ]
+
+        const parsedSchema = x.parse(schema, subject)
+        const parsedConstruct = construct.parse(subject)
+        const parsedStruct = struct.parse(subject)
+
+        expect(parsedSchema.error).toStrictEqual(expectedError)
+        expect(parsedConstruct.error).toStrictEqual(expectedError)
+        expect(parsedStruct.error).toStrictEqual(expectedError)
+
+        const parsedStandard = struct['~standard'].validate(subject)
+
+        if (parsedStandard instanceof Promise) {
+          throw Error('Not expected')
+        }
+
+        expect(parsedStandard.issues).toStrictEqual([
+          { path, message: x.ERROR_CODE.invalidType },
+        ])
+      }
+    }
+  })
+
+  it('Multiple errors', () => {
+    const schema = {
+      type: 'record',
+      of: { type: 'boolean' },
+    } as const satisfies x.Schema
+
+    const subject = { x: true, y: '', z: 0 }
+
+    const parsed = x.parse(schema, subject)
+    const expectedError: x.InvalidSubject[] = [
+      {
+        code: x.ERROR_CODE.invalidType,
+        path: ['y'],
+        subject: subject.y,
+        schema: schema.of,
+      },
+      {
+        code: x.ERROR_CODE.invalidType,
+        path: ['z'],
+        subject: subject.z,
+        schema: schema.of,
+      },
+    ]
+
+    expect(parsed.error).toStrictEqual(expectedError)
+  })
+})
+
+describe('ERROR_CODE.invalidRange (foldD)', () => {
+  it('minLength', () => {
+    const schema = {
+      type: 'record',
+      of: { type: 'boolean' },
+      minLength: 3,
+    } as const satisfies x.Schema
+
+    const struct = x.record(x.boolean()).minLength(schema.minLength)
+    const subjects = [
+      {},
+      { 0: true },
+      { 0: true, 1: false },
+      { 0: true, 1: false, 2: undefined },
+    ]
+
+    foldD: {
+      const construct = x.makeStruct(schema)
+
+      for (const subject of subjects) {
+        const expectedError = [
+          {
+            code: x.ERROR_CODE.invalidRange,
+            schema: schema,
+            subject: subject,
+            path: [],
+          },
+        ]
+
+        const parsedSchema = x.parse(schema, subject)
+        const parsedConstruct = construct.parse(subject)
+        const parsedStruct = struct.parse(subject)
+
+        expect(parsedSchema.error).toStrictEqual(expectedError)
+        expect(parsedConstruct.error).toStrictEqual(expectedError)
+        expect(parsedStruct.error).toStrictEqual(expectedError)
+
+        const parsedStandard = struct['~standard'].validate(subject)
+
+        if (parsedStandard instanceof Promise) {
+          throw Error('Not expected')
+        }
+
+        expect(parsedStandard.issues).toStrictEqual([
+          { message: x.ERROR_CODE.invalidRange, path: [] },
+        ])
+      }
+    }
+  })
+
+  it('maxLength', () => {
+    const schema = {
+      type: 'record',
+      of: { type: 'boolean' },
+      maxLength: 1,
+    } as const satisfies x.Schema
+
+    const struct = x.record(x.boolean()).maxLength(schema.maxLength)
+    const subjects = [
+      { 0: false, 1: true },
+      { 0: false, 1: true, 2: false },
+      { 0: false, 1: true, 2: false, 3: true },
+    ]
+
+    foldD: {
+      const construct = x.makeStruct(schema)
+
+      for (const subject of subjects) {
+        const expectedError = [
+          {
+            code: x.ERROR_CODE.invalidRange,
+            schema: schema,
+            subject: subject,
+            path: [],
+          },
+        ]
+
+        const parsedSchema = x.parse(schema, subject)
+        const parsedConstruct = construct.parse(subject)
+        const parsedStruct = struct.parse(subject)
+
+        expect(parsedSchema.error).toStrictEqual(expectedError)
+        expect(parsedConstruct.error).toStrictEqual(expectedError)
+        expect(parsedStruct.error).toStrictEqual(expectedError)
+
+        const parsedStandard = struct['~standard'].validate(subject)
+
+        if (parsedStandard instanceof Promise) {
+          throw Error('Not expected')
+        }
+
+        expect(parsedStandard.issues).toStrictEqual([
+          { message: x.ERROR_CODE.invalidRange, path: [] },
+        ])
+      }
+    }
+  })
+
+  it('minLength + maxLength', () => {
+    const schema = {
+      type: 'array',
+      of: { type: 'boolean' },
+      maxLength: 2,
+      minLength: 2,
+    } as const satisfies x.Schema
+
+    const struct = x
+      .array(x.boolean())
+      .minLength(schema.minLength)
+      .maxLength(schema.maxLength)
+
+    const subjects = [[], [false], [false, true, false]]
+
+    foldD: {
+      const construct = x.makeStruct(schema)
+
+      for (const subject of subjects) {
+        const expectedError = [
+          {
+            code: x.ERROR_CODE.invalidRange,
+            schema: schema,
+            subject: subject,
+            path: [],
+          },
+        ]
+
+        const parsedSchema = x.parse(schema, subject)
+        const parsedConstruct = construct.parse(subject)
+        const parsedStruct = struct.parse(subject)
+
+        expect(parsedSchema.error).toStrictEqual(expectedError)
+        expect(parsedConstruct.error).toStrictEqual(expectedError)
+        expect(parsedStruct.error).toStrictEqual(expectedError)
+
+        const parsedStandard = struct['~standard'].validate(subject)
+
+        if (parsedStandard instanceof Promise) {
+          throw Error('Not expected')
+        }
+
+        expect(parsedStandard.issues).toStrictEqual([
+          { message: x.ERROR_CODE.invalidRange, path: [] },
+        ])
+      }
+    }
+  })
+})
+
+describe('Compound schema specifics (foldA)', () => {
+  it('nested primitive schema: optional + nullable + brand', () => {
+    const schema = {
+      type: 'record',
+      of: {
+        type: 'boolean',
+        optional: true,
+        nullable: true,
+        brand: ['x', 'y'],
+      },
+    } as const satisfies x.Schema
+
+    const struct = x.record(
+      x
+        .boolean()
+        .optional()
+        .nullable()
+        .brand(...schema.of.brand)
+    )
+
+    type Branded = boolean & { __x: 'y' }
+
+    // TODO: expected that `{ x?: Branded | undefined | null }` will not be
+    //       equivalent to `Record<Branded | undefined | null>`
+    //
+    //       either `tCh` has a flaw or typescript itself, need to investigate this later
+    //
+    type ExpectedSubj = { x?: Branded | undefined | null }
+
+    const subjects = [
+      {},
+      { x: null },
+      { x: true as Branded },
+      { x: false as Branded },
+    ] as const satisfies Array<ExpectedSubj>
+
+    foldA: {
+      const construct = x.makeStruct(schema)
+
+      /* ensure that schema/construct/struct/~standard subject types are identical */
+
+      type ConstructSchemaSubj = x.Infer<typeof construct.__schema>
+
+      x.tCh<ConstructSchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, ConstructSchemaSubj>()
+
+      type SchemaSubj = x.Infer<typeof schema>
+
+      x.tCh<SchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, SchemaSubj>()
+
+      type StructSubj = x.Infer<typeof struct.__schema>
+
+      x.tCh<StructSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StructSubj>()
+
+      type StandardSubj = NonNullable<
+        (typeof struct)['~standard']['types']
+      >['output']
+
+      x.tCh<StandardSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardSubj>()
+
+      /* parsed either type check */
+
+      type ExpectedParsed = x.ParseResult<ExpectedSubj>
+
+      const parsed = x.parse(schema, undefined)
+
+      type SchemaParsed = typeof parsed
+
+      x.tCh<SchemaParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, SchemaParsed>()
+
+      type ConstructParsed = ReturnType<typeof construct.parse>
+
+      x.tCh<ConstructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, ConstructParsed>()
+
+      type StructParsed = ReturnType<typeof struct.parse>
+
+      x.tCh<StructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, StructParsed>()
+
+      type StandardParsed = Extract<
+        ReturnType<(typeof struct)['~standard']['validate']>,
+        { value: unknown }
+      >['value']
+
+      x.tCh<StandardParsed, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardParsed>()
+
+      /* runtime schema check */
+
+      expect(struct.__schema).toStrictEqual(schema)
+      expect(construct.__schema).toStrictEqual(schema)
+      expect(construct.__schema === schema).toBe(false)
+
+      /* parse result check */
+
+      for (const subj of subjects) {
+        const schemaParsed = x.parse(schema, subj)
+
+        expect(schemaParsed.error).toBe(undefined)
+        expect(schemaParsed.data).toStrictEqual(subj)
+
+        const constructParsed = construct.parse(subj)
+
+        expect(constructParsed.error).toBe(undefined)
+        expect(constructParsed.data).toStrictEqual(subj)
+
+        const structParsed = struct.parse(subj)
+
+        expect(structParsed.error).toBe(undefined)
+        expect(structParsed.data).toStrictEqual(subj)
+
+        const standardParsed = struct['~standard'].validate(subj)
+
+        if (standardParsed instanceof Promise) {
+          throw Error('Not expected')
+        }
+
+        if (standardParsed.issues !== undefined) {
+          throw Error('not expected')
+        }
+
+        expect(standardParsed.value).toStrictEqual(subj)
+      }
+    }
+  })
+
+  /**
+   * We ensure that when a developer makes `Object.keys` on a record,
+   * they are, in fact, keys of existing entities within its record.
+   **/
+  it('parsed record should not keep if its value is undefined', () => {
+    const struct = x.record(x.boolean().optional())
+    const parsed = struct.parse({ x: undefined })
+
+    expect(parsed.data).toStrictEqual({})
+  })
+
+  it('nested compound schema: optional + nullable', () => {
+    const schema = {
+      type: 'record',
+      of: {
+        type: 'array',
+        of: { type: 'boolean' },
+        optional: true,
+        nullable: true,
+      },
+    } as const satisfies x.Schema
+
+    const struct = x.record(x.array(x.boolean()).optional().nullable())
+
+    type ExpectedSubj = { x?: Array<boolean> | undefined | null }
+
+    const subjects = [
+      { x: [] },
+      { x: null },
+      { x: [] },
+      { x: [true] },
+    ] as const satisfies Array<ExpectedSubj>
+
+    foldA: {
+      const construct = x.makeStruct(schema)
+
+      /* ensure that schema/construct/struct/~standard subject types are identical */
+
+      type ConstructSchemaSubj = x.Infer<typeof construct.__schema>
+
+      x.tCh<ConstructSchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, ConstructSchemaSubj>()
+
+      type SchemaSubj = x.Infer<typeof schema>
+
+      x.tCh<SchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, SchemaSubj>()
+
+      type StructSubj = x.Infer<typeof struct.__schema>
+
+      x.tCh<StructSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StructSubj>()
+
+      type StandardSubj = NonNullable<
+        (typeof struct)['~standard']['types']
+      >['output']
+
+      x.tCh<StandardSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardSubj>()
+
+      /* parsed either type check */
+
+      type ExpectedParsed = x.ParseResult<ExpectedSubj>
+
+      const parsed = x.parse(schema, undefined)
+
+      type SchemaParsed = typeof parsed
+
+      x.tCh<SchemaParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, SchemaParsed>()
+
+      type ConstructParsed = ReturnType<typeof construct.parse>
+
+      x.tCh<ConstructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, ConstructParsed>()
+
+      type StructParsed = ReturnType<typeof struct.parse>
+
+      x.tCh<StructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, StructParsed>()
+
+      type StandardParsed = Extract<
+        ReturnType<(typeof struct)['~standard']['validate']>,
+        { value: unknown }
+      >['value']
+
+      x.tCh<StandardParsed, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardParsed>()
+
+      /* runtime schema check */
+
+      expect(struct.__schema).toStrictEqual(schema)
+      expect(construct.__schema).toStrictEqual(schema)
+      expect(construct.__schema === schema).toBe(false)
+
+      /* parse result check */
+
+      for (const subj of subjects) {
+        const schemaParsed = x.parse(schema, subj)
+
+        expect(schemaParsed.error).toBe(undefined)
+        expect(schemaParsed.data).toStrictEqual(subj)
+
+        const constructParsed = construct.parse(subj)
+
+        expect(constructParsed.error).toBe(undefined)
+        expect(constructParsed.data).toStrictEqual(subj)
+
+        const structParsed = struct.parse(subj)
+
+        expect(structParsed.error).toBe(undefined)
+        expect(structParsed.data).toStrictEqual(subj)
+
+        const standardParsed = struct['~standard'].validate(subj)
+
+        if (standardParsed instanceof Promise) {
+          throw Error('Not expected')
+        }
+
+        if (standardParsed.issues !== undefined) {
+          throw Error('not expected')
+        }
+
+        expect(standardParsed.value).toStrictEqual(subj)
+      }
+    }
+  })
+
+  it('nested by itself (schema depth: 4)', () => {
+    const schema = {
+      type: 'record',
+      of: {
+        type: 'record',
+        of: {
+          type: 'record',
+          of: { type: 'boolean' },
+        },
+      },
+    } as const satisfies x.Schema
+
+    const struct = x.record(x.record(x.record(x.boolean())))
+
+    type ExpectedSubj = Record<string, Record<string, Record<string, boolean>>>
+
+    const subjects = [
+      { x: { y: { z: true } } },
+      { x: { y: { z: false } } },
+    ] as const satisfies Array<ExpectedSubj>
+
+    foldA: {
+      const construct = x.makeStruct(schema)
+
+      /* ensure that schema/construct/struct/~standard subject types are identical */
+
+      type ConstructSchemaSubj = x.Infer<typeof construct.__schema>
+
+      x.tCh<ConstructSchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, ConstructSchemaSubj>()
+
+      type SchemaSubj = x.Infer<typeof schema>
+
+      x.tCh<SchemaSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, SchemaSubj>()
+
+      type StructSubj = x.Infer<typeof struct.__schema>
+
+      x.tCh<StructSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StructSubj>()
+
+      type StandardSubj = NonNullable<
+        (typeof struct)['~standard']['types']
+      >['output']
+
+      x.tCh<StandardSubj, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardSubj>()
+
+      /* parsed either type check */
+
+      type ExpectedParsed = x.ParseResult<ExpectedSubj>
+
+      const parsed = x.parse(schema, undefined)
+
+      type SchemaParsed = typeof parsed
+
+      x.tCh<SchemaParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, SchemaParsed>()
+
+      type ConstructParsed = ReturnType<typeof construct.parse>
+
+      x.tCh<ConstructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, ConstructParsed>()
+
+      type StructParsed = ReturnType<typeof struct.parse>
+
+      x.tCh<StructParsed, ExpectedParsed>()
+      x.tCh<ExpectedParsed, StructParsed>()
+
+      type StandardParsed = Extract<
+        ReturnType<(typeof struct)['~standard']['validate']>,
+        { value: unknown }
+      >['value']
+
+      x.tCh<StandardParsed, ExpectedSubj>()
+      x.tCh<ExpectedSubj, StandardParsed>()
+
+      /* runtime schema check */
+
+      expect(struct.__schema).toStrictEqual(schema)
+      expect(construct.__schema).toStrictEqual(schema)
+      expect(construct.__schema === schema).toBe(false)
+
+      /* parse result check */
+
+      for (const subj of subjects) {
+        const schemaParsed = x.parse(schema, subj)
+
+        expect(schemaParsed.error).toBe(undefined)
+        expect(schemaParsed.data).toStrictEqual(subj)
+
+        const constructParsed = construct.parse(subj)
+
+        expect(constructParsed.error).toBe(undefined)
+        expect(constructParsed.data).toStrictEqual(subj)
+
+        const structParsed = struct.parse(subj)
+
+        expect(structParsed.error).toBe(undefined)
+        expect(structParsed.data).toStrictEqual(subj)
+
+        const standardParsed = struct['~standard'].validate(subj)
+
+        if (standardParsed instanceof Promise) {
+          throw Error('Not expected')
+        }
+
+        if (standardParsed.issues !== undefined) {
+          throw Error('not expected')
+        }
+
+        expect(standardParsed.value).toStrictEqual(subj)
+      }
+    }
+  })
+})