@mionjs/run-types 0.8.10 → 0.13.2

package/src/jitCompilers/json/stringifyJson.ts

@@ -1,476 +0,0 @@
-/* ########
- * 2025 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {ReflectionKind} from '@deepkit/type';
-import {ReflectionSubKind} from '../../constants.kind.ts';
-import {JitFunctions} from '../../constants.functions.ts';
-import {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
-import {createIfElseFn, isSafePropName, parentIs} from '../../lib/utils.ts';
-import type {IndexSignatureRunType} from '../../nodes/member/indexProperty.ts';
-import type {JitCode} from '../../types.ts';
-import type {BaseRunType} from '../../lib/baseRunTypes.ts';
-import type {ClassRunType} from '../../nodes/collection/class.ts';
-import type {PropertyRunType} from '../../nodes/member/property.ts';
-import type {MapRunType} from '../../nodes/native/map.ts';
-import type {SetRunType} from '../../nodes/native/set.ts';
-import type {InterfaceRunType} from '../../nodes/collection/interface.ts';
-import type {TupleRunType} from '../../nodes/collection/tuple.ts';
-import type {FunctionParamsRunType} from '../../nodes/collection/functionParams.ts';
-import type {UnionRunType} from '../../nodes/collection/union.ts';
-import type {ParameterRunType} from '../../nodes/member/param.ts';
-import type {RestParamsRunType} from '../../nodes/member/restParams.ts';
-import type {ArrayRunType} from '../../nodes/member/array.ts';
-import type {MemberRunType} from '../../lib/baseRunTypes.ts';
-import type {LiteralRunType} from '../../nodes/atomic/literal.ts';
-import type {IterableRunType} from '../../nodes/native/Iterable.ts';
-import {cpf_asJSONString} from '../../run-types-pure-fns.ts';
-
-type Operation = typeof JitFunctions.stringifyJson.id | typeof JitFunctions.toJSCode.id;
-
-export function createStringifyCompiler(fnID: Operation) {
-    const compileStringifyIterable = createStringifyIterable(fnID);
-    /** Centralized compile jit function with a switch statement that handles all node types. */
-    function compileStringify(runType: BaseRunType, comp: JitFnCompiler): JitCode {
-        const src = runType.src;
-        const kind = src.kind;
-
-        switch (kind) {
-            // ###################### ATOMIC RUNTYPES ######################
-            // Primitive types and other atomic types that don't contain other types
-            case ReflectionKind.unknown:
-            case ReflectionKind.any:
-                return {code: `JSON.stringify(${comp.vλl})`, type: 'E'};
-            case ReflectionKind.bigint:
-                return {code: `'"'+${comp.vλl}.toString()+'"'`, type: 'E'};
-            case ReflectionKind.boolean:
-                return {code: `(${comp.vλl} ? 'true' : 'false')`, type: 'E'};
-            case ReflectionKind.enum:
-                if (src.indexType.kind === ReflectionKind.number) return {code: comp.vλl, type: 'E'};
-                return {code: `JSON.stringify(${comp.vλl})`, type: 'E'};
-            case ReflectionKind.enumMember:
-                throw new Error('StringifyJson enum member is not supported.');
-            case ReflectionKind.literal: {
-                const rt = runType as LiteralRunType;
-                if (src.literal instanceof RegExp) return compileStringify({src: {kind: ReflectionKind.regexp}} as any, comp);
-                const literalRt = runType;
-                const originalKind = src.kind;
-                let result: JitCode;
-                switch (typeof rt.src.literal) {
-                    case 'number':
-                        literalRt.src.kind = ReflectionKind.number;
-                        result = compileStringify(literalRt, comp);
-                        break;
-                    case 'string':
-                        literalRt.src.kind = ReflectionKind.string;
-                        result = compileStringify(literalRt, comp);
-                        break;
-                    case 'boolean':
-                        literalRt.src.kind = ReflectionKind.boolean;
-                        result = compileStringify(literalRt, comp);
-                        break;
-                    case 'bigint':
-                        literalRt.src.kind = ReflectionKind.bigint;
-                        result = compileStringify(literalRt, comp);
-                        break;
-                    case 'symbol':
-                        literalRt.src.kind = ReflectionKind.symbol;
-                        result = compileStringify(literalRt, comp);
-                        break;
-                    default:
-                        result = {code: `JSON.stringify(${comp.vλl})`, type: 'E'};
-                        break;
-                }
-                literalRt.src.kind = originalKind;
-                return result;
-            }
-            case ReflectionKind.never:
-                throw new Error('Never type cannot be stringified.');
-            case ReflectionKind.null: {
-                const isRoot = comp.getNestLevel(runType) === 0;
-                return {code: isRoot ? `String(${comp.vλl})` : comp.vλl, type: 'E'};
-            }
-            case ReflectionKind.number: {
-                const isRoot = comp.getNestLevel(runType) === 0;
-                return {code: isRoot ? `String(${comp.vλl})` : comp.vλl, type: 'E'};
-            }
-            case ReflectionKind.object:
-                return {code: `JSON.stringify(${comp.vλl})`, type: 'E'};
-            case ReflectionKind.regexp: {
-                return {code: `JSON.stringify(${comp.vλl}.toString())`, type: 'E'};
-            }
-            case ReflectionKind.string: {
-                return {code: `JSON.stringify(${comp.vλl})`, type: 'E'};
-            }
-            case ReflectionKind.symbol:
-                return {code: `JSON.stringify('Symbol:' + (${comp.vλl}.description || ''))`, type: 'E'};
-            case ReflectionKind.templateLiteral:
-                // runtime value is a plain string
-                return {code: `JSON.stringify(${comp.vλl})`, type: 'E'};
-            case ReflectionKind.undefined: {
-                const isRoot = comp.getNestLevel(runType) === 0;
-                if (isRoot) return {code: `undefined`, type: 'E'};
-                const parentIsArray = parentIs(runType, ReflectionKind.array);
-                if (parentIsArray) return {code: `'null'`, type: 'E'}; // we use array.join(',') to serialize arrays, so we need to return null literal (string)
-                return {code: `null`, type: 'E'};
-            }
-            case ReflectionKind.void:
-                return {code: 'undefined', type: 'E'};
-
-            // ###################### MEMBER RUNTYPES ######################
-            // Types that represent members of collections or other structures
-            case ReflectionKind.array: {
-                const rt = runType as ArrayRunType;
-                rt.checkNonSkipTypes(comp);
-                const childJit = comp.compile(rt.getJitChild(comp), 'E', fnID);
-                if (!childJit?.code) return {code: `JSON.stringify(${comp.vλl})`, type: 'RB'};
-                const jsonItems = comp.getLocalVarName('ls', rt);
-                const resultVal = comp.getLocalVarName('res', rt);
-                const index = rt.getChildVarName(comp);
-                return {
-                    code: `
-                const ${jsonItems} = [];
-                for (let ${index} = ${rt.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {
-                    const ${resultVal} = ${childJit.code};
-                    ${jsonItems}.push(${resultVal});
-                }
-                return '[' + ${jsonItems}.join(',') + ']';
-            `,
-                    type: 'RB',
-                };
-            }
-            case ReflectionKind.indexSignature: {
-                const rt = runType as IndexSignatureRunType;
-                const child = rt.getJitChild(comp);
-                const childJit = comp.compile(child, 'E', fnID);
-                if (!child || !childJit?.code) return {code: undefined, type: 'RB'};
-                const varName = comp.vλl;
-                const prop = rt.getChildVarName(comp);
-                const arrName = comp.getLocalVarName('ls', rt);
-                const sep = rt.skipCommas ? '' : '+","';
-                const skipCode = rt.getSkipCode(comp, prop);
-                // asJSONString is more optimized for propNames than JSON.stringify
-                // in Node, bun is actually slower so we might consider removing this and use native JSON.stringify
-                const asJSONStringFn = comp.addPureFunction(cpf_asJSONString);
-                return {
-                    code: `
-                const ${arrName} = [];
-                for (const ${prop} in ${varName}) {
-                    ${skipCode}
-                    if (${prop} !== undefined) ${arrName}.push(${asJSONStringFn}(${prop}) + ':' + ${childJit.code});
-                }
-                if (!${arrName}.length) return '';
-                return ${arrName}.join(',')${sep};
-            `,
-                    type: 'RB',
-                };
-            }
-            case ReflectionKind.function:
-            case ReflectionKind.method:
-            case ReflectionKind.methodSignature:
-            case ReflectionKind.callSignature:
-                if (runType.src.subKind === ReflectionSubKind.params) {
-                    const rt = runType as FunctionParamsRunType;
-                    const skip = rt.skipJit(comp);
-                    if (skip) return {code: '', type: 'E'};
-                    const params = rt.getParamRunTypes(comp);
-                    if (params.length === 0) return {code: `'[]'`, type: 'E'};
-                    const paramsCode = params.map((p) => comp.compile(p, 'E', fnID).code).join('+');
-                    return {code: `'['+${paramsCode}+']'`, type: 'E'};
-                } else {
-                    throw new Error(
-                        `Compile function ${getOperationName()} not supported, call compileParams or compileReturn instead.`
-                    );
-                }
-            case ReflectionKind.parameter: {
-                const rt = runType as ParameterRunType;
-                switch (src.subKind) {
-                    case ReflectionSubKind.mapKey:
-                    case ReflectionSubKind.mapValue:
-                    case ReflectionSubKind.setItem:
-                        return compileStringifyGenericMember(rt, comp);
-                    default:
-                        return compileStringifyParameter(rt, comp);
-                }
-            }
-            case ReflectionKind.property:
-            case ReflectionKind.propertySignature: {
-                const rt = runType as PropertyRunType;
-                const child = rt.getJitChild(comp);
-                const childJit = comp.compile(child, 'E', fnID);
-                if (!child || !childJit?.code) return {code: undefined, type: 'E'};
-                // this can´t be processed in the parent as we need to handle the empty string case when value is undefined
-                const sep = rt.skipCommas ? '' : '+","';
-                // encoding safe property with ':' inside the string saves a little processing
-                // when prop is not safe we need to double encode double quotes and escape characters
-                const propDef = getPropName(rt, comp);
-                if (rt.src.optional) {
-                    rt.tempChildVλl = comp.getChildVλl();
-                    // TODO: check if json for an object with first property undefined is valid (maybe the comma must be dynamic too)
-                    return {code: `(${rt.tempChildVλl} === undefined ? '' : ${propDef}+${childJit.code}${sep})`, type: 'E'};
-                }
-                return {code: `${propDef}+${childJit.code}${sep}`, type: 'E'};
-            }
-            case ReflectionKind.rest: {
-                const rt = runType as RestParamsRunType;
-                const childJit = comp.compile(rt.getJitChild(comp), 'E', fnID);
-                const itemCodeStr = childJit?.code || 'JSON.stringify(' + comp.getChildVλl() + ')';
-                const arrName = comp.getLocalVarName('res', rt);
-                const itemName = comp.getLocalVarName('its', rt);
-                const index = rt.getChildVarName(comp);
-                const isFist = rt.getChildIndex(comp) === 0;
-                const sep = isFist ? '' : `','+`;
-                return {
-                    code: `
-                const ${arrName} = [];
-                for (let ${index} = ${rt.getChildIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {
-                    const ${itemName} = ${itemCodeStr};
-                    if(${itemName}) ${arrName}.push(${itemName});
-                }
-                if (!${arrName}.length) {return '';}
-                else {return ${sep}${arrName}.join(',')}
-            `,
-                    type: 'RB',
-                };
-            }
-            case ReflectionKind.tupleMember: {
-                const rt = runType as ParameterRunType;
-                const childJit = comp.compile(rt.getJitChild(comp), 'E', fnID);
-                const childCodeStr = childJit?.code || `null`; // non serializable types are set to null
-                if (rt.isRest()) return childJit || {code: `null`, type: 'E'};
-                const isFirst = rt.getChildIndex(comp) === 0;
-                const sep = isFirst ? '' : `','+`;
-                if (rt.isOptional())
-                    return {code: `(${comp.getChildVλl()} === undefined ? ${sep}'null' : ${sep}${childCodeStr})`, type: 'E'};
-                return {code: `${sep}${childCodeStr}`, type: 'E'};
-            }
-            case ReflectionKind.promise: {
-                throw new Error(`Jit compilation disabled for Non Serializable types.`);
-            }
-
-            // ###################### COLLECTION RUNTYPES ######################
-            // Types that contain other types as members
-            case ReflectionKind.objectLiteral:
-            case ReflectionKind.intersection: {
-                if (runType.src.subKind === ReflectionSubKind.nonSerializable) {
-                    throw new Error(`${getOperationName()} is disabled for Non Serializable types.`);
-                } else {
-                    const rt = runType as InterfaceRunType;
-                    return compileStringifyInterface(rt, comp);
-                }
-            }
-            case ReflectionKind.class:
-                return compileStringifyClass(runType, comp);
-            case ReflectionKind.infer:
-                throw new Error('Infer is not supported.');
-            case ReflectionKind.tuple: {
-                const rt = runType as TupleRunType;
-                const skip = rt.skipJit(comp);
-                if (skip) return {code: '', type: 'E'};
-                if (rt.getChildRunTypes().length === 0) return {code: `'[]'`, type: 'E'};
-                const paramsCode = rt
-                    .getChildRunTypes()
-                    .map((p) => comp.compile(p, 'E', fnID).code)
-                    .join('+');
-                return {code: `'['+${paramsCode}+']'`, type: 'E'};
-            }
-            case ReflectionKind.typeParameter:
-                // Type parameter has been replaced by tuple member internally so this should never be called
-                throw new Error('Type parameter not implemented.');
-            case ReflectionKind.union: {
-                const urt = runType as UnionRunType;
-                urt.checkAllowedChildren(comp);
-                const {simpleItems, objectTypes, anyItem} = urt.getUnionChildren(comp);
-                const errName = comp.getLocalVarName('uErr', urt);
-                const fail = `throw new Error(${errName});`;
-                comp.setContextItem(
-                    errName,
-                    `const ${errName} = "Can not ${getOperationName()} union: item does not belong to the union"`
-                );
-                const ifElse = createIfElseFn();
-                // Helper to generate stringify code for a union item
-                const getStringifyCode = (unionItem: BaseRunType) => {
-                    const childJit = comp.compile(unionItem, 'E', fnID);
-                    const encJit = comp.compilePrepareForJson(unionItem, 'E');
-                    const decJit = comp.compileRestoreFromJson(unionItem, 'E');
-                    const needsTupleEncoding = !!encJit?.code || !!decJit?.code;
-                    const skiEncode = !childJit?.code || childJit.code === comp.vλl;
-                    const stringifyCode = skiEncode ? comp.vλl : childJit.code;
-                    const index = urt.getUnionItemIndex(comp, unionItem);
-                    const toTuple = `'[${index},' + ${stringifyCode} + ']'`;
-                    const tupleCode = unionItem.getFamily() === 'A' ? `(${toTuple})` : toTuple;
-                    return needsTupleEncoding ? `return ${tupleCode}` : `return ${stringifyCode}`;
-                };
-                // Generate code for simple items (atomic types)
-                const simpleCode = simpleItems.map((unionItem) => {
-                    const isTypeCode = urt.getChildIsTypeWithLooseCheck(unionItem, comp);
-                    return `${ifElse()} (${isTypeCode}) {${getStringifyCode(unionItem)}}`;
-                });
-                // Generate code for object types (need null guard)
-                const objCode = objectTypes.length
-                    ? objectTypes.map((unionItem) => {
-                          const isTypeCode = urt.getChildIsTypeWithLooseCheck(unionItem, comp);
-                          return `${ifElse()} (typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null && ${isTypeCode}) {${getStringifyCode(unionItem)}}`;
-                      })
-                    : [];
-                // Generate code for anyItem (always matches, checked last as fallback)
-                const anyCode = anyItem ? `${ifElse(true)} {${getStringifyCode(anyItem)}}` : `${ifElse(true)} {${fail}}`;
-
-                return {code: [...simpleCode, ...objCode, anyCode].join(''), type: 'RB'};
-            }
-            default:
-                throw new Error(`Cant ${getOperationName()} for unsupported RunType: ${runType.getTypeName()}`);
-        }
-    }
-
-    function getOperationName() {
-        switch (fnID) {
-            case JitFunctions.stringifyJson.id:
-                return 'StringifyJson';
-            case JitFunctions.toJSCode.id:
-                return 'ToCode';
-            default:
-                throw new Error(`Unknown operation: ${fnID}`);
-        }
-    }
-
-    function getPropName(rt: PropertyRunType, comp: JitFnCompiler): string {
-        if (!isSafePropName(rt.src.name)) return `${JSON.stringify(rt.getChildLiteral(comp) as string)}+':'`;
-        if (fnID === JitFunctions.toJSCode.id) return `'${rt.getChildVarName(comp)}:'`;
-        return `'"${rt.getChildVarName(comp)}":'`;
-    }
-
-    function compileStringifyParameter(rt: ParameterRunType, comp: JitFnCompiler): JitCode {
-        const childJit = comp.compile(rt.getJitChild(comp), 'E', fnID);
-        const childCodeStr = childJit?.code || `null`; // non serializable types are set to null
-        if (rt.isRest()) return childJit || {code: `null`, type: 'E'};
-        const isFirst = rt.getChildIndex(comp) === 0;
-        const sep = isFirst ? '' : `','+`;
-        if (rt.isOptional())
-            return {code: `(${comp.getChildVλl()} === undefined ? ${sep}'null' : ${sep}${childCodeStr})`, type: 'E'};
-        return {code: `${sep}${childCodeStr}`, type: 'E'};
-    }
-
-    function compileStringifyGenericMember(rt: ParameterRunType, comp: JitFnCompiler): JitCode {
-        const child = rt.getJitChild(comp);
-        const argCode = comp.compile(child, 'E', fnID);
-        if (!argCode?.code) return {code: undefined, type: 'E'};
-        const isFirst = rt.getChildIndex(comp) === 0;
-        const sep = isFirst ? '' : `','+`;
-        if (rt.isOptional()) return {code: `(${comp.getChildVλl()} === undefined ? '': ${sep}${argCode.code})`, type: 'E'};
-        return {code: `${sep}${argCode.code}`, type: 'E'};
-    }
-
-    function compileStringifyInterface(rt: InterfaceRunType, comp: JitFnCompiler): JitCode {
-        if (rt.isCallable()) return comp.compile(rt.getCallSignature(), 'E', fnID);
-        const children = rt.getJsonStringifySortedChildren(comp);
-        if (children.length === 0) return {code: `''`, type: 'E'};
-        const allOptional = children.every((prop) => (prop as MemberRunType<any>).isOptional());
-        // if all properties are optional,  we can not optimize and use JSON.stringify
-        if (allOptional) return compileInterfaceIntoArray(rt, comp, children);
-        const childrenCode = children
-            .map((prop, i) => {
-                const nexChild = children[i + 1];
-                const isLast = !nexChild;
-                prop.skipCommas = isLast;
-                return comp.compile(prop, 'E', fnID).code;
-            })
-            .filter(Boolean)
-            .join('+');
-        return {code: `'{'+${childrenCode}+'}'`, type: 'E'};
-    }
-
-    function compileInterfaceIntoArray(rt: InterfaceRunType, comp: JitFnCompiler, children: MemberRunType<any>[]): JitCode {
-        const arrName = comp.getLocalVarName('ns', rt);
-        const childrenCode = children
-            .map((prop) => {
-                prop.skipCommas = true;
-                const childJit = comp.compile(prop, 'E', fnID);
-                if (!childJit?.code) return '';
-                const code = `${arrName}.push(${childJit.code})`;
-                // makes an extra check to avoid pushing empty strings to the array (childJit also makes the same check but is better than having to filter the array after)
-                return prop.isOptional() && prop.tempChildVλl ? `if (${prop.tempChildVλl} !== undefined){${code}}` : `${code};`;
-            })
-            .filter(Boolean)
-            .join('');
-
-        return {code: `(function(){const ${arrName} = [];${childrenCode};return '{'+${arrName}.join(',')+'}'})()`, type: 'E'};
-    }
-
-    function compileStringifyClass(runType: BaseRunType, comp: JitFnCompiler): JitCode {
-        switch (runType.src.subKind) {
-            case ReflectionSubKind.date:
-                return {code: `'"'+${comp.vλl}.toJSON()+'"'`, type: 'E'};
-            case ReflectionSubKind.map: {
-                const rt = runType as unknown as MapRunType;
-                return compileStringifyIterable(rt as unknown as IterableRunType, comp);
-            }
-            case ReflectionSubKind.set: {
-                const rt = runType as unknown as SetRunType;
-                return compileStringifyIterable(rt as unknown as IterableRunType, comp);
-            }
-            case ReflectionSubKind.nonSerializable:
-                throw new Error(`Jit compilation disabled for Non Serializable types.`);
-            default: {
-                const rt = runType as unknown as ClassRunType;
-                if (rt.isCallable()) {
-                    const callSignature = rt.getCallSignature();
-                    if (callSignature) return comp.compile(callSignature, 'E', fnID);
-                }
-                // optional and index properties must be compiled first to prevent trailing commas
-                // this is because the last trailing comma is calculated statically
-                // maybe we need to move that trailing comma compilation to be dynamic
-                // but we would need to create a self invoking function for that
-                const children = rt.getJsonStringifySortedChildren(comp);
-                if (children.length === 0) return {code: `''`, type: 'E'};
-                const childrenCode = children
-                    .map((prop, i) => {
-                        const nexChild = children[i + 1];
-                        const isLast = !nexChild;
-                        prop.skipCommas = isLast;
-                        return comp.compile(prop, 'E', fnID).code;
-                    })
-                    .filter(Boolean)
-                    .join('+');
-                return {code: `'{'+${childrenCode}+'}'`, type: 'E'};
-            }
-        }
-    }
-
-    return compileStringify;
-}
-
-export function createStringifyIterable(fnID: Operation) {
-    return function compileStringifyIterable(
-        rt: IterableRunType,
-        comp: JitFnCompiler,
-        /** prefix characters to add before the generated array, used when generating code instead json */
-        codePrefix: string = '',
-        /** suffix characters to add after the generated array, used when generating code instead json */
-        codeSuffix: string = ''
-    ): JitCode {
-        const entry = rt.getCustomVλl(comp)?.vλl || comp.vλl;
-        const jitChildren = rt.getJitChildren(comp);
-        const childrenCode = jitChildren.map((c) => comp.compile(c, 'E', fnID).code).join('+');
-        const jsonItems = comp.getLocalVarName('ls', rt);
-        const resultVal = comp.getLocalVarName('res', rt);
-        const childrenResult = jitChildren.length > 1 ? `'['+${childrenCode}+']'` : childrenCode;
-        const earlyReturn = codePrefix && codeSuffix ? `if (!${jsonItems}.length) return '${codePrefix}${codeSuffix}';` : '';
-        return {
-            code: `
-        const ${jsonItems} = [];
-        for (const ${entry} of ${comp.vλl}) {
-            const ${resultVal} = ${childrenResult};
-            ${jsonItems}.push(${resultVal});
-        }
-        ${earlyReturn}return '${codePrefix}[' + ${jsonItems}.join(',') + ']${codeSuffix}'
-    `,
-            type: 'RB',
-        };
-    };
-}
-
-export const emitJsonStringify = createStringifyCompiler(JitFunctions.stringifyJson.id);

package/src/jitCompilers/json/stringifySpec/stringifyHelpers.ts

@@ -1,59 +0,0 @@
-/* ########
- * 2025 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {JitFunctions} from '../../../constants.functions.ts';
-import type {InterfaceRunType} from '../../../nodes/collection/interface.ts';
-import type {FunctionRunType} from '../../../nodes/function/function.ts';
-import type {RunType} from '../../../types.ts';
-
-const SERIALIZE_FN = JitFunctions.stringifyJson;
-const DESERIALIZE_FN = JitFunctions.restoreFromJson;
-
-export function createSerializationFns(rt: RunType) {
-    const serialize = rt.createJitFunction(SERIALIZE_FN);
-    const restoreFromJson = rt.createJitFunction(DESERIALIZE_FN);
-    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));
-    return {serialize, deserialize};
-}
-
-export function createSerializationParamsFn(rt: FunctionRunType, sliceStart?: number) {
-    const params = typeof sliceStart === 'number' ? {paramsSlice: {start: sliceStart}} : undefined;
-    const serialize = rt.createJitParamsFunction(SERIALIZE_FN, params);
-    const restoreFromJson = rt.createJitParamsFunction(DESERIALIZE_FN, params);
-    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));
-    return {serialize, deserialize};
-}
-
-export function createSerializationReturnFn(rt: FunctionRunType) {
-    const serialize = rt.createJitReturnFunction(SERIALIZE_FN);
-    const restoreFromJson = rt.createJitReturnFunction(DESERIALIZE_FN);
-    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));
-    return {serialize, deserialize};
-}
-
-export function createSerializationCallSignatureParamsFn(rt: InterfaceRunType) {
-    const callSignature = rt.getCallSignature()!;
-    const serialize = callSignature.createJitParamsFunction(SERIALIZE_FN);
-    const restoreFromJson = callSignature.createJitParamsFunction(DESERIALIZE_FN);
-    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));
-    return {serialize, deserialize};
-}
-
-export function createSerializationCallSignatureReturnFn(rt: InterfaceRunType) {
-    const callSignature = rt.getCallSignature()!;
-    const serialize = callSignature.createJitReturnFunction(SERIALIZE_FN);
-    const restoreFromJson = callSignature.createJitReturnFunction(DESERIALIZE_FN);
-    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));
-    return {serialize, deserialize};
-}
-
-export function roundTrip(serialize: (v: any) => string, deserialize: (v: string) => any, value: any) {
-    const serialized = serialize(value);
-    const deserialized = deserialize(serialized);
-    const result = {serialized, deserialized};
-    return result;
-}