@mionjs/core 0.8.0-alpha.0

package/.dist/cjs/src/friendlyErrors.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"friendlyErrors.cjs","sources":["../../../src/friendlyErrors.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    RunTypeError,\n    StrNumber,\n    PathSegment,\n    MapKeyPathSegment,\n    MapValuePathSegment,\n    SetItemPathSegment,\n} from './types/general.types.ts';\nimport type {\n    FriendlyErrors,\n    FriendlyErrorsResult,\n    AnyFriendlyErrorParams,\n    TypeErrorParam,\n} from './types/formats/friendlyErrors.types.ts';\nimport {isTestEnv} from './utils.ts';\n\n// ============================================================================\n// Map/Set Path Type Guards\n// ============================================================================\n\n/** Check if a path segment is a Map key error */\nfunction isMapKeyPath(segment: unknown): segment is MapKeyPathSegment {\n    return (\n        typeof segment === 'object' &&\n        segment !== null &&\n        'failed' in segment &&\n        (segment as MapKeyPathSegment).failed === 'mapKey'\n    );\n}\n\n/** Check if a path segment is a Map value error */\nfunction isMapValuePath(segment: unknown): segment is MapValuePathSegment {\n    return (\n        typeof segment === 'object' &&\n        segment !== null &&\n        'failed' in segment &&\n        (segment as MapValuePathSegment).failed === 'mapVal'\n    );\n}\n\n/** Check if a path segment is a Set item error (has key and index but no failed property) */\nfunction isSetItemPath(segment: unknown): segment is SetItemPathSegment {\n    return typeof segment === 'object' && segment !== null && 'key' in segment && 'index' in segment && !('failed' in segment);\n}\n\n// ============================================================================\n// Default Error Printer\n// ============================================================================\n\n/**\n * Default error message generator used when no handler is provided.\n * Generates a human-readable message from the RunTypeError.\n * Uses only the last item in the path (the property that failed).\n */\nexport function defaultErrorPrinter(error: RunTypeError): string {\n    const lastSegment = error.path.length > 0 ? error.path[error.path.length - 1] : 'value';\n\n    // Handle Map/Set path segments\n    let prop: StrNumber;\n    if (isMapKeyPath(lastSegment)) {\n        prop = `mapKey[${lastSegment.index}]`;\n    } else if (isMapValuePath(lastSegment)) {\n        prop = `mapValue[${lastSegment.index}]`;\n    } else if (isSetItemPath(lastSegment)) {\n        prop = `setItem[${lastSegment.index}]`;\n    } else {\n        prop = lastSegment as StrNumber;\n    }\n\n    if (error.format) {\n        const param = error.format.formatPath[0];\n        return `${prop}: ${param} validation failed (expected ${error.format.val})`;\n    }\n    return `${prop}: expected ${error.expected}`;\n}\n\n// ============================================================================\n// Aggregated Error Params\n// ============================================================================\n\n/**\n * Aggregated error params for a single field.\n * Contains all format errors merged together plus the base TypeErrorParam fields.\n */\ntype AggregatedErrorParams = TypeErrorParam & {\n    /** All RunTypeErrors for this field */\n    rtErrors: RunTypeError[];\n    /** For Map errors: whether this is a key or value error */\n    mapErrorType?: 'key' | 'value';\n};\n\n/**\n * Merges a RunTypeError into an existing aggregated params object.\n * If error has format, adds the format param key to the object.\n */\nfunction mergeErrorIntoParams(params: AggregatedErrorParams, error: RunTypeError): void {\n    params.rtErrors.push(error);\n    // Update rtError to the latest error (for backward compatibility)\n    params.rtError = error;\n    if (error.format) {\n        const paramKey = error.format.formatPath[0];\n        (params as Record<string, unknown>)[paramKey] = error.format;\n    }\n}\n\n/**\n * Creates initial aggregated error params from a RunTypeError.\n */\nfunction createAggregatedParams(error: RunTypeError): AggregatedErrorParams {\n    const lastSegment = error.path[error.path.length - 1];\n\n    let propName: string | number;\n    let index: number | undefined;\n    let mapErrorType: 'key' | 'value' | undefined;\n\n    if (isMapKeyPath(lastSegment)) {\n        propName = lastSegment.index;\n        index = lastSegment.index;\n        mapErrorType = 'key';\n    } else if (isMapValuePath(lastSegment)) {\n        propName = lastSegment.index;\n        index = lastSegment.index;\n        mapErrorType = 'value';\n    } else if (isSetItemPath(lastSegment)) {\n        propName = lastSegment.index;\n        index = lastSegment.index;\n    } else {\n        propName = lastSegment as StrNumber;\n        index = typeof propName === 'number' ? propName : undefined;\n    }\n\n    const params: AggregatedErrorParams = {\n        rtError: error,\n        rtErrors: [error],\n        propName,\n        index,\n        mapErrorType,\n    };\n\n    if (error.format) {\n        const paramKey = error.format.formatPath[0];\n        (params as Record<string, unknown>)[paramKey] = error.format;\n    }\n\n    return params;\n}\n\n// ============================================================================\n// Path Utilities\n// ============================================================================\n\n/**\n * Converts a path array to a string key for grouping errors.\n * Handles Map/Set path segments by converting them to a string representation.\n */\nfunction pathToKey(path: PathSegment[]): string {\n    return path\n        .map((segment) => {\n            if (isMapKeyPath(segment)) {\n                return `$mapKey[${segment.index}]`;\n            } else if (isMapValuePath(segment)) {\n                return `$mapVal[${segment.index}]`;\n            } else if (isSetItemPath(segment)) {\n                return `$setItem[${segment.index}]`;\n            }\n            return String(segment);\n        })\n        .join('.');\n}\n\n/**\n * Gets or creates a nested object at the given path.\n * Returns the target object and the final key.\n * Handles Map/Set path segments by creating appropriate result structure.\n */\nfunction getOrCreatePath(\n    obj: Record<StrNumber, unknown>,\n    path: PathSegment[]\n): {target: Record<StrNumber, unknown>; key: StrNumber} | null {\n    if (path.length === 0) return null;\n\n    let current = obj;\n    for (let i = 0; i < path.length - 1; i++) {\n        const segment = path[i];\n\n        let key: StrNumber;\n        if (isMapKeyPath(segment)) {\n            // For Map key errors, create $keys container\n            if (current['$keys'] === undefined) {\n                current['$keys'] = {};\n            }\n            current = current['$keys'] as Record<StrNumber, unknown>;\n            key = segment.index;\n        } else if (isMapValuePath(segment)) {\n            // For Map value errors, create $values container\n            if (current['$values'] === undefined) {\n                current['$values'] = {};\n            }\n            current = current['$values'] as Record<StrNumber, unknown>;\n            key = segment.index;\n        } else if (isSetItemPath(segment)) {\n            // For Set item errors, use index directly\n            key = segment.index;\n        } else {\n            key = segment as StrNumber;\n        }\n\n        if (current[key] === undefined) {\n            current[key] = {};\n        }\n        current = current[key] as Record<StrNumber, unknown>;\n    }\n\n    // Handle the final segment\n    const lastSegment = path[path.length - 1];\n    let finalKey: StrNumber;\n\n    if (isMapKeyPath(lastSegment)) {\n        // For Map key errors at the end, create $keys container\n        if (current['$keys'] === undefined) {\n            current['$keys'] = {};\n        }\n        return {target: current['$keys'] as Record<StrNumber, unknown>, key: lastSegment.index};\n    } else if (isMapValuePath(lastSegment)) {\n        // For Map value errors at the end, create $values container\n        if (current['$values'] === undefined) {\n            current['$values'] = {};\n        }\n        return {target: current['$values'] as Record<StrNumber, unknown>, key: lastSegment.index};\n    } else if (isSetItemPath(lastSegment)) {\n        // For Set item errors, use index directly\n        finalKey = lastSegment.index;\n    } else {\n        finalKey = lastSegment as StrNumber;\n    }\n\n    return {target: current, key: finalKey};\n}\n\n// ============================================================================\n// Handler Lookup\n// ============================================================================\n\n/** Runtime type for error params - union of all possible error param types */\ntype RuntimeErrorParams = AnyFriendlyErrorParams | TypeErrorParam;\n\n/**\n * Gets the handler for a given path from the errors map.\n * Returns null if no handler is found.\n * For arrays, the handler at the array property level applies to all indices.\n * For Maps, looks for $key or $value handlers.\n * For Sets, looks for $item handler.\n */\nfunction getHandler<T>(\n    errorsMap: FriendlyErrors<T> | undefined,\n    path: PathSegment[]\n): ((errors: RuntimeErrorParams) => string) | null {\n    if (!errorsMap) return null;\n\n    // Handle top-level array/Map/Set (errorsMap is a function)\n    if (typeof errorsMap === 'function') {\n        return errorsMap as (errors: RuntimeErrorParams) => string;\n    }\n\n    let current: unknown = errorsMap;\n\n    for (let i = 0; i < path.length; i++) {\n        const segment = path[i];\n        if (current === undefined || current === null) return null;\n\n        // Handle Map path segments\n        if (isMapKeyPath(segment)) {\n            // Look for $key handler\n            if (typeof current === 'object' && current !== null && '$key' in current) {\n                const keyHandler = (current as Record<string, unknown>)['$key'];\n                if (typeof keyHandler === 'function') {\n                    return keyHandler as (errors: RuntimeErrorParams) => string;\n                }\n            }\n            // If current is a function, it's a handler for the whole Map\n            if (typeof current === 'function') {\n                return current as (errors: RuntimeErrorParams) => string;\n            }\n            return null;\n        }\n\n        if (isMapValuePath(segment)) {\n            // Look for $value handler\n            if (typeof current === 'object' && current !== null && '$value' in current) {\n                const valueHandler = (current as Record<string, unknown>)['$value'];\n                if (typeof valueHandler === 'function') {\n                    return valueHandler as (errors: RuntimeErrorParams) => string;\n                }\n                // $value could be a nested FriendlyErrors object\n                current = valueHandler;\n                continue;\n            }\n            // If current is a function, it's a handler for the whole Map\n            if (typeof current === 'function') {\n                return current as (errors: RuntimeErrorParams) => string;\n            }\n            return null;\n        }\n\n        if (isSetItemPath(segment)) {\n            // Look for $item handler\n            if (typeof current === 'object' && current !== null && '$item' in current) {\n                const itemHandler = (current as Record<string, unknown>)['$item'];\n                if (typeof itemHandler === 'function') {\n                    return itemHandler as (errors: RuntimeErrorParams) => string;\n                }\n                // $item could be a nested FriendlyErrors object\n                current = itemHandler;\n                continue;\n            }\n            // If current is a function, it's a handler for the whole Set\n            if (typeof current === 'function') {\n                return current as (errors: RuntimeErrorParams) => string;\n            }\n            return null;\n        }\n\n        // Skip numeric segments (array indices) - handlers apply to all indices\n        // But if current is already a function, return it (handler for array elements)\n        if (typeof segment === 'number') {\n            if (typeof current === 'function') {\n                return current as (errors: RuntimeErrorParams) => string;\n            }\n            continue;\n        }\n\n        // If current is a function but we have more non-numeric path segments, no handler found\n        if (typeof current === 'function') return null;\n\n        current = (current as Record<string, unknown>)[segment];\n    }\n\n    if (typeof current === 'function') {\n        return current as (errors: RuntimeErrorParams) => string;\n    }\n    return null;\n}\n\n// ============================================================================\n// Main Function\n// ============================================================================\n\n/**\n * Converts RunTypeError[] to friendly error messages using the provided error map.\n * Aggregates all validation errors per field before calling the error printer function once.\n * For properties without a handler, default error messages are generated and joined.\n *\n * Supports:\n * - Objects with nested properties\n * - Arrays (top-level and nested)\n * - Maps with separate $key and $value handlers\n * - Sets with $item handler\n *\n * @param errors - Array of validation errors from createTypeErrorsFn\n * @param errorsMap - Object mapping properties to error printer functions (optional)\n * @returns Object with same shape as T containing only properties with errors (single string per field)\n */\nexport function getFriendlyErrors<T>(errors: RunTypeError[], errorsMap?: FriendlyErrors<T>): FriendlyErrorsResult<T> {\n    const result: Record<StrNumber, unknown> = {};\n\n    // Step 1: Group errors by path and aggregate params\n    const aggregatedByPath = new Map<string, AggregatedErrorParams>();\n\n    for (const error of errors) {\n        const pathKey = pathToKey(error.path as PathSegment[]);\n        const existing = aggregatedByPath.get(pathKey);\n\n        if (existing) {\n            // Merge this error into existing aggregated params\n            mergeErrorIntoParams(existing, error);\n        } else {\n            // Create new aggregated params for this path\n            aggregatedByPath.set(pathKey, createAggregatedParams(error));\n        }\n    }\n\n    // Step 2: Process each aggregated field and call handlers once per field\n    for (const [pathKey, aggregatedParams] of aggregatedByPath) {\n        const path = aggregatedParams.rtErrors[0].path as PathSegment[];\n        const handler = getHandler(errorsMap, path);\n        let message: string;\n\n        if (handler) {\n            // Call handler once with all aggregated params for this field\n            message = handler(aggregatedParams);\n        } else {\n            // No handler: use defaultErrorPrinter for each error and join messages\n            if (!isTestEnv()) {\n                console.warn(\n                    `[mion] Using defaultErrorPrinter for \"${pathKey || '$root'}\". ` +\n                        `Consider providing a custom error handler for better user-facing messages.`\n                );\n            }\n            // Generate default messages for all errors at this path and join them\n            const messages = aggregatedParams.rtErrors.map((err) => defaultErrorPrinter(err));\n            // Remove duplicates and join into single string\n            message = [...new Set(messages)].join('; ');\n        }\n\n        // Store the single message\n        if (path.length === 0) {\n            // Root level error\n            result['$root'] = message;\n        } else {\n            const pathInfo = getOrCreatePath(result, path);\n            if (pathInfo) {\n                const {target, key} = pathInfo;\n                target[key] = message;\n            }\n        }\n    }\n\n    return result as FriendlyErrorsResult<T>;\n}\n"],"names":["isTestEnv"],"mappings":"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"}

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

@@ -0,0 +1,4 @@
+import { RunTypeError } from './types/general.types.ts';
+import { FriendlyErrors, FriendlyErrorsResult } from './types/formats/friendlyErrors.types.ts';
+export declare function defaultErrorPrinter(error: RunTypeError): string;
+export declare function getFriendlyErrors<T>(errors: RunTypeError[], errorsMap?: FriendlyErrors<T>): FriendlyErrorsResult<T>;

package/.dist/cjs/src/headers.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class HeadersSubset {
+  headers;
+  constructor(headers) {
+    this.headers = headers;
+  }
+  static __type = ["Required", "Optional", "headers", "constructor", "HeadersSubset", `l+&R&R&R&Rb!!c"PPde#!N#!Pde#"N%"K3#9PPPde$!N'!Pde$"N)"K2#"0$5w%`];
+}
+exports.HeadersSubset = HeadersSubset;
+//# sourceMappingURL=headers.cjs.map

package/.dist/cjs/src/headers.cjs.map

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

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

@@ -0,0 +1,12 @@
+export declare class HeadersSubset<Required extends string, Optional extends string = never> {
+    readonly headers: {
+        [K in Required]: string;
+    } & {
+        [K in Optional]?: string;
+    };
+    constructor(headers: {
+        [K in Required]: string;
+    } & {
+        [K in Optional]?: string;
+    });
+}

package/.dist/cjs/src/jit/jitUtils.cjs

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_utils = require("../utils.cjs");
+const src_pureFns_restoreJitFns = require("../pureFns/restoreJitFns.cjs");
+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}`);
+    src_utils.initPureFunction(compiled);
+    return compiled.fn;
+  },
+  getPureFn(namespace, fnHash) {
+    const nsCache = pureFnsCache[namespace];
+    if (!nsCache) return;
+    const compiled = nsCache[fnHash];
+    if (!compiled) return;
+    src_utils.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 };
+      }
+    }
+  }
+  src_pureFns_restoreJitFns.restoreCompiledJitFns(jitFnsCache, pureFnsCache, getJitUtils());
+}
+function getJitFnCaches() {
+  return {
+    jitFnsCache,
+    pureFnsCache
+  };
+}
+function resetJitFnCaches() {
+  if (!src_utils.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];
+}
+exports.addAOTCaches = addAOTCaches;
+exports.addSerializedJitCaches = addSerializedJitCaches;
+exports.getJitFnCaches = getJitFnCaches;
+exports.getJitUtils = getJitUtils;
+exports.resetJitFnCaches = resetJitFnCaches;
+//# sourceMappingURL=jitUtils.cjs.map

package/.dist/cjs/src/jit/jitUtils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"jitUtils.cjs","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":["initPureFunction","restoreCompiledJitFns","isTestEnv"],"mappings":"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"}

package/.dist/cjs/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/cjs/src/pureFns/pureFn.cjs

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_jit_jitUtils = require("../jit/jitUtils.cjs");
+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 = src_jit_jitUtils.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);
+  }
+  src_jit_jitUtils.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 = src_jit_jitUtils.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/%'];
+exports.registerPureFnFactory = registerPureFnFactory;
+//# sourceMappingURL=pureFn.cjs.map

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

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

package/.dist/cjs/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/cjs/src/pureFns/pureServerFn.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_types_pureFunctions_types = require("../types/pureFunctions.types.cjs");
+const PURE_SERVER_FN_NAMESPACE = "pureServerFn";
+pureServerFn.__type = ["pureFn", "bodyHash", () => src_types_pureFunctions_types.__ΩPureServerFnRef, "pureServerFn", 'P"2!&2"8"o#"/$'];
+pureServerFn.__type = [() => src_types_pureFunctions_types.__ΩPureFnDef, "def", "bodyHash", () => src_types_pureFunctions_types.__Ω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 = [() => src_types_pureFunctions_types.__ΩPureFnDef, "defOrFn", "bodyHash", () => src_types_pureFunctions_types.__ΩPureServerFnRef, "pureServerFn", 'PP"o!""J2"&2#8"o$"/%'];
+exports.PURE_SERVER_FN_NAMESPACE = PURE_SERVER_FN_NAMESPACE;
+exports.pureServerFn = pureServerFn;
+//# sourceMappingURL=pureServerFn.cjs.map

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

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

package/.dist/cjs/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/cjs/src/pureFns/quickHash.cjs

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_utils = require("../utils.cjs");
+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 (src_utils.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();
+}
+exports.createHashLiteral = createHashLiteral;
+exports.createUniqueHash = createUniqueHash;
+exports.defaultLiteralLength = defaultLiteralLength;
+exports.hashDefaultLength = hashDefaultLength;
+exports.pureFnHashLength = pureFnHashLength;
+exports.quickHash = quickHash;
+exports.resetHashes = resetHashes;
+//# sourceMappingURL=quickHash.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quickHash.cjs","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":["getENV"],"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,QAAIA,UAAAA,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/cjs/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/cjs/src/pureFns/restoreJitFns.cjs

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_errors = require("../errors.cjs");
+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 src_errors.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 src_errors.TypedError({
+      type: "pure-fn-restore-error",
+      message: `Failed to restore pure function ${fnName}: ${e?.message}`
+    });
+  }
+}
+exports.restoreCompiledJitFns = restoreCompiledJitFns;
+//# sourceMappingURL=restoreJitFns.cjs.map