@mionjs/core 0.8.0-alpha.0

package/.dist/cjs/index.cjs

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

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

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

package/.dist/cjs/index.d.ts

@@ -0,0 +1,21 @@
+export * from './src/types/general.types.ts';
+export * from './src/types/method.types.ts';
+export * from './src/types/pureFunctions.types.ts';
+export * from './src/types/formats/formats.types.ts';
+export * from './src/types/formats/formatsParams.types.ts';
+export * from './src/types/formats/friendlyErrors.types.ts';
+export * from './src/types/formats/formatBrands.types.ts';
+export * from './src/binary/dataView.ts';
+export * from './src/binary/bodySerializer.ts';
+export * from './src/binary/bodyDeserializer.ts';
+export * from './src/binary/bodyDeserializer.ts';
+export * from './src/constants.ts';
+export * from './src/errors.ts';
+export * from './src/friendlyErrors.ts';
+export * from './src/jit/jitUtils.ts';
+export * from './src/routerUtils.ts';
+export * from './src/utils.ts';
+export * from './src/headers.ts';
+export * from './src/pureFns/pureFn.ts';
+export * from './src/pureFns/pureServerFn.ts';
+export * from './src/pureFns/quickHash.ts';

package/.dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_binary_dataView = require("./dataView.cjs");
+const src_constants = require("../constants.cjs");
+const src_errors = require("../errors.cjs");
+const src_routerUtils = require("../routerUtils.cjs");
+function deserializeBinaryBody(path, buffer, isResponse) {
+  try {
+    const deserializer = src_binary_dataView.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 = src_routerUtils.routesCache.getMethodJitFns(key);
+      if (!method) {
+        throw new src_errors.RpcError({
+          statusCode: src_constants.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 src_errors.RpcError) throw err;
+    throw new src_errors.RpcError({
+      statusCode: src_constants.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 src_errors.RpcError({
+      statusCode: src_constants.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 }
+    });
+  }
+}
+exports.deserializeBinaryBody = deserializeBinaryBody;
+//# sourceMappingURL=bodyDeserializer.cjs.map

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

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

package/.dist/cjs/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/cjs/src/binary/bodySerializer.cjs

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_binary_dataView = require("./dataView.cjs");
+const src_constants = require("../constants.cjs");
+const src_errors = require("../errors.cjs");
+function serializeBinaryBody(path, executionChain, body, isResponse, workflowRouteIds) {
+  try {
+    const serializer = src_binary_dataView.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 src_errors.RpcError) throw err;
+    throw new src_errors.RpcError({
+      statusCode: src_constants.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 src_errors.RpcError({
+      type: "missing-toBinary-jit-fn",
+      publicMessage: `Missing toBinary JIT function for method ${method.id}`
+    });
+  if (toBinary.isNoop) return false;
+  if (key === src_constants.MION_ROUTES.thrownErrors) return false;
+  if (isResponse && (!method.hasReturnData || typeof value === "undefined")) return false;
+  if (!isResponse && typeof value === "undefined") return false;
+  serializer.serString(key);
+  toBinary.fn(value, serializer);
+  return true;
+}
+exports.serializeBinaryBody = serializeBinaryBody;
+//# sourceMappingURL=bodySerializer.cjs.map

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

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

package/.dist/cjs/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/cjs/src/binary/dataView.cjs

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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]);
+  }
+}
+exports.createDataViewDeserializer = createDataViewDeserializer;
+exports.createDataViewSerializer = createDataViewSerializer;
+exports.setSerializationOptions = setSerializationOptions;
+//# sourceMappingURL=dataView.cjs.map