@mionjs/run-types 0.8.0-alpha.0

package/.dist/esm/src/jitCompilers/binary/toBinary.js

@@ -0,0 +1,338 @@
+import { ReflectionKind } from "@deepkit/type";
+import { ReflectionSubKind } from "../../constants.kind.js";
+import { JitFunctions } from "../../constants.functions.js";
+import { createIfElseFn } from "../../lib/utils.js";
+import { MAX_UNION_ITEMS } from "../../constants.js";
+const fnID = JitFunctions.toBinary.id;
+function emitToBinary(runType, comp) {
+  const src = runType.src;
+  const kind = src.kind;
+  const sεr = comp.args.sεr;
+  switch (kind) {
+    // ###################### ATOMIC TYPES ######################
+    case ReflectionKind.unknown:
+    case ReflectionKind.any: {
+      return { code: `${sεr}.serString(JSON.stringify(${comp.vλl}))`, type: "S" };
+    }
+    case ReflectionKind.null:
+      return { code: `${sεr}.view.setUint8(${sεr}.index++, 0)`, type: "S" };
+    case ReflectionKind.boolean:
+      return { code: `${sεr}.view.setUint8(${sεr}.index++, !!${comp.vλl})`, type: "S" };
+    case ReflectionKind.number: {
+      return { code: `${sεr}.view.setFloat64(${sεr}.index,${comp.vλl}, 1, (${sεr}.index += 8))`, type: "S" };
+    }
+    case ReflectionKind.string: {
+      return { code: `${sεr}.serString(${comp.vλl})`, type: "S" };
+    }
+    case ReflectionKind.bigint: {
+      return { code: `${sεr}.serString(${comp.vλl}.toString(), true)`, type: "S" };
+    }
+    case ReflectionKind.undefined:
+    case ReflectionKind.void:
+      return { code: `${sεr}.view.setUint8(${sεr}.index++, 1)`, type: "S" };
+    case ReflectionKind.symbol: {
+      return { code: `${sεr}.serString(${comp.vλl}.description || '')`, type: "S" };
+    }
+    case ReflectionKind.regexp: {
+      return { code: `${sεr}.serString(${comp.vλl}.source);${sεr}.serString(${comp.vλl}.flags)`, type: "S" };
+    }
+    case ReflectionKind.object:
+      return { code: `${sεr}.serString(JSON.stringify(${comp.vλl}))`, type: "S" };
+    case ReflectionKind.enum: {
+      return { code: `${sεr}.serEnum(${comp.vλl})`, type: "S" };
+    }
+    case ReflectionKind.enumMember:
+      throw new Error("Binary serialization not supported for enum member types");
+    case ReflectionKind.never:
+      throw new Error("Never type cannot be serialized to Binary");
+    case ReflectionKind.templateLiteral:
+      throw new Error("Template literals are not supported in Binary serialization");
+    case ReflectionKind.literal: {
+      if (comp.opts.noLiterals) {
+        const lit = runType.src.literal;
+        if (lit instanceof RegExp) return emitToBinaryAs(runType, comp, ReflectionKind.regexp);
+        switch (typeof lit) {
+          case "string":
+            return emitToBinaryAs(runType, comp, ReflectionKind.string);
+          case "number":
+            return emitToBinaryAs(runType, comp, ReflectionKind.number);
+          case "boolean":
+            return emitToBinaryAs(runType, comp, ReflectionKind.boolean);
+          case "bigint":
+            return emitToBinaryAs(runType, comp, ReflectionKind.bigint);
+          case "symbol":
+            return emitToBinaryAs(runType, comp, ReflectionKind.symbol);
+          default:
+            throw new Error(`Unsupported literal type ${typeof lit}`);
+        }
+      }
+      return { code: "", type: "S" };
+    }
+    // ###################### MEMBER RUNTYPES ######################
+    // Types that represent members of collections or other structures
+    case ReflectionKind.rest:
+    // rest params are serialized as array but start at rest item index
+    case ReflectionKind.array: {
+      const rt = runType;
+      rt.checkNonSkipTypes(comp);
+      const child = rt.getMemberType();
+      const memberJit = comp.compile(child, "S", fnID);
+      if (!memberJit?.code) throw new Error(`Do not know how to serialize Array<${child.getTypeName()}> to Binary.`);
+      const index = rt.getChildVarName(comp);
+      return {
+        code: `
+                ${sεr}.view.setUint32(${sεr}.index, ${comp.vλl}.length, 1); ${sεr}.index += 4;
+                for (let ${index} = ${rt.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {${memberJit.code}}
+            `,
+        type: "S"
+      };
+    }
+    case ReflectionKind.indexSignature: {
+      const rt = runType;
+      const indexKind = rt.src.index?.kind;
+      const memberJit = comp.compile(rt.getJitChild(comp), "S", fnID);
+      if (!memberJit?.code) return { code: void 0, type: "S" };
+      const propVar = rt.getChildVarName(comp);
+      const lengthVar = comp.getLocalVarName("cnt", rt);
+      const indexVar = comp.getLocalVarName("piI", rt);
+      const varsInit = `let ${lengthVar} = 0; const ${indexVar} = ${sεr}.index; ${sεr}.index += 4;`;
+      let keySerializationCode;
+      if (indexKind === ReflectionKind.number) {
+        keySerializationCode = `${sεr}.view.setUint32(${sεr}.index , Number(${propVar}), 1); ${sεr}.index += 4;`;
+      } else {
+        keySerializationCode = `${sεr}.serString(${propVar});`;
+      }
+      return {
+        code: `
+                ${varsInit};
+                for (const ${propVar} in ${comp.vλl}) {${keySerializationCode} ${memberJit.code}; ${lengthVar}++;}
+                ${sεr}.view.setUint32(${indexVar}, ${lengthVar}, 1);
+            `,
+        type: "S"
+      };
+    }
+    case ReflectionKind.function:
+    case ReflectionKind.method:
+    case ReflectionKind.methodSignature:
+    case ReflectionKind.callSignature:
+      if (runType.src.subKind === ReflectionSubKind.params) {
+        return emitToBinaryAs(runType, comp, ReflectionKind.tuple);
+      } else {
+        throw new Error("Binary serialization not supported for functions, call compileParams or compileReturn instead.");
+      }
+    case ReflectionKind.parameter: {
+      const rt = runType;
+      switch (src.subKind) {
+        case ReflectionSubKind.mapKey:
+        case ReflectionSubKind.mapValue:
+        case ReflectionSubKind.setItem: {
+          const child = rt.getJitChild(comp);
+          const childJit = comp.compile(child, "S", fnID);
+          if (!childJit?.code) throw new Error(`Do not know how to serialize ${rt.getTypeName()} to Binary.`);
+          return childJit;
+        }
+        default: {
+          return emitToBinaryAs(runType, comp, ReflectionKind.tupleMember);
+        }
+      }
+    }
+    case ReflectionKind.property:
+    case ReflectionKind.propertySignature: {
+      const rt = runType;
+      const parent = rt.getParent();
+      if (parent.hasIndexSignature(comp)) return { code: void 0, type: "S" };
+      const memberCode = comp.compile(rt.getJitChild(comp), "S", fnID).code || "";
+      if (rt.isOptional()) {
+        const { bitMIndexVar, bitIndex } = getOptionalBitmapItems(parent, comp, 0, rt.optionalIndex, false);
+        const setBitMask = `${sεr}.setBitMask(${bitMIndexVar}, ${bitIndex})`;
+        return { code: `if (${comp.getChildVλl()} !== undefined) {${memberCode};${setBitMask}}`, type: "S" };
+      }
+      return { code: `${memberCode}`, type: "S" };
+    }
+    case ReflectionKind.tupleMember: {
+      const rt = runType;
+      const child = rt.getJitChild(comp);
+      const childJit = comp.compile(child, "S", fnID);
+      const nullJIt = emitToBinaryAs(rt, comp, ReflectionKind.undefined);
+      const itemJit = childJit?.code ? childJit : nullJIt;
+      if (rt.isRest()) return itemJit;
+      const optionalIndex = rt.optionalIndex;
+      const bitMIndexVar = rt._bitmapVar;
+      const isFnParam = rt._isFnParam;
+      const isOptional = rt.isOptional() || isFnParam;
+      if (isOptional && optionalIndex !== void 0 && bitMIndexVar) {
+        const bitIndex = optionalIndex & 7;
+        const setBitMask = `${sεr}.setBitMask(${bitMIndexVar}, ${bitIndex})`;
+        return { code: `if (${comp.getChildVλl()} !== undefined) {${itemJit.code};${setBitMask}}`, type: "S" };
+      }
+      return itemJit;
+    }
+    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: {
+      const rt = runType;
+      if (rt.isCallable()) return comp.compile(rt.getCallSignature(), "S", fnID);
+      if (runType.src.subKind === ReflectionSubKind.nonSerializable) {
+        throw new Error("Binary serialization is disabled for Non Serializable types");
+      } else {
+        const { required, optional, indexSignatures } = rt.splitJitSplitChildren(comp);
+        if (indexSignatures.length) {
+          return comp.compile(indexSignatures[0], "S", fnID);
+        }
+        const requiredProps = required.map((prop) => comp.compile(prop, "S", fnID).code);
+        const requiredPropsCode = requiredProps.join(";");
+        let optionalPropsCode = "";
+        if (optional.length) {
+          const { bitMapInit, bitMIndexVar } = getOptionalBitmapItems(rt, comp, optional.length, 0, false);
+          const propsCode = optional.map((prop, i) => {
+            prop.optionalIndex = i;
+            const modIndex = i + 1;
+            const shouldIncreaseBufferIndex = modIndex % 8 === 0;
+            const propCode = comp.compile(prop, "S", fnID).code;
+            if (!shouldIncreaseBufferIndex) return propCode;
+            return `${propCode} ${bitMIndexVar}++;`;
+          }).filter(Boolean).join("");
+          optionalPropsCode = `${bitMapInit}
+${propsCode}`;
+        }
+        return { code: `${requiredPropsCode}
+${optionalPropsCode}`, type: "S" };
+      }
+    }
+    case ReflectionKind.class:
+      switch (runType.src.subKind) {
+        case ReflectionSubKind.date:
+          return {
+            code: `${sεr}.view.setFloat64(${sεr}.index, ${comp.vλl}.getTime(), 1, (${sεr}.index += 8))`,
+            type: "S"
+          };
+        case ReflectionSubKind.map:
+        case ReflectionSubKind.set: {
+          const rt = runType;
+          const sεr2 = comp.args.sεr;
+          const entry = rt.getCustomVλl(comp)?.vλl || comp.vλl;
+          const jitChildren = rt.getJitChildren(comp);
+          const childrenCode = jitChildren.map((c) => comp.compile(c, "S", fnID).code).filter(Boolean).join(";");
+          const setLength = `${sεr2}.view.setUint32(${sεr2}.index, ${comp.vλl}.size, 1); ${sεr2}.index += 4;`;
+          return {
+            code: `${setLength} for (const ${entry} of ${comp.vλl}) {${childrenCode}}`,
+            type: "S"
+          };
+        }
+        case ReflectionSubKind.nonSerializable:
+          throw new Error("Binary serialization disabled for Non Serializable types");
+        default: {
+          const rt = runType;
+          if (rt.isCallable()) {
+            const callSignature = rt.getCallSignature();
+            if (callSignature) return comp.compile(callSignature, "S", fnID);
+          }
+          const originalKind = runType.src.kind;
+          runType.src.kind = ReflectionKind.objectLiteral;
+          const result = emitToBinary(runType, comp);
+          runType.src.kind = originalKind;
+          return result;
+        }
+      }
+      break;
+    case ReflectionKind.infer:
+      throw new Error("Infer is not supported in Binary serialization");
+    case ReflectionKind.tuple: {
+      const rt = runType;
+      const skip = rt.skipJit(comp);
+      if (skip) return { code: void 0, type: "S" };
+      const params = rt.getParamRunTypes(comp);
+      if (params.length === 0) return { code: void 0, type: "S" };
+      const isFnParams = runType.src.subKind === ReflectionSubKind.params;
+      const required = isFnParams ? [] : params.filter((p) => !p.isOptional() && !p.isRest());
+      const optional = isFnParams ? params.filter((p) => !p.isRest()) : params.filter((p) => p.isOptional() && !p.isRest());
+      const rest = params.filter((p) => p.isRest());
+      const requiredCode = required.map((p) => comp.compile(p, "S", fnID).code).join(";");
+      let optionalCode = "";
+      if (optional.length) {
+        const { bitMapInit, bitMIndexVar } = getOptionalBitmapItems(rt, comp, optional.length, 0, true);
+        const optionalParamsCode = optional.map((p, i) => {
+          p.optionalIndex = i;
+          p._bitmapVar = bitMIndexVar;
+          p._isFnParam = isFnParams;
+          const paramCode = comp.compile(p, "S", fnID).code || "";
+          const modIndex = i + 1;
+          const shouldIncreaseBufferIndex = modIndex % 8 === 0 && modIndex < optional.length;
+          const increaseIndex = shouldIncreaseBufferIndex ? `${bitMIndexVar}++;` : "";
+          return `${paramCode} ${increaseIndex}`;
+        }).join("");
+        optionalCode = `${bitMapInit}
+${optionalParamsCode}`;
+      }
+      const restCode = rest.map((p) => comp.compile(p, "S", fnID).code).join(";");
+      const allCode = [requiredCode, optionalCode, restCode].filter(Boolean).join(";");
+      return { code: allCode, type: "S" };
+    }
+    case ReflectionKind.typeParameter:
+      throw new Error("Type parameter not implemented in Binary serialization");
+    case ReflectionKind.union: {
+      const rt = runType;
+      rt.checkAllowedChildren(comp);
+      const { simpleItems, objectTypes, anyItem } = rt.getUnionChildren(comp);
+      const totalLength = simpleItems.length + objectTypes.length + (anyItem ? 1 : 0);
+      if (totalLength > MAX_UNION_ITEMS) {
+        throw new Error(
+          `Binary serialization not supported for Union with more than ${MAX_UNION_ITEMS} items. Found ${totalLength} in ${rt.getUnionTypeNames()}`
+        );
+      }
+      const errName = comp.getLocalVarName("uErr", rt);
+      const fail = `throw new Error(${errName});`;
+      comp.setContextItem(
+        errName,
+        `const ${errName} = "Can not encode union to binary: item does not belong to the union"`
+      );
+      const ifElse = createIfElseFn();
+      const getEncodeCode = (childRt) => {
+        const toJit = comp.compile(childRt, "S", fnID);
+        const encodeCode = toJit.code || "";
+        const index = rt.getUnionItemIndex(comp, childRt);
+        const isUint16 = index > 255;
+        const writeIndex = isUint16 ? `${sεr}.view.setUint16(${sεr}.index, ${index}, 1, (${sεr}.index += 2))` : `${sεr}.view.setUint8(${sεr}.index++, ${index})`;
+        return `${writeIndex};${encodeCode}`;
+      };
+      const simpleCode = simpleItems.map((childRt) => {
+        const isTypeCode = rt.getChildIsTypeWithLooseCheck(childRt, comp);
+        return `${ifElse()} (${isTypeCode}) {${getEncodeCode(childRt)}}`;
+      });
+      const objCode = objectTypes.length ? objectTypes.map((childRt) => {
+        const isTypeCode = rt.getChildIsTypeWithLooseCheck(childRt, comp);
+        return `${ifElse()} (typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null && ${isTypeCode}) {${getEncodeCode(childRt)}}`;
+      }) : [];
+      const anyCode = anyItem ? `${ifElse(true)} {${getEncodeCode(anyItem)}}` : `${ifElse(true)} {${fail}}`;
+      return { code: [...simpleCode, ...objCode, anyCode].join(""), type: "S" };
+    }
+    default:
+      throw new Error(`Binary serialization not supported for ${ReflectionKind[kind]} types`);
+  }
+  return { code: void 0, type: "S" };
+}
+function getOptionalBitmapItems(rt, comp, optionalLength = 0, currentIndex = 0, isTuple = false) {
+  const sεr = comp.args.sεr;
+  const prefix = isTuple ? "t" : "";
+  const bitMIndexVar = comp.getLocalVarName(`${prefix}bmI`, rt);
+  const bitmapLength = Math.ceil(optionalLength / 8);
+  const bitIndex = `${currentIndex} & 7`;
+  const indexVar = comp.getLocalVarName(`${prefix}iBl`, rt);
+  const setBitmapToZero = bitmapLength > 1 ? `for (let ${indexVar} = 0; ${indexVar} < ${bitmapLength}; ${indexVar}++) {${sεr}.view.setUint8(${sεr}.index++, 0)}` : `${sεr}.view.setUint8(${sεr}.index++, 0)`;
+  const bitMapInit = `${bitmapLength > 1 ? "let " : "const"} ${bitMIndexVar} = ${sεr}.index; ${setBitmapToZero}`;
+  return { bitMIndexVar, bitmapLength, bitIndex, bitMapInit };
+}
+function emitToBinaryAs(rt, comp, kind) {
+  const originalKind = rt.src.kind;
+  rt.src.kind = kind;
+  const result = emitToBinary(rt, comp);
+  rt.src.kind = originalKind;
+  return result;
+}
+export {
+  emitToBinary
+};
+//# sourceMappingURL=toBinary.js.map

package/.dist/esm/src/jitCompilers/binary/toBinary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toBinary.js","sources":["../../../../../src/jitCompilers/binary/toBinary.ts"],"sourcesContent":["/* ########\n * 2025 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {ReflectionKind} from '@deepkit/type';\nimport {ReflectionSubKind} from '../../constants.kind.ts';\nimport {jitBinarySerializerArgs, JitFunctions} from '../../constants.functions.ts';\nimport {createIfElseFn} from '../../lib/utils.ts';\nimport {MAX_UNION_ITEMS} from '../../constants.ts';\nimport type {JitCode} from '../../types.ts';\nimport type {BaseRunType} from '../../lib/baseRunTypes.ts';\nimport type {BaseFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport type {ArrayRunType} from '../../nodes/member/array.ts';\nimport type {PropertyRunType} from '../../nodes/member/property.ts';\nimport type {InterfaceRunType} from '../../nodes/collection/interface.ts';\nimport type {IndexSignatureRunType} from '../../nodes/member/indexProperty.ts';\nimport type {ParameterRunType} from '../../nodes/member/param.ts';\nimport type {TupleRunType} from '../../nodes/collection/tuple.ts';\nimport type {UnionRunType} from '../../nodes/collection/union.ts';\nimport type {IterableRunType} from '../../nodes/native/Iterable.ts';\nimport type {LiteralRunType} from '../../nodes/atomic/literal.ts';\n\ntype BinaryCompiler = BaseFnCompiler<typeof jitBinarySerializerArgs, typeof JitFunctions.toBinary.id>;\nconst fnID = JitFunctions.toBinary.id;\n\n/**\n * Main Binary serialization compiler function\n * Generates JIT code to serialize values to Binary format following Binary 1.1 specification\n *\n * This function generates JavaScript expressions that return Uint8Array containing Binary bytes.\n */\nexport function emitToBinary(runType: BaseRunType, comp: BinaryCompiler): JitCode {\n    const src = runType.src;\n    const kind = src.kind;\n    const sεr = comp.args.sεr;\n\n    // hack is used in some case to increase the index passing an extra argument to view.set methods\n    // ie: view.setUint32(index, value, littleEndian, index += 4);\n    // setUint32 only accepts 3 arguments, but we use the 4rd one to increase the index on a single statement so code can be used as an expression\n\n    switch (kind) {\n        // ###################### ATOMIC TYPES ######################\n        case ReflectionKind.unknown:\n        case ReflectionKind.any: {\n            // any is serialized as json string\n            return {code: `${sεr}.serString(JSON.stringify(${comp.vλl}))`, type: 'S'};\n        }\n        case ReflectionKind.null:\n            return {code: `${sεr}.view.setUint8(${sεr}.index++, 0)`, type: 'S'};\n        case ReflectionKind.boolean:\n            return {code: `${sεr}.view.setUint8(${sεr}.index++, !!${comp.vλl})`, type: 'S'};\n        case ReflectionKind.number: {\n            return {code: `${sεr}.view.setFloat64(${sεr}.index,${comp.vλl}, 1, (${sεr}.index += 8))`, type: 'S'};\n        }\n        case ReflectionKind.string: {\n            return {code: `${sεr}.serString(${comp.vλl})`, type: 'S'};\n        }\n        case ReflectionKind.bigint: {\n            return {code: `${sεr}.serString(${comp.vλl}.toString(), true)`, type: 'S'};\n        }\n        case ReflectionKind.undefined:\n        case ReflectionKind.void:\n            return {code: `${sεr}.view.setUint8(${sεr}.index++, 1)`, type: 'S'};\n        case ReflectionKind.symbol: {\n            return {code: `${sεr}.serString(${comp.vλl}.description || '')`, type: 'S'};\n        }\n        case ReflectionKind.regexp: {\n            return {code: `${sεr}.serString(${comp.vλl}.source);${sεr}.serString(${comp.vλl}.flags)`, type: 'S'};\n        }\n        case ReflectionKind.object:\n            // similar to any, this is serialized as json string\n            return {code: `${sεr}.serString(JSON.stringify(${comp.vλl}))`, type: 'S'};\n        case ReflectionKind.enum: {\n            return {code: `${sεr}.serEnum(${comp.vλl})`, type: 'S'};\n        }\n        case ReflectionKind.enumMember:\n            throw new Error('Binary serialization not supported for enum member types');\n        case ReflectionKind.never:\n            throw new Error('Never type cannot be serialized to Binary');\n        case ReflectionKind.templateLiteral:\n            throw new Error('Template literals are not supported in Binary serialization');\n        case ReflectionKind.literal: {\n            if (comp.opts.noLiterals) {\n                const lit = (runType as LiteralRunType).src.literal;\n                if (lit instanceof RegExp) return emitToBinaryAs(runType, comp, ReflectionKind.regexp);\n                switch (typeof lit) {\n                    case 'string':\n                        return emitToBinaryAs(runType, comp, ReflectionKind.string);\n                    case 'number':\n                        return emitToBinaryAs(runType, comp, ReflectionKind.number);\n                    case 'boolean':\n                        return emitToBinaryAs(runType, comp, ReflectionKind.boolean);\n                    case 'bigint':\n                        return emitToBinaryAs(runType, comp, ReflectionKind.bigint);\n                    case 'symbol':\n                        return emitToBinaryAs(runType, comp, ReflectionKind.symbol);\n                    default:\n                        throw new Error(`Unsupported literal type ${typeof lit}`);\n                }\n            }\n            return {code: '', type: 'S'}; // literals can be skipped as we restore the value directly from runType in jit code\n        }\n\n        // ###################### MEMBER RUNTYPES ######################\n        // Types that represent members of collections or other structures\n        case ReflectionKind.rest: // rest params are serialized as array but start at rest item index\n        case ReflectionKind.array: {\n            const rt = runType as ArrayRunType;\n            rt.checkNonSkipTypes(comp);\n            const child = rt.getMemberType()!;\n            const memberJit = comp.compile(child, 'S', fnID);\n            if (!memberJit?.code) throw new Error(`Do not know how to serialize Array<${child.getTypeName()}> to Binary.`);\n            const index = rt.getChildVarName(comp);\n            // serialized as [length, items...]\n            return {\n                code: `\n                ${sεr}.view.setUint32(${sεr}.index, ${comp.vλl}.length, 1); ${sεr}.index += 4;\n                for (let ${index} = ${rt.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {${memberJit.code}}\n            `,\n                type: 'S',\n            };\n        }\n        case ReflectionKind.indexSignature: {\n            const rt = runType as IndexSignatureRunType;\n            const indexKind = (rt.src as any).index?.kind;\n            const memberJit = comp.compile(rt.getJitChild(comp), 'S', fnID);\n            if (!memberJit?.code) return {code: undefined, type: 'S'};\n\n            const propVar = rt.getChildVarName(comp);\n            const lengthVar = comp.getLocalVarName('cnt', rt);\n            const indexVar = comp.getLocalVarName('piI', rt);\n            const varsInit = `let ${lengthVar} = 0; const ${indexVar} = ${sεr}.index; ${sεr}.index += 4;`;\n\n            // Serialize entries\n            let keySerializationCode: string;\n            if (indexKind === ReflectionKind.number) {\n                keySerializationCode = `${sεr}.view.setUint32(${sεr}.index , Number(${propVar}), 1); ${sεr}.index += 4;`;\n            } else {\n                keySerializationCode = `${sεr}.serString(${propVar});`;\n            }\n\n            return {\n                code: `\n                ${varsInit};\n                for (const ${propVar} in ${comp.vλl}) {${keySerializationCode} ${memberJit.code}; ${lengthVar}++;}\n                ${sεr}.view.setUint32(${indexVar}, ${lengthVar}, 1);\n            `,\n                type: 'S',\n            };\n        }\n\n        case ReflectionKind.function:\n        case ReflectionKind.method:\n        case ReflectionKind.methodSignature:\n        case ReflectionKind.callSignature:\n            if (runType.src.subKind === ReflectionSubKind.params) {\n                return emitToBinaryAs(runType, comp, ReflectionKind.tuple);\n            } else {\n                throw new Error('Binary serialization not supported for functions, call compileParams or compileReturn instead.');\n            }\n        case ReflectionKind.parameter: {\n            const rt = runType as ParameterRunType;\n            switch (src.subKind) {\n                case ReflectionSubKind.mapKey:\n                case ReflectionSubKind.mapValue:\n                case ReflectionSubKind.setItem: {\n                    const child = rt.getJitChild(comp);\n                    const childJit = comp.compile(child, 'S', fnID);\n                    if (!childJit?.code) throw new Error(`Do not know how to serialize ${rt.getTypeName()} to Binary.`);\n                    return childJit;\n                }\n                default: {\n                    return emitToBinaryAs(runType, comp, ReflectionKind.tupleMember);\n                }\n            }\n        }\n        case ReflectionKind.property:\n        case ReflectionKind.propertySignature: {\n            const rt = runType as PropertyRunType;\n            const parent = rt.getParent() as InterfaceRunType;\n            if (parent.hasIndexSignature(comp)) return {code: undefined, type: 'S'}; // all serialization is done by index signature code\n\n            const memberCode = comp.compile(rt.getJitChild(comp), 'S', fnID).code || '';\n            if (rt.isOptional()) {\n                const {bitMIndexVar, bitIndex} = getOptionalBitmapItems(parent, comp, 0, rt.optionalIndex, false);\n                const setBitMask = `${sεr}.setBitMask(${bitMIndexVar}, ${bitIndex})`;\n                return {code: `if (${comp.getChildVλl()} !== undefined) {${memberCode};${setBitMask}}`, type: 'S'};\n            }\n            // non optional properties rely in the order they are defined in the type so no need to include the index\n            return {code: `${memberCode}`, type: 'S'};\n        }\n        case ReflectionKind.tupleMember: {\n            const rt = runType as ParameterRunType;\n            const child = rt.getJitChild(comp);\n            const childJit = comp.compile(child, 'S', fnID);\n            const nullJIt = emitToBinaryAs(rt, comp, ReflectionKind.undefined);\n            const itemJit = childJit?.code ? childJit : nullJIt; // if child is not serializable, we serialize null as need to fill the space in the tuple\n            if (rt.isRest()) return itemJit;\n            // Optional handling uses bitmap set at tuple level\n            const optionalIndex = (rt as any).optionalIndex;\n            const bitMIndexVar = (rt as any)._bitmapVar;\n            const isFnParam = (rt as any)._isFnParam;\n            // Treat as optional if either isOptional() is true OR it's a function param (all fn params are optional in binary)\n            const isOptional = rt.isOptional() || isFnParam;\n            if (isOptional && optionalIndex !== undefined && bitMIndexVar) {\n                const bitIndex = optionalIndex & 7; // equivalent to optionalIndex % 8\n                const setBitMask = `${sεr}.setBitMask(${bitMIndexVar}, ${bitIndex})`;\n                return {code: `if (${comp.getChildVλl()} !== undefined) {${itemJit.code};${setBitMask}}`, type: 'S'};\n            }\n            return itemJit;\n        }\n\n        case ReflectionKind.promise:\n            throw new Error('Jit compilation disabled for Non Serializable types.');\n\n        // ###################### COLLECTION RUNTYPES ######################\n        // Types that contain other types as members\n        case ReflectionKind.objectLiteral:\n        case ReflectionKind.intersection: {\n            const rt = runType as InterfaceRunType;\n            if (rt.isCallable()) return comp.compile(rt.getCallSignature(), 'S', fnID);\n            if (runType.src.subKind === ReflectionSubKind.nonSerializable) {\n                throw new Error('Binary serialization is disabled for Non Serializable types');\n            } else {\n                // we need to ensure non optional properties are serialized first so then we can restore the object correctly\n                // non optional properties are restored as: '{a: deserializeA, b: deserializeB, c: deserializeC};\n                // and must be serialized/deserialized in the same order they are declared in the type\n                const {required, optional, indexSignatures} = rt.splitJitSplitChildren(comp);\n\n                if (indexSignatures.length) {\n                    return comp.compile(indexSignatures[0], 'S', fnID); // index signature code already contains the loop\n                }\n\n                const requiredProps = required.map((prop) => comp.compile(prop, 'S', fnID).code);\n                const requiredPropsCode = requiredProps.join(';');\n\n                let optionalPropsCode = '';\n                if (optional.length) {\n                    const {bitMapInit, bitMIndexVar} = getOptionalBitmapItems(rt, comp, optional.length, 0, false);\n                    const propsCode = optional\n                        .map((prop, i) => {\n                            prop.optionalIndex = i;\n                            const modIndex = i + 1;\n                            const shouldIncreaseBufferIndex = modIndex % 8 === 0;\n                            const propCode = comp.compile(prop, 'S', fnID).code;\n                            if (!shouldIncreaseBufferIndex) return propCode;\n                            // every 8 props we need to increase the bitmap index\n                            return `${propCode} ${bitMIndexVar}++;`;\n                        })\n                        .filter(Boolean)\n                        .join('');\n                    optionalPropsCode = `${bitMapInit}\\n${propsCode}`;\n                }\n\n                return {code: `${requiredPropsCode}\\n${optionalPropsCode}`, type: 'S'};\n            }\n        }\n        case ReflectionKind.class:\n            switch (runType.src.subKind) {\n                case ReflectionSubKind.date:\n                    return {\n                        code: `${sεr}.view.setFloat64(${sεr}.index, ${comp.vλl}.getTime(), 1, (${sεr}.index += 8))`,\n                        type: 'S',\n                    };\n                case ReflectionSubKind.map:\n                case ReflectionSubKind.set: {\n                    const rt = runType as IterableRunType;\n                    const sεr = comp.args.sεr;\n                    const entry = rt.getCustomVλl(comp)?.vλl || comp.vλl;\n                    const jitChildren = rt.getJitChildren(comp);\n                    const childrenCode = jitChildren\n                        .map((c) => comp.compile(c, 'S', fnID).code)\n                        .filter(Boolean)\n                        .join(';');\n                    // Serialize length at the beginning, then iterate and serialize items\n                    const setLength = `${sεr}.view.setUint32(${sεr}.index, ${comp.vλl}.size, 1); ${sεr}.index += 4;`;\n                    return {\n                        code: `${setLength} for (const ${entry} of ${comp.vλl}) {${childrenCode}}`,\n                        type: 'S',\n                    };\n                }\n                case ReflectionSubKind.nonSerializable:\n                    throw new Error('Binary serialization disabled for Non Serializable types');\n                default: {\n                    const rt = runType as InterfaceRunType;\n                    if (rt.isCallable()) {\n                        const callSignature = rt.getCallSignature();\n                        if (callSignature) return comp.compile(callSignature, 'S', fnID);\n                    }\n                    const originalKind = runType.src.kind;\n                    (runType.src as any).kind = ReflectionKind.objectLiteral;\n                    const result = emitToBinary(runType, comp);\n                    (runType.src as any).kind = originalKind;\n                    return result;\n                }\n            }\n            break;\n\n        case ReflectionKind.infer:\n            throw new Error('Infer is not supported in Binary serialization');\n\n        case ReflectionKind.tuple: {\n            const rt = runType as TupleRunType;\n            const skip = rt.skipJit(comp);\n            if (skip) return {code: undefined, type: 'S'};\n            const params = rt.getParamRunTypes(comp);\n            if (params.length === 0) return {code: undefined, type: 'S'};\n\n            // For function params, all params are treated as optional in binary serialization\n            // This allows sending null/undefined values over the wire even if the type is not optional\n            const isFnParams = runType.src.subKind === ReflectionSubKind.params;\n\n            // Split params into required, optional, and rest\n            // For function params, all non-rest params are treated as optional\n            const required = isFnParams ? [] : params.filter((p) => !p.isOptional() && !p.isRest());\n            const optional = isFnParams ? params.filter((p) => !p.isRest()) : params.filter((p) => p.isOptional() && !p.isRest());\n            const rest = params.filter((p) => p.isRest());\n\n            // Serialize required params first\n            const requiredCode = required.map((p) => comp.compile(p, 'S', fnID).code).join(';');\n\n            // Serialize optional params with bitmap (groups of 8)\n            let optionalCode = '';\n            if (optional.length) {\n                const {bitMapInit, bitMIndexVar} = getOptionalBitmapItems(rt, comp, optional.length, 0, true);\n                const optionalParamsCode = optional\n                    .map((p, i) => {\n                        (p as any).optionalIndex = i; // set optionalIndex for use in tupleMember case\n                        (p as any)._bitmapVar = bitMIndexVar; // pass bitmap variable name to tupleMember case\n                        (p as any)._isFnParam = isFnParams; // flag to indicate this is a function param\n                        const paramCode = comp.compile(p, 'S', fnID).code || '';\n                        const modIndex = i + 1;\n                        const shouldIncreaseBufferIndex = modIndex % 8 === 0 && modIndex < optional.length;\n                        const increaseIndex = shouldIncreaseBufferIndex ? `${bitMIndexVar}++;` : '';\n                        return `${paramCode} ${increaseIndex}`;\n                    })\n                    .join('');\n                optionalCode = `${bitMapInit}\\n${optionalParamsCode}`;\n            }\n\n            // Serialize rest params (handled as array by the rest param itself)\n            const restCode = rest.map((p) => comp.compile(p, 'S', fnID).code).join(';');\n\n            const allCode = [requiredCode, optionalCode, restCode].filter(Boolean).join(';');\n            return {code: allCode, type: 'S'};\n        }\n        case ReflectionKind.typeParameter:\n            throw new Error('Type parameter not implemented in Binary serialization');\n\n        case ReflectionKind.union: {\n            const rt = runType as UnionRunType;\n            rt.checkAllowedChildren(comp);\n            const {simpleItems, objectTypes, anyItem} = rt.getUnionChildren(comp);\n            const totalLength = simpleItems.length + objectTypes.length + (anyItem ? 1 : 0);\n            if (totalLength > MAX_UNION_ITEMS) {\n                throw new Error(\n                    `Binary serialization not supported for Union with more than ${MAX_UNION_ITEMS} items.` +\n                        ` Found ${totalLength} in ${rt.getUnionTypeNames()}`\n                );\n            }\n            const errName = comp.getLocalVarName('uErr', rt);\n            const fail = `throw new Error(${errName});`;\n            comp.setContextItem(\n                errName,\n                `const ${errName} = \"Can not encode union to binary: item does not belong to the union\"`\n            );\n            const ifElse = createIfElseFn();\n            // Helper to generate encode code for a union item\n            const getEncodeCode = (childRt: BaseRunType) => {\n                const toJit = comp.compile(childRt, 'S', fnID);\n                const encodeCode = toJit.code || '';\n                const index = rt.getUnionItemIndex(comp, childRt);\n                const isUint16 = index > 255;\n                const writeIndex = isUint16\n                    ? `${sεr}.view.setUint16(${sεr}.index, ${index}, 1, (${sεr}.index += 2))`\n                    : `${sεr}.view.setUint8(${sεr}.index++, ${index})`;\n                return `${writeIndex};${encodeCode}`;\n            };\n            // Generate code for simple items (atomic types)\n            const simpleCode = simpleItems.map((childRt) => {\n                const isTypeCode = rt.getChildIsTypeWithLooseCheck(childRt, comp);\n                return `${ifElse()} (${isTypeCode}) {${getEncodeCode(childRt)}}`;\n            });\n            // Generate code for object types (need null guard)\n            const objCode = objectTypes.length\n                ? objectTypes.map((childRt) => {\n                      const isTypeCode = rt.getChildIsTypeWithLooseCheck(childRt, comp);\n                      return `${ifElse()} (typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null && ${isTypeCode}) {${getEncodeCode(childRt)}}`;\n                  })\n                : [];\n            // Generate code for anyItem (always matches, checked last as fallback)\n            const anyCode = anyItem ? `${ifElse(true)} {${getEncodeCode(anyItem)}}` : `${ifElse(true)} {${fail}}`;\n            return {code: [...simpleCode, ...objCode, anyCode].join(''), type: 'S'};\n        }\n        default:\n            throw new Error(`Binary serialization not supported for ${ReflectionKind[kind]} types`);\n    }\n\n    // Default return for cases that break without returning\n    return {code: undefined, type: 'S'};\n}\n\n/** Generates bitmap initialization code for optional properties/params. Uses 1 bit per optional item (8 items per byte). */\nfunction getOptionalBitmapItems(\n    rt: InterfaceRunType | TupleRunType,\n    comp: BinaryCompiler,\n    optionalLength = 0,\n    currentIndex = 0,\n    isTuple = false\n) {\n    const sεr = comp.args.sεr;\n    const prefix = isTuple ? 't' : '';\n    const bitMIndexVar = comp.getLocalVarName(`${prefix}bmI`, rt); // index of the bitmap\n    const bitmapLength = Math.ceil(optionalLength / 8);\n    const bitIndex = `${currentIndex} & 7`; // equivalent to index % 8\n    // initialize bitmap to zero as there could be values left from previous serialization\n    const indexVar = comp.getLocalVarName(`${prefix}iBl`, rt);\n    const setBitmapToZero =\n        bitmapLength > 1\n            ? `for (let ${indexVar} = 0; ${indexVar} < ${bitmapLength}; ${indexVar}++) {${sεr}.view.setUint8(${sεr}.index++, 0)}`\n            : `${sεr}.view.setUint8(${sεr}.index++, 0)`;\n    const bitMapInit = `${bitmapLength > 1 ? 'let ' : 'const'} ${bitMIndexVar} = ${sεr}.index; ${setBitmapToZero}`;\n    return {bitMIndexVar, bitmapLength, bitIndex, bitMapInit};\n}\n\nfunction emitToBinaryAs(rt: BaseRunType, comp: BinaryCompiler, kind: ReflectionKind): JitCode {\n    const originalKind = rt.src.kind;\n    (rt.src as any).kind = kind;\n    const result = emitToBinary(rt, comp);\n    (rt.src as any).kind = originalKind;\n    return result;\n}\n"],"names":["sεr"],"mappings":"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"}

package/.dist/esm/src/jitCompilers/equalsHelpers.d.ts

@@ -0,0 +1,4 @@
+export declare function normalizeForComparison(actual: any, expected: any): {
+    actual: any;
+    expected: any;
+};

package/.dist/esm/src/jitCompilers/equalsHelpers.js

@@ -0,0 +1,37 @@
+function normalizeForComparison(actual, expected) {
+  if (Array.isArray(actual) && Array.isArray(expected)) {
+    const maxLength = Math.max(actual.length, expected.length);
+    const normalizedActual = normalizeArrayForComparison(actual, maxLength);
+    const normalizedExpected = normalizeArrayForComparison(expected, maxLength);
+    const resultActual = [];
+    const resultExpected = [];
+    for (let i = 0; i < maxLength; i++) {
+      const normalized = normalizeForComparison(normalizedActual[i], normalizedExpected[i]);
+      resultActual.push(normalized.actual);
+      resultExpected.push(normalized.expected);
+    }
+    return { actual: resultActual, expected: resultExpected };
+  }
+  if (actual && expected && typeof actual === "object" && typeof expected === "object") {
+    const actualKeys = Object.keys(actual);
+    const expectedKeys = Object.keys(expected);
+    const allKeys = [.../* @__PURE__ */ new Set([...actualKeys, ...expectedKeys])];
+    const resultActual = {};
+    const resultExpected = {};
+    for (const key of allKeys) {
+      const normalized = normalizeForComparison(actual[key], expected[key]);
+      resultActual[key] = normalized.actual;
+      resultExpected[key] = normalized.expected;
+    }
+    return { actual: resultActual, expected: resultExpected };
+  }
+  return { actual, expected };
+}
+function normalizeArrayForComparison(arr, targetLength) {
+  if (arr.length >= targetLength) return arr;
+  return [...arr, ...Array(targetLength - arr.length).fill(void 0)];
+}
+export {
+  normalizeForComparison
+};
+//# sourceMappingURL=equalsHelpers.js.map

package/.dist/esm/src/jitCompilers/equalsHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"equalsHelpers.js","sources":["../../../../src/jitCompilers/equalsHelpers.ts"],"sourcesContent":["/* ###############\n * 2026 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ############### */\n\n/**\n * Recursively normalizes values for comparison, handling arrays with optional elements.\n * Returns an object with normalized actual and expected values for direct comparison.\n *\n * This is needed because Vitest's toEqual is stricter than Jest's when comparing arrays\n * with optional/undefined elements. For example:\n * - Jest: [446] equals [446, undefined, undefined, undefined] // true\n * - Vitest: [446] equals [446, undefined, undefined, undefined] // false\n *\n * This function pads shorter arrays with undefined to match the longer array's length,\n * then recursively normalizes nested values.\n */\nexport function normalizeForComparison(actual: any, expected: any): {actual: any; expected: any} {\n    // Handle arrays - normalize length to match expected\n    if (Array.isArray(actual) && Array.isArray(expected)) {\n        const maxLength = Math.max(actual.length, expected.length);\n        const normalizedActual = normalizeArrayForComparison(actual, maxLength);\n        const normalizedExpected = normalizeArrayForComparison(expected, maxLength);\n        const resultActual: any[] = [];\n        const resultExpected: any[] = [];\n        for (let i = 0; i < maxLength; i++) {\n            const normalized = normalizeForComparison(normalizedActual[i], normalizedExpected[i]);\n            resultActual.push(normalized.actual);\n            resultExpected.push(normalized.expected);\n        }\n        return {actual: resultActual, expected: resultExpected};\n    }\n    // Handle nested objects\n    if (actual && expected && typeof actual === 'object' && typeof expected === 'object') {\n        const actualKeys = Object.keys(actual);\n        const expectedKeys = Object.keys(expected);\n        const allKeys = [...new Set([...actualKeys, ...expectedKeys])];\n        const resultActual: any = {};\n        const resultExpected: any = {};\n        for (const key of allKeys) {\n            const normalized = normalizeForComparison(actual[key], expected[key]);\n            resultActual[key] = normalized.actual;\n            resultExpected[key] = normalized.expected;\n        }\n        return {actual: resultActual, expected: resultExpected};\n    }\n    // Primitive values - return as-is\n    return {actual, expected};\n}\n\n/**\n * Normalizes arrays for comparison by padding shorter arrays with undefined values.\n * This handles the difference between Jest and Vitest's toEqual behavior with optional tuple elements.\n * Jest considered [446] and [446, undefined, undefined, undefined] as equal,\n * but Vitest is stricter and requires explicit undefined values.\n */\nfunction normalizeArrayForComparison(arr: any[], targetLength: number): any[] {\n    if (arr.length >= targetLength) return arr;\n    return [...arr, ...Array(targetLength - arr.length).fill(undefined)];\n}\n"],"names":[],"mappings":"AAmBO,SAAS,uBAAuB,QAAa,UAA6C;AAE7F,MAAI,MAAM,QAAQ,MAAM,KAAK,MAAM,QAAQ,QAAQ,GAAG;AAClD,UAAM,YAAY,KAAK,IAAI,OAAO,QAAQ,SAAS,MAAM;AACzD,UAAM,mBAAmB,4BAA4B,QAAQ,SAAS;AACtE,UAAM,qBAAqB,4BAA4B,UAAU,SAAS;AAC1E,UAAM,eAAsB,CAAA;AAC5B,UAAM,iBAAwB,CAAA;AAC9B,aAAS,IAAI,GAAG,IAAI,WAAW,KAAK;AAChC,YAAM,aAAa,uBAAuB,iBAAiB,CAAC,GAAG,mBAAmB,CAAC,CAAC;AACpF,mBAAa,KAAK,WAAW,MAAM;AACnC,qBAAe,KAAK,WAAW,QAAQ;AAAA,IAC3C;AACA,WAAO,EAAC,QAAQ,cAAc,UAAU,eAAA;AAAA,EAC5C;AAEA,MAAI,UAAU,YAAY,OAAO,WAAW,YAAY,OAAO,aAAa,UAAU;AAClF,UAAM,aAAa,OAAO,KAAK,MAAM;AACrC,UAAM,eAAe,OAAO,KAAK,QAAQ;AACzC,UAAM,UAAU,CAAC,GAAG,oBAAI,IAAI,CAAC,GAAG,YAAY,GAAG,YAAY,CAAC,CAAC;AAC7D,UAAM,eAAoB,CAAA;AAC1B,UAAM,iBAAsB,CAAA;AAC5B,eAAW,OAAO,SAAS;AACvB,YAAM,aAAa,uBAAuB,OAAO,GAAG,GAAG,SAAS,GAAG,CAAC;AACpE,mBAAa,GAAG,IAAI,WAAW;AAC/B,qBAAe,GAAG,IAAI,WAAW;AAAA,IACrC;AACA,WAAO,EAAC,QAAQ,cAAc,UAAU,eAAA;AAAA,EAC5C;AAEA,SAAO,EAAC,QAAQ,SAAA;AACpB;AAQA,SAAS,4BAA4B,KAAY,cAA6B;AAC1E,MAAI,IAAI,UAAU,aAAc,QAAO;AACvC,SAAO,CAAC,GAAG,KAAK,GAAG,MAAM,eAAe,IAAI,MAAM,EAAE,KAAK,MAAS,CAAC;AACvE;"}

package/.dist/esm/src/jitCompilers/json/jsonSpec/jsonHelpers.d.ts

@@ -0,0 +1,27 @@
+import { InterfaceRunType } from '../../../nodes/collection/interface.ts';
+import { FunctionRunType } from '../../../nodes/function/function.ts';
+import { RunType } from '../../../types.ts';
+export declare function createSerializationFns(rt: RunType): {
+    serialize: (v: any) => string;
+    deserialize: (data: any) => any;
+};
+export declare function createSerializationParamsFn(rt: FunctionRunType, sliceStart?: number): {
+    serialize: (v: any) => string;
+    deserialize: (data: any) => any;
+};
+export declare function createSerializationReturnFn(rt: FunctionRunType): {
+    serialize: (v: any) => string;
+    deserialize: (data: any) => any;
+};
+export declare function createSerializationCallSignatureParamsFn(rt: InterfaceRunType): {
+    serialize: (v: any) => string;
+    deserialize: (data: any) => any;
+};
+export declare function createSerializationCallSignatureReturnFn(rt: InterfaceRunType): {
+    serialize: (v: any) => string;
+    deserialize: (data: any) => any;
+};
+export declare function roundTrip(serialize: (v: any) => string, deserialize: (v: string) => any, value: any): {
+    serialized: string;
+    deserialized: any;
+};

package/.dist/esm/src/jitCompilers/json/jsonSpec/jsonHelpers.js

@@ -0,0 +1,56 @@
+import { JitFunctions } from "../../../constants.functions.js";
+const SERIALIZE_FN = JitFunctions.prepareForJson;
+const DESERIALIZE_FN = JitFunctions.restoreFromJson;
+function createSerializationFns(rt) {
+  const prepareForJson = rt.createJitFunction(SERIALIZE_FN);
+  const restoreFromJson = rt.createJitFunction(DESERIALIZE_FN);
+  const serialize = (v) => JSON.stringify(prepareForJson(v));
+  const deserialize = (data) => restoreFromJson(JSON.parse(data));
+  return { serialize, deserialize };
+}
+function createSerializationParamsFn(rt, sliceStart) {
+  const params = typeof sliceStart === "number" ? { paramsSlice: { start: sliceStart } } : void 0;
+  const prepareForJson = rt.createJitParamsFunction(SERIALIZE_FN, params);
+  const restoreFromJson = rt.createJitParamsFunction(DESERIALIZE_FN, params);
+  const serialize = (v) => JSON.stringify(prepareForJson(v));
+  const deserialize = (data) => restoreFromJson(JSON.parse(data));
+  return { serialize, deserialize };
+}
+function createSerializationReturnFn(rt) {
+  const prepareForJson = rt.createJitReturnFunction(SERIALIZE_FN);
+  const restoreFromJson = rt.createJitReturnFunction(DESERIALIZE_FN);
+  const serialize = (v) => JSON.stringify(prepareForJson(v));
+  const deserialize = (data) => restoreFromJson(JSON.parse(data));
+  return { serialize, deserialize };
+}
+function createSerializationCallSignatureParamsFn(rt) {
+  const callSignature = rt.getCallSignature();
+  const prepareForJson = callSignature.createJitParamsFunction(SERIALIZE_FN);
+  const restoreFromJson = callSignature.createJitParamsFunction(DESERIALIZE_FN);
+  const serialize = (v) => JSON.stringify(prepareForJson(v));
+  const deserialize = (data) => restoreFromJson(JSON.parse(data));
+  return { serialize, deserialize };
+}
+function createSerializationCallSignatureReturnFn(rt) {
+  const callSignature = rt.getCallSignature();
+  const prepareForJson = callSignature.createJitReturnFunction(SERIALIZE_FN);
+  const restoreFromJson = callSignature.createJitReturnFunction(DESERIALIZE_FN);
+  const serialize = (v) => JSON.stringify(prepareForJson(v));
+  const deserialize = (data) => restoreFromJson(JSON.parse(data));
+  return { serialize, deserialize };
+}
+function roundTrip(serialize, deserialize, value) {
+  const serialized = serialize(value);
+  const deserialized = deserialize(serialized);
+  const result = { serialized, deserialized };
+  return result;
+}
+export {
+  createSerializationCallSignatureParamsFn,
+  createSerializationCallSignatureReturnFn,
+  createSerializationFns,
+  createSerializationParamsFn,
+  createSerializationReturnFn,
+  roundTrip
+};
+//# sourceMappingURL=jsonHelpers.js.map

package/.dist/esm/src/jitCompilers/json/jsonSpec/jsonHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonHelpers.js","sources":["../../../../../../src/jitCompilers/json/jsonSpec/jsonHelpers.ts"],"sourcesContent":["/* ########\n * 2025 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {JitFunctions} from '../../../constants.functions.ts';\nimport type {InterfaceRunType} from '../../../nodes/collection/interface.ts';\nimport type {FunctionRunType} from '../../../nodes/function/function.ts';\nimport type {RunType} from '../../../types.ts';\n\nconst SERIALIZE_FN = JitFunctions.prepareForJson;\nconst DESERIALIZE_FN = JitFunctions.restoreFromJson;\n\nexport function createSerializationFns(rt: RunType) {\n    const prepareForJson = rt.createJitFunction(SERIALIZE_FN);\n    const restoreFromJson = rt.createJitFunction(DESERIALIZE_FN);\n    const serialize = (v: any) => JSON.stringify(prepareForJson(v));\n    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));\n    return {serialize, deserialize};\n}\n\nexport function createSerializationParamsFn(rt: FunctionRunType, sliceStart?: number) {\n    const params = typeof sliceStart === 'number' ? {paramsSlice: {start: sliceStart}} : undefined;\n    const prepareForJson = rt.createJitParamsFunction(SERIALIZE_FN, params);\n    const restoreFromJson = rt.createJitParamsFunction(DESERIALIZE_FN, params);\n    const serialize = (v: any) => JSON.stringify(prepareForJson(v));\n    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));\n    return {serialize, deserialize};\n}\n\nexport function createSerializationReturnFn(rt: FunctionRunType) {\n    const prepareForJson = rt.createJitReturnFunction(SERIALIZE_FN);\n    const restoreFromJson = rt.createJitReturnFunction(DESERIALIZE_FN);\n    const serialize = (v: any) => JSON.stringify(prepareForJson(v));\n    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));\n    return {serialize, deserialize};\n}\n\nexport function createSerializationCallSignatureParamsFn(rt: InterfaceRunType) {\n    const callSignature = rt.getCallSignature()!;\n    const prepareForJson = callSignature.createJitParamsFunction(SERIALIZE_FN);\n    const restoreFromJson = callSignature.createJitParamsFunction(DESERIALIZE_FN);\n    const serialize = (v: any) => JSON.stringify(prepareForJson(v));\n    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));\n    return {serialize, deserialize};\n}\n\nexport function createSerializationCallSignatureReturnFn(rt: InterfaceRunType) {\n    const callSignature = rt.getCallSignature()!;\n    const prepareForJson = callSignature.createJitReturnFunction(SERIALIZE_FN);\n    const restoreFromJson = callSignature.createJitReturnFunction(DESERIALIZE_FN);\n    const serialize = (v: any) => JSON.stringify(prepareForJson(v));\n    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));\n    return {serialize, deserialize};\n}\n\nexport function roundTrip(serialize: (v: any) => string, deserialize: (v: string) => any, value: any) {\n    const serialized = serialize(value);\n    const deserialized = deserialize(serialized);\n    const result = {serialized, deserialized};\n    return result;\n}\n"],"names":[],"mappings":";AAYA,MAAM,eAAe,aAAa;AAClC,MAAM,iBAAiB,aAAa;AAE7B,SAAS,uBAAuB,IAAa;AAChD,QAAM,iBAAiB,GAAG,kBAAkB,YAAY;AACxD,QAAM,kBAAkB,GAAG,kBAAkB,cAAc;AAC3D,QAAM,YAAY,CAAC,MAAW,KAAK,UAAU,eAAe,CAAC,CAAC;AAC9D,QAAM,cAAc,CAAC,SAAc,gBAAgB,KAAK,MAAM,IAAI,CAAC;AACnE,SAAO,EAAC,WAAW,YAAA;AACvB;AAEO,SAAS,4BAA4B,IAAqB,YAAqB;AAClF,QAAM,SAAS,OAAO,eAAe,WAAW,EAAC,aAAa,EAAC,OAAO,WAAA,EAAU,IAAK;AACrF,QAAM,iBAAiB,GAAG,wBAAwB,cAAc,MAAM;AACtE,QAAM,kBAAkB,GAAG,wBAAwB,gBAAgB,MAAM;AACzE,QAAM,YAAY,CAAC,MAAW,KAAK,UAAU,eAAe,CAAC,CAAC;AAC9D,QAAM,cAAc,CAAC,SAAc,gBAAgB,KAAK,MAAM,IAAI,CAAC;AACnE,SAAO,EAAC,WAAW,YAAA;AACvB;AAEO,SAAS,4BAA4B,IAAqB;AAC7D,QAAM,iBAAiB,GAAG,wBAAwB,YAAY;AAC9D,QAAM,kBAAkB,GAAG,wBAAwB,cAAc;AACjE,QAAM,YAAY,CAAC,MAAW,KAAK,UAAU,eAAe,CAAC,CAAC;AAC9D,QAAM,cAAc,CAAC,SAAc,gBAAgB,KAAK,MAAM,IAAI,CAAC;AACnE,SAAO,EAAC,WAAW,YAAA;AACvB;AAEO,SAAS,yCAAyC,IAAsB;AAC3E,QAAM,gBAAgB,GAAG,iBAAA;AACzB,QAAM,iBAAiB,cAAc,wBAAwB,YAAY;AACzE,QAAM,kBAAkB,cAAc,wBAAwB,cAAc;AAC5E,QAAM,YAAY,CAAC,MAAW,KAAK,UAAU,eAAe,CAAC,CAAC;AAC9D,QAAM,cAAc,CAAC,SAAc,gBAAgB,KAAK,MAAM,IAAI,CAAC;AACnE,SAAO,EAAC,WAAW,YAAA;AACvB;AAEO,SAAS,yCAAyC,IAAsB;AAC3E,QAAM,gBAAgB,GAAG,iBAAA;AACzB,QAAM,iBAAiB,cAAc,wBAAwB,YAAY;AACzE,QAAM,kBAAkB,cAAc,wBAAwB,cAAc;AAC5E,QAAM,YAAY,CAAC,MAAW,KAAK,UAAU,eAAe,CAAC,CAAC;AAC9D,QAAM,cAAc,CAAC,SAAc,gBAAgB,KAAK,MAAM,IAAI,CAAC;AACnE,SAAO,EAAC,WAAW,YAAA;AACvB;AAEO,SAAS,UAAU,WAA+B,aAAiC,OAAY;AAClG,QAAM,aAAa,UAAU,KAAK;AAClC,QAAM,eAAe,YAAY,UAAU;AAC3C,QAAM,SAAS,EAAC,YAAY,aAAA;AAC5B,SAAO;AACX;"}

package/.dist/esm/src/jitCompilers/json/stringifyJson.d.ts

@@ -0,0 +1,10 @@
+import { JitFunctions } from '../../constants.functions.ts';
+import { JitFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { JitCode } from '../../types.ts';
+import { BaseRunType } from '../../lib/baseRunTypes.ts';
+import { IterableRunType } from '../../nodes/native/Iterable.ts';
+type Operation = typeof JitFunctions.stringifyJson.id | typeof JitFunctions.toJSCode.id;
+export declare function createStringifyCompiler(fnID: Operation): (runType: BaseRunType, comp: JitFnCompiler) => JitCode;
+export declare function createStringifyIterable(fnID: Operation): (rt: IterableRunType, comp: JitFnCompiler, codePrefix?: string, codeSuffix?: string) => JitCode;
+export declare const emitJsonStringify: (runType: BaseRunType, comp: JitFnCompiler) => JitCode;
+export {};