@mionjs/core 0.8.0-alpha.0

package/.dist/esm/src/jit/jitUtils.d.ts

@@ -0,0 +1,30 @@
+import { JitCompiledFn, JitFunctionsCache, PureFunctionsCache, PersistedPureFunctionsCache, PureFnsDataCache, DeserializeClassFn, AnyClass, SerializableClass, PersistedJitFunctionsCache, FnsDataCache } from '../types/general.types.ts';
+import { CompiledPureFunction, PureFunction } from '../types/pureFunctions.types.ts';
+export interface JITUtils {
+    addToJitCache(comp: JitCompiledFn): void;
+    removeFromJitCache(comp: JitCompiledFn): void;
+    getJIT(jitFnHash: string): JitCompiledFn | undefined;
+    getJitFn(jitFnHash: string): (...args: any[]) => any;
+    hasJitFn(jitFnHash: string): boolean;
+    addPureFn(namespace: string, compiledFn: CompiledPureFunction): void;
+    usePureFn(namespace: string, name: string): PureFunction;
+    getPureFn(namespace: string, name: string): PureFunction | undefined;
+    getCompiledPureFn(namespace: string, name: string): CompiledPureFunction | undefined;
+    hasPureFn(namespace: string, name: string): boolean;
+    findCompiledPureFn(name: string): CompiledPureFunction | undefined;
+    setSerializableClass<C extends SerializableClass>(cls: C): void;
+    useSerializeClass(className: string): SerializableClass;
+    getSerializeClass(className: string): SerializableClass | undefined;
+    setDeserializeFn<C extends AnyClass>(cls: C, deserializeFn: DeserializeClassFn<InstanceType<C>>): void;
+    useDeserializeFn(className: string): DeserializeClassFn<any>;
+    getDeserializeFn(className: string): DeserializeClassFn<any> | undefined;
+}
+export declare function getJitUtils(): JITUtils;
+export declare function addAOTCaches(aotFnsCache: PersistedJitFunctionsCache, aotPureCache: PersistedPureFunctionsCache): void;
+export declare function addSerializedJitCaches(jitDataFnsCache: FnsDataCache, pureFnsDataCache: PureFnsDataCache): void;
+export declare function getJitFnCaches(): {
+    jitFnsCache: Readonly<JitFunctionsCache>;
+    pureFnsCache: Readonly<PureFunctionsCache>;
+};
+export declare function resetJitFnCaches(): void;
+export declare type __ΩJITUtils = any[];

package/.dist/esm/src/jit/jitUtils.js

@@ -0,0 +1,173 @@
+import { isTestEnv, initPureFunction } from "../utils.js";
+import { restoreCompiledJitFns } from "../pureFns/restoreJitFns.js";
+const jitFnsCache = {};
+const pureFnsCache = {};
+const deserializeFnsRegistry = /* @__PURE__ */ new Map();
+const serializableClassRegistry = /* @__PURE__ */ new Map();
+const jitUtils = {
+  addToJitCache(comp) {
+    jitFnsCache[comp.jitFnHash] = comp;
+  },
+  removeFromJitCache(comp) {
+    if (!jitFnsCache[comp.jitFnHash]) return;
+    jitFnsCache[comp.jitFnHash] = void 0;
+  },
+  getJIT(jitFnHash) {
+    return jitFnsCache[jitFnHash];
+  },
+  getJitFn(jitFnHash) {
+    const comp = jitFnsCache[jitFnHash];
+    if (!comp) throw new Error(`Jit function not found for jitFnHash ${jitFnHash}`);
+    return comp.fn;
+  },
+  hasJitFn(jitFnHash) {
+    return !!jitFnsCache[jitFnHash]?.fn;
+  },
+  /**
+   * Checks if key map can be serialized/deserialized with json and still works as a key for a map.
+   * ie: if a map key is an string, it can be serialized to json and deserialized back an still will identify the correct map entry.
+   * ie: if a map entry is an object, the object can not be serialized/deserialized and wont work as the same key for entry map as they are not same memory ref.
+   *  */
+  addPureFn(namespace, compiledFn) {
+    const fnHash = compiledFn.fnName;
+    if (!fnHash) throw new Error("Pure function must have a name and must be unique");
+    const nsCache = ensureNamespace(namespace);
+    const existing = nsCache[fnHash];
+    if (existing) {
+      if (existing.bodyHash && compiledFn.bodyHash && existing.bodyHash !== compiledFn.bodyHash) {
+        console.warn(
+          `Pure function ${namespace}::${fnHash} body hash mismatch. Existing: ${existing.bodyHash}, New: ${compiledFn.bodyHash}. Replacing with new version.`
+        );
+        nsCache[fnHash] = compiledFn;
+        return compiledFn;
+      }
+      return existing;
+    }
+    nsCache[fnHash] = compiledFn;
+    return compiledFn;
+  },
+  usePureFn(namespace, fnHash) {
+    const nsCache = pureFnsCache[namespace];
+    if (!nsCache) throw new Error(`Pure function namespace ${namespace} not found`);
+    const compiled = nsCache[fnHash];
+    if (!compiled) throw new Error(`Pure function with name ${fnHash} not found in namespace ${namespace}`);
+    initPureFunction(compiled);
+    return compiled.fn;
+  },
+  getPureFn(namespace, fnHash) {
+    const nsCache = pureFnsCache[namespace];
+    if (!nsCache) return;
+    const compiled = nsCache[fnHash];
+    if (!compiled) return;
+    initPureFunction(compiled);
+    return compiled.fn;
+  },
+  getCompiledPureFn(namespace, fnHash) {
+    const nsCache = pureFnsCache[namespace];
+    if (!nsCache) return;
+    return nsCache[fnHash];
+  },
+  hasPureFn(namespace, fnHash) {
+    const nsCache = pureFnsCache[namespace];
+    if (!nsCache) return false;
+    return !!nsCache[fnHash];
+  },
+  findCompiledPureFn(fnHash) {
+    for (const namespace of Object.keys(pureFnsCache)) {
+      const nsCache = pureFnsCache[namespace];
+      if (nsCache && nsCache[fnHash]) return nsCache[fnHash];
+    }
+    return void 0;
+  },
+  setSerializableClass(cls) {
+    const className = cls.name;
+    const existingClass = serializableClassRegistry.get(className);
+    if (existingClass && existingClass !== cls) throw new Error(`Deserializable Class ${className} already registered`);
+    serializableClassRegistry.set(className, cls);
+  },
+  useSerializeClass(className) {
+    const cls = serializableClassRegistry.get(className);
+    if (!cls) throw new Error(`Serializable class with name ${className} not found, be sure to register it first`);
+    return cls;
+  },
+  getSerializeClass(className) {
+    return serializableClassRegistry.get(className);
+  },
+  setDeserializeFn(cls, deserializeFn) {
+    const className = cls.name;
+    const fn = deserializeFnsRegistry.get(className);
+    if (fn && fn !== deserializeFn) throw new Error(`Deserialize function for class ${className} already exists`);
+    if (fn) return;
+    deserializeFnsRegistry.set(className, deserializeFn);
+  },
+  useDeserializeFn(className) {
+    const fn = deserializeFnsRegistry.get(className);
+    if (!fn) throw new Error(`Deserialize function for class ${className} not found, be sure to register it first`);
+    return fn;
+  },
+  getDeserializeFn(className) {
+    return deserializeFnsRegistry.get(className);
+  }
+};
+function getJitUtils() {
+  return jitUtils;
+}
+function addAOTCaches(aotFnsCache, aotPureCache) {
+  restoreCaches(aotFnsCache, aotPureCache);
+}
+function addSerializedJitCaches(jitDataFnsCache, pureFnsDataCache) {
+  restoreCaches(jitDataFnsCache, pureFnsDataCache);
+}
+function restoreCaches(fnsCache, pureCache) {
+  for (const key in fnsCache) {
+    if (!(key in jitFnsCache)) {
+      jitFnsCache[key] = { ...fnsCache[key] };
+    }
+  }
+  for (const namespace in pureCache) {
+    const nsCache = ensureNamespace(namespace);
+    const sourceNsCache = pureCache[namespace];
+    for (const key in sourceNsCache) {
+      const existing = nsCache[key];
+      const incoming = sourceNsCache[key];
+      if (existing) {
+        if (existing.bodyHash && incoming.bodyHash && existing.bodyHash !== incoming.bodyHash) {
+          console.warn(
+            `Pure function ${namespace}::${key} cache eviction: bodyHash mismatch (cached: ${existing.bodyHash}, server: ${incoming.bodyHash})`
+          );
+          nsCache[key] = { ...incoming };
+        }
+      } else {
+        nsCache[key] = { ...incoming };
+      }
+    }
+  }
+  restoreCompiledJitFns(jitFnsCache, pureFnsCache, getJitUtils());
+}
+function getJitFnCaches() {
+  return {
+    jitFnsCache,
+    pureFnsCache
+  };
+}
+function resetJitFnCaches() {
+  if (!isTestEnv()) throw new Error("resetJitFnCaches() can only be called fro testing purposes");
+  for (const k in jitFnsCache) delete jitFnsCache[k];
+  for (const k in pureFnsCache) delete pureFnsCache[k];
+  deserializeFnsRegistry.clear();
+  serializableClassRegistry.clear();
+}
+function ensureNamespace(namespace) {
+  if (!pureFnsCache[namespace]) {
+    pureFnsCache[namespace] = {};
+  }
+  return pureFnsCache[namespace];
+}
+export {
+  addAOTCaches,
+  addSerializedJitCaches,
+  getJitFnCaches,
+  getJitUtils,
+  resetJitFnCaches
+};
+//# sourceMappingURL=jitUtils.js.map

package/.dist/esm/src/jit/jitUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jitUtils.js","sources":["../../../../src/jit/jitUtils.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\nimport type {\n    JitCompiledFn,\n    JitFunctionsCache,\n    PureFunctionsCache,\n    PersistedPureFunctionsCache,\n    PureFnsDataCache,\n    DeserializeClassFn,\n    AnyClass,\n    SerializableClass,\n    PersistedJitFunctionsCache,\n    FnsDataCache,\n} from '../types/general.types.ts';\nimport {CompiledPureFunction} from '../types/pureFunctions.types.ts';\nimport {PureFunction} from '../types/pureFunctions.types.ts';\nimport {initPureFunction, isTestEnv} from '../utils.ts';\nimport {restoreCompiledJitFns} from '../pureFns/restoreJitFns.ts';\n\n// Local caches - can be populated from AOT caches via addAOTCaches()\nconst jitFnsCache: JitFunctionsCache = {};\n/** Namespaced pure functions cache: { namespace: { fnHash: CompiledPureFunction } } */\nconst pureFnsCache: PureFunctionsCache = {};\n\n// serializable classes registry, serializable classes can be automatically deserialized if they are registered here\nconst deserializeFnsRegistry = new Map<string, DeserializeClassFn<any>>();\nconst serializableClassRegistry = new Map<string, SerializableClass>();\n\n/**\n * Interface defining the shape of jitUtils\n *\n * !! Important: this needs to be defined as a type for reflection to work correctly\n * !! we can not use  typeof jitUtils\n */\nexport interface JITUtils {\n    /** optimized function to convert an string into a json string wrapped in double quotes */\n    addToJitCache(comp: JitCompiledFn): void;\n    removeFromJitCache(comp: JitCompiledFn): void;\n    getJIT(jitFnHash: string): JitCompiledFn | undefined;\n    getJitFn(jitFnHash: string): (...args: any[]) => any;\n    hasJitFn(jitFnHash: string): boolean;\n    addPureFn(namespace: string, compiledFn: CompiledPureFunction): void;\n    usePureFn(namespace: string, name: string): PureFunction;\n    getPureFn(namespace: string, name: string): PureFunction | undefined;\n    getCompiledPureFn(namespace: string, name: string): CompiledPureFunction | undefined;\n    hasPureFn(namespace: string, name: string): boolean;\n    /** Find a pure function across all namespaces. Returns the compiled function or undefined. */\n    findCompiledPureFn(name: string): CompiledPureFunction | undefined;\n    setSerializableClass<C extends SerializableClass>(cls: C): void;\n    useSerializeClass(className: string): SerializableClass;\n    getSerializeClass(className: string): SerializableClass | undefined;\n    setDeserializeFn<C extends AnyClass>(cls: C, deserializeFn: DeserializeClassFn<InstanceType<C>>): void;\n    useDeserializeFn(className: string): DeserializeClassFn<any>;\n    getDeserializeFn(className: string): DeserializeClassFn<any> | undefined;\n}\n\nconst jitUtils: JITUtils = {\n    addToJitCache(comp: JitCompiledFn) {\n        jitFnsCache[comp.jitFnHash] = comp;\n    },\n    removeFromJitCache(comp: JitCompiledFn) {\n        if (!jitFnsCache[comp.jitFnHash]) return;\n        (jitFnsCache[comp.jitFnHash] as any) = undefined;\n    },\n    getJIT(jitFnHash: string): JitCompiledFn | undefined {\n        return jitFnsCache[jitFnHash];\n    },\n    getJitFn(jitFnHash: string): (...args: any[]) => any {\n        const comp = jitFnsCache[jitFnHash];\n        if (!comp) throw new Error(`Jit function not found for jitFnHash ${jitFnHash}`);\n        return comp.fn;\n    },\n    hasJitFn(jitFnHash: string) {\n        return !!jitFnsCache[jitFnHash]?.fn;\n    },\n    /**\n     * Checks if key map can be serialized/deserialized with json and still works as a key for a map.\n     * ie: if a map key is an string, it can be serialized to json and deserialized back an still will identify the correct map entry.\n     * ie: if a map entry is an object, the object can not be serialized/deserialized and wont work as the same key for entry map as they are not same memory ref.\n     *  */\n\n    addPureFn(namespace: string, compiledFn: CompiledPureFunction): CompiledPureFunction {\n        const fnHash = compiledFn.fnName;\n        if (!fnHash) throw new Error('Pure function must have a name and must be unique');\n        const nsCache = ensureNamespace(namespace);\n        const existing = nsCache[fnHash];\n        if (existing) {\n            // Validate body hash matches - if not, this is a version conflict\n            if (existing.bodyHash && compiledFn.bodyHash && existing.bodyHash !== compiledFn.bodyHash) {\n                console.warn(\n                    `Pure function ${namespace}::${fnHash} body hash mismatch. ` +\n                        `Existing: ${existing.bodyHash}, New: ${compiledFn.bodyHash}. ` +\n                        `Replacing with new version.`\n                );\n                nsCache[fnHash] = compiledFn;\n                return compiledFn;\n            }\n            return existing;\n        }\n\n        nsCache[fnHash] = compiledFn;\n        return compiledFn;\n    },\n    usePureFn(namespace: string, fnHash: string): PureFunction {\n        const nsCache = pureFnsCache[namespace];\n        if (!nsCache) throw new Error(`Pure function namespace ${namespace} not found`);\n        const compiled = nsCache[fnHash];\n        if (!compiled) throw new Error(`Pure function with name ${fnHash} not found in namespace ${namespace}`);\n        initPureFunction(compiled);\n        return compiled.fn;\n    },\n    getPureFn(namespace: string, fnHash: string): PureFunction | undefined {\n        const nsCache = pureFnsCache[namespace];\n        if (!nsCache) return;\n        const compiled = nsCache[fnHash];\n        if (!compiled) return;\n        initPureFunction(compiled);\n        return compiled.fn;\n    },\n    getCompiledPureFn(namespace: string, fnHash: string): CompiledPureFunction | undefined {\n        const nsCache = pureFnsCache[namespace];\n        if (!nsCache) return;\n        return nsCache[fnHash];\n    },\n    hasPureFn(namespace: string, fnHash: string): boolean {\n        const nsCache = pureFnsCache[namespace];\n        if (!nsCache) return false;\n        return !!nsCache[fnHash];\n    },\n    findCompiledPureFn(fnHash: string): CompiledPureFunction | undefined {\n        for (const namespace of Object.keys(pureFnsCache)) {\n            const nsCache = pureFnsCache[namespace];\n            if (nsCache && nsCache[fnHash]) return nsCache[fnHash];\n        }\n        return undefined;\n    },\n    setSerializableClass<C extends SerializableClass>(cls: C) {\n        const className = cls.name;\n        const existingClass = serializableClassRegistry.get(className);\n        if (existingClass && existingClass !== cls) throw new Error(`Deserializable Class ${className} already registered`);\n        serializableClassRegistry.set(className, cls);\n    },\n    useSerializeClass(className: string): SerializableClass {\n        const cls = serializableClassRegistry.get(className);\n        if (!cls) throw new Error(`Serializable class with name ${className} not found, be sure to register it first`);\n        return cls;\n    },\n    getSerializeClass(className: string): SerializableClass | undefined {\n        return serializableClassRegistry.get(className);\n    },\n    setDeserializeFn<C extends AnyClass>(cls: C, deserializeFn: DeserializeClassFn<InstanceType<C>>) {\n        const className = cls.name;\n        const fn = deserializeFnsRegistry.get(className);\n        if (fn && fn !== deserializeFn) throw new Error(`Deserialize function for class ${className} already exists`);\n        if (fn) return;\n        deserializeFnsRegistry.set(className, deserializeFn);\n    },\n    useDeserializeFn(className: string): DeserializeClassFn<any> {\n        const fn = deserializeFnsRegistry.get(className);\n        if (!fn) throw new Error(`Deserialize function for class ${className} not found, be sure to register it first`);\n        return fn;\n    },\n    getDeserializeFn(className: string): DeserializeClassFn<any> | undefined {\n        return deserializeFnsRegistry.get(className);\n    },\n};\n\n/**\n * Returns the jitUtils instance.\n * This function provides access to the utilities used by JIT generated functions.\n * @returns The JITUtils instance\n */\nexport function getJitUtils(): JITUtils {\n    return jitUtils;\n}\n\n/**\n * Adds new AOT JIT and pure functions into the respective caches.\n * This function is intended to be used to restore JitFunctions there were serialized to src code (AOT caches)\n * @param aotFnsCache\n * @param aotPureCache - Namespaced pure functions cache\n */\nexport function addAOTCaches(aotFnsCache: PersistedJitFunctionsCache, aotPureCache: PersistedPureFunctionsCache) {\n    restoreCaches(aotFnsCache, aotPureCache);\n}\n\n/**\n * Adds new JIT and pure functions into the respective caches.\n * This function is intended to restore JitFunctions that were serialized and deserialized over the network\n * @param jitDataFnsCache\n * @param pureFnsDataCache - Namespaced pure functions cache\n */\nexport function addSerializedJitCaches(jitDataFnsCache: FnsDataCache, pureFnsDataCache: PureFnsDataCache) {\n    restoreCaches(jitDataFnsCache, pureFnsDataCache);\n}\n\nfunction restoreCaches(\n    fnsCache: PersistedJitFunctionsCache | FnsDataCache,\n    pureCache: PersistedPureFunctionsCache | PureFnsDataCache\n) {\n    // First load the caches so all entries are available in the global cache\n    // This is needed because createJitFn uses jitUtils.getJIT() to resolve dependencies\n    for (const key in fnsCache) {\n        if (!(key in jitFnsCache)) {\n            // it will be transformed into JitCompiledFn by restoreCompiledJitFns()\n            // Cloning to avoid mutating the original\n            jitFnsCache[key] = {...fnsCache[key]} as JitCompiledFn;\n        }\n    }\n    // Load namespaced pure functions with hash validation\n    for (const namespace in pureCache) {\n        const nsCache = ensureNamespace(namespace);\n        const sourceNsCache = pureCache[namespace];\n        for (const key in sourceNsCache) {\n            const existing = nsCache[key];\n            const incoming = sourceNsCache[key];\n\n            if (existing) {\n                // Validate body hash - evict if mismatch\n                if (existing.bodyHash && incoming.bodyHash && existing.bodyHash !== incoming.bodyHash) {\n                    console.warn(\n                        `Pure function ${namespace}::${key} cache eviction: ` +\n                            `bodyHash mismatch (cached: ${existing.bodyHash}, server: ${incoming.bodyHash})`\n                    );\n                    // Replace with incoming version\n                    nsCache[key] = {...incoming} as CompiledPureFunction;\n                }\n                // If hashes match or one is missing, keep existing\n            } else {\n                // No existing entry, add new one\n                nsCache[key] = {...incoming} as CompiledPureFunction;\n            }\n        }\n    }\n    // Then restore/initialize the functions (invoke createJitFn to set the fn property)\n    // Must restore on the global caches so that when createJitFn calls utl.getJIT() or utl.getPureFn()\n    // it gets the restored functions with fn property set\n    restoreCompiledJitFns(jitFnsCache, pureFnsCache, getJitUtils());\n}\n\n/**\n * Returns the jit and pure functions caches.\n * DO NOT MODIFY THE RETURNED OBJECTS AS THEY ARE THE ORIGINAL ONES USED BY THE JIT FUNCTIONS\n * @returns\n */\nexport function getJitFnCaches() {\n    return {\n        jitFnsCache: jitFnsCache as Readonly<JitFunctionsCache>,\n        pureFnsCache: pureFnsCache as Readonly<PureFunctionsCache>,\n    };\n}\n\n/**\n * Resets the jit and pure functions caches.\n * This is useful for testing purposes only.\n * Note: After calling this, AOT caches must be re-registered via virtual modules or addAOTCaches().\n */\nexport function resetJitFnCaches() {\n    if (!isTestEnv()) throw new Error('resetJitFnCaches() can only be called fro testing purposes');\n    for (const k in jitFnsCache) delete jitFnsCache[k];\n    for (const k in pureFnsCache) delete pureFnsCache[k];\n    deserializeFnsRegistry.clear();\n    serializableClassRegistry.clear();\n}\n\n/** Helper function to ensure namespace exists in the cache */\nfunction ensureNamespace(namespace: string): Record<string, CompiledPureFunction> {\n    if (!pureFnsCache[namespace]) {\n        pureFnsCache[namespace] = {};\n    }\n    return pureFnsCache[namespace];\n}\n"],"names":[],"mappings":";;AAwBA,MAAM,cAAiC,CAAA;AAEvC,MAAM,eAAmC,CAAA;AAGzC,MAAM,6CAA6B,IAAA;AACnC,MAAM,gDAAgC,IAAA;AA8BtC,MAAM,WAAqB;AAAA,EACvB,cAAc,MAAqB;AAC/B,gBAAY,KAAK,SAAS,IAAI;AAAA,EAClC;AAAA,EACA,mBAAmB,MAAqB;AACpC,QAAI,CAAC,YAAY,KAAK,SAAS,EAAG;AACjC,gBAAY,KAAK,SAAS,IAAY;AAAA,EAC3C;AAAA,EACA,OAAO,WAA8C;AACjD,WAAO,YAAY,SAAS;AAAA,EAChC;AAAA,EACA,SAAS,WAA4C;AACjD,UAAM,OAAO,YAAY,SAAS;AAClC,QAAI,CAAC,KAAM,OAAM,IAAI,MAAM,wCAAwC,SAAS,EAAE;AAC9E,WAAO,KAAK;AAAA,EAChB;AAAA,EACA,SAAS,WAAmB;AACxB,WAAO,CAAC,CAAC,YAAY,SAAS,GAAG;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,UAAU,WAAmB,YAAwD;AACjF,UAAM,SAAS,WAAW;AAC1B,QAAI,CAAC,OAAQ,OAAM,IAAI,MAAM,mDAAmD;AAChF,UAAM,UAAU,gBAAgB,SAAS;AACzC,UAAM,WAAW,QAAQ,MAAM;AAC/B,QAAI,UAAU;AAEV,UAAI,SAAS,YAAY,WAAW,YAAY,SAAS,aAAa,WAAW,UAAU;AACvF,gBAAQ;AAAA,UACJ,iBAAiB,SAAS,KAAK,MAAM,kCACpB,SAAS,QAAQ,UAAU,WAAW,QAAQ;AAAA,QAAA;AAGnE,gBAAQ,MAAM,IAAI;AAClB,eAAO;AAAA,MACX;AACA,aAAO;AAAA,IACX;AAEA,YAAQ,MAAM,IAAI;AAClB,WAAO;AAAA,EACX;AAAA,EACA,UAAU,WAAmB,QAA8B;AACvD,UAAM,UAAU,aAAa,SAAS;AACtC,QAAI,CAAC,QAAS,OAAM,IAAI,MAAM,2BAA2B,SAAS,YAAY;AAC9E,UAAM,WAAW,QAAQ,MAAM;AAC/B,QAAI,CAAC,SAAU,OAAM,IAAI,MAAM,2BAA2B,MAAM,2BAA2B,SAAS,EAAE;AACtG,qBAAiB,QAAQ;AACzB,WAAO,SAAS;AAAA,EACpB;AAAA,EACA,UAAU,WAAmB,QAA0C;AACnE,UAAM,UAAU,aAAa,SAAS;AACtC,QAAI,CAAC,QAAS;AACd,UAAM,WAAW,QAAQ,MAAM;AAC/B,QAAI,CAAC,SAAU;AACf,qBAAiB,QAAQ;AACzB,WAAO,SAAS;AAAA,EACpB;AAAA,EACA,kBAAkB,WAAmB,QAAkD;AACnF,UAAM,UAAU,aAAa,SAAS;AACtC,QAAI,CAAC,QAAS;AACd,WAAO,QAAQ,MAAM;AAAA,EACzB;AAAA,EACA,UAAU,WAAmB,QAAyB;AAClD,UAAM,UAAU,aAAa,SAAS;AACtC,QAAI,CAAC,QAAS,QAAO;AACrB,WAAO,CAAC,CAAC,QAAQ,MAAM;AAAA,EAC3B;AAAA,EACA,mBAAmB,QAAkD;AACjE,eAAW,aAAa,OAAO,KAAK,YAAY,GAAG;AAC/C,YAAM,UAAU,aAAa,SAAS;AACtC,UAAI,WAAW,QAAQ,MAAM,EAAG,QAAO,QAAQ,MAAM;AAAA,IACzD;AACA,WAAO;AAAA,EACX;AAAA,EACA,qBAAkD,KAAQ;AACtD,UAAM,YAAY,IAAI;AACtB,UAAM,gBAAgB,0BAA0B,IAAI,SAAS;AAC7D,QAAI,iBAAiB,kBAAkB,IAAK,OAAM,IAAI,MAAM,wBAAwB,SAAS,qBAAqB;AAClH,8BAA0B,IAAI,WAAW,GAAG;AAAA,EAChD;AAAA,EACA,kBAAkB,WAAsC;AACpD,UAAM,MAAM,0BAA0B,IAAI,SAAS;AACnD,QAAI,CAAC,IAAK,OAAM,IAAI,MAAM,gCAAgC,SAAS,0CAA0C;AAC7G,WAAO;AAAA,EACX;AAAA,EACA,kBAAkB,WAAkD;AAChE,WAAO,0BAA0B,IAAI,SAAS;AAAA,EAClD;AAAA,EACA,iBAAqC,KAAQ,eAAoD;AAC7F,UAAM,YAAY,IAAI;AACtB,UAAM,KAAK,uBAAuB,IAAI,SAAS;AAC/C,QAAI,MAAM,OAAO,cAAe,OAAM,IAAI,MAAM,kCAAkC,SAAS,iBAAiB;AAC5G,QAAI,GAAI;AACR,2BAAuB,IAAI,WAAW,aAAa;AAAA,EACvD;AAAA,EACA,iBAAiB,WAA4C;AACzD,UAAM,KAAK,uBAAuB,IAAI,SAAS;AAC/C,QAAI,CAAC,GAAI,OAAM,IAAI,MAAM,kCAAkC,SAAS,0CAA0C;AAC9G,WAAO;AAAA,EACX;AAAA,EACA,iBAAiB,WAAwD;AACrE,WAAO,uBAAuB,IAAI,SAAS;AAAA,EAC/C;AACJ;AAOO,SAAS,cAAwB;AACpC,SAAO;AACX;AAQO,SAAS,aAAa,aAAyC,cAA2C;AAC7G,gBAAc,aAAa,YAAY;AAC3C;AAQO,SAAS,uBAAuB,iBAA+B,kBAAoC;AACtG,gBAAc,iBAAiB,gBAAgB;AACnD;AAEA,SAAS,cACL,UACA,WACF;AAGE,aAAW,OAAO,UAAU;AACxB,QAAI,EAAE,OAAO,cAAc;AAGvB,kBAAY,GAAG,IAAI,EAAC,GAAG,SAAS,GAAG,EAAA;AAAA,IACvC;AAAA,EACJ;AAEA,aAAW,aAAa,WAAW;AAC/B,UAAM,UAAU,gBAAgB,SAAS;AACzC,UAAM,gBAAgB,UAAU,SAAS;AACzC,eAAW,OAAO,eAAe;AAC7B,YAAM,WAAW,QAAQ,GAAG;AAC5B,YAAM,WAAW,cAAc,GAAG;AAElC,UAAI,UAAU;AAEV,YAAI,SAAS,YAAY,SAAS,YAAY,SAAS,aAAa,SAAS,UAAU;AACnF,kBAAQ;AAAA,YACJ,iBAAiB,SAAS,KAAK,GAAG,+CACA,SAAS,QAAQ,aAAa,SAAS,QAAQ;AAAA,UAAA;AAGrF,kBAAQ,GAAG,IAAI,EAAC,GAAG,SAAA;AAAA,QACvB;AAAA,MAEJ,OAAO;AAEH,gBAAQ,GAAG,IAAI,EAAC,GAAG,SAAA;AAAA,MACvB;AAAA,IACJ;AAAA,EACJ;AAIA,wBAAsB,aAAa,cAAc,aAAa;AAClE;AAOO,SAAS,iBAAiB;AAC7B,SAAO;AAAA,IACH;AAAA,IACA;AAAA,EAAA;AAER;AAOO,SAAS,mBAAmB;AAC/B,MAAI,CAAC,UAAA,EAAa,OAAM,IAAI,MAAM,4DAA4D;AAC9F,aAAW,KAAK,YAAa,QAAO,YAAY,CAAC;AACjD,aAAW,KAAK,aAAc,QAAO,aAAa,CAAC;AACnD,yBAAuB,MAAA;AACvB,4BAA0B,MAAA;AAC9B;AAGA,SAAS,gBAAgB,WAAyD;AAC9E,MAAI,CAAC,aAAa,SAAS,GAAG;AAC1B,iBAAa,SAAS,IAAI,CAAA;AAAA,EAC9B;AACA,SAAO,aAAa,SAAS;AACjC;"}

package/.dist/esm/src/pureFns/pureFn.d.ts

@@ -0,0 +1,2 @@
+import { CompiledPureFunction, ParsedFactoryFn, PureFunctionFactory } from '../types/pureFunctions.types.ts';
+export declare function registerPureFnFactory(namespace: string, functionID: string, createPureFn: PureFunctionFactory, parsedFn?: ParsedFactoryFn): CompiledPureFunction;

package/.dist/esm/src/pureFns/pureFn.js

@@ -0,0 +1,80 @@
+import { getJitUtils } from "../jit/jitUtils.js";
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+function registerPureFnFactory(namespace, functionID, createPureFn, parsedFn) {
+  if (!parsedFn)
+    throw new Error("registerPureFnFactory requires mion vite plugin transform to inject parsedFn");
+  const existing = getJitUtils().getCompiledPureFn(namespace, functionID);
+  if (existing)
+    return existing;
+  const compiled = {
+    createPureFn,
+    fn: null,
+    // will be set later so all possible dependencies are resolved
+    namespace,
+    fnName: functionID,
+    bodyHash: parsedFn.bodyHash,
+    paramNames: parsedFn.paramNames,
+    code: parsedFn.code,
+    pureFnDependencies: []
+  };
+  const { proxy, getDependencies } = createDependencyTrackingProxy();
+  try {
+    createPureFn(proxy);
+  } catch {
+  }
+  const detectedDeps = getDependencies();
+  for (const dep of detectedDeps) {
+    if (dep === functionID)
+      continue;
+    if (!compiled.pureFnDependencies.includes(dep))
+      compiled.pureFnDependencies.push(dep);
+  }
+  getJitUtils().addPureFn(namespace, compiled);
+  return compiled;
+}
+registerPureFnFactory.__type = ["namespace", "functionID", "PureFunctionFactory", "createPureFn", "ParsedFactoryFn", "parsedFn", "CompiledPureFunction", "registerPureFnFactory", `P&2!&2""w#2$"w%2&8"w'/(`];
+function createDependencyTrackingProxy() {
+  const dependencies = (Set.Ω = [["&"]], /* @__PURE__ */ new Set());
+  const realUtils = getJitUtils();
+  const noopFn = () => () => {
+  };
+  const proxy = new Proxy(realUtils, {
+    get(target, prop, receiver) {
+      if (prop === "getPureFn" || prop === "usePureFn") {
+        return __assignType((ns, fnName) => {
+          dependencies.add(fnName);
+          const real = target.getPureFn(ns, fnName);
+          return real ?? noopFn;
+        }, ["ns", "fnName", "", 'P&2!&2""/#']);
+      }
+      if (prop === "getCompiledPureFn") {
+        return __assignType((ns, fnName) => {
+          dependencies.add(fnName);
+          return target.getCompiledPureFn(ns, fnName);
+        }, ["ns", "fnName", "", 'P&2!&2""/#']);
+      }
+      if (prop === "hasPureFn") {
+        return __assignType((ns, fnName) => {
+          dependencies.add(fnName);
+          return target.hasPureFn(ns, fnName);
+        }, ["ns", "fnName", "", 'P&2!&2""/#']);
+      }
+      if (prop === "findCompiledPureFn") {
+        return __assignType((fnName) => {
+          dependencies.add(fnName);
+          return target.findCompiledPureFn(fnName);
+        }, ["fnName", "", 'P&2!"/"']);
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+  return { proxy, getDependencies: () => dependencies };
+}
+createDependencyTrackingProxy.__type = ["JITUtils", "proxy", "", "getDependencies", "createDependencyTrackingProxy", 'PP"w!4"P&D/#4$M/%'];
+export {
+  registerPureFnFactory
+};
+//# sourceMappingURL=pureFn.js.map

package/.dist/esm/src/pureFns/pureFn.js.map

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

package/.dist/esm/src/pureFns/pureServerFn.d.ts

@@ -0,0 +1,4 @@
+import { PureFnDef, PureServerFnRef } from '../types/pureFunctions.types.ts';
+export declare const PURE_SERVER_FN_NAMESPACE = "pureServerFn";
+export declare function pureServerFn<F extends (...args: any[]) => any>(pureFn: F, bodyHash?: string): PureServerFnRef<F>;
+export declare function pureServerFn<F extends (...args: any[]) => any>(def: PureFnDef<F>, bodyHash?: string): PureServerFnRef<F>;

package/.dist/esm/src/pureFns/pureServerFn.js

@@ -0,0 +1,20 @@
+import { __ΩPureServerFnRef as ___PureServerFnRef, __ΩPureFnDef as ___PureFnDef } from "../types/pureFunctions.types.js";
+const PURE_SERVER_FN_NAMESPACE = "pureServerFn";
+pureServerFn.__type = ["pureFn", "bodyHash", () => ___PureServerFnRef, "pureServerFn", 'P"2!&2"8"o#"/$'];
+pureServerFn.__type = [() => ___PureFnDef, "def", "bodyHash", () => ___PureServerFnRef, "pureServerFn", 'P"o!"2"&2#8"o$"/%'];
+function pureServerFn(defOrFn, bodyHash) {
+  if (!bodyHash)
+    throw new Error("pureServerFn requires mion vite plugin transform to inject bodyHash");
+  const isFn = typeof defOrFn === "function";
+  const def = isFn ? { pureFn: defOrFn, fnName: bodyHash } : defOrFn;
+  const namespace = def.namespace || PURE_SERVER_FN_NAMESPACE;
+  const fnName = def.fnName || def.pureFn.name || bodyHash;
+  const isFactory = def.isFactory || false;
+  return { namespace, fnName, bodyHash, pureFn: def.pureFn, isFactory };
+}
+pureServerFn.__type = [() => ___PureFnDef, "defOrFn", "bodyHash", () => ___PureServerFnRef, "pureServerFn", 'PP"o!""J2"&2#8"o$"/%'];
+export {
+  PURE_SERVER_FN_NAMESPACE,
+  pureServerFn
+};
+//# sourceMappingURL=pureServerFn.js.map

package/.dist/esm/src/pureFns/pureServerFn.js.map

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

package/.dist/esm/src/pureFns/quickHash.d.ts

@@ -0,0 +1,7 @@
+export declare const hashDefaultLength = 6;
+export declare const defaultLiteralLength = 5;
+export declare const pureFnHashLength = 8;
+export declare function quickHash(input: string, length?: number, prevResult?: string): string;
+export declare function createUniqueHash(id: string, length?: number, isLiteral?: boolean): string;
+export declare function createHashLiteral(id: string, length?: number): string;
+export declare function resetHashes(): void;

package/.dist/esm/src/pureFns/quickHash.js

@@ -0,0 +1,62 @@
+import { getENV } from "../utils.js";
+const hashes = /* @__PURE__ */ new Map();
+const literalHashes = /* @__PURE__ */ new Map();
+const hashChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+const alphaChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+const hashIncrement = 2;
+const maxHashCollisions = 22;
+const PRIME = 37;
+const hashDefaultLength = 6;
+const defaultLiteralLength = 5;
+const pureFnHashLength = 8;
+function quickHash(input, length = hashDefaultLength, prevResult) {
+  let hash = 0;
+  for (let i = 0; i < input.length; i++) {
+    hash = Math.imul(hash, PRIME) + input.charCodeAt(i) >>> 0;
+  }
+  let result = prevResult || "";
+  hash = Math.imul(hash, PRIME) >>> 0;
+  result += alphaChars.charAt(hash % alphaChars.length);
+  while (result.length < length) {
+    hash = Math.imul(hash, PRIME) >>> 0;
+    result += hashChars.charAt(hash % hashChars.length);
+  }
+  return result.slice(0, length);
+}
+function createUniqueHash(id, length = hashDefaultLength, isLiteral = false) {
+  const dictionary = isLiteral ? literalHashes : hashes;
+  let hash = quickHash(id, length);
+  let counter = 1;
+  let existingId = dictionary.get(hash);
+  while (existingId && existingId !== id) {
+    length += counter * hashIncrement;
+    const newId = quickHash(id, length, hash);
+    if (getENV("DEBUG_JIT"))
+      console.warn(
+        `Collision for typeID: ${id} with extended hash: ${newId}, and existing typeID: ${existingId} with hash: ${hash}`
+      );
+    hash = newId;
+    counter++;
+    existingId = dictionary.get(hash);
+    if (counter > maxHashCollisions) throw new Error(`Cannot generate unique hash for typeID: ${id} too many collisions.`);
+  }
+  dictionary.set(hash, id);
+  return hash;
+}
+function createHashLiteral(id, length = defaultLiteralLength) {
+  return createUniqueHash(id, length, true);
+}
+function resetHashes() {
+  hashes.clear();
+  literalHashes.clear();
+}
+export {
+  createHashLiteral,
+  createUniqueHash,
+  defaultLiteralLength,
+  hashDefaultLength,
+  pureFnHashLength,
+  quickHash,
+  resetHashes
+};
+//# sourceMappingURL=quickHash.js.map

package/.dist/esm/src/pureFns/quickHash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quickHash.js","sources":["../../../../src/pureFns/quickHash.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 {getENV} from '../utils.ts';\n\nconst hashes = new Map<string, string>();\nconst literalHashes = new Map<string, string>();\nconst hashChars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';\nconst alphaChars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';\nconst hashIncrement = 2;\nconst maxHashCollisions = 22;\nconst PRIME = 37; // Prime number to mix hash robustly, but quick\n// TODO: investigate if this is a good default length, we want short hashes for small code size but long enough to avoid to many collisions\n// variable hash length avoids collisions, so there shouldn't be any problems. but better to keep an eye on it\nexport const hashDefaultLength = 6;\nexport const defaultLiteralLength = 5;\n/** Hash length used for pure function body hashes */\nexport const pureFnHashLength = 8;\n\nexport function quickHash(input: string, length = hashDefaultLength, prevResult?: string): string {\n    let hash = 0;\n    // Generate initial numeric hash using Math.imul and forcing unsigned 32-bit arithmetic\n    for (let i = 0; i < input.length; i++) {\n        hash = (Math.imul(hash, PRIME) + input.charCodeAt(i)) >>> 0;\n    }\n    let result = prevResult || '';\n    // First char is always from alphaChars to have a valid variable name\n    hash = Math.imul(hash, PRIME) >>> 0;\n    result += alphaChars.charAt(hash % alphaChars.length);\n    // Convert numeric hash to a short alphanumeric string\n    while (result.length < length) {\n        hash = Math.imul(hash, PRIME) >>> 0;\n        result += hashChars.charAt(hash % hashChars.length);\n    }\n    return result.slice(0, length);\n}\n\nexport function createUniqueHash(id: string, length = hashDefaultLength, isLiteral = false): string {\n    const dictionary = isLiteral ? literalHashes : hashes;\n    let hash = quickHash(id, length);\n    let counter = 1;\n    let existingId = dictionary.get(hash);\n    // Check if ID already exists and corresponds to the same input\n    while (existingId && existingId !== id) {\n        length += counter * hashIncrement;\n        // generates a longer hash if there are collisions\n        // this would allow trying to get all possible hashes for a given input just by increasing the length\n        const newId = quickHash(id, length, hash);\n        if (getENV('DEBUG_JIT'))\n            console.warn(\n                `Collision for typeID: ${id} with extended hash: ${newId}, and existing typeID: ${existingId} with hash: ${hash}`\n            );\n        hash = newId;\n        counter++;\n        existingId = dictionary.get(hash);\n        if (counter > maxHashCollisions) throw new Error(`Cannot generate unique hash for typeID: ${id} too many collisions.`);\n    }\n\n    // Store the unique ID with its original input string\n    dictionary.set(hash, id);\n    // console.log(`Jit ID: ${typeID} with hash: ${id}`);\n    return hash;\n}\n\nexport function createHashLiteral(id: string, length = defaultLiteralLength): string {\n    return createUniqueHash(id, length, true);\n}\n\n/** Resets the hash dictionaries. Useful for testing to ensure consistent hash generation. */\nexport function resetHashes(): void {\n    hashes.clear();\n    literalHashes.clear();\n}\n"],"names":[],"mappings":";AASA,MAAM,6BAAa,IAAA;AACnB,MAAM,oCAAoB,IAAA;AAC1B,MAAM,YAAY;AAClB,MAAM,aAAa;AACnB,MAAM,gBAAgB;AACtB,MAAM,oBAAoB;AAC1B,MAAM,QAAQ;AAGP,MAAM,oBAAoB;AAC1B,MAAM,uBAAuB;AAE7B,MAAM,mBAAmB;AAEzB,SAAS,UAAU,OAAe,SAAS,mBAAmB,YAA6B;AAC9F,MAAI,OAAO;AAEX,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,WAAQ,KAAK,KAAK,MAAM,KAAK,IAAI,MAAM,WAAW,CAAC,MAAO;AAAA,EAC9D;AACA,MAAI,SAAS,cAAc;AAE3B,SAAO,KAAK,KAAK,MAAM,KAAK,MAAM;AAClC,YAAU,WAAW,OAAO,OAAO,WAAW,MAAM;AAEpD,SAAO,OAAO,SAAS,QAAQ;AAC3B,WAAO,KAAK,KAAK,MAAM,KAAK,MAAM;AAClC,cAAU,UAAU,OAAO,OAAO,UAAU,MAAM;AAAA,EACtD;AACA,SAAO,OAAO,MAAM,GAAG,MAAM;AACjC;AAEO,SAAS,iBAAiB,IAAY,SAAS,mBAAmB,YAAY,OAAe;AAChG,QAAM,aAAa,YAAY,gBAAgB;AAC/C,MAAI,OAAO,UAAU,IAAI,MAAM;AAC/B,MAAI,UAAU;AACd,MAAI,aAAa,WAAW,IAAI,IAAI;AAEpC,SAAO,cAAc,eAAe,IAAI;AACpC,cAAU,UAAU;AAGpB,UAAM,QAAQ,UAAU,IAAI,QAAQ,IAAI;AACxC,QAAI,OAAO,WAAW;AAClB,cAAQ;AAAA,QACJ,yBAAyB,EAAE,wBAAwB,KAAK,0BAA0B,UAAU,eAAe,IAAI;AAAA,MAAA;AAEvH,WAAO;AACP;AACA,iBAAa,WAAW,IAAI,IAAI;AAChC,QAAI,UAAU,kBAAmB,OAAM,IAAI,MAAM,2CAA2C,EAAE,uBAAuB;AAAA,EACzH;AAGA,aAAW,IAAI,MAAM,EAAE;AAEvB,SAAO;AACX;AAEO,SAAS,kBAAkB,IAAY,SAAS,sBAA8B;AACjF,SAAO,iBAAiB,IAAI,QAAQ,IAAI;AAC5C;AAGO,SAAS,cAAoB;AAChC,SAAO,MAAA;AACP,gBAAc,MAAA;AAClB;"}

package/.dist/esm/src/pureFns/restoreJitFns.d.ts

@@ -0,0 +1,3 @@
+import { PersistedJitFunctionsCache, PersistedPureFunctionsCache, FnsDataCache, PureFnsDataCache, PureFunctionsCache } from '../types/general.types.ts';
+import { JITUtils } from '../jit/jitUtils.ts';
+export declare function restoreCompiledJitFns(jitCache: PersistedJitFunctionsCache | FnsDataCache, pureCache: PureFunctionsCache | PersistedPureFunctionsCache | PureFnsDataCache, jUtil: JITUtils): void;

package/.dist/esm/src/pureFns/restoreJitFns.js

@@ -0,0 +1,88 @@
+import { TypedError } from "../errors.js";
+function restoreCompiledJitFns(jitCache, pureCache, jUtil) {
+  const visitedPure = /* @__PURE__ */ new Set();
+  const visitedJit = /* @__PURE__ */ new Set();
+  for (const namespace in pureCache) {
+    const nsCache = pureCache[namespace];
+    const keysPureFns = Object.keys(nsCache);
+    keysPureFns.forEach((key) => restoreCompiledPureFn(pureCache, namespace, key, jUtil, visitedPure));
+  }
+  const keysJitFns = Object.keys(jitCache);
+  keysJitFns.forEach((key) => restoreCompiledJitFn(jitCache, pureCache, key, jUtil, visitedPure, visitedJit));
+}
+function restoreCompiledPureFn(pureCache, namespace, fnName, jUtil, visited) {
+  const visitedKey = `${namespace}:${fnName}`;
+  if (visited.has(visitedKey)) return;
+  visited.add(visitedKey);
+  const nsCache = pureCache[namespace];
+  if (!nsCache) throw new Error(`Pure function namespace ${namespace} not found`);
+  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;
+  dependencies.forEach((depName) => restoreCompiledPureFn(pureCache, namespace, depName, jUtil, visited));
+  if (pureCompiled.createPureFn) {
+    pureCompiled.fn = pureCompiled.createPureFn(jUtil);
+    return;
+  }
+  restorePureFunction(pureCompiled, jUtil);
+}
+function restoreCompiledJitFn(jitCache, pureCache, fnHash, jUtil, visitedPure, visitedJit) {
+  if (visitedJit.has(fnHash)) return;
+  visitedJit.add(fnHash);
+  const jitCompiled = jitCache[fnHash];
+  if (!jitCompiled) throw new Error(`Jit function ${fnHash} not found`);
+  if (jitCompiled.fn) return;
+  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;
+  dependencies.forEach((dep) => restoreCompiledJitFn(jitCache, pureCache, dep, jUtil, visitedPure, visitedJit));
+  if (jitCompiled.createJitFn) {
+    jitCompiled.fn = jitCompiled.createJitFn(jUtil);
+    return;
+  }
+  restoreCreateJitFn(jitCompiled, jUtil);
+}
+function restoreCreateJitFn(fnData, jUtil) {
+  const fnName = fnData.jitFnHash;
+  const fnWithContext = `'use strict'; ${fnData.code}`;
+  try {
+    const wrapperWithContext = new Function("utl", fnWithContext);
+    const fn = wrapperWithContext(jUtil);
+    const jitFn = fnData;
+    jitFn.createJitFn = wrapperWithContext;
+    jitFn.fn = fn;
+    return jitFn;
+  } catch (e) {
+    throw new TypedError({
+      type: "jit-fn-restore-error",
+      message: `Failed to restore JIT function ${fnName}: ${e?.message}`
+    });
+  }
+}
+function restorePureFunction(pureFnData, jUtil) {
+  const fnName = pureFnData.fnName;
+  const fnWithContext = `'use strict'; ${pureFnData.code}`;
+  try {
+    const wrapperWithContext = new Function("utl", fnWithContext);
+    const fn = wrapperWithContext(jUtil);
+    const pureFn = pureFnData;
+    pureFn.createPureFn = wrapperWithContext;
+    pureFn.fn = fn;
+    return pureFn;
+  } catch (e) {
+    throw new TypedError({
+      type: "pure-fn-restore-error",
+      message: `Failed to restore pure function ${fnName}: ${e?.message}`
+    });
+  }
+}
+export {
+  restoreCompiledJitFns
+};
+//# sourceMappingURL=restoreJitFns.js.map

package/.dist/esm/src/pureFns/restoreJitFns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"restoreJitFns.js","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"],"mappings":"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"}

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

@@ -0,0 +1,24 @@
+import { RemoteMethodOpts, MethodWithOptions, MethodsCache, MethodWithOptsAndJitFns } from './types/method.types.ts';
+import { CoreRouterOptions, JitCompiledFunctions, JitFunctionsHashes } from './types/general.types.ts';
+export declare const routesCache: {
+    getMetadata(id: string): MethodWithOptions | undefined;
+    setMetadata(id: string, methodData: MethodWithOptions): void;
+    hasMetadata(id: string): boolean;
+    getCache(): MethodsCache;
+    getMethodJitFns(id: string): MethodWithOptsAndJitFns | undefined;
+    useMethodJitFns(id: string): MethodWithOptsAndJitFns;
+    setMethodJitFns(id: string, MethodWithOptsAndJitFns: MethodWithOptsAndJitFns): void;
+};
+export declare const methodOptsCache: {
+    getMethodOptions(id: string): RemoteMethodOpts | undefined;
+    setMethodOptions(id: string, options: RemoteMethodOpts): void;
+};
+export declare function addRoutesToCache(newCache: MethodsCache): void;
+export declare function getJitFnHashes(jitHash: string): 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;
+export declare function getRoutePath(pathPointer: string[], routerOptions: CoreRouterOptions): string;
+export declare function resetRoutesCache(): void;
+export declare function resetJitFunctionsCache(): void;
+export declare function getNoopJitFns(): JitCompiledFunctions;