diff --git a/src/typebox.ts b/src/typebox.ts
index 64bb30df1..c6d45c402 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -242,9 +242,10 @@ export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptio
 // --------------------------------------------------------------------------
 // TAsyncIterator
 // --------------------------------------------------------------------------
+export type TAsyncIteratorResolve<T extends TSchema, P extends unknown[]> = Ensure<AsyncIterableIterator<Static<T, P>>>
 export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'AsyncIterator'
-  static: AsyncIterableIterator<Static<T, this['params']>>
+  static: TAsyncIteratorResolve<T, this['params']>
   type: 'AsyncIterator'
   items: T
 }
@@ -280,7 +281,7 @@ export interface TBoolean extends TSchema {
 // --------------------------------------------------------------------------
 // TConstructorParameters
 // --------------------------------------------------------------------------
-export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = TTuple<T['parameters']>
+export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = Ensure<TTuple<T['parameters']>>
 // --------------------------------------------------------------------------
 // TInstanceType
 // --------------------------------------------------------------------------
@@ -307,10 +308,11 @@ export type TComposite<T extends TObject[]> = TIntersect<T> extends TIntersect
 // --------------------------------------------------------------------------
 // TConstructor
 // --------------------------------------------------------------------------
-export type TConstructorParameterArray<T extends readonly TSchema[], P extends unknown[]> = [...{ [K in keyof T]: Static<AssertType<T[K]>, P> }]
+export type TConstructorReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>
+export type TConstructorParameterArray<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TFunctionParameters<R, P>] : []
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Constructor'
-  static: new (...param: TConstructorParameterArray<T, this['params']>) => Static<U, this['params']>
+  static: new (...param: TConstructorParameterArray<T, this['params']>) => TConstructorReturnType<U, this['params']>
   type: 'Constructor'
   parameters: T
   returns: U
@@ -386,10 +388,11 @@ export type TExtract<T extends TSchema, U extends TSchema> =
 // --------------------------------------------------------------------------
 // TFunction
 // --------------------------------------------------------------------------
-export type TFunctionParameters<T extends TSchema[], P extends unknown[]> = [...{ [K in keyof T]: Static<AssertType<T[K]>, P> }]
+export type TFunctionReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>
+export type TFunctionParameters<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TFunctionParameters<R, P>] : []
 export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Function'
-  static: (...param: TFunctionParameters<T, this['params']>) => Static<U, this['params']>
+  static: (...param: TFunctionParameters<T, this['params']>) => TFunctionReturnType<U, this['params']>
   type: 'Function'
   parameters: T
   returns: U
@@ -472,9 +475,10 @@ export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, In
 // --------------------------------------------------------------------------
 // TIterator
 // --------------------------------------------------------------------------
+export type TIteratorResolve<T extends TSchema, P extends unknown[]> = Ensure<IterableIterator<Static<T, P>>>
 export interface TIterator<T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Iterator'
-  static: IterableIterator<Static<T, this['params']>>
+  static: TIteratorResolve<T, this['params']>
   type: 'Iterator'
   items: T
 }
@@ -880,9 +884,9 @@ export type DecodeType<T extends TSchema> = (
   T extends TTransform<infer _, infer R> ? TUnsafe<R> :
   T extends TArray<infer S extends TSchema> ? TArray<DecodeType<S>> :
   T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DecodeType<S>> :
-  T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<P, DecodeType<R>> :
+  T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<DecodeRest<P>, DecodeType<R>> :
   T extends TEnum<infer S> ? TEnum<S> : // intercept for union. interior non decodable
-  T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<P, DecodeType<R>> :
+  T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<DecodeRest<P>, DecodeType<R>> :
   T extends TIntersect<infer S extends TSchema[]> ? TIntersect<DecodeRest<S>> :
   T extends TIterator<infer S extends TSchema> ? TIterator<DecodeType<S>> :
   T extends TNot<infer S extends TSchema> ? TNot<DecodeType<S>> :
@@ -3313,7 +3317,7 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     return this.Create({ ...options, [Kind]: 'BigInt', type: 'bigint' })
   }
   /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-  public ConstructorParameters<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TConstructorParameters<T> {
+  public ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options: SchemaOptions = {}): TConstructorParameters<T> {
     return this.Tuple([...schema.parameters], { ...options })
   }
   /** `[JavaScript]` Creates a Constructor type */
@@ -3339,7 +3343,7 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     return this.Create({ ...options, [Kind]: 'Iterator', type: 'Iterator', items: TypeClone.Type(items) })
   }
   /** `[JavaScript]` Extracts the Parameters from the given Function type */
-  public Parameters<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TParameters<T> {
+  public Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options: SchemaOptions = {}): TParameters<T> {
     return this.Tuple(schema.parameters, { ...options })
   }
   /** `[JavaScript]` Creates a Promise type */
diff --git a/test/static/constructor.ts b/test/static/constructor.ts
index a05363991..c91d398e7 100644
--- a/test/static/constructor.ts
+++ b/test/static/constructor.ts
@@ -1,11 +1,31 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
-
-const C = Type.Constructor(
-  [Type.Number(), Type.String()],
-  Type.Object({
-    method: Type.Function([Type.Number(), Type.String()], Type.Boolean()),
-  }),
-)
-
-Expect(C).ToStatic<new (param_0: number, param_1: string) => { method: (param_0: number, param_1: string) => boolean }>()
+{
+  // simple
+  const T = Type.Constructor([Type.Number(), Type.Boolean()], Type.String())
+  Expect(T).ToStatic<new (param_0: number, param_1: boolean) => string>()
+}
+{
+  // nested
+  // prettier-ignore
+  const T = Type.Constructor([Type.Number(), Type.String()], Type.Object({
+    method: Type.Constructor([Type.Number(), Type.String()], Type.Boolean()),
+  }))
+  Expect(T).ToStatic<new (param_0: number, param_1: string) => { method: new (param_0: number, param_1: string) => boolean }>()
+}
+{
+  // decode 2
+  const S = Type.Transform(Type.Integer())
+    .Decode((value) => new Date(value))
+    .Encode((value) => value.getTime())
+  const T = Type.Constructor([S], Type.String())
+  Expect(T).ToStaticDecode<new (param_0: Date) => string>()
+}
+{
+  // decode 1
+  const S = Type.Transform(Type.Integer())
+    .Decode((value) => new Date(value))
+    .Encode((value) => value.getTime())
+  const T = Type.Constructor([Type.Number()], S)
+  Expect(T).ToStaticDecode<new (param_0: number) => Date>()
+}
diff --git a/test/static/function.ts b/test/static/function.ts
index 623aa911e..a204187a6 100644
--- a/test/static/function.ts
+++ b/test/static/function.ts
@@ -1,11 +1,32 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-const C = Type.Function(
-  [Type.Number(), Type.String()],
-  Type.Object({
+{
+  // simple
+  const T = Type.Function([Type.Number(), Type.Boolean()], Type.String())
+  Expect(T).ToStatic<(param_0: number, param_1: boolean) => string>()
+}
+{
+  // nested
+  // prettier-ignore
+  const T = Type.Function([Type.Number(), Type.String()], Type.Object({
     method: Type.Function([Type.Number(), Type.String()], Type.Boolean()),
-  }),
-)
-
-Expect(C).ToStatic<(param_0: number, param_1: string) => { method: (param_0: number, param_1: string) => boolean }>()
+  }))
+  Expect(T).ToStatic<(param_0: number, param_1: string) => { method: (param_0: number, param_1: string) => boolean }>()
+}
+{
+  // decode 2
+  const S = Type.Transform(Type.Integer())
+    .Decode((value) => new Date(value))
+    .Encode((value) => value.getTime())
+  const T = Type.Function([S], Type.String())
+  Expect(T).ToStaticDecode<(param_0: Date) => string>()
+}
+{
+  // decode 1
+  const S = Type.Transform(Type.Integer())
+    .Decode((value) => new Date(value))
+    .Encode((value) => value.getTime())
+  const T = Type.Function([Type.Number()], S)
+  Expect(T).ToStaticDecode<(param_0: number) => Date>()
+}
diff --git a/test/static/transform.ts b/test/static/transform.ts
index 468787ef2..917628a67 100644
--- a/test/static/transform.ts
+++ b/test/static/transform.ts
@@ -291,3 +291,21 @@ import { Expect } from './assert'
   Expect(T).ToStaticDecode<1>()
   Expect(T).ToStaticEncode<E>()
 }
+{
+  // should transform functions
+  const S = Type.Transform(Type.Number())
+    .Decode((value) => new Date(value))
+    .Encode((value) => value.getTime())
+  const T = Type.Function([S], S)
+  Expect(T).ToStaticDecode<(x: Date) => Date>()
+  Expect(T).ToStaticEncode<(x: number) => number>()
+}
+{
+  // should transform constructors
+  const S = Type.Transform(Type.Number())
+    .Decode((value) => new Date(value))
+    .Encode((value) => value.getTime())
+  const T = Type.Constructor([S], S)
+  Expect(T).ToStaticDecode<new (x: Date) => Date>()
+  Expect(T).ToStaticEncode<new (x: number) => number>()
+}