@mionjs/run-types 0.8.7 → 0.8.8

package/src/lib/baseRunTypeFormat.ts

@@ -0,0 +1,320 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* ########
+ * 2025 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+import type {TypeFormatParams, CompiledPureFunction, TypeFormatValue, JitCompiledFn} from '@mionjs/core';
+import type {BaseRunType} from './baseRunTypes.ts';
+import {createJitCompiler, type JitFnCompiler, type JitErrorsFnCompiler} from './jitFnCompiler.ts';
+import type {JitFnID, Mutable, StrNumber, JitCode, RunTypeOptions} from '../types.ts';
+import {JitFunctions} from '../constants.functions.ts';
+import {ReflectionKind} from '@deepkit/type';
+import {dependenciesToLiteral, getFormatterParams, paramsToLiteral} from './formats.ts';
+import {getFormatterHash} from './utils.ts';
+import {getENV, getJitUtils} from '@mionjs/core';
+
+/**
+ * Base class for all RunType formatters.
+ * A type format is a type that satisfies some extra constrains, like emails, alphanumeric, uuids etc...
+ * All those are formats of string.
+ * At the moment only formats for string and numbers are supported.
+ * Jit formatters receive some params and generate JIT code depending on these params.
+ */
+export abstract class BaseRunTypeFormat<P extends TypeFormatParams = any> {
+    abstract kind: ReflectionKind;
+    abstract name: string;
+    /** The namespace for pure functions used by this formatter. Defaults to 'mionFormats'. */
+    readonly namespace: string = 'mionFormats';
+    rootFormatName: string = '';
+    /**
+     * The jit code for the formatter can be embedded together with the jit code for the type itself.
+     * but sometimes is better to create a separate function for code to be reused.
+     * This method is used to determine if the formatter code can be embedded or not.
+     */
+    canEmbedFormatterCode(_fnId: JitFnID, rt: BaseRunType, _params?: P): boolean {
+        if (rt.src.kind === ReflectionKind.number) return true;
+        // getFormatterJitId is similar to convert params to string
+        const paramsToString = rt.getFormatTypeID() || '';
+        // if there are many params, is better to not inline the formatter so the formatter function can be reused
+        // in the future we could optimize this logic, to decide if a formatter should be embedded or not
+        return paramsToString.length < 300;
+    }
+
+    /** Params from parent formatter */
+    readonly paramsFromParent?: P;
+    /**
+     * When set this in the path to the params in the parent's params object.
+     * ie: if dateTime is the parent of the current formatter and params are {date: {format: 'ISO'}} then the child path will be ['date']
+     */
+    readonly parentPath?: StrNumber[];
+    /** List of params that will be excluded from jit code */
+    readonly extraPathLiteral?: StrNumber;
+
+    /**
+     * The parentPath is the path to the params in the parent's params Formatter.
+     * ie: if dateTime is the parent of the current formatter and params are {date: {format: 'ISO'}} then the child path will be ['date']
+     */
+    constructor(parentPath?: StrNumber[]) {
+        this.parentPath = parentPath;
+    }
+
+    private pushContext(paramsFromParent?: P) {
+        (this as Mutable<BaseRunTypeFormat>).paramsFromParent = paramsFromParent;
+    }
+
+    private popContext() {
+        (this as Mutable<BaseRunTypeFormat>).paramsFromParent = undefined;
+    }
+
+    isRootFormat() {
+        return !this.parentPath?.length;
+    }
+
+    getFormatNestLevel() {
+        return this.parentPath?.length || 0;
+    }
+
+    getParams(rt: BaseRunType): NonNullable<P> {
+        if (this.paramsFromParent) return this.paramsFromParent as NonNullable<P>;
+        const params = getFormatterParams(rt, this.name) as NonNullable<P>;
+        return params;
+    }
+
+    getFormatName(): string {
+        return this.rootFormatName || this.name;
+    }
+
+    /** Returns the path to the params in the parent's params object */
+    getFormatPath(paramName?: StrNumber): StrNumber[] {
+        if (!paramName && this.parentPath) return [...this.parentPath];
+        if (!paramName) return [];
+        return this.parentPath ? [...this.parentPath, paramName] : [paramName];
+    }
+
+    getFormatExtraPathLiteral(): StrNumber | undefined {
+        return this.extraPathLiteral;
+    }
+
+    getIgnoredProps(): string[] | undefined {
+        return undefined;
+    }
+
+    mock(opts: RunTypeOptions, rt: BaseRunType, params?: P): any {
+        if (this.validateParams) this.validateParams(rt, params || this.getParams(rt));
+        this.pushContext(params);
+        const result = this._mock(opts, rt);
+        this.popContext();
+        const formatter = this.createJitCompiledFormatter(JitFunctions.format.id, rt, undefined, params);
+        if (formatter.isNoop) return result;
+        return formatter.fn(result);
+    }
+
+    createJitCompiledFormatter(
+        fnID: JitFnID,
+        rt: BaseRunType,
+        comp?: JitFnCompiler,
+        params?: P,
+        vλl?: string,
+        formatName?: string,
+        opts: RunTypeOptions = {}
+    ): JitCompiledFn {
+        const hash = getFormatterHash(rt);
+        // created function will be an aux function prefixed with the original function id
+        // this is because the new jit function itself is a standalone function  and we don't want it colliding with any other jit function
+        const jitFnHash = `${JitFunctions.aux.id}_${fnID}_${hash}`;
+        const jitCompiled = getJitUtils().getJIT(jitFnHash);
+        if (jitCompiled) {
+            if (getENV('DEBUG_JIT') === 'VERBOSE')
+                console.log(`\x1b[32m Using cached function: ${jitCompiled.jitFnHash} \x1b[0m`);
+            comp?.updateDependencies(jitCompiled);
+            return jitCompiled;
+        }
+        // TODO: decide if we should add parent compiler or not as parent to createJitCompiler
+        const newJitCompiler: JitFnCompiler = createJitCompiler(rt, fnID, undefined, jitFnHash, hash, opts);
+        try {
+            const formatterCode = this.compileFormat(fnID, newJitCompiler, rt, params, vλl, formatName);
+            const withReturn = this.handleReturnValues(rt, newJitCompiler, formatterCode);
+            newJitCompiler.createJitFunction(withReturn);
+            comp?.updateDependencies(newJitCompiler as JitCompiledFn);
+        } catch (e) {
+            // if something goes wrong during compilation we want to remove the compiler from
+            // the cache as this is automatically added to jitUtils cache during compilation
+            newJitCompiler.removeFromJitCache();
+            throw e;
+        }
+
+        return newJitCompiler as JitCompiledFn;
+    }
+
+    compileFormat(
+        fnID: JitFnID,
+        comp: JitFnCompiler,
+        rt: BaseRunType,
+        params?: P,
+        vλl?: string,
+        formatName?: string,
+        extraPathLiteral?: StrNumber
+    ): JitCode {
+        if (this.validateParams) this.validateParams(rt, params || this.getParams(rt));
+        (this as Mutable<BaseRunTypeFormat>).extraPathLiteral = extraPathLiteral;
+        const v = comp.vλl;
+        comp.vλl = vλl || v;
+        this.rootFormatName = formatName || this.name;
+        this.pushContext(params);
+        let result: JitCode;
+        switch (fnID) {
+            case JitFunctions.isType.id:
+                result = this.emitIsType(comp, rt);
+                break;
+            case JitFunctions.typeErrors.id:
+                result = this.emitIsTypeErrors(comp as JitErrorsFnCompiler, rt);
+                break;
+            case JitFunctions.format.id:
+                result = this.emitFormat ? this.emitFormat(comp, rt) : {code: undefined, type: 'S'};
+                break;
+            case JitFunctions.toBinary.id:
+                result = this.emitToBinary ? this.emitToBinary(comp, rt) : {code: undefined, type: 'S'};
+                break;
+            case JitFunctions.fromBinary.id:
+                result = this.emitFromBinary ? this.emitFromBinary(comp, rt) : {code: undefined, type: 'S'};
+                break;
+            // JSON serialization functions - formats don't need special handling for JSON
+            // Just return the value as-is (expression type 'E' with empty code means use vλl)
+            case JitFunctions.prepareForJson.id:
+            case JitFunctions.restoreFromJson.id:
+            case JitFunctions.stringifyJson.id:
+            case JitFunctions.toJSCode.id:
+                result = {code: '', type: 'E'};
+                break;
+            default:
+                throw new Error(`Method not implemented: ${fnID}`);
+        }
+        this.popContext();
+        this.rootFormatName = this.name;
+        (this as Mutable<BaseRunTypeFormat>).extraPathLiteral = undefined;
+        comp.vλl = v;
+        return result;
+    }
+
+    /**
+     * Adds return statements if needed
+     * Unlike handleReturnValues in BaseRunType this one is only called in the root of the formatter
+     */
+    handleReturnValues(rt: BaseRunType, comp: JitFnCompiler, jitC: JitCode): string {
+        if (!jitC?.code) return '';
+        const codeType = jitC.type;
+        switch (codeType) {
+            case 'E':
+                return `return ${jitC.code}`;
+            case 'RB':
+                return jitC.code;
+            case 'S': {
+                // For non-expressions, add a return statement with the default return value
+                // if the code doesn't already have a return statement
+                const lastChar = jitC.code.length - 1;
+                const hasFullStop = jitC.code.lastIndexOf(';') === lastChar || jitC.code.lastIndexOf('}') === lastChar;
+                const stopChar = hasFullStop ? '' : ';';
+                return `${jitC.code}${stopChar} return ${comp.returnName}`;
+            }
+        }
+    }
+
+    abstract _mock(opts: RunTypeOptions, rt: BaseRunType): any;
+    abstract emitIsType(comp: JitFnCompiler, rt: BaseRunType): JitCode;
+    abstract emitIsTypeErrors(comp: JitErrorsFnCompiler, rt: BaseRunType): JitCode;
+
+    // ###### optional methods for type formatters ########
+
+    /** Optional method to compile the formatter function that transforms/sanitize a value */
+    emitFormat?(comp: JitFnCompiler, rt: BaseRunType): JitCode;
+
+    /** Optional method that customizes the binary serialization */
+    emitToBinary?(comp: JitFnCompiler, rt: BaseRunType): JitCode;
+    /** Optional method that customizes the binary deserialization */
+    emitFromBinary?(comp: JitFnCompiler, rt: BaseRunType): JitCode;
+
+    /** Throws an error if params are not valid */
+    validateParams?(rt: BaseRunType, params: P): void;
+
+    compilePureFunctionCall(
+        comp: JitFnCompiler,
+        rt: BaseRunType,
+        compiledPureFn: CompiledPureFunction,
+        params?: TypeFormatValue,
+        dependenciesParams?: Record<string, string | CompiledPureFunction>
+    ): {callCode: string; fnName: string; paramsName: string; dependenciesName?: string} {
+        // PureFunction arguments =>
+
+        // val: any
+        // formatParams: TypeFormatValue,
+        // deps: PureFunctionDeps
+
+        const val = comp.vλl;
+        const paramsName = paramsToLiteral(comp, params || this.getParams(rt), this.getIgnoredProps());
+        const dependenciesName = dependenciesToLiteral(comp, dependenciesParams || {});
+        const callParams = [val, paramsName, dependenciesName];
+        const fnName = comp.addPureFunction(compiledPureFn);
+        const callCode = `${fnName}(${callParams.join(',')})`;
+        return {callCode, fnName, paramsName, dependenciesName};
+    }
+
+    compileErrorsPureFunctionCall(
+        comp: JitErrorsFnCompiler,
+        rt: BaseRunType,
+        compiledPureFn: CompiledPureFunction,
+        params: TypeFormatValue,
+        dependenciesParams?: Record<string, string | CompiledPureFunction>,
+        extraPathLiteral?: StrNumber // TODO: this might not be needed
+    ): {callCode: string; fnName: string; paramsName: string; dependenciesName?: string} {
+        // ErrorsPureFunction arguments =>
+
+        // val: any,
+        // pλth: StrNumber[],
+        // εrr: RunTypeError[],
+        // expected: string,
+
+        // formatName: string,
+        // formatParams: P,
+        // formatPath: StrNumber[],
+        // deps: PureFunctionDeps,
+        // accessPath?: StrNumber[]
+
+        const val = comp.vλl;
+        const path = comp.args.pλth;
+        const err = comp.args.εrr;
+        const expected = paramsToLiteral(comp, rt.getKindName());
+
+        const formatName = paramsToLiteral(comp, this.getFormatName());
+        const formatParams = paramsToLiteral(comp, params, this.getIgnoredProps());
+        const formatPath = paramsToLiteral(comp, this.getFormatPath());
+        const deps = dependenciesToLiteral(comp, dependenciesParams || {});
+        const accessPath = comp.getAccessPathLiteral(extraPathLiteral);
+
+        const callParams = [val, path, err, expected, formatName, formatParams, formatPath, deps];
+        if (accessPath) callParams.push(accessPath);
+
+        const fnName = comp.addPureFunction(compiledPureFn);
+        const callCode = `${fnName}(${callParams.join(',')})`;
+        return {callCode, fnName, paramsName: formatParams, dependenciesName: deps};
+    }
+
+    getCallJitFormatErr(
+        comp: JitErrorsFnCompiler,
+        expected: BaseRunType<any>,
+        formatter: BaseRunTypeFormat<any>,
+        shouldReturn = false,
+        extraPathLiteral?: StrNumber
+    ) {
+        return (paramName: string, paramValue: string | number | boolean | bigint) => {
+            const callCode = comp.callJitFormatErr(expected, formatter, paramName, paramValue, extraPathLiteral);
+            if (shouldReturn) return `return ${callCode}, ${comp.args.εrr}`;
+            return callCode;
+        };
+    }
+
+    printPath(rt: BaseRunType, paramName?: string): string {
+        return [rt.getTypeName(), ...this.getFormatPath(paramName)].join('.');
+    }
+}

package/src/lib/baseRunTypes.ts

@@ -0,0 +1,367 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+import {MAX_STACK_DEPTH, JitCompiledFn, createUniqueHash, getJitUtils, getENV} from '@mionjs/core';
+import type {
+    RunType,
+    Mutable,
+    RunTypeChildAccessor,
+    JitFnID,
+    SrcType,
+    SrcCollection,
+    CustomVλl,
+    JitFn,
+    JitCode,
+    RunTypeOptions,
+    StrNumber,
+    DeepPartial,
+    RunTypeFamily,
+} from '../types.ts';
+import type {mockType} from '../mocking/mockType.ts';
+import {maxStackErrorMessage} from '../constants.ts';
+import {type CodeType, JitFunctions, CodeTypes} from '../constants.functions.ts';
+import {ReflectionKind, stringifyType} from '@deepkit/type';
+import type {TypeIndexSignature, TypeProperty, Type} from '@deepkit/type';
+import {getPropIndex, memorize} from './utils.ts';
+import {createJitCompiler, MockJitCompiler} from './jitFnCompiler.ts';
+import {getJITFnHash} from './createJitFunction.ts';
+import type {JitFnCompiler, JitErrorsFnCompiler} from './jitFnCompiler.ts';
+import {type AnyKindName, getReflectionName} from '../constants.kind.ts';
+import {initFormatAnnotations} from './formats.ts';
+import {createTypeId} from './typeId.ts';
+import {getJitFunctionCompiler, registerJitFunctionCompiler} from './jitFnsRegistry.ts';
+import {defaultMockOptions} from '../mocking/constants.mock.ts';
+
+const RB = CodeTypes.returnBlock;
+const S = CodeTypes.statement;
+const E = CodeTypes.expression;
+
+export abstract class BaseRunType<T extends Type = Type> implements RunType {
+    isCircular?: boolean;
+    readonly src: SrcType<T> = null as any; // real value will be set after construction by the createRunType function
+    abstract getFamily(): RunTypeFamily; // Atomic, Collection, Member, Function
+    /**
+     * This single functions controls whether or not the code for a type should be inlined into the parent function
+     * or should create a separate jit function for it, add as a dependency and call it.
+     * @returns
+     */
+    isJitInlined = (): boolean => {
+        // if is circular, always create a separate jit function as need to self invoke
+        if (this.isCircular) return false;
+        if (getENV('DEBUG_JIT') === 'INLINED') return true;
+        // all array  are self invoked for isType and are usually repeated type like string[] or number[] so worth deduplicating
+        if (this.src.kind === ReflectionKind.array) return false;
+        // collection with name might be used in different places so worth deduplicating
+        if (this.src.typeName && this.getFamily() === 'C') return false;
+        return true;
+    };
+    getKindName = memorize((): AnyKindName => getReflectionName(this));
+    getTypeName = (): string => this.src.typeName || this.getKindName();
+    stringify = memorize((): string => stringifyType(this.src));
+    skipJit(comp: JitFnCompiler): boolean {
+        return false;
+    }
+    /** Returns the format portion of the type ID (cached in src._formatId), or undefined if no format. */
+    getFormatTypeID(): string | undefined {
+        // _formatId is cached by computeDeepkitFormatID during getDeepkitTypeId call
+        // Empty string means no format, undefined means not computed yet
+        const formatId = (this.src as any)._formatId;
+        return formatId || undefined;
+    }
+    /** Returns the type ID which is cached in src._typeId by getDeepkitTypeId(). Format ID is already included. */
+    getTypeID(): StrNumber {
+        if (this.src._typeId === undefined) {
+            throw new Error(`Missing cached type ID for ${this.getTypeName()}. Ensure getDeepkitTypeId() has been called.`);
+        }
+        return this.src._typeId;
+    }
+    getJitHash(opts: RunTypeOptions): string {
+        const optsCopy = {...opts};
+        // remove mock options as not relevant for jit functionality
+        if (optsCopy.mock) delete optsCopy.mock;
+        return createUniqueHash(this.getTypeID().toString() + JSON.stringify(optsCopy));
+    }
+    getParent = (): BaseRunType | undefined => (this.src.parent as SrcType)?._rt as BaseRunType;
+    checkIsCircularAndGetRefId(stack: RunType[] = []): StrNumber | undefined {
+        const inStackIndex = stack.findIndex((rt) => {
+            if (rt === this) return true;
+            // some nodes seems to be different objects in memory but are the same id, so we check by id as well
+            return rt.src.id && this.src.id && rt.src.id === this.src.id;
+        }); // cant use isSameJitType because it uses getTypeID and would loop forever
+        const inStackSrcId = stack.findIndex((rt) => rt.src.id && this.src.id && rt.src.id === this.src.id);
+        const isInStack = inStackIndex >= 0; // recursive reference
+        if (isInStack) {
+            this.isCircular = true;
+            const name = this.src.typeName || ''; // todo: not sure if all the circular references will have a name
+            const refId = '$' + this.src.kind + `_${inStackIndex}` + name; // ensures different circular types have different typeID
+            return refId;
+        }
+        return undefined;
+    }
+    /**
+     * Method that should be called Immediately after the RunType gets created to link the SrcType and RunType.
+     * This is more flexible than passing params to the constructor helps to avoid circular dependencies, etc.
+     * */
+    onCreated(src: SrcType<any>): void {
+        (this as Mutable<RunType>).src = src;
+        (src as Mutable<SrcType>)._rt = this;
+        initFormatAnnotations(this);
+        // Cache the type ID on the src object - this includes format information
+        createTypeId(src);
+    }
+    /**
+     * Some elements might need a standalone name variable that ignores the vλl value of the parents.
+     * returns a variable that is being compiled, ignores the parents variable names */
+    getCustomVλl(comp: JitFnCompiler): CustomVλl | undefined {
+        return undefined;
+    }
+    /**
+     * Some elements might need a custom static path to be able to reference the source of an error.
+     * ie: when validating a Map we need to differentiate if the value that failed is the  key or the value of a map's entry.
+     */
+    getStaticPathLiteral(comp: JitFnCompiler): string | number | undefined {
+        return undefined;
+    }
+
+    // ########## Mock ##########
+
+    async mock(opts?: DeepPartial<RunTypeOptions>): Promise<any> {
+        // although the mock function is not jit, it is also stored in the registry
+        // this is because we don't want to load mock related functionality if not needed
+        await registerJitFunctionCompiler(JitFunctions.mock);
+        return this.mockType(opts);
+    }
+
+    /** synchronous version of mock, throws an error if the mock function has not been loaded */
+    mockType(opts: DeepPartial<RunTypeOptions> = {}): any {
+        const mockFn = getJitFunctionCompiler(JitFunctions.mock) as typeof mockType;
+        if (!mockFn)
+            throw new Error(
+                `Function ${JitFunctions.mock.name} has not been loaded. make sure you have called loadJitCompilerFunction(JitFunctions.mock) before calling mockType.`
+            );
+        const fnID = JitFunctions.mock.id;
+        // options sent to the compiler will be set to empty as mock options are handled separately from the compiler
+        const mockingOpts = {...opts, mock: {...defaultMockOptions, ...(opts.mock || {})}} as RunTypeOptions;
+        const hash = getJITFnHash(fnID, this, mockingOpts);
+        const comp = new MockJitCompiler(this, mockingOpts, undefined, hash, this.getTypeID());
+        return mockFn(this, comp);
+    }
+
+    // ########## Create Jit Functions ##########
+
+    createJitFunction = (jitFn: JitFn, opts: RunTypeOptions = {}): ((...args: any[]) => any) => {
+        return this.createJitCompiledFunction(jitFn.id, undefined, opts).fn;
+    };
+
+    createJitCompiledFunction(fnID: JitFnID, parentCop?: JitFnCompiler, opts: RunTypeOptions = {}): JitCompiledFn {
+        const fnHash = getJITFnHash(fnID, this, opts);
+        const jitCompiled = getJitUtils().getJIT(fnHash);
+        if (jitCompiled) {
+            if (getENV('DEBUG_JIT') === 'VERBOSE')
+                console.log(`\x1b[32m Using cached function: ${jitCompiled.jitFnHash} \x1b[0m`);
+            return jitCompiled;
+        }
+        const newJitCompiler: JitFnCompiler = createJitCompiler(
+            this,
+            fnID,
+            parentCop,
+            undefined,
+            undefined,
+            opts
+        ) as JitFnCompiler;
+        try {
+            const codeType = this.getFamily() === 'A' ? E : S;
+            newJitCompiler.compile(this, codeType, fnID);
+            newJitCompiler.createJitFunction();
+        } catch (e: any) {
+            // if something goes wrong during compilation we want to remove the compiler from
+            // the cache as this is automatically added to jitUtils cache during compilation
+            newJitCompiler.removeFromJitCache();
+            // TODO: we need to print the full path to the type that is causing the error
+            // for this ideally we should add a parent Compiler and print the trace only from the root
+            if (typeof e?.message === 'string' && !newJitCompiler.hasStackTrace(e.message))
+                e.message += newJitCompiler.getStackTrace();
+            throw e;
+        }
+        return newJitCompiler as JitCompiledFn;
+    }
+
+    // ########## emit Methods that generates src code ##########
+
+    abstract emitIsType(comp: JitFnCompiler, expectedCType: CodeType): JitCode;
+    abstract emitTypeErrors(comp: JitErrorsFnCompiler, expectedCType: CodeType): JitCode;
+    abstract emitHasUnknownKeys(comp: JitFnCompiler, expectedCType: CodeType): JitCode;
+    abstract emitUnknownKeyErrors(comp: JitErrorsFnCompiler, expectedCType: CodeType): JitCode;
+    abstract emitStripUnknownKeys(comp: JitFnCompiler, expectedCType: CodeType): JitCode;
+    abstract emitUnknownKeysToUndefined(comp: JitFnCompiler, expectedCType: CodeType): JitCode;
+    // todo: maybe we should move these two into a single file like the rest of serializers
+    abstract emitPrepareForJson(comp: JitFnCompiler, expectedCType: CodeType): JitCode;
+    abstract emitRestoreFromJson(comp: JitFnCompiler, expectedCType: CodeType): JitCode;
+}
+
+/**
+ * RunType that is atomic an does not contains any other child runTypes.
+ * ie: string, number, boolean, any, null, undefined, void, never, bigint, etc.
+ * */
+export abstract class AtomicRunType<T extends Type> extends BaseRunType<T> {
+    getFamily(): 'A' {
+        return 'A';
+    }
+    emitPrepareForJson(comp: JitFnCompiler): JitCode {
+        return {code: undefined, type: S};
+    }
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
+        return {code: undefined, type: S};
+    }
+    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {
+        return {code: undefined, type: E};
+    }
+    emitUnknownKeyErrors(comp: JitFnCompiler): JitCode {
+        return {code: undefined, type: S};
+    }
+    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {
+        return {code: undefined, type: S};
+    }
+    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {
+        return {code: undefined, type: S};
+    }
+}
+
+/**
+ * RunType that contains a collection or child runTypes.
+ * Collection RunTypes are the only ones that can have circular references. as a child of a collection RunType can be the parent of the collection RunType.
+ * i.e: interface, child runTypes are it's properties
+ * i.e: tuple, it's child runTypes are the tuple members
+ */
+export abstract class CollectionRunType<T extends Type> extends BaseRunType<T> {
+    getFamily(): 'C' {
+        return 'C';
+    }
+    getChildRunTypes = (): BaseRunType[] => {
+        const childTypes = ((this.src as SrcCollection).types as SrcType[]) || []; // deepkit stores child types in the types property
+        return childTypes.map((t) => t._rt as BaseRunType);
+    };
+    getJitChildren(comp: JitFnCompiler): BaseRunType[] {
+        let skipIndex = false; // if there are multiple index signatures, only the first one will be used as they must be same type just different keys
+        return this.getChildRunTypes().filter((c) => {
+            if (c.skipJit(comp)) return false;
+            const isIndex = c.src.kind === ReflectionKind.indexSignature;
+            if (isIndex && skipIndex) return false;
+            if (isIndex) skipIndex = true;
+            return true;
+        });
+    }
+    areAllChildrenOptional(children: BaseRunType[]) {
+        return children.every(
+            (prop) =>
+                (prop as MemberRunType<any>)?.isOptional() ||
+                (prop.src as TypeProperty)?.optional ||
+                prop.src.kind === ReflectionKind.indexSignature
+        );
+    }
+    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {
+        const codes = this.getJitChildren(comp)
+            .map((c) => comp.compileHasUnknownKeys(c, E).code)
+            .filter((code) => !!code);
+        return {code: codes.join(' || '), type: E};
+    }
+    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {
+        const codes = this.getJitChildren(comp)
+            .map((c) => comp.compileUnknownKeyErrors(c, S).code)
+            .filter((code) => !!code);
+        return {code: codes.join(';'), type: S};
+    }
+    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {
+        const codes = this.getJitChildren(comp)
+            .map((c) => comp.compileStripUnknownKeys(c, S).code)
+            .filter((code) => !!code);
+        return {code: codes.join(';'), type: S};
+    }
+    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {
+        const codes = this.getJitChildren(comp)
+            .map((c) => comp.compileUnknownKeysToUndefined(c, S).code)
+            .filter((code) => !!code);
+        return {code: codes.join(';'), type: S};
+    }
+}
+
+/**
+ * RunType that contains a single member or child RunType. usually part of a collection RunType.
+ * i.e object properties, {prop: memberType} where memberType is the child RunType
+ */
+export abstract class MemberRunType<T extends Type> extends BaseRunType<T> implements RunTypeChildAccessor {
+    abstract isOptional(): boolean;
+    abstract getChildVarName(comp: JitFnCompiler): string | number;
+    abstract getChildLiteral(comp: JitFnCompiler): string | number;
+    abstract useArrayAccessor(): boolean;
+    /** used to compile json stringify */
+    skipCommas?: boolean;
+    /** used to compile json stringify */
+    tempChildVλl?: string;
+    getFamily(): 'M' {
+        return 'M';
+    }
+    getMemberType(): BaseRunType {
+        const memberType = (this.src as any).type as SrcType; // deepkit stores member types in the type property
+        return memberType._rt as BaseRunType;
+    }
+    getChildIndex(comp: JitFnCompiler) {
+        const start = comp?.opts?.paramsSlice?.start;
+        if (start) return getPropIndex(this.src) - start;
+        return getPropIndex(this.src);
+    }
+    getJitChild(comp: JitFnCompiler): BaseRunType | undefined {
+        const member: BaseRunType = this.getMemberType();
+        if (member.skipJit(comp)) return undefined;
+        return member;
+    }
+    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const codeResult = comp.compileHasUnknownKeys(child, E);
+        if (!codeResult?.code) return {code: undefined, type: E};
+        const childName = comp.getChildVλl();
+        const finalCode = this.isOptional() ? `(${childName} !== undefined && ${codeResult.code})` : codeResult.code;
+        return {code: finalCode, type: codeResult.type};
+    }
+    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const codeResult = comp.compileUnknownKeyErrors(child, S);
+        if (!codeResult?.code) return {code: undefined, type: S};
+        const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;
+        return {code: finalCode, type: codeResult.type};
+    }
+    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const codeResult = comp.compileStripUnknownKeys(child, S);
+        if (!codeResult?.code) return {code: undefined, type: S};
+        const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;
+        return {code: finalCode, type: codeResult.type};
+    }
+    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const codeResult = comp.compileUnknownKeysToUndefined(child, S);
+        if (!codeResult?.code) return {code: undefined, type: S};
+        const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;
+        return {code: finalCode, type: codeResult.type};
+    }
+    visitToBinary(comp: JitFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const code = comp.compileToBinary(child, S);
+        if (!code?.code) return {code: undefined, type: S};
+        return this.isOptional()
+            ? {code: `(${comp.getChildVλl()} !== undefined ? ${code.code} : utl.writeBinaryNull())`, type: S}
+            : code;
+    }
+    visitFromBinary(comp: JitFnCompiler): JitCode {
+        const child = this.getJitChild(comp);
+        const code = comp.compileFromBinary(child, S);
+        if (!code?.code) return {code: undefined, type: S};
+        return code;
+    }
+}
+
+// ########## Load Composable Functions ##########