@mionjs/run-types 0.8.7 → 0.8.10

package/src/nodes/collection/union.ts

@@ -0,0 +1,205 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {ReflectionKind, type TypeUnion} from '@deepkit/type';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import type {JitCode} from '../../types.ts';
+import {BaseRunType, CollectionRunType} from '../../lib/baseRunTypes.ts';
+import {childIsExpression, createIfElseFn, toLiteral} from '../../lib/utils.ts';
+import {isClassRunType, isInterfaceRunType, isIntersectionRunType, isObjectLiteralRunType} from '../../lib/guards.ts';
+import {markDiscriminators, splitUnionItems, SplitUnionResult} from './unionDiscriminator.ts';
+import type {PropertyRunType} from '../member/property.ts';
+
+/**
+ * Unions get encoded into an array where arr[0] is the discriminator and arr[1] is the value.
+ * this is because some times we can't distinguish the type of an union.
+ * ie: bigint gets encoded into an string, so if we have an union 'type U = string | bigint' we can't distinguish between the when encoding/decoding the json.
+ * to solve this issue the index of the type is used as a discriminator.
+ * So [0, "123n"] is interpreted as a string and [1, "123n"] is interpreted as a bigint.
+ * */
+export class UnionRunType extends CollectionRunType<TypeUnion> {
+    hasDiscriminators: boolean | undefined = undefined;
+    hasObjectTypes: boolean | undefined = undefined;
+
+    isTypeWithProperties(rt: BaseRunType) {
+        return (
+            rt.getFamily() === 'C' &&
+            (isInterfaceRunType(rt) || isClassRunType(rt) || isObjectLiteralRunType(rt) || isIntersectionRunType(rt))
+        );
+    }
+
+    getUnionChildren(comp: JitFnCompiler): SplitUnionResult {
+        const children = this.getJitChildren(comp);
+        markDiscriminators(comp, this, children);
+        return splitUnionItems(comp, this, children);
+    }
+
+    getUnionItemIndex(comp: JitFnCompiler, unionItem: BaseRunType): number {
+        const children = this.getJitChildren(comp);
+        const index = children.findIndex((child) => child === unionItem);
+        if (index === -1) throw new Error(`Item ${unionItem.getTypeName()} not found in union ${this.getTypeName()}`);
+        return index;
+    }
+
+    /**
+     * Returns isType check for a union child with loose matching.
+     * Uses first-match strategy: returns first matching type in declaration order.
+     * For all-optional types (weak types), ensures at least one property matches or is empty object.
+     * Note: Use ESLint rules @mionjs/no-unreachable-union-types and @mionjs/no-mixed-union-properties
+     * to detect overlapping union types at compile time.
+     * @see union.spec.ts 'Union Obj' and 'Union Mixed' test suites for examples.
+     */
+    getChildIsTypeWithLooseCheck(rt: BaseRunType, comp: JitFnCompiler): string {
+        const isTypeCode = comp.compileIsType(rt, 'E').code || '';
+        const isTypeWithProperties =
+            isInterfaceRunType(rt) || isClassRunType(rt) || isObjectLiteralRunType(rt) || isIntersectionRunType(rt);
+        if (!isTypeWithProperties || rt.getFamily() !== 'C') return isTypeCode;
+        const props = rt.getJitChildren(comp);
+        const hasIndexProperty = props.some((prop) => prop.src.kind === ReflectionKind.indexSignature);
+        if (hasIndexProperty) return isTypeCode;
+        const isAllOptional = rt.areAllChildrenOptional(props);
+        // For all-optional types (weak types), TypeScript requires at least one matching property
+        // or an empty object. This prevents {c: 'hello'} from matching {a?: string; b?: string}
+        if (isAllOptional && props.length > 0) {
+            // Must have at least one of this type's own props OR be empty
+            const hasOwnPropCheck = props.map((p) => {
+                const name = (p as PropertyRunType).getPropertyName();
+                return `(${toLiteral(name)} in ${comp.vλl})`;
+            });
+            hasOwnPropCheck.push(`Object.keys(${comp.vλl}).length === 0`);
+            const weakTypeCheck = `(${hasOwnPropCheck.join(' || ')})`;
+            return `(${isTypeCode} && ${weakTypeCheck})`;
+        }
+        return isTypeCode;
+    }
+
+    /**
+     * Loose union matching: returns first matching type in declaration order.
+     * Objects with properties from multiple union types will match the first compatible type.
+     * Use ESLint rules to detect overlapping types at compile time.
+     */
+    emitIsType(comp: JitFnCompiler): JitCode {
+        this.checkAllowedChildren(comp);
+        const {simpleItems, objectTypes, anyItem} = this.getUnionChildren(comp);
+        // Simple items (atomic types) don't need null guard
+        const simpleChecks = simpleItems.map((rt) => this.getChildIsTypeWithLooseCheck(rt, comp)).filter(Boolean);
+        // Object types need null guard to prevent accessing properties on null
+        const objChecks = objectTypes.map((rt) => this.getChildIsTypeWithLooseCheck(rt, comp)).filter(Boolean);
+        const objCode = objChecks.length
+            ? `(typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null && (${objChecks.join(' || ')}))`
+            : '';
+        // any/unknown checked last as fallback
+        const anyCheck = anyItem ? this.getChildIsTypeWithLooseCheck(anyItem, comp) : '';
+        const allChecks = [...simpleChecks, objCode, anyCheck].filter(Boolean);
+        return {code: `(${allChecks.join(' || ')})`, type: 'E'};
+    }
+
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        this.checkAllowedChildren(comp);
+        const isType = comp.compileIsType(this, 'E').code;
+        const code = `if (!${isType}) ${comp.callJitErr(this)};`;
+        return {code, type: 'S'};
+    }
+
+    /**
+     * When a union is encodes to json is encode into and array with two elements: [unionDiscriminator, encoded Value]
+     * the first element is the index of the type in the union.
+     * the second element is the encoded value of the type.
+     * ie: type union = string | number | bigint;  var v1: union = 123n;  v1 is encoded as [2, "123n"]
+     */
+    emitPrepareForJson(comp: JitFnCompiler): JitCode {
+        this.checkAllowedChildren(comp);
+        const {simpleItems, objectTypes, anyItem} = this.getUnionChildren(comp);
+        const errName = comp.getLocalVarName('uErr', this);
+        const fail = `throw new Error(${errName});`;
+        comp.setContextItem(errName, `const ${errName} = "Can not json encode union: item does not belong to the union"`);
+
+        const ifElse = createIfElseFn();
+
+        // Helper to generate encode code for a union item
+        const getEncodeCode = (childRt: BaseRunType) => {
+            const toJit = comp.compilePrepareForJson(childRt, 'S');
+            const fromJit = comp.compileRestoreFromJson(childRt, 'S');
+            const needsTupleEncoding = !!toJit.code || !!fromJit.code;
+            const isExpression = childIsExpression(toJit, childRt);
+            const encodeCode = isExpression && toJit.code ? `${comp.vλl} = ${toJit.code};` : toJit.code || '';
+            const index = this.getUnionItemIndex(comp, childRt);
+            const tupleEncode = needsTupleEncoding ? `${comp.vλl} = [${index}, ${comp.vλl}]` : '/*noop*/';
+            return `${encodeCode} ${tupleEncode}`;
+        };
+
+        // Generate code for simple items (atomic types)
+        const simpleCode = simpleItems.map((rt) => {
+            const isTypeCode = this.getChildIsTypeWithLooseCheck(rt, comp);
+            return `${ifElse()} (${isTypeCode}) {${getEncodeCode(rt)}}`;
+        });
+
+        // Generate code for object types (need null guard)
+        const objCode = objectTypes.length
+            ? objectTypes.map((rt) => {
+                  const isTypeCode = this.getChildIsTypeWithLooseCheck(rt, comp);
+                  return `${ifElse()} (typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null && ${isTypeCode}) {${getEncodeCode(rt)}}`;
+              })
+            : [];
+
+        // Generate code for anyItem (always matches, checked last as fallback)
+        const anyCode = anyItem ? `${ifElse(true)} {${getEncodeCode(anyItem)}}` : `${ifElse(true)} {${fail}}`;
+
+        return {code: [...simpleCode, ...objCode, anyCode].join(''), type: 'S'};
+    }
+
+    /**
+     * When a union is decoded from json it expects de two elements array format: [unionDiscriminator, Value to decode]
+     * the first element is the index of the type in the union.
+     * the second element is the encoded value of the type.
+     * ie: type union = string | number | bigint;  var v1: union = 123n;  v1 is encoded as [2, "123n"]
+     */
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
+        this.checkAllowedChildren(comp);
+        const decVar = comp.getLocalVarName('dec', this);
+        const errVarName = comp.getLocalVarName('uErr', this);
+        comp.setContextItem(errVarName, `const ${errVarName} = "Can not json decode union: invalid union index"`);
+        const children = this.getJitChildren(comp);
+        const ifElse = createIfElseFn();
+        const itemsCode = children
+            .map((unionItem) => {
+                const childJit = comp.compileRestoreFromJson(unionItem, 'S');
+                const isExpression = childIsExpression(childJit, unionItem);
+                const code =
+                    isExpression && childJit.code && childJit.code !== comp.vλl
+                        ? `${comp.vλl} = ${childJit.code}`
+                        : childJit.code || '';
+                // item is decoded before being extracted from the array
+                const index = this.getUnionItemIndex(comp, unionItem);
+                return `${ifElse()} (${decVar} === ${index}) {${code || '/*noop*/'}}`;
+            })
+            .filter(Boolean);
+        const childrenCode = itemsCode.join('');
+        const failCode = childrenCode ? `else {throw new Error(${errVarName})}` : '';
+        const code = `
+            if (${comp.vλl}?.length === 2 && Array.isArray(${comp.vλl}) && typeof ${comp.vλl}[0] === 'number') {
+                const ${decVar} = ${comp.vλl}[0]; ${comp.vλl} = ${comp.vλl}[1];
+                ${childrenCode}
+                ${failCode}
+            }
+        `;
+        return {code, type: 'S'};
+    }
+
+    getUnionTypeNames(): string {
+        return this.getChildRunTypes()
+            .map((rt) => rt.getTypeName())
+            .join(' | ');
+    }
+
+    checkAllowedChildren(comp: JitFnCompiler) {
+        const allChildren = this.getChildRunTypes();
+        const toSkip = allChildren.filter((rt) => rt.skipJit(comp));
+        if (toSkip.length)
+            throw new Error(`Union can not have non serializable types, ie: Symbol, Function, etc. \nType: ${this.stringify()}`);
+    }
+}

package/src/nodes/collection/unionDiscriminator.ts

@@ -0,0 +1,259 @@
+import type {BaseRunType, CollectionRunType, MemberRunType} from '../../lib/baseRunTypes.ts';
+import type {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
+import type {UnionRunType} from './union.ts';
+import type {PropertyRunType} from '../member/property.ts';
+import {getTotalComplexity, sortRunTypeByComplexity} from '../../lib/utils.ts';
+import {isAnyRunType, isUnknownRunType} from '../../lib/guards.ts';
+
+export type FlattenedProp = {
+    /** union item, parent of the property */
+    unionItem: CollectionRunType<any>;
+    /** index of the union item in the union */
+    unionIndex: string | number;
+    /** one property of the union item  */
+    prop: PropertyRunType;
+    /** typeID of the property */
+    typeID: string | number;
+    /** name of the property as it should be used in the code */
+    compiledName: string;
+};
+
+export type SplitUnionResult = {
+    simpleItems: BaseRunType[];
+    objectTypes: CollectionRunType<any>[];
+    /** any or unknown type if present in the union, should be checked last */
+    anyItem?: BaseRunType;
+};
+
+/**
+ * Split the union types in two groups: interface types and simple types
+ * interface types are types that have properties, simple types are the rest (atomic types, tuples, etc)
+ * If any or unknown types are present, they are extracted and returned separately as anyItem
+ * so they can be checked last (any/unknown would match anything, so must be last resort)
+ */
+export function splitUnionItems(comp: JitFnCompiler, urt: UnionRunType, unionChildren?: BaseRunType[]): SplitUnionResult {
+    const unionItems = unionChildren || urt.getJitChildren(comp);
+    const objectTypes: CollectionRunType<any>[] = [];
+    const simpleItems: BaseRunType[] = [];
+    let anyItem: BaseRunType | undefined;
+
+    unionItems.forEach((unionItem) => {
+        // Extract any/unknown types to be checked last
+        if (isAnyRunType(unionItem) || isUnknownRunType(unionItem)) {
+            // Only keep the first any/unknown type (having multiple is redundant)
+            if (!anyItem) anyItem = unionItem;
+            return;
+        }
+        const isObj = urt.isTypeWithProperties(unionItem);
+        if (!isObj) return simpleItems.push(unionItem);
+        return objectTypes.push(unionItem as CollectionRunType<any>);
+    });
+
+    // Sort object types to prevent unreachable types (objects with more props should come first when they share same prop types)
+    const sortedObjectTypes = sortUnreachableTypes(comp, objectTypes);
+
+    return {simpleItems, objectTypes: sortedObjectTypes, anyItem};
+}
+
+/**
+ * Sorts object types to prevent unreachable union types.
+ * When two objects share the same properties (by typeID), the one with more properties must come first.
+ * This ensures that at runtime, the more specific type is checked before the less specific one.
+ * Objects that don't share properties with others maintain their relative order.
+ */
+export function sortUnreachableTypes(comp: JitFnCompiler, objectTypes: CollectionRunType<any>[]): CollectionRunType<any>[] {
+    if (objectTypes.length <= 1) return objectTypes;
+
+    // Get property typeIDs for each object type
+    const typePropsMap = new Map<CollectionRunType<any>, Set<string | number>>();
+    objectTypes.forEach((objType) => {
+        const props = objType.getJitChildren(comp) as PropertyRunType[];
+        const propTypeIDs = new Set<string | number>();
+        props.forEach((prop) => propTypeIDs.add(prop.getTypeID()));
+        typePropsMap.set(objType, propTypeIDs);
+    });
+
+    // Check if one object's props are a subset of another's (all props have same typeIDs)
+    const isSubsetOf = (smaller: CollectionRunType<any>, larger: CollectionRunType<any>): boolean => {
+        const smallerProps = typePropsMap.get(smaller)!;
+        const largerProps = typePropsMap.get(larger)!;
+        if (smallerProps.size >= largerProps.size) return false;
+        for (const typeID of smallerProps) {
+            if (!largerProps.has(typeID)) return false;
+        }
+        return true;
+    };
+
+    // Find groups of objects that share properties (one is subset of another)
+    const processed = new Set<CollectionRunType<any>>();
+    const result: CollectionRunType<any>[] = [];
+
+    for (let i = 0; i < objectTypes.length; i++) {
+        const current = objectTypes[i];
+        if (processed.has(current)) continue;
+
+        // Find all objects that are related (subset/superset) to current
+        const relatedGroup: CollectionRunType<any>[] = [current];
+        processed.add(current);
+
+        for (let j = 0; j < objectTypes.length; j++) {
+            if (i === j) continue;
+            const other = objectTypes[j];
+            if (processed.has(other)) continue;
+
+            // Check if current and other are related (one is subset of the other)
+            if (isSubsetOf(current, other) || isSubsetOf(other, current)) {
+                relatedGroup.push(other);
+                processed.add(other);
+            }
+        }
+
+        // Sort related group by number of properties (more props first)
+        if (relatedGroup.length > 1) {
+            relatedGroup.sort((a, b) => {
+                const aSize = typePropsMap.get(a)!.size;
+                const bSize = typePropsMap.get(b)!.size;
+                return bSize - aSize; // descending order (more props first)
+            });
+        }
+
+        result.push(...relatedGroup);
+    }
+
+    return result;
+}
+
+/**
+ * Mark discriminator properties so they can be sorted and validate union more efficiently.
+ * @param comp
+ * @param urt
+ */
+export function markDiscriminators(comp: JitFnCompiler, urt: UnionRunType, unionItems: BaseRunType[]) {
+    if (urt.hasDiscriminators !== undefined && urt.hasObjectTypes !== undefined) return;
+    const objectTypes = unionItems.filter((item) => urt.isTypeWithProperties(item)) as CollectionRunType<any>[];
+    const namedDiscriminators = getDiscriminatorProperties(comp, urt, objectTypes, initGetCompiledName());
+    const uniqueDiscriminators = getUniqueDiscriminatorProperties(comp, urt, objectTypes, initGetCompiledName());
+    urt.hasObjectTypes = !!objectTypes.length;
+    urt.hasDiscriminators = !!namedDiscriminators.length || !!uniqueDiscriminators.length;
+}
+
+type PropUnionItemPair = {prop: PropertyRunType; unionItem: CollectionRunType<any>};
+
+/**
+ * Find a property with the same name in all the types of the union and that has different types.
+ * It also marks those properties as discriminator properties so can be sorted later
+ */
+function getDiscriminatorProperties(
+    comp: JitFnCompiler,
+    urt: UnionRunType,
+    unionTypes: CollectionRunType<any>[],
+    getCompiledName: (comp: JitFnCompiler, urt: UnionRunType, propTypeID: string | number) => string
+): FlattenedProp[] {
+    if (!unionTypes.length) return [];
+    const propByName = new Map<string | number, PropUnionItemPair[]>();
+    unionTypes.forEach((unionItem) => {
+        const props = unionItem.getJitChildren(comp) as PropertyRunType[];
+        props.forEach((prop) => {
+            const name = prop.getChildVarName(comp);
+            const existing = propByName.get(name) || [];
+            // index no needed now
+            propByName.set(name, [...existing, {prop, unionItem}]);
+        });
+    });
+    const propsOnAllTypes = Array.from(propByName.entries())
+        // filter all properties that are in all types
+        .filter(([, props]) => props.length === unionTypes.length)
+        // calculate complexity and check if all types are different in all props
+        .map(([key, props]) => ({
+            name: key,
+            props,
+            complexity: props.reduce((acc, item) => acc + getTotalComplexity(comp, item.prop), 0),
+            isUniqueType: props.every((item) => {
+                const child = item;
+                const typeID = child.prop.getTypeID();
+                const isDiff = props.every((otherItem) => child.prop === otherItem.prop || otherItem.prop.getTypeID() !== typeID);
+                return isDiff;
+            }),
+        }))
+        .filter((item) => item.isUniqueType);
+    const lessComplexProps = propsOnAllTypes.toSorted((a, b) => a.complexity - b.complexity);
+    const lessComplex = lessComplexProps[0];
+    if (!lessComplex) return [];
+    // we need to marks the property as discriminator so they can be sorted and checked first later
+    return lessComplex.props.map((item) => {
+        item.prop.isUnionDiscriminator = true;
+        const unionIndex = urt.getUnionItemIndex(comp, item.unionItem);
+        const typeID = item.prop.getTypeID();
+        return {
+            unionItem: item.unionItem,
+            unionIndex,
+            prop: item.prop,
+            typeID,
+            compiledName: getCompiledName(comp, urt, typeID),
+        };
+    });
+}
+
+/**
+ * Get unique properties in the union as discriminators.
+ * These properties can be of different name but are unique in the union so can act as discriminators.
+ * It also marks those properties as discriminator properties so can be sorted later.
+ * */
+function getUniqueDiscriminatorProperties(
+    comp: JitFnCompiler,
+    urt: UnionRunType,
+    unionTypes: CollectionRunType<any>[],
+    getCompiledName: (comp: JitFnCompiler, urt: UnionRunType, propTypeID: string | number) => string
+): FlattenedProp[] {
+    if (!unionTypes.length) return [];
+    const uniquePropByUnionItem = new Map<CollectionRunType<any>, PropUnionItemPair>();
+    unionTypes.forEach((unionItem) => {
+        const props = unionItem.getJitChildren(comp) as PropertyRunType[];
+        props.forEach((prop) => {
+            const typeID = prop.getTypeID();
+            const isUnique = unionTypes.every((otherUnionItem) => {
+                if (otherUnionItem === unionItem) return true;
+                const otherProps = otherUnionItem.getJitChildren(comp) as MemberRunType<any>[];
+                return otherProps.every((otherProp) => otherProp.getTypeID() !== typeID);
+            });
+            if (isUnique) {
+                const existing = uniquePropByUnionItem.get(unionItem);
+                if (!existing) {
+                    uniquePropByUnionItem.set(unionItem, {
+                        prop,
+                        unionItem,
+                    });
+                    return;
+                }
+                const newItem = {prop, unionItem};
+                const lessComplex = [newItem, existing].toSorted((a, b) => sortRunTypeByComplexity(comp, a.prop, b.prop))[0];
+                uniquePropByUnionItem.set(unionItem, lessComplex);
+            }
+        });
+    });
+    if (!uniquePropByUnionItem.size) return [];
+    const uniqueProps = Array.from(uniquePropByUnionItem.values());
+    return uniqueProps.map((item) => {
+        item.prop.isUnionDiscriminator = true;
+        const unionIndex = urt.getUnionItemIndex(comp, item.unionItem);
+        const typeID = item.prop.getTypeID();
+        return {
+            unionItem: item.unionItem,
+            unionIndex,
+            prop: item.prop,
+            typeID,
+            compiledName: getCompiledName(comp, urt, typeID),
+        };
+    });
+}
+
+function initGetCompiledName() {
+    const typeIDs = new Map<string | number, number>();
+    return function getCompiledName(comp: JitFnCompiler, urt: UnionRunType, typeID: string | number): string {
+        const existingIndex = typeIDs.get(typeID);
+        if (existingIndex) return comp.getLocalVarName('prop', urt) + `_${existingIndex}`;
+        const newIndex = typeIDs.size;
+        typeIDs.set(typeID, newIndex);
+        return comp.getLocalVarName('prop', urt) + `_${newIndex}`;
+    };
+}

package/src/nodes/function/function.ts

@@ -0,0 +1,166 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+import type {AnyFunction, SrcType, JitFn, JitCode, RunTypeOptions} from '../../types.ts';
+import {ReflectionKind, TypeFunction} from '@deepkit/type';
+import {BaseRunType} from '../../lib/baseRunTypes.ts';
+import {isAnyFunctionRunType, isFunctionRunType, isPromiseRunType} from '../../lib/guards.ts';
+import {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import {PromiseRunType} from '../native/promise.ts';
+import {ReflectionSubKind} from '../../constants.kind.ts';
+import {FunctionParamsRunType} from '../collection/functionParams.ts';
+import {JitCompiledFn} from '@mionjs/core';
+import {registerJitFunctionCompiler} from '../../lib/jitFnsRegistry.ts';
+import {JitFunctions} from '../../constants.functions.ts';
+
+export class FunctionRunType<CallType extends AnyFunction = TypeFunction> extends BaseRunType<CallType> {
+    // parameterRunTypes.src must be set after FunctionRunType creation
+    parameterRunTypes: FunctionParamsRunType = new FunctionParamsRunType();
+    skipJit(comp: JitFnCompiler): boolean {
+        if (!comp) return true;
+        return comp.fnID !== JitFunctions.toJSCode.id;
+    }
+    onCreated(deepkitType: SrcType): void {
+        // here we are mapping parameters from TypeParameter[] to TypeTuple as TupleRunType() is the same functionality as ParameterRunType[]
+        super.onCreated(deepkitType);
+        // Create a synthetic type for parameters with its own subKind
+        // Explicitly exclude _typeId and _formatId so the params type gets its own cached IDs
+        const paramsType = {...deepkitType, subKind: ReflectionSubKind.params} as any;
+        delete paramsType._typeId;
+        delete paramsType._formatId;
+        this.parameterRunTypes.onCreated(paramsType);
+    }
+    getFamily(): 'F' {
+        return 'F';
+    }
+    getFnName(): string | number {
+        const name = (this.src as TypeFunction).name;
+        if (!name) return '';
+        if (typeof name === 'symbol') return name.toString();
+        return name;
+    }
+    createJitParamsFunction(jitFn: JitFn, opts?: RunTypeOptions): (...args: any[]) => any {
+        return this.createJitCompiledParamsFunction(jitFn, opts).fn;
+    }
+    createJitCompiledParamsFunction(jitFn: JitFn, opts?: RunTypeOptions): JitCompiledFn {
+        const start = opts?.paramsSlice?.start;
+        const end = opts?.paramsSlice?.end;
+        if (start && end) {
+            if (start < 0 || end > this.parameterRunTypes.getChildRunTypes().length)
+                throw new Error(`Invalid paramsSlice, start: ${start}, end: ${end}.`);
+            if (end <= start) throw new Error(`Invalid paramsSlice, start: ${start}, end: ${end}`);
+        }
+        return this.parameterRunTypes.createJitCompiledFunction(jitFn.id, undefined, opts);
+    }
+    createJitReturnFunction(jitFn: JitFn): (...args: any[]) => any {
+        return this.createJitCompiledReturnFunction(jitFn).fn;
+    }
+
+    createJitCompiledReturnFunction(jitFn: JitFn, opts?: RunTypeOptions): JitCompiledFn {
+        return this.getResolvedReturnType().createJitCompiledFunction(jitFn.id, undefined, opts);
+    }
+
+    // ######## JIT functions (all throw error) ########
+
+    // can't know the types of the run type function parameters, neither the return type, so only compare function name and length
+    emitIsType(comp: JitFnCompiler): JitCode {
+        const minLength = this.parameterRunTypes.totalRequiredParams(comp);
+        const totalParams = this.parameterRunTypes.getParamRunTypes(comp).length;
+        const hasOptional = totalParams > minLength;
+        const maxLength =
+            this.parameterRunTypes.hasRestParameter(comp) || !hasOptional ? '' : ` && ${comp.vλl}.length <= ${totalParams}`;
+        return {code: `(typeof ${comp.vλl} === 'function' && ${comp.vλl}.length >= ${minLength} ${maxLength})`, type: 'E'};
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        return {code: `if (!(${this.emitIsType(comp).code})) ${comp.callJitErr(this)};`, type: 'S'};
+    }
+    /**
+     * json encode a function
+     */
+    emitPrepareForJson(): JitCode {
+        throw new Error(`Compile function PrepareForJson not supported, call compileParams or compileReturn instead.`);
+    }
+    emitRestoreFromJson(): JitCode {
+        throw new Error(`Compile function RestoreFromJson not supported, call compileParams or compileReturn instead.`);
+    }
+    emitHasUnknownKeys(): JitCode {
+        return {code: '', type: 'E'};
+    }
+    emitUnknownKeyErrors(): JitCode {
+        return {code: '', type: 'S'};
+    }
+    emitStripUnknownKeys(): JitCode {
+        return {code: '', type: 'S'};
+    }
+    emitUnknownKeysToUndefined(): JitCode {
+        return {code: '', type: 'S'};
+    }
+
+    // TODO: paramsSlice has been removed as options are not jet passed when building the run type. maybe we can pass it to the JitCompileOperation instead
+    // constructor() {
+    //     const start = opts?.paramsSlice?.start;
+    //     const end = opts?.paramsSlice?.end;
+    //     parameterRunTypes = src.parameters.slice(start, end).map((p) => visitor(p, parents, opts)) as ParameterRunType[];
+    // }
+    getReturnType(): BaseRunType {
+        return (this.src.return as SrcType)._rt as BaseRunType;
+    }
+    /** returns the inner run-type when the handler returns Promise<T> (or nested Promise/function-return chains), or the plain return type otherwise */
+    getResolvedReturnType(): BaseRunType {
+        let currentType: PromiseRunType | FunctionRunType<any> = this; // eslint-disable-line @typescript-eslint/no-this-alias
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            if (isAnyFunctionRunType(currentType)) {
+                const returnType = currentType.getReturnType();
+                if (isPromiseRunType(returnType) || isFunctionRunType(returnType)) {
+                    currentType = returnType;
+                    continue;
+                }
+                return returnType;
+            }
+            const memberType = currentType.getMemberType();
+            if (isPromiseRunType(memberType) || isFunctionRunType(memberType)) {
+                currentType = memberType;
+                continue;
+            }
+            return memberType;
+        }
+    }
+    getParameters(): FunctionParamsRunType {
+        return this.parameterRunTypes;
+    }
+    getParameterNames(opts?: RunTypeOptions): string[] {
+        const start = opts?.paramsSlice?.start;
+        const end = opts?.paramsSlice?.end;
+        if (start || end) {
+            return this.src.parameters.slice(start, end).map((p) => p.name);
+        }
+        return this.src.parameters.map((p) => p.name);
+    }
+    hasReturnData(): boolean {
+        const returnKind = this.getReturnType().src.kind;
+        return (
+            returnKind !== ReflectionKind.void && returnKind !== ReflectionKind.never && returnKind !== ReflectionKind.undefined
+        );
+    }
+    isAsync(): boolean {
+        const returnKind = this.getReturnType().src.kind;
+        return (
+            returnKind === ReflectionKind.promise || returnKind === ReflectionKind.any || returnKind === ReflectionKind.unknown
+        );
+    }
+    returnIsPromise(): boolean {
+        return isPromiseRunType(this.getReturnType());
+    }
+    async mockReturn(ctx?: RunTypeOptions): Promise<any> {
+        await registerJitFunctionCompiler(JitFunctions.mock);
+        return this.getReturnType().mockType(ctx);
+    }
+    async mockParams(ctx?: RunTypeOptions): Promise<any[]> {
+        await registerJitFunctionCompiler(JitFunctions.mock);
+        return this.parameterRunTypes.mockType(ctx);
+    }
+}