@mionjs/core 0.8.0-alpha.0

package/.dist/esm/index.js

@@ -0,0 +1,245 @@
+import { SerializerModes, __ΩAnyClass, __ΩAnyErrorParams, __ΩAnyFn, __ΩAnyObject, __ΩBinaryInput, __ΩCoreRouterOptions, __ΩDataOnly, __ΩDataViewDeserializer, __ΩDataViewSerializer, __ΩDeserializeClassFn, __ΩFnsDataCache, __ΩFromBinaryFn, __ΩIsTypeFn, __ΩJSONString, __ΩJSONValue, __ΩJitCompiledFn, __ΩJitCompiledFnData, __ΩJitCompiledFunctions, __ΩJitFnArgs, __ΩJitFunctionsCache, __ΩJitFunctionsHashes, __ΩJsonStringifyFn, __ΩMapKeyPathSegment, __ΩMapValuePathSegment, __ΩMimeTypes, __ΩMutable, __ΩPathSegment, __ΩPersistedJitFn, __ΩPersistedJitFunctionsCache, __ΩPersistedPureFunctionsCache, __ΩPrepareForJsonFn, __ΩPrettify, __ΩPublicRpcError, __ΩPureFnsDataCache, __ΩPureFunctionsCache, __ΩRestoreFromJsonFn, __ΩRpcErrorParams, __ΩRpcErrorWithPrivate, __ΩRpcErrorWithPublic, __ΩRunTypeError, __ΩSerializableClass, __ΩSerializableJITFunctions, __ΩSerializerCode, __ΩSerializerMode, __ΩSetItemPathSegment, __ΩSrcCodeCompiledPureFunction, __ΩSrcCodeJITCompiledFnsCache, __ΩSrcCodeJitCompiledFn, __ΩSrcCodePureFunctionsCache, __ΩStrNumber, __ΩStrictArrayBuffer, __ΩToBinaryFn, __ΩToCodeFn, __ΩTypeErrorsFn, __ΩTypedErrorParams } from "./src/types/general.types.js";
+import { __ΩHeadersMetaData, __ΩHeadersMethodWithJitFns, __ΩMethodMetadata, __ΩMethodWithJitFns, __ΩMethodWithOptions, __ΩMethodWithOptsAndJitFns, __ΩMethodsCache, __ΩRemoteMethodOpts, __ΩRouteOnlyOptions, __ΩSerializableMethodsData } from "./src/types/method.types.js";
+import { __ΩCompiledPureFunction, __ΩErrorsPureFunction, __ΩGenericPureFunction, __ΩMapFromRef, __ΩMapFromServerFnRef, __ΩParsedFactoryFn, __ΩPersistedPureFunction, __ΩPureFnDef, __ΩPureFunction, __ΩPureFunctionData, __ΩPureFunctionDeps, __ΩPureFunctionFactory, __ΩPureServerFnRef, __ΩRoutesFlowMapping, __ΩRoutesFlowQuery } from "./src/types/pureFunctions.types.js";
+import { __ΩAliasTypeAnnotation, __ΩAliasTypeFormat, __ΩExtractFormatParams, __ΩFormatParam, __ΩFormatParamLiteral, __ΩFormatParamMeta, __ΩTypeFormatError, __ΩTypeFormatParams, __ΩTypeFormatParsedParams, __ΩTypeFormatPrimitives, __ΩTypeFormatValue } from "./src/types/formats/formats.types.js";
+import { __ΩAnyFormatParams, __ΩAnyStringFormatParam, __ΩDateFmt, __ΩFormatParam_Pattern, __ΩFormatParams_BigInt, __ΩFormatParams_Date, __ΩFormatParams_DateTime, __ΩFormatParams_Domain, __ΩFormatParams_DomainCore, __ΩFormatParams_DomainName, __ΩFormatParams_Email, __ΩFormatParams_EmailPattern, __ΩFormatParams_IP, __ΩFormatParams_Number, __ΩFormatParams_Time, __ΩFormatParams_Tld, __ΩFormatParams_UUID, __ΩFormatParams_Url, __ΩFormatParams_UrlPattern, __ΩSamples, __ΩStringParams, __ΩStringTransformers, __ΩStringValidators, __ΩTimeFmt } from "./src/types/formats/formatsParams.types.js";
+import { __ΩAnyFriendlyErrorParams, __ΩBigIntErrorParams, __ΩDateErrorParams, __ΩDateTimeErrorParams, __ΩDomainErrorParams, __ΩEmailErrorParams, __ΩExtractErrorParams, __ΩFriendlyErrorHandler, __ΩFriendlyErrorParams, __ΩFriendlyErrors, __ΩFriendlyErrorsResult, __ΩIPErrorParams, __ΩMapErrorHandlers, __ΩMapErrorsResult, __ΩNumberErrorParams, __ΩSetErrorHandlers, __ΩSetErrorsResult, __ΩStringErrorParams, __ΩTimeErrorParams, __ΩTypeErrorParam, __ΩUUIDErrorParams, __ΩUrlErrorParams } from "./src/types/formats/friendlyErrors.types.js";
+import { __ΩBrand, __ΩBrandDate, __ΩBrandDateTime, __ΩBrandDomain, __ΩBrandEmail, __ΩBrandFloat, __ΩBrandIP, __ΩBrandInt16, __ΩBrandInt32, __ΩBrandInt8, __ΩBrandInteger, __ΩBrandNegative, __ΩBrandNegativeInt, __ΩBrandPositive, __ΩBrandPositiveInt, __ΩBrandTime, __ΩBrandUInt16, __ΩBrandUInt32, __ΩBrandUInt8, __ΩBrandUUID, __ΩBrandUrl } from "./src/types/formats/formatBrands.types.js";
+import { createDataViewDeserializer, createDataViewSerializer, setSerializationOptions } from "./src/binary/dataView.js";
+import { serializeBinaryBody } from "./src/binary/bodySerializer.js";
+import { deserializeBinaryBody } from "./src/binary/bodyDeserializer.js";
+import { DEFAULT_CORE_OPTIONS, EMPTY_HASH, HandlerType, JIT_FUNCTION_IDS, MAX_STACK_DEPTH, MAX_UNKNOWN_KEYS, MIME_TYPES, MION_ROUTES, PATH_SEPARATOR, ROUTER_ITEM_SEPARATOR_CHAR, ROUTE_PATH_ROOT, StatusCodes } from "./src/constants.js";
+import { RpcError, TypedError, __ΩValidationError, __ΩValidationErrorData, isAnyError, isRpcError, isTypedError, registerErrorDeserializers, setErrorOptions } from "./src/errors.js";
+import { defaultErrorPrinter, getFriendlyErrors } from "./src/friendlyErrors.js";
+import { addAOTCaches, addSerializedJitCaches, getJitFnCaches, getJitUtils, resetJitFnCaches } from "./src/jit/jitUtils.js";
+import { addRoutesToCache, getHeaderJitFunctionsFromHash, getJitFnHashes, getJitFunctionsFromHash, getNoopJitFns, getRoutePath, getRouterItemId, methodOptsCache, resetJitFunctionsCache, resetRoutesCache, routesCache } from "./src/routerUtils.js";
+import { fromBase64Url, getENV, initPureFunction, isMionAOTEmitMode, isMionCompileMode, isTestEnv, randomUUID_V7, toBase64Url } from "./src/utils.js";
+import { HeadersSubset } from "./src/headers.js";
+import { registerPureFnFactory } from "./src/pureFns/pureFn.js";
+import { PURE_SERVER_FN_NAMESPACE, pureServerFn } from "./src/pureFns/pureServerFn.js";
+import { createHashLiteral, createUniqueHash, defaultLiteralLength, hashDefaultLength, pureFnHashLength, quickHash, resetHashes } from "./src/pureFns/quickHash.js";
+export {
+  DEFAULT_CORE_OPTIONS,
+  EMPTY_HASH,
+  HandlerType,
+  HeadersSubset,
+  JIT_FUNCTION_IDS,
+  MAX_STACK_DEPTH,
+  MAX_UNKNOWN_KEYS,
+  MIME_TYPES,
+  MION_ROUTES,
+  PATH_SEPARATOR,
+  PURE_SERVER_FN_NAMESPACE,
+  ROUTER_ITEM_SEPARATOR_CHAR,
+  ROUTE_PATH_ROOT,
+  RpcError,
+  SerializerModes,
+  StatusCodes,
+  TypedError,
+  __ΩAliasTypeAnnotation,
+  __ΩAliasTypeFormat,
+  __ΩAnyClass,
+  __ΩAnyErrorParams,
+  __ΩAnyFn,
+  __ΩAnyFormatParams,
+  __ΩAnyFriendlyErrorParams,
+  __ΩAnyObject,
+  __ΩAnyStringFormatParam,
+  __ΩBigIntErrorParams,
+  __ΩBinaryInput,
+  __ΩBrand,
+  __ΩBrandDate,
+  __ΩBrandDateTime,
+  __ΩBrandDomain,
+  __ΩBrandEmail,
+  __ΩBrandFloat,
+  __ΩBrandIP,
+  __ΩBrandInt16,
+  __ΩBrandInt32,
+  __ΩBrandInt8,
+  __ΩBrandInteger,
+  __ΩBrandNegative,
+  __ΩBrandNegativeInt,
+  __ΩBrandPositive,
+  __ΩBrandPositiveInt,
+  __ΩBrandTime,
+  __ΩBrandUInt16,
+  __ΩBrandUInt32,
+  __ΩBrandUInt8,
+  __ΩBrandUUID,
+  __ΩBrandUrl,
+  __ΩCompiledPureFunction,
+  __ΩCoreRouterOptions,
+  __ΩDataOnly,
+  __ΩDataViewDeserializer,
+  __ΩDataViewSerializer,
+  __ΩDateErrorParams,
+  __ΩDateFmt,
+  __ΩDateTimeErrorParams,
+  __ΩDeserializeClassFn,
+  __ΩDomainErrorParams,
+  __ΩEmailErrorParams,
+  __ΩErrorsPureFunction,
+  __ΩExtractErrorParams,
+  __ΩExtractFormatParams,
+  __ΩFnsDataCache,
+  __ΩFormatParam,
+  __ΩFormatParamLiteral,
+  __ΩFormatParamMeta,
+  __ΩFormatParam_Pattern,
+  __ΩFormatParams_BigInt,
+  __ΩFormatParams_Date,
+  __ΩFormatParams_DateTime,
+  __ΩFormatParams_Domain,
+  __ΩFormatParams_DomainCore,
+  __ΩFormatParams_DomainName,
+  __ΩFormatParams_Email,
+  __ΩFormatParams_EmailPattern,
+  __ΩFormatParams_IP,
+  __ΩFormatParams_Number,
+  __ΩFormatParams_Time,
+  __ΩFormatParams_Tld,
+  __ΩFormatParams_UUID,
+  __ΩFormatParams_Url,
+  __ΩFormatParams_UrlPattern,
+  __ΩFriendlyErrorHandler,
+  __ΩFriendlyErrorParams,
+  __ΩFriendlyErrors,
+  __ΩFriendlyErrorsResult,
+  __ΩFromBinaryFn,
+  __ΩGenericPureFunction,
+  __ΩHeadersMetaData,
+  __ΩHeadersMethodWithJitFns,
+  __ΩIPErrorParams,
+  __ΩIsTypeFn,
+  __ΩJSONString,
+  __ΩJSONValue,
+  __ΩJitCompiledFn,
+  __ΩJitCompiledFnData,
+  __ΩJitCompiledFunctions,
+  __ΩJitFnArgs,
+  __ΩJitFunctionsCache,
+  __ΩJitFunctionsHashes,
+  __ΩJsonStringifyFn,
+  __ΩMapErrorHandlers,
+  __ΩMapErrorsResult,
+  __ΩMapFromRef,
+  __ΩMapFromServerFnRef,
+  __ΩMapKeyPathSegment,
+  __ΩMapValuePathSegment,
+  __ΩMethodMetadata,
+  __ΩMethodWithJitFns,
+  __ΩMethodWithOptions,
+  __ΩMethodWithOptsAndJitFns,
+  __ΩMethodsCache,
+  __ΩMimeTypes,
+  __ΩMutable,
+  __ΩNumberErrorParams,
+  __ΩParsedFactoryFn,
+  __ΩPathSegment,
+  __ΩPersistedJitFn,
+  __ΩPersistedJitFunctionsCache,
+  __ΩPersistedPureFunction,
+  __ΩPersistedPureFunctionsCache,
+  __ΩPrepareForJsonFn,
+  __ΩPrettify,
+  __ΩPublicRpcError,
+  __ΩPureFnDef,
+  __ΩPureFnsDataCache,
+  __ΩPureFunction,
+  __ΩPureFunctionData,
+  __ΩPureFunctionDeps,
+  __ΩPureFunctionFactory,
+  __ΩPureFunctionsCache,
+  __ΩPureServerFnRef,
+  __ΩRemoteMethodOpts,
+  __ΩRestoreFromJsonFn,
+  __ΩRouteOnlyOptions,
+  __ΩRoutesFlowMapping,
+  __ΩRoutesFlowQuery,
+  __ΩRpcErrorParams,
+  __ΩRpcErrorWithPrivate,
+  __ΩRpcErrorWithPublic,
+  __ΩRunTypeError,
+  __ΩSamples,
+  __ΩSerializableClass,
+  __ΩSerializableJITFunctions,
+  __ΩSerializableMethodsData,
+  __ΩSerializerCode,
+  __ΩSerializerMode,
+  __ΩSetErrorHandlers,
+  __ΩSetErrorsResult,
+  __ΩSetItemPathSegment,
+  __ΩSrcCodeCompiledPureFunction,
+  __ΩSrcCodeJITCompiledFnsCache,
+  __ΩSrcCodeJitCompiledFn,
+  __ΩSrcCodePureFunctionsCache,
+  __ΩStrNumber,
+  __ΩStrictArrayBuffer,
+  __ΩStringErrorParams,
+  __ΩStringParams,
+  __ΩStringTransformers,
+  __ΩStringValidators,
+  __ΩTimeErrorParams,
+  __ΩTimeFmt,
+  __ΩToBinaryFn,
+  __ΩToCodeFn,
+  __ΩTypeErrorParam,
+  __ΩTypeErrorsFn,
+  __ΩTypeFormatError,
+  __ΩTypeFormatParams,
+  __ΩTypeFormatParsedParams,
+  __ΩTypeFormatPrimitives,
+  __ΩTypeFormatValue,
+  __ΩTypedErrorParams,
+  __ΩUUIDErrorParams,
+  __ΩUrlErrorParams,
+  __ΩValidationError,
+  __ΩValidationErrorData,
+  addAOTCaches,
+  addRoutesToCache,
+  addSerializedJitCaches,
+  createDataViewDeserializer,
+  createDataViewSerializer,
+  createHashLiteral,
+  createUniqueHash,
+  defaultErrorPrinter,
+  defaultLiteralLength,
+  deserializeBinaryBody,
+  fromBase64Url,
+  getENV,
+  getFriendlyErrors,
+  getHeaderJitFunctionsFromHash,
+  getJitFnCaches,
+  getJitFnHashes,
+  getJitFunctionsFromHash,
+  getJitUtils,
+  getNoopJitFns,
+  getRoutePath,
+  getRouterItemId,
+  hashDefaultLength,
+  initPureFunction,
+  isAnyError,
+  isMionAOTEmitMode,
+  isMionCompileMode,
+  isRpcError,
+  isTestEnv,
+  isTypedError,
+  methodOptsCache,
+  pureFnHashLength,
+  pureServerFn,
+  quickHash,
+  randomUUID_V7,
+  registerErrorDeserializers,
+  registerPureFnFactory,
+  resetHashes,
+  resetJitFnCaches,
+  resetJitFunctionsCache,
+  resetRoutesCache,
+  routesCache,
+  serializeBinaryBody,
+  setErrorOptions,
+  setSerializationOptions,
+  toBase64Url
+};
+//# sourceMappingURL=index.js.map

package/.dist/esm/index.js.map

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

package/.dist/esm/src/binary/bodyDeserializer.d.ts

@@ -0,0 +1,5 @@
+import { BinaryInput, DataViewDeserializer } from '../types/general.types.ts';
+export declare function deserializeBinaryBody(path: string, buffer: BinaryInput, isResponse: boolean): {
+    deserializer: DataViewDeserializer;
+    body: Record<string, any>;
+};

package/.dist/esm/src/binary/bodyDeserializer.js

@@ -0,0 +1,54 @@
+import { createDataViewDeserializer } from "./dataView.js";
+import { StatusCodes } from "../constants.js";
+import { RpcError } from "../errors.js";
+import { routesCache } from "../routerUtils.js";
+function deserializeBinaryBody(path, buffer, isResponse) {
+  try {
+    const deserializer = createDataViewDeserializer(path, buffer);
+    const body = {};
+    const itemsLength = deserializer.view.getUint32(0, true);
+    deserializer.index += 4;
+    for (let i = 0; i < itemsLength; i++) {
+      const key = deserializer.desString();
+      const method = routesCache.getMethodJitFns(key);
+      if (!method) {
+        throw new RpcError({
+          statusCode: StatusCodes.UNEXPECTED_ERROR,
+          type: isResponse ? "binary-response-method-Deserialization-error" : "binary-request-method-Deserialization-error",
+          publicMessage: `Unknown method key in binary body: ${key}`,
+          errorData: { methodId: key }
+        });
+      }
+      const value = deserializeMethod(key, method, deserializer, isResponse);
+      body[key] = value;
+    }
+    deserializer.markAsEnded();
+    return { deserializer, body };
+  } catch (err) {
+    if (err instanceof RpcError) throw err;
+    throw new RpcError({
+      statusCode: StatusCodes.UNEXPECTED_ERROR,
+      type: isResponse ? "binary-response-Deserialize-error" : "binary-request-Deserialization-error",
+      publicMessage: `Failed to deserialize body from binary: ${err?.message || "unknown error"}`,
+      originalError: err
+    });
+  }
+}
+function deserializeMethod(key, method, deserializer, isResponse) {
+  const jitFns = isResponse ? method.returnJitFns : method.paramsJitFns;
+  try {
+    return jitFns.fromBinary.fn(void 0, deserializer);
+  } catch (e) {
+    throw new RpcError({
+      statusCode: StatusCodes.UNEXPECTED_ERROR,
+      type: isResponse ? "binary-response-method-Deserialization-error" : "binary-request-method-Deserialization-error",
+      publicMessage: `Failed to deserialize method ${key} from binary`,
+      originalError: e,
+      errorData: { methodId: key }
+    });
+  }
+}
+export {
+  deserializeBinaryBody
+};
+//# sourceMappingURL=bodyDeserializer.js.map

package/.dist/esm/src/binary/bodyDeserializer.js.map

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

package/.dist/esm/src/binary/bodySerializer.d.ts

@@ -0,0 +1,6 @@
+import { DataViewSerializer } from '../types/general.types.ts';
+import { MethodWithJitFns } from '../types/method.types.ts';
+export declare function serializeBinaryBody(path: string, executionChain: MethodWithJitFns[], body: Record<string, any>, isResponse: boolean, workflowRouteIds?: string[]): {
+    serializer: DataViewSerializer;
+    buffer: ReturnType<DataViewSerializer['getBuffer']>;
+};

package/.dist/esm/src/binary/bodySerializer.js

@@ -0,0 +1,49 @@
+import { createDataViewSerializer } from "./dataView.js";
+import { StatusCodes, MION_ROUTES } from "../constants.js";
+import { RpcError } from "../errors.js";
+function serializeBinaryBody(path, executionChain, body, isResponse, workflowRouteIds) {
+  try {
+    const serializer = createDataViewSerializer(path, workflowRouteIds);
+    const itemsLengthIndex = serializer.index;
+    serializer.index += 4;
+    let itemsLength = 0;
+    for (let i = 0; i < executionChain.length; i++) {
+      const method = executionChain[i];
+      const key = method.id;
+      const value = body[key];
+      if (serializeMethod(key, method, value, serializer, isResponse)) {
+        itemsLength++;
+      }
+    }
+    serializer.view.setUint32(itemsLengthIndex, itemsLength, true);
+    serializer.markAsEnded();
+    return { serializer, buffer: serializer.getBuffer() };
+  } catch (err) {
+    if (err instanceof RpcError) throw err;
+    throw new RpcError({
+      statusCode: StatusCodes.UNEXPECTED_ERROR,
+      type: isResponse ? "binary-response-Serialization-error" : "binary-request-Serialization-error",
+      publicMessage: `Failed to serialize body to binary: ${err?.message || "unknown error"}`,
+      originalError: err
+    });
+  }
+}
+function serializeMethod(key, method, value, serializer, isResponse) {
+  const toBinary = isResponse ? method.returnJitFns.toBinary : method.paramsJitFns.toBinary;
+  if (!toBinary?.fn)
+    throw new RpcError({
+      type: "missing-toBinary-jit-fn",
+      publicMessage: `Missing toBinary JIT function for method ${method.id}`
+    });
+  if (toBinary.isNoop) return false;
+  if (key === MION_ROUTES.thrownErrors) return false;
+  if (isResponse && (!method.hasReturnData || typeof value === "undefined")) return false;
+  if (!isResponse && typeof value === "undefined") return false;
+  serializer.serString(key);
+  toBinary.fn(value, serializer);
+  return true;
+}
+export {
+  serializeBinaryBody
+};
+//# sourceMappingURL=bodySerializer.js.map

package/.dist/esm/src/binary/bodySerializer.js.map

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

package/.dist/esm/src/binary/dataView.d.ts

@@ -0,0 +1,16 @@
+import { BinaryInput, DataViewSerializer, DataViewDeserializer } from '../types/general.types.ts';
+declare const DEFAULT_OPTIONS: {
+    maxPoolItems: number;
+    maxStrCacheLength: number;
+    maxCacheSize: number;
+    bufferSize: number;
+    averageResponseSizeMultiplier: number;
+    responseAverageSizes: Map<string, number>;
+    stringBytesCache: Map<string, Uint8Array<ArrayBufferLike>>;
+};
+export type SerializationOptions = typeof DEFAULT_OPTIONS;
+export declare function setSerializationOptions(options: Partial<SerializationOptions>): void;
+export declare function createDataViewSerializer(routeId: string, workflowRouteIds?: string[]): DataViewSerializer;
+export declare function createDataViewDeserializer(routeId: string, input: BinaryInput): DataViewDeserializer;
+export {};
+export declare type __ΩSerializationOptions = any[];

package/.dist/esm/src/binary/dataView.js

@@ -0,0 +1,212 @@
+const STR = 1;
+const NUM = 2;
+const POW_2_32 = 2 ** 32;
+const LE = true;
+const DEFAULT_OPTIONS = {
+  maxPoolItems: 100,
+  maxStrCacheLength: 64,
+  maxCacheSize: 1e3,
+  bufferSize: 2 ** 24,
+  averageResponseSizeMultiplier: 2,
+  responseAverageSizes: /* @__PURE__ */ new Map(),
+  stringBytesCache: /* @__PURE__ */ new Map()
+};
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+let opts = { ...DEFAULT_OPTIONS };
+function setSerializationOptions(options) {
+  opts = { ...opts, ...options };
+}
+function createDataViewSerializer(routeId, workflowRouteIds) {
+  const size = calculateBufferSizeForRequest(routeId, workflowRouteIds);
+  if (size >= POW_2_32) throw new Error("bufferSize option must be strictly less than 2 ** 32");
+  return new DataViewSerializerImpl(routeId, size);
+}
+function createDataViewDeserializer(routeId, input) {
+  if (ArrayBuffer.isView(input)) {
+    const buffer = input.buffer;
+    return new DataViewDeserializerImpl(routeId, buffer, input.byteOffset, input.byteLength);
+  }
+  return new DataViewDeserializerImpl(routeId, input);
+}
+class DataViewSerializerImpl {
+  buffer;
+  uint8View;
+  // Reusable view
+  routeId;
+  index = 0;
+  // byte offset
+  view;
+  hasEnded = false;
+  constructor(routeId, size) {
+    this.routeId = routeId;
+    this.buffer = new ArrayBuffer(size);
+    this.view = new DataView(this.buffer);
+    this.uint8View = new Uint8Array(this.buffer);
+  }
+  reset() {
+    this.index = 0;
+    this.hasEnded = false;
+  }
+  resize(size) {
+    this.buffer = new ArrayBuffer(size);
+    this.view = new DataView(this.buffer);
+    this.uint8View = new Uint8Array(this.buffer);
+  }
+  getBuffer() {
+    const buff = this.buffer.slice(0, this.index);
+    return buff;
+  }
+  getBufferView() {
+    return new Uint8Array(this.buffer, 0, this.index);
+  }
+  markAsEnded() {
+    this.hasEnded = true;
+    updateResponseSize(this.routeId, this.index);
+  }
+  getLength() {
+    return this.index;
+  }
+  serString(str, skipCache) {
+    if (str.length >= opts.maxStrCacheLength || skipCache) {
+      const targetView2 = this.uint8View.subarray(this.index + 4);
+      const result2 = textEncoder.encodeInto(str, targetView2);
+      this.view.setUint32(this.index, result2.written, LE);
+      this.index += 4 + result2.written;
+      return;
+    }
+    const cached = opts.stringBytesCache.get(str);
+    if (cached) {
+      this.uint8View.set(cached, this.index + 4);
+      this.view.setUint32(this.index, cached.length, LE);
+      this.index += 4 + cached.length;
+      return;
+    }
+    const targetView = this.uint8View.subarray(this.index + 4);
+    const result = textEncoder.encodeInto(str, targetView);
+    const written = result.written;
+    this.view.setUint32(this.index, written, LE);
+    this.index += 4 + written;
+    if (opts.stringBytesCache.size >= opts.maxCacheSize) evictStringBytesCache();
+    opts.stringBytesCache.set(str, this.uint8View.slice(this.index - written, this.index));
+  }
+  serFloat64(n) {
+    this.view.setFloat64(this.index, n, LE);
+    this.index += 8;
+  }
+  serEnum(n) {
+    if (typeof n === "number") {
+      this.view.setUint32(this.index, NUM, LE);
+      this.index += 4;
+      this.view.setUint32(this.index, n, LE);
+      this.index += 4;
+      return;
+    }
+    this.view.setUint32(this.index, STR, LE);
+    this.index += 4;
+    this.serString(n);
+  }
+  setBitMask(bitMaskIndex, bitIndex) {
+    const newBitmask = this.view.getUint8(bitMaskIndex) | 1 << bitIndex;
+    this.view.setUint8(bitMaskIndex, newBitmask);
+  }
+}
+class DataViewDeserializerImpl {
+  buffer;
+  uint8View;
+  // Reusable view
+  routeId;
+  index = 0;
+  view;
+  hasEnded = false;
+  constructor(routeId, buffer, byteOffset, byteLength) {
+    this.routeId = routeId;
+    this.buffer = buffer;
+    this.index = 0;
+    this.view = new DataView(buffer, byteOffset, byteLength);
+    this.uint8View = new Uint8Array(buffer, byteOffset, byteLength);
+  }
+  reset() {
+    this.index = 0;
+    this.hasEnded = false;
+  }
+  setBuffer(buffer, byteOffset, byteLength) {
+    this.index = 0;
+    this.buffer = buffer;
+    this.view = new DataView(buffer, byteOffset, byteLength);
+    this.uint8View = new Uint8Array(buffer, byteOffset, byteLength);
+    this.hasEnded = false;
+  }
+  markAsEnded() {
+    this.hasEnded = true;
+  }
+  getLength() {
+    return this.index;
+  }
+  desString() {
+    const len = this.view.getUint32(this.index, LE);
+    this.index += 4;
+    const decoded = textDecoder.decode(this.uint8View.subarray(this.index, this.index + len));
+    this.index += len;
+    return decoded;
+  }
+  /** Deserialize a string that will be used as a property name, with prototype pollution protection */
+  desSafePropName() {
+    const key = this.desString();
+    const len = key.length;
+    if (len === 9) {
+      if (key === "__proto__" || key === "prototype") throw new Error(`Unsafe property name: ${key}`);
+    } else if (len === 11) {
+      if (key === "constructor") throw new Error(`Unsafe property name: ${key}`);
+    }
+    return key;
+  }
+  desFloat64() {
+    const value = this.view.getFloat64(this.index, LE);
+    this.index += 8;
+    return value;
+  }
+  desEnum() {
+    const type = this.view.getUint32(this.index, LE);
+    this.index += 4;
+    if (type === NUM) {
+      const value = this.view.getUint32(this.index, LE);
+      this.index += 4;
+      return value;
+    }
+    return this.desString();
+  }
+}
+function calculateBufferSizeForRequest(routeId, workflowRouteIds) {
+  if (!workflowRouteIds || workflowRouteIds.length === 0) {
+    return calculateDefaultBufferSize(routeId);
+  }
+  let totalSize = 0;
+  for (const id of workflowRouteIds) {
+    totalSize += calculateDefaultBufferSize(id);
+  }
+  return totalSize;
+}
+function calculateDefaultBufferSize(routeId) {
+  const size = opts.responseAverageSizes.get(routeId);
+  if (!size) return opts.bufferSize;
+  return size * opts.averageResponseSizeMultiplier;
+}
+function updateResponseSize(routeId, responseSize) {
+  const currentSize = opts.responseAverageSizes.get(routeId) || opts.bufferSize;
+  const average = (currentSize + responseSize) / 2;
+  opts.responseAverageSizes.set(routeId, Math.floor(average));
+}
+function evictStringBytesCache() {
+  const entries = Array.from(opts.stringBytesCache.entries());
+  opts.stringBytesCache.clear();
+  for (let i = Math.floor(entries.length / 2); i < entries.length; i++) {
+    opts.stringBytesCache.set(entries[i][0], entries[i][1]);
+  }
+}
+export {
+  createDataViewDeserializer,
+  createDataViewSerializer,
+  setSerializationOptions
+};
+//# sourceMappingURL=dataView.js.map

package/.dist/esm/src/binary/dataView.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataView.js","sources":["../../../../src/binary/dataView.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\n// this code is based on from seqproto library https://github.com/oramasearch/seqproto\n\nimport type {StrictArrayBuffer, BinaryInput, DataViewSerializer, DataViewDeserializer} from '../types/general.types.ts';\n\nconst STR = 1;\nconst NUM = 2;\nconst POW_2_32 = 2 ** 32;\nconst LE = true; // always use little endian\n\n// ############## create serializer & deserializer ##############\n\nconst DEFAULT_OPTIONS = {\n    maxPoolItems: 100,\n    maxStrCacheLength: 64,\n    maxCacheSize: 1000,\n    bufferSize: 2 ** 24,\n    averageResponseSizeMultiplier: 2,\n    responseAverageSizes: new Map<string, number>(),\n    stringBytesCache: new Map<string, Uint8Array>(),\n};\n\nexport type SerializationOptions = typeof DEFAULT_OPTIONS;\n\n// ############## DataView-based serializer & deserializer ##############\n// Uses byte-level precision (1-byte minimum unit) instead of 4-byte units\n\nconst textEncoder = new TextEncoder();\nconst textDecoder = new TextDecoder();\n\nlet opts = {...DEFAULT_OPTIONS};\n\nexport function setSerializationOptions(options: Partial<SerializationOptions>) {\n    opts = {...opts, ...options};\n}\n\n/**\n * Creates a DataView-based serializer for binary serialization.\n * @param routeId - The route ID for buffer size calculation and tracking\n * @param workflowRouteIds - Optional array of route IDs for routesFlow requests.\n *                           When provided, buffer size is calculated by summing sizes for each route.\n */\nexport function createDataViewSerializer(routeId: string, workflowRouteIds?: string[]): DataViewSerializer {\n    const size = calculateBufferSizeForRequest(routeId, workflowRouteIds);\n    if (size >= POW_2_32) throw new Error('bufferSize option must be strictly less than 2 ** 32');\n    return new DataViewSerializerImpl(routeId, size);\n}\n\n/** Creates a deserializer from ArrayBuffer or any typed array view (including Node.js Buffer) */\nexport function createDataViewDeserializer(routeId: string, input: BinaryInput): DataViewDeserializer {\n    // Extract ArrayBuffer and offset/length from typed array views (Uint8Array, Buffer, etc.)\n    if (ArrayBuffer.isView(input)) {\n        const buffer = input.buffer as StrictArrayBuffer;\n        return new DataViewDeserializerImpl(routeId, buffer, input.byteOffset, input.byteLength);\n    }\n    // Plain ArrayBuffer\n    return new DataViewDeserializerImpl(routeId, input as StrictArrayBuffer);\n}\n\n// TODO: at the moment we do not resize the buffer, if data does not fit it will throw an error,\n// anything that uses the serializer should catch the error and resize the buffer\nclass DataViewSerializerImpl implements DataViewSerializer {\n    readonly buffer: ArrayBuffer;\n    private uint8View: Uint8Array; // Reusable view\n    readonly routeId: string;\n    index: number = 0; // byte offset\n    view: DataView;\n    hasEnded: boolean = false;\n    constructor(routeId: string, size: number) {\n        this.routeId = routeId;\n        this.buffer = new ArrayBuffer(size);\n        this.view = new DataView(this.buffer);\n        this.uint8View = new Uint8Array(this.buffer);\n    }\n    reset(): void {\n        this.index = 0;\n        this.hasEnded = false;\n    }\n    resize(size: number): void {\n        (this as any).buffer = new ArrayBuffer(size);\n        this.view = new DataView(this.buffer);\n        this.uint8View = new Uint8Array(this.buffer);\n    }\n    getBuffer(): StrictArrayBuffer {\n        const buff = this.buffer.slice(0, this.index);\n        return buff;\n    }\n    getBufferView(): Uint8Array {\n        return new Uint8Array(this.buffer, 0, this.index);\n    }\n    markAsEnded(): void {\n        this.hasEnded = true;\n        updateResponseSize(this.routeId, this.index);\n    }\n    getLength(): number {\n        return this.index;\n    }\n    serString(str: string, skipCache?: boolean): void {\n        if (str.length >= opts.maxStrCacheLength || skipCache) {\n            const targetView = this.uint8View.subarray(this.index + 4);\n            const result = textEncoder.encodeInto(str, targetView);\n            this.view.setUint32(this.index, result.written, LE);\n            this.index += 4 + result.written;\n            return;\n        }\n        const cached = opts.stringBytesCache.get(str);\n        if (cached) {\n            this.uint8View.set(cached, this.index + 4);\n            this.view.setUint32(this.index, cached.length, LE);\n            this.index += 4 + cached.length;\n            return;\n        }\n\n        // Encode directly into working view\n        const targetView = this.uint8View.subarray(this.index + 4);\n        const result = textEncoder.encodeInto(str, targetView);\n        const written = result.written!;\n\n        this.view.setUint32(this.index, written, LE);\n        this.index += 4 + written;\n\n        // Cache the encoded bytes (create slice only for caching)\n        if (opts.stringBytesCache.size >= opts.maxCacheSize) evictStringBytesCache();\n        opts.stringBytesCache.set(str, this.uint8View.slice(this.index - written, this.index));\n    }\n    serFloat64(n: number): void {\n        this.view.setFloat64(this.index, n, LE);\n        this.index += 8;\n    }\n    serEnum(n: number | string): void {\n        if (typeof n === 'number') {\n            this.view.setUint32(this.index, NUM, LE);\n            this.index += 4;\n            this.view.setUint32(this.index, n, LE);\n            this.index += 4;\n            return;\n        }\n        this.view.setUint32(this.index, STR, LE);\n        this.index += 4;\n        this.serString(n);\n    }\n    setBitMask(bitMaskIndex: number, bitIndex: number): void {\n        const newBitmask = this.view.getUint8(bitMaskIndex) | (1 << bitIndex);\n        this.view.setUint8(bitMaskIndex, newBitmask);\n    }\n}\n\nclass DataViewDeserializerImpl implements DataViewDeserializer {\n    readonly buffer: StrictArrayBuffer;\n    private uint8View: Uint8Array; // Reusable view\n    readonly routeId: string;\n    index: number = 0;\n    view: DataView;\n    hasEnded: boolean = false;\n    constructor(routeId: string, buffer: StrictArrayBuffer, byteOffset?: number, byteLength?: number) {\n        this.routeId = routeId;\n        this.buffer = buffer;\n        // index should always start at 0 because DataView/Uint8Array already account for byteOffset\n        this.index = 0;\n        this.view = new DataView(buffer, byteOffset, byteLength);\n        this.uint8View = new Uint8Array(buffer, byteOffset, byteLength);\n    }\n    reset(): void {\n        this.index = 0;\n        this.hasEnded = false;\n    }\n    setBuffer(buffer: StrictArrayBuffer, byteOffset?: number, byteLength?: number): void {\n        // index should always start at 0 because DataView/Uint8Array already account for byteOffset\n        this.index = 0;\n        (this as any).buffer = buffer;\n        this.view = new DataView(buffer, byteOffset, byteLength);\n        this.uint8View = new Uint8Array(buffer, byteOffset, byteLength); // Update working view\n        this.hasEnded = false;\n    }\n    markAsEnded(): void {\n        this.hasEnded = true;\n    }\n    getLength(): number {\n        return this.index;\n    }\n    desString(): string {\n        const len = this.view.getUint32(this.index, LE);\n        this.index += 4;\n\n        const decoded = textDecoder.decode(this.uint8View.subarray(this.index, this.index + len));\n        this.index += len;\n        return decoded;\n    }\n    /** Deserialize a string that will be used as a property name, with prototype pollution protection */\n    desSafePropName(): string {\n        const key = this.desString();\n        const len = key.length;\n        if (len === 9) {\n            if (key === '__proto__' || key === 'prototype') throw new Error(`Unsafe property name: ${key}`);\n        } else if (len === 11) {\n            if (key === 'constructor') throw new Error(`Unsafe property name: ${key}`);\n        }\n        return key;\n    }\n    desFloat64(): number {\n        const value = this.view.getFloat64(this.index, LE);\n        this.index += 8;\n        return value;\n    }\n    desEnum(): number | string {\n        const type = this.view.getUint32(this.index, LE);\n        this.index += 4;\n        if (type === NUM) {\n            const value = this.view.getUint32(this.index, LE);\n            this.index += 4;\n            return value;\n        }\n        return this.desString();\n    }\n}\n\n/**\n * Calculates buffer size for a request, handling both single routes and routesFlows.\n * For routesFlows, sums up the buffer sizes for each individual route.\n */\nfunction calculateBufferSizeForRequest(routeId: string, workflowRouteIds?: string[]): number {\n    if (!workflowRouteIds || workflowRouteIds.length === 0) {\n        return calculateDefaultBufferSize(routeId);\n    }\n\n    // For routesFlows, sum up the buffer sizes for each individual route\n    let totalSize = 0;\n    for (const id of workflowRouteIds) {\n        totalSize += calculateDefaultBufferSize(id);\n    }\n    return totalSize;\n}\n\n/** Returns the average response size for the given route, multiplied by a factor for safety margin */\nfunction calculateDefaultBufferSize(routeId: string): number {\n    const size = opts.responseAverageSizes.get(routeId);\n    if (!size) return opts.bufferSize;\n    return size * opts.averageResponseSizeMultiplier;\n}\n\nfunction updateResponseSize(routeId: string, responseSize: number) {\n    const currentSize = opts.responseAverageSizes.get(routeId) || opts.bufferSize;\n    const average = (currentSize + responseSize) / 2;\n    opts.responseAverageSizes.set(routeId, Math.floor(average));\n}\n\nfunction evictStringBytesCache(): void {\n    const entries = Array.from(opts.stringBytesCache.entries());\n    opts.stringBytesCache.clear();\n    for (let i = Math.floor(entries.length / 2); i < entries.length; i++) {\n        opts.stringBytesCache.set(entries[i][0], entries[i][1]);\n    }\n}\n"],"names":["targetView","result"],"mappings":"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"}