@mionjs/core 0.8.4-alpha.0 → 0.8.6

package/.dist/cjs/index.cjs

@@ -26,6 +26,10 @@ exports.__ΩAnyErrorParams = src_types_general_types.__ΩAnyErrorParams;
 exports.__ΩAnyFn = src_types_general_types.__ΩAnyFn;
 exports.__ΩAnyObject = src_types_general_types.__ΩAnyObject;
 exports.__ΩBinaryInput = src_types_general_types.__ΩBinaryInput;
+exports.__ΩClientSrcCodeCompiledPureFunction = src_types_general_types.__ΩClientSrcCodeCompiledPureFunction;
+exports.__ΩClientSrcCodeJITCompiledFnsCache = src_types_general_types.__ΩClientSrcCodeJITCompiledFnsCache;
+exports.__ΩClientSrcCodeJitCompiledFn = src_types_general_types.__ΩClientSrcCodeJitCompiledFn;
+exports.__ΩClientSrcCodePureFunctionsCache = src_types_general_types.__ΩClientSrcCodePureFunctionsCache;
 exports.__ΩCoreRouterOptions = src_types_general_types.__ΩCoreRouterOptions;
 exports.__ΩDataOnly = src_types_general_types.__ΩDataOnly;
 exports.__ΩDataViewDeserializer = src_types_general_types.__ΩDataViewDeserializer;

package/.dist/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/cjs/src/binary/bodyDeserializer.cjs

@@ -38,6 +38,11 @@ function deserializeBinaryBody(path, buffer, isResponse) {
 }
 function deserializeMethod(key, method, deserializer, isResponse) {
   const jitFns = isResponse ? method.returnJitFns : method.paramsJitFns;
+  if (!jitFns.fromBinary?.fn)
+    throw new src_errors.RpcError({
+      type: "missing-fromBinary-jit-fn",
+      publicMessage: `Missing fromBinary JIT function for method ${key}`
+    });
   try {
     return jitFns.fromBinary.fn(void 0, deserializer);
   } catch (e) {

package/.dist/cjs/src/binary/bodyDeserializer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"bodyDeserializer.cjs","sources":["../../../../src/binary/bodyDeserializer.ts"],"sourcesContent":["import {createDataViewDeserializer} from './dataView.ts';\nimport {StatusCodes} from '../constants.ts';\nimport {RpcError} from '../errors.ts';\nimport type {BinaryInput, DataViewDeserializer} from '../types/general.types.ts';\nimport type {MethodWithJitFns} from '../types/method.types.ts';\nimport {routesCache} from '../routerUtils.ts';\n\n/**\n * Deserializes API body from binary format using JIT-compiled deserialization functions.\n * Reads the binary buffer and reconstructs the body record.\n * Method metadata is looked up from routesCache automatically.\n */\nexport function deserializeBinaryBody(\n    path: string,\n    buffer: BinaryInput,\n    /** If true, the body is a response body, otherwise it's a request body */\n    isResponse: boolean\n): {\n    deserializer: DataViewDeserializer;\n    body: Record<string, any>;\n} {\n    try {\n        // Create deserializer from buffer\n        const deserializer = createDataViewDeserializer(path, buffer);\n        const body: Record<string, any> = {};\n\n        // Read items length from first 32 bits\n        const itemsLength = deserializer.view.getUint32(0, true);\n        deserializer.index += 4;\n\n        // Deserialize each item\n        for (let i = 0; i < itemsLength; i++) {\n            // Deserialize key (method id)\n            const key = deserializer.desString();\n\n            // Find the corresponding method from routesCache\n            const method = routesCache.getMethodJitFns(key);\n            if (!method) {\n                throw new RpcError({\n                    statusCode: StatusCodes.UNEXPECTED_ERROR,\n                    type: isResponse\n                        ? 'binary-response-method-Deserialization-error'\n                        : 'binary-request-method-Deserialization-error',\n                    publicMessage: `Unknown method key in binary body: ${key}`,\n                    errorData: {methodId: key},\n                });\n            }\n\n            // Deserialize value using the appropriate JIT function\n            const value = deserializeMethod(key, method, deserializer, isResponse);\n            body[key] = value;\n        }\n\n        deserializer.markAsEnded();\n        return {deserializer, body};\n    } catch (err: any) {\n        if (err instanceof RpcError) throw err;\n        throw new RpcError({\n            statusCode: StatusCodes.UNEXPECTED_ERROR,\n            type: isResponse ? 'binary-response-Deserialize-error' : 'binary-request-Deserialization-error',\n            publicMessage: `Failed to deserialize body from binary: ${err?.message || 'unknown error'}`,\n            originalError: err,\n        });\n    }\n}\n\n/** Deserializes a single method's value from binary format */\nfunction deserializeMethod(key: string, method: MethodWithJitFns, deserializer: DataViewDeserializer, isResponse: boolean): any {\n    const jitFns = isResponse ? method.returnJitFns : method.paramsJitFns;\n    try {\n        return jitFns.fromBinary.fn(undefined, deserializer);\n    } catch (e: any) {\n        throw new RpcError({\n            statusCode: StatusCodes.UNEXPECTED_ERROR,\n            type: isResponse ? 'binary-response-method-Deserialization-error' : 'binary-request-method-Deserialization-error',\n            publicMessage: `Failed to deserialize method ${key} from binary`,\n            originalError: e,\n            errorData: {methodId: key},\n        });\n    }\n}\n"],"names":["createDataViewDeserializer","routesCache","RpcError","StatusCodes"],"mappings":";;;;;;AAYO,SAAS,sBACZ,MACA,QAEA,YAIF;AACE,MAAI;AAEA,UAAM,eAAeA,oBAAAA,2BAA2B,MAAM,MAAM;AAC5D,UAAM,OAA4B,CAAA;AAGlC,UAAM,cAAc,aAAa,KAAK,UAAU,GAAG,IAAI;AACvD,iBAAa,SAAS;AAGtB,aAAS,IAAI,GAAG,IAAI,aAAa,KAAK;AAElC,YAAM,MAAM,aAAa,UAAA;AAGzB,YAAM,SAASC,gBAAAA,YAAY,gBAAgB,GAAG;AAC9C,UAAI,CAAC,QAAQ;AACT,cAAM,IAAIC,WAAAA,SAAS;AAAA,UACf,YAAYC,cAAAA,YAAY;AAAA,UACxB,MAAM,aACA,iDACA;AAAA,UACN,eAAe,sCAAsC,GAAG;AAAA,UACxD,WAAW,EAAC,UAAU,IAAA;AAAA,QAAG,CAC5B;AAAA,MACL;AAGA,YAAM,QAAQ,kBAAkB,KAAK,QAAQ,cAAc,UAAU;AACrE,WAAK,GAAG,IAAI;AAAA,IAChB;AAEA,iBAAa,YAAA;AACb,WAAO,EAAC,cAAc,KAAA;AAAA,EAC1B,SAAS,KAAU;AACf,QAAI,eAAeD,WAAAA,SAAU,OAAM;AACnC,UAAM,IAAIA,WAAAA,SAAS;AAAA,MACf,YAAYC,cAAAA,YAAY;AAAA,MACxB,MAAM,aAAa,sCAAsC;AAAA,MACzD,eAAe,2CAA2C,KAAK,WAAW,eAAe;AAAA,MACzF,eAAe;AAAA,IAAA,CAClB;AAAA,EACL;AACJ;AAGA,SAAS,kBAAkB,KAAa,QAA0B,cAAoC,YAA0B;AAC5H,QAAM,SAAS,aAAa,OAAO,eAAe,OAAO;AACzD,MAAI;AACA,WAAO,OAAO,WAAW,GAAG,QAAW,YAAY;AAAA,EACvD,SAAS,GAAQ;AACb,UAAM,IAAID,WAAAA,SAAS;AAAA,MACf,YAAYC,cAAAA,YAAY;AAAA,MACxB,MAAM,aAAa,iDAAiD;AAAA,MACpE,eAAe,gCAAgC,GAAG;AAAA,MAClD,eAAe;AAAA,MACf,WAAW,EAAC,UAAU,IAAA;AAAA,IAAG,CAC5B;AAAA,EACL;AACJ;;"}
+{"version":3,"file":"bodyDeserializer.cjs","sources":["../../../../src/binary/bodyDeserializer.ts"],"sourcesContent":["import {createDataViewDeserializer} from './dataView.ts';\nimport {StatusCodes} from '../constants.ts';\nimport {RpcError} from '../errors.ts';\nimport type {BinaryInput, DataViewDeserializer} from '../types/general.types.ts';\nimport type {MethodWithJitFns} from '../types/method.types.ts';\nimport {routesCache} from '../routerUtils.ts';\n\n/**\n * Deserializes API body from binary format using JIT-compiled deserialization functions.\n * Reads the binary buffer and reconstructs the body record.\n * Method metadata is looked up from routesCache automatically.\n */\nexport function deserializeBinaryBody(\n    path: string,\n    buffer: BinaryInput,\n    /** If true, the body is a response body, otherwise it's a request body */\n    isResponse: boolean\n): {\n    deserializer: DataViewDeserializer;\n    body: Record<string, any>;\n} {\n    try {\n        // Create deserializer from buffer\n        const deserializer = createDataViewDeserializer(path, buffer);\n        const body: Record<string, any> = {};\n\n        // Read items length from first 32 bits\n        const itemsLength = deserializer.view.getUint32(0, true);\n        deserializer.index += 4;\n\n        // Deserialize each item\n        for (let i = 0; i < itemsLength; i++) {\n            // Deserialize key (method id)\n            const key = deserializer.desString();\n\n            // Find the corresponding method from routesCache\n            const method = routesCache.getMethodJitFns(key);\n            if (!method) {\n                throw new RpcError({\n                    statusCode: StatusCodes.UNEXPECTED_ERROR,\n                    type: isResponse\n                        ? 'binary-response-method-Deserialization-error'\n                        : 'binary-request-method-Deserialization-error',\n                    publicMessage: `Unknown method key in binary body: ${key}`,\n                    errorData: {methodId: key},\n                });\n            }\n\n            // Deserialize value using the appropriate JIT function\n            const value = deserializeMethod(key, method, deserializer, isResponse);\n            body[key] = value;\n        }\n\n        deserializer.markAsEnded();\n        return {deserializer, body};\n    } catch (err: any) {\n        if (err instanceof RpcError) throw err;\n        throw new RpcError({\n            statusCode: StatusCodes.UNEXPECTED_ERROR,\n            type: isResponse ? 'binary-response-Deserialize-error' : 'binary-request-Deserialization-error',\n            publicMessage: `Failed to deserialize body from binary: ${err?.message || 'unknown error'}`,\n            originalError: err,\n        });\n    }\n}\n\n/** Deserializes a single method's value from binary format */\nfunction deserializeMethod(key: string, method: MethodWithJitFns, deserializer: DataViewDeserializer, isResponse: boolean): any {\n    const jitFns = isResponse ? method.returnJitFns : method.paramsJitFns;\n    if (!jitFns.fromBinary?.fn)\n        throw new RpcError({\n            type: 'missing-fromBinary-jit-fn',\n            publicMessage: `Missing fromBinary JIT function for method ${key}`,\n        });\n    try {\n        return jitFns.fromBinary.fn(undefined, deserializer);\n    } catch (e: any) {\n        throw new RpcError({\n            statusCode: StatusCodes.UNEXPECTED_ERROR,\n            type: isResponse ? 'binary-response-method-Deserialization-error' : 'binary-request-method-Deserialization-error',\n            publicMessage: `Failed to deserialize method ${key} from binary`,\n            originalError: e,\n            errorData: {methodId: key},\n        });\n    }\n}\n"],"names":["createDataViewDeserializer","routesCache","RpcError","StatusCodes"],"mappings":";;;;;;AAYO,SAAS,sBACZ,MACA,QAEA,YAIF;AACE,MAAI;AAEA,UAAM,eAAeA,oBAAAA,2BAA2B,MAAM,MAAM;AAC5D,UAAM,OAA4B,CAAA;AAGlC,UAAM,cAAc,aAAa,KAAK,UAAU,GAAG,IAAI;AACvD,iBAAa,SAAS;AAGtB,aAAS,IAAI,GAAG,IAAI,aAAa,KAAK;AAElC,YAAM,MAAM,aAAa,UAAA;AAGzB,YAAM,SAASC,gBAAAA,YAAY,gBAAgB,GAAG;AAC9C,UAAI,CAAC,QAAQ;AACT,cAAM,IAAIC,WAAAA,SAAS;AAAA,UACf,YAAYC,cAAAA,YAAY;AAAA,UACxB,MAAM,aACA,iDACA;AAAA,UACN,eAAe,sCAAsC,GAAG;AAAA,UACxD,WAAW,EAAC,UAAU,IAAA;AAAA,QAAG,CAC5B;AAAA,MACL;AAGA,YAAM,QAAQ,kBAAkB,KAAK,QAAQ,cAAc,UAAU;AACrE,WAAK,GAAG,IAAI;AAAA,IAChB;AAEA,iBAAa,YAAA;AACb,WAAO,EAAC,cAAc,KAAA;AAAA,EAC1B,SAAS,KAAU;AACf,QAAI,eAAeD,WAAAA,SAAU,OAAM;AACnC,UAAM,IAAIA,WAAAA,SAAS;AAAA,MACf,YAAYC,cAAAA,YAAY;AAAA,MACxB,MAAM,aAAa,sCAAsC;AAAA,MACzD,eAAe,2CAA2C,KAAK,WAAW,eAAe;AAAA,MACzF,eAAe;AAAA,IAAA,CAClB;AAAA,EACL;AACJ;AAGA,SAAS,kBAAkB,KAAa,QAA0B,cAAoC,YAA0B;AAC5H,QAAM,SAAS,aAAa,OAAO,eAAe,OAAO;AACzD,MAAI,CAAC,OAAO,YAAY;AACpB,UAAM,IAAID,WAAAA,SAAS;AAAA,MACf,MAAM;AAAA,MACN,eAAe,8CAA8C,GAAG;AAAA,IAAA,CACnE;AACL,MAAI;AACA,WAAO,OAAO,WAAW,GAAG,QAAW,YAAY;AAAA,EACvD,SAAS,GAAQ;AACb,UAAM,IAAIA,WAAAA,SAAS;AAAA,MACf,YAAYC,cAAAA,YAAY;AAAA,MACxB,MAAM,aAAa,iDAAiD;AAAA,MACpE,eAAe,gCAAgC,GAAG;AAAA,MAClD,eAAe;AAAA,MACf,WAAW,EAAC,UAAU,IAAA;AAAA,IAAG,CAC5B;AAAA,EACL;AACJ;;"}

package/.dist/cjs/src/binary/bodySerializer.cjs

@@ -32,12 +32,7 @@ function serializeBinaryBody(path, executionChain, body, isResponse, workflowRou
 }
 function serializeMethod(key, method, value, serializer, isResponse) {
   const toBinary = isResponse ? method.returnJitFns.toBinary : method.paramsJitFns.toBinary;
-  if (!toBinary?.fn)
-    throw new src_errors.RpcError({
-      type: "missing-toBinary-jit-fn",
-      publicMessage: `Missing toBinary JIT function for method ${method.id}`
-    });
-  if (toBinary.isNoop) return false;
+  if (!toBinary?.fn || toBinary.isNoop) return false;
   if (key === src_constants.MION_ROUTES.thrownErrors) return false;
   if (isResponse && (!method.hasReturnData || typeof value === "undefined")) return false;
   if (!isResponse && typeof value === "undefined") return false;

package/.dist/cjs/src/binary/bodySerializer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"bodySerializer.cjs","sources":["../../../../src/binary/bodySerializer.ts"],"sourcesContent":["import {createDataViewSerializer} from './dataView.ts';\nimport {MION_ROUTES, StatusCodes} from '../constants.ts';\nimport {RpcError} from '../errors.ts';\nimport type {DataViewSerializer} from '../types/general.types.ts';\nimport type {MethodWithJitFns} from '../types/method.types.ts';\n\n/**\n * Serializes API body to binary format using JIT-compiled serialization functions.\n * Combines the results of all body methods into a single binary buffer.\n *\n * Note: This function assumes all methods in executionChain have valid JIT functions.\n * Methods with noop JIT functions or undefined values should be filtered out before calling this function,\n * or handled by the caller. Any serialization errors will be thrown as RpcError.\n *\n */\nexport function serializeBinaryBody(\n    path: string,\n    executionChain: MethodWithJitFns[],\n    body: Record<string, any>,\n    isResponse: boolean,\n    workflowRouteIds?: string[]\n): {\n    serializer: DataViewSerializer;\n    buffer: ReturnType<DataViewSerializer['getBuffer']>;\n} {\n    try {\n        const serializer = createDataViewSerializer(path, workflowRouteIds);\n\n        // Reserve space for items length at index 0 (will be written after counting)\n        const itemsLengthIndex = serializer.index;\n        serializer.index += 4;\n\n        let itemsLength = 0;\n        // serialize each method's value (return value for responses, params for requests)\n        for (let i = 0; i < executionChain.length; i++) {\n            const method = executionChain[i];\n            const key = method.id;\n            const value = body[key];\n            if (serializeMethod(key, method, value, serializer, isResponse)) {\n                itemsLength++;\n            }\n        }\n        // Write items length at reserved index 0\n        serializer.view.setUint32(itemsLengthIndex, itemsLength, true);\n        serializer.markAsEnded();\n\n        return {serializer, buffer: serializer.getBuffer()};\n    } catch (err: any) {\n        if (err instanceof RpcError) throw err;\n        throw new RpcError({\n            statusCode: StatusCodes.UNEXPECTED_ERROR,\n            type: isResponse ? 'binary-response-Serialization-error' : 'binary-request-Serialization-error',\n            publicMessage: `Failed to serialize body to binary: ${err?.message || 'unknown error'}`,\n            originalError: err,\n        });\n    }\n}\n\n/**\n * Serializes a single method's value to binary format.\n * Returns true if the method was serialized, false if it was skipped.\n */\nfunction serializeMethod(\n    key: string,\n    method: MethodWithJitFns,\n    value: any,\n    serializer: DataViewSerializer,\n    isResponse: boolean\n): boolean {\n    const toBinary = isResponse ? method.returnJitFns.toBinary : method.paramsJitFns.toBinary;\n    if (!toBinary?.fn)\n        throw new RpcError({\n            type: 'missing-toBinary-jit-fn',\n            publicMessage: `Missing toBinary JIT function for method ${method.id}`,\n        });\n    if (toBinary.isNoop) return false;\n    // skip @thrownErrors - should be handled separately by the caller if needed\n    if (key === MION_ROUTES.thrownErrors) return false;\n    // skip methods without return data or undefined values (for responses)\n    if (isResponse && (!method.hasReturnData || typeof value === 'undefined')) return false;\n    // skip methods with no params (for requests) or noop serialization\n    if (!isResponse && typeof value === 'undefined') return false;\n    // serialize key\n    serializer.serString(key);\n    // serialize value\n    toBinary.fn(value, serializer);\n    return true;\n}\n"],"names":["createDataViewSerializer","RpcError","StatusCodes","MION_ROUTES"],"mappings":";;;;;AAeO,SAAS,oBACZ,MACA,gBACA,MACA,YACA,kBAIF;AACE,MAAI;AACA,UAAM,aAAaA,oBAAAA,yBAAyB,MAAM,gBAAgB;AAGlE,UAAM,mBAAmB,WAAW;AACpC,eAAW,SAAS;AAEpB,QAAI,cAAc;AAElB,aAAS,IAAI,GAAG,IAAI,eAAe,QAAQ,KAAK;AAC5C,YAAM,SAAS,eAAe,CAAC;AAC/B,YAAM,MAAM,OAAO;AACnB,YAAM,QAAQ,KAAK,GAAG;AACtB,UAAI,gBAAgB,KAAK,QAAQ,OAAO,YAAY,UAAU,GAAG;AAC7D;AAAA,MACJ;AAAA,IACJ;AAEA,eAAW,KAAK,UAAU,kBAAkB,aAAa,IAAI;AAC7D,eAAW,YAAA;AAEX,WAAO,EAAC,YAAY,QAAQ,WAAW,YAAU;AAAA,EACrD,SAAS,KAAU;AACf,QAAI,eAAeC,WAAAA,SAAU,OAAM;AACnC,UAAM,IAAIA,WAAAA,SAAS;AAAA,MACf,YAAYC,cAAAA,YAAY;AAAA,MACxB,MAAM,aAAa,wCAAwC;AAAA,MAC3D,eAAe,uCAAuC,KAAK,WAAW,eAAe;AAAA,MACrF,eAAe;AAAA,IAAA,CAClB;AAAA,EACL;AACJ;AAMA,SAAS,gBACL,KACA,QACA,OACA,YACA,YACO;AACP,QAAM,WAAW,aAAa,OAAO,aAAa,WAAW,OAAO,aAAa;AACjF,MAAI,CAAC,UAAU;AACX,UAAM,IAAID,WAAAA,SAAS;AAAA,MACf,MAAM;AAAA,MACN,eAAe,4CAA4C,OAAO,EAAE;AAAA,IAAA,CACvE;AACL,MAAI,SAAS,OAAQ,QAAO;AAE5B,MAAI,QAAQE,cAAAA,YAAY,aAAc,QAAO;AAE7C,MAAI,eAAe,CAAC,OAAO,iBAAiB,OAAO,UAAU,aAAc,QAAO;AAElF,MAAI,CAAC,cAAc,OAAO,UAAU,YAAa,QAAO;AAExD,aAAW,UAAU,GAAG;AAExB,WAAS,GAAG,OAAO,UAAU;AAC7B,SAAO;AACX;;"}
+{"version":3,"file":"bodySerializer.cjs","sources":["../../../../src/binary/bodySerializer.ts"],"sourcesContent":["import {createDataViewSerializer} from './dataView.ts';\nimport {MION_ROUTES, StatusCodes} from '../constants.ts';\nimport {RpcError} from '../errors.ts';\nimport type {DataViewSerializer} from '../types/general.types.ts';\nimport type {MethodWithJitFns} from '../types/method.types.ts';\n\n/**\n * Serializes API body to binary format using JIT-compiled serialization functions.\n * Combines the results of all body methods into a single binary buffer.\n *\n * Note: This function assumes all methods in executionChain have valid JIT functions.\n * Methods with noop JIT functions or undefined values should be filtered out before calling this function,\n * or handled by the caller. Any serialization errors will be thrown as RpcError.\n *\n */\nexport function serializeBinaryBody(\n    path: string,\n    executionChain: MethodWithJitFns[],\n    body: Record<string, any>,\n    isResponse: boolean,\n    workflowRouteIds?: string[]\n): {\n    serializer: DataViewSerializer;\n    buffer: ReturnType<DataViewSerializer['getBuffer']>;\n} {\n    try {\n        const serializer = createDataViewSerializer(path, workflowRouteIds);\n\n        // Reserve space for items length at index 0 (will be written after counting)\n        const itemsLengthIndex = serializer.index;\n        serializer.index += 4;\n\n        let itemsLength = 0;\n        // serialize each method's value (return value for responses, params for requests)\n        for (let i = 0; i < executionChain.length; i++) {\n            const method = executionChain[i];\n            const key = method.id;\n            const value = body[key];\n            if (serializeMethod(key, method, value, serializer, isResponse)) {\n                itemsLength++;\n            }\n        }\n        // Write items length at reserved index 0\n        serializer.view.setUint32(itemsLengthIndex, itemsLength, true);\n        serializer.markAsEnded();\n\n        return {serializer, buffer: serializer.getBuffer()};\n    } catch (err: any) {\n        if (err instanceof RpcError) throw err;\n        throw new RpcError({\n            statusCode: StatusCodes.UNEXPECTED_ERROR,\n            type: isResponse ? 'binary-response-Serialization-error' : 'binary-request-Serialization-error',\n            publicMessage: `Failed to serialize body to binary: ${err?.message || 'unknown error'}`,\n            originalError: err,\n        });\n    }\n}\n\n/**\n * Serializes a single method's value to binary format.\n * Returns true if the method was serialized, false if it was skipped.\n */\nfunction serializeMethod(\n    key: string,\n    method: MethodWithJitFns,\n    value: any,\n    serializer: DataViewSerializer,\n    isResponse: boolean\n): boolean {\n    const toBinary = isResponse ? method.returnJitFns.toBinary : method.paramsJitFns.toBinary;\n    if (!toBinary?.fn || toBinary.isNoop) return false;\n    // skip @thrownErrors - should be handled separately by the caller if needed\n    if (key === MION_ROUTES.thrownErrors) return false;\n    // skip methods without return data or undefined values (for responses)\n    if (isResponse && (!method.hasReturnData || typeof value === 'undefined')) return false;\n    // skip methods with no params (for requests) or noop serialization\n    if (!isResponse && typeof value === 'undefined') return false;\n    // serialize key\n    serializer.serString(key);\n    // serialize value\n    toBinary.fn(value, serializer);\n    return true;\n}\n"],"names":["createDataViewSerializer","RpcError","StatusCodes","MION_ROUTES"],"mappings":";;;;;AAeO,SAAS,oBACZ,MACA,gBACA,MACA,YACA,kBAIF;AACE,MAAI;AACA,UAAM,aAAaA,oBAAAA,yBAAyB,MAAM,gBAAgB;AAGlE,UAAM,mBAAmB,WAAW;AACpC,eAAW,SAAS;AAEpB,QAAI,cAAc;AAElB,aAAS,IAAI,GAAG,IAAI,eAAe,QAAQ,KAAK;AAC5C,YAAM,SAAS,eAAe,CAAC;AAC/B,YAAM,MAAM,OAAO;AACnB,YAAM,QAAQ,KAAK,GAAG;AACtB,UAAI,gBAAgB,KAAK,QAAQ,OAAO,YAAY,UAAU,GAAG;AAC7D;AAAA,MACJ;AAAA,IACJ;AAEA,eAAW,KAAK,UAAU,kBAAkB,aAAa,IAAI;AAC7D,eAAW,YAAA;AAEX,WAAO,EAAC,YAAY,QAAQ,WAAW,YAAU;AAAA,EACrD,SAAS,KAAU;AACf,QAAI,eAAeC,WAAAA,SAAU,OAAM;AACnC,UAAM,IAAIA,WAAAA,SAAS;AAAA,MACf,YAAYC,cAAAA,YAAY;AAAA,MACxB,MAAM,aAAa,wCAAwC;AAAA,MAC3D,eAAe,uCAAuC,KAAK,WAAW,eAAe;AAAA,MACrF,eAAe;AAAA,IAAA,CAClB;AAAA,EACL;AACJ;AAMA,SAAS,gBACL,KACA,QACA,OACA,YACA,YACO;AACP,QAAM,WAAW,aAAa,OAAO,aAAa,WAAW,OAAO,aAAa;AACjF,MAAI,CAAC,UAAU,MAAM,SAAS,OAAQ,QAAO;AAE7C,MAAI,QAAQC,cAAAA,YAAY,aAAc,QAAO;AAE7C,MAAI,eAAe,CAAC,OAAO,iBAAiB,OAAO,UAAU,aAAc,QAAO;AAElF,MAAI,CAAC,cAAc,OAAO,UAAU,YAAa,QAAO;AAExD,aAAW,UAAU,GAAG;AAExB,WAAS,GAAG,OAAO,UAAU;AAC7B,SAAO;AACX;;"}

package/.dist/cjs/src/constants.cjs

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const DEFAULT_CORE_OPTIONS = {
   /** automatically generate and uuid */
-  autoGenerateErrorId: false
+  autoGenerateErrorId: false,
+  basePath: "",
+  suffix: ""
 };
 const PATH_SEPARATOR = "/";
 const ROUTE_PATH_ROOT = PATH_SEPARATOR;
@@ -12,8 +14,8 @@ const MAX_STACK_DEPTH = 50;
 const MION_ROUTES = {
   /** get remote methods metadata by method id */
   methodsMetadataById: "mion@methodsMetadataById",
-  /** get remote methods metadata by route path, this include all middleFns in the ExecutionChain of the route. */
-  methodsMetadataByPath: "mion@methodsMetadataByPath",
+  /** Middleware that returns methods metadata alongside any route response */
+  methodsMetadata: "mion@methodsMetadata",
   /** Platform or adapters errors that occur before reaching the router or outside the router and are platform/adapter related */
   platformError: "mion@platformError",
   /** not-found route. This route is called when a requested route doesn't exist */

package/.dist/cjs/src/constants.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"constants.cjs","sources":["../../../src/constants.ts"],"sourcesContent":["/* ########\n * 2022 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {CoreRouterOptions} from './types/general.types.ts';\n\nexport const DEFAULT_CORE_OPTIONS: CoreRouterOptions = {\n    /** automatically generate and uuid */\n    autoGenerateErrorId: false,\n};\n\nexport const PATH_SEPARATOR = '/';\nexport const ROUTE_PATH_ROOT = PATH_SEPARATOR;\nexport const ROUTER_ITEM_SEPARATOR_CHAR = '/';\nexport const MAX_UNKNOWN_KEYS = 10;\nexport const MAX_STACK_DEPTH = 50;\n\n/**\n * Mion internal routes.\n */\nexport const MION_ROUTES = {\n    /** get remote methods metadata by method id */\n    methodsMetadataById: 'mion@methodsMetadataById',\n    /** get remote methods metadata by route path, this include all middleFns in the ExecutionChain of the route. */\n    methodsMetadataByPath: 'mion@methodsMetadataByPath',\n    /** Platform or adapters errors that occur before reaching the router or outside the router and are platform/adapter related */\n    platformError: 'mion@platformError',\n    /** not-found route. This route is called when a requested route doesn't exist */\n    notFound: 'mion@notFound',\n    /**\n     * !IMPORTANT!!\n     * This is technically not a route, but a special key used to store unexpected errors in the response body.\n     * is declared as a route to reuse existing router serialization/deserialization logic.\n     * Errors thrown by routes/middleFns, these are not strongly typed\n     * */\n    thrownErrors: '@thrownErrors',\n} as const;\n\n/**\n * Mime types used by mion.\n * Only json and binary are supported out of the box.\n */\nexport const MIME_TYPES = {\n    json: 'application/json',\n    octetStream: 'application/octet-stream',\n} as const;\n\n/**\n * Standard HTTP status codes used by mion.\n * Status codes are a bit irrelevant in mion apps, the important part is the error type, that is a human readable code.\n * They are used mostly for backwards compatibility with HTTP.\n */\nexport const StatusCodes = {\n    /** Any error in the server that is not related to the application, ie: server not ready, etc... */\n    SERVER_ERROR: 500,\n    /** Any expected and strongly typed error returned by a route/middleFn. ie: entity not found, etc. */\n    APPLICATION_ERROR: 400,\n    /**  Any thrown or unexpected error in the application, ie: validation error, not found, etc, database error, serialization error, etc...\n     * These are are typically irrecoverable and can be handled globally, ie redirect to login page if auth fails\n     */\n    UNEXPECTED_ERROR: 422,\n    /** Not found error */\n    NOT_FOUND: 404,\n    /** Standard success code */\n    OK: 200,\n} as const;\n\nexport const HandlerType = {\n    route: 1,\n    middleFn: 2,\n    headersMiddleFn: 3,\n    rawMiddleFn: 4,\n} as const;\n\nexport const JIT_FUNCTION_IDS = {\n    isType: 'is',\n    typeErrors: 'te',\n    prepareForJson: 'tj',\n    restoreFromJson: 'fj',\n    stringifyJson: 'sj',\n    toJSCode: 'tc',\n    toBinary: 'tBi',\n    fromBinary: 'fBi',\n    format: 'fmt',\n    unknownKeyErrors: 'uk',\n    hasUnknownKeys: 'hk',\n    stripUnknownKeys: 'sk',\n    unknownKeysToUndefined: 'ku',\n    aux: 'aux',\n    mock: 'mock',\n    pureFunction: 'pf',\n} as const;\n\n/** Empty hash used when no params exist or return type is void (no JIT functions generated) */\nexport const EMPTY_HASH = '';\n"],"names":[],"mappings":";;AASO,MAAM,uBAA0C;AAAA;AAAA,EAEnD,qBAAqB;;AAGlB,MAAM,iBAAiB;AACvB,MAAM,kBAAkB;AACxB,MAAM,6BAA6B;AACnC,MAAM,mBAAmB;AACzB,MAAM,kBAAkB;AAKxB,MAAM,cAAc;AAAA;AAAA,EAEvB,qBAAqB;AAAA;AAAA,EAErB,uBAAuB;AAAA;AAAA,EAEvB,eAAe;AAAA;AAAA,EAEf,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOV,cAAc;;AAOX,MAAM,aAAa;AAAA,EACtB,MAAM;AAAA,EACN,aAAa;;AAQV,MAAM,cAAc;AAAA;AAAA,EAEvB,cAAc;AAAA;AAAA,EAEd,mBAAmB;AAAA;AAAA;AAAA;AAAA,EAInB,kBAAkB;AAAA;AAAA,EAElB,WAAW;AAAA;AAAA,EAEX,IAAI;;AAGD,MAAM,cAAc;AAAA,EACvB,OAAO;AAAA,EACP,UAAU;AAAA,EACV,iBAAiB;AAAA,EACjB,aAAa;;AAGV,MAAM,mBAAmB;AAAA,EAC5B,QAAQ;AAAA,EACR,YAAY;AAAA,EACZ,gBAAgB;AAAA,EAChB,iBAAiB;AAAA,EACjB,eAAe;AAAA,EACf,UAAU;AAAA,EACV,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,QAAQ;AAAA,EACR,kBAAkB;AAAA,EAClB,gBAAgB;AAAA,EAChB,kBAAkB;AAAA,EAClB,wBAAwB;AAAA,EACxB,KAAK;AAAA,EACL,MAAM;AAAA,EACN,cAAc;;AAIX,MAAM,aAAa;;;;;;;;;;;;;"}
+{"version":3,"file":"constants.cjs","sources":["../../../src/constants.ts"],"sourcesContent":["/* ########\n * 2022 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {CoreRouterOptions} from './types/general.types.ts';\n\nexport const DEFAULT_CORE_OPTIONS: CoreRouterOptions = {\n    /** automatically generate and uuid */\n    autoGenerateErrorId: false,\n    basePath: '',\n    suffix: '',\n};\n\nexport const PATH_SEPARATOR = '/';\nexport const ROUTE_PATH_ROOT = PATH_SEPARATOR;\nexport const ROUTER_ITEM_SEPARATOR_CHAR = '/';\nexport const MAX_UNKNOWN_KEYS = 10;\nexport const MAX_STACK_DEPTH = 50;\n\n/**\n * Mion internal routes.\n */\nexport const MION_ROUTES = {\n    /** get remote methods metadata by method id */\n    methodsMetadataById: 'mion@methodsMetadataById',\n    /** Middleware that returns methods metadata alongside any route response */\n    methodsMetadata: 'mion@methodsMetadata',\n    /** Platform or adapters errors that occur before reaching the router or outside the router and are platform/adapter related */\n    platformError: 'mion@platformError',\n    /** not-found route. This route is called when a requested route doesn't exist */\n    notFound: 'mion@notFound',\n    /**\n     * !IMPORTANT!!\n     * This is technically not a route, but a special key used to store unexpected errors in the response body.\n     * is declared as a route to reuse existing router serialization/deserialization logic.\n     * Errors thrown by routes/middleFns, these are not strongly typed\n     * */\n    thrownErrors: '@thrownErrors',\n} as const;\n\n/**\n * Mime types used by mion.\n * Only json and binary are supported out of the box.\n */\nexport const MIME_TYPES = {\n    json: 'application/json',\n    octetStream: 'application/octet-stream',\n} as const;\n\n/**\n * Standard HTTP status codes used by mion.\n * Status codes are a bit irrelevant in mion apps, the important part is the error type, that is a human readable code.\n * They are used mostly for backwards compatibility with HTTP.\n */\nexport const StatusCodes = {\n    /** Any error in the server that is not related to the application, ie: server not ready, etc... */\n    SERVER_ERROR: 500,\n    /** Any expected and strongly typed error returned by a route/middleFn. ie: entity not found, etc. */\n    APPLICATION_ERROR: 400,\n    /**  Any thrown or unexpected error in the application, ie: validation error, not found, etc, database error, serialization error, etc...\n     * These are are typically irrecoverable and can be handled globally, ie redirect to login page if auth fails\n     */\n    UNEXPECTED_ERROR: 422,\n    /** Not found error */\n    NOT_FOUND: 404,\n    /** Standard success code */\n    OK: 200,\n} as const;\n\nexport const HandlerType = {\n    route: 1,\n    middleFn: 2,\n    headersMiddleFn: 3,\n    rawMiddleFn: 4,\n} as const;\n\nexport const JIT_FUNCTION_IDS = {\n    isType: 'is',\n    typeErrors: 'te',\n    prepareForJson: 'tj',\n    restoreFromJson: 'fj',\n    stringifyJson: 'sj',\n    toJSCode: 'tc',\n    toBinary: 'tBi',\n    fromBinary: 'fBi',\n    format: 'fmt',\n    unknownKeyErrors: 'uk',\n    hasUnknownKeys: 'hk',\n    stripUnknownKeys: 'sk',\n    unknownKeysToUndefined: 'ku',\n    aux: 'aux',\n    mock: 'mock',\n    pureFunction: 'pf',\n} as const;\n\n/** Empty hash used when no params exist or return type is void (no JIT functions generated) */\nexport const EMPTY_HASH = '';\n"],"names":[],"mappings":";;AASO,MAAM,uBAA0C;AAAA;AAAA,EAEnD,qBAAqB;AAAA,EACrB,UAAU;AAAA,EACV,QAAQ;;AAGL,MAAM,iBAAiB;AACvB,MAAM,kBAAkB;AACxB,MAAM,6BAA6B;AACnC,MAAM,mBAAmB;AACzB,MAAM,kBAAkB;AAKxB,MAAM,cAAc;AAAA;AAAA,EAEvB,qBAAqB;AAAA;AAAA,EAErB,iBAAiB;AAAA;AAAA,EAEjB,eAAe;AAAA;AAAA,EAEf,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOV,cAAc;;AAOX,MAAM,aAAa;AAAA,EACtB,MAAM;AAAA,EACN,aAAa;;AAQV,MAAM,cAAc;AAAA;AAAA,EAEvB,cAAc;AAAA;AAAA,EAEd,mBAAmB;AAAA;AAAA;AAAA;AAAA,EAInB,kBAAkB;AAAA;AAAA,EAElB,WAAW;AAAA;AAAA,EAEX,IAAI;;AAGD,MAAM,cAAc;AAAA,EACvB,OAAO;AAAA,EACP,UAAU;AAAA,EACV,iBAAiB;AAAA,EACjB,aAAa;;AAGV,MAAM,mBAAmB;AAAA,EAC5B,QAAQ;AAAA,EACR,YAAY;AAAA,EACZ,gBAAgB;AAAA,EAChB,iBAAiB;AAAA,EACjB,eAAe;AAAA,EACf,UAAU;AAAA,EACV,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,QAAQ;AAAA,EACR,kBAAkB;AAAA,EAClB,gBAAgB;AAAA,EAChB,kBAAkB;AAAA,EAClB,wBAAwB;AAAA,EACxB,KAAK;AAAA,EACL,MAAM;AAAA,EACN,cAAc;;AAIX,MAAM,aAAa;;;;;;;;;;;;;"}

package/.dist/cjs/src/constants.d.ts

@@ -7,7 +7,7 @@ export declare const MAX_UNKNOWN_KEYS = 10;
 export declare const MAX_STACK_DEPTH = 50;
 export declare const MION_ROUTES: {
     readonly methodsMetadataById: "mion@methodsMetadataById";
-    readonly methodsMetadataByPath: "mion@methodsMetadataByPath";
+    readonly methodsMetadata: "mion@methodsMetadata";
     readonly platformError: "mion@platformError";
     readonly notFound: "mion@notFound";
     readonly thrownErrors: "@thrownErrors";

package/.dist/cjs/src/pureFns/pureFn.cjs

@@ -19,8 +19,7 @@ function registerPureFnFactory(namespace, functionID, createPureFn, parsedFn) {
     fnName: functionID,
     bodyHash: parsedFn.bodyHash,
     paramNames: parsedFn.paramNames,
-    code: parsedFn.code,
-    pureFnDependencies: []
+    code: parsedFn.code
   };
   const { proxy, getDependencies } = createDependencyTrackingProxy();
   try {
@@ -31,8 +30,11 @@ function registerPureFnFactory(namespace, functionID, createPureFn, parsedFn) {
   for (const dep of detectedDeps) {
     if (dep === functionID)
       continue;
-    if (!compiled.pureFnDependencies.includes(dep))
-      compiled.pureFnDependencies.push(dep);
+    if (compiled.pureFnDependencies?.includes(dep))
+      continue;
+    if (!compiled.pureFnDependencies)
+      compiled.pureFnDependencies = [];
+    compiled.pureFnDependencies.push(dep);
   }
   src_jit_jitUtils.getJitUtils().addPureFn(namespace, compiled);
   return compiled;

package/.dist/cjs/src/pureFns/pureFn.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"pureFn.cjs","sources":["../../../../src/pureFns/pureFn.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\nimport type {CompiledPureFunction, ParsedFactoryFn, PureFunctionFactory} from '../types/pureFunctions.types.ts';\nimport {getJitUtils, type JITUtils} from '../jit/jitUtils.ts';\n\n// ╔══════════════════════════════════════════════════════════════════════════════╗\n// ║  WARNING: This function's call signature is parsed by the mion vite plugin  ║\n// ║  at build time (see devtools/src/vite-plugin/extractPureFn.ts).             ║\n// ║  Do NOT rename, change the parameter order, or modify the function          ║\n// ║  signature without updating the corresponding AST extraction and            ║\n// ║  transformer logic in @mionjs/devtools.                                    ║\n// ╚══════════════════════════════════════════════════════════════════════════════╝\n\n/**\n * Registers a pure function factory with automatic dependency tracking.\n * The `parsedFn` argument (containing bodyHash, paramNames, and code) is injected\n * at build time by the mion vite plugin's transform hook — it must never be passed manually.\n * If the function is already registered under the same namespace + functionID, the existing\n * compiled entry is returned (idempotent). Dependencies on other pure functions are\n * auto-detected by running the factory once with a tracking proxy.\n *\n * This is intended to share util functions between server and clients\n */\nexport function registerPureFnFactory(\n    namespace: string,\n    functionID: string,\n    createPureFn: PureFunctionFactory,\n    parsedFn?: ParsedFactoryFn // injected by mion vite plugin\n): CompiledPureFunction {\n    if (!parsedFn) throw new Error('registerPureFnFactory requires mion vite plugin transform to inject parsedFn');\n    const existing = getJitUtils().getCompiledPureFn(namespace, functionID);\n    if (existing) return existing;\n\n    const compiled: CompiledPureFunction = {\n        createPureFn,\n        fn: null as any, // will be set later so all possible dependencies are resolved\n        namespace,\n        fnName: functionID,\n        bodyHash: parsedFn.bodyHash,\n        paramNames: parsedFn.paramNames,\n        code: parsedFn.code,\n        pureFnDependencies: [],\n    };\n\n    // Run the factory once with a tracking proxy to auto-detect dependencies\n    const {proxy, getDependencies} = createDependencyTrackingProxy();\n    try {\n        createPureFn(proxy);\n    } catch {\n        // Factory may fail if dependencies aren't registered yet, that's ok\n        // We still capture whatever was accessed before the error\n    }\n    const detectedDeps = getDependencies();\n    for (const dep of detectedDeps) {\n        if (dep === functionID) continue;\n        if (!compiled.pureFnDependencies.includes(dep)) compiled.pureFnDependencies.push(dep);\n    }\n\n    getJitUtils().addPureFn(namespace, compiled);\n    return compiled;\n}\n\n/** Creates a proxy of jitUtils that records all pure function accesses (getPureFn, usePureFn, etc.) */\nfunction createDependencyTrackingProxy(): {proxy: JITUtils; getDependencies: () => Set<string>} {\n    const dependencies = new Set<string>();\n    const realUtils = getJitUtils();\n\n    const noopFn = () => () => {};\n\n    const proxy = new Proxy(realUtils, {\n        get(target, prop, receiver) {\n            if (prop === 'getPureFn' || prop === 'usePureFn') {\n                return (ns: string, fnName: string) => {\n                    dependencies.add(fnName);\n                    // Return a noop function so the factory can execute without errors\n                    const real = target.getPureFn(ns, fnName);\n                    return real ?? noopFn;\n                };\n            }\n            if (prop === 'getCompiledPureFn') {\n                return (ns: string, fnName: string) => {\n                    dependencies.add(fnName);\n                    return target.getCompiledPureFn(ns, fnName);\n                };\n            }\n            if (prop === 'hasPureFn') {\n                return (ns: string, fnName: string) => {\n                    dependencies.add(fnName);\n                    return target.hasPureFn(ns, fnName);\n                };\n            }\n            if (prop === 'findCompiledPureFn') {\n                return (fnName: string) => {\n                    dependencies.add(fnName);\n                    return target.findCompiledPureFn(fnName);\n                };\n            }\n            return Reflect.get(target, prop, receiver);\n        },\n    });\n\n    return {proxy, getDependencies: () => dependencies};\n}\n"],"names":["getJitUtils"],"mappings":";;;;;;;AA4BM,SAAU,sBACZ,WACA,YACA,cACA;AAEA,MAAI,CAAC;AAAU,UAAM,IAAI,MAAM,8EAA8E;AAC7G,QAAM,WAAWA,iBAAAA,YAAA,EAAc,kBAAkB,WAAW,UAAU;AACtE,MAAI;AAAU,WAAO;AAErB,QAAM,WAAiC;AAAA,IACnC;AAAA,IACA,IAAI;AAAA;AAAA,IACJ;AAAA,IACA,QAAQ;AAAA,IACR,UAAU,SAAS;AAAA,IACnB,YAAY,SAAS;AAAA,IACrB,MAAM,SAAS;AAAA,IACf,oBAAoB,CAAA;AAAA,EAAA;AAIxB,QAAM,EAAC,OAAO,gBAAA,IAAmB,8BAAA;AACjC,MAAI;AACA,iBAAa,KAAK;AAAA,EACtB,QAAQ;AAAA,EAGR;AACA,QAAM,eAAe,gBAAA;AACrB,aAAW,OAAO,cAAc;AAC5B,QAAI,QAAQ;AAAY;AACxB,QAAI,CAAC,SAAS,mBAAmB,SAAS,GAAG;AAAG,eAAS,mBAAmB,KAAK,GAAG;AAAA,EACxF;AAEAA,mBAAAA,cAAc,UAAU,WAAW,QAAQ;AAC3C,SAAO;AACX;;AAGA,SAAS,gCAA6B;AAClC,QAAM,gBAAmB,IAAG,IAAA,CAAA,CAAA,GAAA,CAAA,GAAP,oBAAI;AACzB,QAAM,YAAYA,iBAAAA,YAAA;AAElB,QAAM,SAAS,MAAM,MAAK;AAAA,EAAE;AAE5B,QAAM,QAAQ,IAAI,MAAM,WAAW;AAAA,IAC/B,IAAI,QAAQ,MAAM,UAAQ;AACtB,UAAI,SAAS,eAAe,SAAS,aAAa;AAC9C,eAAA,aAAO,CAAC,IAAY,WAAkB;AAClC,uBAAa,IAAI,MAAM;AAEvB,gBAAM,OAAO,OAAO,UAAU,IAAI,MAAM;AACxC,iBAAO,QAAQ;AAAA,QACnB,GAAC,CAAA,MAAA,UAAA,IAAA,YAAA,CAAA;AAAA,MACL;AACA,UAAI,SAAS,qBAAqB;AAC9B,eAAA,aAAO,CAAC,IAAY,WAAkB;AAClC,uBAAa,IAAI,MAAM;AACvB,iBAAO,OAAO,kBAAkB,IAAI,MAAM;AAAA,QAC9C,GAAC,CAAA,MAAA,UAAA,IAAA,YAAA,CAAA;AAAA,MACL;AACA,UAAI,SAAS,aAAa;AACtB,eAAA,aAAO,CAAC,IAAY,WAAkB;AAClC,uBAAa,IAAI,MAAM;AACvB,iBAAO,OAAO,UAAU,IAAI,MAAM;AAAA,QACtC,GAAC,CAAA,MAAA,UAAA,IAAA,YAAA,CAAA;AAAA,MACL;AACA,UAAI,SAAS,sBAAsB;AAC/B,eAAA,aAAO,CAAC,WAAkB;AACtB,uBAAa,IAAI,MAAM;AACvB,iBAAO,OAAO,mBAAmB,MAAM;AAAA,QAC3C,GAAC,CAAA,UAAA,IAAA,SAAA,CAAA;AAAA,MACL;AACA,aAAO,QAAQ,IAAI,QAAQ,MAAM,QAAQ;AAAA,IAC7C;AAAA,EAAA,CACH;AAED,SAAO,EAAC,OAAO,iBAAiB,MAAM,aAAA;AAC1C;;;"}
+{"version":3,"file":"pureFn.cjs","sources":["../../../../src/pureFns/pureFn.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\nimport type {CompiledPureFunction, ParsedFactoryFn, PureFunctionFactory} from '../types/pureFunctions.types.ts';\nimport {getJitUtils, type JITUtils} from '../jit/jitUtils.ts';\n\n// ╔══════════════════════════════════════════════════════════════════════════════╗\n// ║  WARNING: This function's call signature is parsed by the mion vite plugin  ║\n// ║  at build time (see devtools/src/vite-plugin/extractPureFn.ts).             ║\n// ║  Do NOT rename, change the parameter order, or modify the function          ║\n// ║  signature without updating the corresponding AST extraction and            ║\n// ║  transformer logic in @mionjs/devtools.                                    ║\n// ╚══════════════════════════════════════════════════════════════════════════════╝\n\n/**\n * Registers a pure function factory with automatic dependency tracking.\n * The `parsedFn` argument (containing bodyHash, paramNames, and code) is injected\n * at build time by the mion vite plugin's transform hook — it must never be passed manually.\n * If the function is already registered under the same namespace + functionID, the existing\n * compiled entry is returned (idempotent). Dependencies on other pure functions are\n * auto-detected by running the factory once with a tracking proxy.\n *\n * This is intended to share util functions between server and clients\n */\nexport function registerPureFnFactory(\n    namespace: string,\n    functionID: string,\n    createPureFn: PureFunctionFactory,\n    parsedFn?: ParsedFactoryFn // injected by mion vite plugin\n): CompiledPureFunction {\n    if (!parsedFn) throw new Error('registerPureFnFactory requires mion vite plugin transform to inject parsedFn');\n    const existing = getJitUtils().getCompiledPureFn(namespace, functionID);\n    if (existing) return existing;\n\n    const compiled: CompiledPureFunction = {\n        createPureFn,\n        fn: null as any, // will be set later so all possible dependencies are resolved\n        namespace,\n        fnName: functionID,\n        bodyHash: parsedFn.bodyHash,\n        paramNames: parsedFn.paramNames,\n        code: parsedFn.code,\n    };\n\n    // Run the factory once with a tracking proxy to auto-detect dependencies\n    const {proxy, getDependencies} = createDependencyTrackingProxy();\n    try {\n        createPureFn(proxy);\n    } catch {\n        // Factory may fail if dependencies aren't registered yet, that's ok\n        // We still capture whatever was accessed before the error\n    }\n    const detectedDeps = getDependencies();\n    for (const dep of detectedDeps) {\n        if (dep === functionID) continue;\n        if (compiled.pureFnDependencies?.includes(dep)) continue;\n        if (!compiled.pureFnDependencies) (compiled as any).pureFnDependencies = [];\n        compiled.pureFnDependencies!.push(dep);\n    }\n\n    getJitUtils().addPureFn(namespace, compiled);\n    return compiled;\n}\n\n/** Creates a proxy of jitUtils that records all pure function accesses (getPureFn, usePureFn, etc.) */\nfunction createDependencyTrackingProxy(): {proxy: JITUtils; getDependencies: () => Set<string>} {\n    const dependencies = new Set<string>();\n    const realUtils = getJitUtils();\n\n    const noopFn = () => () => {};\n\n    const proxy = new Proxy(realUtils, {\n        get(target, prop, receiver) {\n            if (prop === 'getPureFn' || prop === 'usePureFn') {\n                return (ns: string, fnName: string) => {\n                    dependencies.add(fnName);\n                    // Return a noop function so the factory can execute without errors\n                    const real = target.getPureFn(ns, fnName);\n                    return real ?? noopFn;\n                };\n            }\n            if (prop === 'getCompiledPureFn') {\n                return (ns: string, fnName: string) => {\n                    dependencies.add(fnName);\n                    return target.getCompiledPureFn(ns, fnName);\n                };\n            }\n            if (prop === 'hasPureFn') {\n                return (ns: string, fnName: string) => {\n                    dependencies.add(fnName);\n                    return target.hasPureFn(ns, fnName);\n                };\n            }\n            if (prop === 'findCompiledPureFn') {\n                return (fnName: string) => {\n                    dependencies.add(fnName);\n                    return target.findCompiledPureFn(fnName);\n                };\n            }\n            return Reflect.get(target, prop, receiver);\n        },\n    });\n\n    return {proxy, getDependencies: () => dependencies};\n}\n"],"names":["getJitUtils"],"mappings":";;;;;;;AA4BM,SAAU,sBACZ,WACA,YACA,cACA;AAEA,MAAI,CAAC;AAAU,UAAM,IAAI,MAAM,8EAA8E;AAC7G,QAAM,WAAWA,iBAAAA,YAAA,EAAc,kBAAkB,WAAW,UAAU;AACtE,MAAI;AAAU,WAAO;AAErB,QAAM,WAAiC;AAAA,IACnC;AAAA,IACA,IAAI;AAAA;AAAA,IACJ;AAAA,IACA,QAAQ;AAAA,IACR,UAAU,SAAS;AAAA,IACnB,YAAY,SAAS;AAAA,IACrB,MAAM,SAAS;AAAA,EAAA;AAInB,QAAM,EAAC,OAAO,gBAAA,IAAmB,8BAAA;AACjC,MAAI;AACA,iBAAa,KAAK;AAAA,EACtB,QAAQ;AAAA,EAGR;AACA,QAAM,eAAe,gBAAA;AACrB,aAAW,OAAO,cAAc;AAC5B,QAAI,QAAQ;AAAY;AACxB,QAAI,SAAS,oBAAoB,SAAS,GAAG;AAAG;AAChD,QAAI,CAAC,SAAS;AAAqB,eAAiB,qBAAqB,CAAA;AACzE,aAAS,mBAAoB,KAAK,GAAG;AAAA,EACzC;AAEAA,mBAAAA,cAAc,UAAU,WAAW,QAAQ;AAC3C,SAAO;AACX;;AAGA,SAAS,gCAA6B;AAClC,QAAM,gBAAmB,IAAG,IAAA,CAAA,CAAA,GAAA,CAAA,GAAP,oBAAI;AACzB,QAAM,YAAYA,iBAAAA,YAAA;AAElB,QAAM,SAAS,MAAM,MAAK;AAAA,EAAE;AAE5B,QAAM,QAAQ,IAAI,MAAM,WAAW;AAAA,IAC/B,IAAI,QAAQ,MAAM,UAAQ;AACtB,UAAI,SAAS,eAAe,SAAS,aAAa;AAC9C,eAAA,aAAO,CAAC,IAAY,WAAkB;AAClC,uBAAa,IAAI,MAAM;AAEvB,gBAAM,OAAO,OAAO,UAAU,IAAI,MAAM;AACxC,iBAAO,QAAQ;AAAA,QACnB,GAAC,CAAA,MAAA,UAAA,IAAA,YAAA,CAAA;AAAA,MACL;AACA,UAAI,SAAS,qBAAqB;AAC9B,eAAA,aAAO,CAAC,IAAY,WAAkB;AAClC,uBAAa,IAAI,MAAM;AACvB,iBAAO,OAAO,kBAAkB,IAAI,MAAM;AAAA,QAC9C,GAAC,CAAA,MAAA,UAAA,IAAA,YAAA,CAAA;AAAA,MACL;AACA,UAAI,SAAS,aAAa;AACtB,eAAA,aAAO,CAAC,IAAY,WAAkB;AAClC,uBAAa,IAAI,MAAM;AACvB,iBAAO,OAAO,UAAU,IAAI,MAAM;AAAA,QACtC,GAAC,CAAA,MAAA,UAAA,IAAA,YAAA,CAAA;AAAA,MACL;AACA,UAAI,SAAS,sBAAsB;AAC/B,eAAA,aAAO,CAAC,WAAkB;AACtB,uBAAa,IAAI,MAAM;AACvB,iBAAO,OAAO,mBAAmB,MAAM;AAAA,QAC3C,GAAC,CAAA,UAAA,IAAA,SAAA,CAAA;AAAA,MACL;AACA,aAAO,QAAQ,IAAI,QAAQ,MAAM,QAAQ;AAAA,IAC7C;AAAA,EAAA,CACH;AAED,SAAO,EAAC,OAAO,iBAAiB,MAAM,aAAA;AAC1C;;;"}

package/.dist/cjs/src/pureFns/restoreJitFns.cjs

@@ -21,7 +21,7 @@ function restoreCompiledPureFn(pureCache, namespace, fnName, jUtil, visited) {
   const pureCompiled = nsCache[fnName];
   if (!pureCompiled) throw new Error(`Pure function ${fnName} not found in namespace ${namespace}`);
   if (pureCompiled.fn) return;
-  const dependencies = pureCompiled.pureFnDependencies;
+  const dependencies = pureCompiled.pureFnDependencies || [];
   dependencies.forEach((depName) => restoreCompiledPureFn(pureCache, namespace, depName, jUtil, visited));
   if (pureCompiled.createPureFn) {
     pureCompiled.fn = pureCompiled.createPureFn(jUtil);
@@ -35,14 +35,14 @@ function restoreCompiledJitFn(jitCache, pureCache, fnHash, jUtil, visitedPure, v
   const jitCompiled = jitCache[fnHash];
   if (!jitCompiled) throw new Error(`Jit function ${fnHash} not found`);
   if (jitCompiled.fn) return;
-  const pureDependencies = jitCompiled.pureFnDependencies;
+  const pureDependencies = jitCompiled.pureFnDependencies || [];
   pureDependencies.forEach((dep) => {
     const parts = dep.split("::");
     if (parts.length !== 2) throw new Error(`Invalid pure function dependency format: ${dep}, expected "namespace::fnHash"`);
     const [namespace, fnHash2] = parts;
     restoreCompiledPureFn(pureCache, namespace, fnHash2, jUtil, visitedPure);
   });
-  const dependencies = jitCompiled.jitDependencies;
+  const dependencies = jitCompiled.jitDependencies || [];
   dependencies.forEach((dep) => restoreCompiledJitFn(jitCache, pureCache, dep, jUtil, visitedPure, visitedJit));
   if (jitCompiled.createJitFn) {
     jitCompiled.fn = jitCompiled.createJitFn(jUtil);

package/.dist/cjs/src/pureFns/restoreJitFns.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"restoreJitFns.cjs","sources":["../../../../src/pureFns/restoreJitFns.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 type {\n    Mutable,\n    JitCompiledFn,\n    PersistedJitFunctionsCache,\n    PersistedPureFunctionsCache,\n    FnsDataCache,\n    PureFnsDataCache,\n    PureFunctionsCache,\n    JitCompiledFnData,\n    PersistedJitFn,\n} from '../types/general.types.ts';\nimport {JITUtils} from '../jit/jitUtils.ts';\nimport type {PersistedPureFunction} from '../types/pureFunctions.types.ts';\nimport type {CompiledPureFunction} from '../types/pureFunctions.types.ts';\nimport type {PureFunctionData} from '../types/pureFunctions.types.ts';\nimport type {PureFunctionFactory} from '../types/pureFunctions.types.ts';\nimport {TypedError} from '../errors.ts';\n\n/**\n * Restores the full state of a persisted/serialized jit functions.\n * This functions mutates the input caches!!!\n * Persisted functions are jit functions written to code that contains the createJitFn closure but not the fn.\n * Serialized functions are jit functions sent over the network that contains the code to recreate the createJitFn closure and fn.\n * The JIT fn itself can't be compiled to code as it contains references to context code and jitUtils.\n * So we need to restore it manually by invoking the closure function.\n * */\nexport function restoreCompiledJitFns(\n    jitCache: PersistedJitFunctionsCache | FnsDataCache,\n    pureCache: PureFunctionsCache | PersistedPureFunctionsCache | PureFnsDataCache,\n    jUtil: JITUtils\n): void {\n    // Use visited sets to prevent infinite recursion on circular dependencies\n    // This is needed because during restoration, the `fn` property is not set until after\n    // all dependencies are restored, so checking `fn` alone can't prevent circular calls\n    const visitedPure = new Set<string>();\n    const visitedJit = new Set<string>();\n\n    // Iterate over all namespaces and restore pure functions\n    for (const namespace in pureCache) {\n        const nsCache = pureCache[namespace];\n        const keysPureFns = Object.keys(nsCache);\n        keysPureFns.forEach((key) => restoreCompiledPureFn(pureCache, namespace, key, jUtil, visitedPure));\n    }\n    const keysJitFns = Object.keys(jitCache);\n    keysJitFns.forEach((key) => restoreCompiledJitFn(jitCache, pureCache, key, jUtil, visitedPure, visitedJit));\n}\n\nfunction restoreCompiledPureFn(\n    pureCache: PureFunctionsCache | PersistedPureFunctionsCache | PureFnsDataCache,\n    namespace: string,\n    fnName: string,\n    jUtil: JITUtils,\n    visited: Set<string>\n) {\n    // Use namespace:fnName as the visited key to handle same function names in different namespaces\n    const visitedKey = `${namespace}:${fnName}`;\n    // Skip if already visited (handles circular dependencies)\n    if (visited.has(visitedKey)) return;\n    visited.add(visitedKey);\n\n    const nsCache = pureCache[namespace];\n    if (!nsCache) throw new Error(`Pure function namespace ${namespace} not found`);\n    const pureCompiled = nsCache[fnName];\n    if (!pureCompiled) throw new Error(`Pure function ${fnName} not found in namespace ${namespace}`);\n    if ((pureCompiled as CompiledPureFunction).fn) return;\n    const dependencies = pureCompiled.pureFnDependencies;\n    // Dependencies are in the same namespace\n    dependencies.forEach((depName) => restoreCompiledPureFn(pureCache, namespace, depName, jUtil, visited));\n    // persisted pure functions (AOT code caches) have the createJitFn but not the fn\n    if ((pureCompiled as PersistedPureFunction).createPureFn) {\n        (pureCompiled as any as Mutable<CompiledPureFunction>).fn = (pureCompiled as PersistedPureFunction).createPureFn(jUtil);\n        return;\n    }\n    // serialized pure functions (network sent) do not contains neither createJitFn nor fn\n    restorePureFunction(pureCompiled, jUtil);\n}\n\nfunction restoreCompiledJitFn(\n    jitCache: PersistedJitFunctionsCache | FnsDataCache,\n    pureCache: PureFunctionsCache | PersistedPureFunctionsCache | PureFnsDataCache,\n    fnHash: string,\n    jUtil: JITUtils,\n    visitedPure: Set<string>,\n    visitedJit: Set<string>\n) {\n    // Skip if already visited (handles circular dependencies)\n    if (visitedJit.has(fnHash)) return;\n    visitedJit.add(fnHash);\n\n    const jitCompiled = jitCache[fnHash];\n    if (!jitCompiled) throw new Error(`Jit function ${fnHash} not found`);\n    if ((jitCompiled as JitCompiledFn).fn) return;\n    const pureDependencies = jitCompiled.pureFnDependencies;\n    // Pure function dependencies are stored as \"namespace::fnHash\"\n    pureDependencies.forEach((dep) => {\n        const parts = dep.split('::');\n        if (parts.length !== 2) throw new Error(`Invalid pure function dependency format: ${dep}, expected \"namespace::fnHash\"`);\n        const [namespace, fnHash] = parts;\n        restoreCompiledPureFn(pureCache, namespace, fnHash, jUtil, visitedPure);\n    });\n    const dependencies = jitCompiled.jitDependencies;\n    dependencies.forEach((dep) => restoreCompiledJitFn(jitCache, pureCache, dep, jUtil, visitedPure, visitedJit));\n    if ((jitCompiled as PersistedJitFn).createJitFn) {\n        (jitCompiled as any as Mutable<JitCompiledFn>).fn = (jitCompiled as PersistedJitFn).createJitFn(jUtil);\n        return;\n    }\n    restoreCreateJitFn(jitCompiled, jUtil);\n}\n\n/**\n * Restores a JIT function from serialized function data.\n * This functionsMutates the input data!!!\n * Creates a dynamic function using the serialized code (which already contains the complete function with context),\n * then executes it with jitUtils to produce the final JIT function.\n * @param fnData - The serialized function data containing code, args, and metadata\n * @returns A JitCompiledFn with both the createJitFn closure and the executed fn\n */\nfunction restoreCreateJitFn(fnData: JitCompiledFnData, jUtil: JITUtils): JitCompiledFn {\n    const fnName = fnData.jitFnHash;\n    // fnData.code already contains the complete function with context (e.g., \"const x = ...; return function fnName(args){...}\")\n    const fnWithContext = `'use strict'; ${fnData.code}`;\n    try {\n        // Create wrapper function that works as a factory and returns the actual jit function\n        const wrapperWithContext = new Function('utl', fnWithContext) as (utl: JITUtils) => (...args: any[]) => any;\n        // Execute the wrapper with jitUtils to get the final function\n        const fn = wrapperWithContext(jUtil);\n        const jitFn = fnData as Mutable<JitCompiledFn>;\n        jitFn.createJitFn = wrapperWithContext;\n        jitFn.fn = fn;\n        return jitFn;\n    } catch (e: any) {\n        throw new TypedError({\n            type: 'jit-fn-restore-error',\n            message: `Failed to restore JIT function ${fnName}: ${e?.message}`,\n        });\n    }\n}\n\n/**\n * Restores a pure function from serialized function data.\n * This function mutates the input data!!!\n * Creates a dynamic function using the serialized code (which already contains the complete function with context),\n * then executes it with jitUtils to produce the final pure function.\n * @param pureFnData - The serialized pure function data containing code and metadata\n * @returns A CompiledPureFunction with both the createJitFn closure and the executed fn\n */\nfunction restorePureFunction(pureFnData: PureFunctionData, jUtil: JITUtils): CompiledPureFunction {\n    const fnName = pureFnData.fnName;\n    // pureFnData.code already contains the complete function with context\n    const fnWithContext = `'use strict'; ${pureFnData.code}`;\n    try {\n        // Create wrapper function that works as a factory and returns the actual pure function\n        const wrapperWithContext = new Function('utl', fnWithContext) as PureFunctionFactory;\n        // Execute the wrapper with jitUtils to get the final function\n        const fn = wrapperWithContext(jUtil);\n        const pureFn = pureFnData as Mutable<CompiledPureFunction>;\n        pureFn.createPureFn = wrapperWithContext;\n        pureFn.fn = fn;\n        return pureFn;\n    } catch (e: any) {\n        throw new TypedError({\n            type: 'pure-fn-restore-error',\n            message: `Failed to restore pure function ${fnName}: ${e?.message}`,\n        });\n    }\n}\n"],"names":["fnHash","TypedError"],"mappings":"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"}
+{"version":3,"file":"restoreJitFns.cjs","sources":["../../../../src/pureFns/restoreJitFns.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 type {\n    Mutable,\n    JitCompiledFn,\n    PersistedJitFunctionsCache,\n    PersistedPureFunctionsCache,\n    FnsDataCache,\n    PureFnsDataCache,\n    PureFunctionsCache,\n    JitCompiledFnData,\n    PersistedJitFn,\n} from '../types/general.types.ts';\nimport {JITUtils} from '../jit/jitUtils.ts';\nimport type {PersistedPureFunction} from '../types/pureFunctions.types.ts';\nimport type {CompiledPureFunction} from '../types/pureFunctions.types.ts';\nimport type {PureFunctionData} from '../types/pureFunctions.types.ts';\nimport type {PureFunctionFactory} from '../types/pureFunctions.types.ts';\nimport {TypedError} from '../errors.ts';\n\n/**\n * Restores the full state of a persisted/serialized jit functions.\n * This functions mutates the input caches!!!\n * Persisted functions are jit functions written to code that contains the createJitFn closure but not the fn.\n * Serialized functions are jit functions sent over the network that contains the code to recreate the createJitFn closure and fn.\n * The JIT fn itself can't be compiled to code as it contains references to context code and jitUtils.\n * So we need to restore it manually by invoking the closure function.\n * */\nexport function restoreCompiledJitFns(\n    jitCache: PersistedJitFunctionsCache | FnsDataCache,\n    pureCache: PureFunctionsCache | PersistedPureFunctionsCache | PureFnsDataCache,\n    jUtil: JITUtils\n): void {\n    // Use visited sets to prevent infinite recursion on circular dependencies\n    // This is needed because during restoration, the `fn` property is not set until after\n    // all dependencies are restored, so checking `fn` alone can't prevent circular calls\n    const visitedPure = new Set<string>();\n    const visitedJit = new Set<string>();\n\n    // Iterate over all namespaces and restore pure functions\n    for (const namespace in pureCache) {\n        const nsCache = pureCache[namespace];\n        const keysPureFns = Object.keys(nsCache);\n        keysPureFns.forEach((key) => restoreCompiledPureFn(pureCache, namespace, key, jUtil, visitedPure));\n    }\n    const keysJitFns = Object.keys(jitCache);\n    keysJitFns.forEach((key) => restoreCompiledJitFn(jitCache, pureCache, key, jUtil, visitedPure, visitedJit));\n}\n\nfunction restoreCompiledPureFn(\n    pureCache: PureFunctionsCache | PersistedPureFunctionsCache | PureFnsDataCache,\n    namespace: string,\n    fnName: string,\n    jUtil: JITUtils,\n    visited: Set<string>\n) {\n    // Use namespace:fnName as the visited key to handle same function names in different namespaces\n    const visitedKey = `${namespace}:${fnName}`;\n    // Skip if already visited (handles circular dependencies)\n    if (visited.has(visitedKey)) return;\n    visited.add(visitedKey);\n\n    const nsCache = pureCache[namespace];\n    if (!nsCache) throw new Error(`Pure function namespace ${namespace} not found`);\n    const pureCompiled = nsCache[fnName];\n    if (!pureCompiled) throw new Error(`Pure function ${fnName} not found in namespace ${namespace}`);\n    if ((pureCompiled as CompiledPureFunction).fn) return;\n    const dependencies = pureCompiled.pureFnDependencies || [];\n    // Dependencies are in the same namespace\n    dependencies.forEach((depName) => restoreCompiledPureFn(pureCache, namespace, depName, jUtil, visited));\n    // persisted pure functions (AOT code caches) have the createJitFn but not the fn\n    if ((pureCompiled as PersistedPureFunction).createPureFn) {\n        (pureCompiled as any as Mutable<CompiledPureFunction>).fn = (pureCompiled as PersistedPureFunction).createPureFn(jUtil);\n        return;\n    }\n    // serialized pure functions (network sent) do not contains neither createJitFn nor fn\n    restorePureFunction(pureCompiled, jUtil);\n}\n\nfunction restoreCompiledJitFn(\n    jitCache: PersistedJitFunctionsCache | FnsDataCache,\n    pureCache: PureFunctionsCache | PersistedPureFunctionsCache | PureFnsDataCache,\n    fnHash: string,\n    jUtil: JITUtils,\n    visitedPure: Set<string>,\n    visitedJit: Set<string>\n) {\n    // Skip if already visited (handles circular dependencies)\n    if (visitedJit.has(fnHash)) return;\n    visitedJit.add(fnHash);\n\n    const jitCompiled = jitCache[fnHash];\n    if (!jitCompiled) throw new Error(`Jit function ${fnHash} not found`);\n    if ((jitCompiled as JitCompiledFn).fn) return;\n    const pureDependencies = jitCompiled.pureFnDependencies || [];\n    // Pure function dependencies are stored as \"namespace::fnHash\"\n    pureDependencies.forEach((dep) => {\n        const parts = dep.split('::');\n        if (parts.length !== 2) throw new Error(`Invalid pure function dependency format: ${dep}, expected \"namespace::fnHash\"`);\n        const [namespace, fnHash] = parts;\n        restoreCompiledPureFn(pureCache, namespace, fnHash, jUtil, visitedPure);\n    });\n    const dependencies = jitCompiled.jitDependencies || [];\n    dependencies.forEach((dep) => restoreCompiledJitFn(jitCache, pureCache, dep, jUtil, visitedPure, visitedJit));\n    if ((jitCompiled as PersistedJitFn).createJitFn) {\n        (jitCompiled as any as Mutable<JitCompiledFn>).fn = (jitCompiled as PersistedJitFn).createJitFn(jUtil);\n        return;\n    }\n    restoreCreateJitFn(jitCompiled, jUtil);\n}\n\n/**\n * Restores a JIT function from serialized function data.\n * This functionsMutates the input data!!!\n * Creates a dynamic function using the serialized code (which already contains the complete function with context),\n * then executes it with jitUtils to produce the final JIT function.\n * @param fnData - The serialized function data containing code, args, and metadata\n * @returns A JitCompiledFn with both the createJitFn closure and the executed fn\n */\nfunction restoreCreateJitFn(fnData: JitCompiledFnData, jUtil: JITUtils): JitCompiledFn {\n    const fnName = fnData.jitFnHash;\n    // fnData.code already contains the complete function with context (e.g., \"const x = ...; return function fnName(args){...}\")\n    const fnWithContext = `'use strict'; ${fnData.code}`;\n    try {\n        // Create wrapper function that works as a factory and returns the actual jit function\n        const wrapperWithContext = new Function('utl', fnWithContext) as (utl: JITUtils) => (...args: any[]) => any;\n        // Execute the wrapper with jitUtils to get the final function\n        const fn = wrapperWithContext(jUtil);\n        const jitFn = fnData as Mutable<JitCompiledFn>;\n        jitFn.createJitFn = wrapperWithContext;\n        jitFn.fn = fn;\n        return jitFn;\n    } catch (e: any) {\n        throw new TypedError({\n            type: 'jit-fn-restore-error',\n            message: `Failed to restore JIT function ${fnName}: ${e?.message}`,\n        });\n    }\n}\n\n/**\n * Restores a pure function from serialized function data.\n * This function mutates the input data!!!\n * Creates a dynamic function using the serialized code (which already contains the complete function with context),\n * then executes it with jitUtils to produce the final pure function.\n * @param pureFnData - The serialized pure function data containing code and metadata\n * @returns A CompiledPureFunction with both the createJitFn closure and the executed fn\n */\nfunction restorePureFunction(pureFnData: PureFunctionData, jUtil: JITUtils): CompiledPureFunction {\n    const fnName = pureFnData.fnName;\n    // pureFnData.code already contains the complete function with context\n    const fnWithContext = `'use strict'; ${pureFnData.code}`;\n    try {\n        // Create wrapper function that works as a factory and returns the actual pure function\n        const wrapperWithContext = new Function('utl', fnWithContext) as PureFunctionFactory;\n        // Execute the wrapper with jitUtils to get the final function\n        const fn = wrapperWithContext(jUtil);\n        const pureFn = pureFnData as Mutable<CompiledPureFunction>;\n        pureFn.createPureFn = wrapperWithContext;\n        pureFn.fn = fn;\n        return pureFn;\n    } catch (e: any) {\n        throw new TypedError({\n            type: 'pure-fn-restore-error',\n            message: `Failed to restore pure function ${fnName}: ${e?.message}`,\n        });\n    }\n}\n"],"names":["fnHash","TypedError"],"mappings":"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"}

package/.dist/cjs/src/routerUtils.cjs

@@ -104,33 +104,36 @@ function addRoutesToCache(newCache) {
     }
   }
 }
-function getJitFnHashes(jitHash) {
+function getJitFnHashes(jitHash, needsBinary = false) {
   return {
     isType: `${src_constants.JIT_FUNCTION_IDS.isType}_${jitHash}`,
     typeErrors: `${src_constants.JIT_FUNCTION_IDS.typeErrors}_${jitHash}`,
     prepareForJson: `${src_constants.JIT_FUNCTION_IDS.prepareForJson}_${jitHash}`,
     restoreFromJson: `${src_constants.JIT_FUNCTION_IDS.restoreFromJson}_${jitHash}`,
     stringifyJson: `${src_constants.JIT_FUNCTION_IDS.stringifyJson}_${jitHash}`,
-    toBinary: `${src_constants.JIT_FUNCTION_IDS.toBinary}_${jitHash}`,
-    fromBinary: `${src_constants.JIT_FUNCTION_IDS.fromBinary}_${jitHash}`
+    ...needsBinary ? {
+      toBinary: `${src_constants.JIT_FUNCTION_IDS.toBinary}_${jitHash}`,
+      fromBinary: `${src_constants.JIT_FUNCTION_IDS.fromBinary}_${jitHash}`
+    } : {}
   };
 }
 function getJitFunctionsFromHash(jitHash) {
   if (jitHash === src_constants.EMPTY_HASH) return noopJitFns;
   const cached = jitFunctionsCache.get(jitHash);
   if (cached) return cached;
-  const hashes = getJitFnHashes(jitHash);
   const jUtils = src_jit_jitUtils.getJitUtils();
   const jitFns = {
-    isType: jUtils.getJIT(hashes.isType),
-    typeErrors: jUtils.getJIT(hashes.typeErrors),
-    prepareForJson: jUtils.getJIT(hashes.prepareForJson),
-    restoreFromJson: jUtils.getJIT(hashes.restoreFromJson),
-    stringifyJson: jUtils.getJIT(hashes.stringifyJson),
-    toBinary: jUtils.getJIT(hashes.toBinary),
-    fromBinary: jUtils.getJIT(hashes.fromBinary)
+    isType: jUtils.getJIT(`${src_constants.JIT_FUNCTION_IDS.isType}_${jitHash}`),
+    typeErrors: jUtils.getJIT(`${src_constants.JIT_FUNCTION_IDS.typeErrors}_${jitHash}`),
+    prepareForJson: jUtils.getJIT(`${src_constants.JIT_FUNCTION_IDS.prepareForJson}_${jitHash}`),
+    restoreFromJson: jUtils.getJIT(`${src_constants.JIT_FUNCTION_IDS.restoreFromJson}_${jitHash}`),
+    stringifyJson: jUtils.getJIT(`${src_constants.JIT_FUNCTION_IDS.stringifyJson}_${jitHash}`)
   };
-  for (const key in jitFns) {
+  const toBinaryJit = jUtils.getJIT(`${src_constants.JIT_FUNCTION_IDS.toBinary}_${jitHash}`);
+  const fromBinaryJit = jUtils.getJIT(`${src_constants.JIT_FUNCTION_IDS.fromBinary}_${jitHash}`);
+  if (toBinaryJit) jitFns.toBinary = toBinaryJit;
+  if (fromBinaryJit) jitFns.fromBinary = fromBinaryJit;
+  for (const key of ["isType", "typeErrors", "prepareForJson", "restoreFromJson", "stringifyJson"]) {
     if (!jitFns[key]) throw new Error(`Jit function ${key} not found for jitHash ${jitHash}`);
   }
   jitFunctionsCache.set(jitHash, jitFns);
@@ -169,9 +172,7 @@ const noopJitFns = {
   typeErrors: fakeJitFn(src_constants.JIT_FUNCTION_IDS.typeErrors),
   prepareForJson: fakeJitFn(src_constants.JIT_FUNCTION_IDS.prepareForJson),
   restoreFromJson: fakeJitFn(src_constants.JIT_FUNCTION_IDS.restoreFromJson),
-  stringifyJson: fakeJitFn(src_constants.JIT_FUNCTION_IDS.stringifyJson),
-  toBinary: fakeJitFn(src_constants.JIT_FUNCTION_IDS.toBinary),
-  fromBinary: fakeJitFn(src_constants.JIT_FUNCTION_IDS.fromBinary)
+  stringifyJson: fakeJitFn(src_constants.JIT_FUNCTION_IDS.stringifyJson)
 };
 function fakeJitFn(fnID) {
   return {
@@ -182,8 +183,6 @@ function fakeJitFn(fnID) {
     defaultParamValues: { vλl: "v" },
     isNoop: true,
     code: "",
-    jitDependencies: [],
-    pureFnDependencies: [],
     createJitFn: () => {
       throw new Error("isNoop JIT functions should not be called, this is a function when jit is never used");
     },

package/.dist/cjs/src/routerUtils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"routerUtils.cjs","sources":["../../../src/routerUtils.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {JIT_FUNCTION_IDS, PATH_SEPARATOR, ROUTER_ITEM_SEPARATOR_CHAR, ROUTE_PATH_ROOT, EMPTY_HASH} from './constants.ts';\nimport type {RemoteMethodOpts, MethodWithOptions, MethodsCache, MethodWithOptsAndJitFns} from './types/method.types.ts';\nimport type {CoreRouterOptions, JitCompiledFn, JitCompiledFunctions, JitFunctionsHashes} from './types/general.types.ts';\nimport {getJitUtils} from './jit/jitUtils.ts';\n\nconst methodsCache: MethodsCache = {};\nconst methodsOptionsCache: Record<string, RemoteMethodOpts> = {};\n\n// Cache for JitCompiledFunctions objects keyed by jitHash\nconst jitFunctionsCache = new Map<string, JitCompiledFunctions>();\nconst headerJitFunctionsCache = new Map<string, Pick<JitCompiledFunctions, 'isType' | 'typeErrors'>>();\n\n/**\n * Utilities for accessing and modifying the router cache.\n * The router cache stores method metadata for routes registered via addRoutesToCache() or virtual modules.\n */\nexport const routesCache = {\n    /**\n     * Get method metadata from the router cache by id.\n     * @param id - The method id\n     * @returns The method metadata or undefined if not found\n     */\n    getMetadata(id: string): MethodWithOptions | undefined {\n        return methodsCache[id] as MethodWithOptions | undefined;\n    },\n\n    /**\n     * Set method metadata in the router cache\n     * @param id - The method id\n     * @param methodData - The method metadata\n     */\n    setMetadata(id: string, methodData: MethodWithOptions): void {\n        methodsCache[id] = methodData as any;\n    },\n\n    /**\n     * Check if the router cache contains a method by id.\n     * @param id - The method id\n     * @returns True if the method exists in the cache\n     */\n    hasMetadata(id: string): boolean {\n        return id in methodsCache;\n    },\n\n    /**\n     * Get the raw router cache object.\n     * Use with caution - prefer using get/set/has methods.\n     * @returns The router cache object\n     */\n    getCache(): MethodsCache {\n        return methodsCache;\n    },\n\n    /**\n     * Get method metadata with JIT functions restored from the router cache by id.\n     * This augments the MethodWithOptions with paramsJitFns and returnJitFns.\n     * JIT functions are cached in the entry after first access for performance.\n     * @param id - The method id\n     * @returns The method metadata with JIT functions or undefined if not found\n     */\n    getMethodJitFns(id: string): MethodWithOptsAndJitFns | undefined {\n        if (id in methodsCache) {\n            const cached = methodsCache[id] as any;\n            if (cached.paramsJitFns && cached.returnJitFns) {\n                return cached as MethodWithOptsAndJitFns;\n            }\n        }\n\n        const metadata = this.getMetadata(id);\n        if (!metadata) return undefined;\n\n        const paramsJitFns = getJitFunctionsFromHash(metadata.paramsJitHash);\n        const returnJitFns = getJitFunctionsFromHash(metadata.returnJitHash);\n        const headersParam = metadata.headersParam\n            ? {...metadata.headersParam, jitFns: getHeaderJitFunctionsFromHash(metadata.headersParam.jitHash)}\n            : undefined;\n        const headersReturn = metadata.headersReturn\n            ? {...metadata.headersReturn, jitFns: getHeaderJitFunctionsFromHash(metadata.headersReturn.jitHash)}\n            : undefined;\n\n        const result: MethodWithOptsAndJitFns = {\n            ...metadata,\n            paramsJitFns,\n            returnJitFns,\n            headersParam,\n            headersReturn,\n        };\n\n        methodsCache[id] = result;\n        return result as MethodWithOptsAndJitFns;\n    },\n\n    /**\n     * Get method metadata with JIT functions restored from the router cache by id.\n     * @param id\n     * @returns\n     */\n    useMethodJitFns(id: string): MethodWithOptsAndJitFns {\n        const MethodWithOptsAndJitFns = this.getMethodJitFns(id);\n        if (!MethodWithOptsAndJitFns) throw new Error(`Metadata for remote method ${id} not found`);\n        return MethodWithOptsAndJitFns;\n    },\n\n    /**\n     * Set method metadata with JIT functions in the router cache.\n     * This stores the complete MethodWithOptsAndJitFns object directly.\n     * @param id - The method id\n     * @param MethodWithOptsAndJitFns - The method metadata with JIT functions\n     */\n    setMethodJitFns(id: string, MethodWithOptsAndJitFns: MethodWithOptsAndJitFns): void {\n        methodsCache[id] = MethodWithOptsAndJitFns as any;\n    },\n};\n\nexport const methodOptsCache = {\n    getMethodOptions(id: string): RemoteMethodOpts | undefined {\n        return methodsOptionsCache[id];\n    },\n    setMethodOptions(id: string, options: RemoteMethodOpts): void {\n        methodsOptionsCache[id] = options;\n    },\n};\n\n/**\n * Adds new routes to the router cache.\n * This is the public API for registering routes - called by virtual modules or directly.\n * @param newCache\n */\nexport function addRoutesToCache(newCache: MethodsCache) {\n    for (const key in newCache) {\n        if (!(key in methodsCache)) {\n            // Clone the cache entry to avoid mutating the original\n            methodsCache[key] = {...newCache[key]} as MethodWithOptions;\n        }\n    }\n}\n\nexport function getJitFnHashes(jitHash: string): JitFunctionsHashes {\n    return {\n        isType: `${JIT_FUNCTION_IDS.isType}_${jitHash}`,\n        typeErrors: `${JIT_FUNCTION_IDS.typeErrors}_${jitHash}`,\n        prepareForJson: `${JIT_FUNCTION_IDS.prepareForJson}_${jitHash}`,\n        restoreFromJson: `${JIT_FUNCTION_IDS.restoreFromJson}_${jitHash}`,\n        stringifyJson: `${JIT_FUNCTION_IDS.stringifyJson}_${jitHash}`,\n        toBinary: `${JIT_FUNCTION_IDS.toBinary}_${jitHash}`,\n        fromBinary: `${JIT_FUNCTION_IDS.fromBinary}_${jitHash}`,\n    };\n}\n\n/**\n * Helper function to get JIT functions from a JIT hash\n * Returns nullJitFns for empty hash (handlers with no params or void return)\n * Results are cached to avoid creating duplicate objects.\n */\nexport function getJitFunctionsFromHash(jitHash: string): JitCompiledFunctions {\n    // Empty hash means no JIT functions were generated (optimization for no params or void return)\n    if (jitHash === EMPTY_HASH) return noopJitFns;\n\n    // Check cache first\n    const cached = jitFunctionsCache.get(jitHash);\n    if (cached) return cached;\n\n    const hashes = getJitFnHashes(jitHash);\n    const jUtils = getJitUtils();\n    const jitFns = {\n        isType: jUtils.getJIT(hashes.isType),\n        typeErrors: jUtils.getJIT(hashes.typeErrors),\n        prepareForJson: jUtils.getJIT(hashes.prepareForJson),\n        restoreFromJson: jUtils.getJIT(hashes.restoreFromJson),\n        stringifyJson: jUtils.getJIT(hashes.stringifyJson),\n        toBinary: jUtils.getJIT(hashes.toBinary),\n        fromBinary: jUtils.getJIT(hashes.fromBinary),\n    } as JitCompiledFunctions;\n    for (const key in jitFns) {\n        if (!jitFns[key]) throw new Error(`Jit function ${key} not found for jitHash ${jitHash}`);\n    }\n\n    // Cache for future calls\n    jitFunctionsCache.set(jitHash, jitFns);\n    return jitFns;\n}\n\n/**\n * Helper function to get header JIT functions from a JIT hash\n * Results are cached to avoid creating duplicate objects.\n */\nexport function getHeaderJitFunctionsFromHash(jitHash: string): Pick<JitCompiledFunctions, 'isType' | 'typeErrors'> {\n    // Check cache first\n    const cached = headerJitFunctionsCache.get(jitHash);\n    if (cached) return cached;\n\n    const hashes = getJitFnHashes(jitHash);\n    const jUtils = getJitUtils();\n    const jitFns = {\n        isType: jUtils.getJIT(hashes.isType),\n        typeErrors: jUtils.getJIT(hashes.typeErrors),\n    } as Pick<JitCompiledFunctions, 'isType' | 'typeErrors'>;\n\n    // Cache for future calls\n    headerJitFunctionsCache.set(jitHash, jitFns);\n    return jitFns;\n}\n\n/**\n * Get the router id for Routes or MiddleFns\n * @param itemPointer - The pointer to the item within the Routes object\n * i.e:\n * const routes = {\n *   auth: () => {},\n *   users: {\n *    getUser: () => {}\n *   }\n *   login: () => {}\n * }\n *\n * then the pointer for getUser is => ['users', 'getUser']\n */\nexport function getRouterItemId(itemPointer: string[]) {\n    return itemPointer.join(ROUTER_ITEM_SEPARATOR_CHAR);\n}\n\n/** Gets a route path from a route pointer */\nexport function getRoutePath(pathPointer: string[], routerOptions: CoreRouterOptions) {\n    const pathId = getRouterItemId(pathPointer);\n    const basePath = routerOptions.basePath.startsWith(ROUTE_PATH_ROOT)\n        ? routerOptions.basePath\n        : `${ROUTE_PATH_ROOT}${routerOptions.basePath}`;\n    const routePath = basePath.endsWith(PATH_SEPARATOR) ? `${basePath}${pathId}` : `${basePath}${PATH_SEPARATOR}${pathId}`;\n    return routerOptions.suffix ? routePath + routerOptions.suffix : routePath;\n}\n\nexport function resetRoutesCache() {\n    for (const k in methodsCache) delete methodsCache[k];\n}\n\n/** Resets the JIT functions cache. Useful for testing purposes only. */\nexport function resetJitFunctionsCache(): void {\n    jitFunctionsCache.clear();\n    headerJitFunctionsCache.clear();\n}\n\n// Noop JIT functions used for handlers with no params or void return\n// prettier-ignore\nconst noopJitFns: JitCompiledFunctions = {\n    isType: fakeJitFn(JIT_FUNCTION_IDS.isType),\n    typeErrors: fakeJitFn(JIT_FUNCTION_IDS.typeErrors),\n    prepareForJson: fakeJitFn(JIT_FUNCTION_IDS.prepareForJson),\n    restoreFromJson: fakeJitFn(JIT_FUNCTION_IDS.restoreFromJson),\n    stringifyJson: fakeJitFn(JIT_FUNCTION_IDS.stringifyJson),\n    toBinary: fakeJitFn(JIT_FUNCTION_IDS.toBinary),\n    fromBinary: fakeJitFn(JIT_FUNCTION_IDS.fromBinary),\n} as any;\n\n/** Creates a fake JIT function with isNoop=true for handlers with no params or void return */\nfunction fakeJitFn(fnID: string): JitCompiledFn<any> {\n    return {\n        typeName: 'mionNoopJit',\n        fnID,\n        jitFnHash: EMPTY_HASH,\n        args: {vλl: 'v'},\n        defaultParamValues: {vλl: 'v'},\n        isNoop: true,\n        code: '',\n        jitDependencies: [],\n        pureFnDependencies: [],\n        createJitFn: () => {\n            throw new Error('isNoop JIT functions should not be called, this is a function when jit is never used');\n        },\n        fn: () => {\n            throw new Error('isNoop JIT functions should not be called, this is a function when jit is never used');\n        },\n    };\n}\n\nexport function getNoopJitFns(): JitCompiledFunctions {\n    return noopJitFns;\n}\n"],"names":["JIT_FUNCTION_IDS","EMPTY_HASH","getJitUtils","ROUTER_ITEM_SEPARATOR_CHAR","ROUTE_PATH_ROOT","PATH_SEPARATOR"],"mappings":"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"}
+{"version":3,"file":"routerUtils.cjs","sources":["../../../src/routerUtils.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {JIT_FUNCTION_IDS, PATH_SEPARATOR, ROUTER_ITEM_SEPARATOR_CHAR, ROUTE_PATH_ROOT, EMPTY_HASH} from './constants.ts';\nimport type {RemoteMethodOpts, MethodWithOptions, MethodsCache, MethodWithOptsAndJitFns} from './types/method.types.ts';\nimport type {CoreRouterOptions, JitCompiledFn, JitCompiledFunctions, JitFunctionsHashes} from './types/general.types.ts';\nimport {getJitUtils} from './jit/jitUtils.ts';\n\nconst methodsCache: MethodsCache = {};\nconst methodsOptionsCache: Record<string, RemoteMethodOpts> = {};\n\n// Cache for JitCompiledFunctions objects keyed by jitHash\nconst jitFunctionsCache = new Map<string, JitCompiledFunctions>();\nconst headerJitFunctionsCache = new Map<string, Pick<JitCompiledFunctions, 'isType' | 'typeErrors'>>();\n\n/**\n * Utilities for accessing and modifying the router cache.\n * The router cache stores method metadata for routes registered via addRoutesToCache() or virtual modules.\n */\nexport const routesCache = {\n    /**\n     * Get method metadata from the router cache by id.\n     * @param id - The method id\n     * @returns The method metadata or undefined if not found\n     */\n    getMetadata(id: string): MethodWithOptions | undefined {\n        return methodsCache[id] as MethodWithOptions | undefined;\n    },\n\n    /**\n     * Set method metadata in the router cache\n     * @param id - The method id\n     * @param methodData - The method metadata\n     */\n    setMetadata(id: string, methodData: MethodWithOptions): void {\n        methodsCache[id] = methodData as any;\n    },\n\n    /**\n     * Check if the router cache contains a method by id.\n     * @param id - The method id\n     * @returns True if the method exists in the cache\n     */\n    hasMetadata(id: string): boolean {\n        return id in methodsCache;\n    },\n\n    /**\n     * Get the raw router cache object.\n     * Use with caution - prefer using get/set/has methods.\n     * @returns The router cache object\n     */\n    getCache(): MethodsCache {\n        return methodsCache;\n    },\n\n    /**\n     * Get method metadata with JIT functions restored from the router cache by id.\n     * This augments the MethodWithOptions with paramsJitFns and returnJitFns.\n     * JIT functions are cached in the entry after first access for performance.\n     * @param id - The method id\n     * @returns The method metadata with JIT functions or undefined if not found\n     */\n    getMethodJitFns(id: string): MethodWithOptsAndJitFns | undefined {\n        if (id in methodsCache) {\n            const cached = methodsCache[id] as any;\n            if (cached.paramsJitFns && cached.returnJitFns) {\n                return cached as MethodWithOptsAndJitFns;\n            }\n        }\n\n        const metadata = this.getMetadata(id);\n        if (!metadata) return undefined;\n\n        const paramsJitFns = getJitFunctionsFromHash(metadata.paramsJitHash);\n        const returnJitFns = getJitFunctionsFromHash(metadata.returnJitHash);\n        const headersParam = metadata.headersParam\n            ? {...metadata.headersParam, jitFns: getHeaderJitFunctionsFromHash(metadata.headersParam.jitHash)}\n            : undefined;\n        const headersReturn = metadata.headersReturn\n            ? {...metadata.headersReturn, jitFns: getHeaderJitFunctionsFromHash(metadata.headersReturn.jitHash)}\n            : undefined;\n\n        const result: MethodWithOptsAndJitFns = {\n            ...metadata,\n            paramsJitFns,\n            returnJitFns,\n            headersParam,\n            headersReturn,\n        };\n\n        methodsCache[id] = result;\n        return result as MethodWithOptsAndJitFns;\n    },\n\n    /**\n     * Get method metadata with JIT functions restored from the router cache by id.\n     * @param id\n     * @returns\n     */\n    useMethodJitFns(id: string): MethodWithOptsAndJitFns {\n        const MethodWithOptsAndJitFns = this.getMethodJitFns(id);\n        if (!MethodWithOptsAndJitFns) throw new Error(`Metadata for remote method ${id} not found`);\n        return MethodWithOptsAndJitFns;\n    },\n\n    /**\n     * Set method metadata with JIT functions in the router cache.\n     * This stores the complete MethodWithOptsAndJitFns object directly.\n     * @param id - The method id\n     * @param MethodWithOptsAndJitFns - The method metadata with JIT functions\n     */\n    setMethodJitFns(id: string, MethodWithOptsAndJitFns: MethodWithOptsAndJitFns): void {\n        methodsCache[id] = MethodWithOptsAndJitFns as any;\n    },\n};\n\nexport const methodOptsCache = {\n    getMethodOptions(id: string): RemoteMethodOpts | undefined {\n        return methodsOptionsCache[id];\n    },\n    setMethodOptions(id: string, options: RemoteMethodOpts): void {\n        methodsOptionsCache[id] = options;\n    },\n};\n\n/**\n * Adds new routes to the router cache.\n * This is the public API for registering routes - called by virtual modules or directly.\n * @param newCache\n */\nexport function addRoutesToCache(newCache: MethodsCache) {\n    for (const key in newCache) {\n        if (!(key in methodsCache)) {\n            // Clone the cache entry to avoid mutating the original\n            methodsCache[key] = {...newCache[key]} as MethodWithOptions;\n        }\n    }\n}\n\nexport function getJitFnHashes(jitHash: string, needsBinary: boolean = false): JitFunctionsHashes {\n    return {\n        isType: `${JIT_FUNCTION_IDS.isType}_${jitHash}`,\n        typeErrors: `${JIT_FUNCTION_IDS.typeErrors}_${jitHash}`,\n        prepareForJson: `${JIT_FUNCTION_IDS.prepareForJson}_${jitHash}`,\n        restoreFromJson: `${JIT_FUNCTION_IDS.restoreFromJson}_${jitHash}`,\n        stringifyJson: `${JIT_FUNCTION_IDS.stringifyJson}_${jitHash}`,\n        ...(needsBinary\n            ? {\n                  toBinary: `${JIT_FUNCTION_IDS.toBinary}_${jitHash}`,\n                  fromBinary: `${JIT_FUNCTION_IDS.fromBinary}_${jitHash}`,\n              }\n            : {}),\n    };\n}\n\n/**\n * Helper function to get JIT functions from a JIT hash\n * Returns nullJitFns for empty hash (handlers with no params or void return)\n * Results are cached to avoid creating duplicate objects.\n */\nexport function getJitFunctionsFromHash(jitHash: string): JitCompiledFunctions {\n    // Empty hash means no JIT functions were generated (optimization for no params or void return)\n    if (jitHash === EMPTY_HASH) return noopJitFns;\n\n    // Check cache first\n    const cached = jitFunctionsCache.get(jitHash);\n    if (cached) return cached;\n\n    const jUtils = getJitUtils();\n    const jitFns = {\n        isType: jUtils.getJIT(`${JIT_FUNCTION_IDS.isType}_${jitHash}`),\n        typeErrors: jUtils.getJIT(`${JIT_FUNCTION_IDS.typeErrors}_${jitHash}`),\n        prepareForJson: jUtils.getJIT(`${JIT_FUNCTION_IDS.prepareForJson}_${jitHash}`),\n        restoreFromJson: jUtils.getJIT(`${JIT_FUNCTION_IDS.restoreFromJson}_${jitHash}`),\n        stringifyJson: jUtils.getJIT(`${JIT_FUNCTION_IDS.stringifyJson}_${jitHash}`),\n    } as JitCompiledFunctions;\n    // Only include binary functions if they exist in the store\n    const toBinaryJit = jUtils.getJIT(`${JIT_FUNCTION_IDS.toBinary}_${jitHash}`);\n    const fromBinaryJit = jUtils.getJIT(`${JIT_FUNCTION_IDS.fromBinary}_${jitHash}`);\n    if (toBinaryJit) jitFns.toBinary = toBinaryJit;\n    if (fromBinaryJit) jitFns.fromBinary = fromBinaryJit;\n\n    for (const key of ['isType', 'typeErrors', 'prepareForJson', 'restoreFromJson', 'stringifyJson'] as const) {\n        if (!jitFns[key]) throw new Error(`Jit function ${key} not found for jitHash ${jitHash}`);\n    }\n\n    // Cache for future calls\n    jitFunctionsCache.set(jitHash, jitFns);\n    return jitFns;\n}\n\n/**\n * Helper function to get header JIT functions from a JIT hash\n * Results are cached to avoid creating duplicate objects.\n */\nexport function getHeaderJitFunctionsFromHash(jitHash: string): Pick<JitCompiledFunctions, 'isType' | 'typeErrors'> {\n    // Check cache first\n    const cached = headerJitFunctionsCache.get(jitHash);\n    if (cached) return cached;\n\n    const hashes = getJitFnHashes(jitHash);\n    const jUtils = getJitUtils();\n    const jitFns = {\n        isType: jUtils.getJIT(hashes.isType),\n        typeErrors: jUtils.getJIT(hashes.typeErrors),\n    } as Pick<JitCompiledFunctions, 'isType' | 'typeErrors'>;\n\n    // Cache for future calls\n    headerJitFunctionsCache.set(jitHash, jitFns);\n    return jitFns;\n}\n\n/**\n * Get the router id for Routes or MiddleFns\n * @param itemPointer - The pointer to the item within the Routes object\n * i.e:\n * const routes = {\n *   auth: () => {},\n *   users: {\n *    getUser: () => {}\n *   }\n *   login: () => {}\n * }\n *\n * then the pointer for getUser is => ['users', 'getUser']\n */\nexport function getRouterItemId(itemPointer: string[]) {\n    return itemPointer.join(ROUTER_ITEM_SEPARATOR_CHAR);\n}\n\n/** Gets a route path from a route pointer */\nexport function getRoutePath(pathPointer: string[], routerOptions: CoreRouterOptions) {\n    const pathId = getRouterItemId(pathPointer);\n    const basePath = routerOptions.basePath.startsWith(ROUTE_PATH_ROOT)\n        ? routerOptions.basePath\n        : `${ROUTE_PATH_ROOT}${routerOptions.basePath}`;\n    const routePath = basePath.endsWith(PATH_SEPARATOR) ? `${basePath}${pathId}` : `${basePath}${PATH_SEPARATOR}${pathId}`;\n    return routerOptions.suffix ? routePath + routerOptions.suffix : routePath;\n}\n\nexport function resetRoutesCache() {\n    for (const k in methodsCache) delete methodsCache[k];\n}\n\n/** Resets the JIT functions cache. Useful for testing purposes only. */\nexport function resetJitFunctionsCache(): void {\n    jitFunctionsCache.clear();\n    headerJitFunctionsCache.clear();\n}\n\n// Noop JIT functions used for handlers with no params or void return\n// prettier-ignore\nconst noopJitFns: JitCompiledFunctions = {\n    isType: fakeJitFn(JIT_FUNCTION_IDS.isType),\n    typeErrors: fakeJitFn(JIT_FUNCTION_IDS.typeErrors),\n    prepareForJson: fakeJitFn(JIT_FUNCTION_IDS.prepareForJson),\n    restoreFromJson: fakeJitFn(JIT_FUNCTION_IDS.restoreFromJson),\n    stringifyJson: fakeJitFn(JIT_FUNCTION_IDS.stringifyJson),\n} as any;\n\n/** Creates a fake JIT function with isNoop=true for handlers with no params or void return */\nfunction fakeJitFn(fnID: string): JitCompiledFn<any> {\n    return {\n        typeName: 'mionNoopJit',\n        fnID,\n        jitFnHash: EMPTY_HASH,\n        args: {vλl: 'v'},\n        defaultParamValues: {vλl: 'v'},\n        isNoop: true,\n        code: '',\n        createJitFn: () => {\n            throw new Error('isNoop JIT functions should not be called, this is a function when jit is never used');\n        },\n        fn: () => {\n            throw new Error('isNoop JIT functions should not be called, this is a function when jit is never used');\n        },\n    };\n}\n\nexport function getNoopJitFns(): JitCompiledFunctions {\n    return noopJitFns;\n}\n"],"names":["JIT_FUNCTION_IDS","EMPTY_HASH","getJitUtils","ROUTER_ITEM_SEPARATOR_CHAR","ROUTE_PATH_ROOT","PATH_SEPARATOR"],"mappings":"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"}

package/.dist/cjs/src/routerUtils.d.ts

@@ -14,7 +14,7 @@ export declare const methodOptsCache: {
     setMethodOptions(id: string, options: RemoteMethodOpts): void;
 };
 export declare function addRoutesToCache(newCache: MethodsCache): void;
-export declare function getJitFnHashes(jitHash: string): JitFunctionsHashes;
+export declare function getJitFnHashes(jitHash: string, needsBinary?: boolean): JitFunctionsHashes;
 export declare function getJitFunctionsFromHash(jitHash: string): JitCompiledFunctions;
 export declare function getHeaderJitFunctionsFromHash(jitHash: string): Pick<JitCompiledFunctions, 'isType' | 'typeErrors'>;
 export declare function getRouterItemId(itemPointer: string[]): string;

package/.dist/cjs/src/types/general.types.cjs

@@ -28,7 +28,9 @@ const SerializerModes = {
   /** Use toBinary JIT function for binary serialization */
   binary: 2,
   /** Use stringifyJson JIT function that do not mutates objects. */
-  stringifyJson: 3
+  stringifyJson: 3,
+  /** Client-only: sends plain JSON without JIT, fetches metadata in the same response */
+  optimistic: 4
 };
 const __ΩSerializerMode = [() => SerializerModes, "SerializerMode", 'i!gw"y'];
 const __ΩSerializerCode = [() => SerializerModes, () => __ΩSerializerMode, "SerializerCode", 'i!n"fw#y'];
@@ -45,12 +47,12 @@ const __ΩSetItemPathSegment = ["key", "index", "SetItemPathSegment", `P#4!'4"Mw
 const __ΩPathSegment = [() => __ΩStrNumber, () => __ΩMapKeyPathSegment, () => __ΩMapValuePathSegment, () => __ΩSetItemPathSegment, "PathSegment", 'Pn!n"n#n$Jw%y'];
 const __ΩRunTypeError = [() => __ΩPathSegment, "path", "expected", () => src_types_formats_formats_types.__ΩTypeFormatError, "format", "RunTypeError", 'Pn!F4"&4#n$4%8Mw&y'];
 const __ΩJitFnArgs = ["vλl", "JitFnArgs", 'P&4!&&LMw"y'];
-const __ΩJitCompiledFnData = ["typeName", "fnID", "jitFnHash", () => __ΩJitFnArgs, "args", () => __ΩJitFnArgs, "defaultParamValues", "isNoop", "code", "jitDependencies", "pureFnDependencies", "paramNames", "JitCompiledFnData", `P&4!9&4"9&4#9n$4%9n&4'9)4(89&4)9&F4*9&F4+9&F4,8Mw-y`];
+const __ΩJitCompiledFnData = ["typeName", "fnID", "jitFnHash", () => __ΩJitFnArgs, "args", () => __ΩJitFnArgs, "defaultParamValues", "isNoop", "code", "jitDependencies", "pureFnDependencies", "paramNames", "JitCompiledFnData", `P&4!9&4"9&4#9n$4%9n&4'9)4(89&4)9&F4*89&F4+89&F4,8Mw-y`];
 const __ΩJitCompiledFn = [() => __ΩAnyFn, "Fn", () => __ΩJitCompiledFnData, "JITUtils", "utl", "", "createJitFn", "fn", "JitCompiledFn", `n!c"Pn#P"w$2%e#!/&4'9e"!4(9Mw)y`];
 const __ΩPersistedJitFn = [() => __ΩOmit, () => __ΩJitCompiledFn, "fn", "fn", "PersistedJitFn", 'Pn".#o!#-4$9Mw%y'];
-const __ΩJitCompiledFunctions = [() => __ΩJitCompiledFn, () => __ΩIsTypeFn, "isType", () => __ΩJitCompiledFn, () => __ΩTypeErrorsFn, "typeErrors", () => __ΩJitCompiledFn, () => __ΩPrepareForJsonFn, "prepareForJson", () => __ΩJitCompiledFn, () => __ΩRestoreFromJsonFn, "restoreFromJson", () => __ΩJitCompiledFn, () => __ΩJsonStringifyFn, "stringifyJson", () => __ΩJitCompiledFn, () => __ΩToBinaryFn, "toBinary", () => __ΩJitCompiledFn, () => __ΩFromBinaryFn, "fromBinary", "JitCompiledFunctions", `Pn"o!"4#n%o$"4&n(o'"4)n+o*"4,n.o-"4/n1o0"42n4o3"45Mw6y`];
-const __ΩSerializableJITFunctions = [() => __ΩJitCompiledFnData, "isType", () => __ΩJitCompiledFnData, "typeErrors", () => __ΩJitCompiledFnData, "prepareForJson", () => __ΩJitCompiledFnData, "restoreFromJson", () => __ΩJitCompiledFnData, "stringifyJson", () => __ΩJitCompiledFnData, "toBinary", () => __ΩJitCompiledFnData, "fromBinary", "SerializableJITFunctions", `Pn!4"n#4$n%4&n'4(n)4*n+4,n-4.Mw/y`];
-const __ΩJitFunctionsHashes = ["isType", "typeErrors", "prepareForJson", "restoreFromJson", "stringifyJson", "toBinary", "fromBinary", "JitFunctionsHashes", `P&4!&4"&4#&4$&4%&4&&4'Mw(y`];
+const __ΩJitCompiledFunctions = [() => __ΩJitCompiledFn, () => __ΩIsTypeFn, "isType", () => __ΩJitCompiledFn, () => __ΩTypeErrorsFn, "typeErrors", () => __ΩJitCompiledFn, () => __ΩPrepareForJsonFn, "prepareForJson", () => __ΩJitCompiledFn, () => __ΩRestoreFromJsonFn, "restoreFromJson", () => __ΩJitCompiledFn, () => __ΩJsonStringifyFn, "stringifyJson", () => __ΩJitCompiledFn, () => __ΩToBinaryFn, "toBinary", () => __ΩJitCompiledFn, () => __ΩFromBinaryFn, "fromBinary", "JitCompiledFunctions", `Pn"o!"4#n%o$"4&n(o'"4)n+o*"4,n.o-"4/n1o0"428n4o3"458Mw6y`];
+const __ΩSerializableJITFunctions = [() => __ΩJitCompiledFnData, "isType", () => __ΩJitCompiledFnData, "typeErrors", () => __ΩJitCompiledFnData, "prepareForJson", () => __ΩJitCompiledFnData, "restoreFromJson", () => __ΩJitCompiledFnData, "stringifyJson", () => __ΩJitCompiledFnData, "toBinary", () => __ΩJitCompiledFnData, "fromBinary", "SerializableJITFunctions", `Pn!4"n#4$n%4&n'4(n)4*n+4,8n-4.8Mw/y`];
+const __ΩJitFunctionsHashes = ["isType", "typeErrors", "prepareForJson", "restoreFromJson", "stringifyJson", "toBinary", "fromBinary", "JitFunctionsHashes", `P&4!&4"&4#&4$&4%&4&8&4'8Mw(y`];
 const __ΩJsonStringifyFn = ["value", () => __ΩJSONString, "", "JsonStringifyFn", 'P"2!n"/#w$y'];
 const __ΩRestoreFromJsonFn = [() => __ΩJSONValue, "value", "", "RestoreFromJsonFn", 'Pn!2""/#w$y'];
 const __ΩPrepareForJsonFn = ["value", () => __ΩJSONValue, "", "PrepareForJsonFn", 'P"2!n"/#w$y'];
@@ -69,6 +71,10 @@ const __ΩSrcCodeJitCompiledFn = [() => __ΩJitCompiledFnData, "JITUtils", "utl"
 const __ΩSrcCodeCompiledPureFunction = [() => src_types_pureFunctions_types.__ΩPureFunctionData, "JITUtils", "utl", () => __ΩAnyFn, "", "createPureFn", "fn", "SrcCodeCompiledPureFunction", `Pn!P"w"2#n$/%4&9-4'9Mw(y`];
 const __ΩSrcCodeJITCompiledFnsCache = [() => __ΩRecord, () => __ΩSrcCodeJitCompiledFn, "SrcCodeJITCompiledFnsCache", '&n"o!#w#y'];
 const __ΩSrcCodePureFunctionsCache = [() => __ΩRecord, () => __ΩRecord, () => __ΩSrcCodeCompiledPureFunction, "SrcCodePureFunctionsCache", '&&n#o"#o!#w$y'];
+const __ΩClientSrcCodeJitCompiledFn = [() => __ΩOmit, () => __ΩSrcCodeJitCompiledFn, "code", "args", "defaultParamValues", "fnID", "paramNames", "ClientSrcCodeJitCompiledFn", `n"P.#.$.%.&.'Jo!#w(y`];
+const __ΩClientSrcCodeCompiledPureFunction = [() => __ΩOmit, () => __ΩSrcCodeCompiledPureFunction, "code", "paramNames", "ClientSrcCodeCompiledPureFunction", 'n"P.#.$Jo!#w%y'];
+const __ΩClientSrcCodeJITCompiledFnsCache = [() => __ΩRecord, () => __ΩClientSrcCodeJitCompiledFn, "ClientSrcCodeJITCompiledFnsCache", '&n"o!#w#y'];
+const __ΩClientSrcCodePureFunctionsCache = [() => __ΩRecord, () => __ΩRecord, () => __ΩClientSrcCodeCompiledPureFunction, "ClientSrcCodePureFunctionsCache", '&&n#o"#o!#w$y'];
 const __ΩStrNumber = ["StrNumber", "P&'Jw!y"];
 const __ΩAnyFn = ["args", "", "AnyFn", 'P"@2!"/"w#y'];
 const __ΩAnyObject = [() => __ΩRecord, "AnyObject", '&#o!#w"y'];
@@ -92,6 +98,10 @@ exports.__ΩAnyErrorParams = __ΩAnyErrorParams;
 exports.__ΩAnyFn = __ΩAnyFn;
 exports.__ΩAnyObject = __ΩAnyObject;
 exports.__ΩBinaryInput = __ΩBinaryInput;
+exports.__ΩClientSrcCodeCompiledPureFunction = __ΩClientSrcCodeCompiledPureFunction;
+exports.__ΩClientSrcCodeJITCompiledFnsCache = __ΩClientSrcCodeJITCompiledFnsCache;
+exports.__ΩClientSrcCodeJitCompiledFn = __ΩClientSrcCodeJitCompiledFn;
+exports.__ΩClientSrcCodePureFunctionsCache = __ΩClientSrcCodePureFunctionsCache;
 exports.__ΩCoreRouterOptions = __ΩCoreRouterOptions;
 exports.__ΩDataOnly = __ΩDataOnly;
 exports.__ΩDataViewDeserializer = __ΩDataViewDeserializer;