@mionjs/core 0.8.0-alpha.0

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

@@ -0,0 +1,26 @@
+import { __ΩJitCompiledFunctions as ___JitCompiledFunctions, __ΩSerializerMode as ___SerializerMode, __ΩFnsDataCache as ___FnsDataCache, __ΩPureFnsDataCache as ___PureFnsDataCache } from "./general.types.js";
+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", () => ___SerializerMode, "serializer", "isMutation", "RemoteMethodOpts", `P)4!8)4"8)4#8&4$8n%4&8P)-J4'8Mw(y`];
+const __ΩRouteOnlyOptions = [() => __ΩRemoteMethodOpts, false, "runOnError", () => ___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", () => ___FnsDataCache, "deps", () => ___PureFnsDataCache, "purFnDeps", "SerializableMethodsData", `Pn!4"n#4$n%4&Mw'y`];
+const __ΩHeadersMethodWithJitFns = [() => __ΩHeadersMetaData, () => __ΩPick, () => ___JitCompiledFunctions, "isType", "typeErrors", "jitFns", "HeadersMethodWithJitFns", `Pn!n#P.$.%Jo"#4&Mw'y`];
+const __ΩMethodWithJitFns = [() => __ΩMethodMetadata, () => ___JitCompiledFunctions, "paramsJitFns", () => ___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'];
+export {
+  __ΩHeadersMetaData,
+  __ΩHeadersMethodWithJitFns,
+  __ΩMethodMetadata,
+  __ΩMethodWithJitFns,
+  __ΩMethodWithOptions,
+  __ΩMethodWithOptsAndJitFns,
+  __ΩMethodsCache,
+  __ΩRemoteMethodOpts,
+  __ΩRouteOnlyOptions,
+  __ΩSerializableMethodsData
+};
+//# sourceMappingURL=method.types.js.map

package/.dist/esm/src/types/method.types.js.map

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

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

@@ -0,0 +1,39 @@
+import { __ΩRunTypeError as ___RunTypeError } from "./general.types.js";
+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", () => ___RunTypeError, "εrr", "expected", "formatName", "formatParams", () => __ΩStrNumber, "formatPath", () => __ΩPureFunctionDeps, "deps", () => __ΩStrNumber, "accessPath", () => __ΩStrNumber, "fmtAccessPath", () => ___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`];
+export {
+  __ΩCompiledPureFunction,
+  __ΩErrorsPureFunction,
+  __ΩGenericPureFunction,
+  __ΩMapFromRef,
+  __ΩMapFromServerFnRef,
+  __ΩParsedFactoryFn,
+  __ΩPersistedPureFunction,
+  __ΩPureFnDef,
+  __ΩPureFunction,
+  __ΩPureFunctionData,
+  __ΩPureFunctionDeps,
+  __ΩPureFunctionFactory,
+  __ΩPureServerFnRef,
+  __ΩRoutesFlowMapping,
+  __ΩRoutesFlowQuery
+};
+//# sourceMappingURL=pureFunctions.types.js.map

package/.dist/esm/src/types/pureFunctions.types.js.map

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

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

@@ -0,0 +1,47 @@
+import { getJitUtils } from "./jit/jitUtils.js";
+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(getJitUtils());
+}
+export {
+  fromBase64Url,
+  getENV,
+  initPureFunction,
+  isMionAOTEmitMode,
+  isMionCompileMode,
+  isTestEnv,
+  randomUUID_V7,
+  toBase64Url
+};
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","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":[],"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,aAAa,YAAA,CAAa;AACrD;"}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mion
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90-dark.png">
+    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90.png">
+    <img alt='mion, a mikro kit for Typescript Serverless APIs' src='https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90.png'>
+  </picture>
+</p>
+<p align="center">
+  <strong>mion core functionality.
+  </strong>
+</p>
+<p align=center>
+  <img src="https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square&maxAge=99999999" alt="npm"  style="max-width:100%;">
+  <img src="https://img.shields.io/badge/license-MIT-97ca00.svg?style=flat-square&maxAge=99999999" alt="npm"  style="max-width:100%;">
+</p>
+
+# `@mionjs/core`
+
+This library contains core functionality shared between other mion packages.
+
+- errors
+- configuration
+
+All items in this library should be isomorphic, this mean should used both in the browser or node server.
+
+## Check Out The [Website And Documentation](http://mion.io) 📚
+
+[![mion-website-banner](https://raw.githubusercontent.com/MionKit/mion/master/assets/public/mion-website-banner.png)](http://mion.io)
+
+---
+
+[MIT LICENSE](../../LICENSE)

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@mionjs/core",
+  "version": "0.8.0-alpha.0",
+  "type": "module",
+  "description": "Core functionality required across multiple mion packages",
+  "keywords": [
+    "typescript",
+    "API",
+    "RPC",
+    "json",
+    "schema",
+    "generate",
+    "server",
+    "serverless",
+    "framework",
+    "node",
+    "runtime types"
+  ],
+  "author": "ma jerez",
+  "homepage": "https://mion.io/",
+  "license": "MIT",
+  "browser": {},
+  "exports": {
+    ".": {
+      "source": "./index.ts",
+      "types": "./.dist/esm/index.d.ts",
+      "require": "./.dist/cjs/index.cjs",
+      "default": "./.dist/esm/index.js"
+    }
+  },
+  "directories": {
+    "lib": ".dist"
+  },
+  "files": [
+    ".dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MionKit/mion.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "dev": "vite build --watch",
+    "dev:test": "vitest watch",
+    "lint": "npx eslint src",
+    "format": "prettier --write src/**/*.ts",
+    "build": "vite build",
+    "clean": "rimraf .dist & rimraf .coverage",
+    "fresh-start": "npm run clean && rimraf node_modules"
+  },
+  "bugs": {
+    "url": "https://github.com/MionKit/mion/issues"
+  },
+  "gitHead": "5d2ec524ba39d040338ce8946d8edf78aa7291a3"
+}