@mionjs/core 0.8.0-alpha.0

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

@@ -0,0 +1,246 @@
+import { MIME_TYPES } from '../constants.ts';
+import { TypeFormatError } from './formats/formats.types.ts';
+import { JITUtils } from '../jit/jitUtils.ts';
+import { CompiledPureFunction, PersistedPureFunction, PureFunctionData } from './pureFunctions.types.ts';
+export declare const SerializerModes: {
+    readonly json: 1;
+    readonly binary: 2;
+    readonly stringifyJson: 3;
+};
+export type SerializerMode = keyof typeof SerializerModes;
+export type SerializerCode = (typeof SerializerModes)[SerializerMode];
+export type CoreRouterOptions = {
+    autoGenerateErrorId: boolean;
+    basePath: string;
+    suffix: string;
+};
+export interface TypedErrorParams<ErrType extends StrNumber> {
+    type: ErrType;
+    message?: string;
+    originalError?: Error;
+}
+export interface RpcErrorParams<ErrType extends StrNumber, ErrData = any> {
+    type: ErrType;
+    id?: number | string;
+    publicMessage?: string;
+    message?: string;
+    errorData?: ErrData;
+    originalError?: Error;
+    statusCode?: number;
+}
+export interface RpcErrorWithPublic<ErrType extends StrNumber, ErrData = any> extends RpcErrorParams<ErrType, ErrData> {
+    publicMessage: string;
+}
+export interface RpcErrorWithPrivate<ErrType extends StrNumber, ErrData = any> extends RpcErrorParams<ErrType, ErrData> {
+    message: string;
+}
+export interface PublicRpcError<ErrType extends StrNumber, ErrData = any> extends Omit<RpcErrorParams<ErrType, ErrData>, 'message' | 'originalError'> {
+    readonly 'mion@isΣrrθr': true;
+    type: ErrType;
+    errorData?: ErrData;
+    publicMessage: string;
+}
+export type AnyErrorParams<ErrType extends StrNumber, ErrData = any> = RpcErrorWithPublic<ErrType, ErrData> | RpcErrorWithPrivate<ErrType, ErrData>;
+export type MapKeyPathSegment = {
+    key: unknown;
+    index: number;
+    failed: 'mapKey';
+};
+export type MapValuePathSegment = {
+    key: unknown;
+    index: number;
+    failed: 'mapVal';
+};
+export type SetItemPathSegment = {
+    key: unknown;
+    index: number;
+};
+export type PathSegment = StrNumber | MapKeyPathSegment | MapValuePathSegment | SetItemPathSegment;
+export interface RunTypeError {
+    path: PathSegment[];
+    expected: string;
+    format?: TypeFormatError;
+}
+export type JitFnArgs = {
+    vλl: string;
+    [key: string]: string;
+};
+export interface JitCompiledFnData {
+    readonly typeName: string;
+    readonly fnID: string;
+    readonly jitFnHash: string;
+    readonly args: JitFnArgs;
+    readonly defaultParamValues: JitFnArgs;
+    readonly isNoop?: boolean;
+    readonly code: string;
+    readonly jitDependencies: Array<string>;
+    readonly pureFnDependencies: Array<string>;
+    paramNames?: string[];
+}
+export interface JitCompiledFn<Fn extends AnyFn = AnyFn> extends JitCompiledFnData {
+    readonly createJitFn: (utl: JITUtils) => Fn;
+    readonly fn: Fn;
+}
+export interface PersistedJitFn extends Omit<JitCompiledFn, 'fn'> {
+    readonly fn: undefined;
+}
+export interface JitCompiledFunctions {
+    isType: JitCompiledFn<IsTypeFn>;
+    typeErrors: JitCompiledFn<TypeErrorsFn>;
+    prepareForJson: JitCompiledFn<PrepareForJsonFn>;
+    restoreFromJson: JitCompiledFn<RestoreFromJsonFn>;
+    stringifyJson: JitCompiledFn<JsonStringifyFn>;
+    toBinary: JitCompiledFn<ToBinaryFn>;
+    fromBinary: JitCompiledFn<FromBinaryFn>;
+}
+export interface SerializableJITFunctions {
+    isType: JitCompiledFnData;
+    typeErrors: JitCompiledFnData;
+    prepareForJson: JitCompiledFnData;
+    restoreFromJson: JitCompiledFnData;
+    stringifyJson: JitCompiledFnData;
+    toBinary: JitCompiledFnData;
+    fromBinary: JitCompiledFnData;
+}
+export interface JitFunctionsHashes {
+    isType: string;
+    typeErrors: string;
+    prepareForJson: string;
+    restoreFromJson: string;
+    stringifyJson: string;
+    toBinary: string;
+    fromBinary: string;
+}
+export type JsonStringifyFn = (value: any) => JSONString;
+export type RestoreFromJsonFn = (value: JSONValue) => any;
+export type PrepareForJsonFn = (value: any) => JSONValue;
+export type TypeErrorsFn = (value: any) => RunTypeError[];
+export type IsTypeFn = (value: any) => boolean;
+export type ToCodeFn = (value: any) => string;
+export type ToBinaryFn = (value: any, serializer: DataViewSerializer) => void;
+export type FromBinaryFn = (value: undefined, deserializer: DataViewDeserializer) => any;
+export type JitFunctionsCache = Record<string, JitCompiledFn>;
+export type PureFunctionsCache = Record<string, Record<string, CompiledPureFunction>>;
+export type PersistedJitFunctionsCache = Record<string, PersistedJitFn>;
+export type PersistedPureFunctionsCache = Record<string, Record<string, PersistedPureFunction>>;
+export type FnsDataCache = Record<string, JitCompiledFnData>;
+export type PureFnsDataCache = Record<string, Record<string, PureFunctionData>>;
+export interface SrcCodeJitCompiledFn extends JitCompiledFnData {
+    readonly createJitFn: (utl: JITUtils) => AnyFn;
+    readonly fn: undefined;
+}
+export interface SrcCodeCompiledPureFunction extends PureFunctionData {
+    readonly createPureFn: (utl: JITUtils) => AnyFn;
+    readonly fn: undefined;
+}
+export type SrcCodeJITCompiledFnsCache = Record<string, SrcCodeJitCompiledFn>;
+export type SrcCodePureFunctionsCache = Record<string, Record<string, SrcCodeCompiledPureFunction>>;
+export type StrNumber = string | number;
+export type AnyFn = (...args: any[]) => any;
+export type AnyObject = Record<string, unknown>;
+export interface AnyClass<T = any> {
+    new (...args: any[]): T;
+}
+export interface SerializableClass<T = any> {
+    new (): T;
+}
+export type DeserializeClassFn<C extends InstanceType<AnyClass>> = (deserialized: DataOnly<C>) => C;
+export type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export type Prettify<T> = {
+    [P in keyof T]: T[P];
+} & {};
+export type JSONValue = StrNumber | boolean | null | {
+    [key: string]: JSONValue;
+} | Array<JSONValue>;
+export type JSONString = string;
+type Native = Date | RegExp | URL | URLSearchParams | Blob | File | FileList | FormData | ArrayBuffer | SharedArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+export type DataOnly<T> = T extends object ? T extends Native ? T : T extends Function ? never : T extends new (...args: any[]) => any ? never : T extends Array<infer U> ? Array<DataOnly<U>> : T extends Map<infer K, infer V> ? Map<DataOnly<K>, DataOnly<V>> : T extends Set<infer U> ? Set<DataOnly<U>> : {
+    [K in keyof T as T[K] extends Function ? never : K]: DataOnly<T[K]>;
+} : T;
+export type StrictArrayBuffer = ArrayBuffer & {
+    buffer?: undefined;
+};
+export type BinaryInput = ArrayBuffer | ArrayBufferView;
+export interface DataViewSerializer {
+    index: number;
+    view: DataView;
+    reset: () => void;
+    getBuffer: () => StrictArrayBuffer;
+    getBufferView: () => Uint8Array;
+    markAsEnded: () => void;
+    getLength(): number;
+    serString(str: string): void;
+    serFloat64(n: number): void;
+    serEnum(n: number | string): void;
+    setBitMask(bitMaskIndex: number, bitIndex: number): void;
+}
+export interface DataViewDeserializer {
+    index: number;
+    view: DataView;
+    reset: () => void;
+    setBuffer: (buffer: StrictArrayBuffer, byteOffset?: number, byteLength?: number) => void;
+    markAsEnded: () => void;
+    getLength(): number;
+    desString(): string;
+    desFloat64(): number;
+    desEnum(): number | string;
+}
+export type MimeTypes = (typeof MIME_TYPES)[keyof typeof MIME_TYPES];
+export {};
+export declare type __ΩSerializerMode = any[];
+export declare type __ΩSerializerCode = any[];
+export declare type __ΩCoreRouterOptions = any[];
+export declare type __ΩTypedErrorParams = any[];
+export declare type __ΩRpcErrorParams = any[];
+export declare type __ΩRpcErrorWithPublic = any[];
+export declare type __ΩRpcErrorWithPrivate = any[];
+export declare type __ΩPublicRpcError = any[];
+export declare type __ΩAnyErrorParams = any[];
+export declare type __ΩMapKeyPathSegment = any[];
+export declare type __ΩMapValuePathSegment = any[];
+export declare type __ΩSetItemPathSegment = any[];
+export declare type __ΩPathSegment = any[];
+export declare type __ΩRunTypeError = any[];
+export declare type __ΩJitFnArgs = any[];
+export declare type __ΩJitCompiledFnData = any[];
+export declare type __ΩJitCompiledFn = any[];
+export declare type __ΩPersistedJitFn = any[];
+export declare type __ΩJitCompiledFunctions = any[];
+export declare type __ΩSerializableJITFunctions = any[];
+export declare type __ΩJitFunctionsHashes = any[];
+export declare type __ΩJsonStringifyFn = any[];
+export declare type __ΩRestoreFromJsonFn = any[];
+export declare type __ΩPrepareForJsonFn = any[];
+export declare type __ΩTypeErrorsFn = any[];
+export declare type __ΩIsTypeFn = any[];
+export declare type __ΩToCodeFn = any[];
+export declare type __ΩToBinaryFn = any[];
+export declare type __ΩFromBinaryFn = any[];
+export declare type __ΩJitFunctionsCache = any[];
+export declare type __ΩPureFunctionsCache = any[];
+export declare type __ΩPersistedJitFunctionsCache = any[];
+export declare type __ΩPersistedPureFunctionsCache = any[];
+export declare type __ΩFnsDataCache = any[];
+export declare type __ΩPureFnsDataCache = any[];
+export declare type __ΩSrcCodeJitCompiledFn = any[];
+export declare type __ΩSrcCodeCompiledPureFunction = any[];
+export declare type __ΩSrcCodeJITCompiledFnsCache = any[];
+export declare type __ΩSrcCodePureFunctionsCache = any[];
+export declare type __ΩStrNumber = any[];
+export declare type __ΩAnyFn = any[];
+export declare type __ΩAnyObject = any[];
+export declare type __ΩAnyClass = any[];
+export declare type __ΩSerializableClass = any[];
+export declare type __ΩDeserializeClassFn = any[];
+export declare type __ΩMutable = any[];
+export declare type __ΩPrettify = any[];
+export declare type __ΩJSONValue = any[];
+export declare type __ΩJSONString = any[];
+export declare type __ΩDataOnly = any[];
+export declare type __ΩStrictArrayBuffer = any[];
+export declare type __ΩBinaryInput = any[];
+export declare type __ΩDataViewSerializer = any[];
+export declare type __ΩDataViewDeserializer = any[];
+export declare type __ΩMimeTypes = any[];

package/.dist/cjs/src/types/method.types.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_types_general_types = require("./general.types.cjs");
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+const __ΩPick = ["T", "K", "Pick", 'l+e#!e"!fRb!b"Pde""N#!w#y'];
+const __ΩMethodMetadata = ["type", "id", "isAsync", "hasReturnData", "paramNames", "paramsJitHash", "returnJitHash", () => __ΩHeadersMetaData, "headersParam", () => __ΩHeadersMetaData, "headersReturn", "middleFnIds", "pointer", "nestLevel", "MethodMetadata", `P'4!&4")4#)4$&F4%8&4&&4'n(4)8n*4+8&F4,8&F4-'4.Mw/y`];
+const __ΩRemoteMethodOpts = ["runOnError", "validateParams", "validateReturn", "description", () => src_types_general_types.__ΩSerializerMode, "serializer", "isMutation", "RemoteMethodOpts", `P)4!8)4"8)4#8&4$8n%4&8P)-J4'8Mw(y`];
+const __ΩRouteOnlyOptions = [() => __ΩRemoteMethodOpts, false, "runOnError", () => src_types_general_types.__ΩSerializerMode, "serializer", "RouteOnlyOptions", 'Pn!."4#n$4%Mw&y'];
+const __ΩMethodWithOptions = [() => __ΩMethodMetadata, () => __ΩRemoteMethodOpts, "options", "MethodWithOptions", 'Pn!n"4#Mw$y'];
+const __ΩMethodsCache = [() => __ΩRecord, () => __ΩMethodWithOptions, "MethodsCache", '&n"o!#w#y'];
+const __ΩHeadersMetaData = ["headerNames", "jitHash", "HeadersMetaData", 'P&F4!&4"Mw#y'];
+const __ΩSerializableMethodsData = [() => __ΩMethodsCache, "methods", () => src_types_general_types.__ΩFnsDataCache, "deps", () => src_types_general_types.__ΩPureFnsDataCache, "purFnDeps", "SerializableMethodsData", `Pn!4"n#4$n%4&Mw'y`];
+const __ΩHeadersMethodWithJitFns = [() => __ΩHeadersMetaData, () => __ΩPick, () => src_types_general_types.__ΩJitCompiledFunctions, "isType", "typeErrors", "jitFns", "HeadersMethodWithJitFns", `Pn!n#P.$.%Jo"#4&Mw'y`];
+const __ΩMethodWithJitFns = [() => __ΩMethodMetadata, () => src_types_general_types.__ΩJitCompiledFunctions, "paramsJitFns", () => src_types_general_types.__ΩJitCompiledFunctions, "returnJitFns", () => __ΩHeadersMethodWithJitFns, "headersParam", () => __ΩHeadersMethodWithJitFns, "headersReturn", "MethodWithJitFns", `Pn!n"4#n$4%n&4'8n(4)8Mw*y`];
+const __ΩMethodWithOptsAndJitFns = [() => __ΩMethodWithOptions, () => __ΩMethodWithJitFns, "MethodWithOptsAndJitFns", 'Pn!n"Kw#y'];
+exports.__ΩHeadersMetaData = __ΩHeadersMetaData;
+exports.__ΩHeadersMethodWithJitFns = __ΩHeadersMethodWithJitFns;
+exports.__ΩMethodMetadata = __ΩMethodMetadata;
+exports.__ΩMethodWithJitFns = __ΩMethodWithJitFns;
+exports.__ΩMethodWithOptions = __ΩMethodWithOptions;
+exports.__ΩMethodWithOptsAndJitFns = __ΩMethodWithOptsAndJitFns;
+exports.__ΩMethodsCache = __ΩMethodsCache;
+exports.__ΩRemoteMethodOpts = __ΩRemoteMethodOpts;
+exports.__ΩRouteOnlyOptions = __ΩRouteOnlyOptions;
+exports.__ΩSerializableMethodsData = __ΩSerializableMethodsData;
+//# sourceMappingURL=method.types.cjs.map

package/.dist/cjs/src/types/method.types.cjs.map

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

package/.dist/cjs/src/types/method.types.d.ts

@@ -0,0 +1,60 @@
+import { FnsDataCache, PureFnsDataCache, JitCompiledFunctions, SerializerMode } from './general.types.ts';
+export interface MethodMetadata {
+    type: number;
+    id: string;
+    isAsync: boolean;
+    hasReturnData: boolean;
+    paramNames?: string[];
+    paramsJitHash: string;
+    returnJitHash: string;
+    headersParam?: HeadersMetaData;
+    headersReturn?: HeadersMetaData;
+    middleFnIds?: string[];
+    pointer: string[];
+    nestLevel: number;
+}
+export interface RemoteMethodOpts {
+    runOnError?: boolean;
+    validateParams?: boolean;
+    validateReturn?: boolean;
+    description?: string;
+    serializer?: SerializerMode;
+    isMutation?: boolean | undefined;
+}
+export interface RouteOnlyOptions extends RemoteMethodOpts {
+    runOnError: false;
+    serializer: SerializerMode;
+}
+export interface MethodWithOptions extends MethodMetadata {
+    options: RemoteMethodOpts;
+}
+export type MethodsCache = Record<string, MethodWithOptions>;
+export interface HeadersMetaData {
+    headerNames: string[];
+    jitHash: string;
+}
+export interface SerializableMethodsData {
+    methods: MethodsCache;
+    deps: FnsDataCache;
+    purFnDeps: PureFnsDataCache;
+}
+export interface HeadersMethodWithJitFns extends HeadersMetaData {
+    jitFns: Pick<JitCompiledFunctions, 'isType' | 'typeErrors'>;
+}
+export interface MethodWithJitFns extends MethodMetadata {
+    paramsJitFns: JitCompiledFunctions;
+    returnJitFns: JitCompiledFunctions;
+    headersParam?: HeadersMethodWithJitFns;
+    headersReturn?: HeadersMethodWithJitFns;
+}
+export type MethodWithOptsAndJitFns = MethodWithOptions & MethodWithJitFns;
+export declare type __ΩMethodMetadata = any[];
+export declare type __ΩRemoteMethodOpts = any[];
+export declare type __ΩRouteOnlyOptions = any[];
+export declare type __ΩMethodWithOptions = any[];
+export declare type __ΩMethodsCache = any[];
+export declare type __ΩHeadersMetaData = any[];
+export declare type __ΩSerializableMethodsData = any[];
+export declare type __ΩHeadersMethodWithJitFns = any[];
+export declare type __ΩMethodWithJitFns = any[];
+export declare type __ΩMethodWithOptsAndJitFns = any[];

package/.dist/cjs/src/types/pureFunctions.types.cjs

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_types_general_types = require("./general.types.cjs");
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+const __ΩRequired = ["T", "Required", 'l+e#!e"!fRb!Pde"!gN##w"y'];
+const __ΩReturnType = ["T", "args", "", "ReturnType", `l>e"!R"RPde#!P"@2"h"!/#qk#'QRb!Pde"!p)w$y`];
+const __ΩPick = ["T", "K", "Pick", 'l+e#!e"!fRb!b"Pde""N#!w#y'];
+const __ΩStrNumber = ["StrNumber", "P&'Jw!y"];
+const __ΩPureFunctionDeps = [() => __ΩRecord, () => __ΩPureFunction, "PureFunctionDeps", '&n"o!#w#y'];
+const __ΩGenericPureFunction = ["P", "val", "formatParams", () => __ΩPureFunctionDeps, "deps", "", "GenericPureFunction", `b!P"2"e"!2#n$2%"/&w'y`];
+const __ΩErrorsPureFunction = ["P", "val", () => __ΩStrNumber, "pλth", () => src_types_general_types.__ΩRunTypeError, "εrr", "expected", "formatName", "formatParams", () => __ΩStrNumber, "formatPath", () => __ΩPureFunctionDeps, "deps", () => __ΩStrNumber, "accessPath", () => __ΩStrNumber, "fmtAccessPath", () => src_types_general_types.__ΩRunTypeError, "", "ErrorsPureFunction", `b!P"2"n#F2$n%F2&&2'&2(e"!2)n*F2+n,2-n.F2/8n0F218n2F/3w4y`];
+const __ΩPureFunction = ["args", "", "PureFunction", 'P"@2!"/"w#y'];
+const __ΩPureFunctionFactory = ["JITUtils", "jitUtils", () => __ΩPureFunction, "", "PureFunctionFactory", 'P"w!2"n#/$w%y'];
+const __ΩPureFunctionData = ["namespace", "paramNames", "code", "fnName", "bodyHash", "pureFnDependencies", "PureFunctionData", `P&4!9&F4"9&4#9&4$9&4%9&F4&9Mw'y`];
+const __ΩCompiledPureFunction = [() => __ΩPureFunctionData, () => __ΩPureFunctionFactory, "createPureFn", () => __ΩPureFunction, "fn", "CompiledPureFunction", 'Pn!n"4#n$4%8Mw&y'];
+const __ΩPersistedPureFunction = [() => __ΩCompiledPureFunction, "fn", "PersistedPureFunction", 'Pn!-4"Mw#y'];
+const __ΩPureFnDef = ["args", "", "F", "namespace", "fnName", "isFactory", "pureFn", "PureFnDef", `P"@2!"/"c#P&4$89&4%89)4&8e"!4'9Mw(y`];
+const __ΩParsedFactoryFn = ["bodyHash", "paramNames", "code", "ParsedFactoryFn", 'P&4!9&F4"9&4#9Mw$y'];
+const __ΩPureServerFnRef = ["args", "", "F", () => __ΩRequired, () => __ΩPureFnDef, "namespace", "fnName", "bodyHash", "pureFnDependencies", "PureServerFnRef", `P"@2!"/"c#Pe"!o%"o$"&4&9&4'9&4(9&F4)8Mw*y`];
+const __ΩMapFromServerFnRef = ["args", "", "F", () => __ΩPureServerFnRef, "fromRequestId", "toRequestId", "paramIndex", "mapFromSymbol", () => __ΩReturnType, "type", "MapFromServerFnRef", `P"@2!"/"c#Pe"!o$"&4%&4&'4'+4(Pe#!o)"1*Mw+y`];
+const __ΩMapFromRef = [() => __ΩPick, () => __ΩMapFromServerFnRef, "fromRequestId", "toRequestId", "fnName", "namespace", "paramIndex", "MapFromRef", `"o""P.#.$.%.&.'Jo!#w(y`];
+const __ΩRoutesFlowQuery = ["routes", () => __ΩRoutesFlowMapping, "mappings", "RoutesFlowQuery", 'P&F4!n"F4#8Mw$y'];
+const __ΩRoutesFlowMapping = ["fromId", "toId", "bodyHash", "paramIndex", "RoutesFlowMapping", `P&4!&4"&4#'4$Mw%y`];
+exports.__ΩCompiledPureFunction = __ΩCompiledPureFunction;
+exports.__ΩErrorsPureFunction = __ΩErrorsPureFunction;
+exports.__ΩGenericPureFunction = __ΩGenericPureFunction;
+exports.__ΩMapFromRef = __ΩMapFromRef;
+exports.__ΩMapFromServerFnRef = __ΩMapFromServerFnRef;
+exports.__ΩParsedFactoryFn = __ΩParsedFactoryFn;
+exports.__ΩPersistedPureFunction = __ΩPersistedPureFunction;
+exports.__ΩPureFnDef = __ΩPureFnDef;
+exports.__ΩPureFunction = __ΩPureFunction;
+exports.__ΩPureFunctionData = __ΩPureFunctionData;
+exports.__ΩPureFunctionDeps = __ΩPureFunctionDeps;
+exports.__ΩPureFunctionFactory = __ΩPureFunctionFactory;
+exports.__ΩPureServerFnRef = __ΩPureServerFnRef;
+exports.__ΩRoutesFlowMapping = __ΩRoutesFlowMapping;
+exports.__ΩRoutesFlowQuery = __ΩRoutesFlowQuery;
+//# sourceMappingURL=pureFunctions.types.cjs.map

package/.dist/cjs/src/types/pureFunctions.types.cjs.map

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

package/.dist/cjs/src/types/pureFunctions.types.d.ts

@@ -0,0 +1,75 @@
+import { TypeFormatValue } from './formats/formats.types.ts';
+import { RunTypeError } from './general.types.ts';
+import { JITUtils } from '../jit/jitUtils.ts';
+type StrNumber = string | number;
+export type PureFunctionDeps = Record<string, PureFunction>;
+export type GenericPureFunction<P extends TypeFormatValue> = (val: any, formatParams: P, deps: PureFunctionDeps) => any;
+export type ErrorsPureFunction<P extends TypeFormatValue> = (val: any, pλth: StrNumber[], εrr: RunTypeError[], expected: string, formatName: string, formatParams: P, formatPath: StrNumber[], deps: PureFunctionDeps, accessPath?: StrNumber[], fmtAccessPath?: StrNumber[]) => RunTypeError[];
+export type PureFunction = (...args: any[]) => any;
+export type PureFunctionFactory = (jitUtils: JITUtils) => PureFunction;
+export interface PureFunctionData {
+    readonly namespace: string;
+    readonly paramNames: string[];
+    readonly code: string;
+    readonly fnName: string;
+    readonly bodyHash: string;
+    readonly pureFnDependencies: Array<string>;
+}
+export interface CompiledPureFunction extends PureFunctionData {
+    createPureFn: PureFunctionFactory;
+    fn?: PureFunction;
+}
+export interface PersistedPureFunction extends CompiledPureFunction {
+    fn: undefined;
+}
+export interface PureFnDef<F extends (...args: any[]) => any = (...args: any[]) => any> {
+    readonly namespace?: string;
+    readonly fnName?: string;
+    isFactory?: boolean;
+    readonly pureFn: F;
+}
+export interface ParsedFactoryFn {
+    readonly bodyHash: string;
+    readonly paramNames: string[];
+    readonly code: string;
+}
+export interface PureServerFnRef<F extends (...args: any[]) => any = (...args: any[]) => any> extends Required<PureFnDef<F>> {
+    readonly namespace: string;
+    readonly fnName: string;
+    readonly bodyHash: string;
+    pureFnDependencies?: Array<string>;
+}
+export interface MapFromServerFnRef<F extends (...args: any[]) => any = (...args: any[]) => any> extends PureServerFnRef<F> {
+    fromRequestId: string;
+    toRequestId: string;
+    paramIndex: number;
+    mapFromSymbol: symbol;
+    type(): ReturnType<F>;
+}
+export type MapFromRef = Pick<MapFromServerFnRef<any>, 'fromRequestId' | 'toRequestId' | 'fnName' | 'namespace' | 'paramIndex'>;
+export interface RoutesFlowQuery {
+    routes: string[];
+    mappings?: RoutesFlowMapping[];
+}
+export interface RoutesFlowMapping {
+    fromId: string;
+    toId: string;
+    bodyHash: string;
+    paramIndex: number;
+}
+export {};
+export declare type __ΩPureFunctionDeps = any[];
+export declare type __ΩGenericPureFunction = any[];
+export declare type __ΩErrorsPureFunction = any[];
+export declare type __ΩPureFunction = any[];
+export declare type __ΩPureFunctionFactory = any[];
+export declare type __ΩPureFunctionData = any[];
+export declare type __ΩCompiledPureFunction = any[];
+export declare type __ΩPersistedPureFunction = any[];
+export declare type __ΩPureFnDef = any[];
+export declare type __ΩParsedFactoryFn = any[];
+export declare type __ΩPureServerFnRef = any[];
+export declare type __ΩMapFromServerFnRef = any[];
+export declare type __ΩMapFromRef = any[];
+export declare type __ΩRoutesFlowQuery = any[];
+export declare type __ΩRoutesFlowMapping = any[];

package/.dist/cjs/src/utils.cjs

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_jit_jitUtils = require("./jit/jitUtils.cjs");
+function randomUUID_V7() {
+  const uuid = crypto.randomUUID();
+  const tHex = Date.now().toString(16).padStart(12, "0");
+  return `${tHex.substring(0, 8)}-${tHex.substring(8)}-7${uuid.substring(15)}`;
+}
+function getENV(key) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[key];
+  }
+  return void 0;
+}
+function toBase64Url(str) {
+  return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromBase64Url(encoded) {
+  return atob(encoded.replace(/-/g, "+").replace(/_/g, "/"));
+}
+let isTest = void 0;
+function isMionCompileMode() {
+  const val = getENV("MION_COMPILE");
+  return val === "onlyAOT" || val === "viteSSR";
+}
+function isMionAOTEmitMode() {
+  const val = getENV("MION_COMPILE");
+  return val === "onlyAOT" || val === "viteSSR" || val === "serve";
+}
+function isTestEnv() {
+  if (isTest !== void 0) return isTest;
+  isTest = getENV("VITEST") !== void 0 || getENV("NODE_ENV") === "test";
+  return isTest;
+}
+function initPureFunction(compiled) {
+  if (compiled.fn) return;
+  compiled.fn = compiled.createPureFn(src_jit_jitUtils.getJitUtils());
+}
+exports.fromBase64Url = fromBase64Url;
+exports.getENV = getENV;
+exports.initPureFunction = initPureFunction;
+exports.isMionAOTEmitMode = isMionAOTEmitMode;
+exports.isMionCompileMode = isMionCompileMode;
+exports.isTestEnv = isTestEnv;
+exports.randomUUID_V7 = randomUUID_V7;
+exports.toBase64Url = toBase64Url;
+//# sourceMappingURL=utils.cjs.map

package/.dist/cjs/src/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","sources":["../../../src/utils.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 {getJitUtils} from './jit/jitUtils.ts';\nimport type {CompiledPureFunction} from './types/pureFunctions.types.ts';\n\n/** Generates a random UUID V7 (RFC 9562),\n * uses crypto.randomUUID() (v4) as random source as it's a native C++ binding that batches entropy,\n * might be faster than allocating typed arrays via crypto.getRandomValues */\nexport function randomUUID_V7(): string {\n    const uuid = crypto.randomUUID();\n    const tHex = Date.now().toString(16).padStart(12, '0');\n    return `${tHex.substring(0, 8)}-${tHex.substring(8)}-7${uuid.substring(15)}`;\n}\n\n/**\n * Browser-safe function to access environment variables.\n * Returns undefined when running in browser environments where process is not available.\n * @param key - The environment variable key to retrieve\n * @returns The environment variable value or undefined if not available/in browser\n */\nexport function getENV(key: string): string | undefined {\n    if (typeof process !== 'undefined' && process.env) {\n        return process.env[key];\n    }\n    return undefined;\n}\n\n// ############# Base64 URL #############\n\n/** Encodes a string to URL-safe base64 (RFC 4648 §5) without padding */\nexport function toBase64Url(str: string): string {\n    return btoa(str).replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');\n}\n\n/** Decodes a URL-safe base64 string (RFC 4648 §5) back to a string */\nexport function fromBase64Url(encoded: string): string {\n    return atob(encoded.replace(/-/g, '+').replace(/_/g, '/'));\n}\n\nlet isTest: boolean | undefined = undefined;\n/** Whether the process is in mion compile mode (onlyAOT or viteSSR).\n * In these modes platform adapters skip server.listen() — the server does NOT start. */\nexport function isMionCompileMode(): boolean {\n    const val = getENV('MION_COMPILE');\n    return val === 'onlyAOT' || val === 'viteSSR';\n}\n\n/** Whether AOT caches should be generated and emitted (onlyAOT, viteSSR, or serve).\n * Unlike isMionCompileMode(), this also includes 'serve' mode where the server DOES start\n * and keeps running after emitting AOT caches via IPC. */\nexport function isMionAOTEmitMode(): boolean {\n    const val = getENV('MION_COMPILE');\n    return val === 'onlyAOT' || val === 'viteSSR' || val === 'serve';\n}\n\nexport function isTestEnv() {\n    if (isTest !== undefined) return isTest;\n    isTest = getENV('VITEST') !== undefined || getENV('NODE_ENV') === 'test';\n    return isTest;\n}\n\n/**\n * Restores the full state of a compiled pure function,\n * The pure function itself can't be compiled to code as it contains references to context code and jitUtils.\n * So we need to restore it manually by invoking the closure function.\n * */\nexport function initPureFunction(compiled: CompiledPureFunction): asserts compiled is Required<CompiledPureFunction> {\n    if (compiled.fn) return;\n    compiled.fn = compiled.createPureFn(getJitUtils());\n}\n"],"names":["getJitUtils"],"mappings":";;;AAaO,SAAS,gBAAwB;AACpC,QAAM,OAAO,OAAO,WAAA;AACpB,QAAM,OAAO,KAAK,MAAM,SAAS,EAAE,EAAE,SAAS,IAAI,GAAG;AACrD,SAAO,GAAG,KAAK,UAAU,GAAG,CAAC,CAAC,IAAI,KAAK,UAAU,CAAC,CAAC,KAAK,KAAK,UAAU,EAAE,CAAC;AAC9E;AAQO,SAAS,OAAO,KAAiC;AACpD,MAAI,OAAO,YAAY,eAAe,QAAQ,KAAK;AAC/C,WAAO,QAAQ,IAAI,GAAG;AAAA,EAC1B;AACA,SAAO;AACX;AAKO,SAAS,YAAY,KAAqB;AAC7C,SAAO,KAAK,GAAG,EAAE,QAAQ,OAAO,GAAG,EAAE,QAAQ,OAAO,GAAG,EAAE,QAAQ,OAAO,EAAE;AAC9E;AAGO,SAAS,cAAc,SAAyB;AACnD,SAAO,KAAK,QAAQ,QAAQ,MAAM,GAAG,EAAE,QAAQ,MAAM,GAAG,CAAC;AAC7D;AAEA,IAAI,SAA8B;AAG3B,SAAS,oBAA6B;AACzC,QAAM,MAAM,OAAO,cAAc;AACjC,SAAO,QAAQ,aAAa,QAAQ;AACxC;AAKO,SAAS,oBAA6B;AACzC,QAAM,MAAM,OAAO,cAAc;AACjC,SAAO,QAAQ,aAAa,QAAQ,aAAa,QAAQ;AAC7D;AAEO,SAAS,YAAY;AACxB,MAAI,WAAW,OAAW,QAAO;AACjC,WAAS,OAAO,QAAQ,MAAM,UAAa,OAAO,UAAU,MAAM;AAClE,SAAO;AACX;AAOO,SAAS,iBAAiB,UAAoF;AACjH,MAAI,SAAS,GAAI;AACjB,WAAS,KAAK,SAAS,aAAaA,iBAAAA,YAAA,CAAa;AACrD;;;;;;;;;"}

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

@@ -0,0 +1,9 @@
+import { CompiledPureFunction } from './types/pureFunctions.types.ts';
+export declare function randomUUID_V7(): string;
+export declare function getENV(key: string): string | undefined;
+export declare function toBase64Url(str: string): string;
+export declare function fromBase64Url(encoded: string): string;
+export declare function isMionCompileMode(): boolean;
+export declare function isMionAOTEmitMode(): boolean;
+export declare function isTestEnv(): boolean;
+export declare function initPureFunction(compiled: CompiledPureFunction): asserts compiled is Required<CompiledPureFunction>;

package/.dist/esm/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';