@mionjs/core 0.8.0-alpha.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"dataView.cjs","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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"}

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const DEFAULT_CORE_OPTIONS = {
+  /** automatically generate and uuid */
+  autoGenerateErrorId: false
+};
+const PATH_SEPARATOR = "/";
+const ROUTE_PATH_ROOT = PATH_SEPARATOR;
+const ROUTER_ITEM_SEPARATOR_CHAR = "/";
+const MAX_UNKNOWN_KEYS = 10;
+const MAX_STACK_DEPTH = 50;
+const MION_ROUTES = {
+  /** get remote methods metadata by method id */
+  methodsMetadataById: "mion@methodsMetadataById",
+  /** get remote methods metadata by route path, this include all middleFns in the ExecutionChain of the route. */
+  methodsMetadataByPath: "mion@methodsMetadataByPath",
+  /** Platform or adapters errors that occur before reaching the router or outside the router and are platform/adapter related */
+  platformError: "mion@platformError",
+  /** not-found route. This route is called when a requested route doesn't exist */
+  notFound: "mion@notFound",
+  /**
+   * !IMPORTANT!!
+   * This is technically not a route, but a special key used to store unexpected errors in the response body.
+   * is declared as a route to reuse existing router serialization/deserialization logic.
+   * Errors thrown by routes/middleFns, these are not strongly typed
+   * */
+  thrownErrors: "@thrownErrors"
+};
+const MIME_TYPES = {
+  json: "application/json",
+  octetStream: "application/octet-stream"
+};
+const StatusCodes = {
+  /** Any error in the server that is not related to the application, ie: server not ready, etc... */
+  SERVER_ERROR: 500,
+  /** Any expected and strongly typed error returned by a route/middleFn. ie: entity not found, etc. */
+  APPLICATION_ERROR: 400,
+  /**  Any thrown or unexpected error in the application, ie: validation error, not found, etc, database error, serialization error, etc...
+   * These are are typically irrecoverable and can be handled globally, ie redirect to login page if auth fails
+   */
+  UNEXPECTED_ERROR: 422,
+  /** Not found error */
+  NOT_FOUND: 404,
+  /** Standard success code */
+  OK: 200
+};
+const HandlerType = {
+  route: 1,
+  middleFn: 2,
+  headersMiddleFn: 3,
+  rawMiddleFn: 4
+};
+const JIT_FUNCTION_IDS = {
+  isType: "is",
+  typeErrors: "te",
+  prepareForJson: "tj",
+  restoreFromJson: "fj",
+  stringifyJson: "sj",
+  toJSCode: "tc",
+  toBinary: "tBi",
+  fromBinary: "fBi",
+  format: "fmt",
+  unknownKeyErrors: "uk",
+  hasUnknownKeys: "hk",
+  stripUnknownKeys: "sk",
+  unknownKeysToUndefined: "ku",
+  aux: "aux",
+  mock: "mock",
+  pureFunction: "pf"
+};
+const EMPTY_HASH = "";
+exports.DEFAULT_CORE_OPTIONS = DEFAULT_CORE_OPTIONS;
+exports.EMPTY_HASH = EMPTY_HASH;
+exports.HandlerType = HandlerType;
+exports.JIT_FUNCTION_IDS = JIT_FUNCTION_IDS;
+exports.MAX_STACK_DEPTH = MAX_STACK_DEPTH;
+exports.MAX_UNKNOWN_KEYS = MAX_UNKNOWN_KEYS;
+exports.MIME_TYPES = MIME_TYPES;
+exports.MION_ROUTES = MION_ROUTES;
+exports.PATH_SEPARATOR = PATH_SEPARATOR;
+exports.ROUTER_ITEM_SEPARATOR_CHAR = ROUTER_ITEM_SEPARATOR_CHAR;
+exports.ROUTE_PATH_ROOT = ROUTE_PATH_ROOT;
+exports.StatusCodes = StatusCodes;
+//# sourceMappingURL=constants.cjs.map

package/.dist/cjs/src/constants.cjs.map

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

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

@@ -0,0 +1,50 @@
+import { CoreRouterOptions } from './types/general.types.ts';
+export declare const DEFAULT_CORE_OPTIONS: CoreRouterOptions;
+export declare const PATH_SEPARATOR = "/";
+export declare const ROUTE_PATH_ROOT = "/";
+export declare const ROUTER_ITEM_SEPARATOR_CHAR = "/";
+export declare const MAX_UNKNOWN_KEYS = 10;
+export declare const MAX_STACK_DEPTH = 50;
+export declare const MION_ROUTES: {
+    readonly methodsMetadataById: "mion@methodsMetadataById";
+    readonly methodsMetadataByPath: "mion@methodsMetadataByPath";
+    readonly platformError: "mion@platformError";
+    readonly notFound: "mion@notFound";
+    readonly thrownErrors: "@thrownErrors";
+};
+export declare const MIME_TYPES: {
+    readonly json: "application/json";
+    readonly octetStream: "application/octet-stream";
+};
+export declare const StatusCodes: {
+    readonly SERVER_ERROR: 500;
+    readonly APPLICATION_ERROR: 400;
+    readonly UNEXPECTED_ERROR: 422;
+    readonly NOT_FOUND: 404;
+    readonly OK: 200;
+};
+export declare const HandlerType: {
+    readonly route: 1;
+    readonly middleFn: 2;
+    readonly headersMiddleFn: 3;
+    readonly rawMiddleFn: 4;
+};
+export declare const JIT_FUNCTION_IDS: {
+    readonly isType: "is";
+    readonly typeErrors: "te";
+    readonly prepareForJson: "tj";
+    readonly restoreFromJson: "fj";
+    readonly stringifyJson: "sj";
+    readonly toJSCode: "tc";
+    readonly toBinary: "tBi";
+    readonly fromBinary: "fBi";
+    readonly format: "fmt";
+    readonly unknownKeyErrors: "uk";
+    readonly hasUnknownKeys: "hk";
+    readonly stripUnknownKeys: "sk";
+    readonly unknownKeysToUndefined: "ku";
+    readonly aux: "aux";
+    readonly mock: "mock";
+    readonly pureFunction: "pf";
+};
+export declare const EMPTY_HASH = "";

package/.dist/cjs/src/errors.cjs

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_constants = require("./constants.cjs");
+const src_utils = require("./utils.cjs");
+const src_jit_jitUtils = require("./jit/jitUtils.cjs");
+const __ΩReadonly = ["T", "Readonly", 'l+e#!e"!fRb!Pde"!gN#%w"y'];
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+const __ΩValidationErrorData = ["RunTypeError", "typeErrors", "ValidationErrorData", 'P"w!F4"Mw#y'];
+const __ΩValidationError = ["validation-error", () => __ΩValidationErrorData, () => RpcError, "ValidationError", 'P.!n"7#w$y'];
+let options = { ...src_constants.DEFAULT_CORE_OPTIONS };
+function setErrorOptions(opts) {
+  options = opts;
+}
+setErrorOptions.__type = ["CoreRouterOptions", "opts", "setErrorOptions", 'P"w!2""/#'];
+class TypedError extends Error {
+  /**
+   * Unique error identifier,
+   * Ideally this should be a symbol but we need to be able to serialize it so a namespaced prop is used instead
+   */
+  // eslint-disable-next-line @typescript-eslint/prefer-as-const
+  "mion@isΣrrθr" = true;
+  /** Error type, can be used as discriminator in union types*/
+  type;
+  // Note: message and name are NOT declared as properties here
+  // They are inherited from Error class and assigned in constructor
+  // This prevents them from being included in type reflection for JIT validation
+  constructor({ message, originalError, type }) {
+    const errorMessage = message || originalError?.message || "";
+    super(errorMessage);
+    this.type = type;
+    Object.defineProperty(this, "message", {
+      value: errorMessage,
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(this, "name", {
+      value: "TypedError",
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+    if (originalError?.stack) {
+      try {
+        this.stack = originalError.stack;
+      } catch {
+        try {
+          Object.defineProperty(this, "stack", {
+            value: originalError.stack,
+            writable: true,
+            configurable: true
+          });
+        } catch {
+        }
+      }
+    }
+    Object.setPrototypeOf(this, TypedError.prototype);
+  }
+  static __type = ["ErrType", () => Error, true, "mion@isΣrrθr", function() {
+    return true;
+  }, "type", "TypedErrorParams", "param0", "constructor", "TypedError", `b!P7".#3$9>%e!!3&9P"w'2("0)5w*`];
+}
+class RpcError extends TypedError {
+  // Note: name is NOT declared as a property here
+  // It is inherited from Error class and assigned in constructor
+  // This prevents it from being included in type reflection for JIT validation
+  /**
+   * id of the error, ideally each error should unique identifiable
+   * * if RouterOptions.autoGenerateErrorId is set to true and id with timestamp+uuid will be generated
+   * */
+  id;
+  /** the message that will be returned in the response */
+  publicMessage;
+  /** options data related to the error, ie validation data, must be json serializable */
+  errorData;
+  /** optional http status code */
+  statusCode;
+  constructor({ message, publicMessage, originalError, errorData, type, id, statusCode }) {
+    const originalMessage = message || originalError?.message || publicMessage || "";
+    super({
+      message: originalMessage,
+      originalError,
+      type
+    });
+    const { autoGenerateErrorId } = options;
+    this.id = id ?? (autoGenerateErrorId ? src_utils.randomUUID_V7() : void 0);
+    this.publicMessage = publicMessage || "";
+    this.errorData = errorData;
+    this.statusCode = statusCode;
+    Object.defineProperty(this, "name", {
+      value: "RpcError",
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+    Object.setPrototypeOf(this, RpcError.prototype);
+  }
+  static __type = ["ErrType", "ErrData", () => TypedError, "id", "publicMessage", () => __ΩReadonly, "errorData", "statusCode", "AnyErrorParams", "param0", "constructor", "RpcErrorParams", "RpcError", `b!"c"Pe"!7#P'&J3$89&3%9e!"o&"3'89'3(8P"w)2*"0+5e!!6""w,x"w-`];
+}
+function hasUnknownKeys(obj, keys) {
+  for (const prop in obj) {
+    let found = false;
+    for (let j = 0; j < keys.length; j++) {
+      if (keys[j] === prop) {
+        found = true;
+        break;
+      }
+    }
+    if (!found)
+      return true;
+  }
+  return false;
+}
+hasUnknownKeys.__type = [() => __ΩRecord, "StrNumber", "obj", "keys", "hasUnknownKeys", 'P"w""o!#2#"w"F2$)/%'];
+function isTypedError(error) {
+  if (!error)
+    return false;
+  if (error instanceof TypedError)
+    return true;
+  return error && error["mion@isΣrrθr"] === true && (typeof error.type === "string" || typeof error.type === "number") && !hasUnknownKeys(error, ["mion@isΣrrθr", "type", "message"]);
+}
+isTypedError.__type = ["error", "isTypedError", 'P"2!!/"'];
+function isRpcError(error) {
+  if (!error)
+    return false;
+  if (error instanceof RpcError)
+    return true;
+  return error && error["mion@isΣrrθr"] === true && (typeof error.type === "string" || typeof error.type === "number") && (error.id === void 0 || typeof error.id === "string" || typeof error.id === "number") && !hasUnknownKeys(error, ["mion@isΣrrθr", "id", "message", "publicMessage", "errorData", "type", "statusCode"]);
+}
+isRpcError.__type = ["error", "isRpcError", 'P"2!!/"'];
+function isAnyError(error) {
+  if (!error)
+    return false;
+  const tErr = error;
+  if (tErr["mion@isΣrrθr"] === true)
+    return true;
+  if (typeof Error.isError === "function")
+    return Error.isError(error);
+  return error instanceof Error;
+}
+isAnyError.__type = ["error", "isAnyError", 'P"2!!/"'];
+let errorDeserializersRegistered = false;
+function registerErrorDeserializers() {
+  if (errorDeserializersRegistered)
+    return;
+  if (!TypedError || !RpcError)
+    return;
+  errorDeserializersRegistered = true;
+  src_jit_jitUtils.getJitUtils().setDeserializeFn(TypedError, __assignType((data) => {
+    return new TypedError(data);
+  }, ["DataOnly", "data", "", 'P"w!2""/#']));
+  src_jit_jitUtils.getJitUtils().setDeserializeFn(RpcError, __assignType((data) => {
+    return new RpcError(data);
+  }, ["DataOnly", "data", "", 'P"w!2""/#']));
+}
+registerErrorDeserializers.__type = ["registerErrorDeserializers", 'P"/!'];
+exports.RpcError = RpcError;
+exports.TypedError = TypedError;
+exports.__ΩValidationError = __ΩValidationError;
+exports.__ΩValidationErrorData = __ΩValidationErrorData;
+exports.isAnyError = isAnyError;
+exports.isRpcError = isRpcError;
+exports.isTypedError = isTypedError;
+exports.registerErrorDeserializers = registerErrorDeserializers;
+exports.setErrorOptions = setErrorOptions;
+//# sourceMappingURL=errors.cjs.map

package/.dist/cjs/src/errors.cjs.map

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

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

@@ -0,0 +1,24 @@
+import { CoreRouterOptions, AnyErrorParams, TypedErrorParams, RpcErrorParams, RunTypeError } from './types/general.types.ts';
+export interface ValidationErrorData {
+    typeErrors: RunTypeError[];
+}
+export type ValidationError = RpcError<'validation-error', ValidationErrorData>;
+export declare function setErrorOptions(opts: CoreRouterOptions): void;
+export declare class TypedError<ErrType extends string> extends Error {
+    readonly 'mion@isΣrrθr': true;
+    readonly type: ErrType;
+    constructor({ message, originalError, type }: TypedErrorParams<ErrType>);
+}
+export declare class RpcError<ErrType extends string, ErrData = any> extends TypedError<ErrType> implements RpcErrorParams<ErrType, ErrData> {
+    readonly id?: number | string;
+    readonly publicMessage: string;
+    readonly errorData?: Readonly<ErrData>;
+    statusCode?: number;
+    constructor({ message, publicMessage, originalError, errorData, type, id, statusCode }: AnyErrorParams<ErrType, ErrData>);
+}
+export declare function isTypedError(error: any): error is TypedError<any>;
+export declare function isRpcError(error: any): error is RpcError<string>;
+export declare function isAnyError(error: any): error is TypedError<any> | RpcError<string> | Error;
+export declare function registerErrorDeserializers(): void;
+export declare type __ΩValidationErrorData = any[];
+export declare type __ΩValidationError = any[];

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

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_utils = require("./utils.cjs");
+function isMapKeyPath(segment) {
+  return typeof segment === "object" && segment !== null && "failed" in segment && segment.failed === "mapKey";
+}
+function isMapValuePath(segment) {
+  return typeof segment === "object" && segment !== null && "failed" in segment && segment.failed === "mapVal";
+}
+function isSetItemPath(segment) {
+  return typeof segment === "object" && segment !== null && "key" in segment && "index" in segment && !("failed" in segment);
+}
+function defaultErrorPrinter(error) {
+  const lastSegment = error.path.length > 0 ? error.path[error.path.length - 1] : "value";
+  let prop;
+  if (isMapKeyPath(lastSegment)) {
+    prop = `mapKey[${lastSegment.index}]`;
+  } else if (isMapValuePath(lastSegment)) {
+    prop = `mapValue[${lastSegment.index}]`;
+  } else if (isSetItemPath(lastSegment)) {
+    prop = `setItem[${lastSegment.index}]`;
+  } else {
+    prop = lastSegment;
+  }
+  if (error.format) {
+    const param = error.format.formatPath[0];
+    return `${prop}: ${param} validation failed (expected ${error.format.val})`;
+  }
+  return `${prop}: expected ${error.expected}`;
+}
+function mergeErrorIntoParams(params, error) {
+  params.rtErrors.push(error);
+  params.rtError = error;
+  if (error.format) {
+    const paramKey = error.format.formatPath[0];
+    params[paramKey] = error.format;
+  }
+}
+function createAggregatedParams(error) {
+  const lastSegment = error.path[error.path.length - 1];
+  let propName;
+  let index;
+  let mapErrorType;
+  if (isMapKeyPath(lastSegment)) {
+    propName = lastSegment.index;
+    index = lastSegment.index;
+    mapErrorType = "key";
+  } else if (isMapValuePath(lastSegment)) {
+    propName = lastSegment.index;
+    index = lastSegment.index;
+    mapErrorType = "value";
+  } else if (isSetItemPath(lastSegment)) {
+    propName = lastSegment.index;
+    index = lastSegment.index;
+  } else {
+    propName = lastSegment;
+    index = typeof propName === "number" ? propName : void 0;
+  }
+  const params = {
+    rtError: error,
+    rtErrors: [error],
+    propName,
+    index,
+    mapErrorType
+  };
+  if (error.format) {
+    const paramKey = error.format.formatPath[0];
+    params[paramKey] = error.format;
+  }
+  return params;
+}
+function pathToKey(path) {
+  return path.map((segment) => {
+    if (isMapKeyPath(segment)) {
+      return `$mapKey[${segment.index}]`;
+    } else if (isMapValuePath(segment)) {
+      return `$mapVal[${segment.index}]`;
+    } else if (isSetItemPath(segment)) {
+      return `$setItem[${segment.index}]`;
+    }
+    return String(segment);
+  }).join(".");
+}
+function getOrCreatePath(obj, path) {
+  if (path.length === 0) return null;
+  let current = obj;
+  for (let i = 0; i < path.length - 1; i++) {
+    const segment = path[i];
+    let key;
+    if (isMapKeyPath(segment)) {
+      if (current["$keys"] === void 0) {
+        current["$keys"] = {};
+      }
+      current = current["$keys"];
+      key = segment.index;
+    } else if (isMapValuePath(segment)) {
+      if (current["$values"] === void 0) {
+        current["$values"] = {};
+      }
+      current = current["$values"];
+      key = segment.index;
+    } else if (isSetItemPath(segment)) {
+      key = segment.index;
+    } else {
+      key = segment;
+    }
+    if (current[key] === void 0) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const lastSegment = path[path.length - 1];
+  let finalKey;
+  if (isMapKeyPath(lastSegment)) {
+    if (current["$keys"] === void 0) {
+      current["$keys"] = {};
+    }
+    return { target: current["$keys"], key: lastSegment.index };
+  } else if (isMapValuePath(lastSegment)) {
+    if (current["$values"] === void 0) {
+      current["$values"] = {};
+    }
+    return { target: current["$values"], key: lastSegment.index };
+  } else if (isSetItemPath(lastSegment)) {
+    finalKey = lastSegment.index;
+  } else {
+    finalKey = lastSegment;
+  }
+  return { target: current, key: finalKey };
+}
+function getHandler(errorsMap, path) {
+  if (!errorsMap) return null;
+  if (typeof errorsMap === "function") {
+    return errorsMap;
+  }
+  let current = errorsMap;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    if (current === void 0 || current === null) return null;
+    if (isMapKeyPath(segment)) {
+      if (typeof current === "object" && current !== null && "$key" in current) {
+        const keyHandler = current["$key"];
+        if (typeof keyHandler === "function") {
+          return keyHandler;
+        }
+      }
+      if (typeof current === "function") {
+        return current;
+      }
+      return null;
+    }
+    if (isMapValuePath(segment)) {
+      if (typeof current === "object" && current !== null && "$value" in current) {
+        const valueHandler = current["$value"];
+        if (typeof valueHandler === "function") {
+          return valueHandler;
+        }
+        current = valueHandler;
+        continue;
+      }
+      if (typeof current === "function") {
+        return current;
+      }
+      return null;
+    }
+    if (isSetItemPath(segment)) {
+      if (typeof current === "object" && current !== null && "$item" in current) {
+        const itemHandler = current["$item"];
+        if (typeof itemHandler === "function") {
+          return itemHandler;
+        }
+        current = itemHandler;
+        continue;
+      }
+      if (typeof current === "function") {
+        return current;
+      }
+      return null;
+    }
+    if (typeof segment === "number") {
+      if (typeof current === "function") {
+        return current;
+      }
+      continue;
+    }
+    if (typeof current === "function") return null;
+    current = current[segment];
+  }
+  if (typeof current === "function") {
+    return current;
+  }
+  return null;
+}
+function getFriendlyErrors(errors, errorsMap) {
+  const result = {};
+  const aggregatedByPath = /* @__PURE__ */ new Map();
+  for (const error of errors) {
+    const pathKey = pathToKey(error.path);
+    const existing = aggregatedByPath.get(pathKey);
+    if (existing) {
+      mergeErrorIntoParams(existing, error);
+    } else {
+      aggregatedByPath.set(pathKey, createAggregatedParams(error));
+    }
+  }
+  for (const [pathKey, aggregatedParams] of aggregatedByPath) {
+    const path = aggregatedParams.rtErrors[0].path;
+    const handler = getHandler(errorsMap, path);
+    let message;
+    if (handler) {
+      message = handler(aggregatedParams);
+    } else {
+      if (!src_utils.isTestEnv()) {
+        console.warn(
+          `[mion] Using defaultErrorPrinter for "${pathKey || "$root"}". Consider providing a custom error handler for better user-facing messages.`
+        );
+      }
+      const messages = aggregatedParams.rtErrors.map((err) => defaultErrorPrinter(err));
+      message = [...new Set(messages)].join("; ");
+    }
+    if (path.length === 0) {
+      result["$root"] = message;
+    } else {
+      const pathInfo = getOrCreatePath(result, path);
+      if (pathInfo) {
+        const { target, key } = pathInfo;
+        target[key] = message;
+      }
+    }
+  }
+  return result;
+}
+exports.defaultErrorPrinter = defaultErrorPrinter;
+exports.getFriendlyErrors = getFriendlyErrors;
+//# sourceMappingURL=friendlyErrors.cjs.map