schematox 1.2.2 → 1.2.3

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

@@ -1,1684 +0,0 @@
-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('required', () => {
-    const schema = {
-      type: 'array',
-      of: { type: 'boolean' },
-    } as const satisfies x.Schema
-
-    const struct = x.array(x.boolean())
-
-    type ExpectedSubj = boolean[]
-
-    const subjects: Array<ExpectedSubj> = [
-      [true, false],
-      [false, 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', () => {
-    const schema = {
-      type: 'array',
-      of: { type: 'boolean' },
-      optional: true,
-    } as const satisfies x.Schema
-
-    const struct = x.array(x.boolean()).optional()
-
-    type ExpectedSubj = boolean[] | undefined
-
-    const subjects: Array<ExpectedSubj> = [
-      [true, false],
-      [false, true],
-      undefined,
-    ]
-
-    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: 'array',
-      of: { type: 'boolean' },
-      nullable: true,
-    } as const satisfies x.Schema
-
-    const struct = x.array(x.boolean()).nullable()
-
-    type ExpectedSubj = boolean[] | null
-
-    const subjects: Array<ExpectedSubj> = [[true, false], [false, 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: 'array',
-      of: { type: 'boolean' },
-      minLength: 2,
-    } as const satisfies x.Schema
-
-    const struct = x.array(x.boolean()).minLength(schema.minLength)
-
-    type ExpectedSubj = boolean[]
-
-    const subjects: Array<ExpectedSubj> = [
-      [true, false],
-      [false, 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: 'array',
-      of: { type: 'boolean' },
-      maxLength: 2,
-    } as const satisfies x.Schema
-
-    const struct = x.array(x.boolean()).maxLength(schema.maxLength)
-
-    type ExpectedSubj = boolean[]
-
-    const subjects: Array<ExpectedSubj> = [
-      [true, false],
-      [false, 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', () => {
-    const schema = {
-      type: 'array',
-      of: { type: 'boolean' },
-      minLength: 2,
-      maxLength: 2,
-      optional: true,
-      nullable: true,
-    } as const satisfies x.Schema
-
-    const struct = x
-      .array(x.boolean())
-      .minLength(schema.minLength)
-      .maxLength(schema.maxLength)
-      .optional()
-      .nullable()
-
-    type ExpectedSubj = boolean[] | undefined | null
-
-    const subjects: Array<ExpectedSubj> = [
-      [true, false],
-      [false, 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: 'array',
-      of: { type: 'boolean' },
-      optional: true,
-    } as const satisfies x.Schema
-
-    const prevStruct = x.array(x.boolean())
-    const struct = prevStruct.optional()
-
-    type ExpectedKeys =
-      | StructSharedKeys
-      | 'description'
-      | 'maxLength'
-      | 'minLength'
-      | 'nullable'
-
-    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: 'array',
-      of: { type: 'boolean' },
-      optional: true,
-      nullable: true,
-    } as const satisfies x.Schema
-
-    const prevStruct = x.array(x.boolean()).optional()
-    const struct = prevStruct.nullable()
-
-    type ExpectedKeys =
-      | StructSharedKeys
-      | 'description'
-      | 'maxLength'
-      | 'minLength'
-
-    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: 'array',
-      of: { type: 'boolean' },
-      optional: true,
-      nullable: true,
-      minLength: 2,
-    } as const satisfies x.Schema
-
-    const prevStruct = x.array(x.boolean()).optional().nullable()
-    const struct = prevStruct.minLength(schema.minLength)
-
-    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: 'array',
-      of: { type: 'boolean' },
-      optional: true,
-      nullable: true,
-      minLength: 2,
-      maxLength: 2,
-    } as const satisfies x.Schema
-
-    const prevStruct = x
-      .array(x.boolean())
-      .optional()
-      .nullable()
-      .minLength(schema.minLength)
-
-    const struct = prevStruct.maxLength(schema.maxLength)
-
-    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: 'array',
-      of: { type: 'boolean' },
-      optional: true,
-      nullable: true,
-      minLength: 2,
-      maxLength: 2,
-      description: 'x',
-    } as const satisfies x.Schema
-
-    const prevStruct = x
-      .array(x.boolean())
-      .optional()
-      .nullable()
-      .minLength(schema.minLength)
-      .maxLength(schema.maxLength)
-
-    const struct = prevStruct.description(schema.description)
-
-    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: 'array',
-      of: { type: 'boolean' },
-      optional: true,
-      nullable: true,
-      minLength: 2,
-      maxLength: 2,
-      description: 'x',
-    } as const satisfies x.Schema
-
-    const prevStruct = x
-      .array(x.boolean())
-      .description(schema.description)
-      .maxLength(schema.maxLength)
-      .minLength(schema.minLength)
-      .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: 'array',
-      of: { type: 'boolean' },
-    } as const satisfies x.Schema
-
-    const struct = x.array(x.boolean())
-    const source = fixture.DATA_TYPE
-
-    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: 'array',
-      of: { type: 'array', of: { type: 'boolean' } },
-    } as const satisfies x.Schema
-
-    const struct = x.array(x.array(x.boolean()))
-    const samples: Array<
-      [
-        subj: unknown[],
-        invalidSubj: unknown,
-        invalidSubjSchema: x.Schema,
-        errorPath: x.ErrorPath,
-      ]
-    > = [
-      [[[null, false, true]], null, schema.of.of, [0, 0]],
-      [[[], [null, false, true]], null, schema.of.of, [1, 0]],
-      [[[], [], [null, false, true]], null, schema.of.of, [2, 0]],
-      [[[true, 'str', true]], 'str', schema.of.of, [0, 1]],
-      [[[], [true, 'str', true]], 'str', schema.of.of, [1, 1]],
-      [[[], [], [true, 'str', true]], 'str', schema.of.of, [2, 1]],
-      [[[true, false, 69]], 69, schema.of.of, [0, 2]],
-      [[[], [true, false, 69]], 69, schema.of.of, [1, 2]],
-      [[[], [], [true, false, 69]], 69, schema.of.of, [2, 2]],
-    ]
-
-    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: 'array',
-      of: { type: 'boolean' },
-    } as const satisfies x.Schema
-
-    const struct = x.array(x.boolean())
-
-    const construct = x.makeStruct(schema)
-
-    const subject = [null, true, undefined]
-
-    const expectedError: x.InvalidSubject[] = [
-      {
-        code: x.ERROR_CODE.invalidType,
-        path: [0],
-        schema: schema.of,
-        subject: null,
-      },
-      {
-        code: x.ERROR_CODE.invalidType,
-        path: [2],
-        schema: schema.of,
-        subject: undefined,
-      },
-    ]
-
-    const parsedSchema = x.parse(schema, subject)
-    const parsedStruct = struct.parse(subject)
-    const parsedConstruct = construct.parse(subject)
-
-    expect(parsedSchema.error).toStrictEqual(expectedError)
-    expect(parsedStruct.error).toStrictEqual(expectedError)
-    expect(parsedConstruct.error).toStrictEqual(expectedError)
-  })
-})
-
-describe('ERROR_CODE.invalidRange (foldD)', () => {
-  it('minLength', () => {
-    const schema = {
-      type: 'array',
-      of: { type: 'boolean' },
-      minLength: 3,
-    } as const satisfies x.Schema
-
-    const struct = x.array(x.boolean()).minLength(schema.minLength)
-    const subjects = [[], [false], [false, 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('maxLength', () => {
-    const schema = {
-      type: 'array',
-      of: { type: 'boolean' },
-      maxLength: 0,
-    } as const satisfies x.Schema
-
-    const struct = x.array(x.boolean()).maxLength(schema.maxLength)
-    const subjects = [[false], [false, true], [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: [] },
-        ])
-      }
-    }
-  })
-
-  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: 'array',
-      of: {
-        type: 'boolean',
-        optional: true,
-        nullable: true,
-        brand: ['x', 'y'],
-      },
-    } as const satisfies x.Schema
-
-    const struct = x.array(
-      x
-        .boolean()
-        .optional()
-        .nullable()
-        .brand(...schema.of.brand)
-    )
-
-    type Branded = boolean & { __x: 'y' }
-    type ExpectedSubj = Array<Branded | undefined | null>
-
-    const subjects = [
-      [],
-      [undefined],
-      [null],
-      [true as Branded],
-      [false as Branded, undefined, null],
-    ] 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 compound schema: optional + nullable', () => {
-    const schema = {
-      type: 'array',
-      of: {
-        type: 'array',
-        of: { type: 'boolean' },
-        optional: true,
-        nullable: true,
-      },
-    } as const satisfies x.Schema
-
-    const struct = x.array(x.array(x.boolean()).optional().nullable())
-
-    type ExpectedSubj = Array<Array<boolean> | undefined | null>
-
-    const subjects = [
-      [],
-      [undefined],
-      [null],
-      [[]],
-      [[true]],
-      [[false], undefined, null],
-    ] 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: 'array',
-      of: {
-        type: 'array',
-        of: { type: 'array', of: { type: 'boolean' } },
-      },
-    } as const satisfies x.Schema
-
-    const struct = x.array(x.array(x.array(x.boolean())))
-
-    type ExpectedSubj = Array<Array<Array<boolean>>>
-
-    const subjects = [
-      [[]],
-      [[], []],
-      [[[]]],
-      [
-        [[], []],
-        [[], []],
-      ],
-      [[[true]], [[true, 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)
-      }
-    }
-  })
-})