@mionjs/run-types 0.8.10 → 0.13.2

package/src/nodes/collection/union.ts

@@ -1,205 +0,0 @@
-/* ########
- * 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

@@ -1,259 +0,0 @@
-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

@@ -1,166 +0,0 @@
-/* ########
- * 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);
-    }
-}