@mionjs/core 0.8.0-alpha.0

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

@@ -0,0 +1,84 @@
+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 = "";
+export {
+  DEFAULT_CORE_OPTIONS,
+  EMPTY_HASH,
+  HandlerType,
+  JIT_FUNCTION_IDS,
+  MAX_STACK_DEPTH,
+  MAX_UNKNOWN_KEYS,
+  MIME_TYPES,
+  MION_ROUTES,
+  PATH_SEPARATOR,
+  ROUTER_ITEM_SEPARATOR_CHAR,
+  ROUTE_PATH_ROOT,
+  StatusCodes
+};
+//# sourceMappingURL=constants.js.map

package/.dist/esm/src/constants.js.map

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

package/.dist/esm/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/esm/src/errors.js

@@ -0,0 +1,170 @@
+import { DEFAULT_CORE_OPTIONS } from "./constants.js";
+import { randomUUID_V7 } from "./utils.js";
+import { getJitUtils } from "./jit/jitUtils.js";
+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 = { ...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 ? 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;
+  getJitUtils().setDeserializeFn(TypedError, __assignType((data) => {
+    return new TypedError(data);
+  }, ["DataOnly", "data", "", 'P"w!2""/#']));
+  getJitUtils().setDeserializeFn(RpcError, __assignType((data) => {
+    return new RpcError(data);
+  }, ["DataOnly", "data", "", 'P"w!2""/#']));
+}
+registerErrorDeserializers.__type = ["registerErrorDeserializers", 'P"/!'];
+export {
+  RpcError,
+  TypedError,
+  __ΩValidationError,
+  __ΩValidationErrorData,
+  isAnyError,
+  isRpcError,
+  isTypedError,
+  registerErrorDeserializers,
+  setErrorOptions
+};
+//# sourceMappingURL=errors.js.map

package/.dist/esm/src/errors.js.map

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

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

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

package/.dist/esm/src/friendlyErrors.js

@@ -0,0 +1,235 @@
+import { isTestEnv } from "./utils.js";
+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 (!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;
+}
+export {
+  defaultErrorPrinter,
+  getFriendlyErrors
+};
+//# sourceMappingURL=friendlyErrors.js.map

package/.dist/esm/src/friendlyErrors.js.map

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

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

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

package/.dist/esm/src/headers.js

@@ -0,0 +1,11 @@
+class HeadersSubset {
+  headers;
+  constructor(headers) {
+    this.headers = headers;
+  }
+  static __type = ["Required", "Optional", "headers", "constructor", "HeadersSubset", `l+&R&R&R&Rb!!c"PPde#!N#!Pde#"N%"K3#9PPPde$!N'!Pde$"N)"K2#"0$5w%`];
+}
+export {
+  HeadersSubset
+};
+//# sourceMappingURL=headers.js.map

package/.dist/esm/src/headers.js.map

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