@mionjs/run-types 0.8.6 → 0.8.8

package/src/nodes/collection/interface.ts

@@ -0,0 +1,300 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+import {TypeObjectLiteral, TypeClass, TypeIntersection, ReflectionKind} from '@deepkit/type';
+import type {JitCode} from '../../types.ts';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import {arrayToLiteral, getJitFnArgCallVarName, memorize, sortDiscriminatorsFirst} from '../../lib/utils.ts';
+import {PropertyRunType} from '../member/property.ts';
+import {BaseRunType, CollectionRunType, MemberRunType} from '../../lib/baseRunTypes.ts';
+import {MethodSignatureRunType} from '../member/methodSignature.ts';
+import {IndexSignatureRunType} from '../member/indexProperty.ts';
+import {MethodRunType} from '../member/method.ts';
+import {CallSignatureRunType} from '../member/callSignature.ts';
+import {JitFunctions} from '../../constants.functions.ts';
+import {isIndexSignatureRunType} from '../../lib/guards.ts';
+import {cpf_getUnknownKeysFromArray, cpf_hasUnknownKeysFromArray} from '../../run-types-pure-fns.ts';
+
+export type InterfaceMember =
+    | PropertyRunType
+    | MethodSignatureRunType
+    | IndexSignatureRunType
+    | MethodRunType
+    | CallSignatureRunType;
+
+export class InterfaceRunType<
+    T extends TypeObjectLiteral | TypeClass | TypeIntersection = TypeObjectLiteral,
+> extends CollectionRunType<T> {
+    getNamedChildren(comp: JitFnCompiler): InterfaceMember[] {
+        return this.getJitChildren(comp).filter((prop) => !!(prop.src as any).name) as InterfaceMember[];
+    }
+
+    isCallable(): boolean {
+        return this.getCallSignature() !== undefined;
+    }
+
+    getCallSignature = memorize((): CallSignatureRunType | undefined => {
+        return this.getChildRunTypes().find((prop) => prop.src.kind === ReflectionKind.callSignature) as CallSignatureRunType;
+    });
+
+    getJitChildren(comp: JitFnCompiler): InterfaceMember[] {
+        const children = super.getJitChildren(comp) as InterfaceMember[];
+        return children.toSorted((a, b) => sortDiscriminatorsFirst(a, b)) as InterfaceMember[];
+    }
+    /** Split children in two groups: required and optional */
+    splitJitSplitChildren(comp: JitFnCompiler): {
+        /** all required properties */
+        required: PropertyRunType[];
+        /** all optional properties */
+        optional: PropertyRunType[];
+        /** all index signatures */
+        indexSignatures: IndexSignatureRunType[];
+    } {
+        const children = super.getJitChildren(comp) as InterfaceMember[];
+        const required = children.filter((prop) => !prop.isOptional()) as PropertyRunType[];
+        const optional = children.filter((prop) => prop.isOptional() && !isIndexSignatureRunType(prop)) as PropertyRunType[];
+        const indexSignatures = children.filter((prop) => isIndexSignatureRunType(prop)) as IndexSignatureRunType[];
+        return {required, optional, indexSignatures};
+    }
+    isPartOfUnion(): boolean {
+        return this.getParent()?.src.kind === ReflectionKind.union;
+    }
+    hasIndexSignature(comp: JitFnCompiler): boolean {
+        return this.getJitChildren(comp).some((prop) => isIndexSignatureRunType(prop));
+    }
+
+    // #### collection's jit code ####
+
+    emitIsType(comp: JitFnCompiler): JitCode {
+        const varName = comp.vλl;
+        const children = this.getJitChildren(comp);
+        const childrenCode = children
+            .map((prop) => comp.compileIsType(prop, 'E').code)
+            .filter(Boolean)
+            .join(' && ');
+        if (this.isCallable())
+            return {
+                code: [this.getCallSignature()!.emitIsType(comp).code, childrenCode].filter(Boolean).join(' && '),
+                type: 'E',
+            };
+        let propsCode = '';
+        if (comp.opts.strictTypes && !this.hasIndexSignature(comp)) {
+            const unknownCheck = callCheckUnknownProperties(this, comp, children, false, false);
+            if (unknownCheck) propsCode = `!${unknownCheck}`;
+        }
+        const objectCheck = this.isPartOfUnion() ? '' : `typeof ${varName} === 'object' && ${varName} !== null`;
+        const itemsCode = [objectCheck, this.allOptionalCode(comp), childrenCode, propsCode].filter(Boolean).join(' && ');
+        return {code: `(${itemsCode})`, type: 'E'};
+    }
+
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        const varName = comp.vλl;
+        const children = this.getJitChildren(comp);
+        const childrenCode = children
+            .map((prop) => comp.compileTypeErrors(prop, 'S').code)
+            .filter(Boolean)
+            .join(';');
+        if (this.isCallable()) {
+            return {code: `${this.getCallSignature()!.emitTypeErrors(comp).code} else {${childrenCode}}`, type: 'S'};
+        }
+        let propsCode = '';
+        if (comp.opts.strictTypes && !this.hasIndexSignature(comp)) {
+            const unknownVar = comp.getLocalVarName('unk', this);
+            const keyVar = comp.getLocalVarName('ky', this);
+            const unknownValue = callCheckUnknownProperties(this, comp, children, true, false);
+            if (unknownValue) {
+                propsCode = `
+                    const ${unknownVar} = ${unknownValue};
+                    if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}) {${comp.callJitErrWithPath('never', keyVar)}}}
+                `;
+            }
+        }
+        const objectCheck = this.isPartOfUnion() ? '' : `typeof ${varName} === 'object' && ${varName} !== null`;
+        const isObjectCode = [objectCheck, this.allOptionalCode(comp)].filter(Boolean).join(' && ');
+        return {
+            code: `
+            if (!(${isObjectCode})) {
+                ${comp.callJitErr(this)};
+            } else {
+                ${childrenCode}
+                ${propsCode}
+            }
+        `,
+            type: 'S',
+        };
+    }
+    emitPrepareForJson(comp: JitFnCompiler): JitCode {
+        if (this.isCallable()) return this.getCallSignature()!.emitPrepareForJson();
+        const children = this.getJitChildren(comp);
+        const childrenCode = children
+            .map((prop) => comp.compilePrepareForJson(prop, 'S').code)
+            .filter(Boolean)
+            .join(';');
+        return {code: childrenCode, type: 'S'};
+    }
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
+        if (this.isCallable()) return this.getCallSignature()!.emitRestoreFromJson();
+        const children = this.getJitChildren(comp);
+        const childrenCode = children
+            .map((prop) => comp.compileRestoreFromJson(prop, 'S').code)
+            .filter(Boolean)
+            .join(';');
+        return {code: childrenCode, type: 'S'};
+    }
+    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {
+        const children = this.getJitChildren(comp);
+        const allChildren = this.getChildRunTypes().filter((prop) => !isIndexSignatureRunType(prop));
+        const hasIndexProp = children.some((prop) => isIndexSignatureRunType(prop));
+        const parentCode = hasIndexProp
+            ? ''
+            : callCheckUnknownProperties(this, comp, children, false, !this.isPartOfUnion(), allChildren);
+        const childrenCode = super.emitHasUnknownKeys(comp).code;
+        return {code: [parentCode, childrenCode].filter(Boolean).join(' || '), type: 'E'};
+    }
+    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {
+        const children = this.getJitChildren(comp);
+        const allChildren = this.getChildRunTypes().filter((prop) => !isIndexSignatureRunType(prop));
+        const hasIndexProp = children.some((prop) => isIndexSignatureRunType(prop));
+        const unknownVar = comp.getLocalVarName('unk', this);
+        const keyVar = comp.getLocalVarName('ky', this);
+        const unknownValue = hasIndexProp
+            ? undefined
+            : callCheckUnknownProperties(this, comp, children, true, !this.isPartOfUnion(), allChildren);
+        const parentCode = `
+            const ${unknownVar} = ${unknownValue};
+            if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}) {${comp.callJitErrWithPath('never', keyVar)}}}
+        `;
+        const childrenCode = super.emitUnknownKeyErrors(comp).code;
+        return {code: [unknownValue ? parentCode : '', childrenCode].filter(Boolean).join('\n'), type: 'S'};
+    }
+    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {
+        const children = this.getJitChildren(comp);
+        const unknownVar = comp.getLocalVarName('unk', this);
+        const keyVar = comp.getLocalVarName('ky', this);
+        const hasIndexProp = children.some((prop) => isIndexSignatureRunType(prop));
+        const unknownValue = hasIndexProp
+            ? undefined
+            : callCheckUnknownProperties(this, comp, children, true, !this.isPartOfUnion());
+        const parentCode = `
+            const ${unknownVar} = ${unknownValue};
+            if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}){delete ${comp.vλl}[${keyVar}]}}
+        `;
+        const childrenCode = super.emitStripUnknownKeys(comp).code;
+        return {code: [unknownValue ? parentCode : '', childrenCode].filter(Boolean).join('\n'), type: 'S'};
+    }
+    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {
+        const children = this.getJitChildren(comp);
+        const unknownVar = comp.getLocalVarName('unk', this);
+        const keyVar = comp.getLocalVarName('ky', this);
+        const hasIndexProp = children.some((prop) => isIndexSignatureRunType(prop));
+        const unknownValue = hasIndexProp
+            ? undefined
+            : callCheckUnknownProperties(this, comp, children, true, !this.isPartOfUnion());
+        const parentCode = `
+            const ${unknownVar} = ${unknownValue};
+            if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}){${comp.vλl}[${keyVar}] = undefined}}
+        `;
+        const childrenCode = super.emitUnknownKeysToUndefined(comp).code;
+        return {code: [unknownValue ? parentCode : '', childrenCode].filter(Boolean).join('\n'), type: 'S'};
+    }
+
+    // In order to json stringify to work properly optional properties must come first
+    getJsonStringifySortedChildren(comp: JitFnCompiler): MemberRunType<any>[] {
+        return this.getJitChildren(comp).toSorted((a, b) => {
+            const aOptional = a instanceof MemberRunType && a.isOptional();
+            const bOptional = b instanceof MemberRunType && b.isOptional();
+            if (aOptional && !bOptional) return -1;
+            if (!aOptional && bOptional) return 1;
+            return 0;
+        }) as MemberRunType<any>[];
+    }
+
+    // extra check to prevent empty array passing as object where all properties are optional
+    // when this check is disabled empty array will pass as object but fail when checking for properties
+    allOptionalCode(comp: JitFnCompiler): string {
+        const children = this.getJitChildren(comp);
+        if (children.length !== 0 && !this.areAllChildrenOptional(children)) return '';
+        const isNotArray = `!Array.isArray(${comp.vλl})`;
+        const ifNoNative = `Object.prototype.toString.call(${comp.vλl}) === '[object Object]'`;
+        return `(${isNotArray} && ${ifNoNative})`;
+    }
+
+    addObjectPropsToContext(comp: JitFnCompiler, jitChildrenRunTypes?: BaseRunType[], allChildrenRuntypes?: BaseRunType[]) {
+        const children = jitChildrenRunTypes || this.getJitChildren(comp);
+        const allChildren = allChildrenRuntypes || this.getChildRunTypes();
+        return addObjectPropsToContext(this, comp, children, allChildren);
+    }
+}
+
+export interface ObjectPropsContextResult {
+    keysName: string;
+    allKeysName: string;
+    hasNonJitChildren: boolean;
+    jitChildrenNames: string[];
+    allChildrenNames: string[];
+}
+
+/**
+ * Extracts object property names and adds them to the JIT compiler context.
+ */
+function addObjectPropsToContext(
+    rt: InterfaceRunType<any>,
+    comp: JitFnCompiler,
+    jitChildrenRunTypes: BaseRunType[],
+    allChildrenRuntypes?: BaseRunType[]
+): ObjectPropsContextResult {
+    const jitArrNames = jitChildrenRunTypes.filter((prop) => !!(prop.src as any).name).map((prop) => (prop.src as any).name);
+    const AllArrNames = allChildrenRuntypes?.filter((prop) => !!(prop.src as any).name).map((prop) => (prop.src as any).name);
+    const jitChildrenNames = Array.from(new Set(jitArrNames));
+    const allChildrenNames = Array.from(new Set(AllArrNames));
+    const isSameLength = jitChildrenNames.length === allChildrenNames.length;
+    const isSameSet = isSameLength && jitChildrenNames.every((v) => allChildrenNames.includes(v));
+    const hasNonJitChildren = !(isSameLength && isSameSet);
+    const keysName = `k_${rt.getJitHash(comp.opts)}`;
+    const allKeysName = `kA_${rt.getJitHash(comp.opts)}`;
+
+    comp.setContextItem(keysName, `const ${keysName} = ${arrayToLiteral(jitChildrenNames)}`);
+    if (hasNonJitChildren) comp.setContextItem(allKeysName, `const ${allKeysName} = ${arrayToLiteral(allChildrenNames)}`);
+
+    return {
+        keysName,
+        allKeysName,
+        hasNonJitChildren,
+        jitChildrenNames,
+        allChildrenNames,
+    };
+}
+
+// TODO: look like some of this logic should be moved to index prop ? Also the runtime
+function callCheckUnknownProperties(
+    rt: InterfaceRunType<any>,
+    comp: JitFnCompiler,
+    jitChildrenRunTypes: BaseRunType[],
+    returnKeys: boolean,
+    checkObject = true,
+    allChildrenRuntypes?: BaseRunType[]
+): string {
+    const result = addObjectPropsToContext(rt, comp, jitChildrenRunTypes, allChildrenRuntypes);
+
+    if (result.jitChildrenNames.length === 0 && result.allChildrenNames.length === 0) return '';
+
+    const objectCheckCode = checkObject ? [`typeof ${comp.vλl} === 'object'`, `${comp.vλl} !== null`] : [];
+    const checkPropName = JitFunctions.hasUnknownKeys.runTimeOptions.checkNonJitProps.keyName;
+    const optsVarName = getJitFnArgCallVarName(comp, rt, JitFunctions.hasUnknownKeys.id, 'θpts');
+    const conditional =
+        allChildrenRuntypes?.length && result.hasNonJitChildren
+            ? `${optsVarName}.${checkPropName} ? ${result.allKeysName} : ${result.keysName}`
+            : result.keysName;
+    if (returnKeys) {
+        const getUnknownKeysFn = comp.addPureFunction(cpf_getUnknownKeysFromArray);
+        return `${getUnknownKeysFn}(${comp.vλl}, ${conditional})`;
+    }
+    const hasUnknownKeysFn = comp.addPureFunction(cpf_hasUnknownKeysFromArray);
+    objectCheckCode.push(`${hasUnknownKeysFn}(${comp.vλl}, ${conditional})`);
+    const filtered = objectCheckCode.filter(Boolean);
+    if (filtered.length > 1) return `(${filtered.join(' && ')})`;
+    return filtered[0];
+}

package/src/nodes/collection/intersection.ts

@@ -0,0 +1,30 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {TypeIntersection} from '@deepkit/type';
+import {InterfaceRunType} from './interface.ts';
+import {type JitCode} from '../../types.ts';
+
+/** IMPORTANT:
+ * Intersection are already resolved by deepkit so seems like this runType wont ever be called
+ * ie: type A = {a: string} & {b: number} will be resolved to ObjectLiteral {a: string, b: number}
+ * ie: type NeVer = string & number will be resolved to never
+ * */
+export class IntersectionRunType extends InterfaceRunType<TypeIntersection> {
+    compileIsType(): JitCode {
+        throw new Error('Intersection validation not supported, should be resolve to other RunTypes');
+    }
+    compileTypeErrors(): JitCode {
+        throw new Error('Intersection validation not supported, should be resolve to other RunTypes');
+    }
+    compilePrepareForJson(): JitCode {
+        throw new Error('Intersection serialization not supported, should be resolve to other RunTypes');
+    }
+    compileRestoreFromJson(): JitCode {
+        throw new Error('Intersection serialization not supported, should be resolve to other RunTypes');
+    }
+}

package/src/nodes/collection/tuple.ts

@@ -0,0 +1,80 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {TypeFunction, TypeTuple} from '@deepkit/type';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import type {AnyParameterListRunType, SrcType, JitCode} from '../../types.ts';
+import {ParameterRunType} from '../member/param.ts';
+import {CollectionRunType} from '../../lib/baseRunTypes.ts';
+import {TupleMemberRunType} from '../member/tupleMember.ts';
+
+type AnyParamRunType = ParameterRunType | TupleMemberRunType;
+
+export class TupleRunType<
+    ParamList extends AnyParameterListRunType = TypeTuple,
+    ParamType extends AnyParamRunType = TupleMemberRunType,
+> extends CollectionRunType<ParamList> {
+    getChildRunTypes = (): ParamType[] => {
+        const childTypes = ((this.src as TypeFunction).parameters || (this.src as TypeTuple).types || []) as SrcType[];
+        return childTypes.map((t) => t._rt as ParamType);
+    };
+    getParamRunTypes(comp: JitFnCompiler): ParamType[] {
+        const start = comp.opts?.paramsSlice?.start;
+        const end = comp.opts?.paramsSlice?.end;
+        const children = this.getChildRunTypes();
+        if (!start && !end) return children;
+        // Get all child run types first without using comp to avoid recursion
+        return children.slice(start, end);
+    }
+    hasRestParameter(comp: JitFnCompiler): boolean {
+        return (
+            !!this.getParamRunTypes(comp).length && this.getParamRunTypes(comp)[this.getParamRunTypes(comp).length - 1].isRest()
+        );
+    }
+    totalRequiredParams(comp: JitFnCompiler): number {
+        return this.getParamRunTypes(comp).filter((p) => !p.isOptional() && !p.isRest()).length;
+    }
+    // ####### params #######
+
+    emitIsType(comp: JitFnCompiler): JitCode {
+        const children = this.getParamRunTypes(comp);
+        if (children.length === 0 && comp.opts.noIsArrayCheck) return {code: undefined, type: 'E'};
+        if (children.length === 0) return {code: `Array.isArray(${comp.vλl}) && ${comp.vλl}.length === 0`, type: 'E'};
+        const lengthCode = this.hasRestParameter(comp) ? '' : `&& ${comp.vλl}.length <= ${this.getParamRunTypes(comp).length}`;
+        const paramsCode = children.map((p) => `(${comp.compileIsType(p, 'E').code})`).join(' && ');
+        const checkIsArrayCode = comp.opts.noIsArrayCheck ? '' : `Array.isArray(${comp.vλl})${lengthCode} && `;
+        return {code: `(${checkIsArrayCode} ${paramsCode})`, type: 'E'};
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        const children = this.getParamRunTypes(comp);
+        if (children.length === 0 && comp.opts.noIsArrayCheck) return {code: undefined, type: 'S'};
+        if (children.length === 0)
+            return {code: `if (!Array.isArray(${comp.vλl}) || && ${comp.vλl}.length === 0) ${comp.callJitErr(this)}`, type: 'S'};
+        const lengthCode = this.hasRestParameter(comp) ? '' : `|| ${comp.vλl}.length > ${this.getParamRunTypes(comp).length}`;
+        const paramsCode = children.map((p) => comp.compileTypeErrors(p, 'S').code).join(';');
+        if (comp.opts.noIsArrayCheck) return {code: paramsCode, type: 'S'};
+        return {code: `if (!Array.isArray(${comp.vλl})${lengthCode}) ${comp.callJitErr(this)}; else {${paramsCode}}`, type: 'S'};
+    }
+    emitPrepareForJson(comp: JitFnCompiler): JitCode {
+        const children = this.getParamRunTypes(comp);
+        if (!children.length) return {code: undefined, type: 'S'};
+        const code = children
+            .map((p) => comp.compilePrepareForJson(p, 'S').code)
+            .filter(Boolean)
+            .join(';');
+        return {code: code, type: 'S'};
+    }
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
+        const children = this.getParamRunTypes(comp);
+        if (!children.length) return {code: undefined, type: 'S'};
+        const code = children
+            .map((p) => comp.compileRestoreFromJson(p, 'S').code)
+            .filter(Boolean)
+            .join(';');
+        return {code: code, type: 'S'};
+    }
+}

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()}`);
+    }
+}